RPCX源码学习-server端

认识RPC

1. RPC是什么东西？
   RPC: Remote Procedure Call（远程过程调用），是一个计算机通信协议。
   
   
2. 协议的主要内容是什么？
   该协议允许运行于一台计算机中的程序调用另一个地址空间（通常为一个开放网络中的一台计算机）的子程序，而程序员就像调用本地程序一样，无需额外的为这个交互作用编程（无需关注细节）。
   
   
3. 主要用来解决什么问题？
   解决分布式系统中服务之间的调用问题。
   使远程调用像本地方法调用一样方便，隐藏底层网络通信的复杂性，使我们更专注于业务。
   
   

4. 一次rpc通信会涉及到哪些角色？流程是什么样的？
   client: 客户端程序，调用的发起者
   client-stub: 将调用参数和方法按照约定的协议进行编码，然后传输到server
   server: 服务端程序，处理client的调用
   server-stub: 收到client的消息后，按照约定的协议进行解码，然后调用本地方法进行处理

   

RPCX框架简介

rpcx是一个分布式的RPC框架，由go语言开发，支持Zookepper、etcd、consul多种服务发现方式，多种服务路由方式，是目前性能最好的RPC框架之一。

详情见官网介绍: https://books.studygolang.com...

server端源码剖析

从入口开始，我们启动一个rpc服务时，需要通过NewServer方法去创建一个Server对象，源码如下：

// NewServer returns a server.
func NewServer(options ...OptionFn) *Server {
    s := &Server{ // 创建一个Server对象，给一些字段赋默认值
        Plugins:    &pluginContainer{},
        options:    make(map[string]interface{}),
        activeConn: make(map[net.Conn]struct{}),
        doneChan:   make(chan struct{}),
        serviceMap: make(map[string]*service),
        router:     make(map[string]Handler),
        AsyncWrite: false, // 除非你想benchmark或者极致优化，否则建议你设置为false
    }

    for _, op := range options {
        op(s)
    }

    // 设置tcp连接的keepAlive参数
    if s.options["TCPKeepAlivePeriod"] == nil {
        s.options["TCPKeepAlivePeriod"] = 3 * time.Minute
    }
    return s
}

Server结构如下：

type Handler func(ctx *Context) error

// Server is rpcx server that use TCP or UDP.
type Server struct {
    ln                 net.Listener // 监听器，用来监听服务端的端口
    readTimeout        time.Duration // 读取client请求数据包的超时时间
    writeTimeout       time.Duration // 给client写响应数据包的超时时间
    gatewayHTTPServer  *http.Server // http网管
    DisableHTTPGateway bool // should disable http invoke or not.
    DisableJSONRPC     bool // should disable json rpc or not.
    AsyncWrite         bool // set true if your server only serves few clients

    serviceMapMu sync.RWMutex // 读写锁，保护sericeMap的并发读写
    serviceMap   map[string]*service // 服务记录表

    router map[string]Handler

    mu         sync.RWMutex // 读写锁，保护activeConn的并发读写
    activeConn map[net.Conn]struct{} // 活跃连接记录表
    doneChan   chan struct{}
    seq        uint64 // server端id

    inShutdown int32
    onShutdown []func(s *Server)
    onRestart  []func(s *Server)

    // TLSConfig for creating tls tcp connection.
    tlsConfig *tls.Config
    // BlockCrypt for kcp.BlockCrypt
    options map[string]interface{}

    // CORS options 跨域
    corsOptions *CORSOptions
    // 插件
    Plugins PluginContainer

    // AuthFunc can be used to auth.
    AuthFunc func(ctx context.Context, req *protocol.Message, token string) error

    handlerMsgNum int32

    HandleServiceError func(error)
}

对象创建完成之后，需要我们来注册对外提供的服务，通过RegisterName方法来实现：

/*
    @name: 对外提供的服务名称
    @rcvr: 对外提供的服务对象的实例
*/
func (s *Server) RegisterName(name string, rcvr interface{}, metadata string) error {
    _, err := s.register(rcvr, name, true) // 创建service对象，存储到对象表中
    if err != nil {
        return err
    }
    if s.Plugins == nil {
        s.Plugins = &pluginContainer{}
    }
    return s.Plugins.DoRegister(name, rcvr, metadata)
}

