func (m *Master) Start() {
context = m
if !m.Agent {
log.TraceInfo("master", "start")
tcpListener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", m.Host, m.Port))
if err != nil {
log.LogError(err)
log.LogFatalf(err)
}
m.tcpListener = tcpListener
tcpserver := &tcp_server{}
m.waitGroup.Wrap(func() { util.TCPServer(m.tcpListener, tcpserver) })
}
if !m.Agent && m.ConsolePort != 0 {
StartConsoleServer(m)
log.LogMessage("console start at:", m.ConsolePort)
}
if m.Agent {
log.TraceInfo("master agent", "start")
m.agent = &Agent{}
m.agent.Connect(m.Host, m.Port, true, m.ConnectToMaster)
} else {
m.agentlist = NewAgentList()
m.waitfor = true
if m.WaitAgents == 0 {
m.waitfor = false
StartApp(m)
}
}
}
func (l *LoginMgr) OnPrepare() bool {
log.TraceInfo(l.Name, "init link")
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", l.ClientHost, l.ClientPort))
if err != nil {
panic(err)
}
l.listener = listener
log.TraceInfo("sockettype:", l.Sockettype)
switch l.Sockettype {
case "websocket":
l.WaitGroup.Wrap(func() { util.WSServer(listener, &wshandler{}) })
default:
l.WaitGroup.Wrap(func() { util.TCPServer(listener, &handler{}) })
}
log.TraceInfo(l.Name, "start link complete")
return true
}
func (svr *Server) Start(master string, localip string, outerip string, typ string, argstr string) bool {
svr.startTime = time.Now()
defer func() {
if e := recover(); e != nil {
log.LogFatalf(e)
}
}()
args, err := simplejson.NewJson([]byte(argstr))
if err != nil {
panic(err)
}
svr.Type = typ
svr.StartArgs = args
if name, ok := args.CheckGet("name"); ok {
v, err := name.String()
if err != nil {
panic(err)
}
svr.Name = v
} else {
panic("app id not defined")
}
svr.MailBox = rpc.NewMailBox(0, 0, svr.AppId)
//now := time.Now()
//log.WriteToFile(fmt.Sprintf("log/%s_%d_%d_%d_%d_%d_%d.log", svr.Name, now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second()))
log.LogMessage("id:", svr.AppId, ", name:", svr.Name)
svr.Host = localip
if svr.Host == "" {
if host, ok := args.CheckGet("host"); ok {
v, err := host.String()
if err != nil {
panic(err)
}
svr.Host = v
} else {
panic(svr.Name + " host not defined")
}
}
if port, ok := args.CheckGet("port"); ok {
v, err := port.Int()
if err != nil {
panic(err)
}
svr.Port = v
} else {
panic(svr.Name + "port not defined")
}
svr.ClientHost = outerip
if svr.ClientHost == "" {
if clienthost, ok := args.CheckGet("clienthost"); ok {
v, err := clienthost.String()
if err != nil {
panic(err)
}
svr.ClientHost = v
}
}
if clientport, ok := args.CheckGet("clientport"); ok {
v, err := clientport.Int()
if err != nil {
panic(err)
}
svr.ClientPort = v
}
if fronted, ok := args.CheckGet("fronted"); ok {
v, err := fronted.Bool()
if err != nil {
panic(err)
}
svr.Fronted = v
}
svr.Sockettype = "native"
if Sockettype, ok := args.CheckGet("sockettype"); ok {
v, err := Sockettype.String()
if err != nil {
panic(err)
}
svr.Sockettype = v
}
//rpc端口
r, err := net.Listen("tcp", fmt.Sprintf("%s:%d", svr.Host, svr.Port))
if err != nil {
panic(err)
}
svr.rpcListener = r
if svr.Port == 0 {
svr.Port = r.Addr().(*net.TCPAddr).Port
}
if svr.Fronted && !svr.apper.RawSock() {
log.TraceInfo(svr.Name, "init link")
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", svr.ClientHost, svr.ClientPort))
if err != nil {
panic(err)
}
svr.clientListener = listener
if svr.ClientPort == 0 {
svr.ClientPort = listener.Addr().(*net.TCPAddr).Port
}
switch svr.Sockettype {
case "websocket":
svr.WaitGroup.Wrap(func() { util.WSServer(svr.clientListener, &WSClientHandler{}) })
default:
svr.WaitGroup.Wrap(func() { util.TCPServer(svr.clientListener, &ClientHandler{}) })
}
log.TraceInfo(svr.Name, "start link complete")
}
master_peer := &master_peer{}
peer := &peer{addr: master, h: master_peer}
if err := peer.Connect(); err != nil {
panic(err)
}
svr.noder = peer
signalChan := make(chan os.Signal, 1)
go func() {
for {
if _, ok := <-signalChan; !ok {
return
}
}
}()
signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
if debug, ok := args.CheckGet("debug"); ok {
v, err := debug.Bool()
if err == nil {
svr.Debug = v
}
}
if pfport, ok := args.CheckGet("pprof"); ok {
v, err := pfport.Int()
if err == nil {
svr.PProfPort = v
}
}
if assets, ok := args.CheckGet("assets"); ok {
v, err := assets.String()
if err == nil {
svr.AssetPath = v
}
}
if loglevel, ok := args.CheckGet("loglevel"); ok {
v, err := loglevel.Int()
if err == nil {
log.SetLogLevel("stdout", v)
}
}
svr.globalset = "GlobalSet"
if gs, ok := args.CheckGet("globalset"); ok {
v, err := gs.String()
if err == nil {
svr.globalset = v
}
}
svr.globaldataserver = false
if enable, ok := args.CheckGet("globaldataserver"); ok {
v, err := enable.Bool()
if err == nil {
svr.globaldataserver = v
}
}
svr.enableglobaldata = false
if enable, ok := args.CheckGet("enableglobaldata"); ok {
v, err := enable.Bool()
if err == nil {
svr.enableglobaldata = v
}
}
svr.maxglobalentry = 10
if max, ok := args.CheckGet("maxglobalentry"); ok {
v, err := max.Int()
if err == nil {
svr.maxglobalentry = v
}
}
log.LogMessage("global data status is ", svr.enableglobaldata)
if svr.globaldataserver {
svr.globalHelper.SetServer()
log.LogMessage("promote to global data server")
}
serial := (uint64(time.Now().Unix()%0x80000000) << 32) | (uint64(svr.AppId) << 24)
svr.setSerial(serial)
log.LogMessage("start serial:", fmt.Sprintf("%X", serial))
if !svr.apper.OnPrepare() {
return false
}
svr.CurrentInBase(svr.apper.IsBase())
if svr.AssetPath != "" {
helper.LoadAllConfig(svr.AssetPath)
}
//内部rpc注册
svr.rpcCh = make(chan *rpc.RpcCall, RPCBUFFER)
svr.rpcServer = createRpc(svr.rpcCh)
svr.WaitGroup.Wrap(func() { rpc.CreateService(svr.rpcServer, svr.rpcListener) })
svr.rpcProto = codec
if svr.rpcProto == nil {
panic("proto not set")
}
log.LogMessage("client proto:", svr.rpcProto.GetCodecInfo())
svr.Ready()
return true
}