diff --git a/cluster/cluster.go b/cluster/cluster.go index f05d750..4c98f58 100644 --- a/cluster/cluster.go +++ b/cluster/cluster.go @@ -109,7 +109,7 @@ func (cls *Cluster) DelNode(nodeId int,immediately bool){ nodeInfo.status = Discard rpc.client.Unlock() cls.locker.Unlock() - log.Release("Discard node %d %s",nodeInfo.NodeId,nodeInfo.ListenAddr) + log.SRelease("Discard node ",nodeInfo.NodeId," ",nodeInfo.ListenAddr) return } rpc.client.Unlock() @@ -127,7 +127,7 @@ func (cls *Cluster) DelNode(nodeId int,immediately bool){ rpc.client.Close(false) } - log.Release("remove node %d %s",nodeInfo.NodeId,nodeInfo.ListenAddr) + log.SRelease("remove node ",nodeInfo.NodeId," ",nodeInfo.ListenAddr) } func (cls *Cluster) serviceDiscoveryDelNode (nodeId int,immediately bool){ @@ -173,7 +173,7 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo (nodeInfo *NodeInfo){ for _,serviceName := range nodeInfo.PublicServiceList { if _,ok := mapDuplicate[serviceName];ok == true { //存在重复 - log.Error("Bad duplicate Service Cfg.") + log.SError("Bad duplicate Service Cfg.") continue } mapDuplicate[serviceName] = nil @@ -184,7 +184,7 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo (nodeInfo *NodeInfo){ } cls.mapIdNode[nodeInfo.NodeId] = *nodeInfo - log.Release("Discovery nodeId: %d services:%+v",nodeInfo.NodeId,nodeInfo.PublicServiceList) + log.SRelease("Discovery nodeId: ",nodeInfo.NodeId," services:",nodeInfo.PublicServiceList) //已经存在连接，则不需要进行设置 if _,rpcInfoOK := cls.mapRpc[nodeInfo.NodeId];rpcInfoOK == true { @@ -366,7 +366,7 @@ func (cls *Cluster) triggerRpcEvent (bConnect bool,clientSeq uint32,nodeId int) for serviceName,_:= range cls.mapServiceListenRpcEvent{ ser := service.GetService(serviceName) if ser == nil { - log.Error("cannot find service name %s",serviceName) + log.SError("cannot find service name ",serviceName) continue } diff --git a/cluster/dynamicdiscovery.go b/cluster/dynamicdiscovery.go index d3a418d..222b38e 100644 --- a/cluster/dynamicdiscovery.go +++ b/cluster/dynamicdiscovery.go @@ -1,7 +1,7 @@ package cluster import ( - "fmt" + "errors" "github.com/duanhf2012/origin/log" "github.com/duanhf2012/origin/rpc" "github.com/duanhf2012/origin/service" @@ -121,8 +121,8 @@ func (ds *DynamicDiscoveryMaster) RpcCastGo(serviceMethod string, args interface // 收到注册过来的结点 func (ds *DynamicDiscoveryMaster) RPC_RegServiceDiscover(req *rpc.ServiceDiscoverReq, res *rpc.Empty) error { if req.NodeInfo == nil { - err := fmt.Errorf("RPC_RegServiceDiscover req is error.") - log.Error(err.Error()) + err := errors.New("RPC_RegServiceDiscover req is error.") + log.SError(err.Error()) return err } @@ -335,12 +335,12 @@ func (dc *DynamicDiscoveryClient) OnNodeConnected(nodeId int) { //向Master服务同步本Node服务信息 err := dc.AsyncCallNode(nodeId, RegServiceDiscover, &req, func(res *rpc.Empty, err error) { if err != nil { - log.Error("call %s is fail :%s", RegServiceDiscover, err.Error()) + log.SError("call ",RegServiceDiscover," is fail :", err.Error()) return } }) if err != nil { - log.Error("call %s is fail :%s", RegServiceDiscover, err.Error()) + log.SError("call ",RegServiceDiscover," is fail :", err.Error()) } } diff --git a/cluster/parsecfg.go b/cluster/parsecfg.go index 9cafc13..93adc6a 100644 --- a/cluster/parsecfg.go +++ b/cluster/parsecfg.go @@ -55,7 +55,7 @@ func (cls *Cluster) readServiceConfig(filepath string) (map[string]interface{}, serviceCfg :=v.(map[string]interface{}) nodeId,ok := serviceCfg["NodeId"] if ok == false { - log.Fatal("NodeService list not find nodeId field: %+v",nodeServiceList) + log.SFatal("NodeService list not find nodeId field") } mapNodeService[int(nodeId.(float64))] = serviceCfg } diff --git a/event/event.go b/event/event.go index e0fd53b..de9d564 100644 --- a/event/event.go +++ b/event/event.go @@ -1,7 +1,6 @@ package event import ( - "fmt" "github.com/duanhf2012/origin/log" "runtime" "sync" @@ -217,8 +216,7 @@ func (processor *EventProcessor) EventHandler(ev IEvent) { if r := recover(); r != nil { buf := make([]byte, 4096) l := runtime.Stack(buf, false) - err := fmt.Errorf("%v: %s", r, buf[:l]) - log.Error("core dump info:%+v\n",err) + log.SError("core dump info:",r,":",string(buf[:l])) } }() @@ -233,7 +231,7 @@ func (processor *EventProcessor) EventHandler(ev IEvent) { func (processor *EventProcessor) pushEvent(event IEvent){ if len(processor.eventChannel)>=cap(processor.eventChannel){ - log.Error("event process channel is full,data:%+v!",event) + log.SError("event process channel is full,data:",event.GetEventType()) return } @@ -242,13 +240,13 @@ func (processor *EventProcessor) pushEvent(event IEvent){ func (processor *EventProcessor) castEvent(event IEvent){ if processor.mapListenerEvent == nil { - log.Error("mapListenerEvent not init!") + log.SError("mapListenerEvent not init!") return } eventProcessor,ok := processor.mapListenerEvent[event.GetEventType()] if ok == false || processor == nil{ - log.Debug("event type %d not listen.",event.GetEventType()) + log.SDebug("event type ",event.GetEventType()," not listen.") return } diff --git a/log/log.go b/log/log.go index c969854..d1c53c1 100644 --- a/log/log.go +++ b/log/log.go @@ -167,6 +167,23 @@ func (logger *Logger) doSPrintf(level int, printLevel string, a []interface{}) { logger.buf.AppendString(printLevel) for _,s := range a { switch s.(type) { + //case error: + // logger.buf.AppendString(s.(error).Error()) + case []string: + strSlice := s.([]string) + logger.buf.AppendByte('[') + for _,str := range strSlice { + logger.buf.AppendString(str) + logger.buf.AppendByte(',') + } + + lastIdx := logger.buf.Len()-1 + if logger.buf.Bytes()[lastIdx] == ',' { + logger.buf.Bytes()[lastIdx] = ']' + }else{ + logger.buf.AppendByte(']') + } + case int: logger.buf.AppendInt(int64(s.(int))) case int8: @@ -293,14 +310,15 @@ func (logger *Logger) doSPrintf(level int, printLevel string, a []interface{}) { }else{ logger.buf.AppendString("nil<*string>") } + case []byte: + logger.buf.AppendBytes(s.([]byte)) default: - b,err := json.Marshal(s) - if err != nil { - logger.buf.AppendString("") - }else{ - logger.buf.AppendBytes(b) - } - + //b,err := json.MarshalToString(s) + //if err != nil { + logger.buf.AppendString("") + //}else{ + //logger.buf.AppendBytes(b) + //} } } logger.buf.AppendByte('\n') diff --git a/network/http_server.go b/network/http_server.go index b5879b4..a9da037 100644 --- a/network/http_server.go +++ b/network/http_server.go @@ -42,7 +42,7 @@ func (slf *HttpServer) startListen() error { for _, caFile := range slf.caFileList { cer, err := tls.LoadX509KeyPair(caFile.CertFile, caFile.Keyfile) if err != nil { - log.Fatal("Load CA [%s]-[%s] file is fail:%s", caFile.CertFile, caFile.Keyfile, err.Error()) + log.SFatal("Load CA [",caFile.CertFile,"]-[",caFile.Keyfile,"] file is fail:",err.Error()) return err } tlsCaList = append(tlsCaList, cer) @@ -69,7 +69,7 @@ func (slf *HttpServer) startListen() error { } if err != nil { - log.Fatal("Listen for address %s failure:%+v.",slf.listenAddr,err) + log.SFatal("Listen for address ",slf.listenAddr," failure:",err.Error()) return err } diff --git a/network/tcp_client.go b/network/tcp_client.go index b38bedb..212976f 100644 --- a/network/tcp_client.go +++ b/network/tcp_client.go @@ -42,21 +42,21 @@ func (client *TCPClient) init() { if client.ConnNum <= 0 { client.ConnNum = 1 - log.Release("invalid ConnNum, reset to %v", client.ConnNum) + log.SRelease("invalid ConnNum, reset to ", client.ConnNum) } if client.ConnectInterval <= 0 { client.ConnectInterval = 3 * time.Second - log.Release("invalid ConnectInterval, reset to %v", client.ConnectInterval) + log.SRelease("invalid ConnectInterval, reset to ", client.ConnectInterval) } if client.PendingWriteNum <= 0 { client.PendingWriteNum = 1000 - log.Release("invalid PendingWriteNum, reset to %v", client.PendingWriteNum) + log.SRelease("invalid PendingWriteNum, reset to ", client.PendingWriteNum) } if client.NewAgent == nil { - log.Fatal("NewAgent must not be nil") + log.SFatal("NewAgent must not be nil") } if client.cons != nil { - log.Fatal("client is running") + log.SFatal("client is running") } client.cons = make(ConnSet) @@ -79,7 +79,7 @@ func (client *TCPClient) dial() net.Conn { return conn } - log.Warning("connect to %v error: %v", client.Addr, err) + log.SWarning("connect to ",client.Addr," error:", err.Error()) time.Sleep(client.ConnectInterval) continue } diff --git a/network/tcp_conn.go b/network/tcp_conn.go index 031ba9a..f9c04b7 100644 --- a/network/tcp_conn.go +++ b/network/tcp_conn.go @@ -89,7 +89,7 @@ func (tcpConn *TCPConn) GetRemoteIp() string { func (tcpConn *TCPConn) doWrite(b []byte) { if len(tcpConn.writeChan) == cap(tcpConn.writeChan) { tcpConn.ReleaseReadMsg(b) - log.Error("close conn: channel full") + log.SError("close conn: channel full") tcpConn.doDestroy() return } diff --git a/network/tcp_server.go b/network/tcp_server.go index 9040e7f..834d1a4 100644 --- a/network/tcp_server.go +++ b/network/tcp_server.go @@ -35,19 +35,19 @@ func (server *TCPServer) Start() { func (server *TCPServer) init() { ln, err := net.Listen("tcp", server.Addr) if err != nil { - log.Fatal("%v", err) + log.SFatal("Listen tcp error:", err.Error()) } if server.MaxConnNum <= 0 { server.MaxConnNum = 100 - log.Release("invalid MaxConnNum, reset to %v", server.MaxConnNum) + log.SRelease("invalid MaxConnNum, reset to ", server.MaxConnNum) } if server.PendingWriteNum <= 0 { server.PendingWriteNum = 100 - log.Release("invalid PendingWriteNum, reset to %v", server.PendingWriteNum) + log.SRelease("invalid PendingWriteNum, reset to ", server.PendingWriteNum) } if server.NewAgent == nil { - log.Fatal("NewAgent must not be nil") + log.SFatal("NewAgent must not be nil") } server.ln = ln @@ -89,7 +89,7 @@ func (server *TCPServer) run() { if max := 1 * time.Second; tempDelay > max { tempDelay = max } - log.Release("accept error: %v; retrying in %v", err, tempDelay) + log.SRelease("accept error:",err.Error(),"; retrying in ", tempDelay) time.Sleep(tempDelay) continue } @@ -102,7 +102,7 @@ func (server *TCPServer) run() { if len(server.conns) >= server.MaxConnNum { server.mutexConns.Unlock() conn.Close() - log.Debug("too many connections") + log.SWarning("too many connections") continue } server.conns[conn] = struct{}{} diff --git a/network/ws_client.go b/network/ws_client.go index 14dcd31..6c06b6b 100644 --- a/network/ws_client.go +++ b/network/ws_client.go @@ -38,29 +38,29 @@ func (client *WSClient) init() { if client.ConnNum <= 0 { client.ConnNum = 1 - log.Release("invalid ConnNum, reset to %v", client.ConnNum) + log.SRelease("invalid ConnNum, reset to ", client.ConnNum) } if client.ConnectInterval <= 0 { client.ConnectInterval = 3 * time.Second - log.Release("invalid ConnectInterval, reset to %v", client.ConnectInterval) + log.SRelease("invalid ConnectInterval, reset to ", client.ConnectInterval) } if client.PendingWriteNum <= 0 { client.PendingWriteNum = 100 - log.Release("invalid PendingWriteNum, reset to %v", client.PendingWriteNum) + log.SRelease("invalid PendingWriteNum, reset to ", client.PendingWriteNum) } if client.MaxMsgLen <= 0 { client.MaxMsgLen = 4096 - log.Release("invalid MaxMsgLen, reset to %v", client.MaxMsgLen) + log.SRelease("invalid MaxMsgLen, reset to ", client.MaxMsgLen) } if client.HandshakeTimeout <= 0 { client.HandshakeTimeout = 10 * time.Second - log.Release("invalid HandshakeTimeout, reset to %v", client.HandshakeTimeout) + log.SRelease("invalid HandshakeTimeout, reset to ", client.HandshakeTimeout) } if client.NewAgent == nil { - log.Fatal("NewAgent must not be nil") + log.SFatal("NewAgent must not be nil") } if client.cons != nil { - log.Fatal("client is running") + log.SFatal("client is running") } client.cons = make(WebsocketConnSet) @@ -77,7 +77,7 @@ func (client *WSClient) dial() *websocket.Conn { return conn } - log.Release("connect to %v error: %v", client.Addr, err) + log.SRelease("connect to ", client.Addr," error: ", err.Error()) time.Sleep(client.ConnectInterval) continue } diff --git a/network/ws_conn.go b/network/ws_conn.go index 79429dc..6c7f2f1 100644 --- a/network/ws_conn.go +++ b/network/ws_conn.go @@ -75,7 +75,7 @@ func (wsConn *WSConn) Close() { func (wsConn *WSConn) doWrite(b []byte) { if len(wsConn.writeChan) == cap(wsConn.writeChan) { - log.Debug("close conn: channel full") + log.SDebug("close conn: channel full") wsConn.doDestroy() return } diff --git a/network/ws_server.go b/network/ws_server.go index 58aa754..8546f01 100644 --- a/network/ws_server.go +++ b/network/ws_server.go @@ -41,7 +41,7 @@ func (handler *WSHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { } conn, err := handler.upgrader.Upgrade(w, r, nil) if err != nil { - log.Debug("upgrade error: %v", err) + log.SError("upgrade error: ", err.Error()) return } conn.SetReadLimit(int64(handler.maxMsgLen)) @@ -58,7 +58,7 @@ func (handler *WSHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(handler.conns) >= handler.maxConnNum { handler.mutexConns.Unlock() conn.Close() - log.Debug("too many connections") + log.SWarning("too many connections") return } handler.conns[conn] = struct{}{} @@ -79,27 +79,27 @@ func (handler *WSHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { func (server *WSServer) Start() { ln, err := net.Listen("tcp", server.Addr) if err != nil { - log.Fatal("%v", err) + log.SFatal("WSServer Listen fail:", err.Error()) } if server.MaxConnNum <= 0 { server.MaxConnNum = 100 - log.Release("invalid MaxConnNum, reset to %v", server.MaxConnNum) + log.SRelease("invalid MaxConnNum, reset to ", server.MaxConnNum) } if server.PendingWriteNum <= 0 { server.PendingWriteNum = 100 - log.Release("invalid PendingWriteNum, reset to %v", server.PendingWriteNum) + log.SRelease("invalid PendingWriteNum, reset to ", server.PendingWriteNum) } if server.MaxMsgLen <= 0 { server.MaxMsgLen = 4096 - log.Release("invalid MaxMsgLen, reset to %v", server.MaxMsgLen) + log.SRelease("invalid MaxMsgLen, reset to ", server.MaxMsgLen) } if server.HTTPTimeout <= 0 { server.HTTPTimeout = 10 * time.Second - log.Release("invalid HTTPTimeout, reset to %v", server.HTTPTimeout) + log.SRelease("invalid HTTPTimeout, reset to ", server.HTTPTimeout) } if server.NewAgent == nil { - log.Fatal("NewAgent must not be nil") + log.SFatal("NewAgent must not be nil") } if server.CertFile != "" || server.KeyFile != "" { @@ -110,7 +110,7 @@ func (server *WSServer) Start() { config.Certificates = make([]tls.Certificate, 1) config.Certificates[0], err = tls.LoadX509KeyPair(server.CertFile, server.KeyFile) if err != nil { - log.Fatal("%v", err) + log.SFatal("LoadX509KeyPair fail:", err.Error()) } ln = tls.NewListener(ln, config) diff --git a/node/node.go b/node/node.go index f585127..c82cce2 100644 --- a/node/node.go +++ b/node/node.go @@ -131,7 +131,7 @@ func initNode(id int){ nodeId = id err := cluster.GetCluster().Init(GetNodeId(),Setup) if err != nil { - log.Fatal("read system config is error %+v",err) + log.SFatal("read system config is error ",err.Error()) } err = initLog() @@ -227,8 +227,8 @@ func startNode(args interface{}) error{ return fmt.Errorf("invalid option %s",param) } - timer.StartTimer(10*time.Millisecond,100000) - log.Release("Start running server.") + timer.StartTimer(10*time.Millisecond,1000000) + log.SRelease("Start running server.") //2.初始化node initNode(nodeId) @@ -250,7 +250,7 @@ func startNode(args interface{}) error{ for bRun { select { case <-sig: - log.Debug("receipt stop signal.") + log.SRelease("receipt stop signal.") bRun = false case <- pProfilerTicker.C: profiler.Report() @@ -261,7 +261,7 @@ func startNode(args interface{}) error{ close(closeSig) service.WaitStop() - log.Debug("Server is stop.") + log.SRelease("Server is stop.") return nil } diff --git a/profiler/profiler.go b/profiler/profiler.go index c88df8a..15d847b 100644 --- a/profiler/profiler.go +++ b/profiler/profiler.go @@ -167,7 +167,7 @@ func DefaultReportFunction(name string,callNum int,costTime time.Duration,record elem = elem.Next() } - log.Release(strReport) + log.SRelease(strReport) } func Report() { diff --git a/rpc/client.go b/rpc/client.go index 821be36..6acf2eb 100644 --- a/rpc/client.go +++ b/rpc/client.go @@ -259,8 +259,7 @@ func (client *Client) Run(){ if r := recover(); r != nil { buf := make([]byte, 4096) l := runtime.Stack(buf, false) - err := fmt.Errorf("%v: %s\n", r, buf[:l]) - log.Error("core dump info:%+v",err) + log.SError("core dump info:",r,":", string(buf[:l])) } }() @@ -268,14 +267,14 @@ func (client *Client) Run(){ for { bytes,err := client.conn.ReadMsg() if err != nil { - log.Error("rpcClient %s ReadMsg error:%+v", client.Addr,err) + log.SError("rpcClient ",client.Addr," ReadMsg error:",err.Error()) return } processor := GetProcessor(uint8(bytes[0])) if processor==nil { client.conn.ReleaseReadMsg(bytes) - log.Error("rpcClient %s ReadMsg head error:%+v", client.Addr,err) + log.SError("rpcClient ",client.Addr," ReadMsg head error:",err.Error()) return } @@ -287,19 +286,19 @@ func (client *Client) Run(){ client.conn.ReleaseReadMsg(bytes) if err != nil { processor.ReleaseRpcResponse(response.RpcResponseData) - log.Error("rpcClient Unmarshal head error,error:%+v",err) + log.SError("rpcClient Unmarshal head error:",err.Error()) continue } v := client.RemovePending(response.RpcResponseData.GetSeq()) if v == nil { - log.Error("rpcClient cannot find seq %d in pending", response.RpcResponseData.GetSeq()) + log.SError("rpcClient cannot find seq ",response.RpcResponseData.GetSeq()," in pending") }else { v.Err = nil if len(response.RpcResponseData.GetReply()) >0 { err = processor.Unmarshal(response.RpcResponseData.GetReply(),v.Reply) if err != nil { - log.Error("rpcClient Unmarshal body error,error:%+v",err) + log.SError("rpcClient Unmarshal body error:",err.Error()) v.Err = err } } diff --git a/rpc/rpchandler.go b/rpc/rpchandler.go index 35786d3..7cad748 100644 --- a/rpc/rpchandler.go +++ b/rpc/rpchandler.go @@ -6,6 +6,7 @@ import ( "github.com/duanhf2012/origin/log" "reflect" "runtime" + "strconv" "strings" "unicode" "unicode/utf8" @@ -218,8 +219,7 @@ func (handler *RpcHandler) HandlerRpcResponseCB(call *Call){ if r := recover(); r != nil { buf := make([]byte, 4096) l := runtime.Stack(buf, false) - err := fmt.Errorf("%v: %s\n", r, buf[:l]) - log.Error("core dump info:%+v",err) + log.SError("core dump info:",r,":",string(buf[:l])) } }() @@ -240,8 +240,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) { if r := recover(); r != nil { buf := make([]byte, 4096) l := runtime.Stack(buf, false) - err := fmt.Errorf("%v: %s", r, buf[:l]) - log.Error("Handler Rpc %s Core dump info:%+v\n",request.RpcRequestData.GetServiceMethod(),err) + log.SError("Handler Rpc ",request.RpcRequestData.GetServiceMethod()," Core dump info:",r,":",string(buf[:l])) rpcErr := RpcError("call error : core dumps") if request.requestHandle!=nil { request.requestHandle(nil,rpcErr) @@ -256,8 +255,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) { if rawRpcId>0 { v,ok := handler.mapRawFunctions[rawRpcId] if ok == false { - err := fmt.Sprintf("RpcHandler cannot find request rpc id %d!",rawRpcId) - log.Error(err) + log.SError("RpcHandler cannot find request rpc id",rawRpcId) return } @@ -269,7 +267,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) { v,ok := handler.mapFunctions[request.RpcRequestData.GetServiceMethod()] if ok == false { err := "RpcHandler "+handler.rpcHandler.GetName()+"cannot find "+request.RpcRequestData.GetServiceMethod() - log.Error(err) + log.SError(err) if request.requestHandle!=nil { request.requestHandle(nil,RpcError(err)) } @@ -300,7 +298,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) { paramList = append(paramList,oParam) //输出参数 }else if request.requestHandle != nil && v.hasResponder==false{ //调用方有返回值，但被调用函数没有返回参数 rErr := "Call Rpc "+request.RpcRequestData.GetServiceMethod()+" without return parameter!" - log.Error(rErr) + log.SError(rErr) request.requestHandle(nil, RpcError(rErr)) return } @@ -319,9 +317,8 @@ func (handler *RpcHandler) CallMethod(ServiceMethod string,param interface{},rep var err error v,ok := handler.mapFunctions[ServiceMethod] if ok == false { - err = fmt.Errorf("RpcHandler %s cannot find %s", handler.rpcHandler.GetName(),ServiceMethod) - log.Error("%s",err.Error()) - + err = errors.New("RpcHandler "+ handler.rpcHandler.GetName()+" cannot find"+ServiceMethod) + log.SError(err.Error()) return err } @@ -343,11 +340,11 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor,bCast bool,nodeId int,s var pClientList [maxClusterNode]*Client err,count := handler.funcRpcClient(nodeId,serviceMethod,pClientList[:]) if count==0||err != nil { - log.Error("Call %s is error:%+v!",serviceMethod,err) + log.SError("Call ",serviceMethod," is error:",err.Error()) return err } if count > 1 && bCast == false{ - log.Error("Cannot call %s more then 1 node!",serviceMethod) + log.SError("Cannot call %s more then 1 node!",serviceMethod) return fmt.Errorf("Cannot call more then 1 node!") } @@ -359,8 +356,8 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor,bCast bool,nodeId int,s //判断是否是同一服务 findIndex := strings.Index(serviceMethod,".") if findIndex==-1 { - sErr := fmt.Errorf("Call serviceMethod %s is error!",serviceMethod) - log.Error("%+v", sErr) + sErr := errors.New("Call serviceMethod "+serviceMethod+" is error!") + log.SError(sErr.Error()) if sErr != nil { err = sErr } @@ -397,15 +394,15 @@ func (handler *RpcHandler) callRpc(nodeId int,serviceMethod string,args interfac var pClientList [maxClusterNode]*Client err,count := handler.funcRpcClient(nodeId,serviceMethod,pClientList[:]) if err != nil { - log.Error("Call serviceMethod is error:%+v!",err) + log.SError("Call serviceMethod is error:",err.Error()) return err }else if count <=0 { - err = fmt.Errorf("Call serviceMethod is error:cannot find %s",serviceMethod) - log.Error("%s",err.Error()) + err = errors.New("Call serviceMethod is error:cannot find "+serviceMethod) + log.SError(err.Error()) return err }else if count > 1 { - log.Error("Cannot call more then 1 node!") - return fmt.Errorf("Cannot call more then 1 node!") + log.SError("Cannot call more then 1 node!") + return errors.New("Cannot call more then 1 node!") } //2.rpcclient调用 @@ -416,8 +413,8 @@ func (handler *RpcHandler) callRpc(nodeId int,serviceMethod string,args interfac //判断是否是同一服务 findIndex := strings.Index(serviceMethod,".") if findIndex==-1 { - err := fmt.Errorf("Call serviceMethod %s is error!",serviceMethod) - log.Error("%+v",err) + err := errors.New("Call serviceMethod "+serviceMethod+"is error!") + log.SError(err.Error()) return err } serviceName := serviceMethod[:findIndex] @@ -449,20 +446,20 @@ func (handler *RpcHandler) callRpc(nodeId int,serviceMethod string,args interfac func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args interface{},callback interface{}) error { fVal := reflect.ValueOf(callback) if fVal.Kind()!=reflect.Func{ - err := fmt.Errorf("call %s input callback param is error!",serviceMethod) - log.Error("+v",err) + err := errors.New("call "+serviceMethod+" input callback param is error!") + log.SError(err.Error()) return err } if fVal.Type().NumIn()!= 2 { - err := fmt.Errorf("call %s callback param function is error!",serviceMethod) - log.Error("%+v",err) + err := errors.New("call "+serviceMethod+" callback param function is error!") + log.SError(err.Error()) return err } if fVal.Type().In(0).Kind() != reflect.Ptr || fVal.Type().In(1).String() != "error"{ - err := fmt.Errorf("call %s callback function param is error!",serviceMethod) - log.Error("%+v",err) + err := errors.New("call "+serviceMethod+" callback param function is error!") + log.SError(err.Error()) return err } @@ -470,18 +467,19 @@ func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args int var pClientList [maxClusterNode]*Client err,count := handler.funcRpcClient(nodeid,serviceMethod,pClientList[:]) if count==0||err != nil { + strNodeId := strconv.Itoa(nodeid) if err == nil { - err = fmt.Errorf("cannot find rpcclient from nodeid %d serviceMethod %s",nodeid,serviceMethod) + err = errors.New("cannot find rpcclient from nodeid "+strNodeId+" "+serviceMethod) } fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)}) - log.Error("Call serviceMethod is error:%+v!",err) + log.SError("Call serviceMethod is error:%+v!",err.Error()) return nil } if count > 1 { - err := fmt.Errorf("Cannot call more then 1 node!") + err := errors.New("Cannot call more then 1 node!") fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)}) - log.Error("Cannot call more then 1 node!") + log.SError(err.Error()) return nil } @@ -493,9 +491,9 @@ func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args int //判断是否是同一服务 findIndex := strings.Index(serviceMethod,".") if findIndex==-1 { - err := fmt.Errorf("Call serviceMethod %s is error!",serviceMethod) + err := errors.New("Call serviceMethod "+serviceMethod+" is error!") fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)}) - log.Error("%+v",err) + log.SError(err.Error()) return nil } serviceName := serviceMethod[:findIndex] @@ -567,13 +565,14 @@ func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType,nodeId in err,count := handler.funcRpcClient(nodeId,serviceName,pClientList[:]) if count==0||err != nil { //args.DoGc() - log.Error("Call serviceMethod is error:%+v!",err) + log.SError("Call serviceMethod is error:",err.Error()) return err } if count > 1 { //args.DoGc() - log.Error("Cannot call more then 1 node!") - return fmt.Errorf("Cannot call more then 1 node!") + err := errors.New("Cannot call more then 1 node!") + log.SError(err.Error()) + return err } //2.rpcclient调用 @@ -620,15 +619,17 @@ func (handler *RpcHandler) UnmarshalInParam(rpcProcessor IRpcProcessor,serviceMe if rawRpcMethodId>0 { v,ok := handler.mapRawFunctions[rawRpcMethodId] if ok == false { - err := fmt.Errorf("RpcHandler cannot find request rpc id %d!",rawRpcMethodId) - log.Error(err.Error()) + strRawRpcMethodId := strconv.FormatUint(uint64(rawRpcMethodId),10) + err := errors.New("RpcHandler cannot find request rpc id "+strRawRpcMethodId) + log.SError(err.Error()) return nil,err } msg,err := v.Unmarshal(inParam) if err != nil { - err := fmt.Errorf("RpcHandler cannot Unmarshal rpc id %d!",rawRpcMethodId) - log.Error(err.Error()) + strRawRpcMethodId := strconv.FormatUint(uint64(rawRpcMethodId),10) + err := errors.New("RpcHandler cannot Unmarshal rpc id "+strRawRpcMethodId) + log.SError(err.Error()) return nil,err } diff --git a/rpc/server.go b/rpc/server.go index bc32eda..840d171 100644 --- a/rpc/server.go +++ b/rpc/server.go @@ -1,6 +1,7 @@ package rpc import ( + "errors" "fmt" "github.com/duanhf2012/origin/log" "github.com/duanhf2012/origin/network" @@ -65,7 +66,7 @@ func (server *Server) Init(rpcHandleFinder RpcHandleFinder) { func (server *Server) Start(listenAddr string) { splitAddr := strings.Split(listenAddr,":") if len(splitAddr)!=2{ - log.Fatal("listen addr is error :%s",listenAddr) + log.SFatal("listen addr is error :",listenAddr) } server.rpcServer.Addr = ":"+splitAddr[1] @@ -98,13 +99,13 @@ func (agent *RpcAgent) WriteResponse(processor IRpcProcessor,serviceMethod strin defer processor.ReleaseRpcResponse(rpcResponse.RpcResponseData) if errM != nil { - log.Error("service method %s %+v Marshal error:%+v!", serviceMethod,rpcResponse,errM) + log.SError("service method ",serviceMethod," Marshal error:",errM.Error()) return } errM = agent.conn.WriteMsg([]byte{uint8(processor.GetProcessorType())},bytes) if errM != nil { - log.Error("Rpc %s return is error:%+v",serviceMethod,errM) + log.SError("Rpc ",serviceMethod," return is error:",errM.Error()) } } @@ -112,7 +113,7 @@ func (agent *RpcAgent) Run() { for { data,err := agent.conn.ReadMsg() if err != nil { - log.Error("remoteAddress:%s,read message: %v,",agent.conn.RemoteAddr().String(),err) + log.SError("remoteAddress:",agent.conn.RemoteAddr().String(),",read message: ",err.Error()) //will close tcpconn break } @@ -120,7 +121,7 @@ func (agent *RpcAgent) Run() { processor := GetProcessor(uint8(data[0])) if processor==nil { agent.conn.ReleaseReadMsg(data) - log.Error("remote rpc %s data head error:%+v",agent.conn.RemoteAddr(),err) + log.SError("remote rpc ",agent.conn.RemoteAddr()," data head error:",err.Error()) return } @@ -129,7 +130,7 @@ func (agent *RpcAgent) Run() { err = processor.Unmarshal(data[1:],req.RpcRequestData) agent.conn.ReleaseReadMsg(data) if err != nil { - log.Error("rpc Unmarshal request is error: %v", err) + log.SError("rpc Unmarshal request is error:", err.Error()) if req.RpcRequestData.GetSeq()>0 { rpcError := RpcError(err.Error()) if req.RpcRequestData.IsNoReply()==false { @@ -152,7 +153,7 @@ func (agent *RpcAgent) Run() { agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError) } ReleaseRpcRequest(req) - log.Debug("rpc request req.ServiceMethod is error") + log.SError("rpc request req.ServiceMethod is error") continue } @@ -163,7 +164,7 @@ func (agent *RpcAgent) Run() { agent.WriteResponse(processor,req.RpcRequestData.GetServiceMethod(),req.RpcRequestData.GetSeq(),nil,rpcError) } - log.Error("service method %s not config!", req.RpcRequestData.GetServiceMethod()) + log.SError("service method ",req.RpcRequestData.GetServiceMethod()," not config!") ReleaseRpcRequest(req) continue } @@ -181,7 +182,7 @@ func (agent *RpcAgent) Run() { if req.requestHandle!=nil { req.requestHandle(nil, RpcError(rErr)) } - log.Error(rErr) + log.SError(rErr) ReleaseRpcRequest(req) continue } @@ -230,8 +231,8 @@ func (server *Server) NewAgent(c *network.TCPConn) network.Agent { func (server *Server) myselfRpcHandlerGo(handlerName string,serviceMethod string, args interface{},reply interface{}) error { rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName) if rpcHandler== nil { - err := fmt.Errorf("service method %s not config!", serviceMethod) - log.Error("%s",err.Error()) + err := errors.New("service method "+serviceMethod+" not config!") + log.SError(err.Error()) return err } @@ -246,8 +247,8 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName) if rpcHandler== nil { pCall.Seq = 0 - pCall.Err = fmt.Errorf("service method %s not config!", serviceMethod) - log.Error("%s",pCall.Err.Error()) + pCall.Err = errors.New("service method "+serviceMethod+" not config!") + log.SError(pCall.Err.Error()) pCall.done <- pCall return pCall @@ -277,20 +278,20 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien if reply != nil && Returns != reply && Returns != nil { byteReturns, err := req.rpcProcessor.Marshal(Returns) if err != nil { - log.Error("returns data cannot be marshal",pCall.Seq) + log.SError("returns data cannot be marshal ",pCall.Seq) ReleaseRpcRequest(req) } err = req.rpcProcessor.Unmarshal(byteReturns, reply) if err != nil { - log.Error("returns data cannot be Unmarshal",pCall.Seq) + log.SError("returns data cannot be Unmarshal ",pCall.Seq) ReleaseRpcRequest(req) } } v := client.RemovePending(pCall.Seq) if v == nil { - log.Error("rpcClient cannot find seq %d in pending",pCall.Seq) + log.SError("rpcClient cannot find seq ",pCall.Seq," in pending") ReleaseRpcRequest(req) return } @@ -317,8 +318,8 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien func (server *Server) selfNodeRpcHandlerAsyncGo(client *Client,callerRpcHandler IRpcHandler,noReply bool,handlerName string,serviceMethod string,args interface{},reply interface{},callback reflect.Value) error { rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName) if rpcHandler== nil { - err := fmt.Errorf("service method %s not config!", serviceMethod) - log.Error("%+v",err) + err := errors.New("service method "+serviceMethod+" not config!") + log.SError(err.Error()) return err } @@ -339,7 +340,7 @@ func (server *Server) selfNodeRpcHandlerAsyncGo(client *Client,callerRpcHandler req.requestHandle = func(Returns interface{},Err RpcError){ v := client.RemovePending(callSeq) if v == nil { - log.Error("rpcClient cannot find seq %d in pending",pCall.Seq) + log.SError("rpcClient cannot find seq ",pCall.Seq," in pending") //ReleaseCall(pCall) ReleaseRpcRequest(req) return diff --git a/service/module.go b/service/module.go index 9db603f..79920a5 100644 --- a/service/module.go +++ b/service/module.go @@ -110,7 +110,7 @@ func (m *Module) AddModule(module IModule) (int64,error){ m.child[module.GetModuleId()] = module m.ancestor.getBaseModule().(*Module).descendants[module.GetModuleId()] = module - log.Debug("Add module %s completed", m.GetModuleName()) + log.SDebug("Add module ",module.GetModuleName()," completed") return module.GetModuleId(),nil } @@ -124,7 +124,7 @@ func (m *Module) ReleaseModule(moduleId int64){ pModule.GetEventHandler().Destroy() pModule.self.OnRelease() - log.Debug("Release module %s.", m.GetModuleName()) + log.SDebug("Release module ", pModule.GetModuleName()) for pTimer,_ := range pModule.mapActiveTimer { pTimer.Cancel() } diff --git a/service/service.go b/service/service.go index 6ccab8d..cf154e1 100644 --- a/service/service.go +++ b/service/service.go @@ -64,7 +64,7 @@ func (s *Service) OnSetup(iService IService){ func (s *Service) OpenProfiler() { s.profiler = profiler.RegProfiler(s.GetName()) if s.profiler==nil { - log.Fatal("rofiler.RegProfiler %s fail.", s.GetName()) + log.SFatal("rofiler.RegProfiler ",s.GetName()," fail.") } } @@ -88,7 +88,7 @@ func (s *Service) Init(iService IService,getClientFun rpc.FuncRpcClient,getServe func (s *Service) SetGoRoutineNum(goroutineNum int32) bool { //已经开始状态不允许修改协程数量,打开性能分析器不允许开多线程 if s.startStatus == true || s.profiler!=nil { - log.Error("open profiler mode is not allowed to set Multi-coroutine.") + log.SError("open profiler mode is not allowed to set Multi-coroutine.") return false } @@ -109,7 +109,7 @@ func (s *Service) Start() { } func (s *Service) Run() { - log.Debug("Start running Service %s.", s.GetName()) + log.SDebug("Start running Service ", s.GetName()) defer s.wg.Done() var bStop = false s.self.(IService).OnStart() @@ -184,12 +184,11 @@ func (s *Service) Release(){ if r := recover(); r != nil { buf := make([]byte, 4096) l := runtime.Stack(buf, false) - err := fmt.Errorf("%v: %s", r, buf[:l]) - log.Error("core dump info:%+v\n",err) + log.SError("core dump info:",r," : ",string(buf[:l])) } }() s.self.OnRelease() - log.Debug("Release Service %s.", s.GetName()) + log.SDebug("Release Service ", s.GetName()) } func (s *Service) OnRelease(){ diff --git a/sysservice/tcpservice/tcpservice.go b/sysservice/tcpservice/tcpservice.go index 31f8c65..8679751 100644 --- a/sysservice/tcpservice/tcpservice.go +++ b/sysservice/tcpservice/tcpservice.go @@ -189,7 +189,7 @@ func (slf *Client) Run() { slf.tcpConn.SetReadDeadline(slf.tcpService.ReadDeadline) bytes,err := slf.tcpConn.ReadMsg() if err != nil { - log.Debug("read client id %d is error:%+v",slf.id,err) + log.SDebug("read client id ",slf.id," is error:",err.Error()) break } data,err:=slf.tcpService.process.Unmarshal(bytes) diff --git a/util/timer/heap.go b/util/timer/heap.go index 1b0b672..8b47249 100644 --- a/util/timer/heap.go +++ b/util/timer/heap.go @@ -95,7 +95,7 @@ func tick() bool{ t := heap.Pop(&timerHeap).(*Timer) timerHeapLock.Unlock() if len(t.C)>= cap(t.C) { - log.Error("Timer channel full!") + log.SError("Timer channel full!") return true } diff --git a/util/timer/timer.go b/util/timer/timer.go index 4ed080f..a53fc3d 100644 --- a/util/timer/timer.go +++ b/util/timer/timer.go @@ -95,7 +95,7 @@ func (t *Timer) Do(){ buf := make([]byte, 4096) l := runtime.Stack(buf, false) err := fmt.Errorf("%v: %s", r, buf[:l]) - log.Error("core dump info:%+v\n", err) + log.SError("core dump info:", err.Error()) } }() t.cb()