Ma/origin
1
0
Fork 0
mirror of https://github.com/duanhf2012/origin.git synced 2026-02-03 22:45:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

优化日志，避免一些变量的逃逸

Browse Source
This commit is contained in:
boyce
2021-07-01 16:27:48 +08:00
parent 7392d90ef2
commit d9333e31c0
22 changed files with 157 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
cluster/cluster.go
View File

@@ -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
}

10
cluster/dynamicdiscovery.go
View File

@@ -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())
}
}

2
cluster/parsecfg.go
View File

@@ -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
}

10
event/event.go
View File

@@ -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
}

30
log/log.go
View File

@@ -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 {
//b,err := json.MarshalToString(s)
//if err != nil {
logger.buf.AppendString("<unknown type>")
}else{
logger.buf.AppendBytes(b)
}
//}else{
//logger.buf.AppendBytes(b)
//}
}
}
logger.buf.AppendByte('\n')

4
network/http_server.go
View File

@@ -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
}

12
network/tcp_client.go
View File

@@ -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
}

2
network/tcp_conn.go
View File

@@ -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
}

12
network/tcp_server.go
View File

@@ -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{}{}

16
network/ws_client.go
View File

@@ -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
}

2
network/ws_conn.go
View File

@@ -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
}

18
network/ws_server.go
View File

@@ -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)

10
node/node.go
View File

@@ -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
}

2
profiler/profiler.go
View File

@@ -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() {

13
rpc/client.go
View File

@@ -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
}
}

83
rpc/rpchandler.go
View File

@@ -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
}

39
rpc/server.go
View File

@@ -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

4
service/module.go
View File

@@ -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()
}

11
service/service.go
View File

@@ -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(){

2
sysservice/tcpservice/tcpservice.go
View File

@@ -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)

2
util/timer/heap.go
View File

@@ -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
}

2
util/timer/timer.go
View File

@@ -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()