1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package redis
import (
"fmt"
"github.com/beego/beego/v2/core/logs"
beego "github.com/beego/beego/v2/server/web"
"github.com/google/uuid"
"gopkg.in/redis.v5"
"strconv"
"strings"
"time"
)
var redisCache *redis.Client
func init() {
//return
host, _ := beego.AppConfig.String("tokenhost")
db, _ := beego.AppConfig.Int("tokendb")
pass, _ := beego.AppConfig.String("tokenpass")
redisCache = createClient(host, pass, db)
}
func createClient(redisHost string, password string, dataBase int) *redis.Client {
client := redis.NewClient(&redis.Options{
Addr: redisHost,
Password: password,
DB: dataBase,
})
_, err := client.Ping().Result()
if err != nil {
logs.Error("连接失败,", err)
panic(err.Error())
}
return client
}
func tryAcquire(rs *redis.Client, lockKey string, lockTimeout time.Duration) (acquired bool, release func(), _ error) {
timeout := time.Now().Add(lockTimeout).UnixNano()
lockToken := fmt.Sprintf("%d,%s", timeout, uuid.New().String())
release = func() {
// Best effort to check we're releasing the lock we think we have. Note that it
// is still technically possible the lock token has changed between the GET and
// DEL since these are two separate operations, i.e. when the current lock happen
// to be expired at this very moment.
get, _ := rs.Get(lockKey).Result()
if get == lockToken {
_ = rs.Del(lockKey)
}
}
set, err := rs.SetNX(lockKey, lockToken, lockTimeout).Result()
if err != nil {
return false, nil, err
} else if set {
return true, release, nil
}
// We didn't get the lock, but we can check if the lock is expired.
currentLockToken, err := rs.Get(lockKey).Result()
if err == redis.Nil {
// Someone else got the lock and released it already.
return false, nil, nil
} else if err != nil {
return false, nil, err
}
currentTimeout, _ := strconv.ParseInt(strings.SplitN(currentLockToken, ",", 2)[0], 10, 64)
if currentTimeout > time.Now().UnixNano() {
// The lock is still valid.
return false, nil, nil
}
// The lock has expired, try to acquire it.
get, err := rs.GetSet(lockKey, lockToken).Result()
if err != nil {
return false, nil, err
} else if get != currentLockToken {
// Someone else got the lock
return false, nil, nil
}
// We got the lock.
return true, release, nil
}
func SetHeat(key string, value interface{}, time time.Duration) {
}
func SetKeyAndData(key string, value interface{}, time time.Duration) error {
err := redisCache.Set(key, value, time).Err()
if err != nil {
logs.Error("set key:", key, ",value:", value, err)
return err
}
return nil
}
func GetDataToString(key string) (string, error) {
v, err := redisCache.Get(key).Result()
if err != nil {
return "", err
}
return v, nil
}
func GetDataToBytes(key string) ([]byte, error) {
v, err := redisCache.Get(key).Bytes()
if err != nil {
return nil, err
}
return v, nil
}
func DeleteKey(key string) error {
err := redisCache.Del(key).Err()
return err
}