C++博客-Error-文章分类-网狐棋牌源码分析

协议分析-服务器接收

Enic — Tue, 05 Jul 2011 05:15:00 GMT

在服务器哪里,网络通信有两个接口:IClientSocketSink IAttemperEngineSink
IClientSocketSink一般用用于网络服务器之间通信
IAttemperEngineSink用于和客户端通信

// logon server
CAttemperEngineSink::OnEventSocketRead
    MDM_GP_LOGON //登录消息
        SUB_GP_LOGON_ACCOUNTS //帐号登录
      CMD_GP_LogonByAccounts
  SUB_GP_LOGON_USERID //ID 登录
   CMD_GP_LogonByUserID
  SUB_GP_REGISTER_ACCOUNTS //注册帐号
      CMD_GP_RegisterAccounts

// gamer server
CAttemperEngineSink::OnEventSocketRead
MDM_GR_LOGON //登录消息
        SUB_GP_LOGON_ACCOUNTS //帐号登录
      CMD_GP_LogonByAccounts
  SUB_GP_LOGON_USERID //ID 登录
   CMD_GP_LogonByUserID
MDM_GR_USER //用户消息
  SUB_GR_USER_SIT_REQ //坐下桌子
  SUB_GR_USER_LOOKON_REQ //旁观桌子
   CMD_GR_UserSitReq
  SUB_GR_USER_STANDUP_REQ //起立请求
  SUB_GR_USER_LEFT_GAME_REQ //强退请求
  SUB_GR_USER_CHAT //聊天消息
   CMD_GR_UserChat
  SUB_GR_USER_WISPER //私语消息
   CMD_GR_Wisper
  SUB_GR_USER_RULE //用户规则
   CMD_GR_UserRule
  SUB_GR_USER_INVITE_REQ //邀请用户
   CMD_GR_UserInviteReq
MDM_GR_MANAGER //管理消息
  SUB_GR_SEND_WARNING: //警告消息
   CMD_GR_SendWarning
  SUB_GR_LOOK_USER_IP: //查看地址
      CMD_GR_LookUserIP
  SUB_GR_KILL_USER:  //踢出用户
   CMD_GR_KillUser
  SUB_GR_LIMIT_ACCOUNS: //禁用帐户
   CMD_GR_LimitAccounts
  SUB_GR_SET_USER_RIGHT: //用户权限
   CMD_GR_SetUserRight
  SUB_GR_SEND_MESSAGE: //发送消息
   CMD_GR_SendMessage
  SUB_GR_OPTION_SERVER: //房间设置
   CMD_GR_OptionServer
MDM_GF_FRAME //框架消息
MDM_GF_GAME //游戏消息

// center server
CAttemperEngineSink::OnEventSocketRead
MDM_CS_SERVER_LIST: //列表消息
  SUB_CS_GET_SERVER_LIST: //获取列表
MDM_CS_SERVER_MANAGER: //房间管理
  SUB_CS_REG_GAME_SERVER: //房间注册
  SUB_CS_UNREG_GAME_SERVER: //注销房间
  SUB_CS_SERVER_ONLINE_COUNT: //更新人数

Enic 2011-07-05 13:15 发表评论

协议分析：GamePlaza的网络协议（收）

Enic — Mon, 04 Jul 2011 05:48:00 GMT

通过对基础库的分析可以知道，客户端通过IClientSocket、IClientSocketSink和服务器通讯。
现在把问题集中起来，只分析客户端和服务器之间的接口，也就是IO
当前分析的模式是GamePlaza
CPlazaViewItem  CRoomViewItem这两个实现了IClientSocketSink接口，也就是说他们能接受服务器消息；
IClientSocketSink能响应三个事件OnSocketConnect  OnSocketRead  OnSocketClose
主要的数据交换应该是依赖OnSocketRead
CPlazaViewItem
    OnSocketRead
      MDM_GP_LOGON  //登陆消息
        SUB_GP_LOGON_SUCCESS  //登陆成功
          CMD_GP_LogonSuccess
          (接下来的叫扩展信息)
          DTP_USER_ACCOUNTS  //用户帐户
            数据由DataDescribe描述
          DTP_USER_PASS  //用户密码
            数据由DataDescribe描述
          DTP_USER_GROUP_NAME  //社团名字
            数据由DataDescribe描述
        SUB_GP_LOGON_ERROR  //登陆失败
      MDM_GP_SERVER_LIST  //列表消息
        SUB_GP_LIST_TYPE  //类型信息
          tagGameType数组
        SUB_GP_LIST_KIND  //种类消息
          tagGameKind数组
        SUB_GP_LIST_PROCESS  //进程信息
          tagGameProcess数组
        SUB_GP_LIST_STATION  //站点消息
          tagGameStation数组
        SUB_GP_LIST_SERVER  //服务器房间
          tagGameServer数组
        SUB_GP_LIST_FINISH  //列表发送完成
        SUB_GP_LIST_CONFIG  //列表配置
          CMD_GP_ListConfig
      MDM_GP_SYSTEM  //系统消息
        SUB_GP_VERSION  //版本信息
          CMD_GP_Version
