init

logic/dao/dao.go

@@ -0,0 +1,72 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"github.com/gomodule/redigo/redis"
+	"gitlab.33.cn/chat/im/logic/conf"
+	kafka "gopkg.in/Shopify/sarama.v1"
+)
+
+// Dao dao.
+type Dao struct {
+	c           *conf.Config
+	kafkaPub    kafka.SyncProducer
+	redis       *redis.Pool
+	redisExpire int32
+}
+
+// New new a dao and return.
+func New(c *conf.Config) *Dao {
+	d := &Dao{
+		c:           c,
+		kafkaPub:    newKafkaPub(c.Kafka),
+		redis:       newRedis(c.Redis),
+		redisExpire: int32(time.Duration(c.Redis.Expire) / time.Second),
+	}
+	return d
+}
+
+func newKafkaPub(c *conf.Kafka) kafka.SyncProducer {
+	kc := kafka.NewConfig()
+	kc.Producer.RequiredAcks = kafka.WaitForAll // Wait for all in-sync replicas to ack the message
+	kc.Producer.Retry.Max = 10                  // Retry up to 10 times to produce the message
+	kc.Producer.Return.Successes = true
+	kc.Version = kafka.V0_11_0_2
+	pub, err := kafka.NewSyncProducer(c.Brokers, kc)
+	if err != nil {
+		panic(err)
+	}
+	return pub
+}
+
+func newRedis(c *conf.Redis) *redis.Pool {
+	return &redis.Pool{
+		MaxIdle:     c.Idle,
+		MaxActive:   c.Active,
+		IdleTimeout: time.Duration(c.IdleTimeout),
+		Dial: func() (redis.Conn, error) {
+			conn, err := redis.Dial(c.Network, c.Addr,
+				redis.DialConnectTimeout(time.Duration(c.DialTimeout)),
+				redis.DialReadTimeout(time.Duration(c.ReadTimeout)),
+				redis.DialWriteTimeout(time.Duration(c.WriteTimeout)),
+				redis.DialPassword(c.Auth),
+			)
+			if err != nil {
+				return nil, err
+			}
+			return conn, nil
+		},
+	}
+}
+
+// Close close the resource.
+func (d *Dao) Close() error {
+	return d.redis.Close()
+}
+
+// Ping dao ping.
+func (d *Dao) Ping(c context.Context) error {
+	return d.pingRedis(c)
+}

logic/dao/kafka.go

@@ -0,0 +1,44 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"github.com/opentracing/opentracing-go"
+	"gitlab.33.cn/chat/im-pkg/trace"
+	comet "gitlab.33.cn/chat/im/api/comet/grpc"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/rs/zerolog/log"
+	pb "gitlab.33.cn/chat/im/api/logic/grpc"
+	"gopkg.in/Shopify/sarama.v1"
+)
+
+// PushMsg push a message to databus.
+func (d *Dao) PublishMsg(ctx context.Context, appId string, fromId string, op comet.Op, key string, msg []byte) (err error) {
+	tracer := opentracing.GlobalTracer()
+	span, ctx := opentracing.StartSpanFromContextWithTracer(ctx, tracer, fmt.Sprintf("Publish -%v-%v", appId, op.String()))
+	defer span.Finish()
+
+	pushMsg := &pb.BizMsg{
+		AppId:  appId,
+		FromId: fromId,
+		Op:     int32(op),
+		Key:    key,
+		Msg:    msg,
+	}
+	b, err := proto.Marshal(pushMsg)
+	if err != nil {
+		return
+	}
+	appTopic := fmt.Sprintf("goim-%s-topic", appId)
+	m := &sarama.ProducerMessage{
+		Key:   sarama.StringEncoder(fromId),
+		Topic: appTopic,
+		Value: sarama.ByteEncoder(b),
+	}
+	trace.InjectMQHeader(tracer, span.Context(), ctx, m)
+	if _, _, err = d.kafkaPub.SendMessage(m); err != nil {
+		log.Error().Interface("pushMsg", pushMsg).Err(err).Msg("kafkaPub.SendMessage error")
+	}
+	return
+}

