Linux后台服务端（四）

主模块的实现

CServer.h

#pragma once
#include "Socket.h"
#include "Epoll.h"
#include "ThreadPool.h"
#include "Process.h"
class CBusiness
{
public:
 virtual int BusinessProcess() = 0;
 template<typename _FUNCTION_, typename...
_ARGS_>
 int setConnectedCallback(_FUNCTION_ func,
_ARGS_... args) {
m_connectedcallback = new CFunction<
_FUNCTION_, _ARGS_...>(func, args...);
 if (m_connectedcallback == NULL)return
-1;
 return 0;
 }
 template<typename _FUNCTION_, typename...
_ARGS_>
 int setRecvCallback(_FUNCTION_ func,
_ARGS_... args) {
 m_recvcallback = new CFunction<
_FUNCTION_, _ARGS_...>(func, args...);
 if (m_recvcallback == NULL)return -1;
 return 0;
 }
private:
 CFunctionBase* m_connectedcallback;
 CFunctionBase* m_recvcallback;
};
class CServer
{
public:
 CServer();
 ~CServer() { Close(); }
 CServer(const CServer&) = delete;
 CServer& operator=(const CServer&) = delete;
public:
 int Init(CBusiness* business, const Buffer&
ip = "127.0.0.1", short port = 9999);
 int Run();
 int Close();
private:
 int ThreadFunc();
private:
 CThreadPool m_pool;
 CSocketBase* m_server;
 CEpoll m_epoll;
 CProcess m_process;
 CBusiness* m_business;//业务模块 需要我们手动
delete
};

CServer.cpp