CRoomViewItem
    OnSocketRead
        MDM_GR_LOGON  //登录消息
            SUB_GR_LOGON_SUCCESS  //登录成功
            SUB_GR_LOGON_ERROR  //登录失败
            SUB_GR_LOGON_FINISH  //登录完成
        MDM_GR_USER  //用户消息
            SUB_GR_USER_COME  //用户进入
                tagUserInfoHead
                    （附加）
                    DTP_USER_ACCOUNTS  //用户帐户
                    数据由DataDescribe描述
                    DTP_USER_GROUP_NAME  //社团名字
                    数据由DataDescribe描述
            SUB_GR_USER_STATUS  //用户状态
                CMD_GR_UserStatus
            SUB_GR_USER_SCORE  //用户分数
                CMD_GR_UserScore
            SUB_GR_SIT_FAILED  //坐下失败
                CMD_GR_SitFailed
            SUB_GR_USER_CHAT  //用户聊天
                CMD_GR_UserChat
            SUB_GR_USER_WISPER  //用户私语
                CMD_GR_Wisper
            SUB_GR_USER_INVITE  //邀请玩家
                CMD_GR_UserInvite
        MDM_GR_INFO  //配置信息
            SUB_GR_SERVER_INFO  //房间信息
                CMD_GR_ServerInfo
            SUB_GR_COLUMN_INFO  //列表解释
                CMD_GR_ColumnInfo
            SUB_GR_CONFIG_FINISH  //配置完成
        MDM_GR_STATUS  //状态信息
            SUB_GR_TABLE_INFO  //桌子信息
                CMD_GR_TableInfo
            SUB_GR_TABLE_STATUS  //桌子状态
                CMD_GR_TableStatus
        MDM_GR_SYSTEM  //系统消息
            SUB_GR_MESSAGE  //系统消息
                CMD_GR_Message
        MDM_GR_SERVER_INFO  //房间信息
            SUB_GR_ONLINE_COUNT_INFO  //在线信息
                tagOnLineCountInfo
        MDM_GF_GAME  //游戏消息
        MDM_GF_FRAME  //框架消息
            IPC_SocketPackage

Enic 2011-07-04 13:48 发表评论

工具类：收发包辅助类 CSendPacketHelpr CRecvPacketHelpr

Enic — Mon, 04 Jul 2011 02:50:00 GMT

应为协议都是遵循：len type data这样的结构，所以打包发送和接收解包可以有通用的做法，，，

//////////////////////////////////////////////////////////////////////////

//数据描述头
struct tagDataDescribe
{
WORD wDataSize; //数据大小
WORD wDataDescribe; //数据描述
};

//////////////////////////////////////////////////////////////////////////

//数据包辅助类（多包组合成一包）
class CSendPacketHelper
{
    //变量定义
protected:
    WORD                                m_wDataSize;                    //数据大小
    WORD                                m_wBufferSize;                    //缓冲大小
    BYTE                                * m_pcbBuffer;                    //缓冲指针

    //函数定义
public:
    //构造函数
    CSendPacketHelper(void * pcbBuffer, WORD wBufferSize)
    {
        m_wDataSize=0;
        m_wBufferSize=wBufferSize;
        m_pcbBuffer=(BYTE *)pcbBuffer;
    }
    //析构函数
    virtual ~CSendPacketHelper() {}

    //功能函数
public:
    //清理数据
    void CleanData() { m_wDataSize=0; }
    //获取大小
    WORD GetDataSize() { return m_wDataSize; }
    //获取缓冲
    void * GetDataBuffer() { return m_pcbBuffer; }
    //插入数据（如果缓冲区长度不够返回false）
    // wDataSize, wDataType 实际上就是DataDescribe
    bool AddPacket(void * pData, WORD wDataSize, WORD wDataType)
    {
        //效验大小
        ASSERT((wDataSize+sizeof(tagDataDescribe)+m_wDataSize)<=m_wBufferSize);
        if ((wDataSize+sizeof(tagDataDescribe)+m_wDataSize)>m_wBufferSize) return false;

        //插入数据
        ASSERT(m_pcbBuffer!=NULL);
        tagDataDescribe * pDataDescribe=(tagDataDescribe *)(m_pcbBuffer+m_wDataSize);
        pDataDescribe->wDataSize=wDataSize;
        pDataDescribe->wDataDescribe=wDataType;

        //插入数据
        if (wDataSize>0)
        {
            ASSERT(pData!=NULL);
            CopyMemory(pDataDescribe+1,pData,wDataSize);
        }

        //设置数据
        m_wDataSize+=sizeof(tagDataDescribe)+wDataSize;

        return true;
    }
};