logic/dao/main_test.go

@@ -0,0 +1,32 @@
+package dao
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	xtime "github.com/Terry-Mao/goim/pkg/time"
+	"github.com/gomodule/redigo/redis"
+	"gitlab.33.cn/chat/im/logic/conf"
+)
+
+var (
+	testConf  *conf.Config
+	testRedis *redis.Pool
+)
+
+func TestMain(m *testing.M) {
+	testRedis = newRedis(&conf.Redis{
+		Network:      "tcp",
+		Addr:         "127.0.0.1:6379",
+		Auth:         "",
+		Active:       60000,
+		Idle:         1024,
+		DialTimeout:  xtime.Duration(200 * time.Millisecond),
+		ReadTimeout:  xtime.Duration(500 * time.Millisecond),
+		WriteTimeout: xtime.Duration(500 * time.Millisecond),
+		IdleTimeout:  xtime.Duration(120 * time.Second),
+		Expire:       xtime.Duration(30 * time.Minute),
+	})
+	os.Exit(m.Run())
+}

logic/dao/redis.go

@@ -0,0 +1,300 @@
+package dao
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/gomodule/redigo/redis"
+	"github.com/rs/zerolog/log"
+)
+
+const (
+	MidFmt             = "%s:%v"       // {appId}:{uid}
+	_prefixMidServer   = "mid_%s:%v"   // mid_{appId}:{uid} -> key:server
+	_prefixKeyServer   = "key_%s"      // key_{key} -> server
+	_prefixKeyUser     = "usr_%s"      // usr_{key} -> {appId}:{uid}
+	_prefixGroupServer = "group_%s:%s" // group_{appId}:{gid} -> {server}:{score}
+)
+
+func keyMidServer(appId string, mid string) string {
+	return fmt.Sprintf(_prefixMidServer, appId, mid)
+}
+
+func keyKeyServer(key string) string {
+	return fmt.Sprintf(_prefixKeyServer, key)
+}
+
+func keyKeyUser(key string) string {
+	return fmt.Sprintf(_prefixKeyUser, key)
+}
+
+func keyGroupServer(appId, gid string) string {
+	return fmt.Sprintf(_prefixGroupServer, appId, gid)
+}
+
+func (d *Dao) pingRedis(c context.Context) (err error) {
+	conn := d.redis.Get()
+	_, err = conn.Do("SET", "PING", "PONG")
+	conn.Close()
+	return
+}
+
+func (d *Dao) GetMember(c context.Context, key string) (appId string, mid string, err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	ss, err := redis.String(conn.Do("GET", keyKeyUser(key)))
+	if err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.DO(GET)")
+		return "", "", err
+	}
+	arr := strings.Split(ss, ":")
+	if len(arr) != 2 {
+		return "", "", errors.New("invalid key")
+	}
+	appId = arr[0]
+	mid = arr[1]
+	return
+}
+
+func (d *Dao) GetServer(c context.Context, key string) (server string, err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	if server, err = redis.String(conn.Do("GET", keyKeyServer(key))); err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.DO(GET)")
+	}
+	return
+}
+
+func (d *Dao) AddMapping(c context.Context, mid string, appId string, key string, server string) (err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	var n = 4
+	if mid != "" {
+		if err = conn.Send("HSET", keyMidServer(appId, mid), key, server); err != nil {
+			log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(HSET %s,%s,%s,%s) error", appId, mid, server, key))
+			return
+		}
+		if err = conn.Send("EXPIRE", keyMidServer(appId, mid), d.redisExpire); err != nil {
+			log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s,%s,%s,%s)", appId, mid, key, server))
+			return
+		}
+		n += 2
+	}
+	if err = conn.Send("SET", keyKeyServer(key), server); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(HSET %s,%s,%s) error", mid, server, key))
+		return
+	}
+	if err = conn.Send("EXPIRE", keyKeyServer(key), d.redisExpire); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s,%s,%s) error", mid, key, server))
+		return
+	}
+	user := fmt.Sprintf(MidFmt, appId, mid)
+	if err = conn.Send("SET", keyKeyUser(key), user); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(HSET %s,%s,%s) error", mid, appId, key))
+		return
+	}
+	if err = conn.Send("EXPIRE", keyKeyUser(key), d.redisExpire); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s,%s,%s) error", mid, appId, key))
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.Flush() error")
+		return
+	}
+	for i := 0; i < n; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error().Str("key", key).Err(err).Msg("conn.Receive() error")
+			return
+		}
+	}
+	return
+}
+
+// ExpireMapping expire a mapping.
+func (d *Dao) ExpireMapping(c context.Context, mid string, appId string, key string) (has bool, err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	var n = 2
+	if mid != "" {
+		if err = conn.Send("EXPIRE", keyMidServer(appId, mid), d.redisExpire); err != nil {
+			log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s) error", keyMidServer(appId, mid)))
+			return
+		}
+		n++
+	}
+	if err = conn.Send("EXPIRE", keyKeyServer(key), d.redisExpire); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s) error", keyKeyServer(key)))
+		return
+	}
+	if err = conn.Send("EXPIRE", keyKeyUser(key), d.redisExpire); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s) error", keyKeyServer(key)))
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.Flush() error")
+		return
+	}
+	for i := 0; i < n; i++ {
+		if has, err = redis.Bool(conn.Receive()); err != nil {
+			log.Error().Str("key", key).Err(err).Msg("conn.Receive() error")
+			return
+		}
+	}
+	return
+}
+
+func (d *Dao) DelMapping(c context.Context, mid string, appId string, key string) (has bool, err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	var n = 2
+	if mid != "" {
+		if err = conn.Send("HDEL", keyMidServer(appId, mid), key); err != nil {
+			log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(HDEL %s) error", keyMidServer(appId, mid)))
+			return
+		}
+		n++
+	}
+	if err = conn.Send("DEL", keyKeyServer(key)); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(DEL %s) error", keyKeyServer(key)))
+		return
+	}
+	if err = conn.Send("DEL", keyKeyUser(key)); err != nil {
+		log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(DEL %s) error", keyKeyUser(key)))
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.Flush() error")
+		return
+	}
+	for i := 0; i < n; i++ {
+		if has, err = redis.Bool(conn.Receive()); err != nil {
+			log.Error().Str("key", key).Err(err).Msg("conn.Receive() error")
+			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()
+	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().Err(err).Msg(fmt.Sprintf("conn.Do(MGET %v) error", args))
+	}
+	return
+}
+
+// KeysByMids get a key server by mid.
+func (d *Dao) KeysByMids(c context.Context, appId string, mids []string) (ress map[string]string, olMids []string, err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	ress = make(map[string]string)
+	for _, mid := range mids {
+		if err = conn.Send("HGETALL", keyMidServer(appId, mid)); err != nil {
+			log.Error().Err(err).Msg(fmt.Sprintf("conn.Do(HGETALL %s) error", mid))
+			return
+		}
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error().Err(err).Msg("conn.Flush() error")
+		return
+	}
+	for idx := 0; idx < len(mids); idx++ {
+		var (
+			res map[string]string
+		)
+		if res, err = redis.StringMap(conn.Receive()); err != nil {
+			log.Error().Err(err).Msg("conn.Receive() error")
+			return
+		}
+		if len(res) > 0 {
+			olMids = append(olMids, mids[idx])
+		}
+		for k, v := range res {
+			ress[k] = v
+		}
+	}
+	return
+}
+
+//groups
+func (d *Dao) IncGroupServer(c context.Context, appId, key, server string, gid []string) (err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	var n = 0
+	for _, g := range gid {
+		if err = conn.Send("ZINCRBY", keyGroupServer(appId, g), "1", server); err != nil {
+			log.Error().Str("key", key).Err(err).Msg(
+				fmt.Sprintf("conn.Send(ZINCRBY %s,%s,%s) error", keyGroupServer(appId, g), "1", server))
+			return
+		}
+		//if err = conn.Send("EXPIRE", keyGroupServer(appId, g), d.redisExpire); err != nil {
+		//	log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s,%s,%s,%s)", appId, mid, key, server))
+		//	return
+		//}
+		n++
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.Flush() error")
+		return
+	}
+	for i := 0; i < n; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error().Str("key", key).Err(err).Msg("conn.Receive() error")
+			return
+		}
+	}
+	return
+}
+
+func (d *Dao) DecGroupServer(c context.Context, appId, key, server string, gid []string) (err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	var n = 0
+	for _, g := range gid {
+		if err = conn.Send("ZINCRBY", keyGroupServer(appId, g), "-1", server); err != nil {
+			log.Error().Str("key", key).Err(err).Msg(
+				fmt.Sprintf("conn.Send(ZINCRBY %s,%s,%s) error", keyGroupServer(appId, g), "-1", server))
+			return
+		}
+		//if err = conn.Send("EXPIRE", keyGroupServer(appId, g), d.redisExpire); err != nil {
+		//	log.Error().Str("key", key).Err(err).Msg(fmt.Sprintf("conn.Send(EXPIRE %s,%s,%s,%s)", appId, mid, key, server))
+		//	return
+		//}
+		n++
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error().Str("key", key).Err(err).Msg("conn.Flush() error")
+		return
+	}
+	for i := 0; i < n; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error().Str("key", key).Err(err).Msg("conn.Receive() error")
+			return
+		}
+	}
+	return
+}
+
+// KeysByMids get a key server by mid.
+func (d *Dao) ServersByGid(c context.Context, appId string, gid string) (res []string, err error) {
+	conn := d.redis.Get()
+	defer conn.Close()
+	res = make([]string, 0)
+	ress := make(map[string]string)
+	if ress, err = redis.StringMap(conn.Do("ZRANGE", keyGroupServer(appId, gid), "0", "-1", "WITHSCORES")); err != nil {
+		log.Error().Str("appId", appId).Str("gid", gid).Err(err).Msg(
+			fmt.Sprintf("conn.DO(ZRANGE %s,%s,%s,%s) error", keyGroupServer(appId, gid), "0", "-1", "WITHSCORES"))
+	}
+	for k, _ := range ress {
+		res = append(res, k)
+	}
+	return
+}

