Create & Init Project...

app/interface/main/broadcast/cmd/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "cmd",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    data = ["broadcast.toml"],
+    importpath = "go-common/app/interface/main/broadcast/cmd",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/broadcast/conf:go_default_library",
+        "//app/interface/main/broadcast/server:go_default_library",
+        "//app/interface/main/broadcast/server/grpc:go_default_library",
+        "//app/interface/main/broadcast/server/http:go_default_library",
+        "//library/conf/env:go_default_library",
+        "//library/conf/paladin:go_default_library",
+        "//library/log:go_default_library",
+        "//library/naming:go_default_library",
+        "//library/naming/discovery:go_default_library",
+        "//library/net/ip:go_default_library",
+        "//library/net/rpc/warden/resolver: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/cmd/broadcast.toml

@@ -0,0 +1,77 @@
+# This is a TOML document. Boom
+[broadcast]
+debug = true
+maxproc = 10
+serverTick = "5s"
+onlineTick = "10s"
+apiHost = "http://api.bilibili.com"
+apiToken = "test"
+
+[log]
+    stdout=true
+
+[http]
+    addr = "0.0.0.0:7825"
+	timeout = "1s"
+
+[wardenserver]
+	addr = "0.0.0.0:7829"
+	timeout = "1s"
+
+[wardenclient]
+	dial = "1s"
+	timeout = "1s"
+
+[discovery]
+    nodes = ["172.22.33.126:7171"]
+	key = "6a29f8ed87407c11"
+	secret = "d3c5a85f5b895a03735b5d20a273bc57"
+
+[tcp]
+	bind = ["0.0.0.0:7821"]
+	sndbuf = 2048
+	rcvbuf = 256
+	keepalive = false
+	reader = 1024
+	readBuf = 1024
+	readBufSize = 512
+	writer = 1024
+	writeBuf = 1024
+	writeBufSize = 4096
+
+[websocket]
+	bind = ["0.0.0.0:7822"]
+
+[timer]
+	timer = 256
+	timerSize = 2048
+
+[protoSection]
+	handshakeTimeout = "5s"
+	writeTimeout = "5s"
+	svrProto = 80
+	cliProto = 5
+
+[whitelist]
+	Whitelist = [123,1,2,3]
+	WhiteLog  = "/tmp/white_list.log"
+
+[bucket]
+	size = 256
+	channel = 1024
+	room = 1024
+	routineAmount = 128
+	routineSize = 20
+
+[httpClient]
+key = "test"
+secret = "test"
+dial = "300ms"
+timeout = "500ms"
+keepAlive = "60s"
+[httpClient.breaker]
+window  = "10s"
+sleep   = "50ms"
+bucket  = 10
+ratio   = 0.5
+request = 100

app/interface/main/broadcast/cmd/main.go

