func InitRouter() (err error) {
var (
network, addr string
)
routerRing = ketama.NewRing(ketama.Base)
for serverId, addrs := range Conf.RouterRPCAddrs {
// WARN r must every recycle changed for reconnect
var (
r *rpc.Client
routerQuit = make(chan struct{}, 1)
)
if network, addr, err = inet.ParseNetwork(addrs); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
r, err = rpc.Dial(network, addr)
if err != nil {
log.Error("rpc.Dial(\"%s\", \"%s\") error(%s)", network, addr, err)
}
go rpc.Reconnect(&r, routerQuit, network, addr)
log.Debug("router rpc addr:%s connect", addr)
routerServiceMap[serverId] = &r
routerRing.AddNode(serverId, 1)
}
routerRing.Bake()
return
}
func InitCometRpc(addrs map[int32]string) (err error) {
for serverID, addrs := range addrs {
var (
rpcClient *protorpc.Client
quit chan struct{}
network, addr string
)
if network, addr, err = inet.ParseNetwork(addrs); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
rpcClient, err = protorpc.Dial(network, addr)
if err != nil {
log.Error("protorpc.Dial(\"%s\") error(%s)", addr, err)
return
}
go protorpc.Reconnect(&rpcClient, quit, network, addr)
log.Info("rpc addr:%s connected", addr)
cometServiceMap[serverID] = &rpcClient
}
return
}
func InitLogicRpc(addrs string) (err error) {
var network, addr string
if network, addr, err = inet.ParseNetwork(addrs); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
logicRpcClient, err = protorpc.Dial(network, addr)
if err != nil {
log.Error("rpc.Dial(\"%s\", \"%s\") error(%s)", network, addr, err)
}
go protorpc.Reconnect(&logicRpcClient, logicRpcQuit, network, addr)
log.Debug("logic rpc addr %s:%s connected", network, addr)
return
}
func InitHTTPPush() (err error) {
var network, addr string
for i := 0; i < len(Conf.HTTPPushAddrs); i++ {
httpServeMux := http.NewServeMux()
httpServeMux.HandleFunc("/1/push", Push)
log.Info("start http push listen:\"%s\"", Conf.HTTPPushAddrs[i])
if network, addr, err = inet.ParseNetwork(Conf.HTTPPushAddrs[i]); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
go httpListen(httpServeMux, network, addr)
}
return
}
func InitRPC(auther Auther) (err error) {
var (
network, addr string
c = &RPC{auther: auther}
)
rpc.Register(c)
for i := 0; i < len(Conf.RPCAddrs); i++ {
log.Info("start listen rpc addr: \"%s\"", Conf.RPCAddrs[i])
if network, addr, err = inet.ParseNetwork(Conf.RPCAddrs[i]); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
go rpcListen(network, addr)
}
return
}
func InitRPC(bs []*Bucket) (err error) {
var (
network, addr string
c = &RouterRPC{Buckets: bs, BucketIdx: int64(len(bs))}
)
rpc.Register(c)
for i := 0; i < len(Conf.RPCAddrs); i++ {
log.Info("start listen rpc addr: \"%s\"", Conf.RPCAddrs[i])
if network, addr, err = inet.ParseNetwork(Conf.RPCAddrs[i]); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
go rpcListen(network, addr)
}
return
}
func InitRPCPush(addrs []string) (err error) {
var (
bind string
network, addr string
c = &PushRPC{}
)
rpc.Register(c)
for _, bind = range addrs {
if network, addr, err = inet.ParseNetwork(bind); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
go rpcListen(network, addr)
}
return
}
func InitHTTP() (err error) {
// http listen
var network, addr string
for i := 0; i < len(Conf.HTTPAddrs); i++ {
httpServeMux := http.NewServeMux()
httpServeMux.HandleFunc("/1/push", Push)
httpServeMux.HandleFunc("/1/pushs", Pushs)
httpServeMux.HandleFunc("/1/push/all", PushAll)
httpServeMux.HandleFunc("/1/server/del", DelServer)
httpServeMux.HandleFunc("/1/count", Count)
log.Info("start http listen:\"%s\"", Conf.HTTPAddrs[i])
if network, addr, err = inet.ParseNetwork(Conf.HTTPAddrs[i]); err != nil {
log.Error("inet.ParseNetwork() error(%v)", err)
return
}
go httpListen(httpServeMux, network, addr)
}
return
}