build: removes unused vendored files

go.mod

@@ -48,7 +48,7 @@ require (
 	github.com/onsi/gomega v1.5.0 // indirect
 	github.com/opentracing/opentracing-go v1.1.0
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pkg/errors v0.8.1 // indirect
+	github.com/pkg/errors v0.8.1
 	github.com/prometheus/client_golang v0.9.2
 	github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90
 	github.com/prometheus/common v0.2.0

vendor/github.com/go-macaron/session/memcache/memcache.go

@@ -1,204 +0,0 @@
-// Copyright 2013 Beego Authors
-// Copyright 2014 The Macaron Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package session
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/bradfitz/gomemcache/memcache"
-
-	"github.com/go-macaron/session"
-)
-
-// MemcacheStore represents a memcache session store implementation.
-type MemcacheStore struct {
-	c      *memcache.Client
-	sid    string
-	expire int32
-	lock   sync.RWMutex
-	data   map[interface{}]interface{}
-}
-
-// NewMemcacheStore creates and returns a memcache session store.
-func NewMemcacheStore(c *memcache.Client, sid string, expire int32, kv map[interface{}]interface{}) *MemcacheStore {
-	return &MemcacheStore{
-		c:      c,
-		sid:    sid,
-		expire: expire,
-		data:   kv,
-	}
-}
-
-func NewItem(sid string, data []byte, expire int32) *memcache.Item {
-	return &memcache.Item{
-		Key:        sid,
-		Value:      data,
-		Expiration: expire,
-	}
-}
-
-// Set sets value to given key in session.
-func (s *MemcacheStore) Set(key, val interface{}) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data[key] = val
-	return nil
-}
-
-// Get gets value by given key in session.
-func (s *MemcacheStore) Get(key interface{}) interface{} {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	return s.data[key]
-}
-
-// Delete delete a key from session.
-func (s *MemcacheStore) Delete(key interface{}) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	delete(s.data, key)
-	return nil
-}
-
-// ID returns current session ID.
-func (s *MemcacheStore) ID() string {
-	return s.sid
-}
-
-// Release releases resource and save data to provider.
-func (s *MemcacheStore) Release() error {
-	// Skip encoding if the data is empty
-	if len(s.data) == 0 {
-		return nil
-	}
-
-	data, err := session.EncodeGob(s.data)
-	if err != nil {
-		return err
-	}
-
-	return s.c.Set(NewItem(s.sid, data, s.expire))
-}
-
-// Flush deletes all session data.
-func (s *MemcacheStore) Flush() error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data = make(map[interface{}]interface{})
-	return nil
-}
-
-// MemcacheProvider represents a memcache session provider implementation.
-type MemcacheProvider struct {
-	c      *memcache.Client
-	expire int32
-}
-
-// Init initializes memcache session provider.
-// connStrs: 127.0.0.1:9090;127.0.0.1:9091
-func (p *MemcacheProvider) Init(expire int64, connStrs string) error {
-	p.expire = int32(expire)
-	p.c = memcache.New(strings.Split(connStrs, ";")...)
-	return nil
-}
-
-// Read returns raw session store by session ID.
-func (p *MemcacheProvider) Read(sid string) (session.RawStore, error) {
-	if !p.Exist(sid) {
-		if err := p.c.Set(NewItem(sid, []byte(""), p.expire)); err != nil {
-			return nil, err
-		}
-	}
-
-	var kv map[interface{}]interface{}
-	item, err := p.c.Get(sid)
-	if err != nil {
-		return nil, err
-	}
-	if len(item.Value) == 0 {
-		kv = make(map[interface{}]interface{})
-	} else {
-		kv, err = session.DecodeGob(item.Value)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return NewMemcacheStore(p.c, sid, p.expire, kv), nil
-}
-
-// Exist returns true if session with given ID exists.
-func (p *MemcacheProvider) Exist(sid string) bool {
-	_, err := p.c.Get(sid)
-	return err == nil
-}
-
-// Destory deletes a session by session ID.
-func (p *MemcacheProvider) Destory(sid string) error {
-	return p.c.Delete(sid)
-}
-
-// Regenerate regenerates a session store from old session ID to new one.
-func (p *MemcacheProvider) Regenerate(oldsid, sid string) (_ session.RawStore, err error) {
-	if p.Exist(sid) {
-		return nil, fmt.Errorf("new sid '%s' already exists", sid)
-	}
-
-	item := NewItem(sid, []byte(""), p.expire)
-	if p.Exist(oldsid) {
-		item, err = p.c.Get(oldsid)
-		if err != nil {
-			return nil, err
-		} else if err = p.c.Delete(oldsid); err != nil {
-			return nil, err
-		}
-		item.Key = sid
-	}
-	if err = p.c.Set(item); err != nil {
-		return nil, err
-	}
-
-	var kv map[interface{}]interface{}
-	if len(item.Value) == 0 {
-		kv = make(map[interface{}]interface{})
-	} else {
-		kv, err = session.DecodeGob(item.Value)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return NewMemcacheStore(p.c, sid, p.expire, kv), nil
-}
-
-// Count counts and returns number of sessions.
-func (p *MemcacheProvider) Count() int {
-	// FIXME: how come this library does not have Stats method?
-	return -1
-}
-
-// GC calls GC to clean expired sessions.
-func (p *MemcacheProvider) GC() {}
-
-func init() {
-	session.Register("memcache", &MemcacheProvider{})
-}

vendor/github.com/go-macaron/session/memcache/memcache.goconvey

@@ -1 +0,0 @@
-ignore

vendor/github.com/go-macaron/session/postgres/postgres.go

@@ -1,201 +0,0 @@
-// Copyright 2013 Beego Authors
-// Copyright 2014 The Macaron Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package session
-
-import (
-	"database/sql"
-	"fmt"
-	"log"
-	"sync"
-	"time"
-
-	_ "github.com/lib/pq"
-
-	"github.com/go-macaron/session"
-)
-
-// PostgresStore represents a postgres session store implementation.
-type PostgresStore struct {
-	c    *sql.DB
-	sid  string
-	lock sync.RWMutex
-	data map[interface{}]interface{}
-}
-
-// NewPostgresStore creates and returns a postgres session store.
-func NewPostgresStore(c *sql.DB, sid string, kv map[interface{}]interface{}) *PostgresStore {
-	return &PostgresStore{
-		c:    c,
-		sid:  sid,
-		data: kv,
-	}
-}
-
-// Set sets value to given key in session.
-func (s *PostgresStore) Set(key, value interface{}) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data[key] = value
-	return nil
-}
-
-// Get gets value by given key in session.
-func (s *PostgresStore) Get(key interface{}) interface{} {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	return s.data[key]
-}
-
-// Delete delete a key from session.
-func (s *PostgresStore) Delete(key interface{}) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	delete(s.data, key)
-	return nil
-}
-
-// ID returns current session ID.
-func (s *PostgresStore) ID() string {
-	return s.sid
-}
-
-// save postgres session values to database.
-// must call this method to save values to database.
-func (s *PostgresStore) Release() error {
-	// Skip encoding if the data is empty
-	if len(s.data) == 0 {
-		return nil
-	}
-
-	data, err := session.EncodeGob(s.data)
-	if err != nil {
-		return err
-	}
-
-	_, err = s.c.Exec("UPDATE session SET data=$1, expiry=$2 WHERE key=$3",
-		data, time.Now().Unix(), s.sid)
-	return err
-}
-
-// Flush deletes all session data.
-func (s *PostgresStore) Flush() error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data = make(map[interface{}]interface{})
-	return nil
-}
-
-// PostgresProvider represents a postgres session provider implementation.
-type PostgresProvider struct {
-	c           *sql.DB
-	maxlifetime int64
-}
-
-// Init initializes postgres session provider.
-// connStr: user=a password=b host=localhost port=5432 dbname=c sslmode=disable
-func (p *PostgresProvider) Init(maxlifetime int64, connStr string) (err error) {
-	p.maxlifetime = maxlifetime
-
-	p.c, err = sql.Open("postgres", connStr)
-	if err != nil {
-		return err
-	}
-	return p.c.Ping()
-}
-
-// Read returns raw session store by session ID.
-func (p *PostgresProvider) Read(sid string) (session.RawStore, error) {
-	var data []byte
-	err := p.c.QueryRow("SELECT data FROM session WHERE key=$1", sid).Scan(&data)
-	if err == sql.ErrNoRows {
-		_, err = p.c.Exec("INSERT INTO session(key,data,expiry) VALUES($1,$2,$3)",
-			sid, "", time.Now().Unix())
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	var kv map[interface{}]interface{}
-	if len(data) == 0 {
-		kv = make(map[interface{}]interface{})
-	} else {
-		kv, err = session.DecodeGob(data)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return NewPostgresStore(p.c, sid, kv), nil
-}
-
-// Exist returns true if session with given ID exists.
-func (p *PostgresProvider) Exist(sid string) bool {
-	var data []byte
-	err := p.c.QueryRow("SELECT data FROM session WHERE key=$1", sid).Scan(&data)
-	if err != nil && err != sql.ErrNoRows {
-		panic("session/postgres: error checking existence: " + err.Error())
-	}
-	return err != sql.ErrNoRows
-}
-
-// Destory deletes a session by session ID.
-func (p *PostgresProvider) Destory(sid string) error {
-	_, err := p.c.Exec("DELETE FROM session WHERE key=$1", sid)
-	return err
-}
-
-// Regenerate regenerates a session store from old session ID to new one.
-func (p *PostgresProvider) Regenerate(oldsid, sid string) (_ session.RawStore, err error) {
-	if p.Exist(sid) {
-		return nil, fmt.Errorf("new sid '%s' already exists", sid)
-	}
-
-	if !p.Exist(oldsid) {
-		if _, err = p.c.Exec("INSERT INTO session(key,data,expiry) VALUES($1,$2,$3)",
-			oldsid, "", time.Now().Unix()); err != nil {
-			return nil, err
-		}
-	}
-
-	if _, err = p.c.Exec("UPDATE session SET key=$1 WHERE key=$2", sid, oldsid); err != nil {
-		return nil, err
-	}
-
-	return p.Read(sid)
-}
-
-// Count counts and returns number of sessions.
-func (p *PostgresProvider) Count() (total int) {
-	if err := p.c.QueryRow("SELECT COUNT(*) AS NUM FROM session").Scan(&total); err != nil {
-		panic("session/postgres: error counting records: " + err.Error())
-	}
-	return total
-}
-
-// GC calls GC to clean expired sessions.
-func (p *PostgresProvider) GC() {
-	if _, err := p.c.Exec("DELETE FROM session WHERE EXTRACT(EPOCH FROM NOW()) - expiry > $1", p.maxlifetime); err != nil {
-		log.Printf("session/postgres: error garbage collecting: %v", err)
-	}
-}
-
-func init() {
-	session.Register("postgres", &PostgresProvider{})
-}

vendor/github.com/go-macaron/session/postgres/postgres.goconvey

@@ -1 +0,0 @@
-ignore

vendor/github.com/go-macaron/session/redis/redis.go

@@ -1,240 +0,0 @@
-// Copyright 2013 Beego Authors
-// Copyright 2014 The Macaron Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License"): you may
-// not use this file except in compliance with the License. You may obtain
-// a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-// License for the specific language governing permissions and limitations
-// under the License.
-
-package session
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/Unknwon/com"
-	"gopkg.in/ini.v1"
-	"gopkg.in/redis.v2"
-
-	"github.com/go-macaron/session"
-)
-
-// RedisStore represents a redis session store implementation.
-type RedisStore struct {
-	c           *redis.Client
-	prefix, sid string
-	duration    time.Duration
-	lock        sync.RWMutex
-	data        map[interface{}]interface{}
-}
-
-// NewRedisStore creates and returns a redis session store.
-func NewRedisStore(c *redis.Client, prefix, sid string, dur time.Duration, kv map[interface{}]interface{}) *RedisStore {
-	return &RedisStore{
-		c:        c,
-		prefix:   prefix,
-		sid:      sid,
-		duration: dur,
-		data:     kv,
-	}
-}
-
-// Set sets value to given key in session.
-func (s *RedisStore) Set(key, val interface{}) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data[key] = val
-	return nil
-}
-
-// Get gets value by given key in session.
-func (s *RedisStore) Get(key interface{}) interface{} {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	return s.data[key]
-}
-
-// Delete delete a key from session.
-func (s *RedisStore) Delete(key interface{}) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	delete(s.data, key)
-	return nil
-}
-
-// ID returns current session ID.
-func (s *RedisStore) ID() string {
-	return s.sid
-}
-
-// Release releases resource and save data to provider.
-func (s *RedisStore) Release() error {
-	// Skip encoding if the data is empty
-	if len(s.data) == 0 {
-		return nil
-	}
-
-	data, err := session.EncodeGob(s.data)
-	if err != nil {
-		return err
-	}
-
-	return s.c.SetEx(s.prefix+s.sid, s.duration, string(data)).Err()
-}
-
-// Flush deletes all session data.
-func (s *RedisStore) Flush() error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data = make(map[interface{}]interface{})
-	return nil
-}
-
-// RedisProvider represents a redis session provider implementation.
-type RedisProvider struct {
-	c        *redis.Client
-	duration time.Duration
-	prefix   string
-}
-
-// Init initializes redis session provider.
-// configs: network=tcp,addr=:6379,password=macaron,db=0,pool_size=100,idle_timeout=180,prefix=session;
-func (p *RedisProvider) Init(maxlifetime int64, configs string) (err error) {
-	p.duration, err = time.ParseDuration(fmt.Sprintf("%ds", maxlifetime))
-	if err != nil {
-		return err
-	}
-
-	cfg, err := ini.Load([]byte(strings.Replace(configs, ",", "\n", -1)))
-	if err != nil {
-		return err
-	}
-
-	opt := &redis.Options{
-		Network: "tcp",
-	}
-	for k, v := range cfg.Section("").KeysHash() {
-		switch k {
-		case "network":
-			opt.Network = v
-		case "addr":
-			opt.Addr = v
-		case "password":
-			opt.Password = v
-		case "db":
-			opt.DB = com.StrTo(v).MustInt64()
-		case "pool_size":
-			opt.PoolSize = com.StrTo(v).MustInt()
-		case "idle_timeout":
-			opt.IdleTimeout, err = time.ParseDuration(v + "s")
-			if err != nil {
-				return fmt.Errorf("error parsing idle timeout: %v", err)
-			}
-		case "prefix":
-			p.prefix = v
-		default:
-			return fmt.Errorf("session/redis: unsupported option '%s'", k)
-		}
-	}
-
-	p.c = redis.NewClient(opt)
-	return p.c.Ping().Err()
-}
-
-// Read returns raw session store by session ID.
-func (p *RedisProvider) Read(sid string) (session.RawStore, error) {
-	psid := p.prefix + sid
-	if !p.Exist(sid) {
-		if err := p.c.SetEx(psid, p.duration, "").Err(); err != nil {
-			return nil, err
-		}
-	}
-
-	var kv map[interface{}]interface{}
-	kvs, err := p.c.Get(psid).Result()
-	if err != nil {
-		return nil, err
-	}
-	if len(kvs) == 0 {
-		kv = make(map[interface{}]interface{})
-	} else {
-		kv, err = session.DecodeGob([]byte(kvs))
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return NewRedisStore(p.c, p.prefix, sid, p.duration, kv), nil
-}
-
-// Exist returns true if session with given ID exists.
-func (p *RedisProvider) Exist(sid string) bool {
-	has, err := p.c.Exists(p.prefix + sid).Result()
-	return err == nil && has
-}
-
-// Destory deletes a session by session ID.
-func (p *RedisProvider) Destory(sid string) error {
-	return p.c.Del(p.prefix + sid).Err()
-}
-
-// Regenerate regenerates a session store from old session ID to new one.
-func (p *RedisProvider) Regenerate(oldsid, sid string) (_ session.RawStore, err error) {
-	poldsid := p.prefix + oldsid
-	psid := p.prefix + sid
-
-	if p.Exist(sid) {
-		return nil, fmt.Errorf("new sid '%s' already exists", sid)
-	} else if !p.Exist(oldsid) {
-		// Make a fake old session.
-		if err = p.c.SetEx(poldsid, p.duration, "").Err(); err != nil {
-			return nil, err
-		}
-	}
-
-	if err = p.c.Rename(poldsid, psid).Err(); err != nil {
-		return nil, err
-	}
-
-	var kv map[interface{}]interface{}
-	kvs, err := p.c.Get(psid).Result()
-	if err != nil {
-		return nil, err
-	}
-
-	if len(kvs) == 0 {
-		kv = make(map[interface{}]interface{})
-	} else {
-		kv, err = session.DecodeGob([]byte(kvs))
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return NewRedisStore(p.c, p.prefix, sid, p.duration, kv), nil
-}
-
-// Count counts and returns number of sessions.
-func (p *RedisProvider) Count() int {
-	return int(p.c.DbSize().Val())
-}
-
-// GC calls GC to clean expired sessions.
-func (_ *RedisProvider) GC() {}
-
-func init() {
-	session.Register("redis", &RedisProvider{})
-}

vendor/github.com/go-macaron/session/redis/redis.goconvey

@@ -1 +0,0 @@
-ignore

vendor/modules.txt

@@ -77,9 +77,6 @@ github.com/go-macaron/gzip
 github.com/go-macaron/inject
 # github.com/go-macaron/session v0.0.0-20190131233854-0a0a789bf193
 github.com/go-macaron/session
-github.com/go-macaron/session/memcache
-github.com/go-macaron/session/postgres
-github.com/go-macaron/session/redis
 # github.com/go-sql-driver/mysql v1.4.1
 github.com/go-sql-driver/mysql
 # github.com/go-stack/stack v1.8.0