@@ -0,0 +1,157 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"math/rand"
+	"net"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+
+	"go-common/app/interface/main/broadcast/conf"
+	"go-common/app/interface/main/broadcast/server"
+	wardenServer "go-common/app/interface/main/broadcast/server/grpc"
+	"go-common/app/interface/main/broadcast/server/http"
+	"go-common/library/conf/env"
+	"go-common/library/conf/paladin"
+	"go-common/library/log"
+	"go-common/library/naming"
+	"go-common/library/naming/discovery"
+	"go-common/library/net/ip"
+	"go-common/library/net/rpc/warden/resolver"
+)
+
+const (
+	ver = "v1.2.0"
+)
+
+func main() {
+	flag.Parse()
+	if err := paladin.Init(); err != nil {
+		panic(err)
+	}
+	if err := paladin.Watch("broadcast.toml", conf.Conf); err != nil {
+		panic(err)
+	}
+	runtime.GOMAXPROCS(conf.Conf.Broadcast.MaxProc)
+	log.Init(conf.Conf.Log)
+	defer log.Close()
+	log.Info("broadcast %s start", ver)
+	rand.Seed(time.Now().UTC().UnixNano())
+	dis := discovery.New(conf.Conf.Discovery)
+	resolver.Register(dis)
+	// server
+	srv := server.NewServer(conf.Conf)
+	if err := server.InitWhitelist(conf.Conf.Whitelist); err != nil {
+		panic(err)
+	}
+	if err := server.InitTCP(srv, conf.Conf.TCP.Bind, conf.Conf.Broadcast.MaxProc); err != nil {
+		panic(err)
+	}
+	if err := server.InitWebsocket(srv, conf.Conf.WebSocket.Bind, conf.Conf.Broadcast.MaxProc); err != nil {
+		panic(err)
+	}
+	if conf.Conf.WebSocket.TLSOpen {
+		if err := server.InitWebsocketWithTLS(srv, conf.Conf.WebSocket.TLSBind, conf.Conf.WebSocket.CertFile, conf.Conf.WebSocket.PrivateFile, runtime.NumCPU()); err != nil {
+			panic(err)
+		}
+	}
+	// v1
+	if conf.Conf.Broadcast.OpenPortV1 {
+		if err := server.InitTCPV1(srv, conf.Conf.TCP.BindV1, conf.Conf.Broadcast.MaxProc); err != nil {
+			panic(err)
+		}
+		if err := server.InitWebsocketV1(srv, conf.Conf.WebSocket.BindV1, conf.Conf.Broadcast.MaxProc); err != nil {
+			panic(err)
+		}
+		if conf.Conf.WebSocket.TLSOpen {
+			if err := server.InitWebsocketWithTLSV1(srv, conf.Conf.WebSocket.TLSBindV1, conf.Conf.WebSocket.CertFile, conf.Conf.WebSocket.PrivateFile, runtime.NumCPU()); err != nil {
+				panic(err)
+			}
+		}
+	}
+	// http & grpc
+	http.Init(conf.Conf)
+	rpcSrv := wardenServer.New(conf.Conf, srv)
+	var (
+		err       error
+		disCancel context.CancelFunc
+	)
+	if env.IP == "" {
+		addr := ip.InternalIP()
+		_, port, _ := net.SplitHostPort(conf.Conf.WardenServer.Addr)
+		ins := &naming.Instance{
+			Region:   env.Region,
+			Zone:     env.Zone,
+			Env:      env.DeployEnv,
+			Hostname: env.Hostname,
+			Status:   1,
+			AppID:    "push.interface.broadcast",
+			Addrs: []string{
+				"grpc://" + addr + ":" + port,
+			},
+			Metadata: map[string]string{
+				"weight":      os.Getenv("WEIGHT"),
+				"ip_addrs":    os.Getenv("IP_ADDRS"),
+				"ip_addrs_v6": os.Getenv("IP_ADDRS_V6"),
+				"offline":     os.Getenv("OFFLINE"),
+				"overseas":    os.Getenv("OVERSEAS"),
+			},
+		}
+		disCancel, err = dis.Register(context.Background(), ins)
+		if err != nil {
+			panic(err)
+		}
+		go func() {
+			for {
+				var (
+					err     error
+					conns   int
+					ips     = make(map[string]struct{})
+					roomIPs = make(map[string]struct{})
+				)
+				for _, bucket := range srv.Buckets() {
+					for ip := range bucket.IPCount() {
+						ips[ip] = struct{}{}
+					}
+					for ip := range bucket.RoomIPCount() {
+						roomIPs[ip] = struct{}{}
+					}
+					conns += bucket.ChannelCount()
+				}
+				ins.Metadata["conns"] = fmt.Sprint(conns)
+				ins.Metadata["ips"] = fmt.Sprint(len(ips))
+				ins.Metadata["room_ips"] = fmt.Sprint(len(roomIPs))
+				if err = dis.Set(ins); err != nil {
+					log.Error("dis.Set(%+v) error(%v)", ins, err)
+					time.Sleep(time.Second)
+					continue
+				}
+				time.Sleep(time.Duration(conf.Conf.Broadcast.ServerTick))
+			}
+		}()
+	}
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
+	for {
+		s := <-c
+		log.Info("broadcast get a signal %s", s.String())
+		switch s {
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+			log.Info("broadcast %s exit", ver)
+			if disCancel != nil {
+				disCancel()
+			}
+			srv.Close()
+			rpcSrv.Shutdown(context.Background())
+			return
+		case syscall.SIGHUP:
+		default:
+			return
+		}
+	}
+}