Add version 1.0.0

Author: LyricTian

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Golang Session
+Copyright (c) 2018 Lyric
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,2 +1,96 @@
 # redis
-A redis-based session store
+
+> A redis-based session store
+
+[![ReportCard][reportcard-image]][reportcard-url] [![GoDoc][godoc-image]][godoc-url] [![License][license-image]][license-url]
+
+## Quick Start
+
+### Download and install
+
+```bash
+$ go get -u -v gopkg.in/go-session/redis.v1
+```
+
+### Create file `server.go`
+
+```go
+package main
+
+import (
+	"fmt"
+	"net/http"
+
+	"gopkg.in/go-session/redis.v1"
+	"gopkg.in/session.v2"
+)
+
+func main() {
+	session.InitManager(
+		session.SetCookieName("session_id"),
+		session.SetSign([]byte("sign")),
+		session.SetStore(redis.NewRedisStore(&redis.Options{
+			Addr: "127.0.0.1:6379",
+			DB:   15,
+		})),
+	)
+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		store, err := session.Start(w, r)
+		if err != nil {
+			fmt.Fprint(w, err)
+			return
+		}
+
+		store.Set("foo", "bar")
+		err = store.Save()
+		if err != nil {
+			fmt.Fprint(w, err)
+			return
+		}
+
+		http.Redirect(w, r, "/foo", 302)
+	})
+
+	http.HandleFunc("/foo", func(w http.ResponseWriter, r *http.Request) {
+		store, err := session.Start(w, r)
+		if err != nil {
+			fmt.Fprint(w, err)
+			return
+		}
+
+		foo, ok := store.Get("foo")
+		if ok {
+			fmt.Fprintf(w, "foo:%s", foo)
+			return
+		}
+		fmt.Fprint(w, "does not exist")
+	})
+
+	http.ListenAndServe(":8080", nil)
+}
+```
+
+### Build and run
+
+```bash
+$ go build server.go
+$ ./server
+```
+
+### Open in your web browser
+
+<http://localhost:8080>
+
+    foo:bar
+
+## MIT License
+
+    Copyright (c) 2018 Lyric
+
+[reportcard-url]: https://goreportcard.com/report/gopkg.in/go-session/redis.v1
+[reportcard-image]: https://goreportcard.com/badge/gopkg.in/go-session/redis.v1
+[godoc-url]: https://godoc.org/gopkg.in/go-session/redis.v1
+[godoc-image]: https://godoc.org/gopkg.in/go-session/redis.v1?status.svg
+[license-url]: http://opensource.org/licenses/MIT
+[license-image]: https://img.shields.io/npm/l/express.svg

options.go

@@ -0,0 +1,90 @@
+package redis
+
+import (
+	"crypto/tls"
+	"net"
+	"time"
+
+	"github.com/go-redis/redis"
+)
+
+// Options Redis parameter options
+type Options struct {
+	// The network type, either tcp or unix.
+	// Default is tcp.
+	Network string
+	// host:port address.
+	Addr string
+
+	// Dialer creates new network connection and has priority over
+	// Network and Addr options.
+	Dialer func() (net.Conn, error)
+
+	// Optional password. Must match the password specified in the
+	// requirepass server configuration option.
+	Password string
+	// Database to be selected after connecting to the server.
+	DB int
+
+	// Maximum number of retries before giving up.
+	// Default is to not retry failed commands.
+	MaxRetries int
+	// Minimum backoff between each retry.
+	// Default is 8 milliseconds; -1 disables backoff.
+	MinRetryBackoff time.Duration
+	// Maximum backoff between each retry.
+	// Default is 512 milliseconds; -1 disables backoff.
+	MaxRetryBackoff time.Duration
+
+	// Dial timeout for establishing new connections.
+	// Default is 5 seconds.
+	DialTimeout time.Duration
+	// Timeout for socket reads. If reached, commands will fail
+	// with a timeout instead of blocking.
+	// Default is 3 seconds.
+	ReadTimeout time.Duration
+	// Timeout for socket writes. If reached, commands will fail
+	// with a timeout instead of blocking.
+	// Default is ReadTimeout.
+	WriteTimeout time.Duration
+
+	// Maximum number of socket connections.
+	// Default is 10 connections per every CPU as reported by runtime.NumCPU.
+	PoolSize int
+	// Amount of time client waits for connection if all connections
+	// are busy before returning an error.
+	// Default is ReadTimeout + 1 second.
+	PoolTimeout time.Duration
+	// Amount of time after which client closes idle connections.
+	// Should be less than server's timeout.
+	// Default is 5 minutes.
+	IdleTimeout time.Duration
+	// Frequency of idle checks.
+	// Default is 1 minute.
+	// When minus value is set, then idle check is disabled.
+	IdleCheckFrequency time.Duration
+
+	// TLS Config to use. When set TLS will be negotiated.
+	TLSConfig *tls.Config
+}
+
+func (o *Options) redisOptions() *redis.Options {
+	return &redis.Options{
+		Network:            o.Network,
+		Addr:               o.Addr,
+		Dialer:             o.Dialer,
+		Password:           o.Password,
+		DB:                 o.DB,
+		MaxRetries:         o.MaxRetries,
+		MinRetryBackoff:    o.MinRetryBackoff,
+		MaxRetryBackoff:    o.MaxRetryBackoff,
+		DialTimeout:        o.DialTimeout,
+		ReadTimeout:        o.ReadTimeout,
+		WriteTimeout:       o.WriteTimeout,
+		PoolSize:           o.PoolSize,
+		PoolTimeout:        o.PoolTimeout,
+		IdleTimeout:        o.IdleTimeout,
+		IdleCheckFrequency: o.IdleCheckFrequency,
+		TLSConfig:          o.TLSConfig,
+	}
+}

