Create & Init Project...

app/service/live/xroom/internal/dao/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/service/live/xroom/internal/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xroom/internal/dao/dao.go

@@ -0,0 +1,92 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/database/sql"
+)
+
+// Dao dao.
+type Dao struct {
+	db          *sql.DB
+	redis       *redis.Pool
+	redisExpire int32
+	mc          *memcache.Pool
+	mcExpire    int32
+}
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+// New new a dao and return.
+func New() (dao *Dao) {
+	var (
+	// dc struct {
+	// 	Demo *sql.Config
+	// }
+	// rc struct {
+	// 	Demo       *redis.Config
+	// 	DemoExpire xtime.Duration
+	// }
+	// mc struct {
+	// 	Demo       *memcache.Config
+	// 	DemoExpire xtime.Duration
+	// }
+	)
+	// checkErr(paladin.Get("mysql.toml").UnmarshalTOML(&dc))
+	// checkErr(paladin.Get("redis.toml").UnmarshalTOML(&rc))
+	// checkErr(paladin.Get("memcache.toml").UnmarshalTOML(&mc))
+	dao = &Dao{
+		// // mysql
+		// db: sql.NewMySQL(dc.Demo),
+		// // redis
+		// redis:       redis.NewPool(rc.Demo),
+		// redisExpire: int32(time.Duration(rc.DemoExpire) / time.Second),
+		// // memcache
+		// mc:       memcache.NewPool(mc.Demo),
+		// mcExpire: int32(time.Duration(mc.DemoExpire) / time.Second),
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	// d.mc.Close()
+	// d.redis.Close()
+	// d.db.Close()
+}
+
+// Ping ping the resource.
+func (d *Dao) Ping(ctx context.Context) (err error) {
+	// if err = d.pingMC(ctx); err != nil {
+	// 	return
+	// }
+	// if err = d.pingRedis(ctx); err != nil {
+	// 	return
+	// }
+	// return d.db.Ping(ctx)
+	return nil
+}
+
+// func (d *Dao) pingMC(ctx context.Context) (err error) {
+// 	conn := d.mc.Get(ctx)
+// 	defer conn.Close()
+// 	if err = conn.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0}); err != nil {
+// 		log.Error("conn.Set(PING) error(%v)", err)
+// 	}
+// 	return
+// }
+
+// func (d *Dao) pingRedis(ctx context.Context) (err error) {
+// 	conn := d.redis.Get(ctx)
+// 	defer conn.Close()
+// 	if _, err = conn.Do("SET", "ping", "pong"); err != nil {
+// 		log.Error("conn.Set(PING) error(%v)", err)
+// 	}
+// 	return
+// }

app/service/live/xroom/internal/model/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["model.go"],
+    importpath = "go-common/app/service/live/xroom/internal/model",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xroom/internal/model/model.go

@@ -0,0 +1 @@
+package model

app/service/live/xroom/internal/server/grpc/BUILD

@@ -0,0 +1,34 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["server.go"],
+    importpath = "go-common/app/service/live/xroom/internal/server/grpc",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xroom/api:go_default_library",
+        "//app/service/live/xroom/internal/service:go_default_library",
+        "//library/conf/paladin:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xroom/internal/server/grpc/server.go

@@ -0,0 +1,27 @@
+package grpc
+
+import (
+	pb "go-common/app/service/live/xroom/api"
+	"go-common/app/service/live/xroom/internal/service"
+	"go-common/library/conf/paladin"
+	"go-common/library/net/rpc/warden"
+)
+
+// New new a grpc server.
+func New(svc *service.Service) *warden.Server {
+	var rc struct {
+		Server *warden.ServerConfig
+	}
+	if err := paladin.Get("grpc.toml").UnmarshalTOML(&rc); err != nil {
+		if err != paladin.ErrNotExist {
+			panic(err)
+		}
+	}
+	ws := warden.NewServer(rc.Server)
+	pb.RegisterRoomServer(ws.Server(), svc)
+	ws, err := ws.Start()
+	if err != nil {
+		panic(err)
+	}
+	return ws
+}

app/service/live/xroom/internal/server/http/BUILD

@@ -0,0 +1,35 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["http.go"],
+    importpath = "go-common/app/service/live/xroom/internal/server/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xroom/internal/service:go_default_library",
+        "//library/conf/paladin:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/middleware/verify:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xroom/internal/server/http/http.go

@@ -0,0 +1,61 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/service/live/xroom/internal/service"
+	"go-common/library/conf/paladin"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/verify"
+)
+
+var (
+	svc *service.Service
+)
+
+// New new a bm server.
+func New(s *service.Service) (engine *bm.Engine) {
+	var (
+		hc struct {
+			Server *bm.ServerConfig
+		}
+	)
+	if err := paladin.Get("http.toml").UnmarshalTOML(&hc); err != nil {
+		if err != paladin.ErrNotExist {
+			panic(err)
+		}
+	}
+	svc = s
+	engine = bm.DefaultServer(hc.Server)
+	initRouter(engine, verify.New(nil))
+	if err := engine.Start(); err != nil {
+		panic(err)
+	}
+	return
+}
+
+func initRouter(e *bm.Engine, v *verify.Verify) {
+	e.Ping(ping)
+	e.Register(register)
+	g := e.Group("/x/xroom")
+	{
+		g.GET("/start", v.Verify, howToStart)
+	}
+}
+
+func ping(ctx *bm.Context) {
+	if err := svc.Ping(ctx); err != nil {
+		log.Error("ping error(%v)", err)
+		ctx.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}
+
+// example for http request handler.
+func howToStart(c *bm.Context) {
+	c.String(0, "Golang 大法好 !!!")
+}

app/service/live/xroom/internal/service/BUILD

@@ -0,0 +1,40 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "room.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/service/live/xroom/internal/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/dao-anchor/api/grpc/v1:go_default_library",
+        "//app/service/live/xroom/api:go_default_library",
+        "//app/service/live/xroom/internal/dao:go_default_library",
+        "//library/conf/paladin:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xroom/internal/service/room.go

@@ -0,0 +1,222 @@
+package service
+
+import (
+	"context"
+
+	dav1 "go-common/app/service/live/dao-anchor/api/grpc/v1"
+	pb "go-common/app/service/live/xroom/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+type fieldInfo struct {
+	fields []string
+	attrs  map[string]bool
+}
+
+// Model维度Model定义
+var (
+	attrsMap = map[string][]string{
+		"status": {"live_status", "live_screen_type", "live_mark", "lock_time", "lock_status", "hidden_status", "hidden_time", "live_type"},
+		"show":   {"short_id", "title", "cover", "tags", "background", "description", "keyframe", "popularity_count", "tag_list", "live_start_time"},
+		"area":   {"area_id", "area_name", "parent_area_id", "parent_area_name"},
+		"anchor": {"anchor_profile_type", "anchor_data"},
+	}
+)
+
+// GetMultiple implementation
+// 批量根据room_ids获取房间信息
+func (s *Service) GetMultiple(ctx context.Context, req *pb.RoomIDsReq) (resp *pb.RoomIDsInfosResp, err error) {
+	resp = &pb.RoomIDsInfosResp{
+		List: map[int64]*pb.Infos{},
+	}
+
+	var fi *fieldInfo
+	if fi, err = attrsProcess(req.Attrs); err != nil {
+		return
+	}
+
+	freq := &dav1.RoomByIDsReq{
+		RoomIds:       req.RoomIds,
+		Fields:        fi.fields,
+		DefaultFields: 0,
+	}
+
+	fresp, ferr := s.daClient.FetchRoomByIDs(ctx, freq)
+	if ferr != nil {
+		log.Error("[GetMultiple]FetchRoomByIDs from dao-anchor err:%+v", ferr.Error())
+		return nil, ferr
+	}
+
+	for k, v := range fresp.RoomDataSet {
+		resp.List[k] = infoSet(v, len(req.RoomIds), fi.attrs)
+	}
+
+	return resp, nil
+}
+
+// GetMultipleByUids implementation
+// 批量根据uids获取房间信息
+func (s *Service) GetMultipleByUids(ctx context.Context, req *pb.UIDsReq) (resp *pb.UIDsInfosResp, err error) {
+	resp = &pb.UIDsInfosResp{
+		List: map[int64]*pb.Infos{},
+	}
+
+	var fi *fieldInfo
+	if fi, err = attrsProcess(req.Attrs); err != nil {
+		return
+	}
+
+	freq := &dav1.RoomByIDsReq{
+		Uids:          req.Uids,
+		Fields:        fi.fields,
+		DefaultFields: 0,
+	}
+
+	fresp, ferr := s.daClient.FetchRoomByIDs(ctx, freq)
+	if ferr != nil {
+		log.Error("[GetMultipleByUids]FetchRoomByIDs from dao-anchor err:%+v", ferr.Error())
+		return resp, ferr
+	}
+
+	for _, v := range fresp.RoomDataSet {
+		resp.List[v.Uid] = infoSet(v, len(req.Uids), fi.attrs)
+	}
+	return
+}
+
+// IsAnchor implementation
+// 批量根据uids判断是否是主播，如果是返回主播的room_id，否则返回0
+func (s *Service) IsAnchor(ctx context.Context, req *pb.IsAnchorUIDsReq) (resp *pb.IsAnchorUIDsResp, err error) {
+	resp = &pb.IsAnchorUIDsResp{
+		List: map[int64]int64{},
+	}
+
+	freq := &dav1.RoomByIDsReq{
+		Uids:          req.Uids,
+		Fields:        []string{"room_id", "uid"},
+		DefaultFields: 1,
+	}
+
+	fresp, ferr := s.daClient.FetchRoomByIDs(ctx, freq)
+	if ferr != nil {
+		log.Error("[IsAnchor] FetchRoomByIDs from dao-anchor err:%+v]", ferr.Error())
+		return resp, ferr
+	}
+
+	uidMap := make(map[int64]int64)
+	for _, v := range fresp.RoomDataSet {
+		uidMap[v.Uid] = v.RoomId
+	}
+
+	for _, v := range req.Uids {
+		if roomID, ok := uidMap[v]; ok {
+			resp.List[v] = roomID
+			continue
+		}
+		resp.List[v] = 0
+	}
+	return
+}
+
+func attrsProcess(attrs []string) (fi *fieldInfo, err error) {
+	fi = &fieldInfo{
+		fields: []string{},
+		attrs:  map[string]bool{},
+	}
+
+	tidyFields := make([]string, 0)
+	fieldsExistMap := make(map[string]bool)
+
+	for _, dimension := range attrs {
+		if fields, ok := attrsMap[dimension]; ok {
+			for _, field := range fields {
+				if _, exist := fieldsExistMap[field]; !exist {
+					tidyFields = append(tidyFields, field)
+					fieldsExistMap[field] = true
+				}
+			}
+			fi.attrs[dimension] = true
+		}
+	}
+
+	if len(tidyFields) == 0 {
+		return nil, ecode.Error(-400, "attrs error value")
+	}
+	fi.fields = tidyFields
+
+	return fi, nil
+}
+
+func tagList(tag []*dav1.TagData, len int) (pbTags []*pb.TagData) {
+	pbTags = make([]*pb.TagData, 0, len)
+	for k, v := range tag {
+		pbTags[k] = &pb.TagData{
+			TagId:    v.GetTagId(),
+			TagSubId: v.GetTagSubId(),
+			TagValue: v.GetTagValue(),
+			TagExt:   v.GetTagExt(),
+		}
+	}
+	return nil
+}
+
+func infoSet(rs *dav1.RoomData, len int, attrs map[string]bool) (info *pb.Infos) {
+	infos := &pb.Infos{
+		RoomId: rs.GetRoomId(),
+		Uid:    rs.GetUid(),
+	}
+
+	if attrs["status"] {
+		infos.Status = &pb.RoomStatusInfo{
+			LiveStatus:     rs.GetLiveStatus(),
+			LiveScreenType: rs.GetLiveScreenType(),
+			LiveMark:       rs.GetLiveMark(),
+			LockTime:       rs.GetLockTime(),
+			LockStatus:     rs.GetLockStatus(),
+			HiddenStatus:   rs.GetHiddenStatus(),
+			HiddenTime:     rs.GetHiddenTime(),
+			LiveType:       rs.GetLiveType(),
+		}
+	}
+
+	if attrs["show"] {
+		infos.Show = &pb.RoomShowInfo{
+			ShortId:         rs.GetShortId(),
+			Title:           rs.GetTitle(),
+			Cover:           rs.GetCover(),
+			Tags:            rs.GetTags(),
+			Background:      rs.GetBackground(),
+			Description:     rs.GetDescription(),
+			Keyframe:        rs.GetKeyframe(),
+			PopularityCount: rs.GetPopularityCount(),
+			TagList:         tagList(rs.GetTagList(), len),
+			LiveStartTime:   rs.GetLiveStartTime(),
+		}
+	}
+
+	if attrs["area"] {
+		infos.Area = &pb.RoomAreaInfo{
+			AreaId:         rs.GetAreaId(),
+			AreaName:       rs.GetAreaName(),
+			ParentAreaId:   rs.GetParentAreaId(),
+			ParentAreaName: rs.GetParentAreaName(),
+		}
+	}
+
+	if attrs["anchor"] {
+		infos.Anchor = &pb.RoomAnchorInfo{
+			AnchorProfileType: rs.GetAnchorProfileType(),
+			AnchorLevel: &pb.AnchorLevel{
+				Level:    rs.GetAnchorLevel().GetLevel(),
+				Color:    rs.GetAnchorLevel().GetColor(),
+				Score:    rs.GetAnchorLevel().GetScore(),
+				Left:     rs.GetAnchorLevel().GetLeft(),
+				Right:    rs.GetAnchorLevel().GetRight(),
+				MaxLevel: rs.GetAnchorLevel().GetMaxLevel(),
+			},
+		}
+	}
+
+	return infos
+}

app/service/live/xroom/internal/service/service.go

@@ -0,0 +1,63 @@
+package service
+
+import (
+	"context"
+
+	dav1 "go-common/app/service/live/dao-anchor/api/grpc/v1"
+	"go-common/app/service/live/xroom/internal/dao"
+	"go-common/library/conf/paladin"
+	"go-common/library/net/rpc/warden"
+)
+
+// Service service.
+type Service struct {
+	ac *paladin.Map
+
+	appConf *AppConf
+
+	dao      *dao.Dao
+	daClient *dav1.Client
+}
+
+// AppConf Conf
+type AppConf struct {
+}
+
+//GrpcConf conf
+type GrpcConf struct {
+	Client *warden.ClientConfig
+	Server *warden.ServerConfig
+}
+
+// New new a service and return.
+func New() (s *Service) {
+	var ac = new(paladin.TOML)
+	if err := paladin.Watch("application.toml", ac); err != nil {
+		panic(err)
+	}
+	var gConf *GrpcConf
+	if err := paladin.Get("grpc.toml").UnmarshalTOML(&gConf); err != nil {
+		panic(err)
+	}
+	dClient, err := dav1.NewClient(gConf.Client)
+	if err != nil {
+		panic(err)
+	}
+
+	s = &Service{
+		ac:       ac,
+		dao:      dao.New(),
+		daClient: dClient,
+	}
+	return s
+}
+
+// Ping ping the resource.
+func (s *Service) Ping(ctx context.Context) (err error) {
+	return s.dao.Ping(ctx)
+}
+
+// Close close the resource.
+func (s *Service) Close() {
+	s.dao.Close()
+}