/////////////////////////////////////////////////////////////////////////////////////////

//数据包辅助类
class CRecvPacketHelper
{
    //变量定义
protected:
    WORD                                m_wDataPos;                        //数据点
    WORD                                m_wDataSize;                    //数据大小
    BYTE                                * m_pcbBuffer;                    //缓冲指针

    //函数定义
public:
    //构造函数
    CRecvPacketHelper(LPCVOID pcbBuffer, WORD wDataSize)
    {
        m_wDataPos=0;
        m_wDataSize=wDataSize;
        m_pcbBuffer=(BYTE *)pcbBuffer;
    }
    //析构函数
    virtual ~CRecvPacketHelper() {}

    //功能函数
public:
    //获取数据（返回一包数据）
    // @DataDescribe：数据描述（len type）
    // @return: 数据
    void * GetData(tagDataDescribe & DataDescribe)
    {
        //效验数据
        if (m_wDataPos>=m_wDataSize)
        {
            ASSERT(m_wDataPos==m_wDataSize);
            DataDescribe.wDataSize=0;
            DataDescribe.wDataDescribe=DTP_NULL;
            return NULL;
        }

        //获取数据
        ASSERT((m_wDataPos+sizeof(tagDataDescribe))<=m_wDataSize);
        CopyMemory(&DataDescribe,m_pcbBuffer+m_wDataPos,sizeof(tagDataDescribe));
        ASSERT((m_wDataPos+sizeof(tagDataDescribe)+DataDescribe.wDataSize)<=m_wDataSize);

        //效验数据
        if ((m_wDataPos+sizeof(tagDataDescribe)+DataDescribe.wDataSize)>m_wDataSize)
        {
            DataDescribe.wDataSize=0;
            DataDescribe.wDataDescribe=DTP_NULL;
            return NULL;
        }

        //设置数据
        void * pData=NULL;
        if (DataDescribe.wDataSize>0) pData=m_pcbBuffer+m_wDataPos+sizeof(tagDataDescribe);
        m_wDataPos+=sizeof(tagDataDescribe)+DataDescribe.wDataSize;
        return pData;
    };
};

Enic 2011-07-04 10:50 发表评论

成也萧何败也肖何？ IUnknowEx

Enic — Fri, 10 Jun 2011 04:30:00 GMT

相关UML:

看下某个查询接口的代码：

//////////////////////////////////////////////////////////////////////////

