add vendor

vendor/github.com/jtolds/gls/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2013, Space Monkey, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/jtolds/gls/README.md

@@ -0,0 +1,89 @@
+gls
+===
+
+Goroutine local storage
+
+### IMPORTANT NOTE ###
+
+It is my duty to point you to https://blog.golang.org/context, which is how 
+Google solves all of the problems you'd perhaps consider using this package
+for at scale. 
+
+One downside to Google's approach is that *all* of your functions must have
+a new first argument, but after clearing that hurdle everything else is much
+better.
+
+If you aren't interested in this warning, read on.
+
+### Huhwaht? Why? ###
+
+Every so often, a thread shows up on the
+[golang-nuts](https://groups.google.com/d/forum/golang-nuts) asking for some
+form of goroutine-local-storage, or some kind of goroutine id, or some kind of
+context. There are a few valid use cases for goroutine-local-storage, one of
+the most prominent being log line context. One poster was interested in being
+able to log an HTTP request context id in every log line in the same goroutine
+as the incoming HTTP request, without having to change every library and
+function call he was interested in logging.
+
+This would be pretty useful. Provided that you could get some kind of
+goroutine-local-storage, you could call
+[log.SetOutput](http://golang.org/pkg/log/#SetOutput) with your own logging
+writer that checks goroutine-local-storage for some context information and
+adds that context to your log lines.
+
+But alas, Andrew Gerrand's typically diplomatic answer to the question of
+goroutine-local variables was:
+
+> We wouldn't even be having this discussion if thread local storage wasn't
+> useful. But every feature comes at a cost, and in my opinion the cost of
+> threadlocals far outweighs their benefits. They're just not a good fit for
+> Go.
+
+So, yeah, that makes sense. That's a pretty good reason for why the language
+won't support a specific and (relatively) unuseful feature that requires some
+runtime changes, just for the sake of a little bit of log improvement.
+
+But does Go require runtime changes?
+
+### How it works ###
+
+Go has pretty fantastic introspective and reflective features, but one thing Go
+doesn't give you is any kind of access to the stack pointer, or frame pointer,
+or goroutine id, or anything contextual about your current stack. It gives you
+access to your list of callers, but only along with program counters, which are
+fixed at compile time.
+
+But it does give you the stack.
+
+So, we define 16 special functions and embed base-16 tags into the stack using
+the call order of those 16 functions. Then, we can read our tags back out of
+the stack looking at the callers list.
+
+We then use these tags as an index into a traditional map for implementing
+this library.
+
+### What are people saying? ###
+
+"Wow, that's horrifying."
+
+"This is the most terrible thing I have seen in a very long time."
+
+"Where is it getting a context from? Is this serializing all the requests? 
+What the heck is the client being bound to? What are these tags? Why does he 
+need callers? Oh god no. No no no."
+
+### Docs ###
+
+Please see the docs at http://godoc.org/github.com/jtolds/gls
+
+### Related ###
+
+If you're okay relying on the string format of the current runtime stacktrace 
+including a unique goroutine id (not guaranteed by the spec or anything, but 
+very unlikely to change within a Go release), you might be able to squeeze 
+out a bit more performance by using this similar library, inspired by some 
+code Brad Fitzpatrick wrote for debugging his HTTP/2 library: 
+https://github.com/tylerb/gls (in contrast, jtolds/gls doesn't require 
+any knowledge of the string format of the runtime stacktrace, which 
+probably adds unnecessary overhead).

vendor/github.com/jtolds/gls/context.go

@@ -0,0 +1,144 @@
+// Package gls implements goroutine-local storage.
+package gls
+
+import (
+	"sync"
+)
+
+const (
+	maxCallers = 64
+)
+
+var (
+	stackTagPool   = &idPool{}
+	mgrRegistry    = make(map[*ContextManager]bool)
+	mgrRegistryMtx sync.RWMutex
+)
+
+// Values is simply a map of key types to value types. Used by SetValues to
+// set multiple values at once.
+type Values map[interface{}]interface{}
+
+// ContextManager is the main entrypoint for interacting with
+// Goroutine-local-storage. You can have multiple independent ContextManagers
+// at any given time. ContextManagers are usually declared globally for a given
+// class of context variables. You should use NewContextManager for
+// construction.
+type ContextManager struct {
+	mtx    sync.RWMutex
+	values map[uint]Values
+}
+
+// NewContextManager returns a brand new ContextManager. It also registers the
+// new ContextManager in the ContextManager registry which is used by the Go
+// method. ContextManagers are typically defined globally at package scope.
+func NewContextManager() *ContextManager {
+	mgr := &ContextManager{values: make(map[uint]Values)}
+	mgrRegistryMtx.Lock()
+	defer mgrRegistryMtx.Unlock()
+	mgrRegistry[mgr] = true
+	return mgr
+}
+
+// Unregister removes a ContextManager from the global registry, used by the
+// Go method. Only intended for use when you're completely done with a
+// ContextManager. Use of Unregister at all is rare.
+func (m *ContextManager) Unregister() {
+	mgrRegistryMtx.Lock()
+	defer mgrRegistryMtx.Unlock()
+	delete(mgrRegistry, m)
+}
+
+// SetValues takes a collection of values and a function to call for those
+// values to be set in. Anything further down the stack will have the set
+// values available through GetValue. SetValues will add new values or replace
+// existing values of the same key and will not mutate or change values for
+// previous stack frames.
+// SetValues is slow (makes a copy of all current and new values for the new
+// gls-context) in order to reduce the amount of lookups GetValue requires.
+func (m *ContextManager) SetValues(new_values Values, context_call func()) {
+	if len(new_values) == 0 {
+		context_call()
+		return
+	}
+
+	tags := readStackTags(1)
+
+	m.mtx.Lock()
+	values := new_values
+	for _, tag := range tags {
+		if existing_values, ok := m.values[tag]; ok {
+			// oh, we found existing values, let's make a copy
+			values = make(Values, len(existing_values)+len(new_values))
+			for key, val := range existing_values {
+				values[key] = val
+			}
+			for key, val := range new_values {
+				values[key] = val
+			}
+			break
+		}
+	}
+	new_tag := stackTagPool.Acquire()
+	m.values[new_tag] = values
+	m.mtx.Unlock()
+	defer func() {
+		m.mtx.Lock()
+		delete(m.values, new_tag)
+		m.mtx.Unlock()
+		stackTagPool.Release(new_tag)
+	}()
+
+	addStackTag(new_tag, context_call)
+}
+
+// GetValue will return a previously set value, provided that the value was set
+// by SetValues somewhere higher up the stack. If the value is not found, ok
+// will be false.
+func (m *ContextManager) GetValue(key interface{}) (value interface{}, ok bool) {
+
+	tags := readStackTags(1)
+	m.mtx.RLock()
+	defer m.mtx.RUnlock()
+	for _, tag := range tags {
+		if values, ok := m.values[tag]; ok {
+			value, ok := values[key]
+			return value, ok
+		}
+	}
+	return "", false
+}
+
+func (m *ContextManager) getValues() Values {
+	tags := readStackTags(2)
+	m.mtx.RLock()
+	defer m.mtx.RUnlock()
+	for _, tag := range tags {
+		if values, ok := m.values[tag]; ok {
+			return values
+		}
+	}
+	return nil
+}
+
+// Go preserves ContextManager values and Goroutine-local-storage across new
+// goroutine invocations. The Go method makes a copy of all existing values on
+// all registered context managers and makes sure they are still set after
+// kicking off the provided function in a new goroutine. If you don't use this
+// Go method instead of the standard 'go' keyword, you will lose values in
+// ContextManagers, as goroutines have brand new stacks.
+func Go(cb func()) {
+	mgrRegistryMtx.RLock()
+	defer mgrRegistryMtx.RUnlock()
+
+	for mgr, _ := range mgrRegistry {
+		values := mgr.getValues()
+		if len(values) > 0 {
+			mgr_copy := mgr
+			cb_copy := cb
+			cb = func() { mgr_copy.SetValues(values, cb_copy) }
+		}
+	}
+
+	go cb()
+}

vendor/github.com/jtolds/gls/gen_sym.go

@@ -0,0 +1,13 @@
+package gls
+
+var (
+	symPool = &idPool{}
+)
+
+// ContextKey is a throwaway value you can use as a key to a ContextManager
+type ContextKey struct{ id uint }
+
+// GenSym will return a brand new, never-before-used ContextKey
+func GenSym() ContextKey {
+	return ContextKey{id: symPool.Acquire()}
+}

vendor/github.com/jtolds/gls/id_pool.go

@@ -0,0 +1,34 @@
+package gls
+
+// though this could probably be better at keeping ids smaller, the goal of
+// this class is to keep a registry of the smallest unique integer ids
+// per-process possible
+
+import (
+	"sync"
+)
+
+type idPool struct {
+	mtx      sync.Mutex
+	released []uint
+	max_id   uint
+}
+
+func (p *idPool) Acquire() (id uint) {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	if len(p.released) > 0 {
+		id = p.released[len(p.released)-1]
+		p.released = p.released[:len(p.released)-1]
+		return id
+	}
+	id = p.max_id
+	p.max_id++
+	return id
+}
+
+func (p *idPool) Release(id uint) {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	p.released = append(p.released, id)
+}

vendor/github.com/jtolds/gls/stack_tags.go

@@ -0,0 +1,43 @@
+package gls
+
+// so, basically, we're going to encode integer tags in base-16 on the stack
+
+const (
+	bitWidth = 4
+)
+
+func addStackTag(tag uint, context_call func()) {
+	if context_call == nil {
+		return
+	}
+	markS(tag, context_call)
+}
+
+func markS(tag uint, cb func()) { _m(tag, cb) }
+func mark0(tag uint, cb func()) { _m(tag, cb) }
+func mark1(tag uint, cb func()) { _m(tag, cb) }
+func mark2(tag uint, cb func()) { _m(tag, cb) }
+func mark3(tag uint, cb func()) { _m(tag, cb) }
+func mark4(tag uint, cb func()) { _m(tag, cb) }
+func mark5(tag uint, cb func()) { _m(tag, cb) }
+func mark6(tag uint, cb func()) { _m(tag, cb) }
+func mark7(tag uint, cb func()) { _m(tag, cb) }
+func mark8(tag uint, cb func()) { _m(tag, cb) }
+func mark9(tag uint, cb func()) { _m(tag, cb) }
+func markA(tag uint, cb func()) { _m(tag, cb) }
+func markB(tag uint, cb func()) { _m(tag, cb) }
+func markC(tag uint, cb func()) { _m(tag, cb) }
+func markD(tag uint, cb func()) { _m(tag, cb) }
+func markE(tag uint, cb func()) { _m(tag, cb) }
+func markF(tag uint, cb func()) { _m(tag, cb) }
+
+var pc_lookup = make(map[uintptr]int8, 17)
+var mark_lookup [16]func(uint, func())
+
+func _m(tag_remainder uint, cb func()) {
+	if tag_remainder == 0 {
+		cb()
+	} else {
+		mark_lookup[tag_remainder&0xf](tag_remainder>>bitWidth, cb)
+	}
+}

vendor/github.com/jtolds/gls/stack_tags_js.go

@@ -0,0 +1,101 @@
+// +build js
+
+package gls
+
+// This file is used for GopherJS builds, which don't have normal runtime support
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/gopherjs/gopherjs/js"
+)
+
+var stackRE = regexp.MustCompile("\\s+at (\\S*) \\([^:]+:(\\d+):(\\d+)")
+
+func findPtr() uintptr {
+	jsStack := js.Global.Get("Error").New().Get("stack").Call("split", "\n")
+	for i := 1; i < jsStack.Get("length").Int(); i++ {
+		item := jsStack.Index(i).String()
+		matches := stackRE.FindAllStringSubmatch(item, -1)
+		if matches == nil {
+			return 0
+		}
+		pkgPath := matches[0][1]
+		if strings.HasPrefix(pkgPath, "$packages.github.com/jtolds/gls.mark") {
+			line, _ := strconv.Atoi(matches[0][2])
+			char, _ := strconv.Atoi(matches[0][3])
+			x := (uintptr(line) << 16) | uintptr(char)
+			return x
+		}
+	}
+
+	return 0
+}
+
+func init() {
+	setEntries := func(f func(uint, func()), v int8) {
+		var ptr uintptr
+		f(0, func() {
+			ptr = findPtr()
+		})
+		pc_lookup[ptr] = v
+		if v >= 0 {
+			mark_lookup[v] = f
+		}
+	}
+	setEntries(markS, -0x1)
+	setEntries(mark0, 0x0)
+	setEntries(mark1, 0x1)
+	setEntries(mark2, 0x2)
+	setEntries(mark3, 0x3)
+	setEntries(mark4, 0x4)
+	setEntries(mark5, 0x5)
+	setEntries(mark6, 0x6)
+	setEntries(mark7, 0x7)
+	setEntries(mark8, 0x8)
+	setEntries(mark9, 0x9)
+	setEntries(markA, 0xa)
+	setEntries(markB, 0xb)
+	setEntries(markC, 0xc)
+	setEntries(markD, 0xd)
+	setEntries(markE, 0xe)
+	setEntries(markF, 0xf)
+}
+
+func currentStack(skip int) (stack []uintptr) {
+	jsStack := js.Global.Get("Error").New().Get("stack").Call("split", "\n")
+	for i := skip + 2; i < jsStack.Get("length").Int(); i++ {
+		item := jsStack.Index(i).String()
+		matches := stackRE.FindAllStringSubmatch(item, -1)
+		if matches == nil {
+			return stack
+		}
+		line, _ := strconv.Atoi(matches[0][2])
+		char, _ := strconv.Atoi(matches[0][3])
+		x := (uintptr(line) << 16) | uintptr(char)&0xffff
+		stack = append(stack, x)
+	}
+
+	return stack
+}
+
+func readStackTags(skip int) (tags []uint) {
+	stack := currentStack(skip)
+	var current_tag uint
+	for _, pc := range stack {
+		val, ok := pc_lookup[pc]
+		if !ok {
+			continue
+		}
+		if val < 0 {
+			tags = append(tags, current_tag)
+			current_tag = 0
+			continue
+		}
+		current_tag <<= bitWidth
+		current_tag += uint(val)
+	}
+	return
+}

