openbilibili/go-common
1
0
Fork 0
Code Releases Activity

Create & Init Project...

Browse Source
This commit is contained in:
MiaoWoo
2019-04-22 18:49:16 +08:00
commit fc4fa37393
25440 changed files with 4054998 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
app/interface/main/broadcast/benchmark/broadcast/BUILD Normal file
View File

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

94
app/interface/main/broadcast/benchmark/broadcast/main.go Normal file
View File

@@ -0,0 +1,94 @@
package main
// Start Commond eg: ./broadcast 10 10000 127.0.0.1:7831
// first routine count
// second parameter: running time
// third parameter: service server ip
import (
"context"
"fmt"
"net/url"
"os"
"strconv"
"time"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/netutil/breaker"
xtime "go-common/library/time"
)
var (
httpClient *bm.Client
)
const TestContent = "{\"test\":\"test push braocast\"}"
func init() {
httpClient = bm.NewClient(&bm.ClientConfig{
App: &bm.App{
Key: "6aa4286456d16b97",
Secret: "test",
},
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 main() {
rountineNum, err := strconv.Atoi(os.Args[1])
if err != nil {
panic(err)
}
t, err := strconv.Atoi(os.Args[2])
if err != nil {
panic(err)
}
addr := os.Args[3]
speed := os.Args[4]
gap := time.Second / time.Duration(rountineNum)
delay := time.Duration(0)
time.AfterFunc(time.Duration(t)*time.Second, stop)
go run(addr, time.Duration(0)*time.Second, speed)
for i := 0; i < rountineNum-1; i++ {
go run(addr, delay, speed)
delay += gap
fmt.Println("delay:", delay)
}
time.Sleep(9999 * time.Hour)
}
func stop() {
os.Exit(-1)
}
func run(addr string, delay time.Duration, speed string) {
time.Sleep(delay)
for {
go post(addr, speed)
time.Sleep(time.Second)
}
}
func post(addr string, speed string) {
params := url.Values{}
params.Set("operation", "9")
params.Set("speed", speed)
params.Set("message", TestContent)
if err := httpClient.Get(context.Background(), "http://"+addr+"/x/internal/broadcast/push/all", "", params, nil); err != nil {
fmt.Printf("Error: bm.get() error(%v)\n", err.Error())
return
}
}

39
app/interface/main/broadcast/benchmark/client/BUILD Normal file
View File

@@ -0,0 +1,39 @@
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/client",
tags = ["automanaged"],
visibility = ["//visibility:public"],
deps = [
"//app/service/main/broadcast/libs/bufio:go_default_library",
"//app/service/main/broadcast/model: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"],
)

156
app/interface/main/broadcast/benchmark/client/main.go Normal file
View File

@@ -0,0 +1,156 @@
package main
// Start Commond eg: ./client 1 5000 localhost:8080
// first parameter：beginning userId
// second parameter: amount of clients
// third parameter: comet server ip
import (
"flag"
"fmt"
"log"
"math/rand"
"net"
"os"
"runtime"
"strconv"
"time"
"go-common/app/service/main/broadcast/libs/bufio"
"go-common/app/service/main/broadcast/model"
)
var (
lg *log.Logger
)
const (
_heartTime = 10 * time.Second
)
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
_, err := os.OpenFile("./client.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
panic(err)
}
lg = log.New(os.Stdout, "", log.LstdFlags|log.Lshortfile)
flag.Parse()
begin, err := strconv.Atoi(os.Args[1])
if err != nil {
panic(err)
}
num, err := strconv.Atoi(os.Args[2])
if err != nil {
panic(err)
}
for i := begin; i < begin+num; i++ {
go client(fmt.Sprintf("%d", i))
}
var exit chan bool
<-exit
}
func client(key string) {
time.Sleep(time.Duration(rand.Intn(5000)) * time.Microsecond)
for {
conn, err := net.DialTimeout("tcp", os.Args[3], time.Second)
if err != nil {
lg.Printf("err.net.Dial(%s) error(%v)\n", os.Args[3], err)
return
}
defer func() {
conn.Close()
lg.Printf("err.conn.Close() key:%s", key)
}()
wr := bufio.NewWriter(conn)
rd := bufio.NewReader(conn)
// timeout
if err = conn.SetDeadline(time.Now().Add(time.Second * 5)); err != nil {
lg.Printf("err.conn.SetDeadline() error(%v)\n", err)
return
}
body := fmt.Sprintf(`{"device_id":"1231231","access_key":"test","platform":"android","mobi_app":"android","build":50000,"accepts":[10001]}`)
fmt.Println(body)
// auth first
proto := &model.Proto{
Operation: model.OpAuth,
Body: []byte(body),
}
if err = proto.WriteTCP(wr); err != nil {
lg.Printf("err.auth write error(%v)\n", err)
return
}
if err = wr.Flush(); err != nil {
lg.Printf("err.auth flush error(%v)\n", err)
return
}
go heartbeat(conn, wr, key)
for {
if err = proto.ReadTCP(rd); err != nil {
lg.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 {
lg.Printf("err.conn.SetDeadline() key:%v error(%v)\n", key, err)
return
}
lg.Printf("info.read key:%v heartbeat proto.body(%s) seq: %d\n", key, string(proto.Body), proto.SeqId)
default:
lg.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 (
a int32
err error
)
defer conn.Close()
for {
a++
proto := &model.Proto{
Operation: model.OpHeartbeat,
SeqId: a,
}
if err = proto.WriteTCP(wr); err != nil {
lg.Printf("err.heartbeat write error(%v)\n", err)
return
}
if err = wr.Flush(); err != nil {
lg.Printf("err.heartbeat key:%s flush error(%v)\n", key, err)
return
}
lg.Printf("info.write key:%s heartbeat proto(%+v)\n", key, proto)
a++
// op := ChangeRoomReq{
// RoomID: "test://2233",
// }
// body, err := json.Marshal(op)
// if err != nil {
// panic(err)
// }
// proto = &model.Proto{
// Operation: model.OpChangeRoom,
// SeqId: a,
// Body: body,
// }
// if err = proto.WriteTCP(wr); err != nil {
// lg.Printf("err.heartbeat write error(%v)\n", err)
// return
// }
// if err = wr.Flush(); err != nil {
// lg.Printf("err.heartbeat key:%s flush error(%v)\n", key, err)
// return
// }
// lg.Printf("info.write key:%s heartbeat proto(%+v)\n", key, proto)
time.Sleep(_heartTime)
}
}

40
app/interface/main/broadcast/benchmark/push/BUILD Normal file
View File

@@ -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/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"],
)

116
app/interface/main/broadcast/benchmark/push/main.go Normal file
View File

@@ -0,0 +1,116 @@
package main
// Start Commond eg:./push 1 500 127.0.0.1:7831 100
// first parameter：beginning port
// second parameter: end port
// third parameter: comet server ip
// fourth parameter: runing time
import (
"context"
"fmt"
"log"
"net/url"
"os"
"runtime"
"strconv"
"time"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/netutil/breaker"
xtime "go-common/library/time"
)
var (
lg *log.Logger
httpClient *bm.Client
t int
)
const TestContent = "{\"test\":1}"
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
infoLogfi, err := os.OpenFile("./pushs.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
panic(err)
}
lg = log.New(infoLogfi, "", log.LstdFlags|log.Lshortfile)
begin, err := strconv.Atoi(os.Args[1])
if err != nil {
panic(err)
}
end, err := strconv.Atoi(os.Args[2])
if err != nil {
panic(err)
}
t, err = strconv.Atoi(os.Args[4])
if err != nil {
panic(err)
}
num := runtime.NumCPU() * 2
lg.Printf("start routine num:%d", num)
l := end / num
b, e := begin, begin+l
time.AfterFunc(time.Duration(t)*time.Second, stop)
for i := begin; i <= end; i++ {
this := i
go func() {
for {
startPush(this, num)
time.Sleep(time.Second)
}
}()
}
for i := 0; i < num; i++ {
go startPush(b, e)
b += l
e += l
}
time.Sleep(9999 * time.Hour)
}
func init() {
httpClient = bm.NewClient(&bm.ClientConfig{
App: &bm.App{
Key: "6aa4286456d16b97",
Secret: "test",
},
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 stop() {
os.Exit(-1)
}
func startPush(b, e int) {
lg.Printf("start Push key from %d to %d", b, e)
for i := b; i < b+e; i++ {
params := url.Values{}
params.Set("operation", "9")
params.Set("keys", strconv.Itoa(b))
params.Set("message", TestContent)
err := httpClient.Get(context.Background(), fmt.Sprintf("http://%s/x/internal/broadcast/push/keys", os.Args[3]), "", params, nil)
if err != nil {
lg.Printf("get error (%v)", err)
return
}
}
}

40
app/interface/main/broadcast/benchmark/push_room/BUILD Normal file
View File

@@ -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_room",
embed = [":go_default_library"],
tags = ["automanaged"],
)
go_library(
name = "go_default_library",
srcs = ["main.go"],
importpath = "go-common/app/interface/main/broadcast/benchmark/push_room",
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"],
)

96
app/interface/main/broadcast/benchmark/push_room/main.go Normal file
View File

@@ -0,0 +1,96 @@
package main
// Start Commond eg: ./push_room test://test_room 10 100 127.0.0.1:7831
// first parameter: room id
// second parameter: routine count
// third parameter: running time
// fourth parameter: service server ip
import (
"context"
"fmt"
"net/url"
"os"
"strconv"
"time"
bm "go-common/library/net/http/blademaster"
"go-common/library/net/netutil/breaker"
xtime "go-common/library/time"
)
var (
httpClient *bm.Client
)
const TestContent = "{\"test\":\"test push room\"}"
func init() {
httpClient = bm.NewClient(&bm.ClientConfig{
App: &bm.App{
Key: "6aa4286456d16b97",
Secret: "test",
},
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 main() {
rountineNum, err := strconv.Atoi(os.Args[2])
if err != nil {
panic(err)
}
t, err := strconv.Atoi(os.Args[3])
if err != nil {
panic(err)
}
addr := os.Args[4]
time.AfterFunc(time.Duration(t)*time.Second, stop)
gap := time.Second / time.Duration(rountineNum)
delay := time.Duration(0)
go run(addr, time.Duration(0)*time.Second)
for i := 0; i < rountineNum-1; i++ {
go run(addr, delay)
delay += gap
fmt.Println("delay:", delay)
}
time.Sleep(9999 * time.Hour)
}
func run(addr string, delay time.Duration) {
time.Sleep(delay)
i := int64(0)
for {
go post(addr, i)
time.Sleep(time.Second)
i++
}
}
func stop() {
os.Exit(-1)
}
func post(addr string, i int64) {
params := url.Values{}
params.Set("room", os.Args[1])
params.Set("operation", "9")
params.Set("message", TestContent)
if err := httpClient.Get(context.Background(), "http://"+addr+"/x/internal/broadcast/push/room", "", params, nil); err != nil {
fmt.Printf("Error: bm.post() error(%s)\n", err.Error())
return
}
}

40
app/interface/main/broadcast/benchmark/tool/client/BUILD Normal file
View File

@@ -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"],
)

133
app/interface/main/broadcast/benchmark/tool/client/main.go Normal file
View File

@@ -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)
}
}

40
app/interface/main/broadcast/benchmark/tool/push/BUILD Normal file
View File

@@ -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"],
)

146
app/interface/main/broadcast/benchmark/tool/push/main.go Normal file
View File

@@ -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
}

157
app/interface/main/broadcast/benchmark/websocket/app.js Normal file
View File

@@ -0,0 +1,157 @@
(function(win) {
const rawHeaderLen = 18;
const packetOffset = 0;
const headerOffset = 4;
const verOffset = 6;
const opOffset = 8;
const seqOffset = 12;
const compressOffset = 16;
const ctypeOffset = 17;
var Client = function(options) {
var MAX_CONNECT_TIMES = 10;
var DELAY = 15000;
this.options = options || {};
this.createConnect(MAX_CONNECT_TIMES, DELAY);
}
Client.prototype.createConnect = function(max, delay) {
var self = this;
if (max === 0) {
return;
}
connect();
var textDecoder = new TextDecoder();
var textEncoder = new TextEncoder();
var heartbeatInterval;
function connect() {
var ws = new WebSocket('ws://172.22.33.126:7822/sub');
ws.binaryType = 'arraybuffer';
ws.onopen = function() {
console.log("auth start")
auth();
register();
}
ws.onmessage = function(evt) {
var data = evt.data;
var dataView = new DataView(data, 0);
var packetLen = dataView.getInt32(packetOffset);
var headerLen = dataView.getInt16(headerOffset);
var ver = dataView.getInt16(verOffset);
var op = dataView.getInt32(opOffset);
var seq = dataView.getInt32(seqOffset);
var msgBody = textDecoder.decode(data.slice(headerLen, packetLen));
console.log("receiveHeader: packetLen=" + packetLen, "headerLen=" + headerLen, "ver=" + ver, "op=" + op, "seq=" + seq,"body="+msgBody);
switch(op) {
case 8:
// heartbeat
heartbeat();
heartbeatInterval = setInterval(heartbeat, 30 * 1000);
break;
case 3:
// heartbeat reply
console.log("receive: heartbeat online=", dataView.getInt32(rawHeaderLen));
break;
case 5:
// batch message
for (var offset=0; offset<data.byteLength; offset+=packetLen) {
// parse
var packetLen = dataView.getInt32(offset);
var headerLen = dataView.getInt16(offset+headerOffset);
var ver = dataView.getInt16(offset+verOffset);
var msgBody = textDecoder.decode(data.slice(offset+headerLen, offset+packetLen));
// callback
messageReceived(ver, msgBody);
}
break;
}
}
ws.onclose = function() {
console.log("closed")
if (heartbeatInterval) clearInterval(heartbeatInterval);
setTimeout(reConnect, delay);
}
function heartbeat() {
var headerBuf = new ArrayBuffer(rawHeaderLen);
var headerView = new DataView(headerBuf, 0);
headerView.setInt32(packetOffset, rawHeaderLen);
headerView.setInt16(headerOffset, rawHeaderLen);
headerView.setInt16(verOffset, 1);
headerView.setInt32(opOffset, 2);
headerView.setInt32(seqOffset, 1);
headerView.setInt8(compressOffset, 0);
headerView.setInt8(ctypeOffset, 0);
ws.send(headerBuf);
console.log("send: heartbeat");
}
function auth() {
var token ='{"room_id":"test://room_001","platform":"web"}' // ,"device_id":"123"
var headerBuf = new ArrayBuffer(rawHeaderLen);
var headerView = new DataView(headerBuf, 0);
var bodyBuf = textEncoder.encode(token);
headerView.setInt32(packetOffset, rawHeaderLen + bodyBuf.byteLength);
headerView.setInt16(headerOffset, rawHeaderLen);
headerView.setInt16(verOffset, 1);
headerView.setInt32(opOffset, 7);
headerView.setInt32(seqOffset, 1);
headerView.setInt8(compressOffset, 0);
headerView.setInt8(ctypeOffset, 0);
ws.send(mergeArrayBuffer(headerBuf, bodyBuf));
}
function register() {
var token ='{"operations":[1001,1002,1003]}' // ,"device_id":"123"
var headerBuf = new ArrayBuffer(rawHeaderLen);
var headerView = new DataView(headerBuf, 0);
var bodyBuf = textEncoder.encode(token);
headerView.setInt32(packetOffset, rawHeaderLen + bodyBuf.byteLength);
headerView.setInt16(headerOffset, rawHeaderLen);
headerView.setInt16(verOffset, 1);
headerView.setInt32(opOffset, 14);
headerView.setInt32(seqOffset, 3);
headerView.setInt8(compressOffset, 0);
headerView.setInt8(ctypeOffset, 0);
ws.send(mergeArrayBuffer(headerBuf, bodyBuf));
}
function messageReceived(ver, body) {
var notify = self.options.notify;
if(notify) notify(body);
console.log("messageReceived:", "ver=" + ver, "body=" + body);
}
function mergeArrayBuffer(ab1, ab2) {
var u81 = new Uint8Array(ab1),
u82 = new Uint8Array(ab2),
res = new Uint8Array(ab1.byteLength + ab2.byteLength);
res.set(u81, 0);
res.set(u82, ab1.byteLength);
return res.buffer;
}
function char2ab(str) {
var buf = new ArrayBuffer(str.length);
var bufView = new Uint8Array(buf);
for (var i=0; i<str.length; i++) {
bufView[i] = str[i];
}
return buf;
}
}
function reConnect() {
self.createConnect(--max, delay * 2);
}
}
win['MyClient'] = Client;
})(window);

21
app/interface/main/broadcast/benchmark/websocket/index.html Normal file
View File

@@ -0,0 +1,21 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script src="./app.js"></script>
</head>
<body>
<div class="btn-cs">Broadcast</div>
<script>
var client = new MyClient({
notify: function(data) {
console.log(data);
alert(JSON.stringify(data));
}
});
</script>
</body>
</html>