func handleSuccess() {
var (
pm *sarama.ProducerMessage
)
for {
pm = <-producer.Successes()
if pm != nil {
log.Info("producer message success, partition:%d offset:%d key:%v valus:%s", pm.Partition, pm.Offset, pm.Key, pm.Value)
}
}
}
// retPWrite marshal the result and write to client(post).
func retPWrite(w http.ResponseWriter, r *http.Request, res map[string]interface{}, body *string, start time.Time) {
data, err := json.Marshal(res)
if err != nil {
log.Error("json.Marshal(\"%v\") error(%v)", res, err)
return
}
dataStr := string(data)
if _, err := w.Write([]byte(dataStr)); err != nil {
log.Error("w.Write(\"%s\") error(%v)", dataStr, err)
}
log.Info("req: \"%s\", post: \"%s\", res:\"%s\", ip:\"%s\", time:\"%fs\"", r.URL.String(), *body, dataStr, r.RemoteAddr, time.Now().Sub(start).Seconds())
}
func rpcListen(network, addr string) {
l, err := net.Listen(network, addr)
if err != nil {
log.Error("net.Listen(\"%s\", \"%s\") error(%v)", network, addr, err)
panic(err)
}
// if process exit, then close the rpc addr
defer func() {
log.Info("listen rpc: \"%s\" close", addr)
if err := l.Close(); err != nil {
log.Error("listener.Close() error(%v)", err)
}
}()
rpc.Accept(l)
}
// InitSignal register signals handler.
func InitSignal() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT, syscall.SIGSTOP)
for {
s := <-c
log.Info("job[%s] get a signal %s", Ver, s.String())
switch s {
case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGSTOP, syscall.SIGINT:
return
case syscall.SIGHUP:
continue
default:
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/push/room", PushRoom)
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
}
// ping ping the rpc connect and reconnect when has an error.
func (c *Client) Ping(serviceMethod string) {
var (
arg = proto.NoArg{}
reply = proto.NoReply{}
err error
)
for {
select {
case <-c.quit:
goto closed
return
default:
}
if c.Client != nil && c.err == nil {
// ping
if err = c.Call(serviceMethod, &arg, &reply); err != nil {
c.err = err
if err != rpc.ErrShutdown {
c.Client.Close()
}
log.Error("client.Call(%s, arg, reply) error(%v)", serviceMethod, err)
}
} else {
// reconnect
if err = c.dial(); err == nil {
// reconnect ok
c.err = nil
log.Info("client reconnect %s ok", c.options.Addr)
}
}
time.Sleep(pingDuration)
}
closed:
if c.Client != nil {
c.Client.Close()
}
}
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)
// init slow log
// TODO need to performance optimizition, so stop to use slow log
/*if err := initSlowLog(Conf.SlowLog); err != nil {
panic(err)
}*/
// 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,
RoutineAmount: Conf.RoutineAmount,
RoutineSize: Conf.RoutineSize,
}, RoomOptions{
ChannelSize: Conf.RoomChannel,
})
}
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{
CliProto: Conf.CliProto,
SvrProto: Conf.SvrProto,
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)
}
// flash safe policy
if Conf.FlashPolicyOpen {
if err := InitFlashPolicy(); err != nil {
panic(err)
}
}
// wss comet
if Conf.WebsocketTLSOpen {
if err := InitWebsocketWithTLS(Conf.WebsocketTLSBind, Conf.WebsocketCertFile, Conf.WebsocketPrivateFile); err != nil {
panic(err)
}
}
// start rpc
if err := InitRPCPush(Conf.RPCPushAddrs); err != nil {
panic(err)
}
// block until a signal is received.
InitSignal()
}
func (p *Proto) Print() {
log.Info("\n-------- proto --------\nver: %d\nop: %d\nseq: %d\nbody: %s\n", p.Ver, p.Operation, p.SeqId, string(p.Body))
}
func startClient(key string) {
//time.Sleep(time.Duration(mrand.Intn(30)) * time.Second)
quit := make(chan bool, 1)
defer close(quit)
conn, err := net.Dial("tcp", os.Args[3])
if err != nil {
log.Error("net.Dial(\"%s\") error(%v)", os.Args[3], err)
return
}
seqId := int32(0)
wr := bufio.NewWriter(conn)
rd := bufio.NewReader(conn)
proto := new(Proto)
proto.Ver = 1
// auth
// test handshake timeout
// time.Sleep(time.Second * 31)
proto.Operation = OP_AUTH
proto.SeqId = seqId
proto.Body = []byte(key)
if err = tcpWriteProto(wr, proto); err != nil {
log.Error("tcpWriteProto() error(%v)", err)
return
}
if err = tcpReadProto(rd, proto); err != nil {
log.Error("tcpReadProto() error(%v)", err)
return
}
log.Debug("key:%s auth ok, proto: %v", key, proto)
seqId++
// writer
go func() {
proto1 := new(Proto)
for {
// heartbeat
proto1.Operation = OP_HEARTBEAT
proto1.SeqId = seqId
proto1.Body = nil
if err = tcpWriteProto(wr, proto1); err != nil {
log.Error("key:%s tcpWriteProto() error(%v)", key, err)
return
}
log.Debug("key:%s Write heartbeat", key)
// test heartbeat
time.Sleep(heart)
seqId++
select {
case <-quit:
return
default:
}
}
}()
// reader
for {
if err = tcpReadProto(rd, proto); err != nil {
log.Error("key:%s tcpReadProto() error(%v)", key, err)
quit <- true
return
}
if proto.Operation == OP_HEARTBEAT_REPLY {
log.Debug("key:%s receive heartbeat", key)
if err = conn.SetReadDeadline(time.Now().Add(heart + 60*time.Second)); err != nil {
log.Error("conn.SetReadDeadline() error(%v)", err)
quit <- true
return
}
} else if proto.Operation == OP_TEST_REPLY {
log.Debug("body: %s", string(proto.Body))
} else if proto.Operation == OP_SEND_SMS_REPLY {
log.Info("key:%s msg: %s", key, string(proto.Body))
atomic.AddInt64(&countDown, 1)
}
}
}