Create & Init Project...

app/interface/main/broadcast/benchmark/tool/client/BUILD

@@ -0,0 +1,40 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "client",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    importpath = "go-common/app/interface/main/broadcast/benchmark/tool/client",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/broadcast/libs/bufio:go_default_library",
+        "//app/service/main/broadcast/model:go_default_library",
+        "//library/xstr: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/interface/main/broadcast/benchmark/tool/client/main.go

@@ -0,0 +1,133 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net"
+	"time"
+
+	"go-common/app/service/main/broadcast/libs/bufio"
+	"go-common/app/service/main/broadcast/model"
+	"go-common/library/xstr"
+)
+
+var (
+	op        string
+	key       string
+	room      string
+	accessKey string
+	platform  string
+	mobiApp   string
+	addr      string
+	build     int
+)
+
+const (
+	_heartTime = 30 * time.Second
+)
+
+func init() {
+	flag.StringVar(&addr, "addr", "172.22.33.126:7821", "server ip:port")
+	flag.StringVar(&key, "device_id", "test_"+fmt.Sprint(time.Now().Unix()), "client key")
+	flag.StringVar(&room, "room_id", "", "client room")
+	flag.StringVar(&accessKey, "access_key", "", "client access_key")
+	flag.StringVar(&platform, "platform", "", "client platform")
+	flag.StringVar(&mobiApp, "mobi_app", "", "client moni_app")
+	flag.StringVar(&op, "op", "", "op=1000,1002,1003")
+	flag.IntVar(&build, "build", 0, "client build")
+}
+
+func main() {
+	flag.Parse()
+	if op == "" {
+		panic("please input the op=1000/1002/1003")
+	}
+	if platform == "" {
+		panic("please input the platform=android/ios/web")
+	}
+	log.Printf("addr=%s op=%s key=%s\n", addr, op, key)
+
+	_, err := xstr.SplitInts(op)
+	if err != nil {
+		panic(err)
+	}
+	client()
+}
+
+func client() {
+	conn, err := net.DialTimeout("tcp", addr, time.Second)
+	if err != nil {
+		log.Printf("err.net.Dial(%s) error(%v)\n", addr, err)
+		return
+	}
+	defer func() {
+		conn.Close()
+		log.Printf("err.conn.Close() key:%s\n", key)
+	}()
+	wr := bufio.NewWriter(conn)
+	rd := bufio.NewReader(conn)
+	// timeout
+	if err = conn.SetDeadline(time.Now().Add(time.Second * 5)); err != nil {
+		log.Printf("err.conn.SetDeadline() error(%v)\n", err)
+		return
+	}
+	body := fmt.Sprintf(`{"device_id":"%s","access_key":"%s","platform":"%s","mobi_app":"%s","build":%d,"accepts":[%s],"room_id":"%s"}`, key, accessKey, platform, mobiApp, build, op, room)
+	log.Printf("auth:%s\n", body)
+	// auth first
+	proto := &model.Proto{
+		Operation: model.OpAuth,
+		Body:      []byte(body),
+	}
+	if err = proto.WriteTCP(wr); err != nil {
+		log.Printf("err.auth write error(%v)\n", err)
+		return
+	}
+	if err = wr.Flush(); err != nil {
+		log.Printf("err.auth flush error(%v)\n", err)
+		return
+	}
+	go heartbeat(conn, wr, key)
+	for {
+		if err = proto.ReadTCP(rd); err != nil {
+			log.Printf("err.read a proto key:%v error(%v)\n", key, err)
+			return
+		}
+		switch proto.Operation {
+		case model.OpHeartbeatReply:
+			if err = conn.SetDeadline(time.Now().Add(_heartTime * 5)); err != nil {
+				log.Printf("err.conn.SetDeadline() key:%v error(%v)\n", key, err)
+				return
+			}
+
+			log.Printf("info.read key:%v heartbeat proto.body(%s) seq: %d\n", key, string(proto.Body), proto.SeqId)
+		default:
+			log.Printf("info.read a key:%v proto(%+v)  op:%d\n", key, proto, proto.Operation)
+		}
+	}
+}
+
+func heartbeat(conn net.Conn, wr *bufio.Writer, key string) {
+	var (
+		seq int32
+		err error
+	)
+	defer conn.Close()
+	for {
+		seq++
+		proto := &model.Proto{
+			Operation: model.OpHeartbeat,
+			SeqId:     seq,
+		}
+		if err = proto.WriteTCP(wr); err != nil {
+			log.Printf("err.heartbeat write error(%v)\n", err)
+			return
+		}
+		if err = wr.Flush(); err != nil {
+			log.Printf("err.heartbeat key:%s flush error(%v)\n", key, err)
+			return
+		}
+		log.Printf("info.write key:%s heartbeat proto(%+v)\n", key, proto)
+		time.Sleep(_heartTime)
+	}
+}