logic/dao/redis_test.go

@@ -0,0 +1,231 @@
+package dao
+
+import (
+	"context"
+	"github.com/gomodule/redigo/redis"
+	"gopkg.in/Shopify/sarama.v1"
+	"testing"
+
+	"gitlab.33.cn/chat/im/logic/conf"
+)
+
+func TestDao_IncGroupServer(t *testing.T) {
+	type fields struct {
+		c           *conf.Config
+		kafkaPub    sarama.SyncProducer
+		redis       *redis.Pool
+		redisExpire int32
+	}
+	type args struct {
+		c      context.Context
+		appId  string
+		key    string
+		server string
+		gid    []string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "",
+			fields: fields{
+				c:           testConf,
+				kafkaPub:    nil,
+				redis:       testRedis,
+				redisExpire: 0,
+			},
+			args: args{
+				c:      nil,
+				appId:  "dtalk",
+				key:    "1",
+				server: "grpc://172.0.0.1:8080",
+				gid:    []string{"1"},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				c:           tt.fields.c,
+				kafkaPub:    tt.fields.kafkaPub,
+				redis:       tt.fields.redis,
+				redisExpire: tt.fields.redisExpire,
+			}
+			if err := d.IncGroupServer(tt.args.c, tt.args.appId, tt.args.key, tt.args.server, tt.args.gid); (err != nil) != tt.wantErr {
+				t.Errorf("IncGroupServer() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDao_DecGroupServer(t *testing.T) {
+	type fields struct {
+		c           *conf.Config
+		kafkaPub    sarama.SyncProducer
+		redis       *redis.Pool
+		redisExpire int32
+	}
+	type args struct {
+		c      context.Context
+		appId  string
+		key    string
+		server string
+		gid    []string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "",
+			fields: fields{
+				c:           testConf,
+				kafkaPub:    nil,
+				redis:       testRedis,
+				redisExpire: 0,
+			},
+			args: args{
+				c:      nil,
+				appId:  "dtalk",
+				key:    "1",
+				server: "grpc://172.0.0.1:8080",
+				gid:    []string{"1"},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				c:           tt.fields.c,
+				kafkaPub:    tt.fields.kafkaPub,
+				redis:       tt.fields.redis,
+				redisExpire: tt.fields.redisExpire,
+			}
+			if err := d.DecGroupServer(tt.args.c, tt.args.appId, tt.args.key, tt.args.server, tt.args.gid); (err != nil) != tt.wantErr {
+				t.Errorf("IncGroupServer() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDao_ServersByGid(t *testing.T) {
+	type fields struct {
+		c           *conf.Config
+		kafkaPub    sarama.SyncProducer
+		redis       *redis.Pool
+		redisExpire int32
+	}
+	type args struct {
+		c     context.Context
+		appId string
+		gid   string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantRes []string
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "",
+			fields: fields{
+				c:           nil,
+				kafkaPub:    nil,
+				redis:       testRedis,
+				redisExpire: 0,
+			},
+			args: args{
+				c:     nil,
+				appId: "dtalk",
+				gid:   "1",
+			},
+			wantRes: nil,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				c:           tt.fields.c,
+				kafkaPub:    tt.fields.kafkaPub,
+				redis:       tt.fields.redis,
+				redisExpire: tt.fields.redisExpire,
+			}
+			gotRes, err := d.ServersByGid(tt.args.c, tt.args.appId, tt.args.gid)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ServersByGid() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			for i, re := range gotRes {
+				t.Logf("got %v:%v\n", i, re)
+			}
+		})
+	}
+}
+
+func TestDao_KeysByMids(t *testing.T) {
+	type fields struct {
+		c           *conf.Config
+		kafkaPub    sarama.SyncProducer
+		redis       *redis.Pool
+		redisExpire int32
+	}
+	type args struct {
+		c     context.Context
+		appId string
+		mids  []string
+	}
+	tests := []struct {
+		name       string
+		fields     fields
+		args       args
+		wantRess   map[string]string
+		wantOlMids []string
+		wantErr    bool
+	}{
+		{
+			name: "",
+			fields: fields{
+				c:           testConf,
+				kafkaPub:    nil,
+				redis:       testRedis,
+				redisExpire: 0,
+			},
+			args: args{
+				c:     context.Background(),
+				appId: "dtalk",
+				mids:  []string{"1ygj6Un2UzL2rev6ub6NukWrGcKjW8LoG", "1LNaxM1BtkkRpWEGty8bDxmvWwRwxsCy1B", "14si8HGSBKN2B4Ps7QQJeRLvqWoXHX2NwB", ""},
+			},
+			wantRess:   nil,
+			wantOlMids: nil,
+			wantErr:    false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Dao{
+				c:           tt.fields.c,
+				kafkaPub:    tt.fields.kafkaPub,
+				redis:       tt.fields.redis,
+				redisExpire: tt.fields.redisExpire,
+			}
+			gotRess, gotOlMids, err := d.KeysByMids(tt.args.c, tt.args.appId, tt.args.mids)
+			if err != nil {
+				t.Error(err)
+			}
+			t.Log(gotRess)
+			t.Log(gotOlMids)
+		})
+	}
+}