vendor/github.com/jtolds/gls/stack_tags_main.go

@@ -0,0 +1,61 @@
+// +build !js
+
+package gls
+
+// This file is used for standard Go builds, which have the expected runtime support
+
+import (
+	"reflect"
+	"runtime"
+)
+
+func init() {
+	setEntries := func(f func(uint, func()), v int8) {
+		pc_lookup[reflect.ValueOf(f).Pointer()] = v
+		if v >= 0 {
+			mark_lookup[v] = f
+		}
+	}
+	setEntries(markS, -0x1)
+	setEntries(mark0, 0x0)
+	setEntries(mark1, 0x1)
+	setEntries(mark2, 0x2)
+	setEntries(mark3, 0x3)
+	setEntries(mark4, 0x4)
+	setEntries(mark5, 0x5)
+	setEntries(mark6, 0x6)
+	setEntries(mark7, 0x7)
+	setEntries(mark8, 0x8)
+	setEntries(mark9, 0x9)
+	setEntries(markA, 0xa)
+	setEntries(markB, 0xb)
+	setEntries(markC, 0xc)
+	setEntries(markD, 0xd)
+	setEntries(markE, 0xe)
+	setEntries(markF, 0xf)
+}
+
+func currentStack(skip int) []uintptr {
+	stack := make([]uintptr, maxCallers)
+	return stack[:runtime.Callers(3+skip, stack)]
+}
+
+func readStackTags(skip int) (tags []uint) {
+	stack := currentStack(skip)
+	var current_tag uint
+	for _, pc := range stack {
+		pc = runtime.FuncForPC(pc).Entry()
+		val, ok := pc_lookup[pc]
+		if !ok {
+			continue
+		}
+		if val < 0 {
+			tags = append(tags, current_tag)
+			current_tag = 0
+			continue
+		}
+		current_tag <<= bitWidth
+		current_tag += uint(val)
+	}
+	return
+}