https://github.com/pete911/examples-redigo
golang redigo examples
https://github.com/pete911/examples-redigo
go golang redigo redis
Last synced: over 1 year ago
JSON representation
golang redigo examples
- Host: GitHub
- URL: https://github.com/pete911/examples-redigo
- Owner: pete911
- Created: 2016-11-16T10:23:01.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2020-12-07T18:23:50.000Z (over 5 years ago)
- Last Synced: 2025-03-16T01:11:22.810Z (over 1 year ago)
- Topics: go, golang, redigo, redis
- Size: 3.91 KB
- Stars: 86
- Watchers: 4
- Forks: 12
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# examples-redigo
Examples on using redigo library. First file contains initialized redis pool
that is stored in `Pool` variable. Pool connects by default `localhost:6379`.
This can be changed by passing `REDIS_HOST` environment variable.
**redis/pool.go** file
```go
package redis
import (
"github.com/gomodule/redigo/redis"
"os"
"os/signal"
"syscall"
"time"
)
var (
Pool *redis.Pool
)
func init() {
redisHost := os.Getenv("REDIS_HOST")
if redisHost == "" {
redisHost = ":6379"
}
Pool = newPool(redisHost)
cleanupHook()
}
func newPool(server string) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", server)
if err != nil {
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
}
func cleanupHook() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
signal.Notify(c, syscall.SIGKILL)
go func() {
<-c
Pool.Close()
os.Exit(0)
}()
}
```
Util file provides basic (most common) redis operations. This is supposed to be
an example not full list of all operations.
**redis/util.go** file
```go
package redis
import (
"fmt"
"github.com/gomodule/redigo/redis"
)
func Ping() error {
conn := Pool.Get()
defer conn.Close()
_, err := redis.String(conn.Do("PING"))
if err != nil {
return fmt.Errorf("cannot 'PING' db: %v", err)
}
return nil
}
func Get(key string) ([]byte, error) {
conn := Pool.Get()
defer conn.Close()
var data []byte
data, err := redis.Bytes(conn.Do("GET", key))
if err != nil {
return data, fmt.Errorf("error getting key %s: %v", key, err)
}
return data, err
}
func Set(key string, value []byte) error {
conn := Pool.Get()
defer conn.Close()
_, err := conn.Do("SET", key, value)
if err != nil {
v := string(value)
if len(v) > 15 {
v = v[0:12] + "..."
}
return fmt.Errorf("error setting key %s to %s: %v", key, v, err)
}
return err
}
func Exists(key string) (bool, error) {
conn := Pool.Get()
defer conn.Close()
ok, err := redis.Bool(conn.Do("EXISTS", key))
if err != nil {
return ok, fmt.Errorf("error checking if key %s exists: %v", key, err)
}
return ok, err
}
func Delete(key string) error {
conn := Pool.Get()
defer conn.Close()
_, err := conn.Do("DEL", key)
return err
}
func GetKeys(pattern string) ([]string, error) {
conn := Pool.Get()
defer conn.Close()
iter := 0
keys := []string{}
for {
arr, err := redis.Values(conn.Do("SCAN", iter, "MATCH", pattern))
if err != nil {
return keys, fmt.Errorf("error retrieving '%s' keys", pattern)
}
iter, _ = redis.Int(arr[0], nil)
k, _ := redis.Strings(arr[1], nil)
keys = append(keys, k...)
if iter == 0 {
break
}
}
return keys, nil
}
func Incr(counterKey string) (int, error) {
conn := Pool.Get()
defer conn.Close()
return redis.Int(conn.Do("INCR", counterKey))
}
```