Skip to content
Projects
Groups
Snippets
Help
This project
Loading...
Sign in / Register
Toggle navigation
N
nexpie-grafana-theme
Overview
Overview
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Registry
Registry
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Wiki
Wiki
Snippets
Snippets
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
Kornkitt Poolsup
nexpie-grafana-theme
Commits
a8326e3e
Commit
a8326e3e
authored
Apr 26, 2019
by
bergquist
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
build: removes unused vendored files
parent
daea9e9f
Hide whitespace changes
Inline
Side-by-side
Showing
8 changed files
with
1 additions
and
655 deletions
+1
-655
go.mod
+1
-1
vendor/github.com/go-macaron/session/memcache/memcache.go
+0
-204
vendor/github.com/go-macaron/session/memcache/memcache.goconvey
+0
-2
vendor/github.com/go-macaron/session/postgres/postgres.go
+0
-201
vendor/github.com/go-macaron/session/postgres/postgres.goconvey
+0
-2
vendor/github.com/go-macaron/session/redis/redis.go
+0
-240
vendor/github.com/go-macaron/session/redis/redis.goconvey
+0
-2
vendor/modules.txt
+0
-3
No files found.
go.mod
View file @
a8326e3e
...
...
@@ -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
deleted
100644 → 0
View file @
daea9e9f
// 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
deleted
100644 → 0
View file @
daea9e9f
ignore
\ No newline at end of file
vendor/github.com/go-macaron/session/postgres/postgres.go
deleted
100644 → 0
View file @
daea9e9f
// 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
deleted
100644 → 0
View file @
daea9e9f
ignore
\ No newline at end of file
vendor/github.com/go-macaron/session/redis/redis.go
deleted
100644 → 0
View file @
daea9e9f
// 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
deleted
100644 → 0
View file @
daea9e9f
ignore
\ No newline at end of file
vendor/modules.txt
View file @
a8326e3e
...
...
@@ -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
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment