Updating go depencancies. Switching to go1.6 vendoring (#2949)

3 files changed, 0 insertions, 177 deletions

diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/doc.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/doc.go
deleted file mode 100644
index adb4618d3..000000000
--- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package store offers a memory-based and a Redis-based throttled.Store implementation.
-package store
diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem.go
deleted file mode 100644
index 22d200e8d..000000000
--- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/mem.go
+++ /dev/null
@@ -1,90 +0,0 @@
-package store
-
-import (
-	"sync"
-	"time"
-
-	"github.com/golang/groupcache/lru"
-	"gopkg.in/throttled/throttled.v1"
-)
-
-// memStore implements an in-memory Store.
-type memStore struct {
-	sync.Mutex
-	keys *lru.Cache
-	m    map[string]*counter
-}
-
-// NewMemStore creates a new MemStore. If maxKeys > 0, the number of different keys
-// is restricted to the specified amount. In this case, it uses an LRU algorithm to
-// evict older keys to make room for newer ones. If a request is made for a key that
-// has been evicted, it will be processed as if its count was 0, possibly allowing requests
-// that should be denied.
-//
-// If maxKeys <= 0, there is no limit on the number of keys, which may use an unbounded amount of
-// memory depending on the server's load.
-//
-// The MemStore is only for single-process rate-limiting. To share the rate limit state
-// among multiple instances of the web server, use a database- or key-value-based
-// store.
-//
-func NewMemStore(maxKeys int) throttled.Store {
-	var m *memStore
-	if maxKeys > 0 {
-		m = &memStore{
-			keys: lru.New(maxKeys),
-		}
-	} else {
-		m = &memStore{
-			m: make(map[string]*counter),
-		}
-	}
-	return m
-}
-
-// A counter represents a single entry in the MemStore.
-type counter struct {
-	n  int
-	ts time.Time
-}
-
-// Incr increments the counter for the specified key. It returns the new
-// count value and the remaining number of seconds, or an error.
-func (ms *memStore) Incr(key string, window time.Duration) (int, int, error) {
-	ms.Lock()
-	defer ms.Unlock()
-	var c *counter
-	if ms.keys != nil {
-		v, _ := ms.keys.Get(key)
-		if v != nil {
-			c = v.(*counter)
-		}
-	} else {
-		c = ms.m[key]
-	}
-	if c == nil {
-		c = &counter{0, time.Now().UTC()}
-	}
-	c.n++
-	if ms.keys != nil {
-		ms.keys.Add(key, c)
-	} else {
-		ms.m[key] = c
-	}
-	return c.n, throttled.RemainingSeconds(c.ts, window), nil
-}
-
-// Reset resets the counter for the specified key. It sets the count
-// to 1 and initializes the timestamp with the current time, in UTC.
-// It returns an error if the operation fails.
-func (ms *memStore) Reset(key string, win time.Duration) error {
-	ms.Lock()
-	defer ms.Unlock()
-	c := &counter{1, time.Now().UTC()}
-	if ms.keys != nil {
-		ms.keys.Add(key, c)
-	} else {
-		ms.m[key] = c
-	}
-	return nil
-}
diff --git a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis.go b/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis.go
deleted file mode 100644
index b089f9f4e..000000000
--- a/Godeps/_workspace/src/gopkg.in/throttled/throttled.v1/store/redis.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package store
-
-import (
-	"time"
-
-	"github.com/garyburd/redigo/redis"
-	"gopkg.in/throttled/throttled.v1"
-)
-
-// redisStore implements a Redis-based store.
-type redisStore struct {
-	pool   *redis.Pool
-	prefix string
-	db     int
-}
-
-// NewRedisStore creates a new Redis-based store, using the provided pool to get its
-// connections. The keys will have the specified keyPrefix, which may be an empty string,
-// and the database index specified by db will be selected to store the keys.
-//
-func NewRedisStore(pool *redis.Pool, keyPrefix string, db int) throttled.Store {
-	return &redisStore{
-		pool:   pool,
-		prefix: keyPrefix,
-		db:     db,
-	}
-}
-
-// Incr increments the specified key. If the key did not exist, it sets it to 1
-// and sets it to expire after the number of seconds specified by window.
-//
-// It returns the new count value and the number of remaining seconds, or an error
-// if the operation fails.
-func (r *redisStore) Incr(key string, window time.Duration) (int, int, error) {
-	conn := r.pool.Get()
-	defer conn.Close()
-	if err := selectDB(r.db, conn); err != nil {
-		return 0, 0, err
-	}
-	// Atomically increment and read the TTL.
-	conn.Send("MULTI")
-	conn.Send("INCR", r.prefix+key)
-	conn.Send("TTL", r.prefix+key)
-	vals, err := redis.Values(conn.Do("EXEC"))
-	if err != nil {
-		conn.Do("DISCARD")
-		return 0, 0, err
-	}
-	var cnt, ttl int
-	if _, err = redis.Scan(vals, &cnt, &ttl); err != nil {
-		return 0, 0, err
-	}
-	// If there was no TTL set, then this is a newly created key (INCR creates the key
-	// if it didn't exist), so set it to expire.
-	if ttl == -1 {
-		ttl = int(window.Seconds())
-		_, err = conn.Do("EXPIRE", r.prefix+key, ttl)
-		if err != nil {
-			return 0, 0, err
-		}
-	}
-	return cnt, ttl, nil
-}
-
-// Reset sets the value of the key to 1, and resets its time window.
-func (r *redisStore) Reset(key string, window time.Duration) error {
-	conn := r.pool.Get()
-	defer conn.Close()
-	if err := selectDB(r.db, conn); err != nil {
-		return err
-	}
-	_, err := redis.String(conn.Do("SET", r.prefix+key, "1", "EX", int(window.Seconds()), "NX"))
-	return err
-}
-
-// Select the specified database index.
-func selectDB(db int, conn redis.Conn) error {
-	// Select the specified database
-	if db > 0 {
-		if _, err := redis.String(conn.Do("SELECT", db)); err != nil {
-			return err
-		}
-	}
-	return nil
-}