21ic电子技术开发论坛 › 个人版区 › 贝贝的实验室 › 五年前写的C++代码，好久没有用C++了，生疏了。 ...
返回列表 发新帖我要提问

五年前写的C++代码，好久没有用C++了，生疏了。

[复制链接]
1557|1
 楼主| keer_zu 发表于 2022-1-7 16:18 | 显示全部楼层 |阅读模式
C++代码, se, IO, session, ge, TI


一个通信程序的会话管理部分：

复制
  1. #include <iostream>
    

  2. #include <memory>
    

  3. #include "InterfaceApiImp.h"
    

  4. #include "Error.h"
    


  5. 

  6. #include "json/json.h"
    


  7. 

  8. #include <log4cxx/logger.h>
    

  9. #include <log4cxx/logstring.h>
    

  10. #include <log4cxx/propertyconfigurator.h>
    


  11. 

  12. #include "Log4cxxWrapper.h"
    


  13. 


  14. 


  15. 

  16. using namespace log4cxx;
    

  17. extern LoggerPtr g_logger;
    


  18. 

  19. using namespace std;
    


  20. 


  21. 

  22. void SessionImp::ProcessFrame(const char *buf, int length)
    

  23. {
    

  24.         int i,len = length,count = 0;
    

  25.         string newFrame;
    

  26.         int pos=0;
    

  27.         len =0;
    


  28. 

  29.         LoggerWrapper dsLog= LoggerWrapper::GetInstance();
    

  30.         
    

  31.         
    

  32.         if(buf == NULL){
    

  33.                 dsLog.Log(true,LOGGER_ERROR,"buf == NULL , [%s][%s][%d]\n",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  34.         }
    


  35. 

  36.     
    

  37.         for(i=0;i<length;i++){
    

  38.                 if(buf[i] == '\0'){
    

  39.                         len = i-pos;
    

  40.                         pos = i;
    

  41.                         newFrame.clear();
    

  42.                         newFrame.assign(m_rdBuffer.begin(),m_rdBuffer.end());
    

  43.                         len += m_rdBuffer.size();
    


  44. 

  45.                         if(len>1){
    

  46.                                 OnFrame(newFrame);
    

  47.                                 m_rdBuffer.clear();
    

  48.                         }
    

  49.                 } else {
    

  50.                         m_rdBuffer.push_back(buf[i]);
    

  51.                 }        
    

  52.         }
    


  53. 

  54.         return;
    

  55. }
    


  56. 

  57. void SessionImp::SetConnection(Connection * conn)
    

  58. {
    

  59.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    

  60.         
    

  61.         
    

  62.         if(conn == NULL){
    

  63.                 dsLog.Log(true,LOGGER_ERROR,"%s:SessionImp::%s:%d  error param",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  64.                 return;
    

  65.         }
    

  66.         
    

  67.         m_connection = conn;
    

  68. }
    


  69. 


  70. 


  71. 

  72. int SessionImp::SendMessage(string &str)
    

  73. {
    

  74.         int ret;
    

  75.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    

  76.         
    

  77.         str =str+'\0';
    

  78.         if(m_connection != NULL){cout << "==================== ts cmd: " << str << endl;
    

  79.                 ret = m_connection->Send(str.data(),str.length());
    


  80. 

  81.                 if(ret < 0){
    

  82.                         dsLog.Log(true,LOGGER_ERROR,"%s:SessionImp::%s:%d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  83.                 }
    

  84.                 
    

  85.                 return ret;
    

  86.         }
    


  87. 

  88.         return -1;
    

  89. }
    


  90. 


  91. 

  92. void SessionImp::ShowReadBuf()
    

  93. {
    

  94.         vector<char>::iterator iter;
    

  95.         for (iter = m_rdBuffer.begin(); iter != m_rdBuffer.end(); iter++){
    

  96.                 cout << (*iter);
    

  97.         }
    


  98. 

  99.         cout << endl;
    

  100. }
    


  101. 


  102. 


  103. 


  104. 


  105. 

  106. TsSessionImp::TsSessionImp(/*ITsSessionUser *sessionUser,*/TsSession *tssession)
    

  107. {
    

  108.         //m_sessionUser = sessionUser;
    

  109.         m_tssession = tssession;
    

  110.         m_sessionType = SESSION_TS;
    

  111. }
    


  112. 

  113. //void TsSessionImp::SetSessionUser(ITsSessionUser *sessionUser)
    

  114. //{
    

  115.         //m_sessionUser = sessionUser;
    

  116. //}
    


  117. 


  118. 


  119. 

  120. void TsSessionImp::Close()
    

  121. {
    

  122.         // close connect
    

  123.         struct TsSessionInfo *tsSessionInfo;
    

  124.         list<struct TsSessionInfo*>::iterator tlit;
    


  125. 

  126.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    

  127.         
    

  128.         m_connection->Close();
    


  129. 

  130.         if (this->m_connection){
    

  131.                 delete this->m_connection;
    

  132.                 this->m_connection = NULL;
    

  133.         }
    


  134. 

  135.         for (tlit = smi.m_tsSessionList.begin();tlit != smi.m_tsSessionList.end();tlit ++) { 
    

  136.                 tsSessionInfo = *tlit;
    

  137.                 if(tsSessionInfo != NULL){
    

  138.                         if(tsSessionInfo->session == this->m_tssession){
    

  139.                                 
    

  140.                                 smi.m_tsSessionList.erase(tlit);   
    


  141. 

  142.                                 delete tsSessionInfo;
    

  143.                                 
    

  144.                                 break;
    

  145.                         }
    

  146.                 }
    

  147.         }
    


  148. 

  149.         delete this;
    

  150. }
    


  151. 


  152. 

  153. void TsSessionImp::OnData(const char *buf, int length, Connection *conn)
    

  154. {
    

  155.         ProcessFrame(buf,length);
    

  156. }
    


  157. 

  158.         // called when user can write data to network.
    

  159. void TsSessionImp::OnWrite(Connection *conn)
    

  160. {
    


  161. 

  162. }
    

  163.         // called when the connection is broken, if user call Connection::Close(), //&&&
    

  164.         // will not get this callback.
    

  165. void TsSessionImp::OnDisconnect(int reason, Connection *conn)
    

  166. {
    

  167.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    


  168. 

  169.         if(this->m_tssession != NULL)
    

  170.                 smi.OnSessionClose(*this->m_tssession);
    

  171.         
    

  172.         Close();
    

  173. }
    


  174. 

  175. bool TsSessionImp::OnFrame(string &frame)
    

  176. {
    

  177.         struct TsSessionInfo *tsSessionInfo;
    

  178.         list<struct TsSessionInfo*>::iterator it;
    

  179.         //ITsSessionUser* tsSessionUser;
    

  180.         Json::Value  value;  
    

  181.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    

  182.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    


  183. 

  184.         std::auto_ptr<Json::Reader> pJsonParser(new Json::Reader(Json::Features::strictMode())); 
    


  185. 

  186.         ITsNewFrame* itsu;
    

  187.         
    


  188. 

  189.         if(!pJsonParser->parse(frame,value)){
    

  190.                 dsLog.Log(true,LOGGER_ERROR,"message Decode error! %s : %s : %d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  191.                 return false;
    

  192.         }
    


  193. 

  194.         if(value["type"].isNull() ||  !value["type"].isString()){
    

  195.                 dsLog.Log(true,LOGGER_ERROR,"message Decode error! %s : %s : %d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  196.                 return false;
    

  197.         }
    


  198. 


  199. 

  200.         if(value["type"] == "LinkResponse"){
    

  201.                 for(it = smi.m_tsSessionList.begin();it != smi.m_tsSessionList.end();it ++) {//printf("[url=home.php?mod=space&uid=1353124]@@@@@@@@@@@[/url] leng:%d     0x%x     (%d)\n",smi.m_tsSessionList.size(),it,__LINE__);
    

  202.                         tsSessionInfo = *it;
    

  203.                         if(tsSessionInfo != NULL){
    

  204.                                 if(tsSessionInfo->session == this->m_tssession){
    

  205.                                         tsSessionInfo->timeOut = 0;
    

  206.                                         break;
    

  207.                                 }
    

  208.                         }
    

  209.                 }
    

  210.         } else {
    

  211.                 itsu= smi.GetTsNewFrame();
    

  212.                 if(itsu == NULL){
    

  213.                         dsLog.Log(true,LOGGER_ERROR,"%s:%s:%d   smi.GetSessionUser() == NULL\n",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  214.                         return false;
    

  215.                 }
    

  216.                 itsu->OnNewFrame(this->m_tssession,frame);
    

  217.         }
    


  218. 

  219.         return true;
    

  220. }
    


  221. 

  222. /////////////////////// ts client session ///////////////////////
    


  223. 

  224. void TsClientSessionImp::Close()
    

  225. {
    


  226. 

  227. }
    


  228. 

  229. void TsClientSessionImp::OnData(const char *buf, int length, Connection *conn)
    

  230. {
    


  231. 

  232. }
    


  233. 

  234.         // called when user can write data to network.
    

  235. void TsClientSessionImp::OnWrite(Connection *conn)
    

  236. {
    


  237. 

  238. }
    

  239.         // called when the connection is broken, if user call Connection::Close(), //&&&
    

  240.         // will not get this callback.
    

  241. void TsClientSessionImp::OnDisconnect(int reason, Connection *conn)
    

  242. {
    


  243. 

  244. }
    


  245. 

  246. bool TsClientSessionImp::OnFrame(string &frame)
    

  247. {
    

  248. }
    

  249. /////////////////// /// app server session /////////////////////
    


  250. 


  251. 


  252. 


  253. 

  254. void AppServerSessionImp::Close()
    

  255. {
    

  256.         m_connection->Close();
    


  257. 

  258.         if (this->m_connection){
    

  259.                 delete this->m_connection;
    

  260.                 this->m_connection = NULL;
    

  261.         }
    


  262. 

  263.         delete this;
    

  264. }
    


  265. 

  266. void AppServerSessionImp::OnData(const char *buf, int length, Connection *conn)
    

  267. {
    

  268.         //printf("++++++++++++++++++++++++++++++++++: \n%s\n",buf);
    

  269.     LoggerWrapper dsLog= LoggerWrapper::GetInstance();
    

  270.         
    

  271.         dsLog.Log(true,LOGGER_DEBUG,"\n\n ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n MSG From App:\n%s\n",buf);
    

  272.         
    

  273.         ProcessFrame(buf,length);
    

  274. }
    


  275. 

  276. void AppServerSessionImp::OnWrite(Connection *conn)
    

  277. {
    


  278. 

  279. }
    


  280. 

  281. void AppServerSessionImp::OnDisconnect(int reason, Connection *conn)
    

  282. {
    

  283.         struct TsSessionInfo *tsSessionInfo;
    

  284.         list<struct TsSessionInfo*>::iterator tlit;
    

  285.         
    

  286.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    

  287.         smi.OnSessionClose(*this);
    


  288. 

  289.         Close();
    

  290. }
    


  291. 

  292. bool AppServerSessionImp::OnFrame(string &frame)
    

  293. {
    


  294. 

  295.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    


  296. 

  297.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    


  298. 

  299.         IAppNewFrame* iael = smi.GetAppNewFrame();
    

  300.         if(iael == NULL){
    

  301.                 dsLog.Log(true,LOGGER_ERROR,"GetAppEventListener error! %s : %s : %d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  302.                 return false;
    

  303.         }
    


  304. 

  305.         iael->OnNewFrame(this->m_session,frame);
    


  306. 

  307.         return true;
    

  308. }
    


  309. 


  310. 

  311. //////////////////////// app client session ///////////////////
    


  312. 


  313. 

  314. void AppClientSessionImp::Close()
    

  315. {
    

  316.         if(m_connection != NULL)
    

  317.                 m_connection->Close();
    


  318. 

  319.         if (this->m_connection){
    

  320.                 delete this->m_connection;
    

  321.                 this->m_connection = NULL;
    

  322.         }
    


  323. 

  324.         delete this;
    

  325. }
    


  326. 

  327. void AppClientSessionImp::OnData(const char *buf, int length, Connection *conn)
    

  328. {
    

  329.         
    

  330.         ProcessFrame(buf,length);
    

  331.         
    

  332. }
    


  333. 

  334. void AppClientSessionImp::OnWrite(Connection *conn)
    

  335. {
    


  336. 

  337. }
    


  338. 

  339. void AppClientSessionImp::OnDisconnect(int reason, Connection *conn)
    

  340. {
    


  341. 

  342.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    

  343.         smi.OnSessionClose(*this);
    


  344. 

  345.         Close();
    

  346. }
    


  347. 

  348. bool AppClientSessionImp::OnFrame(string &frame)
    

  349. {
    

  350.         Json::Value  value;  
    

  351.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    

  352.         SessionManagerImp& smi =  SessionManagerImp::GetInstance();
    


  353. 

  354.         std::auto_ptr<Json::Reader> pJsonParser(new Json::Reader(Json::Features::strictMode())); 
    

  355.         
    


  356. 

  357.         if(!pJsonParser->parse(frame,value)){
    

  358.                 dsLog.Log(true,LOGGER_ERROR,"message Decode error! %s : %s : %d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  359.                 return false;
    

  360.         }
    


  361. 

  362.         if(value["command"].isNull() ||  !value["command"].isString()){
    

  363.                 dsLog.Log(true,LOGGER_ERROR,"message Decode error! %s : %s : %d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  364.                 return false;
    

  365.         }
    


  366. 


  367. 

  368.         if(value["command"] == "response"){
    

  369.                 cout << "app client OnDisconnect from(OnFrame) "  << endl;
    

  370.                 smi.OnSessionClose(*this);
    


  371. 

  372.                 Close();
    

  373.         } else {
    

  374.                 dsLog.Log(true,LOGGER_ERROR,"this message may be not a AppClientSession message! %s : %s : %d",__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  375.                 return false;
    

  376.         }
    


  377. 


  378. 

  379.         return true;
    

  380. }
    


  381. 


  382. 


  383. 


  384.


回复

收藏 举报

相关帖子
 楼主| keer_zu 发表于 2022-1-7 16:19 | 显示全部楼层
复制
  1. #include <iostream>
    

  2. #include "InterfaceApiImp.h"
    

  3. #include "ConfigManager.h"
    

  4. #include "Log4cxxWrapper.h"
    

  5. #include "DataShow.h"
    

  6. #include "json/json.h"
    

  7. #include <execinfo.h> 
    

  8. #include <string.h>
    

  9. #include "AppResultSubmit.h"
    


  10. 


  11. 


  12. 

  13. using namespace cdy;
    


  14. 


  15. 


  16. 

  17. SessionManagerImp::SessionManagerImp(/*SessionManager &wrapper*/)
    

  18.         //:m_appEventListener(NULL)
    

  19.         //,m_sessionUser(NULL)
    

  20.         :m_idleConnectionChecker(-1)
    

  21.         ,m_connectionTimeout(-1)
    

  22.         //,m_timerHandler(NULL)
    

  23.         ,m_dataShow(NULL)
    

  24. {
    

  25.         
    

  26.         struct timeval tv1={8, 0};
    

  27.         m_idleConnectionChecker = EventLooper::GetInstance().ScheduleTimer(&tv1, TF_FIRE_PERIODICALLY, this);
    


  28. 


  29. 

  30.         struct timeval tv2={1, 0};
    

  31.         m_connectionTimeout = EventLooper::GetInstance().ScheduleTimer(&tv2, TF_FIRE_PERIODICALLY, this);
    


  32. 

  33.         
    

  34. }
    


  35. 

  36. SessionManagerImp::~SessionManagerImp()
    

  37. {
    

  38.         if(m_appListener){
    

  39.                 m_appListener->Stop();
    

  40.                 delete  m_appListener;
    

  41.         }
    


  42. 

  43.         if(m_tsListener){
    

  44.                 m_tsListener->Stop();
    

  45.                 delete m_tsListener;
    

  46.         }
    


  47. 

  48.         EventLooper::GetInstance().CancelTimer(m_idleConnectionChecker);
    

  49.         EventLooper::GetInstance().CancelTimer(m_connectionTimeout);
    

  50. }
    


  51. 

  52. TimerID SessionManagerImp::NewTimer(unsigned int dwInterval,TimerHandler pTimerHander )
    

  53. {
    

  54.         TimerID timerForApp;
    

  55.         struct timeval tv={dwInterval, 0};
    

  56.         
    

  57.         timerForApp = EventLooper::GetInstance().ScheduleTimer(&tv, TF_FIRE_PERIODICALLY, this);
    


  58. 

  59.         m_timerMap[timerForApp] = pTimerHander;
    


  60. 

  61.         printf("timerID: %d     %s:%d\n",timerForApp,__FUNCTION__,__LINE__);
    

  62.         //if(m_timerHandler == NULL)
    

  63.         //        m_timerHandler = pTimerHander;
    

  64.         return timerForApp;
    

  65. }
    

  66.         
    

  67. void SessionManagerImp::KillTimer(TimerID id)
    

  68. {
    

  69.         EventLooper::GetInstance().CancelTimer(id);
    


  70. 

  71.         map<TimerID,TimerHandler>::iterator iTimer = m_timerMap.find(id);
    

  72.         if(iTimer !=  m_timerMap.end())
    

  73.                 m_timerMap.erase(iTimer);
    

  74.         //if(m_timerHandler != NULL)
    

  75.         //        m_timerHandler = NULL;
    

  76. }
    


  77. 


  78. 

  79. SessionManagerImp& SessionManagerImp::GetInstance()
    

  80. {
    

  81.         static  SessionManagerImp instance_;
    

  82.         return instance_; 
    


  83. 

  84. }
    


  85. 

  86. bool SessionManagerImp::StartListenForAppServer(IAppNewFrame &appNewFrame)
    

  87. {
    

  88.         LoggerWrapper &loggerUser = LoggerWrapper::GetInstance();
    

  89.         short port;
    

  90.         //IAppEventListener listener;
    

  91.         
    

  92.         //m_appEventListener = &listener;
    


  93. 

  94.         
    

  95.         m_appNewFrame = &appNewFrame;
    

  96.         m_appResultSubmit = &DocAppResultSubmit::GetInstance();//&appResultSubmit;
    

  97.         m_appResultSubmit->add(&VideoAppResultSubmit::GetInstance());
    

  98.         m_appResultSubmit->add(&DpptAppResultSubmit::GetInstance());
    

  99.         m_appResultSubmit->add(&NoUseTsAppResultSubmit::GetInstance());
    


  100. 

  101.         
    


  102. 

  103.         const string& addr = ConfigManager::GetIp();//appInfo.GetAppListenIp();
    

  104.         port =  (short)ConfigManager::GetAppPort();//(short)appInfo.GetAppListenPort();
    


  105. 

  106.         m_appListener = new  Acceptor(addr, port,this);
    

  107.         
    

  108.         return m_appListener->StartListen() == 0;
    

  109. }
    


  110. 


  111. 

  112. bool SessionManagerImp::StartListenForTS(ITsNewFrame &tsNewFrame,ITsServerLeave &tsServerLeave)
    

  113. {
    

  114.         m_tsNewFrame = &tsNewFrame;
    


  115. 

  116.         m_tsServerLeave = &tsServerLeave;
    

  117.         
    

  118.         m_tsListener = new  Acceptor(ConfigManager::GetIp(), (short)ConfigManager::GetTsPort(),this);
    

  119.         
    

  120.         
    

  121.         return m_tsListener->StartListen() == 0;
    

  122. }
    


  123. 


  124. 


  125. 

  126. bool SessionManagerImp::DestoryConnectToServer(string ip,unsigned int port)
    

  127. {
    

  128.         map<TargetAttributeT *,IConnectorAcceptor *>::iterator it;
    

  129.         
    


  130. 

  131.          for(it = m_longConnectors.begin();it != m_longConnectors.end();it ++){
    

  132.                  if(((TargetAttributeT *)it->first)->ip == ip && ((TargetAttributeT *)it->first)->port == port){
    

  133.                         // TODO: close this connection;
    

  134.                         if(it->first != NULL)
    

  135.                                 delete it->first;
    

  136.                         
    

  137.                         if(it->second)
    

  138.                                 delete it->second;
    

  139.                         
    

  140.                         m_longConnectors.erase(it);
    

  141.                         
    

  142.                         break;
    

  143.                  } 
    

  144.         }
    

  145. }
    


  146. 


  147. 

  148. void SessionManagerImp::SetDataShowProvider(IDataShowProvider &dataShow)
    

  149. {
    

  150.         m_dataShow = &dataShow;
    

  151.         printf("####################### datashow: 0x%x\n",m_dataShow);
    

  152. }
    


  153. 


  154. 

  155. void print_trace(void)   
    

  156. {   
    

  157.     int i;   
    

  158.     const int MAX_CALLSTACK_DEPTH = 32;    /* 需要打印堆栈的最大深度 */  
    

  159.     void *traceback[MAX_CALLSTACK_DEPTH];  /* 用来存储调用堆栈中的地址 */  
    

  160.     /* 利用 addr2line 命令可以打印出一个函数地址所在的源代码位置   
    

  161.      * 调用格式为： addr2line -f -e /tmp/a.out 0x400618  
    

  162.      * 使用前，源代码编译时要加上 -rdynamic -g 选项  
    

  163.      */  
    

  164.     char cmd[512] = "addr2line -f -e ";   
    

  165.     char *prog = cmd + strlen(cmd);   
    

  166.     /* 得到当前可执行程序的路径和文件名 */  
    

  167.     int r = readlink("/proc/self/exe",prog,sizeof(cmd)-(prog-cmd)-1);   
    

  168.     /* popen会fork出一个子进程来调用/bin/sh, 并执行cmd字符串中的命令，  
    

  169.      * 同时，会创建一个管道，由于参数是'w', 管道将与标准输入相连接，  
    

  170.      * 并返回一个FILE的指针fp指向所创建的管道，以后只要用fp往管理里写任何内容，  
    

  171.      * 内容都会被送往到标准输入，  
    

  172.      * 在下面的代码中，会将调用堆栈中的函数地址写入管道中，  
    

  173.      * addr2line程序会从标准输入中得到该函数地址，然后根据地址打印出源代码位置和函数名。  
    

  174.      */  
    

  175.     FILE *fp = popen(cmd, "w");   
    

  176.     /* 得到当前调用堆栈中的所有函数地址，放到traceback数组中 */  
    

  177.     int depth = backtrace(traceback, MAX_CALLSTACK_DEPTH);   
    

  178.     for (i = 0; i < depth; i++)   
    

  179.     {   
    

  180.         /* 得到调用堆栈中的函数的地址，然后将地址发送给 addr2line */  
    

  181.         fprintf(fp, "%p\n", traceback[i]);   
    

  182.         /* addr2line 命令在收到地址后，会将函数地址所在的源代码位置打印到标准输出 */  
    

  183.     }   
    

  184.     fclose(fp);   
    

  185. } 
    


  186. 


  187. 


  188. 

  189. void SessionManagerImp::SendAppMessage(const string addr,const unsigned int port,const string msg,void* pTaskMessage)
    

  190. {//连接失败后尝试三次间隔时间暂定5分钟
    


  191. 

  192.         static unsigned int ConnectTimes = 0;
    

  193.         Connector *connector=NULL;
    

  194.         static unsigned int connectErrorTimes = 0;
    


  195. 

  196.         struct ConnectorInfo *connectorInfo;
    


  197. 

  198.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    


  199. 

  200.         if(addr == "" || msg == "" || port < 0){
    

  201.                 printf("addr: %s           msg: %s     port:%d\n",addr.c_str(),msg.c_str(),port);
    

  202. //                print_trace();
    

  203.                 dsLog.Log(true,LOGGER_ERROR," parameter error! line:%d\n",__LINE__);
    

  204.                 return;
    

  205.         }
    

  206.         
    

  207.         if (!connector)
    

  208.                 connector = new Connector(addr, port, this);
    


  209. 

  210. try_connect:
    

  211.         
    

  212.         if (connector->Connect(300) == 0){
    

  213.                 connectorInfo = new struct ConnectorInfo;//(struct ConnectorInfo *)malloc(sizeof(struct ConnectorInfo));
    

  214.                 if(connectorInfo == NULL){
    

  215.                         dsLog.Log(true,LOGGER_ERROR," new struct ConnectorInfo error! \n");
    

  216.                         return;
    

  217.                 }
    

  218.                 
    

  219.                 connectorInfo->msg = msg;
    

  220.                 connectorInfo->re_connect_times = 0;
    

  221.                 connectorInfo->pTaskMessage = pTaskMessage;
    

  222.                 m_connectors[connector] = connectorInfo;
    


  223. 

  224.                 connectErrorTimes = 0;
    

  225.                 
    

  226.         } else {
    

  227.         
    

  228.                 delete connector;
    


  229. 

  230.                 connectErrorTimes ++;
    

  231.                 
    

  232.                 if (connectErrorTimes < 3){
    

  233.                         connector = new Connector(addr, port, this);
    

  234.                         goto try_connect;
    

  235.                 }
    


  236. 

  237.                 connectErrorTimes = 0;
    

  238.                 
    

  239.         }
    


  240. 

  241.         return;
    


  242. 

  243. }
    


  244. 

  245. void SessionManagerImp::OnNewSession(SessionImp &session)
    

  246. {
    

  247.         list<SessionImp*>::iterator alit;
    

  248.         
    

  249.         if(session.m_sessionType == SESSION_APP_CLIENT){
    

  250.                 
    

  251.         } else if(session.m_sessionType == SESSION_APP_SERVER){
    


  252. 

  253.         }
    

  254. }
    


  255. 

  256. void SessionManagerImp::OnNewSession(TsSession &session)
    

  257. {
    

  258.         list<struct TsSessionInfo*>::iterator tlit;
    

  259.         
    

  260. }
    


  261. 


  262. 


  263. 


  264. 

  265. void SessionManagerImp::OnSessionClose(SessionImp &session)
    

  266. {
    

  267.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    

  268.         
    

  269.         list<SessionImp*>::iterator alit;
    

  270.         SessionImp *session_imp;
    


  271. 

  272.         
    

  273.         if(session.m_sessionType == SESSION_APP_CLIENT){
    

  274.                 
    

  275.                 for (alit = m_appClientSessionList.begin();alit != m_appClientSessionList.end();alit ++) {
    

  276.                         session_imp = *alit;
    

  277.                         if(session_imp == &session){
    

  278.                                 m_appClientSessionList.erase(alit);  
    

  279.                                 
    

  280.                                 break;
    

  281.                         }
    

  282.                 }
    

  283.                 
    

  284.         } else if(session.m_sessionType == SESSION_APP_SERVER){
    

  285.                 for (alit = m_appServerSessionList.begin();alit != m_appServerSessionList.end();alit ++) {
    

  286.                         session_imp = *alit;
    

  287.                         if(session_imp == &session){
    

  288.                                 m_appServerSessionList.erase(alit);   
    

  289.                                 
    

  290.                                 break;
    

  291.                         }
    

  292.                 }
    


  293. 

  294.         }
    

  295. }
    


  296. 

  297. void SessionManagerImp::OnSessionClose(TsSession &session)
    

  298. {
    

  299.         struct TsSessionInfo *tsSessionInfo;
    

  300.         list<struct TsSessionInfo*>::iterator tlit;
    


  301. 

  302.         if(m_tsServerLeave != NULL)
    

  303.                 m_tsServerLeave->OnServerLeave(session);
    

  304.         
    

  305.         for (tlit = m_tsSessionList.begin();tlit != m_tsSessionList.end();tlit ++) {//printf("@@@@@@@@@@@ leng:%d     0x%x     (%d)\n",m_tsSessionList.size(),tlit,__LINE__);
    

  306.                 tsSessionInfo = *tlit;
    

  307.                 if(tsSessionInfo->session == &session){
    

  308.                         
    

  309.                         m_tsSessionList.erase(tlit);   
    


  310. 

  311.                         delete tsSessionInfo;
    

  312.                         
    

  313.                         break;
    

  314.                 }
    

  315.         }
    

  316. }
    


  317. 

  318. void SessionManagerImp::OnConnection(Connection *conn, IConnectorAcceptor *ca)
    

  319. {
    

  320.         int ret;
    

  321.         
    

  322.         TsSession *ts_session;
    

  323.         struct TsSessionInfo *tsSessionInfo;
    

  324.         //TsSessionImp *ts_session_imp;
    

  325.         TsSessionImp *ts_session_imp;
    

  326.         SessionImp *session_imp;
    

  327.         TsClientSession *tsClientSession;
    

  328.         //TsClientSessionImp *tsClientSessionImp;
    


  329. 


  330. 

  331.         map<IConnectorAcceptor*,struct ConnectorInfo *>::iterator it;
    


  332. 

  333.         map<TargetAttributeT *,IConnectorAcceptor *>::iterator lcit;
    


  334. 

  335.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    


  336. 

  337.         if(!ca){
    

  338.                 return;
    

  339.         }
    


  340. 

  341.         if (conn){
    

  342.                 if (ca->IsConnector() == false){//accepter
    

  343.                         if (ca == m_tsListener) {//ts
    


  344. 

  345.                                 ts_session = new TsSession();
    

  346.                                 if(ts_session == NULL){
    

  347.                                         dsLog.Log(true,LOGGER_ERROR," new TsSession error! \n");
    

  348.                                         return;
    

  349.                                 }
    

  350.                                 
    

  351.                                 conn->SetConnectionSink(ts_session->m_imp);
    


  352. 

  353.                                 tsSessionInfo = new struct TsSessionInfo;
    

  354.                                 if (tsSessionInfo == NULL){
    

  355.                                         
    

  356.                                         dsLog.Log(true,LOGGER_ERROR,"malloc error!\n");
    

  357.                                 }
    


  358. 

  359.                                 tsSessionInfo->session = ts_session;
    

  360.                                 
    

  361.                                 ts_session_imp = (TsSessionImp *)ts_session->m_imp;
    

  362.                                 //ts_session_imp->SetSessionUser(this->m_sessionUser);
    

  363.                                 ts_session_imp->SetConnection(conn);
    


  364. 

  365.                                 tsSessionInfo->timeOut = 0;
    

  366.                                 
    

  367.                                 m_tsSessionList.push_back(tsSessionInfo);
    

  368.                                 OnNewSession(*ts_session);
    

  369.                                 
    

  370.                         } else if (ca == m_appListener){ //app
    


  371. 

  372.                                 session_imp = new AppServerSessionImp(conn/*,this->m_appEventListener*/);
    

  373.                                 if(session_imp == NULL){
    

  374.                                         dsLog.Log(true,LOGGER_ERROR," new AppServerSessionImp error! \n");
    

  375.                                         return;
    

  376.                                 }
    

  377.                                 
    

  378.                                 conn->SetConnectionSink(session_imp);
    

  379.                                 session_imp->SetConnection(conn);
    


  380. 

  381.                                 m_appServerSessionList.push_back(session_imp);
    

  382.                                 OnNewSession(*session_imp);
    

  383.                                 
    

  384.                         } else {
    

  385.                                 
    

  386.                         }
    

  387.                         
    

  388.                 } else {//connector
    


  389. 

  390.                          for(lcit = m_longConnectors.begin();lcit != m_longConnectors.end();lcit ++){
    

  391.                                  if((IConnectorAcceptor *)lcit->second == ca){
    

  392.                                         tsClientSession = new TsClientSession();
    

  393.                                         if(session_imp == NULL){
    

  394.                                                 dsLog.Log(true,LOGGER_ERROR," new AppClientSessionImp error! \n");
    

  395.                                                 return;
    

  396.                                         }
    


  397. 

  398.                                         //conn->SetConnectionSink(session_imp);
    

  399.                                         //session_imp->SetConnection(conn);
    

  400.                                         conn->SetConnectionSink(tsClientSession->m_imp);
    

  401.                                         tsClientSession->m_imp->SetConnection(conn);
    


  402. 

  403.                                         TsClientSessionInfoT *info = new TsClientSessionInfoT;
    

  404.                                         info->session =tsClientSession;//->m_imp->m_session;
    

  405.                                         info->ip = ((TargetAttributeT *)lcit->first)->ip;
    

  406.                                         info->port = ((TargetAttributeT *)lcit->first)->port;
    

  407.                                         
    

  408.                                         m_tsClinetSessionList.push_back(info);
    

  409.                                         // TODO:OnNewSession(*session_imp);
    

  410.                                         
    

  411.                                         return;
    

  412.                                  } 
    

  413.                         }
    

  414.  
    

  415.                         it = m_connectors.find(ca);
    

  416.                         if(it != m_connectors.end()){  //
    


  417. 

  418.                                 session_imp = new AppClientSessionImp(conn);
    

  419.                                 if(session_imp == NULL){
    

  420.                                         dsLog.Log(true,LOGGER_ERROR," new AppClientSessionImp error! \n");
    

  421.                                         return;
    

  422.                                 }
    

  423.                                 
    

  424.                                 conn->SetConnectionSink(session_imp);
    

  425.                                 session_imp->SetConnection(conn);
    


  426. 

  427.                                 m_appClientSessionList.push_back(session_imp);
    

  428.                                 OnNewSession(*session_imp);
    


  429. 

  430.                                 if(it->second != NULL){
    

  431.                                         ret = session_imp->SendMessage(it->second->msg);
    

  432.                                         m_appResultSubmit->OnResultSubmit(ret,it->second->pTaskMessage);
    

  433.                                 }
    

  434.                                 dsLog.Log(true,LOGGER_INFO,"Send app message:%s, %s:%s:%d",it->second->msg.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);
    

  435.                                         
    

  436.                                 delete ca;
    


  437. 

  438.                                 if(it->second != NULL)
    

  439.                                         delete it->second;
    

  440.                                 m_connectors.erase(it);
    

  441.                                 
    

  442.                         } else {  // error ,Can not find connector
    

  443.                                 dsLog.Log(true,LOGGER_ERROR,"Can not find connector! :%d",__LINE__);
    

  444.                                 delete ca;
    

  445.                         }
    

  446.                 }
    

  447.         } else {   
    

  448.                 //Added by wwz 160424 for test
    

  449.                 printf("conn is NULL\n");
    

  450.     
    

  451. //                cout << "not connected, try again!" << endl;
    

  452.                 if (ca->IsConnector() == true){//connector
    

  453.                         it = m_connectors.find(ca);
    

  454.                         if(it == m_connectors.end()){  //This connector does not exist
    

  455.                                 cout << "This connector does not exist :%d" << endl;
    

  456.                         } else {
    

  457.                                 if(it->second != NULL){
    

  458.                                         if(it->second->re_connect_times == 0){
    

  459.                                                 it->second->re_connect_times = 3;    //Join the Error handling map
    

  460.                                         } else {
    

  461.                                                 if(it->second->re_connect_times == 1){  //Connection failed three times
    

  462.                                                         //Added by wwz 160424 for test,for connection failure
    

  463.                                                         printf("connection failure,send task result fail!\n");
    

  464.                                                         m_appResultSubmit->OnResultSubmit(ret,it->second->pTaskMessage);
    

  465.                                                 
    

  466.                                                         delete ca;
    

  467.                                                         delete it->second;
    

  468.                                                         m_connectors.erase(it); //it->second
    

  469.                                                 } else {
    

  470.                                                         it->second->re_connect_times -= 1;
    

  471.                                                 }
    

  472.                                         }
    

  473.                                 }
    

  474.                         }
    

  475.                 }
    

  476.         }
    

  477. }
    


  478. 


  479. 

  480. void SessionManagerImp::OnTimer(TimerID tid)
    

  481. {
    

  482.         struct TsSessionInfo *tsSessionInfo;
    

  483.         string json;
    

  484.         Json::Value root;
    


  485. 

  486.         root["type"] = "SvrLinkCheck";
    


  487. 

  488.         map<TimerID,TimerHandler>::iterator iTimer;
    


  489. 

  490.         //root.toStyledString();
    

  491.         json = root.toStyledString();
    

  492.         
    

  493.         //SvrLinkCheck svrLinkCheck;
    

  494.         map<IConnectorAcceptor*,struct ConnectorInfo *>::iterator mit;
    

  495.         list<struct TsSessionInfo *>::iterator it;
    

  496.         map<TargetAttributeT *,IConnectorAcceptor *>::iterator lcit;
    

  497.         //TsMessageBase *msg;
    

  498.         TsSession *tsSession;
    

  499.         LoggerWrapper& dsLog = LoggerWrapper::GetInstance();
    

  500.         Connector *connector=NULL;
    

  501.         
    

  502.         if (tid == m_connectionTimeout){
    

  503.                  for(mit = m_connectors.begin();mit != m_connectors.end();){
    

  504.                          if(mit->second != NULL){
    

  505.                                 if(mit->second->re_connect_times >= 1){
    

  506.                                         if(((Connector *)(mit->first))->Connect(300) != 0){// Remove from map directly 
    

  507.                                                 if(mit->first != NULL)
    

  508.                                                         delete mit->first;
    

  509.                                                 delete mit->second;
    

  510.                                                 m_connectors.erase(mit ++); 
    

  511.                                         } else {
    

  512.                                                 mit ++;
    

  513.                                         }
    

  514.                                         
    

  515.                                 } else {
    

  516.                                         mit ++;
    

  517.                                 }
    

  518.                          }
    

  519.             else
    

  520.             {
    

  521.                 mit ++;
    

  522.             }
    

  523.                  }
    


  524. 

  525.                 for(lcit = m_longConnectors.begin();lcit != m_longConnectors.end();lcit ++){
    

  526.                         if (lcit->second == NULL){
    

  527.                                 if(((TargetAttributeT *)lcit->first)->reconnectInterval >= LONG_CONNECT_RETRY_INTERFAL){
    

  528.                                         if (!connector)
    

  529.                                                 connector = new Connector(((TargetAttributeT *)lcit->first)->ip,((TargetAttributeT *)lcit->first)->port, this);
    

  530.                                         if (connector->Connect(300) == 0){
    

  531.                                                 lcit->second = connector;
    

  532.                                         } else {
    

  533.                                                 ((TargetAttributeT *)lcit->first)->reconnectInterval = 0;
    

  534.                                         }
    

  535.                                 } else {
    

  536.                                         ((TargetAttributeT *)lcit->first)->reconnectInterval += 1;
    

  537.                                 }
    

  538.                         }
    

  539.                 }
    

  540.         } else if(tid == m_idleConnectionChecker) {
    

  541.                 for(it = m_tsSessionList.begin();it != m_tsSessionList.end();) {//printf("@@@@@@@@@@@ leng:%d     0x%x     (%d)\n",m_tsSessionList.size(),it,__LINE__);
    

  542.                         
    

  543.                         tsSessionInfo = *(it++);
    

  544.                         if(tsSessionInfo == NULL){
    

  545.                                 dsLog.Log(true,LOGGER_ERROR," tsSessionInfo is NUL!");
    

  546.                                 return;
    

  547.                         }
    

  548.                         
    

  549.                         tsSession = tsSessionInfo->session;
    

  550.                         if(tsSession == NULL){
    

  551.                                 dsLog.Log(true,LOGGER_ERROR," tsSession is NUL!");
    

  552.                                 return;
    

  553.                         }
    


  554. 

  555.                         if(tsSessionInfo->timeOut == 1) {  // Timeout handling
    

  556.                                 dsLog.Log(true,LOGGER_DEBUG,"Timeout handling!  session:0x%x   sessionimp:0x%x\n",tsSessionInfo->session,tsSessionInfo->session->m_imp);        
    

  557.                                 OnSessionClose(*tsSessionInfo->session);
    

  558.                                 tsSession->Close();
    


  559. 

  560.                         } else {
    

  561.                                         
    

  562.                                 tsSessionInfo->session->SendMessage(/**msg*/json);
    

  563.                                 tsSessionInfo->timeOut = 1;
    


  564. 

  565.                         }
    

  566.                 }
    

  567.         //}else if(tid == m_timerForApp){ 
    

  568.         //                m_timerHandler();                
    

  569.         } else { //app timer handle
    

  570.                 
    

  571.                 for(iTimer = m_timerMap.begin();iTimer != m_timerMap.end();++ iTimer){
    

  572.                         if(tid == iTimer->first){
    

  573.                                 ((TimerHandler)iTimer->second)();
    

  574.                                 break;
    

  575.                         }
    

  576.                 }
    

  577.         }
    


  578. 

  579. }
    


  580. 

  581. //IAppEventListener* SessionManagerImp::GetAppEventListener() const
    

  582. //{
    

  583. //        return m_appEventListener;
    

  584. //}
    


  585. 

  586. IAppNewFrame *SessionManagerImp::GetAppNewFrame() const
    

  587. {
    


  588. 

  589.         return m_appNewFrame;
    

  590. }
    


  591. 


  592. 

  593. //ITsSessionUser* SessionManagerImp::GetSessionUser() const
    

  594. //{
    

  595. //        return m_sessionUser;
    

  596. //}
    


  597. 

  598. ITsNewFrame* SessionManagerImp::GetTsNewFrame() const
    

  599. {
    

  600.         return m_tsNewFrame;
    

  601. }
    


  602. 

  603. void SessionManagerImp::ShowConnectors()
    

  604. {
    

  605.         int i;
    

  606.         map<IConnectorAcceptor*,struct ConnectorInfo *>::iterator mit;
    

  607.         
    

  608.         if(m_dataShow == NULL)
    

  609.                 return;
    

  610.         
    

  611.         m_dataShow->DataPrint("\n\n\n++++++ connectors:\n");
    

  612.         for(mit = m_connectors.begin(),i = 0;mit != m_connectors.end();mit ++,i ++){
    

  613.                 m_dataShow->DataPrint("----------------the %dth elem: \n",i);
    

  614.                 m_dataShow->DataPrint("connector: 0x%x\n",(Connector *)(mit->first));
    

  615.                 m_dataShow->DataPrint("msg: %s\n",((struct ConnectorInfo *)mit->second)->msg.data());
    

  616.                 m_dataShow->DataPrint("re_connect_times: %d\n",((struct ConnectorInfo *)mit->second)->re_connect_times);
    

  617.                 m_dataShow->DataPrint("\n\n\n");
    

  618.         }
    

  619.         
    

  620. }
    


  621. 


  622. 

  623. void SessionManagerImp::ShowTsSessionList()
    

  624. {
    

  625.         int i;
    

  626.         struct TsSessionInfo *tsSessionInfo;
    

  627.         list<struct TsSessionInfo *>::iterator it;
    

  628.         
    

  629.         if(m_dataShow == NULL)
    

  630.                 return;
    

  631.         
    

  632.         m_dataShow->DataPrint("\n\n\n++++++ ts_session_list:\n");
    

  633.         for(it = m_tsSessionList.begin(),i = 0;it != m_tsSessionList.end();it ++,i ++) {//printf("@@@@@@@@@@@ leng:%d     0x%x     (%d)\n",m_tsSessionList.size(),it,__LINE__);
    

  634.                 tsSessionInfo = *it;
    

  635.                 m_dataShow->DataPrint("----------------the %dth elem:  \n",i);
    

  636.                 m_dataShow->DataPrint("session: 0x%x\n",tsSessionInfo->session);
    

  637.                 m_dataShow->DataPrint("timeOut:%d\n",tsSessionInfo->timeOut);
    

  638.                 m_dataShow->DataPrint("\n\n\n");
    

  639.         }
    

  640. }
    


  641. 

  642. void SessionManagerImp::ShowAppServerSessionList()
    

  643. {
    

  644.         int i;
    

  645.         list<SessionImp*>::iterator alit;
    

  646.         
    

  647.         if(m_dataShow == NULL)
    

  648.                 return;
    


  649. 

  650.         m_dataShow->DataPrint("\n\n\n++++++ app_server_session_list:\n");
    

  651.         for (alit = m_appServerSessionList.begin(),i = 0;alit != m_appServerSessionList.end();alit ++,i ++) {
    

  652.                 m_dataShow->DataPrint("----------------the %dth elem:   \n",i);
    

  653.                 m_dataShow->DataPrint("session_imp: 0x%x\n",*alit);
    

  654.                 m_dataShow->DataPrint("\n\n\n");
    

  655.         }
    

  656.                 
    

  657. }
    


  658. 

  659. void SessionManagerImp::ShowAppClientSessionList()
    

  660. {
    

  661.         int i;
    

  662.         list<SessionImp*>::iterator alit;
    

  663.         
    

  664.         if(m_dataShow == NULL)
    

  665.                 return;
    

  666.         
    

  667.         m_dataShow->DataPrint("\n\n\n++++++ app_client_session_list:\n");
    

  668.         for (alit = m_appClientSessionList.begin();alit != m_appClientSessionList.end();alit ++,i ++) {
    

  669.                 m_dataShow->DataPrint("----------------the %dth elem:    \n",i);
    

  670.                 m_dataShow->DataPrint("session_imp: 0x%x\n",*alit);
    

  671.                 m_dataShow->DataPrint("\n\n\n");
    

  672.         }
    


  673. 

  674. }
    


  675. 


  676. 


  677.


回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

keer_zu
个人签名：qq群：49734243 Email:zukeqiang@gmail.com

1488

主题

12949

帖子

55

粉丝
快速回复 在线客服 返回列表 返回顶部