redis.go

@@ -0,0 +1,158 @@
+package redis
+
+import (
+	"encoding/json"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis"
+	"gopkg.in/session.v2"
+)
+
+var (
+	_ session.ManagerStore = &managerStore{}
+	_ session.Store        = &store{}
+)
+
+// NewRedisStore Create an instance of a redis store
+func NewRedisStore(opt *Options) session.ManagerStore {
+	if opt == nil {
+		panic("Option cannot be nil")
+	}
+	return &managerStore{cli: redis.NewClient(opt.redisOptions())}
+}
+
+type managerStore struct {
+	cli *redis.Client
+}
+
+func (s *managerStore) getValue(sid string) (string, error) {
+	cmd := s.cli.Get(sid)
+	if err := cmd.Err(); err != nil {
+		if err == redis.Nil {
+			return "", nil
+		}
+		return "", err
+	}
+
+	return cmd.Val(), nil
+}
+
+func (s *managerStore) parseValue(value string) (map[string]string, error) {
+	var values map[string]string
+
+	if len(value) > 0 {
+		err := json.Unmarshal([]byte(value), &values)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if values == nil {
+		values = make(map[string]string)
+	}
+	return values, nil
+}
+
+func (s *managerStore) Create(sid string, expired int64) (session.Store, error) {
+	values := make(map[string]string)
+	return &store{sid: sid, cli: s.cli, expired: expired, values: values}, nil
+}
+
+func (s *managerStore) Update(sid string, expired int64) (session.Store, error) {
+	value, err := s.getValue(sid)
+	if err != nil {
+		return nil, err
+	} else if value == "" {
+		return s.Create(sid, expired)
+	}
+
+	cmd := s.cli.Set(sid, value, time.Duration(expired)*time.Second)
+	if err = cmd.Err(); err != nil {
+		return nil, err
+	}
+
+	values, err := s.parseValue(value)
+	if err != nil {
+		return nil, err
+	}
+
+	return &store{sid: sid, cli: s.cli, expired: expired, values: values}, nil
+}
+
+func (s *managerStore) Delete(sid string) error {
+	cmd := s.cli.Del(sid)
+	return cmd.Err()
+}
+
+func (s *managerStore) Check(sid string) (bool, error) {
+	cmd := s.cli.Get(sid)
+	if err := cmd.Err(); err != nil {
+		if err == redis.Nil {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
+func (s *managerStore) Close() error {
+	return s.cli.Close()
+}
+
+type store struct {
+	sid     string
+	cli     *redis.Client
+	expired int64
+	values  map[string]string
+	sync.RWMutex
+}
+
+func (s *store) SessionID() string {
+	return s.sid
+}
+
+func (s *store) Set(key, value string) {
+	s.Lock()
+	s.values[key] = value
+	s.Unlock()
+}
+
+func (s *store) Get(key string) (string, bool) {
+	s.RLock()
+	defer s.RUnlock()
+	val, ok := s.values[key]
+	return val, ok
+}
+
+func (s *store) Delete(key string) string {
+	s.RLock()
+	v, ok := s.values[key]
+	s.RUnlock()
+	if ok {
+		s.Lock()
+		delete(s.values, key)
+		s.Unlock()
+	}
+	return v
+}
+
+func (s *store) Flush() {
+	s.Lock()
+	s.values = make(map[string]string)
+	s.Unlock()
+}
+
+func (s *store) Save() error {
+	var value string
+
+	s.RLock()
+	if len(s.values) > 0 {
+		buf, _ := json.Marshal(s.values)
+		value = string(buf)
+	}
+	s.RUnlock()
+
+	cmd := s.cli.Set(s.sid, value, time.Duration(s.expired)*time.Second)
+	return cmd.Err()
+}