github.com/astaxie/beego@v1.12.3/session/ledis/ledis_session.go (about)

     1  // Package ledis provide session Provider
     2  package ledis
     3  
     4  import (
     5  	"net/http"
     6  	"strconv"
     7  	"strings"
     8  	"sync"
     9  
    10  	"github.com/ledisdb/ledisdb/config"
    11  	"github.com/ledisdb/ledisdb/ledis"
    12  
    13  	"github.com/astaxie/beego/session"
    14  )
    15  
    16  var (
    17  	ledispder = &Provider{}
    18  	c         *ledis.DB
    19  )
    20  
    21  // SessionStore ledis session store
    22  type SessionStore struct {
    23  	sid         string
    24  	lock        sync.RWMutex
    25  	values      map[interface{}]interface{}
    26  	maxlifetime int64
    27  }
    28  
    29  // Set value in ledis session
    30  func (ls *SessionStore) Set(key, value interface{}) error {
    31  	ls.lock.Lock()
    32  	defer ls.lock.Unlock()
    33  	ls.values[key] = value
    34  	return nil
    35  }
    36  
    37  // Get value in ledis session
    38  func (ls *SessionStore) Get(key interface{}) interface{} {
    39  	ls.lock.RLock()
    40  	defer ls.lock.RUnlock()
    41  	if v, ok := ls.values[key]; ok {
    42  		return v
    43  	}
    44  	return nil
    45  }
    46  
    47  // Delete value in ledis session
    48  func (ls *SessionStore) Delete(key interface{}) error {
    49  	ls.lock.Lock()
    50  	defer ls.lock.Unlock()
    51  	delete(ls.values, key)
    52  	return nil
    53  }
    54  
    55  // Flush clear all values in ledis session
    56  func (ls *SessionStore) Flush() error {
    57  	ls.lock.Lock()
    58  	defer ls.lock.Unlock()
    59  	ls.values = make(map[interface{}]interface{})
    60  	return nil
    61  }
    62  
    63  // SessionID get ledis session id
    64  func (ls *SessionStore) SessionID() string {
    65  	return ls.sid
    66  }
    67  
    68  // SessionRelease save session values to ledis
    69  func (ls *SessionStore) SessionRelease(w http.ResponseWriter) {
    70  	b, err := session.EncodeGob(ls.values)
    71  	if err != nil {
    72  		return
    73  	}
    74  	c.Set([]byte(ls.sid), b)
    75  	c.Expire([]byte(ls.sid), ls.maxlifetime)
    76  }
    77  
    78  // Provider ledis session provider
    79  type Provider struct {
    80  	maxlifetime int64
    81  	savePath    string
    82  	db          int
    83  }
    84  
    85  // SessionInit init ledis session
    86  // savepath like ledis server saveDataPath,pool size
    87  // e.g. 127.0.0.1:6379,100,astaxie
    88  func (lp *Provider) SessionInit(maxlifetime int64, savePath string) error {
    89  	var err error
    90  	lp.maxlifetime = maxlifetime
    91  	configs := strings.Split(savePath, ",")
    92  	if len(configs) == 1 {
    93  		lp.savePath = configs[0]
    94  	} else if len(configs) == 2 {
    95  		lp.savePath = configs[0]
    96  		lp.db, err = strconv.Atoi(configs[1])
    97  		if err != nil {
    98  			return err
    99  		}
   100  	}
   101  	cfg := new(config.Config)
   102  	cfg.DataDir = lp.savePath
   103  
   104  	var ledisInstance *ledis.Ledis
   105  	ledisInstance, err = ledis.Open(cfg)
   106  	if err != nil {
   107  		return err
   108  	}
   109  	c, err = ledisInstance.Select(lp.db)
   110  	return err
   111  }
   112  
   113  // SessionRead read ledis session by sid
   114  func (lp *Provider) SessionRead(sid string) (session.Store, error) {
   115  	var (
   116  		kv  map[interface{}]interface{}
   117  		err error
   118  	)
   119  
   120  	kvs, _ := c.Get([]byte(sid))
   121  
   122  	if len(kvs) == 0 {
   123  		kv = make(map[interface{}]interface{})
   124  	} else {
   125  		if kv, err = session.DecodeGob(kvs); err != nil {
   126  			return nil, err
   127  		}
   128  	}
   129  
   130  	ls := &SessionStore{sid: sid, values: kv, maxlifetime: lp.maxlifetime}
   131  	return ls, nil
   132  }
   133  
   134  // SessionExist check ledis session exist by sid
   135  func (lp *Provider) SessionExist(sid string) bool {
   136  	count, _ := c.Exists([]byte(sid))
   137  	return count != 0
   138  }
   139  
   140  // SessionRegenerate generate new sid for ledis session
   141  func (lp *Provider) SessionRegenerate(oldsid, sid string) (session.Store, error) {
   142  	count, _ := c.Exists([]byte(sid))
   143  	if count == 0 {
   144  		// oldsid doesn't exists, set the new sid directly
   145  		// ignore error here, since if it return error
   146  		// the existed value will be 0
   147  		c.Set([]byte(sid), []byte(""))
   148  		c.Expire([]byte(sid), lp.maxlifetime)
   149  	} else {
   150  		data, _ := c.Get([]byte(oldsid))
   151  		c.Set([]byte(sid), data)
   152  		c.Expire([]byte(sid), lp.maxlifetime)
   153  	}
   154  	return lp.SessionRead(sid)
   155  }
   156  
   157  // SessionDestroy delete ledis session by id
   158  func (lp *Provider) SessionDestroy(sid string) error {
   159  	c.Del([]byte(sid))
   160  	return nil
   161  }
   162  
   163  // SessionGC Impelment method, no used.
   164  func (lp *Provider) SessionGC() {
   165  }
   166  
   167  // SessionAll return all active session
   168  func (lp *Provider) SessionAll() int {
   169  	return 0
   170  }
   171  func init() {
   172  	session.Register("ledis", ledispder)
   173  }