#include "CServer.h"
#include "Logger.h"
CServer::CServer()
{
 m_server = NULL;
 m_business = NULL;
}
int CServer::Init(CBusiness* business, const
Buffer& ip, short port)
{
 int ret = 0;
 if (business == NULL)return -1;
 m_business = business;
 ret =
m_process.SetEntryFunction(&CBusiness::BusinessPr
ocess, m_business);
 if (ret != 0)return -2;
 ret = m_process.CreateSubProcess();
 if (ret != 0)return -3;
 ret = m_pool.Start(2);
 if (ret != 0)return -4;
 ret = m_epoll.Create(2);
 if (ret != 0)return -5;
 m_server = new CSocket();
 if (m_server == NULL)return -6;
 ret = m_server->Init(CSockParam(ip, port,
SOCK_ISSERVER | SOCK_ISIP));
 if (ret != 0)return -7;
 ret = m_epoll.Add(*m_server,
EpollData((void*)m_server));
 if (ret != 0)return -8;
 for (size_t i = 0; i < m_pool.Size(); i++) {
 ret =
m_pool.AddTask(&CServer::ThreadFunc, this);
 if (ret != 0)return -9;
 }
 return 0;
}
int CServer::Run()
{
 while (m_server != NULL) {
 usleep(10);
 }
 return 0;
}
int CServer::Close()
{
 if (m_server) {
 CSocketBase* sock = m_server;
 m_server = NULL;
 m_epoll.Del(*sock);
 delete sock;
 }
 m_epoll.Close();
 m_process.SendFD(-1);
 m_pool.Close();
 return 0;
}
int CServer::ThreadFunc()
{
 int ret = 0;
 EPEvents events;
 while ((m_epoll != -1) && (m_server != NULL))
{
 ssize_t size =
m_epoll.WaitEvents(events);
 if (size < 0)break;
 if (size > 0) {
 for (ssize_t i = 0; i < size; i++)
 {
 if (events[i].events & EPOLLERR)
{
 break;
 }
 else if (events[i].events &
EPOLLIN) {
 if (m_server) {
 CSocketBase* pClient =
NULL;
 ret = m_server-
>Link(&pClient);
 if (ret != 0)continue;
 ret =
m_process.SendFD(*pClient);
 delete pClient;
 if (ret != 0) {
 TRACEE("send client
%d failed!", (int)*pClient);
 continue;
 }
 }
 }
 }
 }
 }
 return 0;

客户端处理模块的设计

基本流程图

CEdoyunPlayerServer.h

#pragma once
#include "Logger.h"
#include "CServer.h"
#include <map>
/*
* 1. 客户端的地址问题
* 2. 连接回调的参数问题
* 3. 接收回调的参数问题
*/
#define ERR_RETURN(ret, err) if(ret!=0)
{TRACEE("ret= %d errno = %d msg = [%s]", ret,
errno, strerror(errno));return err;}
#define WARN_CONTINUE(ret) if(ret!=0)
{TRACEW("ret= %d errno = %d msg = [%s]", ret,
errno, strerror(errno));continue;}
class CEdoyunPlayerServer :
 public CBusiness
{
public:
 CEdoyunPlayerServer(unsigned count)
:CBusiness() {
 m_count = count;
 }
 ~CEdoyunPlayerServer() {
 m_epoll.Close();
 m_pool.Close();
 for (auto it : m_mapClients) {
 if (it.second) {
 delete it.second;
 }
 }
 m_mapClients.clear();
 }
 virtual int BusinessProcess(CProcess* proc) {
 int ret = 0;
 ret = m_epoll.Create(m_count);
 ERR_RETURN(ret, -1);
 ret = m_pool.Start(m_count);
 ERR_RETURN(ret, -2);
 for (unsigned i = 0; i < m_count; i++) {
 ret =
m_pool.AddTask(&CEdoyunPlayerServer::ThreadFunc,
this);
 ERR_RETURN(ret, -3);
 }
 int sock = 0;
 
setRecvCallback(&CEdoyunPlayerServer::RecvDone,
this, std::placeholders::_1,
std::placeholders::_2);
 
setConnectedCallback(&CEdoyunPlayerServer::Connec
tedDone, this, std::placeholders::_1);
 while (m_epoll != -1) {
 ret = proc->RecvFD(sock);
 if (ret < 0 || (sock == 0))break;
 CSocketBase* pClient = new
CSocket(sock);
 if (pClient == NULL)continue;
 ret = m_epoll.Add(sock,
EpollData((void*)pClient));
 if (m_connectedcallback) {
 (*m_connectedcallback)(pClient);
 }
 WARN_CONTINUE(ret);
 }
 return 0;
 }
private:
 int ConnectedDone(CSocketBase* pClient) {
 return 0;
 }
 int RecvDone(CSocketBase* pClient, const
Buffer& data) {
 return 0;
 }
private:
 int ThreadFunc() {
 int ret = 0;
 EPEvents events;
 while (m_epoll != -1) {
 ssize_t size =
m_epoll.WaitEvents(events);
 if (size < 0)break;
 if (size > 0) {
 for (ssize_t i = 0; i < size;
i++)
 {
 if (events[i].events &
EPOLLERR) {
 break;
 }
 else if (events[i].events &
EPOLLIN) {
 CSocketBase* pClient =
(CSocketBase*)events[i].data.ptr;
 if (pClient) {
 Buffer data;
 ret = pClient-
>Recv(data);
 WARN_CONTINUE(ret);
 if (m_recvcallback) {
 (*m_recvcallback)
(pClient, data);
 }
 }
 }
 }
 }
 }
 return 0;
 }
private:
 CEpoll m_epoll;
 std::map<int, CSocketBase*> m_mapClients;
 CThreadPool m_pool;
 unsigned m_count;
};

Function.h

#pragma once
#include <unistd.h>
#include <sys/types.h>
#include <functional>
class CSocketBase;
class Buffer;
class CFunctionBase
{
public:
 virtual ~CFunctionBase() {}
 virtual int operator()() { return 0; }
 virtual int operator()(CSocketBase*) { return
0; }
 virtual int operator()(CSocketBase*, const
Buffer&) { return 0; }
};
template<typename _FUNCTION_, typename... _ARGS_>
class CFunction :public CFunctionBase
{
public:
 CFunction(_FUNCTION_ func, _ARGS_... args)
 :m_binder(std::forward<_FUNCTION_>(func),
std::forward<_ARGS_>(args)...)
 {}
 virtual ~CFunction() {}
 virtual int operator()() {
 return m_binder();
 }
 typename std::_Bindres_helper<int,
_FUNCTION_, _ARGS_...>::type m_binder;
};
template<typename _FUNCTION_, typename... _ARGS_>
class CConnectedFunction :public CFunctionBase
{
public:
 CConnectedFunction(_FUNCTION_ func, _ARGS_...
args)
 :m_binder(std::forward<_FUNCTION_>(func),
std::forward<_ARGS_>(args)...)
 {}
 virtual ~CConnectedFunction() {}
 
 virtual int operator()(CSocketBase* pClient)
{
 return m_binder(pClient);
 }
 typename std::_Bindres_helper<int,
_FUNCTION_, _ARGS_...>::type m_binder;
};
template<typename _FUNCTION_, typename... _ARGS_>
class CRecvFunction :public CFunctionBase
{
public:
 CRecvFunction(_FUNCTION_ func, _ARGS_...
args)
 :m_binder(std::forward<_FUNCTION_>(func),
std::forward<_ARGS_>(args)...)
 {}
 virtual ~CRecvFunction() {}
 virtual int operator()(CSocketBase* pClient,
const Buffer& data) {
 return m_binder(pClient, data);
 }
 typename std::_Bindres_helper<int,
_FUNCTION_, _ARGS_...>::type m_binder;
};