kudu源码分析之二传输者transfer

之一只是单纯的对一些全局常量进行声明以及定义，之二开始涉及一些rpc的操作。传输者transfer主要是对网络socket的write以及recv进行封装，负责发送rpc中的调用方法id以及参数。

#ifndef KUDU_RPC_TRANSFER_H
#define KUDU_RPC_TRANSFER_H

#include <boost/intrusive/list.hpp>
#include <gflags/gflags.h>
#include <set>
#include <stdint.h>
#include <string>
#include <vector>

#include "kudu/rpc/constants.h"
#include "kudu/util/net/sockaddr.h"
#include "kudu/util/status.h"
//与其他模块的依赖项较少
//容易自底向上进行分析

DECLARE_int32(rpc_max_message_size);

namespace google {
    namespace protobuf {
        class Message;
    } // namespace protobuf
} // namespace google

//google protobuf命名空间下 声明一个类 对kudu rpc的namespace有啥影响?
// 比较搞不懂为什么这样写 有读者可以跟我讲一下吗

namespace kudu {

    class Socket;
//socket
    namespace rpc {

        class Messenger;

        struct TransferCallbacks;

//信使类 调用reactor执行一些task
//用于transfer的一些回调函数
        class TransferLimits {
        public:
            enum {
                kMaxSidecars = 10,
                kMaxPayloadSlices = kMaxSidecars + 2 // (header + msg)
            };
//Transfer的限制 是数量还是啥 ?

            DISALLOW_IMPLICIT_CONSTRUCTORS(TransferLimits);
        };//不允许隐式构造


// 这个类被rpc层内部使用 用于表示一个内部接收的过程
//当一个connection接受数据时 接收transfer obj被创建
//当信息完全被接受 要么解析为client对server的一次调用 server接收到call
//或者是server调用的response返回,client接收这个reponse
//transfer obj被移交??啥意思 析构?
        class InboundTransfer {
        public:

            InboundTransfer();
//构造函数


            Status ReceiveBuffer(Socket &socket);

//从socket中接受信息到buffer

            bool TransferStarted() const;

//有一些字节开始被发送 返回true

            bool TransferFinished() const;

//如果整个transfer被发送 返回true

            Slice data() const {
                return Slice(buf_);
            }
//返回buf的内容 转换成Slice


            std::string StatusAsString() const;
//返回transfer的状态 比如接收了多少字节

        private:

            Status ProcessInboundHeader();
//
            faststring buf_;
//缓存区
            int32_t total_length_;
            int32_t cur_offset_;
//总长度 当前接收到数据的偏离量
            DISALLOW_COPY_AND_ASSIGN(InboundTransfer);
//不允许拷贝以及赋值
        };
// so that each time
// the Connection wakes up with a writable socket, it consumes more bytes off
// the next pending transfer in the queue.
// 当链接需要接受数据时 创建一个outbound transfer 封装这个过程
// 在connection里 obj有一个队列 每次connection唤醒一个可写socket
// 需要消耗更多字节 ??不是很懂 
//out transfer完成时 触发一个回调
        class OutboundTransfer : public boost::intrusive::list_base_hook<> {
        public:
            /
            // 工厂方法创建transfer 与调用请求或者响应 载荷(就是调用的方法 参数 返回值)会被写入socket
            //当transfer完成或者错误,调用callbacks


            // 不会占据callbacks的所有权 或者slices的底层内存
            //slices必须可用 在发送完成或者出错


            //payload有最大限制

            // 发请求
            static OutboundTransfer *CreateForCallRequest(int32_t call_id,
                                                          const std::vector <Slice> &payload,
                                                          TransferCallbacks *callbacks);

            //静态函数 返回一个transfer 输入调用id 载荷 以及完成发送的callbacks
            //发response
            static OutboundTransfer *CreateForCallResponse(const