/
session.go
165 lines (143 loc) · 5.11 KB
/
session.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
// Copyright 2014 beego Author. All Rights Reserved.
//
// 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 provider
//
// Usage:
// import(
// "github.com/beego/beego/v2/server/web/session"
// )
//
// func init() {
// globalSessions, _ = session.NewManager("memory", `{"cookieName":"gosessionid", "enableSetCookie,omitempty": true, "gclifetime":3600, "maxLifetime": 3600, "secure": false, "cookieLifeTime": 3600, "providerConfig": ""}`)
// go globalSessions.GC()
// }
//
package session
import (
"io"
"net/http"
"os"
"github.com/beego/beego/v2/server/web/session"
)
// Store contains all data for one session process with specific id.
type Store interface {
Set(key, value interface{}) error // set session value
Get(key interface{}) interface{} // get session value
Delete(key interface{}) error // delete session value
SessionID() string // back current sessionID
SessionRelease(w http.ResponseWriter) // release the resource & save data to provider & return the data
Flush() error // delete all data
}
// Provider contains global session methods and saved SessionStores.
// it can operate a SessionStore by its id.
type Provider interface {
SessionInit(gclifetime int64, config string) error
SessionRead(sid string) (Store, error)
SessionExist(sid string) bool
SessionRegenerate(oldsid, sid string) (Store, error)
SessionDestroy(sid string) error
SessionAll() int // get all active session
SessionGC()
}
// SLogger a helpful variable to log information about session
var SLogger = NewSessionLog(os.Stderr)
// Register makes a session provide available by the provided name.
// If Register is called twice with the same name or if driver is nil,
// it panics.
func Register(name string, provide Provider) {
session.Register(name, &oldToNewProviderAdapter{
delegate: provide,
})
}
// GetProvider
func GetProvider(name string) (Provider, error) {
res, err := session.GetProvider(name)
if adt, ok := res.(*oldToNewProviderAdapter); err == nil && ok {
return adt.delegate, err
}
return &newToOldProviderAdapter{
delegate: res,
}, err
}
// ManagerConfig define the session config
type ManagerConfig session.ManagerConfig
// Manager contains Provider and its configuration.
type Manager session.Manager
// NewManager Create new Manager with provider name and json config string.
// provider name:
// 1. cookie
// 2. file
// 3. memory
// 4. redis
// 5. mysql
// json config:
// 1. is https default false
// 2. hashfunc default sha1
// 3. hashkey default beegosessionkey
// 4. maxage default is none
func NewManager(provideName string, cf *ManagerConfig) (*Manager, error) {
m, err := session.NewManager(provideName, (*session.ManagerConfig)(cf))
return (*Manager)(m), err
}
// GetProvider return current manager's provider
func (manager *Manager) GetProvider() Provider {
return &newToOldProviderAdapter{
delegate: (*session.Manager)(manager).GetProvider(),
}
}
// SessionStart generate or read the session id from http request.
// if session id exists, return SessionStore with this id.
func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (Store, error) {
s, err := (*session.Manager)(manager).SessionStart(w, r)
return &NewToOldStoreAdapter{
delegate: s,
}, err
}
// SessionDestroy Destroy session by its id in http request cookie.
func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request) {
(*session.Manager)(manager).SessionDestroy(w, r)
}
// GetSessionStore Get SessionStore by its id.
func (manager *Manager) GetSessionStore(sid string) (Store, error) {
s, err := (*session.Manager)(manager).GetSessionStore(sid)
return &NewToOldStoreAdapter{
delegate: s,
}, err
}
// GC Start session gc process.
// it can do gc in times after gc lifetime.
func (manager *Manager) GC() {
(*session.Manager)(manager).GC()
}
// SessionRegenerateID Regenerate a session id for this SessionStore who's id is saving in http request.
func (manager *Manager) SessionRegenerateID(w http.ResponseWriter, r *http.Request) Store {
s, _ := (*session.Manager)(manager).SessionRegenerateID(w, r)
return &NewToOldStoreAdapter{
delegate: s,
}
}
// GetActiveSession Get all active sessions count number.
func (manager *Manager) GetActiveSession() int {
return (*session.Manager)(manager).GetActiveSession()
}
// SetSecure Set cookie with https.
func (manager *Manager) SetSecure(secure bool) {
(*session.Manager)(manager).SetSecure(secure)
}
// Log implement the log.Logger
type Log session.Log
// NewSessionLog set io.Writer to create a Logger for session.
func NewSessionLog(out io.Writer) *Log {
return (*Log)(session.NewSessionLog(out))
}