app/interface/main/broadcast/benchmark/tool/push/BUILD

@@ -0,0 +1,40 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "push",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    importpath = "go-common/app/interface/main/broadcast/benchmark/tool/push",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/netutil/breaker:go_default_library",
+        "//library/time: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/interface/main/broadcast/benchmark/tool/push/main.go

@@ -0,0 +1,146 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log"
+	"net/url"
+	"time"
+
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/netutil/breaker"
+	xtime "go-common/library/time"
+)
+
+const (
+	_apiPushKey  = "http://172.22.33.126:7831/x/internal/broadcast/push/keys"
+	_apiPushMid  = "http://172.22.33.126:7831/x/internal/broadcast/push/mids"
+	_apiPushRoom = "http://172.22.33.126:7831/x/internal/broadcast/push/room"
+	_apiPushAll  = "http://172.22.33.126:7831/x/internal/broadcast/push/all"
+)
+
+var (
+	cmd      string
+	op       string
+	key      string
+	mid      string
+	room     string
+	platform string
+	message  string
+
+	httpClient = bm.NewClient(&bm.ClientConfig{
+		App: &bm.App{
+			Key:    "6a29f8ed87407c11",
+			Secret: "d3c5a85f5b895a03735b5d20a273bc57",
+		},
+		Dial:      xtime.Duration(time.Second),
+		Timeout:   xtime.Duration(time.Second),
+		KeepAlive: xtime.Duration(time.Second * 10),
+		Breaker: &breaker.Config{
+			Window:    xtime.Duration(time.Second),
+			Sleep:     xtime.Duration(time.Second),
+			Bucket:    10,
+			Ratio:     0.8,
+			Request:   100,
+			SwitchOff: false,
+		},
+	})
+)
+
+func init() {
+	flag.StringVar(&cmd, "cmd", "", "cmd=key/mid/room/all")
+	flag.StringVar(&op, "op", "", "op=1000,1002,1003")
+	flag.StringVar(&key, "key", "", "client key")
+	flag.StringVar(&mid, "mid", "", "mid")
+	flag.StringVar(&room, "room", "", "room")
+	flag.StringVar(&platform, "platform", "", "platform")
+	flag.StringVar(&message, "message", "", "message content")
+}
+
+func main() {
+	flag.Parse()
+	if op == "" {
+		panic("please input the op=1000/1002/1003")
+	}
+	switch cmd {
+	case "key":
+		pushKey(op, key, message)
+	case "mid":
+		pushMid(op, mid, message)
+	case "room":
+		pushRoom(op, room, message)
+	case "all":
+		pushAll(op, platform, message)
+	default:
+		log.Printf("unknown cmd=%s\n", cmd)
+		return
+	}
+}
+
+func pushKey(op, key, content string) (err error) {
+	params := url.Values{}
+	params.Set("operation", op)
+	params.Set("keys", key)
+	params.Set("message", content)
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+	}
+	if err = httpClient.Post(context.Background(), _apiPushKey, "", params, &res); err != nil {
+		log.Printf("http error(%v)", err)
+		return
+	}
+	log.Printf("sent op[%s] key[%s] message:%s\n result:(%d,%s)\n", op, key, message, res.Code, res.Msg)
+	return
+}
+
+func pushMid(op, mid, content string) (err error) {
+	params := url.Values{}
+	params.Set("operation", op)
+	params.Set("mids", mid)
+	params.Set("message", content)
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+	}
+	if err = httpClient.Post(context.Background(), _apiPushMid, "", params, &res); err != nil {
+		log.Printf("http error(%v)\n", err)
+		return
+	}
+	log.Printf("sent op[%s] mid[%s] message:%s\n, result:(%d,%s)\n", op, mid, message, res.Code, res.Msg)
+	return
+}
+
+func pushRoom(op, room, content string) (err error) {
+	params := url.Values{}
+	params.Set("operation", op)
+	params.Set("room", room)
+	params.Set("message", content)
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+	}
+	if err = httpClient.Post(context.Background(), _apiPushRoom, "", params, nil); err != nil {
+		log.Printf("http error(%v)\n", err)
+		return
+	}
+	log.Printf("sent op[%s] room[%s] message:%s\n, result:(%d,%s)\n", op, room, message, res.Code, res.Msg)
+	return
+}
+
+func pushAll(op, platform, content string) (err error) {
+	params := url.Values{}
+	params.Set("operation", op)
+	params.Set("platform", platform)
+	params.Set("message", content)
+	var res struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+	}
+	if err = httpClient.Post(context.Background(), _apiPushAll, "", params, &res); err != nil {
+		log.Printf("http error(%v)\n", err)
+		return
+	}
+	log.Printf("sent op[%s] platform[%s] message:%s\n, result:(%d,%s)\n", op, platform, message, res.Code, res.Msg)
+	return
+}