// 注册service
func (s *Server) register(rcvr interface{}, name string, useName bool) (string, error) {
    // 加写锁
    s.serviceMapMu.Lock()
    defer s.serviceMapMu.Unlock()

    // 构造service对象
    service := new(service)
    service.typ = reflect.TypeOf(rcvr)
    service.rcvr = reflect.ValueOf(rcvr)
    sname := reflect.Indirect(service.rcvr).Type().Name() // Type
    if useName {
        sname = name
    }
    if sname == "" {
        errorStr := "rpcx.Register: no service name for type " + service.typ.String()
        log.Error(errorStr)
        return sname, errors.New(errorStr)
    }
    if !useName && !isExported(sname) {
        errorStr := "rpcx.Register: type " + sname + " is not exported"
        log.Error(errorStr)
        return sname, errors.New(errorStr)
    }
    service.name = sname

    // Install the methods
    // 将rcvr对象的所有方法查找出来
    service.method = suitableMethods(service.typ, true)

    if len(service.method) == 0 {
        var errorStr string

        // To help the user, see if a pointer receiver would work.
        method := suitableMethods(reflect.PtrTo(service.typ), false)
        if len(method) != 0 {
            errorStr = "rpcx.Register: type " + sname + " has no exported methods of suitable type (hint: pass a pointer to value of that type)"
        } else {
            errorStr = "rpcx.Register: type " + sname + " has no exported methods of suitable type"
        }
        log.Error(errorStr)
        return sname, errors.New(errorStr)
    }
    // 更新服务记录表
    s.serviceMap[service.name] = service
    return sname, nil
}

// DoRegister invokes DoRegister plugin.
func (p *pluginContainer) DoRegister(name string, rcvr interface{}, metadata string) error {
    var es []error
    for _, rp := range p.plugins {
        // 如果是RegisterPlugin类型的插件，会调用它的Register函数进行注册
        if plugin, ok := rp.(RegisterPlugin); ok {
            err := plugin.Register(name, rcvr, metadata)
            if err != nil {
                es = append(es, err)
            }
        }
    }

    if len(es) > 0 {
        return errors.NewMultiError(es)
    }
    return nil
}

服务注册完毕之后，就开始启动服务了：

// Serve starts and listens RPC requests.
// It is blocked until receiving connections from clients.
func (s *Server) Serve(network, address string) (err error) {
    var ln net.Listener
    // 设置监听器，监听地址中配置的端口
    ln, err = s.makeListener(network, address)
    if err != nil {
        return
    }
    // 如果选择http协议，走这里
    if network == "http" {
        s.serveByHTTP(ln, "")
        return nil
    }
    // 选择ws/wss协议走这里
    if network == "ws" || network == "wss" {
        s.serveByWS(ln, "")
        return nil
    }

    // try to start gateway
    // 尝试启动网关，如果是tcp协议，则会通过goroutine启动一个网关服务
    ln = s.startGateway(network, ln)
    // tcp协议走这里，开始处理监听端口处的数据
    return s.serveListener(ln)
}

// 获取端口数据并启动goroutine处理
func (s *Server) serveListener(ln net.Listener) error {
    var tempDelay time.Duration

    s.mu.Lock()
    s.ln = ln
    s.mu.Unlock()

    for {// 死循环
        // 有请求数据到达时，channel会返回数据
        conn, e := ln.Accept()
        if e != nil { // 错误处理
            select {
            case <-s.getDoneChan(): // 连接关闭，报错，跳出循环
                return ErrServerClosed
            default:
            }

            if ne, ok := e.(net.Error); ok && ne.Temporary() { // 短暂错误
                if tempDelay == 0 {
                    tempDelay = 5 * time.Millisecond
                } else {
                    tempDelay *= 2
                }

                if max := 1 * time.Second; tempDelay > max {
                    tempDelay = max
                }

                log.Errorf("rpcx: Accept error: %v; retrying in %v", e, tempDelay)
                time.Sleep(tempDelay)
                continue
            }

            if strings.Contains(e.Error(), "listener closed") {
                return ErrServerClosed
            }
            return e
        }
        tempDelay = 0

        // 如果是tcp连接，设置keepAlive相关参数
        if tc, ok := conn.(*net.TCPConn); ok {
            period := s.options["TCPKeepAlivePeriod"]
            if period != nil {
                tc.SetKeepAlive(true)
                tc.SetKeepAlivePeriod(period.(time.Duration))
                tc.SetLinger(10)
            }
        }

        // 有PostConnAcceptPlugin类型插件时，进行处理
        conn, ok := s.Plugins.DoPostConnAccept(conn)
        if !ok {
            conn.Close()
            continue
        }

        s.mu.Lock()
        // 记录活跃连接
        s.activeConn[conn] = struct{}{}
        s.mu.Unlock()

        if share.Trace {
            log.Debugf("server accepted an conn: %v", conn.RemoteAddr().String())
        }
        // 启动goroutine异步处理请求，继续开始下一次循环
        go s.serveConn(conn)
    }
}