//接口查询宏
#define QUERYINTERFACE(Interface,Guid,dwQueryVer)                                        \
    if ((Guid==IID_##Interface)&&(InterfaceVersionCheck(dwQueryVer,VER_##Interface)))    \
        return static_cast<Interface *>(this);

#define QUERYINTERFACE_IUNKNOWNEX(BaseInterface,Guid,dwQueryVer)                        \
    if ((Guid==IID_IUnknownEx)&&(InterfaceVersionCheck(dwQueryVer,VER_IUnknownEx)))        \
        return static_cast<IUnknownEx *>(static_cast<BaseInterface *>(this));

//获取接口宏
#define GET_MYSELF_INTERFACE(Interface)                                                    \
    ((Interface *)QueryInterface(IID_##Interface,VER_##Interface))

#define GET_OBJECT_INTERFACE(Object,Interface)                                            \
    ((Interface *)Object.QueryInterface(IID_##Interface,VER_##Interface))

#define GET_OBJECTPTR_INTERFACE(pObject,Interface)                                        \
    ((pObject==NULL)?NULL:((Interface *)pObject->QueryInterface(IID_##Interface,VER_##Interface)))

//////////////////////////////////////////////////////////////////////////

//接口查询
void * __cdecl CEventService::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
    QUERYINTERFACE(IEventService,Guid,dwQueryVer);
    QUERYINTERFACE_IUNKNOWNEX(IEventService,Guid,dwQueryVer);
    return NULL;
}

由于这个函数的存在，是的接口传递的类型检查由编译期转到了运行期。
任意接口的传递都只需要传递一个IUnknowEx指针，然后接受方使用IUnknowEx去判断是否是自己需要的接口。
这个机制是好是坏，难说，，，

Enic 2011-06-10 12:30 发表评论

服务引擎概览

Enic — Fri, 10 Jun 2011 03:57:00 GMT

相关UML：

服务引擎这是简单的聚合了其他的子模块，然后在Start中做些初始化的工作。

Enic 2011-06-10 11:57 发表评论

异步引擎

Enic — Thu, 09 Jun 2011 08:40:00 GMT

相关UML：

核心技术在于：在指定的线程中创建窗口，然后向窗口发送消息，在窗口消息处理中调用外部回调。

Enic 2011-06-09 16:40 发表评论

CEventService

Enic — Wed, 08 Jun 2011 16:13:00 GMT

相关UML：

线程安全的做一些格式化，然后一股脑输出到窗口句柄上，，，

Enic 2011-06-09 00:13 发表评论

DataBaseEngine

Enic — Wed, 08 Jun 2011 10:16:00 GMT

相关UML：

使用数据库引擎必须持有数据库引擎内部队列，实现数据库回调接口（用来处理数据库操作请求），然后结果投递到调度引擎队列。

理解网络狐棋牌，最重要是理解两个概念：
1，队列服务
2，接口的传递

晚上分析IEventService，明天应该能把IServiceEngine搞定 -_+!

Enic 2011-06-08 18:16 发表评论

TCPSocketEnging分析

Enic — Tue, 07 Jun 2011 15:28:00 GMT

相关UML：
网络引擎整体结构：

SocketItem细节：

先来看几个底层结构：

//重叠结构类
class COverLapped
{
    //变量定义
public:
    WSABUF                            m_WSABuffer;                        //数据指针
    OVERLAPPED                        m_OverLapped;                        //重叠结构
    const enOperationType            m_OperationType;                    //操作类型

    //函数定义
public:
    //构造函数
    COverLapped(enOperationType OperationType);
    //析构函数
    virtual ~COverLapped();

    //信息函数
public:
    //获取类型
    enOperationType GetOperationType() { return m_OperationType; }
};

//接收重叠结构
class COverLappedSend : public COverLapped
{
    //数据变量
public:
    BYTE                            m_cbBuffer[SOCKET_BUFFER];            //数据缓冲

    //函数定义
public:
    //构造函数
    COverLappedSend();
    //析构函数
    virtual ~COverLappedSend();
};

//重叠结构模板
template <enOperationType OperationType> class CATLOverLapped : public COverLapped
{
    //函数定义
public:
    //构造函数
    CATLOverLapped() : COverLapped(OperationType) {}
    //析构函数
    virtual ~CATLOverLapped() {}
};

先复习下基础，Windows下的网络模型有很多种，这里只拿出三种来说：
EventSelect：基于信号机制，以socket为单位绑定信号量，当socket上有指定的事件发生时激发信号，然后查询事件处理事件重设事件，继续在信号量上等待。其实也是在伯克利select模型上的换不换药的加强。
OverLapped：分两种工作模式完成回调，和完成事件。重叠IO监视每次操作，每次IO都绑定一个重叠对象，当操作完成以后激发信号或者调用回调。
IOCP：和overlapped类似，不过结果经过了Windows的预处理以队列的形式挂在完成端口上

根据上面的复习，可以得出一个结论，IOCP环境中每一次IO操作都需要一个重叠结构，那么一个CServerSocketItem至少需要如些这些东东：
他要接受数据，所以必须有一个接受数据的 OverLapped
它要发送数据，说以必须有一个发送数据的 OverLapped
netFox对OverLapped做了使用了类似池的的管理手段，他的Send都是不等待上一次完成就直接投递下一个请求了，，，这是很操蛋的做法，，，

然后继续复习下基础：
在EventSelect模型中获处理件类型流程是这样：
event受信，使用::WSAEnumNetworkEvents查询和这个event关联的socket发生的事件，根据查询到的事件类型去处理事件
在以每一次IO为查询对象重叠IO、IOCP模型中是这样：
使用GetOverlappedResult 或者 GetQueuedCompletionStatus然后根据重叠结构去查询投递的是什么类型的操作，然后找到关联的socket去操作，，，

这样必然要给OverLapped做个扩展，提供一种通过OverLapped查询操作类型和socket的能力。
通过分析代码，netFox关联socket是通过在创建完成端口的时候绑定SocketItem对象指针完成的，操作类型是通过对OverLapped结构加强完成的。
通过GetQueuedCompletionStatus获取到完成OverLapped以后使用一个宏：
（这是COverLapped类型） pSocketLapped=CONTAINING_RECORD(pOverLapped,COverLapped,m_OverLapped);
来获取包装后的OverLapped，然后获取操作类型，然后执行具体操作。
其实宏的展开如下：
（COverLapped*）((BYTE*)pOverLapped - (COverLapped*)(0)->m_OverLapped);
pOverLapped是获取到的某个COverLapped中的成员变量，(COverLapped*)(0)->m_OverLapped是到在COverLapped中的偏移，((BYTE*)pOverLapped - (COverLapped*)(0)->m_OverLapped) 就是根据pOverLapped推算出来的包含地址为pOverLapped作为成员变量m_OverLapped的COverLapped对象的地址。
然后就分别调用：

//发送完成函数
bool CServerSocketItem::OnSendCompleted(COverLappedSend * pOverLappedSend, DWORD dwThancferred);

//接收完成函数
bool CServerSocketItem::OnRecvCompleted(COverLappedRecv * pOverLappedRecv, DWORD dwThancferred);

为毛要区分Send OverLapped 和 Recv OverLapped呢，，，
应为投递一次Send不一定是瞬间完成的，在处理的过程中存储数据的内存应该是锁定的，也就是不允许修改的，，，所以OverLapped应该自己管理内存。
而recv应该也是需要有一片内存直接接受数据的，很奇怪netFox没有提供，，，

recv居然是在投递接受请求的时候给了一个空的buffer，然后在完成回调中自己再次调用recv方法接受数据。
接受有关的成员变量如下：

    //状态变量
protected:
    bool                            m_bNotify;                            //通知标志
    bool                            m_bRecvIng;                            //接收标志
    bool                            m_bCloseIng;                        //关闭标志
    bool                            m_bAllowBatch;                        //接受群发
    WORD                            m_wRecvSize;                        //接收长度
    BYTE                            m_cbRecvBuf[SOCKET_BUFFER*5];        //接收缓冲

int iRetCode=recv(m_hSocket,(char *)m_cbRecvBuf+m_wRecvSize,sizeof(m_cbRecvBuf)-m_wRecvSize,0);
难道这么蠢的做法只是为了躲开分包算法？
具体的看看接受代码：

//接收完成函数
bool CServerSocketItem::OnRecvCompleted(COverLappedRecv * pOverLappedRecv, DWORD dwThancferred)
{
    //效验数据
    ASSERT(m_bRecvIng==true);

    //设置变量
    m_bRecvIng=false;
    m_dwRecvTickCount=GetTickCount();

    //判断关闭
    if (m_hSocket==INVALID_SOCKET)
    {
        CloseSocket(m_wRountID);
        return true;
    }

    //接收数据
    int iRetCode=recv(m_hSocket,(char *)m_cbRecvBuf+m_wRecvSize,sizeof(m_cbRecvBuf)-m_wRecvSize,0);
    if (iRetCode<=0)
    {
        CloseSocket(m_wRountID);
        return true;
    }

    //接收完成
    m_wRecvSize+=iRetCode;
    BYTE cbBuffer[SOCKET_BUFFER];
    CMD_Head * pHead=(CMD_Head *)m_cbRecvBuf;

    //处理数据
    try
    {
        while (m_wRecvSize>=sizeof(CMD_Head))
        {
            //效验数据
            WORD wPacketSize=pHead->CmdInfo.wDataSize;
            if (wPacketSize>SOCKET_BUFFER) throw TEXT("数据包超长");
            if (wPacketSize<sizeof(CMD_Head)) throw TEXT("数据包非法");
            if (pHead->CmdInfo.cbMessageVer!=SOCKET_VER) throw TEXT("数据包版本错误");
            if (m_wRecvSize<wPacketSize) break;

            //提取数据
            CopyMemory(cbBuffer,m_cbRecvBuf,wPacketSize);
            WORD wRealySize=CrevasseBuffer(cbBuffer,wPacketSize);
            ASSERT(wRealySize>=sizeof(CMD_Head));
            m_dwRecvPacketCount++;

            //解释数据
            WORD wDataSize=wRealySize-sizeof(CMD_Head);
            void * pDataBuffer=cbBuffer+sizeof(CMD_Head);
            CMD_Command Command=((CMD_Head *)cbBuffer)->CommandInfo;

            //内核命令
            if (Command.wMainCmdID==MDM_KN_COMMAND)
            {
                switch (Command.wSubCmdID)
                {
                case SUB_KN_DETECT_SOCKET:    //网络检测
                    {
                        break;
                    }
                default: throw TEXT("非法命令码");
                }
            }
            else
            {
                //消息处理
                m_pIServerSocketItemSink->OnSocketReadEvent(Command,pDataBuffer,wDataSize,this);
            }

            //删除缓存数据
            m_wRecvSize-=wPacketSize;
            MoveMemory(m_cbRecvBuf,m_cbRecvBuf+wPacketSize,m_wRecvSize);
        }
    }
    catch ()
    {
        CloseSocket(m_wRountID);
        return false;
    }

    return RecvData();
}

这是还是有分包算法的，总的来说接受流程如下：
直接使用recv把数据接受到SocketItem的缓冲区中，当长度大于CMD_HEAD之后，进入处理阶段，处理head数据各种判断，然后将数据扔出去，再调整缓冲区，，，

简单的说：
Send完全不考虑同步问题，不管一个劲的网队列投递Send请求，，，这边处理队列也是直接Send完事，完全不考虑上一次是否send成功，，，
Recv更是莫名其妙的使用完成端口绕一圈还回到recv直接接受了，，，

很狗血的做法，，，

更正下我自己狗血的不理解：
如果一个服务器提交了非常多的重叠的receive在每一个连接上，那么限制会随着连接数的增长而变化。如果一个服务器能够预先估计可能会产生的最大并发连接数，服务器可以投递一个使用零缓冲区的receive在每一个连接上。因为当你提交操作没有缓冲区时，那么也不会存在内存被锁定了。使用这种办法后，当你的receive操作事件完成返回时，该socket底层缓冲区的数据会原封不动的还在其中而没有被读取到receive操作的缓冲区来。此时，服务器可以简单的调用非阻塞式的recv将存在socket缓冲区中的数据全部读出来，一直到recv返回 WSAEWOULDBLOCK 为止。这种设计非常适合那些可以牺牲数据吞吐量而换取巨大并发连接数的服务器。当然，你也需要意识到如何让客户端的行为尽量避免对服务器造成影响。在上一个例子中，当一个零缓冲区的receive操作被返回后使用一个非阻塞的recv去读取socket缓冲区中的数据，如果服务器此时可预计到将会有爆发的数据流，那么可以考虑此时投递一个或者多个receive 来取代非阻塞的recv来进行数据接收。（这比你使用1个缺省的8K缓冲区来接收要好的多。）

源码中提供了一个简单实用的解决WSAENOBUF错误的办法。我们执行了一个零字节缓冲的异步WSARead(...)(参见 OnZeroByteRead(..))。当这个请求完成，我们知道在TCP/IP栈中有数据，然后我们通过执行几个有MAXIMUMPACKAGESIZE缓冲的异步WSARead(...)去读，解决了WSAENOBUFS问题。但是这种解决方法降低了服务器的吞吐量。

总结：

解决方法一：

投递使用空缓冲区的 receive操作，当操作返回后，使用非阻塞的recv来进行真实数据的读取。因此在完成端口的每一个连接中需要使用一个循环的操作来不断的来提交空缓冲区的receive操作。

解决方法二：

在投递几个普通含有缓冲区的receive操作后，进接着开始循环投递一个空缓冲区的receive操作。这样保证它们按照投递顺序依次返回，这样我们就总能对被锁定的内存进行解锁。

///////////

如果一个服务器同时连接了许多客户端, 对每个客户端又调用了许多 WSARecv, 那么大量的内存将会被锁定到非分页内存池. 锁定这些内存时是按照页面边界来锁定的, 也就是说即使你 WSARecv 的缓存大小是 1 字节, 被锁定的内存也将会是 4k. 非分页内存池是由整个系统共用的, 如果用完的话最坏的情况就是系统崩溃. 一个解决办法是, 使用大小为 0 的缓冲区调用 WSARecv. 等到调用成功时再换用非阻塞的 recv 接收到来的数据, 直到它返回 WSAEWOULDBLOCK 表明数据已经全部读完. 在这个过程中没有任何内存需要被锁定, 但坏处是效率稍低.

Enic 2011-06-07 23:28 发表评论

TimerEngine

Enic — Tue, 07 Jun 2011 07:13:00 GMT

相关UML：

CTimerEngine成员变量：

    //状态变量
    DWORD                                m_dwTimerSpace;                    //时间间隔，这个值后来应该是给了定时器线程
protected:
    bool                                m_bService;                        //运行标志
    DWORD                                m_dwTimePass;                    //经过时间
    DWORD                                m_dwTimeLeave;                    //倒计时间
    CTimerItemPtr                        m_TimerItemFree;                //空闲数组
    CTimerItemPtr                        m_TimerItemActive;                //活动数组

这些是分析定时器线程函数需要了解的成员变量，其次是线程同步：
从代码中可以看出所有对：m_TimerItemActive; m_TimerItemFree;的操作都是在一个线程锁的保护之下的。

定时器线程：
通过CTimerThread绕一圈以后最终被循环执行的实际上是这个函数（m_dwTimerSpace控制最小时间）：

//定时器通知
void CTimerEngine::OnTimerThreadSink()
{
    //锁定资源
    CThreadLockHandle LockHandle(&m_ThreadLock);

    //倒计时间
    if (m_dwTimeLeave==NO_TIME_LEFT)
    {
        ASSERT(m_TimerItemActive.GetCount()==0);
        return;
    }

    //减少时间
    ASSERT(m_dwTimeLeave>=m_dwTimerSpace);
    m_dwTimeLeave-=m_dwTimerSpace;
    m_dwTimePass+=m_dwTimerSpace;

    //查询定时器
    if (m_dwTimeLeave==0)
    {
        bool bKillTimer=false;
        tagTimerItem * pTimerItem=NULL;
        DWORD dwTimeLeave=NO_TIME_LEFT;
        for (INT_PTR i=0;i<m_TimerItemActive.GetCount();)
        {
            //效验参数
            pTimerItem=m_TimerItemActive[i];
            ASSERT(pTimerItem!=NULL);
            ASSERT(pTimerItem->dwTimeLeave>=m_dwTimePass);

            //定时器处理
            bKillTimer=false;
            // 这一行做了--操作
            pTimerItem->dwTimeLeave -= m_dwTimePass;
            if (pTimerItem->dwTimeLeave==0L)
            {
                //发送通知
                m_AttemperEvent.PostTimerEvent(pTimerItem->wTimerID,pTimerItem->wBindParam);

                //设置次数
                if (pTimerItem->dwRepeatTimes!=TIMER_REPEAT_TIMER)
                {
                    ASSERT(pTimerItem->dwRepeatTimes>0);
                    if (pTimerItem->dwRepeatTimes==1L)
                    {
                        bKillTimer=true;
                        m_TimerItemActive.RemoveAt(i);
                        m_TimerItemFree.Add(pTimerItem);
                    }
                    else pTimerItem->dwRepeatTimes--;
                }

                //设置时间，从新开始倒计时
                if (bKillTimer==false) pTimerItem->dwTimeLeave=pTimerItem->dwElapse;
            }

            //增加索引
            if (bKillTimer==false)
            {
                i++;
                dwTimeLeave=__min(dwTimeLeave,pTimerItem->dwTimeLeave);
                ASSERT(dwTimeLeave%m_dwTimerSpace==0);
            }
        }

        //设置响应
        m_dwTimePass=0L;
        m_dwTimeLeave=dwTimeLeave;
    }

    return;
}

CTimerEngine：
启动一个定时器线程，循环遍历定时器，如果发现满足出发条件的定时器就投递一个定时器消息到CQueueServiceEvent对象。

Enic 2011-06-07 15:13 发表评论

调度引擎初步分析

Enic — Tue, 07 Jun 2011 01:37:00 GMT

摘要: 相关UML：CAttempterEngine实现了两个接口：IQueueServiceSink、IAttemperEngine;通过前面的分析，偶们了解到，IQueueServiceSink这个接口被是用来处理CQueueService中的数据的，根据上面的UML我们可以看到，CAttemperEngine关联了一个CQueueService（或者直接点说是：持有了一个CQueueService对... 阅读全文

Enic 2011-06-07 09:37 发表评论

CQueueServiceEvent初步分析

Enic — Thu, 02 Jun 2011 06:36:00 GMT

相关UML：

代码分析：
首先CQueueServiceEvent这个名字很有诱惑，，，你感觉他是一个事件，其实不是。它实际的功能应该是一个带打包功能的事件队列，，，或者说是一个像指定的类似EventQueue的东东中投递事件。从接口上看，这个东东能投递TimerEvent DataBaseEvent SocketAcceptEvent SocketReadEvent SocketCloseEvent
应为它本身持有一个CQueueService指针，所以本身并不负责数据管理，只负责打包并添加到CQueueService实例中去。

先看定时器事件：

1    //定时器事件
2    bool PostTimerEvent(WORD wTimerID, WPARAM wBindParam)
3    {
4        //效验参数
5        ASSERT(m_pIQueueService!=NULL);
6        if (m_pIQueueService==NULL) return false;
7
8        //缓冲锁定
9        CThreadLockHandle BufferLockHandle(&m_BufferLock);
10
11        //投递消息
12        NTY_TimerEvent * pTimerEvent=(NTY_TimerEvent *)m_cbBuffer;
13        pTimerEvent->wTimerID=wTimerID;
14        pTimerEvent->wBindParam=wBindParam;
15        m_pIQueueService->AddToQueue(EVENT_TIMER,m_cbBuffer,sizeof(NTY_TimerEvent));
16
17        return true;
18    }

嗯哼，代码质量很高哈，，，
入口都有断言在debug阶段帮助暴露错误，断言之后还有if语句再次判断，这样即使release版本错误也不会被漏掉，，，
关于事件的封装，在这里其实已经分层了，，，

这里是第一层：

1struct tagDataHead
2{
3    WORD                            wDataSize;                            //数据大小
4    WORD                            wIdentifier;                        //类型标识
5    DWORD                            dwInsertTime;                        //插入时间
6};

这一层实际上是由CDataStorage负责打包管理，在CQueueServiceEvent执行PostTimerEvent操作的时候会在内部调用CQueueService的add最终调用到CDataStrorage的Add来打包数据,这里的结构也是非常像网络数据包|- len -|- type -|- data -|。
在来看Post这一层做的数据打包：

1//定时器事件
2struct NTY_TimerEvent
3{
4 WORD wTimerID; //定时器 ID
5 WPARAM wBindParam; //绑定参数
6};

|- len -|- type -|- sub protocl -|。
其他事件的打包过程都是类似的：

1//数据库请求事件
2struct NTY_DataBaseEvent
3{
4    WORD                            wIndex;                                //对象索引
5    WORD                            wRoundID;                            //对象标识
6    WORD                            wRequestID;                            //请求标识
7};
8
9//网络应答事件
10struct NTY_SocketAcceptEvent
11{
12    WORD                            wIndex;                                //连接索引
13    WORD                            wRoundID;                            //连接标识
14    DWORD                            dwClientIP;                            //连接地址
15};
16
17//网络读取事件
18struct NTY_SocketReadEvent
19{
20    WORD                            wIndex;                                //连接索引
21    WORD                            wRoundID;                            //连接标识
22    WORD                            wDataSize;                            //数据大小
23    CMD_Command                        Command;                            //命令信息
24};
25
26//网络关闭事件
27struct NTY_SocketCloseEvent
28{
29    WORD                            wIndex;                                //连接索引
30    WORD                            wRoundID;                            //连接标识
31    DWORD                            dwClientIP;                            //连接地址
32    DWORD                            dwConnectSecond;                    //连接时间
33};

还是一样，一句话总结CQueueServiceEvent：
线程安全的接受各种异步事件，并打包封装好以后插入到关联的制定IQueueService中.

Enic 2011-06-02 14:36 发表评论

ServerKernel中的IQueueService接口分析

Enic — Mon, 30 May 2011 08:10:00 GMT

相关UML如下：

添加：

处理

关键代码解析：

1//开始服务
2bool __cdecl CQueueService::StartService()
3{
4    //效验参数
5    ASSERT(m_bService==false);
6    ASSERT(m_hCompletionPort==NULL);
7    ASSERT(m_pIQueueServiceSink!=NULL);
8
9    //建立完成端口
10    //! 需要追踪一下这里的完成端口句柄
11    //! 首先分析这里的创建，INVALID_HANDLE_VALUE表示没有关联任何文件句柄，也就是
12    //! 说不存在某个实现某个操作完成以后系统自动给这个完成端口post一个完成消息的概念
13    //! 然后这里用限制工作线程数是1，也就是同意时刻只会有一条线程受到完成消息
14    m_hCompletionPort=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,NULL,1);
15    if (m_hCompletionPort==NULL) throw TEXT("队列对象完成端口创建失败");
16
17    //启动线程
18    if (m_QueueServiceThread.InitThread(m_hCompletionPort)==false) throw TEXT("队列对象线程初始化失败");
19    if (m_QueueServiceThread.StartThead()==false) throw TEXT("队列对象线程启动失败");
20
21    //设置参数
22    m_bService=true;
23
24    return true;
25}

m_QueueServiceThread.InitThread(m_hCompletionPort);
他悄悄的给完成端口句柄扔给了服务线程，偶们去看看服务线程拿这玩意干了啥，，，

//运行函数
bool CQueueServiceThread::RepetitionRun()
{
    //效验参数
    ASSERT(m_hCompletionPort!=NULL);

    //变量定义
    DWORD dwThancferred=0;
    OVERLAPPED * pOverLapped=NULL;
    CQueueService * pQueueService=NULL;

    //等待完成端口
    if (GetQueuedCompletionStatus(m_hCompletionPort,&dwThancferred,(PULONG_PTR)&pQueueService,&pOverLapped,INFINITE))
    {
        //判断退出
        if (pQueueService==NULL) return false;

        //获取数据
        tagDataHead DataHead;
        bool bSuccess=pQueueService->GetData(DataHead,m_cbBuffer,sizeof(m_cbBuffer));
        ASSERT(bSuccess==true);

        //处理数据
        if (bSuccess==true) pQueueService->OnQueueServiceThread(DataHead,m_cbBuffer,DataHead.wDataSize);

        return true;
    }

    return false;
}

秘密在此：
GetQueuedCompletionStatus(m_hCompletionPort,&dwThancferred,(PULONG_PTR)&pQueueService,&pOverLapped,INFINITE)
m_hCompletionPort是通过线程参数传递进来的，dwThancferred和pQueueService是在之前CQueueService::AddToQueue()中Post过来的参数，，，

//加入数据
bool __cdecl CQueueService::AddToQueue(WORD wIdentifier, void * const pBuffer, WORD wDataSize)
{
    CThreadLockHandle LockHandle(&m_ThreadLock);
    m_DataStorage.AddData(wIdentifier,pBuffer,wDataSize);
    PostQueuedCompletionStatus(m_hCompletionPort,wDataSize,(ULONG_PTR)this,NULL);
    return true;
}

数据经过完成端口在CQueueServiceThread绕一圈以后会回到CQueueService::OnQueueServiceThread()

//数据消息
void CQueueService::OnQueueServiceThread(const tagDataHead & DataHead, void * pBuffer, WORD wDataSize)
{
    ASSERT(m_pIQueueServiceSink!=NULL);
    try
    {
        m_pIQueueServiceSink->OnQueueServiceSink(DataHead.wIdentifier,pBuffer,DataHead.wDataSize,DataHead.dwInsertTime);
    }
    catch () {}
    return;
}

这样队列服务就完成了他的使命，将执行的消息，异步的交给指定接口去处理，，，

稍后将对列队列服务做个宏观上的的分析，，，下班时间到，，，回去继续，，，

用一句话来描述QueueService模块就是：
将队列的插入和处理通过关联到完成端口上以实现在IOCP线程池管理下异步处理；
Add以后投递完成消息，在完成端口上监听的线程受到消息以后读取数据并处理；

Enic 2011-05-30 16:10 发表评论