func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
log.Global = log.NewDefaultLogger(log.DEBUG)
flag.Parse()
defer log.Close()
begin, err := strconv.Atoi(os.Args[1])
if err != nil {
panic(err)
}
num, err := strconv.Atoi(os.Args[2])
if err != nil {
panic(err)
}
go result()
for i := begin; i < begin+num; i++ {
key := fmt.Sprintf("%d", i)
quit := make(chan bool, 1)
go startClient(key, quit)
}
var exit chan bool
<-exit
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
log.Info("logic[%s] start", Ver)
perf.Init(Conf.PprofAddrs)
// router rpc
if err := InitRouter(); err != nil {
log.Warn("router rpc current can't connect, retry")
}
MergeRoomCount()
go SyncRoomCount()
// logic rpc
if err := InitRPC(NewDefaultAuther()); err != nil {
panic(err)
}
if err := InitKafka(Conf.KafkaAddrs); err != nil {
panic(err)
}
if err := InitHTTP(); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
log.Global = log.NewDefaultLogger(log.DEBUG)
flag.Parse()
defer log.Close()
begin, err := strconv.Atoi(os.Args[1])
if err != nil {
panic(err)
}
num, err := strconv.Atoi(os.Args[2])
if err != nil {
panic(err)
}
//time.AfterFunc(time.Duration(t)*time.Second, stop)
go result()
for i := begin; i < begin+num; i++ {
key := fmt.Sprintf("%d", i)
go startClient(key)
}
var exit chan bool
<-exit
}
func main() {
var err error
// Parse cmd-line arguments
flag.Parse()
log.Info("web ver: \"%s\" start", ver.Version)
if err = InitConfig(); err != nil {
panic(err)
}
// Set max routine
runtime.GOMAXPROCS(Conf.MaxProc)
// init log
log.LoadConfiguration(Conf.Log)
defer log.Close()
// init zookeeper
zkConn, err := InitZK()
if err != nil {
if zkConn != nil {
zkConn.Close()
}
panic(err)
}
// start pprof http
perf.Init(Conf.PprofBind)
// start http listen.
StartHTTP()
// process init
if err = process.Init(Conf.User, Conf.Dir, Conf.PidFile); err != nil {
panic(err)
}
// init signals, block wait signals
signalCH := InitSignal()
HandleSignal(signalCH)
log.Info("web stop")
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
//l4g.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter("server.log", false))
// creates a tcp listener
l4g.LoadConfiguration("./conf/log4go.xml")
tcpAddr, err := net.ResolveTCPAddr("tcp4", ":8989")
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
defer l4g.Close()
// creates a server
config := &gotcp.Config{
PacketSendChanLimit: 20,
PacketReceiveChanLimit: 20,
}
srv := gotcp.NewServer(config, &Callback{}, &echo.EchoProtocol{})
// starts service
go srv.Start(listener, time.Second)
l4g.Debug("listening: %s", listener.Addr())
//log.Println("listening:", listener.Addr())
// catchs system signal
chSig := make(chan os.Signal)
signal.Notify(chSig, syscall.SIGINT, syscall.SIGTERM, syscall.SIGUSR2) //, syscall.SIGINT, syscall.SIGTERM
l4g.Trace("Signal: %s", <-chSig)
//log.Println("Signal: ", <-chSig)
// stops service
srv.Stop()
}
func main() {
var (
addr *net.UDPAddr
listener *net.UDPConn
err error
)
log.LoadConfiguration(Conf.Log)
defer log.Close()
if addr, err = net.ResolveUDPAddr("udp4", Conf.Bind); err != nil {
log.Error("net.ResolveUDPAddr(\"udp4\", \"%s\") error(%v)", Conf.Bind, err)
return
}
if listener, err = net.ListenUDP("udp4", addr); err != nil {
log.Error("net.ListenUDP(\"udp4\", \"%v\") error(%v)", addr, err)
return
}
defer listener.Close()
if Debug {
log.Debug("start udp listen: \"%s\"", Conf.Bind)
}
//N core accept
for i := 0; i < Conf.MaxProc; i++ {
go acceptUDP(listener)
}
//wait
InitSignal()
}
func (c *Client) Must(result *Result, err *AppError) *Result {
if err != nil {
l4g.Close()
time.Sleep(time.Second)
panic(err)
}
return result
}
func Must(sc StoreChannel) interface{} {
r := <-sc
if r.Err != nil {
l4g.Close()
time.Sleep(time.Second)
panic(r.Err)
}
return r.Data
}
func main() {
// init cmd args
flag.Parse()
// init config
if err := initConfig(); err != nil {
os.Exit(termExit)
}
// init log
log.LoadConfiguration(conf.Log)
defer log.Close()
if len(conf.Sentinel) == 0 {
// set to zk
log.Error("conf.Sentinel don't have any sentinel addr")
time.Sleep(logWait)
os.Exit(retryExit)
}
log.Info("sentinels: \"%v\", master: \"%s\"", conf.Sentinel, conf.Master)
// init sentinel addrs
for _, addr := range conf.Sentinel {
sentinelList.PushBack(addr)
}
redisConn := sentinel()
if redisConn == nil {
log.Error("sentinel can't connect")
time.Sleep(logWait)
os.Exit(retryExit)
}
defer redisConn.Close()
// master redis
redisMaster := masterAddr(redisConn)
log.Debug("redis master: \"%s\"", redisMaster)
isMaster := checkRole(redisMaster, roleMaster)
if isMaster {
refreshSentinel(redisConn)
} else {
log.Warn("abort the mission, master not ok")
time.Sleep(logWait)
os.Exit(retryExit)
}
// set to zk
zkConn := zkDial()
if zkConn == nil {
log.Error("zookeeper can't connect")
time.Sleep(logWait)
os.Exit(retryExit)
}
defer zkConn.Close()
if err := zkData(zkConn, redisMaster); err != nil {
log.Error("zookeeper set data failed")
time.Sleep(logWait)
os.Exit(retryExit)
}
time.Sleep(logWait)
os.Exit(okExit)
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
if Conf.Type == ProtoTCP {
initTCP()
} else if Conf.Type == ProtoWebsocket {
initWebsocket()
} else if Conf.Type == ProtoWebsocketTLS {
initWebsocketTLS()
}
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
perf.Init(Conf.PprofBind)
if Conf.Type == ProtoTCP {
initTCP()
} else if Conf.Type == ProtoWebsocket {
initWebsocket()
}
time.Sleep(10 * time.Second)
}
func main() {
// parse cmd-line arguments
flag.Parse()
log.Info("comet ver: \"%s\" start", ver.Version)
// init config
if err := InitConfig(); err != nil {
panic(err)
}
// set max routine
runtime.GOMAXPROCS(Conf.MaxProc)
// init log
log.LoadConfiguration(Conf.Log)
defer log.Close()
// start pprof
perf.Init(Conf.PprofBind)
// create channel
// if process exit, close channel
UserChannel = NewChannelList()
defer UserChannel.Close()
// start stats
StartStats()
// start rpc
if err := StartRPC(); err != nil {
panic(err)
}
// start comet
if err := StartComet(); err != nil {
panic(err)
}
// init zookeeper
zkConn, err := InitZK()
if err != nil {
if zkConn != nil {
zkConn.Close()
}
panic(err)
}
// process init
if err = process.Init(Conf.User, Conf.Dir, Conf.PidFile); err != nil {
panic(err)
}
// init signals, block wait signals
signalCH := InitSignal()
HandleSignal(signalCH)
// exit
log.Info("comet stop")
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
log.Info("comet[%s] start", Ver)
perf.Init(Conf.PprofBind)
// logic rpc
if err := InitLogicRpc(Conf.LogicAddr); err != nil {
log.Warn("logic rpc current can't connect, retry")
}
// new server
buckets := make([]*Bucket, Conf.Bucket)
for i := 0; i < Conf.Bucket; i++ {
buckets[i] = NewBucket(Conf.Channel, Conf.Room, Conf.RoomChannel, Conf.CliProto, Conf.SvrProto)
}
round := NewRound(Conf.ReadBuf, Conf.WriteBuf, Conf.Timer, Conf.TimerSize)
operator := new(DefaultOperator)
DefaultServer = NewServer(buckets, round, operator)
if err := InitTCP(); err != nil {
panic(err)
}
if err := InitWebsocket(); err != nil {
panic(err)
}
if Conf.WebsocketTLSOpen {
if err := InitWebsocketWithTLS(); err != nil {
panic(err)
}
}
if err := InitHTTP(); err != nil {
panic(err)
}
// start rpc
if err := InitRPCPush(); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
fmt.Printf("init err: %s", err)
panic(err)
}
log.LoadConfiguration(Conf.Log)
defer log.Close()
// init evnet and shutdown
InitEvent()
defer ShutdownEvent()
SyncDaemon()
signal.InitSignal(reload)
}
func configureLog(s *model.LogSettings) {
l4g.Close()
if s.EnableConsole {
level := l4g.DEBUG
if s.ConsoleLevel == "INFO" {
level = l4g.INFO
} else if s.ConsoleLevel == "WARN" {
level = l4g.WARNING
} else if s.ConsoleLevel == "ERROR" {
level = l4g.ERROR
}
l4g.AddFilter("stdout", level, l4g.NewConsoleLogWriter())
}
if s.EnableFile {
var fileFormat = s.FileFormat
if fileFormat == "" {
fileFormat = "[%D %T] [%L] %M"
}
level := l4g.DEBUG
if s.FileLevel == "INFO" {
level = l4g.INFO
} else if s.FileLevel == "WARN" {
level = l4g.WARNING
} else if s.FileLevel == "ERROR" {
level = l4g.ERROR
}
flw := l4g.NewFileLogWriter(GetLogFileLocation(s.FileLocation), false)
flw.SetFormat(fileFormat)
flw.SetRotate(true)
flw.SetRotateLines(LOG_ROTATE_SIZE)
l4g.AddFilter("file", level, flw)
}
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
fmt.Printf("init err: %s", err)
panic(err)
}
log.LoadConfiguration(Conf.Log)
defer log.Close()
// init evnet and shutdown
InitEvent()
defer ShutdownEvent()
StartMongoReplica()
StartCheckpointDeamon()
InitSignal()
}
func main() {
flag.Parse()
log.Info("message ver: \"%s\" start", ver.Version)
if err := InitConfig(); err != nil {
panic(err)
}
// Set max routine
runtime.GOMAXPROCS(Conf.MaxProc)
// init log
log.LoadConfiguration(Conf.Log)
defer log.Close()
// start pprof http
perf.Init(Conf.PprofBind)
// Initialize redis
if err := InitStorage(); err != nil {
panic(err)
}
// init rpc service
if err := InitRPC(); err != nil {
panic(err)
}
// init zookeeper
zk, err := InitZK()
if err != nil {
if zk != nil {
zk.Close()
}
panic(err)
}
// process init
if err = process.Init(Conf.User, Conf.Dir, Conf.PidFile); err != nil {
panic(err)
}
// init signals, block wait signals
sig := InitSignal()
HandleSignal(sig)
// exit
log.Info("message stop")
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
log.Info("comet[%s] start", Ver)
perf.Init(Conf.PprofBind)
if err := InitRSA(); err != nil {
panic(err)
}
// new server
buckets := make([]*Bucket, Conf.Bucket)
for i := 0; i < Conf.Bucket; i++ {
buckets[i] = NewBucket(Conf.Channel, Conf.CliProto, Conf.SvrProto)
}
round := NewRound(Conf.ReadBuf, Conf.WriteBuf, Conf.Timer, Conf.TimerSize, Conf.Session, Conf.SessionSize)
codec := new(BinaryServerCodec)
operator := new(DefaultOperator)
cryptor := NewDefaultCryptor()
DefaultServer = NewServer(buckets, round, codec, operator, cryptor)
if err := InitTCP(); err != nil {
panic(err)
}
if err := InitWebsocket(); err != nil {
panic(err)
}
if err := InitHttpPush(); err != nil {
panic(err)
}
// start rpc
if err := InitRPCPush(); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
log.Info("router[%s] start", VERSION)
// start prof
perf.Init(Conf.PprofBind)
// start rpc
buckets := make([]*Bucket, Conf.Bucket)
for i := 0; i < Conf.Bucket; i++ {
buckets[i] = NewBucket(Conf.Session, Conf.Server, Conf.Cleaner)
}
if err := InitRPC(buckets); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func configureLog(s LogSettings) {
l4g.Close()
if s.ConsoleEnable {
level := l4g.DEBUG
if s.ConsoleLevel == "INFO" {
level = l4g.INFO
} else if s.ConsoleLevel == "ERROR" {
level = l4g.ERROR
}
l4g.AddFilter("stdout", level, l4g.NewConsoleLogWriter())
}
if s.FileEnable {
if s.FileFormat == "" {
s.FileFormat = "[%D %T] [%L] %M"
}
if s.FileLocation == "" {
s.FileLocation = FindDir("logs") + "mattermost.log"
}
level := l4g.DEBUG
if s.FileLevel == "INFO" {
level = l4g.INFO
} else if s.FileLevel == "ERROR" {
level = l4g.ERROR
}
flw := l4g.NewFileLogWriter(s.FileLocation, false)
flw.SetFormat(s.FileFormat)
flw.SetRotate(true)
flw.SetRotateLines(100000)
l4g.AddFilter("file", level, flw)
}
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
log.Info("logic[%s] start", Ver)
perf.Init(Conf.PprofBind)
if err := InitRouterRpc(Conf.RouterPPCAddrs, Conf.RouterRPCRetry); err != nil {
panic(err)
}
// init http
if err := InitHTTP(); err != nil {
panic(err)
}
// start rpc
if err := InitRPC(NewDefaultAuther()); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func init() {
log4go.Close()
log4go.AddFilter("test", log4go.DEBUG, log4go.NewConsoleLogWriter())
}
func flushLogAndExit(code int) {
l4g.Close()
time.Sleep(time.Second)
os.Exit(code)
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
Debug = Conf.Debug
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
log.Info("comet[%s] start", Ver)
perf.Init(Conf.PprofBind)
// logic rpc
if err := InitLogicRpc(Conf.LogicAddr); err != nil {
log.Warn("logic rpc current can't connect, retry")
}
// new server
buckets := make([]*Bucket, Conf.Bucket)
for i := 0; i < Conf.Bucket; i++ {
buckets[i] = NewBucket(BucketOptions{
ChannelSize: Conf.BucketChannel,
RoomSize: Conf.BucketRoom,
}, RoomOptions{
ChannelSize: Conf.RoomChannel,
BatchNum: Conf.RoomBatch,
SignalTime: Conf.RoomSignal,
})
}
round := NewRound(RoundOptions{
Reader: Conf.TCPReader,
ReadBuf: Conf.TCPReadBuf,
ReadBufSize: Conf.TCPReadBufSize,
Writer: Conf.TCPWriter,
WriteBuf: Conf.TCPWriteBuf,
WriteBufSize: Conf.TCPWriteBufSize,
Timer: Conf.Timer,
TimerSize: Conf.TimerSize,
})
operator := new(DefaultOperator)
DefaultServer = NewServer(buckets, round, operator, ServerOptions{
Proto: Conf.Proto,
HandshakeTimeout: Conf.HandshakeTimeout,
TCPKeepalive: Conf.TCPKeepalive,
TCPRcvbuf: Conf.TCPRcvbuf,
TCPSndbuf: Conf.TCPSndbuf,
})
// tcp comet
if err := InitTCP(Conf.TCPBind, Conf.MaxProc); err != nil {
panic(err)
}
// websocket comet
if err := InitWebsocket(Conf.WebsocketBind); err != nil {
panic(err)
}
// wss comet
if Conf.WebsocketTLSOpen {
if err := InitWebsocketWithTLS(Conf.WebsocketTLSBind, Conf.WebsocketCertFile, Conf.WebsocketPrivateFile); err != nil {
panic(err)
}
}
// http comet
if err := InitHTTP(Conf.HTTPBind); err != nil {
panic(err)
}
// start rpc
if err := InitRPCPush(Conf.RPCPushAddrs); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func main() {
flag.Parse()
if err := InitConfig(); err != nil {
panic(err)
}
runtime.GOMAXPROCS(Conf.MaxProc)
log.LoadConfiguration(Conf.Log)
defer log.Close()
perf.Init(Conf.PprofBind)
if err := InitRSA(); err != nil {
panic(err)
}
conn, err := net.Dial("tcp", Conf.TCPAddr)
if err != nil {
log.Error("net.Dial(\"%s\") error(%v)", Conf.TCPAddr, err)
return
}
seqId := int32(0)
wr := bufio.NewWriter(conn)
rd := bufio.NewReader(conn)
proto := new(Proto)
proto.Ver = 1
key := make([]byte, 32)
// handshake
if _, err = rand.Read(key); err != nil {
panic(err)
}
proto.Operation = OP_HANDSHARE
proto.SeqId = seqId
proto.Body = key
// aes
var (
block cipher.Block
)
if block, err = aes.NewCipher(key[:16]); err != nil {
log.Error("aes.NewCipher() error(%v)", err)
return
}
log.Debug("aes key: %x, iv: %x", key[:16], key[16:])
ebm := cipher.NewCBCEncrypter(block, key[16:])
dbm := cipher.NewCBCDecrypter(block, key[16:])
// rsa
if proto.Body, err = rsa.EncryptOAEP(sha256.New(), rand.Reader, RSAPub, proto.Body, nil); err != nil {
return
}
if err = WriteProto(wr, proto); err != nil {
log.Error("WriteProto() error(%v)", err)
return
}
if err = ReadProto(rd, proto); err != nil {
log.Error("ReadProto() error(%v)", err)
return
}
log.Debug("handshake ok, proto: %v", proto)
dbm.CryptBlocks(proto.Body, proto.Body)
if proto.Body, err = padding.PKCS7.Unpadding(proto.Body, dbm.BlockSize()); err != nil {
log.Error("Unpadding() error(%v)", err)
return
}
log.Debug("handshake sessionid : %s", string(proto.Body))
seqId++
// auth
// test handshake timeout
// time.Sleep(time.Second * 31)
proto.Operation = OP_AUTH
proto.SeqId = seqId
proto.Body = padding.PKCS7.Padding([]byte(Conf.SubKey), ebm.BlockSize())
// user aes encrypt sub key
ebm.CryptBlocks(proto.Body, proto.Body)
if err = WriteProto(wr, proto); err != nil {
log.Error("WriteProto() error(%v)", err)
return
}
if err = ReadProto(rd, proto); err != nil {
log.Error("ReadProto() error(%v)", err)
return
}
log.Debug("auth ok, proto: %v", proto)
seqId++
// writer
go func() {
proto1 := new(Proto)
for {
// heartbeat
proto1.Operation = OP_HEARTBEAT
proto1.SeqId = seqId
proto1.Body = nil
if err = WriteProto(wr, proto1); err != nil {
log.Error("WriteProto() error(%v)", err)
return
}
// test heartbeat
//time.Sleep(time.Second * 31)
seqId++
// op_test
proto1.Operation = OP_TEST
proto1.SeqId = seqId
// use aes
proto1.Body = padding.PKCS7.Padding([]byte("hello test"), block.BlockSize())
ebm.CryptBlocks(proto1.Body, proto1.Body)
if err = WriteProto(wr, proto1); err != nil {
log.Error("WriteProto() error(%v)", err)
return
}
seqId++
time.Sleep(10000 * time.Millisecond)
}
}()
// reader
for {
if err = ReadProto(rd, proto); err != nil {
log.Error("ReadProto() error(%v)", err)
return
}
if proto.Body != nil {
dbm.CryptBlocks(proto.Body, proto.Body)
}
if proto.Operation == OP_HEARTBEAT_REPLY {
if err = conn.SetReadDeadline(time.Now().Add(25 * time.Second)); err != nil {
log.Error("conn.SetReadDeadline() error(%v)", err)
return
}
log.Debug("receive heartbeat")
} else if proto.Operation == OP_TEST_REPLY {
log.Debug("receive test")
bodyStr, err := padding.PKCS7.Unpadding(proto.Body, block.BlockSize())
if err != nil {
log.Error("pkcs7.Unpadding() error(%v)", err)
return
}
log.Debug("body: %s", bodyStr)
} else if proto.Operation == OP_SEND_SMS_REPLY {
log.Debug("receive message")
bodyStr, err := padding.PKCS7.Unpadding(proto.Body, block.BlockSize())
if err != nil {
log.Error("pkcs7.Unpadding() error(%v)", err)
return
}
log.Debug("body: %s", bodyStr)
}
}
}