监听到请求后，会启动一个goroutine进行异步处理，接下来看看请求的处理逻辑：

func (s *Server) serveConn(conn net.Conn) {
    if s.isShutdown() { // 异常处理，关闭连接
        s.closeConn(conn)
        return
    }

    defer func() {// 捕获异常，打印错误堆栈信息，关闭连接
        if err := recover(); err != nil {
            const size = 64 << 10
            buf := make([]byte, size)
            ss := runtime.Stack(buf, false)
            if ss > size {
                ss = size
            }
            buf = buf[:ss]
            log.Errorf("serving %s panic error: %s, stack:\n %s", conn.RemoteAddr(), err, buf)
        }

        if share.Trace {
            log.Debugf("server closed conn: %v", conn.RemoteAddr().String())
        }

        s.closeConn(conn)
    }()

    // TLS处理
    if tlsConn, ok := conn.(*tls.Conn); ok {
        if d := s.readTimeout; d != 0 {
            conn.SetReadDeadline(time.Now().Add(d))
        }
        if d := s.writeTimeout; d != 0 {
            conn.SetWriteDeadline(time.Now().Add(d))
        }
        if err := tlsConn.Handshake(); err != nil {
            log.Errorf("rpcx: TLS handshake error from %s: %v", conn.RemoteAddr(), err)
            return
        }
    }

    // 申请空间，存放请求数据
    r := bufio.NewReaderSize(conn, ReaderBuffsize)

    var writeCh chan *[]byte
    if s.AsyncWrite { // 如果设置了同步写，走这里
        writeCh = make(chan *[]byte, 1)
        defer close(writeCh)
        go s.serveAsyncWrite(conn, writeCh)
    }
    for {
        if s.isShutdown() {
            return
        }

        t0 := time.Now()
        if s.readTimeout != 0 { // 设置超时时间
            conn.SetReadDeadline(t0.Add(s.readTimeout))
        }

        // 创建上下文
        ctx := share.WithValue(context.Background(), RemoteConnContextKey, conn)
        // 获取请求数据
        req, err := s.readRequest(ctx, r)
        if err != nil { // 获取失败的处理逻辑
            protocol.FreeMsg(req)

            if err == io.EOF {
                log.Infof("client has closed this connection: %s", conn.RemoteAddr().String())
            } else if strings.Contains(err.Error(), "use of closed network connection") {
                log.Infof("rpcx: connection %s is closed", conn.RemoteAddr().String())
            } else if errors.Is(err, ErrReqReachLimit) {
                if !req.IsOneway() {
                    res := req.Clone()
                    res.SetMessageType(protocol.Response)
                    if len(res.Payload) > 1024 && req.CompressType() != protocol.None {
                        res.SetCompressType(req.CompressType())
                    }
                    handleError(res, err)
                    s.Plugins.DoPreWriteResponse(ctx, req, res, err)
                    data := res.EncodeSlicePointer()
                    if s.AsyncWrite {
                        writeCh <- data
                    } else {
                        conn.Write(*data)
                        protocol.PutData(data)
                    }
                    s.Plugins.DoPostWriteResponse(ctx, req, res, err)
                    protocol.FreeMsg(res)
                } else {
                    s.Plugins.DoPreWriteResponse(ctx, req, nil, err)
                }
                protocol.FreeMsg(req)
                continue
            } else {
                log.Warnf("rpcx: failed to read request: %v", err)
            }
            return
        }

        if s.writeTimeout != 0 {
            conn.SetWriteDeadline(t0.Add(s.writeTimeout))
        }

        if share.Trace {
            log.Debugf("server received an request %+v from conn: %v", req, conn.RemoteAddr().String())
        }

        // 更新上下文的值
        ctx = share.WithLocalValue(ctx, StartRequestContextKey, time.Now().UnixNano())
        closeConn := false
        if !req.IsHeartbeat() { // 不是心跳包
            err = s.auth(ctx, req) // 如果设置有auth防范，执行auth逻辑
            closeConn = err != nil
        }

        if err != nil { // auth失败的处理逻辑
            if !req.IsOneway() {
                res := req.Clone()
                res.SetMessageType(protocol.Response)
                if len(res.Payload) > 1024 && req.CompressType() != protocol.None {
                    res.SetCompressType(req.CompressType())
                }
                handleError(res, err)
                s.Plugins.DoPreWriteResponse(ctx, req, res, err)
                data := res.EncodeSlicePointer()
                if s.AsyncWrite {
                    writeCh <- data
                } else {
                    conn.Write(*data)
                    protocol.PutData(data)
                }
                s.Plugins.DoPostWriteResponse(ctx, req, res, err)
                protocol.FreeMsg(res)
            } else {
                s.Plugins.DoPreWriteResponse(ctx, req, nil, err)
            }
            protocol.FreeMsg(req)
            // auth failed, closed the connection
            if closeConn {
                log.Infof("auth failed for conn %s: %v", conn.RemoteAddr().String(), err)
                return
            }
            continue
        }

        go func() {//启动goroutine处理
            defer func() { // 处理结束，捕获异常
                if r := recover(); r != nil {
                    // maybe panic because the writeCh is closed.
                    log.Errorf("failed to handle request: %v", r)
                }
            }()

            // 原子操作，记录服务处理的消息数量
            atomic.AddInt32(&s.handlerMsgNum, 1)
            defer atomic.AddInt32(&s.handlerMsgNum, -1)

            if req.IsHeartbeat() { // 心跳包的处理逻辑
                s.Plugins.DoHeartbeatRequest(ctx, req)
                req.SetMessageType(protocol.Response)
                data := req.EncodeSlicePointer()
                if s.AsyncWrite {
                    writeCh <- data
                } else {
                    conn.Write(*data)
                    protocol.PutData(data)
                }
                protocol.FreeMsg(req)
                return
            }

            resMetadata := make(map[string]string)
            ctx = share.WithLocalValue(share.WithLocalValue(ctx, share.ReqMetaDataKey, req.Metadata),
                share.ResMetaDataKey, resMetadata)
            // 如果服务通过metadata设置了超时时间，则创建一个超时上下文
            cancelFunc := parseServerTimeout(ctx, req)
            if cancelFunc != nil {
                defer cancelFunc()
            }
            // 插件处理
            s.Plugins.DoPreHandleRequest(ctx, req)

            if share.Trace {
                log.Debugf("server handle request %+v from conn: %v", req, conn.RemoteAddr().String())
            }

            // first use handler
            if handler, ok := s.router[req.ServicePath+"."+req.ServiceMethod]; ok {
                sctx := NewContext(ctx, conn, req, writeCh)
                err := handler(sctx)
                if err != nil {
                    log.Errorf("[handler internal error]: servicepath: %s, servicemethod, err: %v", req.ServicePath, req.ServiceMethod, err)
                }

                return
            }

            // 处理请求
            res, err := s.handleRequest(ctx, req)
            if err != nil {
                if s.HandleServiceError != nil {
                    s.HandleServiceError(err)
                } else {
                    log.Warnf("rpcx: failed to handle request: %v", err)
                }
            }

            s.Plugins.DoPreWriteResponse(ctx, req, res, err)
            if !req.IsOneway() {
                if len(resMetadata) > 0 { // copy meta in context to request
                    meta := res.Metadata
                    if meta == nil {
                        res.Metadata = resMetadata
                    } else {
                        for k, v := range resMetadata {
                            if meta[k] == "" {
                                meta[k] = v
                            }
                        }
                    }
                }

                if len(res.Payload) > 1024 && req.CompressType() != protocol.None {
                    res.SetCompressType(req.CompressType())
                }
                data := res.EncodeSlicePointer()
                if s.AsyncWrite {
                    writeCh <- data
                } else {
                    conn.Write(*data)
                    protocol.PutData(data)
                }

            }

            s.Plugins.DoPostWriteResponse(ctx, req, res, err)

            if share.Trace {
                log.Debugf("server write response %+v for an request %+v from conn: %v", res, req, conn.RemoteAddr().String())
            }

            // 释放对象，放回对象池
            protocol.FreeMsg(req)
            protocol.FreeMsg(res)
        }()
    }
}

未完待续……