Beego/session/postgres/sess_postgresql.go

package session

/*

beego session provider for postgresql
-------------------------------------

depends on github.com/lib/pq:

go install github.com/lib/pq


needs this table in your database:

CREATE TABLE session (
session_key	char(64) NOT NULL,
session_data	bytea,
session_expiry	timestamp NOT NULL,
CONSTRAINT session_key PRIMARY KEY(session_key)
);


will be activated with these settings in app.conf:

SessionOn = true
SessionProvider = postgresql
SessionSavePath = "user=a password=b dbname=c sslmode=disable"
SessionName = session

*/

import (
	"database/sql"
	"net/http"
	"sync"
	"time"

	"github.com/astaxie/beego/session"

	_ "github.com/lib/pq"
)

var postgresqlpder = &PostgresqlProvider{}

// postgresql session store
type PostgresqlSessionStore struct {
	c      *sql.DB
	sid    string
	lock   sync.RWMutex
	values map[interface{}]interface{}
}

// set value in postgresql session.
// it is temp value in map.
func (st *PostgresqlSessionStore) Set(key, value interface{}) error {
	st.lock.Lock()
	defer st.lock.Unlock()
	st.values[key] = value
	return nil
}

// get value from postgresql session
func (st *PostgresqlSessionStore) Get(key interface{}) interface{} {
	st.lock.RLock()
	defer st.lock.RUnlock()
	if v, ok := st.values[key]; ok {
		return v
	} else {
		return nil
	}
	return nil
}

// delete value in postgresql session
func (st *PostgresqlSessionStore) Delete(key interface{}) error {
	st.lock.Lock()
	defer st.lock.Unlock()
	delete(st.values, key)
	return nil
}

// clear all values in postgresql session
func (st *PostgresqlSessionStore) Flush() error {
	st.lock.Lock()
	defer st.lock.Unlock()
	st.values = make(map[interface{}]interface{})
	return nil
}

// get session id of this postgresql session store
func (st *PostgresqlSessionStore) SessionID() string {
	return st.sid
}

// save postgresql session values to database.
// must call this method to save values to database.
func (st *PostgresqlSessionStore) SessionRelease(w http.ResponseWriter) {
	defer st.c.Close()
	b, err := session.EncodeGob(st.values)
	if err != nil {
		return
	}
	st.c.Exec("UPDATE session set session_data=$1, session_expiry=$2 where session_key=$3",
		b, time.Now().Format(time.RFC3339), st.sid)

}

// postgresql session provider
type PostgresqlProvider struct {
	maxlifetime int64
	savePath    string
}

// connect to postgresql
func (mp *PostgresqlProvider) connectInit() *sql.DB {
	db, e := sql.Open("postgres", mp.savePath)
	if e != nil {
		return nil
	}
	return db
}

// init postgresql session.
// savepath is the connection string of postgresql.
func (mp *PostgresqlProvider) SessionInit(maxlifetime int64, savePath string) error {
	mp.maxlifetime = maxlifetime
	mp.savePath = savePath
	return nil
}

// get postgresql session by sid
func (mp *PostgresqlProvider) SessionRead(sid string) (session.SessionStore, error) {
	c := mp.connectInit()
	row := c.QueryRow("select session_data from session where session_key=$1", sid)
	var sessiondata []byte
	err := row.Scan(&sessiondata)
	if err == sql.ErrNoRows {
		_, err = c.Exec("insert into session(session_key,session_data,session_expiry) values($1,$2,$3)",
			sid, "", time.Now().Format(time.RFC3339))

		if err != nil {
			return nil, err
		}
	} else if err != nil {
		return nil, err
	}

	var kv map[interface{}]interface{}
	if len(sessiondata) == 0 {
		kv = make(map[interface{}]interface{})
	} else {
		kv, err = session.DecodeGob(sessiondata)
		if err != nil {
			return nil, err
		}
	}
	rs := &PostgresqlSessionStore{c: c, sid: sid, values: kv}
	return rs, nil
}

// check postgresql session exist
func (mp *PostgresqlProvider) SessionExist(sid string) bool {
	c := mp.connectInit()
	defer c.Close()
	row := c.QueryRow("select session_data from session where session_key=$1", sid)
	var sessiondata []byte
	err := row.Scan(&sessiondata)

	if err == sql.ErrNoRows {
		return false
	} else {
		return true
	}
}

// generate new sid for postgresql session
func (mp *PostgresqlProvider) SessionRegenerate(oldsid, sid string) (session.SessionStore, error) {
	c := mp.connectInit()
	row := c.QueryRow("select session_data from session where session_key=$1", oldsid)
	var sessiondata []byte
	err := row.Scan(&sessiondata)
	if err == sql.ErrNoRows {
		c.Exec("insert into session(session_key,session_data,session_expiry) values($1,$2,$3)",
			oldsid, "", time.Now().Format(time.RFC3339))
	}
	c.Exec("update session set session_key=$1 where session_key=$2", sid, oldsid)
	var kv map[interface{}]interface{}
	if len(sessiondata) == 0 {
		kv = make(map[interface{}]interface{})
	} else {
		kv, err = session.DecodeGob(sessiondata)
		if err != nil {
			return nil, err
		}
	}
	rs := &PostgresqlSessionStore{c: c, sid: sid, values: kv}
	return rs, nil
}

// delete postgresql session by sid
func (mp *PostgresqlProvider) SessionDestroy(sid string) error {
	c := mp.connectInit()
	c.Exec("DELETE FROM session where session_key=$1", sid)
	c.Close()
	return nil
}

// delete expired values in postgresql session
func (mp *PostgresqlProvider) SessionGC() {
	c := mp.connectInit()
	c.Exec("DELETE from session where EXTRACT(EPOCH FROM (current_timestamp - session_expiry)) > $1", mp.maxlifetime)
	c.Close()
	return
}

// count values in postgresql session
func (mp *PostgresqlProvider) SessionAll() int {
	c := mp.connectInit()
	defer c.Close()
	var total int
	err := c.QueryRow("SELECT count(*) as num from session").Scan(&total)
	if err != nil {
		return 0
	}
	return total
}

func init() {
	session.Register("postgresql", postgresqlpder)
}