You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
328 lines
8.4 KiB
328 lines
8.4 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
"strconv" |
|
"time" |
|
|
|
"go-common/app/service/main/broadcast/model" |
|
"go-common/library/cache/redis" |
|
"go-common/library/log" |
|
) |
|
|
|
const ( |
|
_prefixMidServer = "mid_%d" // mid -> key:server |
|
_prefixKeyServer = "key_%s" // key -> server |
|
_prefixServerOnline = "ol_%s" // server -> online |
|
_keyServers = "servers" |
|
_keyMigrateRooms = "migrate_rooms" |
|
_keyMigrateServers = "migrate_servers" |
|
) |
|
|
|
var ( |
|
_redisExpire = int32(time.Minute * 30 / time.Second) |
|
) |
|
|
|
func keyMidServer(mid int64) string { |
|
return fmt.Sprintf(_prefixMidServer, mid) |
|
} |
|
|
|
func keyKeyServer(key string) string { |
|
return fmt.Sprintf(_prefixKeyServer, key) |
|
} |
|
|
|
func keyServerOnline(key string) string { |
|
return fmt.Sprintf(_prefixServerOnline, key) |
|
} |
|
|
|
// pingRedis check redis connection. |
|
func (d *Dao) pingRedis(c context.Context) (err error) { |
|
conn := d.redis.Get(c) |
|
_, err = conn.Do("SET", "PING", "PONG") |
|
conn.Close() |
|
return |
|
} |
|
|
|
// AddMapping add a mapping. |
|
// Mapping: |
|
// mid -> key_server |
|
// key -> server |
|
func (d *Dao) AddMapping(c context.Context, mid int64, key, server string) (err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
var n = 2 |
|
if mid > 0 { |
|
if err = conn.Send("HSET", keyMidServer(mid), key, server); err != nil { |
|
log.Error("conn.Send(HSET %d,%s,%s) error(%v)", mid, server, key, err) |
|
return |
|
} |
|
if err = conn.Send("EXPIRE", keyMidServer(mid), _redisExpire); err != nil { |
|
log.Error("conn.Send(EXPIRE %d,%s,%s) error(%v)", mid, key, server, err) |
|
return |
|
} |
|
n += 2 |
|
} |
|
if err = conn.Send("SET", keyKeyServer(key), server); err != nil { |
|
log.Error("conn.Send(HSET %d,%s,%s) error(%v)", mid, server, key, err) |
|
return |
|
} |
|
if err = conn.Send("EXPIRE", keyKeyServer(key), _redisExpire); err != nil { |
|
log.Error("conn.Send(EXPIRE %d,%s,%s) error(%v)", mid, key, server, err) |
|
return |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush() error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < n; i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ExpireMapping expire a mapping. |
|
func (d *Dao) ExpireMapping(c context.Context, mid int64, key string) (has bool, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
var n = 1 |
|
if mid > 0 { |
|
if err = conn.Send("EXPIRE", keyMidServer(mid), _redisExpire); err != nil { |
|
log.Error("conn.Send(EXPIRE %d,%s) error(%v)", mid, key, err) |
|
return |
|
} |
|
n++ |
|
} |
|
if err = conn.Send("EXPIRE", keyKeyServer(key), _redisExpire); err != nil { |
|
log.Error("conn.Send(EXPIRE %d,%s) error(%v)", mid, key, err) |
|
return |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush() error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < n; i++ { |
|
if has, err = redis.Bool(conn.Receive()); err != nil { |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// DelMapping del a mapping. |
|
func (d *Dao) DelMapping(c context.Context, mid int64, key, server string) (has bool, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
n := 1 |
|
if mid > 0 { |
|
if err = conn.Send("HDEL", keyMidServer(mid), key); err != nil { |
|
log.Error("conn.Send(HDEL %d,%s,%s) error(%v)", mid, key, server, err) |
|
return |
|
} |
|
n++ |
|
} |
|
if err = conn.Send("DEL", keyKeyServer(key)); err != nil { |
|
log.Error("conn.Send(HDEL %d,%s,%s) error(%v)", mid, key, server, err) |
|
return |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush() error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < n; i++ { |
|
if has, err = redis.Bool(conn.Receive()); err != nil { |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ServersByKeys get a server by key. |
|
func (d *Dao) ServersByKeys(c context.Context, keys []string) (res []string, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
var args []interface{} |
|
for _, key := range keys { |
|
args = append(args, keyKeyServer(key)) |
|
} |
|
if res, err = redis.Strings(conn.Do("MGET", args...)); err != nil { |
|
log.Error("conn.Do(MGET %v) error(%v)", args, err) |
|
} |
|
return |
|
} |
|
|
|
// KeysByMids get a key server by mid. |
|
func (d *Dao) KeysByMids(c context.Context, mids []int64) (ress map[string]string, olMids []int64, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
ress = make(map[string]string) |
|
for _, mid := range mids { |
|
if err = conn.Send("HGETALL", keyMidServer(mid)); err != nil { |
|
log.Error("conn.Do(HGETALL %d) error(%v)", mid, err) |
|
return |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush() error(%v)", err) |
|
return |
|
} |
|
for idx := 0; idx < len(mids); idx++ { |
|
var ( |
|
res map[string]string |
|
) |
|
if res, err = redis.StringMap(conn.Receive()); err != nil { |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
if len(res) > 0 { |
|
olMids = append(olMids, mids[idx]) |
|
} |
|
for k, v := range res { |
|
ress[k] = v |
|
} |
|
} |
|
return |
|
} |
|
|
|
// AddServerOnline add server online. |
|
func (d *Dao) AddServerOnline(c context.Context, server string, sharding int32, online *model.Online) (err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
b, _ := json.Marshal(online) |
|
key := keyServerOnline(server) |
|
if err = conn.Send("HSET", key, strconv.FormatInt(int64(sharding), 10), b); err != nil { |
|
log.Error("conn.Send(SET %s,%d) error(%v)", key, sharding, err) |
|
return |
|
} |
|
if err = conn.Send("EXPIRE", key, _redisExpire); err != nil { |
|
log.Error("conn.Send(EXPIRE %s) error(%v)", key, err) |
|
return |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush() error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < 2; i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ServerOnline get a server online. |
|
func (d *Dao) ServerOnline(c context.Context, server string, shard int) (online *model.Online, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
key := keyServerOnline(server) |
|
hashKey := fmt.Sprint(shard) |
|
b, err := redis.Bytes(conn.Do("HGET", key, hashKey)) |
|
if err != nil { |
|
if err != redis.ErrNil { |
|
log.Error("conn.Do(HGET %s %s) error(%v)", key, hashKey, err) |
|
} else { |
|
err = nil |
|
} |
|
return |
|
} |
|
online = new(model.Online) |
|
if err = json.Unmarshal(b, online); err != nil { |
|
log.Error("serverOnline json.Unmarshal(%s) error(%v)", b, err) |
|
} |
|
return |
|
} |
|
|
|
// DelServerOnline del a server online. |
|
func (d *Dao) DelServerOnline(c context.Context, server string, shard int) (err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
key := keyServerOnline(server) |
|
hashKey := fmt.Sprint(shard) |
|
if _, err = conn.Do("HDEL", key, hashKey); err != nil { |
|
log.Error("conn.Do(DEL %s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// SetServers set servers info. |
|
func (d *Dao) SetServers(c context.Context, srvs []*model.ServerInfo) (err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
b, _ := json.Marshal(srvs) |
|
if _, err = conn.Do("SET", _keyServers, b); err != nil { |
|
log.Error("conn.Do(SET %s,%s) error(%v)", _keyServers, b, err) |
|
} |
|
return |
|
} |
|
|
|
// Servers return servers. |
|
func (d *Dao) Servers(c context.Context) (srvs []*model.ServerInfo, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
b, err := redis.Bytes(conn.Do("GET", _keyServers)) |
|
if err != nil { |
|
if err != redis.ErrNil { |
|
log.Error("conn.Do(GET %s) error(%v)", _keyServers, err) |
|
} else { |
|
err = nil |
|
} |
|
return |
|
} |
|
if err = json.Unmarshal(b, &srvs); err != nil { |
|
log.Error("MigrateServers json.Unmarshal(%s) error(%v)", b, err) |
|
} |
|
return |
|
} |
|
|
|
// MigrateServers migrate servers. |
|
func (d *Dao) MigrateServers(c context.Context) (conns, ips int64, err error) { |
|
var servers struct { |
|
Conns int64 `json:"conn_count"` |
|
IPs int64 `json:"ip_count"` |
|
} |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
b, err := redis.Bytes(conn.Do("GET", _keyMigrateServers)) |
|
if err != nil { |
|
if err != redis.ErrNil { |
|
log.Error("conn.Do(GET %s) error(%v)", _keyMigrateServers, err) |
|
} else { |
|
err = nil |
|
} |
|
return |
|
} |
|
if err = json.Unmarshal(b, &servers); err != nil { |
|
log.Error("MigrateServers json.Unmarshal(%s) error(%v)", b, err) |
|
return |
|
} |
|
conns = servers.Conns |
|
ips = servers.IPs |
|
return |
|
} |
|
|
|
// MigrateRooms migrate rooms. |
|
func (d *Dao) MigrateRooms(c context.Context, shard int) (rooms map[string]int32, err error) { |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
b, err := redis.Bytes(conn.Do("HGET", _keyMigrateRooms, fmt.Sprint(shard))) |
|
if err != nil { |
|
if err != redis.ErrNil { |
|
log.Error("conn.Do(HGET %s,%d) error(%v)", _keyMigrateRooms, shard, err) |
|
} else { |
|
err = nil |
|
} |
|
return |
|
} |
|
rooms = make(map[string]int32) |
|
if err = json.Unmarshal(b, &rooms); err != nil { |
|
log.Error("migrateRooms json.Unmarshal() error(%v)", err) |
|
} |
|
return |
|
}
|
|
|