mirror of
https://github.com/hanzoai/beego.git
synced 2026-11-17 13:19:25 +00:00
hanzokv/go v9.22.0 renames its Go package from `redis` to `kv` (import path is unchanged). Follow the dependency and finish the job: the three session backends that speak to our KV store now say "kv" everywhere instead of carrying a vendor name we no longer use. server/web/session/redis -> server/web/session/kv server/web/session/redis_cluster -> server/web/session/kv_cluster server/web/session/redis_sentinel -> server/web/session/kv_sentinel Provider names registered with session.Register, and the matching session.ProviderType constants, move with them: "redis" ProviderRedis -> "kv" ProviderKV "redis_cluster" ProviderRedisCluster -> "kv_cluster" ProviderKVCluster "redis_sentinel" ProviderRedisSentinel -> "kv_sentinel" ProviderKVSentinel Also: drop the kv_cluster import alias (rediss) now that the package identifier no longer collides, rename the redispder package vars to kvpder, rename the SessionRead local map from kv to values so it stops shadowing the imported package, and repoint the stale upstream doc comments (gomodule/redigo, redis/go-redis) at hanzokv/go/v9. Not touched: client/cache/redis still rides gomodule/redigo, a genuinely foreign client, so it keeps its name. The REDIS_ADDR test env var also stays, because client/cache/redis tests read the same variable and splitting it would mean two knobs for one address. This is a breaking change for anyone importing the old paths or naming the old providers in config. Co-authored-by: Hanzo Dev <[email protected]>
379 lines
11 KiB
Go
379 lines
11 KiB
Go
// 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/hanzoai/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 (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/textproto"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
)
|
|
|
|
// Store contains all data for one session process with specific id.
|
|
type Store interface {
|
|
Set(ctx context.Context, key, value interface{}) error // Set set session value
|
|
Get(ctx context.Context, key interface{}) interface{} // Get get session value
|
|
Delete(ctx context.Context, key interface{}) error // Delete delete session value
|
|
SessionID(ctx context.Context) string // SessionID return current sessionID
|
|
SessionReleaseIfPresent(ctx context.Context, w http.ResponseWriter) // SessionReleaseIfPresent release the resource & save data to provider & return the data when the session is present, not all implementation support this feature, you need to check if the specific implementation if support this feature.
|
|
SessionRelease(ctx context.Context, w http.ResponseWriter) // SessionRelease release the resource & save data to provider & return the data
|
|
Flush(ctx context.Context) error // Flush delete all data
|
|
}
|
|
|
|
// Provider contains global session methods and saved SessionStores.
|
|
// it can operate a SessionStore by its id.
|
|
type Provider interface {
|
|
SessionInit(ctx context.Context, gclifetime int64, config string) error
|
|
SessionRead(ctx context.Context, sid string) (Store, error)
|
|
SessionExist(ctx context.Context, sid string) (bool, error)
|
|
SessionRegenerate(ctx context.Context, oldsid, sid string) (Store, error)
|
|
SessionDestroy(ctx context.Context, sid string) error
|
|
SessionAll(ctx context.Context) int // get all active session
|
|
SessionGC(ctx context.Context)
|
|
}
|
|
|
|
var provides = make(map[string]Provider)
|
|
|
|
// 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 provider is nil, it panic
|
|
func Register(name string, provide Provider) {
|
|
if provide == nil {
|
|
panic("session: Register provide is nil")
|
|
}
|
|
provides[name] = provide
|
|
}
|
|
|
|
// GetProvider
|
|
func GetProvider(name string) (Provider, error) {
|
|
provider, ok := provides[name]
|
|
if !ok {
|
|
return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", name)
|
|
}
|
|
return provider, nil
|
|
}
|
|
|
|
// Manager contains Provider and its configuration.
|
|
type Manager struct {
|
|
provider Provider
|
|
config *ManagerConfig
|
|
}
|
|
|
|
// NewManager Create new Manager with provider name and json config string.
|
|
// provider name:
|
|
// 1. cookie
|
|
// 2. file
|
|
// 3. memory
|
|
// 4. kv
|
|
// 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) {
|
|
provider, ok := provides[provideName]
|
|
if !ok {
|
|
return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", provideName)
|
|
}
|
|
|
|
if cf.Maxlifetime == 0 {
|
|
cf.Maxlifetime = cf.Gclifetime
|
|
}
|
|
|
|
if cf.EnableSidInHTTPHeader {
|
|
if cf.SessionNameInHTTPHeader == "" {
|
|
panic(errors.New("SessionNameInHTTPHeader is empty"))
|
|
}
|
|
|
|
strMimeHeader := textproto.CanonicalMIMEHeaderKey(cf.SessionNameInHTTPHeader)
|
|
if cf.SessionNameInHTTPHeader != strMimeHeader {
|
|
strErrMsg := "SessionNameInHTTPHeader (" + cf.SessionNameInHTTPHeader + ") has the wrong format, it should be like this : " + strMimeHeader
|
|
panic(errors.New(strErrMsg))
|
|
}
|
|
}
|
|
|
|
err := provider.SessionInit(context.Background(), cf.Maxlifetime, cf.ProviderConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if cf.SessionIDLength == 0 {
|
|
cf.SessionIDLength = 16
|
|
}
|
|
|
|
return &Manager{
|
|
provider,
|
|
cf,
|
|
}, nil
|
|
}
|
|
|
|
// GetProvider return current manager's provider
|
|
func (manager *Manager) GetProvider() Provider {
|
|
return manager.provider
|
|
}
|
|
|
|
// getSid retrieves session identifier from HTTP Request.
|
|
// First try to retrieve id by reading from cookie, session cookie name is configurable,
|
|
// if not exist, then retrieve id from querying parameters.
|
|
//
|
|
// error is not nil when there is anything wrong.
|
|
// sid is empty when need to generate a new session id
|
|
// otherwise return a valid session id.
|
|
func (manager *Manager) getSid(r *http.Request) (string, error) {
|
|
cookie, errs := r.Cookie(manager.config.CookieName)
|
|
if errs != nil || cookie.Value == "" {
|
|
var sid string
|
|
if manager.config.EnableSidInURLQuery {
|
|
errs := r.ParseForm()
|
|
if errs != nil {
|
|
return "", errs
|
|
}
|
|
|
|
sid = r.FormValue(manager.config.CookieName)
|
|
}
|
|
|
|
// if not found in Cookie / param, then read it from request headers
|
|
if manager.config.EnableSidInHTTPHeader && sid == "" {
|
|
sids, isFound := r.Header[manager.config.SessionNameInHTTPHeader]
|
|
if isFound && len(sids) != 0 {
|
|
return sids[0], nil
|
|
}
|
|
}
|
|
|
|
return sid, nil
|
|
}
|
|
|
|
// HTTP Request contains cookie for sessionid info.
|
|
return url.QueryUnescape(cookie.Value)
|
|
}
|
|
|
|
// 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) (session Store, err error) {
|
|
sid, errs := manager.getSid(r)
|
|
if errs != nil {
|
|
return nil, errs
|
|
}
|
|
|
|
if sid != "" {
|
|
exists, err := manager.provider.SessionExist(context.Background(), sid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if exists {
|
|
return manager.provider.SessionRead(context.Background(), sid)
|
|
}
|
|
}
|
|
|
|
// Generate a new session
|
|
sid, errs = manager.sessionID()
|
|
if errs != nil {
|
|
return nil, errs
|
|
}
|
|
|
|
session, err = manager.provider.SessionRead(context.Background(), sid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cookie := &http.Cookie{
|
|
Name: manager.config.CookieName,
|
|
Value: url.QueryEscape(sid),
|
|
Path: "/",
|
|
HttpOnly: !manager.config.DisableHTTPOnly,
|
|
Secure: manager.isSecure(r),
|
|
Domain: manager.config.Domain,
|
|
SameSite: manager.config.CookieSameSite,
|
|
}
|
|
if manager.config.CookieLifeTime > 0 {
|
|
cookie.MaxAge = manager.config.CookieLifeTime
|
|
cookie.Expires = time.Now().Add(time.Duration(manager.config.CookieLifeTime) * time.Second)
|
|
}
|
|
if manager.config.EnableSetCookie {
|
|
http.SetCookie(w, cookie)
|
|
}
|
|
r.AddCookie(cookie)
|
|
|
|
if manager.config.EnableSidInHTTPHeader {
|
|
r.Header.Set(manager.config.SessionNameInHTTPHeader, sid)
|
|
w.Header().Set(manager.config.SessionNameInHTTPHeader, sid)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// SessionDestroy Destroy session by its id in http request cookie.
|
|
func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request) {
|
|
if manager.config.EnableSidInHTTPHeader {
|
|
r.Header.Del(manager.config.SessionNameInHTTPHeader)
|
|
w.Header().Del(manager.config.SessionNameInHTTPHeader)
|
|
}
|
|
|
|
cookie, err := r.Cookie(manager.config.CookieName)
|
|
if err != nil || cookie.Value == "" {
|
|
return
|
|
}
|
|
|
|
sid, _ := url.QueryUnescape(cookie.Value)
|
|
manager.provider.SessionDestroy(context.Background(), sid)
|
|
if manager.config.EnableSetCookie {
|
|
expiration := time.Now()
|
|
cookie = &http.Cookie{
|
|
Name: manager.config.CookieName,
|
|
Path: "/",
|
|
HttpOnly: !manager.config.DisableHTTPOnly,
|
|
Expires: expiration,
|
|
MaxAge: -1,
|
|
Domain: manager.config.Domain,
|
|
SameSite: manager.config.CookieSameSite,
|
|
}
|
|
|
|
http.SetCookie(w, cookie)
|
|
}
|
|
}
|
|
|
|
// GetSessionStore Get SessionStore by its id.
|
|
func (manager *Manager) GetSessionStore(sid string) (sessions Store, err error) {
|
|
sessions, err = manager.provider.SessionRead(context.Background(), sid)
|
|
return
|
|
}
|
|
|
|
// GC Start session gc process.
|
|
// it can do gc in times after gc lifetime.
|
|
func (manager *Manager) GC() {
|
|
manager.provider.SessionGC(nil)
|
|
time.AfterFunc(time.Duration(manager.config.Gclifetime)*time.Second, func() { manager.GC() })
|
|
}
|
|
|
|
// SessionRegenerateID Regenerate a session id for this SessionStore whose id is saving in http request.
|
|
func (manager *Manager) SessionRegenerateID(w http.ResponseWriter, r *http.Request) (Store, error) {
|
|
sid, err := manager.sessionID()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var session Store
|
|
cookie, err := r.Cookie(manager.config.CookieName)
|
|
if err != nil || cookie.Value == "" {
|
|
// delete old cookie
|
|
session, err = manager.provider.SessionRead(context.Background(), sid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cookie = &http.Cookie{
|
|
Name: manager.config.CookieName,
|
|
Value: url.QueryEscape(sid),
|
|
}
|
|
} else {
|
|
oldsid, err := url.QueryUnescape(cookie.Value)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
session, err = manager.provider.SessionRegenerate(context.Background(), oldsid, sid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cookie.Value = url.QueryEscape(sid)
|
|
}
|
|
if manager.config.CookieLifeTime > 0 {
|
|
cookie.MaxAge = manager.config.CookieLifeTime
|
|
cookie.Expires = time.Now().Add(time.Duration(manager.config.CookieLifeTime) * time.Second)
|
|
}
|
|
|
|
cookie.HttpOnly = !manager.config.DisableHTTPOnly
|
|
cookie.Path = "/"
|
|
cookie.Secure = manager.isSecure(r)
|
|
cookie.Domain = manager.config.Domain
|
|
cookie.SameSite = manager.config.CookieSameSite
|
|
|
|
if manager.config.EnableSetCookie {
|
|
http.SetCookie(w, cookie)
|
|
}
|
|
r.AddCookie(cookie)
|
|
if manager.config.EnableSidInHTTPHeader {
|
|
r.Header.Set(manager.config.SessionNameInHTTPHeader, sid)
|
|
w.Header().Set(manager.config.SessionNameInHTTPHeader, sid)
|
|
}
|
|
return session, nil
|
|
}
|
|
|
|
// GetActiveSession Get all active sessions count number.
|
|
func (manager *Manager) GetActiveSession() int {
|
|
return manager.provider.SessionAll(nil)
|
|
}
|
|
|
|
// SetSecure Set cookie with https.
|
|
func (manager *Manager) SetSecure(secure bool) {
|
|
manager.config.Secure = secure
|
|
}
|
|
|
|
func (manager *Manager) sessionID() (string, error) {
|
|
b := make([]byte, manager.config.SessionIDLength)
|
|
n, err := rand.Read(b)
|
|
if n != len(b) || err != nil {
|
|
return "", fmt.Errorf("Could not successfully read from the system CSPRNG")
|
|
}
|
|
return manager.config.SessionIDPrefix + hex.EncodeToString(b), nil
|
|
}
|
|
|
|
// Set cookie with https.
|
|
func (manager *Manager) isSecure(req *http.Request) bool {
|
|
if !manager.config.Secure {
|
|
return false
|
|
}
|
|
if req.URL.Scheme != "" {
|
|
return req.URL.Scheme == "https"
|
|
}
|
|
if req.TLS == nil {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Log implement the log.Logger
|
|
type Log struct {
|
|
*log.Logger
|
|
}
|
|
|
|
// NewSessionLog set io.Writer to create a Logger for session.
|
|
func NewSessionLog(out io.Writer) *Log {
|
|
sl := new(Log)
|
|
sl.Logger = log.New(out, "[SESSION]", 1e9)
|
|
return sl
|
|
}
|