21ic电子技术开发论坛 › 软件应用 › 平台与系统开发 › 贴三段代码，一起分析一下优劣。
12下一页
返回列表 发新帖我要提问

贴三段代码，一起分析一下优劣。

[复制链接]
3301|28
 楼主| keer_zu 发表于 2015-8-11 09:28 | 显示全部楼层 |阅读模式
代码
如题，内容看后续三帖子。编号 1， 2， 3
回复

收藏 举报

相关帖子
 楼主| keer_zu 发表于 2015-8-11 09:29 | 显示全部楼层
本帖最后由 keer_zu 于 2015-8-12 09:49 编辑

1-----------
复制

  1. 

  2. #include <iostream>
    

  3. #include <stdio.h>
    

  4.         
    

  5. #include <pthread.h>
    

  6. #include <sys/time.h>
    

  7. #include <error.h>
    

  8. #include <stdlib.h>
    

  9. #include <memory.h>
    

  10. #include <fstream>
    

  11. //#include <log4cxx/logger.h>
    

  12. //#include <log4cxx/logstring.h>
    

  13. //#include <log4cxx/propertyconfigurator.h>
    

  14. #include "log4cxx_wrapper.h"
    

  15. #include "interface_api.h"
    

  16. #include "disp_task.h"
    

  17. #include "queue_manager.h"
    


  18. 


  19. 

  20. //using namespace log4cxx;
    

  21. //extern LoggerPtr g_Dslogger;
    


  22. 

  23. extern DsManage g_cDsManage;
    


  24. 

  25. BOOL32 DsGetTimeInfo( TaskTimeInfo* ptTimeInfo )
    

  26. {
    

  27.     if( NULL == ptTimeInfo )
    

  28.     {
    

  29.         return FALSE;
    

  30.     }
    


  31. 

  32.     struct tm tmTemp;
    

  33.     struct timeval ttTemp;
    

  34.     if( 0 != gettimeofday( &ttTemp , NULL ) )
    

  35.     {
    

  36.         return FALSE;
    

  37.     }
    

  38.     tmTemp = *localtime( &ttTemp.tv_sec );
    

  39.     ptTimeInfo->m_wYear = tmTemp.tm_year+1900;
    

  40.     ptTimeInfo->m_wMonth = tmTemp.tm_mon+1;
    

  41.     ptTimeInfo->m_wDay = tmTemp.tm_mday;
    

  42.     ptTimeInfo->m_wHour = tmTemp.tm_hour;
    

  43.     ptTimeInfo->m_wMinute = tmTemp.tm_min;
    

  44.     ptTimeInfo->m_wSecond = tmTemp.tm_sec;
    

  45.     return TRUE;
    


  46. 

  47. }
    


  48. 


  49. 

  50. void DsManage::OnRegister(RegisterInfo ®Info, TsSession &session) 
    

  51. {
    

  52.     string json;
    

  53.     TsMessageCodec tmpTsMessageCodec;
    

  54.     RegisterResponse* pResponse = new RegisterResponse; 
    

  55.     u32 dwTsIndex=0;
    

  56.     u32 dwTsFreeIndex = 0;
    

  57.     bool bFind = FALSE;
    

  58.     bool bResult = TRUE;
    

  59.     TsType tsType = regInfo.GetTsType();
    

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

  61.     dsLog.Log(TRUE,LOGGER_DEBUG,"session:%d,GetTsId:%s,GetTsIp:%s,GetTstype:%d , [%s][%s][%d]\n",&session,regInfo.GetTsId().c_str(),regInfo.GetTsIp().c_str(),regInfo.GetTsType(),__FILE__,__PRETTY_FUNCTION__,__LINE__);    
    


  62. 

  63. //    printf("GetTsId:%s,GetTsIp:%s,GetTstype:%d\n",regInfo.GetTsId().c_str(),regInfo.GetTsIp().c_str(),regInfo.GetTsType());
    

  64.     //添加注册的转换服务器进入转换服务器队列
    

  65.     if(TS_DYNAMIC_PPT == tsType)
    

  66.     {
    

  67.         for(dwTsIndex=1;dwTsIndex<MAX_DANAMIC_PPT_TRANS_SERVER_NUM;dwTsIndex++)
    

  68.         {
    


  69. 

  70.             if(TS_UNREGISTERED == g_cDsManage.PPTTs[dwTsIndex].GetState())
    

  71.             {
    

  72.                 if(FALSE == bFind)
    

  73.                 {
    

  74.                     bFind = TRUE;
    

  75.                     dwTsFreeIndex = dwTsIndex;
    

  76.                 }
    


  77. 

  78.             }
    

  79.             else if((TS_FREE == g_cDsManage.PPTTs[dwTsIndex].GetState()) ||(TS_RUNNING== g_cDsManage.PPTTs[dwTsIndex].GetState()))
    

  80.             {
    

  81.                 if((g_cDsManage.PPTTs[dwTsIndex].GetIpAddr() == regInfo.GetTsIp()) && (g_cDsManage.PPTTs[dwTsIndex].GetTsId() == regInfo.GetTsId()))
    

  82.                 {
    

  83.                     bResult = FALSE;
    

  84.                     break;
    

  85.                 }
    

  86.             }
    

  87.         }
    


  88. 

  89.         if(bFind && bResult)
    

  90.         {
    

  91.             PPTTs[dwTsFreeIndex].SetIpAddr(regInfo.GetTsIp());
    

  92.             PPTTs[dwTsFreeIndex].SetTsId( regInfo.GetTsId());
    

  93.             PPTTs[dwTsFreeIndex].SetTsType( regInfo.GetTsType());
    

  94.             PPTTs[dwTsFreeIndex].SetTsSession( &session);
    

  95.             PPTTs[dwTsFreeIndex].SetState(TS_FREE);
    


  96. 

  97.         }
    


  98. 

  99.     }
    

  100.     else if(TS_DOCUMENT_WINDOWS == tsType)
    

  101.     {
    

  102.         for(dwTsIndex=1;dwTsIndex<MAX_DOC_WINDOWS_TRANS_SERVER_NUM;dwTsIndex++)
    

  103.         {
    


  104. 

  105.             if(TS_UNREGISTERED == g_cDsManage.DocWindowsTs[dwTsIndex].GetState())
    

  106.             {
    

  107.                 if(FALSE == bFind)
    

  108.                 {
    

  109.                     bFind = TRUE;
    

  110.                     dwTsFreeIndex = dwTsIndex;
    

  111.                 }
    


  112. 

  113.             }
    

  114.             else if((TS_FREE == g_cDsManage.DocWindowsTs[dwTsIndex].GetState()) ||(TS_RUNNING== g_cDsManage.DocWindowsTs[dwTsIndex].GetState()))
    

  115.             {
    

  116.                 if((g_cDsManage.DocWindowsTs[dwTsIndex].GetIpAddr() == regInfo.GetTsIp()) && (g_cDsManage.DocWindowsTs[dwTsIndex].GetTsId() == regInfo.GetTsId()))
    

  117.                 {
    

  118.                     bResult = FALSE;
    

  119.                     break;
    

  120.                 }
    

  121.             }
    

  122.         }
    


  123. 

  124.         if(bFind && bResult)
    

  125.         {
    

  126.             DocWindowsTs[dwTsFreeIndex].SetIpAddr(regInfo.GetTsIp());
    

  127.             DocWindowsTs[dwTsFreeIndex].SetTsId( regInfo.GetTsId());
    

  128.             DocWindowsTs[dwTsFreeIndex].SetTsType( regInfo.GetTsType());
    

  129.             DocWindowsTs[dwTsFreeIndex].SetTsSession( &session);
    

  130.             DocWindowsTs[dwTsFreeIndex].SetState(TS_FREE);
    

  131.         }
    


  132. 

  133.     }    
    

  134.     else if(TS_DOCUMENT == tsType)
    

  135.     {
    

  136.         for(dwTsIndex=1;dwTsIndex<MAX_DOC_TRANS_SERVER_NUM;dwTsIndex++)
    

  137.         {
    

  138.             
    

  139.             if(TS_UNREGISTERED == g_cDsManage.DocTs[dwTsIndex].GetState())
    

  140.             {
    

  141.                 if(FALSE == bFind)
    

  142.                 {
    

  143.                     bFind = TRUE;
    

  144.                     dwTsFreeIndex = dwTsIndex;
    

  145.                 }
    

  146.                 
    

  147.             }
    

  148.             else if((TS_FREE == g_cDsManage.DocTs[dwTsIndex].GetState()) ||(TS_RUNNING== g_cDsManage.DocTs[dwTsIndex].GetState()))
    

  149.             {
    

  150.                 if((g_cDsManage.DocTs[dwTsIndex].GetIpAddr() == regInfo.GetTsIp()) && (g_cDsManage.DocTs[dwTsIndex].GetTsId() == regInfo.GetTsId()))
    

  151.                 {
    

  152.                     bResult = FALSE;
    

  153.                     break;
    

  154.                 }
    

  155.             }
    

  156.         }
    


  157. 

  158.         if(bFind && bResult)
    

  159.         {
    

  160.             DocTs[dwTsFreeIndex].SetIpAddr(regInfo.GetTsIp());
    

  161.             DocTs[dwTsFreeIndex].SetTsId( regInfo.GetTsId());
    

  162.             DocTs[dwTsFreeIndex].SetTsType( regInfo.GetTsType());
    

  163.             DocTs[dwTsFreeIndex].SetTsSession( &session);
    

  164.             DocTs[dwTsFreeIndex].SetState(TS_FREE);
    

  165.         }
    

  166.         
    

  167.     }
    

  168.     else if(TS_VIDEO == tsType)
    

  169.     {
    

  170.         for(dwTsIndex=1;dwTsIndex<MAX_VIDEO_TRANS_SERVER_NUM;dwTsIndex++)
    

  171.         {
    

  172.             
    

  173.             if(TS_UNREGISTERED == g_cDsManage.VideoTs[dwTsIndex].GetState())
    

  174.             {
    

  175.                 if(FALSE == bFind)
    

  176.                 {
    

  177.                     bFind = TRUE;
    

  178.                     dwTsFreeIndex = dwTsIndex;
    

  179.                 }
    

  180.                 
    

  181.             }
    

  182.             else if((TS_FREE == g_cDsManage.VideoTs[dwTsIndex].GetState()) ||(TS_RUNNING== g_cDsManage.VideoTs[dwTsIndex].GetState()))
    

  183.             {
    

  184.                 if((g_cDsManage.VideoTs[dwTsIndex].GetIpAddr() == regInfo.GetTsIp()) && (g_cDsManage.VideoTs[dwTsIndex].GetTsId() == regInfo.GetTsId()))
    

  185.                 {
    

  186.                     bResult = FALSE;
    

  187.                     break;
    

  188.                 }
    

  189.             }
    

  190.         }
    


  191. 

  192.         if(bFind && bResult)
    

  193.         {
    

  194.             VideoTs[dwTsFreeIndex].SetIpAddr(regInfo.GetTsIp());
    

  195.             VideoTs[dwTsFreeIndex].SetTsId( regInfo.GetTsId());
    

  196.             VideoTs[dwTsFreeIndex].SetTsType( regInfo.GetTsType());
    

  197.             VideoTs[dwTsFreeIndex].SetTsSession( &session);
    

  198.             VideoTs[dwTsFreeIndex].SetState(TS_FREE);
    


  199. 

  200.         }
    

  201.         
    

  202.     }
    

  203.     else
    

  204.     {
    

  205.         dsLog.Log(TRUE,LOGGER_DEBUG,"error message from transfer server. Register invalid ts server type::%d , [%s][%s][%d]\n",tsType,__FILE__,__PRETTY_FUNCTION__,__LINE__);        
    

  206. //        LOG4CXX_ERROR(g_Dslogger, "error message from transfer server. Register invalid ts server type: ");
    

  207. //        LOG4CXX_ERROR(g_Dslogger, tsType);    
    

  208.         return;
    

  209.     }
    

  210.     
    

  211.     //发送响应消息给转换服务器
    

  212.     if(bFind && bResult)
    

  213.     {
    

  214.         pResponse->SetResult(TRUE);
    

  215.         pResponse->SetErrorCode(RET_OK);
    

  216.         pResponse->SetErrorDetail("");
    

  217.     }
    

  218.     else if(FALSE == bResult)
    

  219.     {
    

  220.         pResponse->SetResult(FALSE);
    

  221.         pResponse->SetErrorCode(RET_E_REPEATED_TS_ID);
    

  222.         pResponse->SetErrorDetail("Same ts id   can not be registered repeated!");
    

  223.     }
    

  224.     else if(FALSE == bFind)
    

  225.     {
    

  226.         pResponse->SetResult(FALSE);
    

  227.         pResponse->SetErrorCode(RET_E_TS_USED_UP);
    

  228.         pResponse->SetErrorDetail("No enough ts resource can be registered!");
    

  229.     }
    


  230. 

  231.     session.SendMessage(*pResponse);
    

  232.     if((FALSE == bResult) || (FALSE == bFind))
    

  233.     {
    

  234.         session.Close();
    

  235.         return;
    

  236.     }
    


  237. 

  238.     //如果注册成功检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  239.     //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  240.     if(TS_DYNAMIC_PPT == tsType)
    

  241.     {
    

  242.         if (( !m_TransDynamicPptWaitQueue.empty() ) && (TRUE == bResult)&& (TRUE == bFind))
    

  243.         {
    

  244.             AppTaskMessage*  pTaskMessage = m_TransDynamicPptWaitQueue.top( );
    

  245. //                printf("4444  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  246.       //          printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());  
    

  247.             m_TransDynamicPptWaitQueue.pop( );   
    

  248.             TaskTimeInfo tTaskTimeInfo ;
    

  249.             if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  250.             {
    

  251.                 return;
    

  252.             }
    

  253.             pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  254.             m_TransDynamicPptRunQueue.push_back(pTaskMessage);
    

  255.      
    

  256.             PPTTs[dwTsFreeIndex].SetMessageInTs(pTaskMessage);
    

  257.             PPTTs[dwTsFreeIndex].SetState(TS_RUNNING);
    

  258.             pTaskMessage->SetTsNum(dwTsFreeIndex);
    

  259.             
    

  260.             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  261.             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  262.             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  263.             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  264.             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  265.             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  266.         
    

  267.             PPTTs[dwTsFreeIndex].GetTsSession()->SendMessage(*pTransitionRequest);
    

  268. //                printf("55555  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  269.     //            printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());          
    

  270.             if(NULL !=  pTransitionRequest)
    

  271.             {
    

  272.                 delete pTransitionRequest;
    

  273.                 pTransitionRequest = NULL;
    

  274.             }
    

  275.  //               printf("666  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  276.    //             printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());          
    


  277. 

  278.         }
    


  279. 

  280.     }
    

  281.     else if(TS_DOCUMENT_WINDOWS == tsType)
    

  282.     {
    

  283.         if (( !m_TransDocWindowsWaitQueue.empty() ) && (TRUE == bResult)&& (TRUE == bFind))
    

  284.         {
    

  285.             AppTaskMessage*  pTaskMessage = m_TransDocWindowsWaitQueue.top( );
    

  286. //                printf("4444  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  287.       //          printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());  
    

  288.             m_TransDocWindowsWaitQueue.pop( ); 
    

  289.             TaskTimeInfo tTaskTimeInfo ;
    

  290.             if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  291.             {
    

  292.                 return;
    

  293.             }
    

  294.             pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    


  295. 

  296.             m_TransDocWindowsRunQueue.push_back(pTaskMessage);
    

  297.      
    

  298.             DocWindowsTs[dwTsFreeIndex].SetMessageInTs(pTaskMessage);
    

  299.             DocWindowsTs[dwTsFreeIndex].SetState(TS_RUNNING);
    

  300.             pTaskMessage->SetTsNum(dwTsFreeIndex);
    

  301.             
    

  302.             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  303.             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  304.             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  305.             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  306.             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  307.             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  308.         
    

  309.             DocWindowsTs[dwTsFreeIndex].GetTsSession()->SendMessage(*pTransitionRequest);
    

  310. //                printf("55555  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  311.     //            printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());          
    

  312.             if(NULL !=  pTransitionRequest)
    

  313.             {
    

  314.                 delete pTransitionRequest;
    

  315.                 pTransitionRequest = NULL;
    

  316.             }
    

  317.  //               printf("666  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  318.    //             printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());          
    


  319. 

  320.         }
    


  321. 

  322.     }    
    

  323.     else if(TS_DOCUMENT == tsType)
    

  324.     {
    

  325.         if (( !m_TransDocWaitQueue.empty() ) && (TRUE == bResult)&& (TRUE == bFind))
    

  326.         {
    

  327.             AppTaskMessage*  pTaskMessage = m_TransDocWaitQueue.top( );
    

  328. //                printf("4444  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  329.     //            printf("m_TransDocWaitQueue.size:%d\n",m_TransDocWaitQueue.size());  
    

  330.             m_TransDocWaitQueue.pop( );      
    

  331.             TaskTimeInfo tTaskTimeInfo ;
    

  332.             if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  333.             {
    

  334.                 return;
    

  335.             }
    

  336.             pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    


  337. 

  338.             m_TransDocRunQueue.push_back(pTaskMessage);
    

  339.      
    

  340.             DocTs[dwTsFreeIndex].SetMessageInTs(pTaskMessage);
    

  341.             DocTs[dwTsFreeIndex].SetState(TS_RUNNING);
    

  342.             pTaskMessage->SetTsNum(dwTsFreeIndex);
    

  343.             
    

  344.             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  345.             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  346.             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  347.             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  348.             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  349.             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  350. 

  351.             DocTs[dwTsFreeIndex].GetTsSession()->SendMessage(*pTransitionRequest);
    

  352. //                printf("55555  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  353.  //               printf("m_TransDocWaitQueue.size:%d\n",m_TransDocWaitQueue.size());          
    

  354.             if(NULL !=  pTransitionRequest)
    

  355.             {
    

  356.                 delete pTransitionRequest;
    

  357.                 pTransitionRequest = NULL;
    

  358.             }
    

  359. //                printf("666  target:%s,prefix:%s,type:%d\n",pTaskMessage->GetTargetFullPathFileName().c_str(),pTaskMessage->GetFilePrefix().c_str(),pTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  360.  //               printf("m_TransDocWaitQueue.size:%d\n",m_TransDocWaitQueue.size());          
    


  361. 

  362.         }
    

  363.     }
    

  364.     else  //(TS_VIDEO == tsType)
    

  365.     {
    

  366.         if (( !m_VideoWaitQueue.empty() ) && (TRUE == bResult)&& (TRUE == bFind))
    

  367.         {            
    

  368.             AppTaskMessage*  pTaskMessage = m_VideoWaitQueue.top( );
    

  369.             m_VideoWaitQueue.pop( ); 
    

  370.             TaskTimeInfo tTaskTimeInfo ;
    

  371.             if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  372.             {
    

  373.                 return;
    

  374.             }
    

  375.             pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    


  376. 

  377.             m_VideoRunQueue.push_back(pTaskMessage);
    

  378.      
    

  379.             VideoTs[dwTsFreeIndex].SetMessageInTs(pTaskMessage);
    

  380.             VideoTs[dwTsFreeIndex].SetState(TS_RUNNING);
    

  381.             pTaskMessage->SetTsNum(dwTsFreeIndex);
    


  382. 

  383.             if(APP_MESSAGE_VIDEO_TRANS_TASK == pTaskMessage->GetAppMessageType())
    

  384.             {   
    

  385.                 TransVideoRequest* pTransVideoRequest = new TransVideoRequest;
    

  386.                 pTransVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  387.                 pTransVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  388.                 pTransVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    


  389. 

  390.                 char cFormat[100];
    

  391.                 sprintf(cFormat, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwFormat);
    

  392.                 pTransVideoRequest->SetFormat(cFormat);
    


  393. 

  394.                 char cBitRate[100];
    

  395.                 sprintf(cBitRate, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwBitrate);
    

  396.                 pTransVideoRequest->SetBitRate(cBitRate);
    


  397. 

  398.                 char cWidth[100];
    

  399.                 char cHeight[100];
    

  400.                 string strWidth,strHeight,strResolution;
    

  401.                 sprintf(cWidth, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionWidth);
    

  402.                 sprintf(cHeight, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionHeight);
    

  403.                 strWidth = cWidth;
    

  404.                 strHeight = cHeight;
    

  405.                 strResolution = strWidth +"*"+strHeight;
    

  406.                 pTransVideoRequest->SetResolution(strResolution);
    

  407.                 
    

  408.                 VideoTs[dwTsFreeIndex].GetTsSession()->SendMessage(*pTransVideoRequest);
    

  409.                 if(NULL !=  pTransVideoRequest)
    

  410.                 {
    

  411.                     delete pTransVideoRequest;
    

  412.                     pTransVideoRequest = NULL;
    

  413.                 }
    

  414.             }
    

  415.             else if(APP_MESSAGE_VIDEO_CAPTURE_TASK == pTaskMessage->GetAppMessageType())
    

  416.             {
    

  417.                 CapVideoRequest* pCapVideoRequest = new CapVideoRequest;
    

  418.                 pCapVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  419.                 pCapVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  420.                 pCapVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  421.                 pCapVideoRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    


  422. 

  423.                 char cStart[100];
    

  424.                 sprintf(cStart, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwStartTIme);
    

  425.                 pCapVideoRequest->SetStart(cStart);
    


  426. 

  427.                 char cCount[100];
    

  428.                 sprintf(cCount, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwPhotoCount);
    

  429.                 pCapVideoRequest->SetCount(cCount);
    


  430. 


  431. 

  432.                 char cInterval[100];
    

  433.                 sprintf(cInterval, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwSustainedTime);
    

  434.                 pCapVideoRequest->SetInterval(cInterval);
    

  435.                 
    

  436.                 VideoTs[dwTsFreeIndex].GetTsSession()->SendMessage(*pCapVideoRequest);
    

  437.                 if(NULL !=  pCapVideoRequest)
    

  438.                 {
    

  439.                     delete pCapVideoRequest;
    

  440.                     pCapVideoRequest = NULL;
    

  441.                 }
    

  442.             }
    

  443.             else if(APP_MESSAGE_VIDEO_INFO_TASK == pTaskMessage->GetAppMessageType())
    

  444.             {
    

  445.                 GetVideoInfoRequest* pVideoInfoRequest = new GetVideoInfoRequest;
    

  446.                 pVideoInfoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  447.                 pVideoInfoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  448.                 
    

  449.                 VideoTs[dwTsFreeIndex].GetTsSession()->SendMessage(*pVideoInfoRequest);
    

  450.                 if(NULL !=  pVideoInfoRequest)
    

  451.                 {
    

  452.                     delete pVideoInfoRequest;
    

  453.                     pVideoInfoRequest = NULL;
    

  454.                 }
    

  455.             }
    

  456.             else //error
    

  457.             {
    

  458.                 dsLog.Log(TRUE,LOGGER_DEBUG,"error task in the wait queue  appMessage type::%d , [%s][%s][%d]\n",pTaskMessage->GetAppMessageType(),__FILE__,__PRETTY_FUNCTION__,__LINE__);        
    


  459. 

  460.             }
    


  461. 

  462.         }
    

  463.     }
    

  464.     
    

  465. }
    


  466. 

  467. void DsManage::OnTaskResult(TaskResult &taskResult, TsSession &session) 
    

  468. {
    

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

  470.     //    printf("OnTaskResult,  result:%d, session:%d  ***************\n",taskResult.GetResult(),&session);
    

  471.     dsLog.Log(TRUE,LOGGER_DEBUG,"OnTaskResult,  result:%d, session:%d , [%s][%s][%d]\n",taskResult.GetResult(),&session,__FILE__,__PRETTY_FUNCTION__,__LINE__);        
    

  472.     string json;
    

  473.     TsMessageCodec tmpTsMessageCodec;
    

  474.     ResultResponse* pResponse = new ResultResponse; 
    


  475. 

  476.     TsTaskResultType tsTaskResultType = taskResult.GetTsTaskResultType();
    

  477.     bool bFind =FALSE;
    


  478. 

  479.     //对视频服务器消息的部分单独处理
    

  480.     if(TS_MESSAGE_VIDEO_TRANS_RESULT == tsTaskResultType)
    

  481.     {
    

  482.         pResponse->SetMessageId(taskResult.GetMessageId());
    

  483.         pResponse->SetServerType("Transfer");
    

  484.     }
    

  485.     else if(TS_MESSAGE_VIDEO_CAPTURE_RESULT == tsTaskResultType)
    

  486.     {
    

  487.         pResponse->SetMessageId(taskResult.GetMessageId());
    

  488.         pResponse->SetServerType("CapVideo");
    


  489. 

  490.     }
    

  491.     else if(TS_MESSAGE_VIDEO_INFO_RESULT == tsTaskResultType)
    

  492.     {
    

  493.         pResponse->SetMessageId(taskResult.GetMessageId());
    

  494.         pResponse->SetServerType("Message");
    

  495.     }
    

  496.     //回复收到转换服务器消息resultresponse    
    

  497.     session.SendMessage(*pResponse);
    

  498.     if(NULL != pResponse)
    

  499.     {
    

  500.         delete pResponse;
    

  501.         pResponse = NULL;
    

  502.     }
    


  503. 

  504.     if(TS_MESSAGE_DOC_TRANS_RESULT == tsTaskResultType)
    

  505.     {
    

  506.         AppDocTransResultMessage* pResult = new AppDocTransResultMessage; 
    

  507.         //连接和发送转换结果给应用客户端
    

  508.         pResult->SetMessageId(taskResult.GetMessageId());
    

  509.         pResult->SetResult((taskResult).GetResult());
    

  510.         pResult->SetErrorCode((taskResult).GetErrorCode());      
    

  511.         pResult->SetPages((taskResult).GetPages());      
    


  512. 

  513.         //根据转换结果执行相应处理
    

  514.         
    

  515.         //查找运行队列中任务保留该任务ID的IP，端口信息,发送消息给应用端
    

  516.         TaskMessageList::iterator iterIdCheck;
    

  517.         for (iterIdCheck=m_TransDocRunQueue.begin(); iterIdCheck!=m_TransDocRunQueue.end(); iterIdCheck++)
    

  518.         {
    

  519.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  520.             if(pTaskMessage->GetMessageId() == taskResult.GetMessageId())
    

  521.             {
    

  522.                 u32 dwRepeatedTimes = pTaskMessage->GetRepeatedTimes();
    

  523.                 u32 dwWindowsRepeatedTimes = pTaskMessage->GetMessagePara().unTransDoc.m_dwWindowsRepeatTimes;
    

  524. //                if(((3 == dwRepeatedTimes)&&(FALSE == taskResult.GetResult())) || (TRUE == taskResult.GetResult()))
    

  525.                 if( TRUE == taskResult.GetResult())
    

  526.                 {
    

  527.                     string strAppTargetIp;
    

  528.                     u32 dwAppTargetPort;
    

  529.                     if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  530.                     {
    

  531.                         pResult->SetAppTargetIp(strAppTargetIp);
    

  532.                         pResult->SetAppTargetPort(dwAppTargetPort);
    

  533.                         bFind = TRUE;
    

  534.                         
    

  535.                     }
    

  536.                     else
    

  537.                     {
    

  538.                     //error
    

  539.                     }
    


  540. 

  541.                     DocTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  542.                     DocTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                    
    

  543.                     //将该任务从运行队列移除，并归还给空闲队列
    

  544.                     pTaskMessage->Initialize();
    

  545.                     m_FreeMessageQueue.push_back(pTaskMessage);
    

  546.                     m_TransDocRunQueue.erase(iterIdCheck);            
    

  547.                 
    

  548.                 }
    

  549.                 else if((dwRepeatedTimes<MAX_DOC_TRANS_REPEATED_TIMES)&&(FALSE == taskResult.GetResult()))
    

  550.                 {
    

  551.                     bool bFindSecond = FALSE;
    

  552.                     //查找是否存在除了自己以外的空闲转换服务器，如果找到，把任务交给它重新处理,发送任务消息给相关服务器
    

  553.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DOC_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  554.                     {
    

  555.                         if((TS_FREE== DocTs[dwFreeTsNo].GetState()) && (dwFreeTsNo != pTaskMessage->GetTsNum()))
    

  556.                         {
    

  557.                             DocTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  558.                             DocTs[dwFreeTsNo].SetState(TS_RUNNING);                            
    

  559.                             DocTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  560.                             DocTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  561. 

  562.                             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  563.                             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  564.                             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  565.                             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  566.                             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  567.                             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  568. 

  569.                             DocTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  570.                             if(NULL != pTransitionRequest)
    

  571.                             {
    

  572.                                 delete pTransitionRequest;
    

  573.                                 pTransitionRequest = NULL;
    

  574.                             }
    

  575.                             
    

  576.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  577.                             bFindSecond = TRUE;
    

  578.                             break;
    

  579.                         }
    

  580.                     }
    

  581.                     //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  582.                     if(FALSE == bFindSecond)
    

  583.                     {
    

  584.                         pTaskMessage->SetPriority(9);
    

  585.                         m_TransDocWaitQueue.push(pTaskMessage);
    

  586.                         DocTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  587.                         DocTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                        
    

  588.                         TaskMessageList::iterator iterIdCheck;
    

  589.                         for (iterIdCheck=m_TransDocRunQueue.begin(); iterIdCheck!=m_TransDocRunQueue.end(); iterIdCheck++)
    

  590.                         {
    

  591.                             if(*iterIdCheck ==pTaskMessage)
    

  592.                             {
    

  593.                                 m_TransDocRunQueue.erase(iterIdCheck);
    

  594.                                 break;
    

  595.                             }
    

  596.                         }
    

  597.                     }
    


  598. 

  599.                     dwRepeatedTimes++;
    

  600.                     pTaskMessage->SetRepeatedTimes( dwRepeatedTimes);
    

  601.                 }
    

  602.                 else if(((MAX_DOC_TRANS_REPEATED_TIMES == dwRepeatedTimes)&&(FALSE == taskResult.GetResult()))&&(0 == dwWindowsRepeatedTimes))
    

  603.                 {
    

  604.                 //将该任务交给windows版本文档转换处理，同时从运行队列删除
    

  605.                     bool bFindWindows = FALSE;
    

  606.                     //查找是否存在空闲windows 转换服务器，如果找到，把任务交给它重新处理,并添加到运行队列中，发送任务消息给相关服务器
    

  607.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  608.                     {   
    

  609.                         if((TS_FREE== DocWindowsTs[dwFreeTsNo].GetState()))
    

  610.                         {
    

  611.                             DocWindowsTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  612.                             DocWindowsTs[dwFreeTsNo].SetState(TS_RUNNING);                            
    

  613.                             DocTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  614.                             DocTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  615. 

  616.                             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  617.                             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  618.                             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  619.                             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  620.                             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  621.                             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  622. 

  623.                             DocWindowsTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  624.                             if(NULL != pTransitionRequest)
    

  625.                             {
    

  626.                                 delete pTransitionRequest;
    

  627.                                 pTransitionRequest = NULL;
    

  628.                             }
    


  629. 

  630.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  631.                             bFindWindows = TRUE;
    

  632.                             //将该任务添加到windows版本文档转换运行队列中
    

  633.                             TaskTimeInfo tTaskTimeInfo ;
    

  634.                             if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  635.                             {
    

  636.                                 return;
    

  637.                             }
    

  638.                             pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  639.                             
    

  640.                             m_TransDocWindowsRunQueue.push_back(pTaskMessage);
    

  641.                             break;
    

  642.                         }
    

  643.                     }
    

  644.                     //如果没有windows 转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列
    

  645.                     if(FALSE == bFindWindows)
    

  646.                     {
    

  647.                         pTaskMessage->SetPriority(9);
    

  648.                         m_TransDocWindowsWaitQueue.push(pTaskMessage);
    

  649.                     }
    


  650. 

  651.                     //将该任务从linux版文档转换服务器运行队列移除
    

  652.                     
    

  653.                     m_TransDocRunQueue.erase(iterIdCheck); 
    


  654. 

  655.                 }
    

  656.                 break;
    

  657.             }
    

  658.         }
    

  659.         
    

  660.         if(bFind)
    

  661.         {
    

  662.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  663.         }
    


  664. 

  665.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  666.         //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    


  667. 

  668.         for(u32 dwTsNo =1; dwTsNo <MAX_DOC_TRANS_SERVER_NUM; dwTsNo++)
    

  669.         {
    

  670.             if(&session ==DocTs[dwTsNo].GetTsSession()) 
    

  671.             {
    

  672.     //            printf("find ts,dwTsNo:%d,m_TransDocWaitQueue.size:%d,m_TransDocWaitQueue.empty():%d\n",dwTsNo,m_TransDocWaitQueue.size(),m_TransDocWaitQueue.empty());
    

  673.                 if( !m_TransDocWaitQueue.empty() )
    

  674.                 { 
    

  675.                     AppTaskMessage*  pTaskMessage = m_TransDocWaitQueue.top( );
    

  676.                     m_TransDocWaitQueue.pop( );   
    

  677.                     TaskTimeInfo tTaskTimeInfo ;
    

  678.                     if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  679.                     {
    

  680.                         return;
    

  681.                     }
    

  682.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  683.                     
    

  684.                     m_TransDocRunQueue.push_back(pTaskMessage);
    

  685.              
    

  686.                     DocTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  687.                     DocTs[dwTsNo].SetState(TS_RUNNING);
    

  688.                     pTaskMessage->SetTsNum(dwTsNo);
    

  689.                     TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  690.                     pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  691.                     pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  692.                     pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  693.                     pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  694.                     pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  695. 


  696. 

  697.                     DocTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  698.                     if(NULL !=  pTransitionRequest)
    

  699.                     {
    

  700.                         delete pTransitionRequest; 
    

  701.                         pTransitionRequest = NULL;
    

  702.                     }
    

  703.                 }
    

  704.                 else
    

  705.                 {
    

  706.                     DocTs[dwTsNo].SetState(TS_FREE);
    

  707.                     DocTs[dwTsNo].SetMessageInTs(NULL);                                    
    

  708.                 } 
    

  709.                 
    

  710.                 break;
    

  711.             }
    

  712.         
    

  713.         }         
    

  714.         
    

  715.         if(NULL != pResult)
    

  716.         {
    

  717.             delete pResult;
    

  718.             pResult = NULL;
    

  719.         }
    

  720.         
    

  721.     }
    

  722.     else  if(TS_MESSAGE_DOC_WINDOWS_TRANS_RESULT == tsTaskResultType)    
    

  723.     {
    

  724.         
    

  725.         //后面跟应用定了协议之后需要创建新的动态PPT的类        
    

  726.        AppDocTransResultMessage*  pResult = new AppDocTransResultMessage;
    

  727.         //连接和发送转换结果给应用客户端
    

  728.         pResult->SetMessageId(taskResult.GetMessageId());
    

  729.         pResult->SetResult(taskResult.GetResult());
    

  730.         pResult->SetErrorCode(taskResult.GetErrorCode());   
    

  731.         pResult->SetPages((taskResult).GetPages()); 
    


  732. 

  733.         //根据转换结果执行相应处理
    

  734. //          printf("m_TransDocWindowsRunQueue.size():%d\n",m_TransDocWindowsRunQueue.size());
    

  735.           //查找运行队列中任务保留该任务ID的IP，端口信息,发送消息给应用端
    

  736.         TaskMessageList::iterator iterIdCheck;
    

  737.         for (iterIdCheck=m_TransDocWindowsRunQueue.begin(); iterIdCheck!=m_TransDocWindowsRunQueue.end(); iterIdCheck++)
    

  738.         {
    

  739.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  740.             if(pTaskMessage->GetMessageId() == taskResult.GetMessageId())
    

  741.             {
    

  742.                 u32 dwWindowsRepeatedTimes = pTaskMessage->GetMessagePara().unTransDoc.m_dwWindowsRepeatTimes;
    

  743.                 if(((MAX_DOC_WINDOWS_TRANS_REPEATED_TIMES == dwWindowsRepeatedTimes)&&(FALSE == taskResult.GetResult())) || (TRUE == taskResult.GetResult()))
    

  744.                 {
    

  745.                     string strAppTargetIp;
    

  746.                     u32 dwAppTargetPort;
    

  747.                     if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  748.                     {
    

  749.                         pResult->SetAppTargetIp(strAppTargetIp);
    

  750.                         pResult->SetAppTargetPort(dwAppTargetPort);
    

  751.                         bFind = TRUE;
    

  752.                           
    

  753.                     }
    

  754.                     else
    

  755.                     {
    

  756.                     //error
    

  757.                     }
    


  758. 


  759. 

  760.                     DocWindowsTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  761.                     DocWindowsTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  762.                     //将该任务从运行队列移除，并归还给空闲队列
    

  763.                     pTaskMessage->Initialize();
    

  764.                     m_FreeMessageQueue.push_back(pTaskMessage);
    

  765.                     m_TransDocWindowsRunQueue.erase(iterIdCheck);            
    

  766.                   
    

  767.                 }
    

  768.                 else
    

  769.                 {
    

  770.                     bool bFindSecond = FALSE;
    

  771.                     //查找是否存在除了自己以外的空闲转换服务器，如果找到，把任务交给它重新处理,发送任务消息给相关服务器
    

  772.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  773.                     {   
    

  774.                         if((TS_FREE== DocWindowsTs[dwFreeTsNo].GetState()) && (dwFreeTsNo != pTaskMessage->GetTsNum()))
    

  775.                         {
    

  776.                             DocWindowsTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  777.                             DocWindowsTs[dwFreeTsNo].SetState(TS_RUNNING);
    

  778.                             DocWindowsTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  779.                             DocWindowsTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  780. 

  781.                             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  782.                             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  783.                             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  784.                             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  785.                             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  786.                             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  787. 

  788.                             DocWindowsTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  789.                             if(NULL != pTransitionRequest)
    

  790.                             {
    

  791.                                 delete pTransitionRequest;
    

  792.                                 pTransitionRequest = NULL;
    

  793.                              }
    

  794.                               
    

  795.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  796.                             bFindSecond = TRUE;
    

  797.                             break;
    

  798.                          }
    

  799.                      }
    

  800.                      //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  801.                      if(FALSE == bFindSecond)
    

  802.                      {
    

  803.                          pTaskMessage->SetPriority(9);
    

  804.                          m_TransDocWindowsWaitQueue.push(pTaskMessage);
    

  805.                          DocWindowsTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  806.                          DocWindowsTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                        
    


  807. 

  808.                          m_TransDocWindowsRunQueue.erase(iterIdCheck);                   
    

  809.                      }
    

  810.                       
    

  811.                      dwWindowsRepeatedTimes++;
    

  812. //                     pTaskMessage->SetRepeatedTimes( dwWindowsRepeatedTimes);
    

  813.                      UnionMessageParam unMessagePara;
    

  814.                      unMessagePara = pTaskMessage->GetMessagePara();
    

  815.                      unMessagePara.unTransDoc.m_dwWindowsRepeatTimes = dwWindowsRepeatedTimes;
    

  816.                      pTaskMessage->SetMessagePara(unMessagePara);
    


  817. 

  818.                  }
    

  819.         
    

  820.                  break;
    

  821.              }
    

  822.          }
    


  823. 

  824.  
    

  825.          if(bFind)
    

  826.          {
    

  827.              (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  828.          }
    

  829.         
    

  830.          //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  831.          //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  832.         
    

  833.          for(u32 dwTsNo =1; dwTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwTsNo++)
    

  834.          {
    

  835.              if(&session ==DocWindowsTs[dwTsNo].GetTsSession()) 
    

  836.              {
    

  837.    //              printf("find ts,dwTsNo:%d,m_TransDocWaitQueue.size:%d,m_TransDocWaitQueue.empty():%d\n",dwTsNo,m_TransDocWaitQueue.size(),m_TransDocWaitQueue.empty());
    

  838.                  if( !m_TransDocWindowsWaitQueue.empty() )
    

  839.                  { 
    

  840.                      AppTaskMessage*  pTaskMessage = m_TransDocWindowsWaitQueue.top( );
    

  841.                      m_TransDocWindowsWaitQueue.pop( );      
    

  842.                      
    

  843.                      TaskTimeInfo tTaskTimeInfo ;
    

  844.                      if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  845.                      {
    

  846.                          return;
    

  847.                      }
    

  848.                      pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  849.                      m_TransDocWindowsRunQueue.push_back(pTaskMessage);
    

  850.                
    

  851.                      DocWindowsTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  852.                      DocWindowsTs[dwTsNo].SetState(TS_RUNNING);
    

  853.                      pTaskMessage->SetTsNum(dwTsNo);
    

  854.                      TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  855.                      pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  856.                      pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  857.                      pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  858.                      pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  859.                      pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  860.                   
    

  861.                      DocWindowsTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  862.                      if(NULL !=  pTransitionRequest)
    

  863.                      {
    

  864.                          delete pTransitionRequest; 
    

  865.                          pTransitionRequest = NULL;
    

  866.                      }
    

  867.                  }
    

  868.                  else
    

  869.                  {
    

  870.                      DocWindowsTs[dwTsNo].SetState(TS_FREE);
    

  871.                      DocWindowsTs[dwTsNo].SetMessageInTs(NULL);
    

  872.                  } 
    

  873.                   
    

  874.                  break;
    

  875.              }
    

  876.           
    

  877.          }         
    

  878.         
    

  879.         if(NULL != pResult)
    

  880.         {
    

  881.             delete pResult;
    

  882.             pResult = NULL;
    

  883.         }
    


  884. 

  885.     }    
    

  886.     else  if(TS_MESSAGE_DYNAMIC_PPT_RESULT == tsTaskResultType)
    

  887.     {
    


  888. 

  889.         //后面跟应用定了协议之后需要创建新的动态PPT的类        
    

  890.        AppDynamicPptTransResultMessage*  pResult = new AppDynamicPptTransResultMessage;
    

  891.         //连接和发送转换结果给应用客户端
    

  892.         pResult->SetMessageId(taskResult.GetMessageId());
    

  893.         pResult->SetResult(taskResult.GetResult());
    

  894.         pResult->SetErrorCode(taskResult.GetErrorCode());   
    

  895.         pResult->SetPages((taskResult).GetPages()); 
    


  896. 

  897.         //根据转换结果执行相应处理
    

  898.           
    

  899.           //查找运行队列中任务保留该任务ID的IP，端口信息,发送消息给应用端
    

  900.         TaskMessageList::iterator iterIdCheck;
    

  901.         for (iterIdCheck=m_TransDynamicPptRunQueue.begin(); iterIdCheck!=m_TransDynamicPptRunQueue.end(); iterIdCheck++)
    

  902.         {
    

  903.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  904.             if(pTaskMessage->GetMessageId() == taskResult.GetMessageId())
    

  905.             {
    

  906.                 u32 dwRepeatedTimes = pTaskMessage->GetRepeatedTimes();
    

  907.                 if(((3 == dwRepeatedTimes)&&(FALSE == taskResult.GetResult())) || (TRUE == taskResult.GetResult()))
    

  908.                 {
    

  909.                     string strAppTargetIp;
    

  910.                     u32 dwAppTargetPort;
    

  911.                     if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  912.                     {
    

  913.                         pResult->SetAppTargetIp(strAppTargetIp);
    

  914.                         pResult->SetAppTargetPort(dwAppTargetPort);
    

  915.                         bFind = TRUE;
    

  916.                           
    

  917.                     }
    

  918.                     else
    

  919.                     {
    

  920.                     //error
    

  921.                     }
    


  922. 


  923. 

  924.                     PPTTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  925.                     PPTTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  926.                     //将该任务从运行队列移除，并归还给空闲队列
    

  927.                     pTaskMessage->Initialize();
    

  928.                     m_FreeMessageQueue.push_back(pTaskMessage);
    

  929.                     m_TransDynamicPptRunQueue.erase(iterIdCheck);            
    

  930.                   
    

  931.                 }
    

  932.                 else
    

  933.                 {
    

  934.                     bool bFindSecond = FALSE;
    

  935.                     //查找是否存在除了自己以外的空闲转换服务器，如果找到，把任务交给它重新处理,发送任务消息给相关服务器
    

  936.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DANAMIC_PPT_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  937.                     {   
    

  938.                         if((TS_FREE== PPTTs[dwFreeTsNo].GetState()) && (dwFreeTsNo != pTaskMessage->GetTsNum()))
    

  939.                         {
    

  940.                             PPTTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  941.                             PPTTs[dwFreeTsNo].SetState(TS_RUNNING);
    

  942.                             PPTTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  943.                             PPTTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  944. 

  945.                             TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  946.                             pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  947.                             pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  948.                             pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  949.                             pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  950.                             pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  951. 

  952.                             PPTTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  953.                             if(NULL != pTransitionRequest)
    

  954.                             {
    

  955.                                 delete pTransitionRequest;
    

  956.                                 pTransitionRequest = NULL;
    

  957.                              }
    

  958.                               
    

  959.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  960.                             bFindSecond = TRUE;
    

  961.                             break;
    

  962.                          }
    

  963.                      }
    

  964.                      //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  965.                      if(FALSE == bFindSecond)
    

  966.                      {
    

  967.                          pTaskMessage->SetPriority(9);
    

  968.                          m_TransDynamicPptWaitQueue.push(pTaskMessage);
    

  969.                          PPTTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  970.                          PPTTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                        
    

  971.                          
    

  972.                          TaskMessageList::iterator iterIdCheck;
    

  973.                          for (iterIdCheck=m_TransDynamicPptRunQueue.begin(); iterIdCheck!=m_TransDynamicPptRunQueue.end(); iterIdCheck++)
    

  974.                          {
    

  975.                              if(*iterIdCheck ==pTaskMessage)
    

  976.                              {
    

  977.                                  m_TransDynamicPptRunQueue.erase(iterIdCheck);
    

  978.                                  break;
    

  979.                              }
    

  980.                          }                    
    

  981.                      }
    

  982.                       
    

  983.                      dwRepeatedTimes++;
    

  984.                      pTaskMessage->SetRepeatedTimes( dwRepeatedTimes);
    

  985.                  }
    

  986.         
    

  987.                  break;
    

  988.              }
    

  989.          }
    

  990.           
    

  991.          if(bFind)
    

  992.          {
    

  993.              (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  994.          }
    

  995.         
    

  996.          //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  997.          //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  998.         
    

  999.          for(u32 dwTsNo =1; dwTsNo <MAX_DANAMIC_PPT_TRANS_SERVER_NUM; dwTsNo++)
    

  1000.          {
    

  1001.              if(&session ==PPTTs[dwTsNo].GetTsSession()) 
    

  1002.              {
    

  1003.    //              printf("find ts,dwTsNo:%d,m_TransDocWaitQueue.size:%d,m_TransDocWaitQueue.empty():%d\n",dwTsNo,m_TransDocWaitQueue.size(),m_TransDocWaitQueue.empty());
    

  1004.                  if( !m_TransDynamicPptWaitQueue.empty() )
    

  1005.                  { 
    

  1006.                      AppTaskMessage*  pTaskMessage = m_TransDynamicPptWaitQueue.top( );
    

  1007.                      m_TransDynamicPptWaitQueue.pop( );    
    

  1008.                      
    

  1009.                      TaskTimeInfo tTaskTimeInfo ;
    

  1010.                      if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  1011.                      {
    

  1012.                          return;
    

  1013.                      }
    

  1014.                      pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  1015.                      m_TransDynamicPptRunQueue.push_back(pTaskMessage);
    

  1016.                
    

  1017.                      PPTTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  1018.                      PPTTs[dwTsNo].SetState(TS_RUNNING);
    

  1019.                      pTaskMessage->SetTsNum(dwTsNo);
    

  1020.                      TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  1021.                      pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1022.                      pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  1023.                      pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  1024.                      pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  1025.                      pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  1026.                   
    

  1027.                      PPTTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  1028.                      if(NULL !=  pTransitionRequest)
    

  1029.                      {
    

  1030.                          delete pTransitionRequest; 
    

  1031.                          pTransitionRequest = NULL;
    

  1032.                      }
    

  1033.                  }
    

  1034.                  else
    

  1035.                  {
    

  1036.                      PPTTs[dwTsNo].SetState(TS_FREE);
    

  1037.                      PPTTs[dwTsNo].SetMessageInTs(NULL);
    

  1038.                  } 
    

  1039.                   
    

  1040.                  break;
    

  1041.              }
    

  1042.           
    

  1043.          }         
    

  1044.         
    

  1045.         if(NULL != pResult)
    

  1046.         {
    

  1047.             delete pResult;
    

  1048.             pResult = NULL;
    

  1049.         }
    


  1050. 

  1051.     }
    

  1052.     else  if(TS_MESSAGE_VIDEO_TRANS_RESULT == tsTaskResultType)
    

  1053.     {
    

  1054.         AppVideoTransResultMessage* pResult;
    

  1055.         pResult = new AppVideoTransResultMessage;
    

  1056.         //连接和发送转换结果给应用客户端
    

  1057.         pResult->SetMessageId(taskResult.GetMessageId());
    

  1058.         pResult->SetResult((taskResult).GetResult());
    

  1059.         pResult->SetErrorCode((taskResult).GetErrorCode());
    

  1060.         if(FALSE != (taskResult).GetResult())
    

  1061.         {
    

  1062.             pResult->SetTargetFullPathFileName( taskResult.GetTargetFolder());
    

  1063.         }
    

  1064.         else
    

  1065.         {
    

  1066.             pResult->SetTargetFullPathFileName("");
    

  1067.         }
    

  1068.         //根据转换结果执行相应处理
    


  1069. 

  1070.         //查找运行队列中任务保留该任务ID的IP，端口信息,发送消息给应用端
    

  1071.         TaskMessageList::iterator iterIdCheck;
    

  1072.         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  1073.         {
    

  1074.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  1075.             if(pTaskMessage->GetMessageId() == taskResult.GetMessageId())
    

  1076.             {
    

  1077.                 u32 dwRepeatedTimes = pTaskMessage->GetRepeatedTimes();
    

  1078.                 if(((3 == dwRepeatedTimes)&&(FALSE == taskResult.GetResult())) || (TRUE == taskResult.GetResult()))
    

  1079.                 {
    

  1080.                     string strAppTargetIp;
    

  1081.                     u32 dwAppTargetPort;
    

  1082.                     if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  1083.                     {
    

  1084.                         pResult->SetAppTargetIp(strAppTargetIp);
    

  1085.                         pResult->SetAppTargetPort(dwAppTargetPort);
    

  1086.                         bFind = TRUE;
    

  1087.                         
    

  1088.                     }
    

  1089.                     else
    

  1090.                     {
    

  1091.                     //error
    

  1092.                     }
    


  1093. 

  1094.                     VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1095.                     VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                    
    

  1096.                     //将该任务从运行队列移除，并归还给空闲队列
    

  1097.                     pTaskMessage->Initialize();
    

  1098.                     m_FreeMessageQueue.push_back(pTaskMessage);
    

  1099.                     m_VideoRunQueue.erase(iterIdCheck);            
    

  1100.                 
    

  1101.                 }
    

  1102.                 else
    

  1103.                 {
    

  1104.                     bool bFindSecond = FALSE;
    

  1105.                     //查找是否存在除了自己以外的空闲转换服务器，如果找到，把任务交给它重新处理,发送任务消息给相关服务器
    

  1106.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1107.                     {   
    

  1108.                         if((TS_FREE== VideoTs[dwFreeTsNo].GetState()) && (dwFreeTsNo != pTaskMessage->GetTsNum()))
    

  1109.                         {
    

  1110.                             VideoTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  1111.                             VideoTs[dwFreeTsNo].SetState(TS_RUNNING);                            
    

  1112.                             VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1113.                             VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  1114. 


  1115. 

  1116.                             TransVideoRequest* pTransVideoRequest = new TransVideoRequest;
    

  1117.                             pTransVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1118.                             pTransVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  1119.                             pTransVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    


  1120. 

  1121.                             char cFormat[100];
    

  1122.                             sprintf(cFormat, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwFormat);
    

  1123.                             pTransVideoRequest->SetFormat(cFormat);
    

  1124.                             
    

  1125.                             char cBitRate[100];
    

  1126.                             sprintf(cBitRate, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwBitrate);
    

  1127.                             pTransVideoRequest->SetBitRate(cBitRate);
    

  1128.                             
    

  1129.                             char cWidth[100];
    

  1130.                             char cHeight[100];
    

  1131.                             string strWidth,strHeight,strResolution;
    

  1132.                             sprintf(cWidth, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionWidth);
    

  1133.                             sprintf(cHeight, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionHeight);
    

  1134.                             strWidth = cWidth;
    

  1135.                             strHeight = cHeight;
    

  1136.                             strResolution = strWidth +"*"+strHeight;
    

  1137.                             pTransVideoRequest->SetResolution(strResolution);
    

  1138.                             
    

  1139.                             VideoTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransVideoRequest);
    

  1140.                             if(NULL !=  pTransVideoRequest)
    

  1141.                             {
    

  1142.                                 delete pTransVideoRequest;
    

  1143.                                 pTransVideoRequest = NULL;
    

  1144.                             }
    


  1145. 

  1146.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  1147.                             bFindSecond = TRUE;
    

  1148.                             break;
    

  1149.                         }
    

  1150.                     }
    

  1151.                     //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  1152.                     if(FALSE == bFindSecond)
    

  1153.                     {
    

  1154.                         pTaskMessage->SetPriority(9);
    

  1155.                         m_VideoWaitQueue.push(pTaskMessage);
    

  1156.                         VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1157.                         VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                        
    

  1158.                         TaskMessageList::iterator iterIdCheck;
    

  1159.                         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  1160.                         {
    

  1161.                             if(*iterIdCheck ==pTaskMessage)
    

  1162.                             {
    

  1163.                                 m_VideoRunQueue.erase(iterIdCheck);
    

  1164.                                 break;
    

  1165.                             }
    

  1166.                         }
    

  1167.                     }
    


  1168. 

  1169.                     dwRepeatedTimes++;
    

  1170.                     pTaskMessage->SetRepeatedTimes( dwRepeatedTimes);
    

  1171.                 }
    


  1172. 

  1173.                 break;
    

  1174.             }
    

  1175.         }
    

  1176.         
    

  1177.         if(bFind)
    

  1178.         {
    

  1179.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  1180.         }
    


  1181. 

  1182.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  1183.         //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    


  1184. 

  1185.         for(u32 dwTsNo =1; dwTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwTsNo++)
    

  1186.         {
    

  1187.             if(&session ==VideoTs[dwTsNo].GetTsSession()) 
    

  1188.             {
    

  1189.     //            printf("find ts,dwTsNo:%d,m_TransDocWaitQueue.size:%d,m_TransDocWaitQueue.empty():%d\n",dwTsNo,m_TransDocWaitQueue.size(),m_TransDocWaitQueue.empty());
    

  1190.                 if( !m_VideoWaitQueue.empty() )
    

  1191.                 { 
    

  1192.                     AppTaskMessage*  pTaskMessage = m_VideoWaitQueue.top( );
    

  1193.                     m_VideoWaitQueue.pop( );  
    

  1194.                     
    

  1195.                     TaskTimeInfo tTaskTimeInfo ;
    

  1196.                     if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  1197.                     {
    

  1198.                         return;
    

  1199.                     }
    

  1200.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  1201.                     m_VideoRunQueue.push_back(pTaskMessage);
    

  1202.              
    

  1203.                     VideoTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  1204.                     VideoTs[dwTsNo].SetState(TS_RUNNING);
    

  1205.                     pTaskMessage->SetTsNum(dwTsNo);
    


  1206. 

  1207.                     TransVideoRequest* pTransVideoRequest = new TransVideoRequest;
    

  1208.                     pTransVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1209.                     pTransVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  1210.                     pTransVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    


  1211. 

  1212.                     char cFormat[100];
    

  1213.                     sprintf(cFormat, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwFormat);
    

  1214.                     pTransVideoRequest->SetFormat(cFormat);
    


  1215. 

  1216.                     char cBitRate[100];
    

  1217.                     sprintf(cBitRate, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwBitrate);
    

  1218.                     pTransVideoRequest->SetBitRate(cBitRate);
    

  1219.                     
    

  1220.                     char cWidth[100];
    

  1221.                     char cHeight[100];
    

  1222.                     string strWidth,strHeight,strResolution;
    

  1223.                     sprintf(cWidth, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionWidth);
    

  1224.                     sprintf(cHeight, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionHeight);
    

  1225.                     strWidth = cWidth;
    

  1226.                     strHeight = cHeight;
    

  1227.                     strResolution = strWidth +"*"+strHeight;
    

  1228.                     pTransVideoRequest->SetResolution(strResolution);
    

  1229.                     
    

  1230.                     VideoTs[dwTsNo].GetTsSession()->SendMessage(*pTransVideoRequest);
    

  1231.                     if(NULL !=  pTransVideoRequest)
    

  1232.                     {
    

  1233.                         delete pTransVideoRequest;
    

  1234.                         pTransVideoRequest = NULL;
    

  1235.                     }
    

  1236.     
    

  1237.                 }
    

  1238.                 else
    

  1239.                 {
    

  1240.                     VideoTs[dwTsNo].SetState(TS_FREE);
    

  1241.                     VideoTs[dwTsNo].SetMessageInTs(NULL);                                    
    

  1242.                 } 
    

  1243.                 
    

  1244.                 break;
    

  1245.             }
    

  1246.         
    

  1247.         }         
    

  1248.         
    

  1249.         if(NULL != pResult)
    

  1250.         {
    

  1251.             delete pResult;
    

  1252.             pResult = NULL;
    

  1253.         }
    

  1254.         
    

  1255.     }
    

  1256.     else  if(TS_MESSAGE_VIDEO_CAPTURE_RESULT == tsTaskResultType)
    

  1257.     {
    

  1258.         AppVideoCaptureResultMessage* pResult;
    

  1259.         pResult = new AppVideoCaptureResultMessage;
    

  1260.         //连接和发送转换结果给应用客户端
    

  1261.         pResult->SetMessageId(taskResult.GetMessageId());
    

  1262.         pResult->SetResult(taskResult.GetResult());
    

  1263.         pResult->SetErrorCode(taskResult.GetErrorCode());
    

  1264.         pResult->SetCount(taskResult.GetCount());
    


  1265. 

  1266.         //根据转换结果执行相应处理
    

  1267.         
    

  1268.         //查找运行队列中任务保留该任务ID的IP，端口信息,发送消息给应用端
    

  1269.         TaskMessageList::iterator iterIdCheck;
    

  1270.         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  1271.         {
    

  1272.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  1273.             if(pTaskMessage->GetMessageId() == taskResult.GetMessageId())
    

  1274.             {
    

  1275.                 u32 dwRepeatedTimes = pTaskMessage->GetRepeatedTimes();
    

  1276.                 if(((3 == dwRepeatedTimes)&&(FALSE == taskResult.GetResult())) || (TRUE == taskResult.GetResult()))
    

  1277.                 {
    

  1278.                     string strAppTargetIp;
    

  1279.                     u32 dwAppTargetPort;
    

  1280.                     if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  1281.                     {
    

  1282.                         pResult->SetAppTargetIp(strAppTargetIp);
    

  1283.                         pResult->SetAppTargetPort(dwAppTargetPort);
    

  1284.                         bFind = TRUE;
    

  1285.                         
    

  1286.                     }
    

  1287.                     else
    

  1288.                     {
    

  1289.                     //error
    

  1290.                     }
    


  1291. 

  1292.                     VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1293.                     VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                    
    

  1294.                     //将该任务从运行队列移除，并归还给空闲队列
    

  1295.                     pTaskMessage->Initialize();
    

  1296.                     m_FreeMessageQueue.push_back(pTaskMessage);
    

  1297.                     m_VideoRunQueue.erase(iterIdCheck);            
    

  1298.                 
    

  1299.                 }
    

  1300.                 else
    

  1301.                 {
    

  1302.                     bool bFindSecond = FALSE;
    

  1303.                     //查找是否存在除了自己以外的空闲转换服务器，如果找到，把任务交给它重新处理,发送任务消息给相关服务器
    

  1304.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1305.                     {   
    

  1306.                         if((TS_FREE== VideoTs[dwFreeTsNo].GetState()) && (dwFreeTsNo != pTaskMessage->GetTsNum()))
    

  1307.                         {
    

  1308.                             VideoTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  1309.                             VideoTs[dwFreeTsNo].SetState(TS_RUNNING);                            
    

  1310.                             VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1311.                             VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  1312. 

  1313.                             CapVideoRequest* pCapVideoRequest = new CapVideoRequest;
    

  1314.                             pCapVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1315.                             pCapVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  1316.                             pCapVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  1317.                             pCapVideoRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  1318.                             
    

  1319.                             char cStart[100];
    

  1320.                             sprintf(cStart, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwStartTIme);
    

  1321.                             pCapVideoRequest->SetStart(cStart);
    

  1322.                             
    

  1323.                             char cCount[100];
    

  1324.                             sprintf(cCount, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwPhotoCount);
    

  1325.                             pCapVideoRequest->SetCount(cCount);
    

  1326.                             
    

  1327.                             
    

  1328.                             char cInterval[100];
    

  1329.                             sprintf(cInterval, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwSustainedTime);
    

  1330.                             pCapVideoRequest->SetInterval(cInterval);
    

  1331.                             
    

  1332.                             VideoTs[dwFreeTsNo].GetTsSession()->SendMessage(*pCapVideoRequest);
    

  1333.                             if(NULL !=  pCapVideoRequest)
    

  1334.                             {
    

  1335.                                 delete pCapVideoRequest;
    

  1336.                                 pCapVideoRequest = NULL;
    

  1337.                             }
    


  1338. 


  1339. 

  1340.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  1341.                             bFindSecond = TRUE;
    

  1342.                             break;
    

  1343.                         }
    

  1344.                     }
    

  1345.                     //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  1346.                     if(FALSE == bFindSecond)
    

  1347.                     {
    

  1348.                         pTaskMessage->SetPriority(9);
    

  1349.                         m_VideoWaitQueue.push(pTaskMessage);
    

  1350.                         VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1351.                         VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                        
    

  1352.                         TaskMessageList::iterator iterIdCheck;
    

  1353.                         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  1354.                         {
    

  1355.                             if(*iterIdCheck ==pTaskMessage)
    

  1356.                             {
    

  1357.                                 m_VideoRunQueue.erase(iterIdCheck);
    

  1358.                                 break;
    

  1359.                             }
    

  1360.                         }
    

  1361.                     }
    


  1362. 

  1363.                     dwRepeatedTimes++;
    

  1364.                     pTaskMessage->SetRepeatedTimes( dwRepeatedTimes);
    

  1365.                 }
    


  1366. 

  1367.                 break;
    

  1368.             }
    

  1369.         }
    

  1370.         
    

  1371.         if(bFind)
    

  1372.         {
    

  1373.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  1374.         }
    


  1375. 

  1376.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  1377.         //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    


  1378. 

  1379.         for(u32 dwTsNo =1; dwTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwTsNo++)
    

  1380.         {
    

  1381.             if(&session ==VideoTs[dwTsNo].GetTsSession()) 
    

  1382.             {
    

  1383.     //            printf("find ts,dwTsNo:%d,m_TransDocWaitQueue.size:%d,m_TransDocWaitQueue.empty():%d\n",dwTsNo,m_TransDocWaitQueue.size(),m_TransDocWaitQueue.empty());
    

  1384.                 if( !m_VideoWaitQueue.empty() )
    

  1385.                 { 
    

  1386.                     AppTaskMessage*  pTaskMessage = m_VideoWaitQueue.top( );
    

  1387.                     m_VideoWaitQueue.pop( );    
    

  1388.                     
    

  1389.                     TaskTimeInfo tTaskTimeInfo ;
    

  1390.                     if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  1391.                     {
    

  1392.                         return;
    

  1393.                     }
    

  1394.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  1395.                     m_VideoRunQueue.push_back(pTaskMessage);
    

  1396.              
    

  1397.                     VideoTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  1398.                     VideoTs[dwTsNo].SetState(TS_RUNNING);
    

  1399.                     pTaskMessage->SetTsNum(dwTsNo);
    


  1400. 

  1401.                     CapVideoRequest* pCapVideoRequest = new CapVideoRequest;
    

  1402.                     pCapVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1403.                     pCapVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  1404.                     pCapVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  1405.                     pCapVideoRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  1406.                     
    

  1407.                     char cStart[100];
    

  1408.                     sprintf(cStart, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwStartTIme);
    

  1409.                     pCapVideoRequest->SetStart(cStart);
    

  1410.                     
    

  1411.                     char cCount[100];
    

  1412.                     sprintf(cCount, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwPhotoCount);
    

  1413.                     pCapVideoRequest->SetCount(cCount);
    

  1414.                     
    

  1415.                     
    

  1416.                     char cInterval[100];
    

  1417.                     sprintf(cInterval, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwSustainedTime);
    

  1418.                     pCapVideoRequest->SetInterval(cInterval);
    

  1419.                     
    

  1420.                     VideoTs[dwTsNo].GetTsSession()->SendMessage(*pCapVideoRequest);
    

  1421.                     if(NULL !=  pCapVideoRequest)
    

  1422.                     {
    

  1423.                         delete pCapVideoRequest;
    

  1424.                         pCapVideoRequest = NULL;
    

  1425.                     }
    


  1426. 

  1427.     
    

  1428.                 }
    

  1429.                 else
    

  1430.                 {
    

  1431.                     VideoTs[dwTsNo].SetState(TS_FREE);
    

  1432.                     VideoTs[dwTsNo].SetMessageInTs(NULL);                                    
    

  1433.                 } 
    

  1434.                 
    

  1435.                 break;
    

  1436.             }
    

  1437.         
    

  1438.         }         
    

  1439.         
    

  1440.         if(NULL != pResult)
    

  1441.         {
    

  1442.             delete pResult;
    

  1443.             pResult = NULL;
    

  1444.         }
    

  1445.         
    

  1446.     }
    

  1447.     else  if(TS_MESSAGE_VIDEO_INFO_RESULT == tsTaskResultType)
    

  1448.     {
    

  1449.         AppVideoInfoResultMessage* pResult;
    

  1450.         pResult = new AppVideoInfoResultMessage;
    

  1451.         //连接和发送转换结果给应用客户端
    

  1452.         pResult->SetMessageId(taskResult.GetMessageId());
    


  1453. 

  1454.         pResult->SetDuration(atoll(taskResult.GetDuration().c_str()));
    

  1455.         pResult->SetResolution(taskResult.GetResolution());
    

  1456.         pResult->SetAudioCode(taskResult.GetAudioCode());
    

  1457.         pResult->SetVideoCode(taskResult.GetVideoCode());
    

  1458.         pResult->SetAudioTrack(taskResult.GetAudioTrack());
    

  1459.         pResult->SetVideoType(taskResult.GetVideoType());
    

  1460.         pResult->SetFrameRate(atoi(taskResult.GetFrameRate().c_str()));
    

  1461.         pResult->SetBitRate(atoi(taskResult.GetBitRate().c_str()));
    

  1462.         pResult->SetResult((taskResult).GetResult());
    

  1463.         pResult->SetErrorCode((taskResult).GetErrorCode());
    


  1464. 


  1465. 

  1466.         //根据转换结果执行相应处理
    

  1467.         
    

  1468.         //查找运行队列中任务保留该任务ID的IP，端口信息,发送消息给应用端
    

  1469.         TaskMessageList::iterator iterIdCheck;
    

  1470.         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  1471.         {
    

  1472.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  1473.             if(pTaskMessage->GetMessageId() == taskResult.GetMessageId())
    

  1474.             {
    

  1475.                 u32 dwRepeatedTimes = pTaskMessage->GetRepeatedTimes();
    

  1476.                 if(((3 == dwRepeatedTimes)&&(FALSE == taskResult.GetResult())) || (TRUE == taskResult.GetResult()))
    

  1477.                 {
    

  1478.                     string strAppTargetIp;
    

  1479.                     u32 dwAppTargetPort;
    

  1480.                     if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  1481.                     {
    

  1482.                         pResult->SetAppTargetIp(strAppTargetIp);
    

  1483.                         pResult->SetAppTargetPort(dwAppTargetPort);
    

  1484.                         bFind = TRUE;
    

  1485.                         
    

  1486.                     }
    

  1487.                     else
    

  1488.                     {
    

  1489.                     //error
    

  1490.                     }
    


  1491. 

  1492.                     VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1493.                     VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                    
    

  1494.                     //将该任务从运行队列移除，并归还给空闲队列
    

  1495.                     pTaskMessage->Initialize();
    

  1496.                     m_FreeMessageQueue.push_back(pTaskMessage);
    

  1497.                     m_VideoRunQueue.erase(iterIdCheck);            
    

  1498.                 
    

  1499.                 }
    

  1500.                 else
    

  1501.                 {
    

  1502.                     bool bFindSecond = FALSE;
    

  1503.                     //查找是否存在除了自己以外的空闲转换服务器，如果找到，把任务交给它重新处理,发送任务消息给相关服务器
    

  1504.                     for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1505.                     {   
    

  1506.                         if((TS_FREE== VideoTs[dwFreeTsNo].GetState()) && (dwFreeTsNo != pTaskMessage->GetTsNum()))
    

  1507.                         {
    

  1508.                             VideoTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  1509.                             VideoTs[dwFreeTsNo].SetState(TS_RUNNING);                            
    

  1510.                             VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1511.                             VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  1512. 

  1513.                             GetVideoInfoRequest* pVideoInfoRequest = new GetVideoInfoRequest;
    

  1514.                             pVideoInfoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1515.                             pVideoInfoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  1516.                             
    

  1517.                             VideoTs[dwFreeTsNo].GetTsSession()->SendMessage(*pVideoInfoRequest);
    

  1518.                             if(NULL !=  pVideoInfoRequest)
    

  1519.                             {
    

  1520.                                 delete pVideoInfoRequest;
    

  1521.                                 pVideoInfoRequest = NULL;
    

  1522.                             }
    


  1523. 

  1524.                             pTaskMessage->SetTsNum(dwFreeTsNo);
    

  1525.                             bFindSecond = TRUE;
    

  1526.                             break;
    

  1527.                         }
    

  1528.                     }
    

  1529.                     //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  1530.                     if(FALSE == bFindSecond)
    

  1531.                     {
    

  1532.                         pTaskMessage->SetPriority(9);
    

  1533.                         m_VideoWaitQueue.push(pTaskMessage);
    

  1534.                         VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  1535.                         VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);                        
    

  1536.                         TaskMessageList::iterator iterIdCheck;
    

  1537.                         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  1538.                         {
    

  1539.                             if(*iterIdCheck ==pTaskMessage)
    

  1540.                             {
    

  1541.                                 m_VideoRunQueue.erase(iterIdCheck);
    

  1542.                                 break;
    

  1543.                             }
    

  1544.                         }
    

  1545.                     }
    


  1546. 

  1547.                     dwRepeatedTimes++;
    

  1548.                     pTaskMessage->SetRepeatedTimes( dwRepeatedTimes);
    

  1549.                 }
    


  1550. 

  1551.                 break;
    

  1552.             }
    

  1553.         }
    

  1554.         
    

  1555.         if(bFind)
    

  1556.         {
    

  1557.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  1558.         }
    


  1559. 

  1560.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  1561.         //如果有，则将该任务分配给该服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    


  1562. 

  1563.         for(u32 dwTsNo =1; dwTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwTsNo++)
    

  1564.         {
    

  1565.             if(&session ==VideoTs[dwTsNo].GetTsSession()) 
    

  1566.             {
    

  1567.     //            printf("find ts,dwTsNo:%d,m_TransDocWaitQueue.size:%d,m_TransDocWaitQueue.empty():%d\n",dwTsNo,m_TransDocWaitQueue.size(),m_TransDocWaitQueue.empty());
    

  1568.                 if( !m_VideoWaitQueue.empty() )
    

  1569.                 { 
    

  1570.                     AppTaskMessage*  pTaskMessage = m_VideoWaitQueue.top( );
    

  1571.                     m_VideoWaitQueue.pop( );   
    

  1572.                     
    

  1573.                     TaskTimeInfo tTaskTimeInfo ;
    

  1574.                     if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  1575.                     {
    

  1576.                         return;
    

  1577.                     }
    

  1578.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  1579.                     m_VideoRunQueue.push_back(pTaskMessage);
    

  1580.              
    

  1581.                     VideoTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  1582.                     VideoTs[dwTsNo].SetState(TS_RUNNING);
    

  1583.                     pTaskMessage->SetTsNum(dwTsNo);
    


  1584. 

  1585.                     GetVideoInfoRequest* pVideoInfoRequest = new GetVideoInfoRequest;
    

  1586.                     pVideoInfoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  1587.                     pVideoInfoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    


  1588. 

  1589.                     VideoTs[dwTsNo].GetTsSession()->SendMessage(*pVideoInfoRequest);
    

  1590.                     if(NULL !=  pVideoInfoRequest)
    

  1591.                     {
    

  1592.                         delete pVideoInfoRequest;
    

  1593.                         pVideoInfoRequest = NULL;
    

  1594.                     }
    


  1595. 

  1596.     
    

  1597.                 }
    

  1598.                 else
    

  1599.                 {
    

  1600.                     VideoTs[dwTsNo].SetState(TS_FREE);
    

  1601.                     VideoTs[dwTsNo].SetMessageInTs(NULL);                                    
    

  1602.                 } 
    

  1603.                 
    

  1604.                 break;
    

  1605.             }
    

  1606.         
    

  1607.         }         
    

  1608.         
    

  1609.         if(NULL != pResult)
    

  1610.         {
    

  1611.             delete pResult;
    

  1612.             pResult = NULL;
    

  1613.         }
    

  1614.         
    

  1615.     }
    

  1616.     else  //if(TS_MESSAGE_PRINT_SCREEN_PROGRESS_RESULT == tsTaskResultType)
    

  1617.     {
    

  1618.         
    

  1619.     }
    


  1620. 


  1621. 

  1622. }
    


  1623. 

  1624. void DsManage::OnServerLeave(TsSession &session)    //服务器掉线等事件,网络断开与心跳检测失败；
    

  1625. {
    

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

  1627.     static int leavecount = 0;
    

  1628. //    printf("OnServerLeave enter++++++++++++++++,count:%d\n",++leavecount);
    

  1629.     dsLog.Log(TRUE,LOGGER_DEBUG,"OnServerLeave enter,session:%d,count:%d , [%s][%s][%d]\n",&session,++leavecount,__FILE__,__PRETTY_FUNCTION__,__LINE__);        
    

  1630.     bool bFindServer = FALSE;
    

  1631. //检查服务器是否有任务在处理，没有直接返回，约定底层已经close  session了
    

  1632.     for(u32 dwTsNo =1; dwTsNo <MAX_DOC_TRANS_SERVER_NUM; dwTsNo++)
    

  1633.     {
    

  1634.   //      printf("OnServerLeave 1111 dwTsNo:%d++++++++++++++++\n",dwTsNo);
    

  1635.         if(&session ==DocTs[dwTsNo].GetTsSession())
    

  1636.         {
    

  1637.             bFindServer = TRUE;
    

  1638.    //         printf("OnServerLeave 2222 dwTsNo:%d++++++++++++++++\n",dwTsNo);
    

  1639.   //          printf("DocTs[dwTsNo].GetState():%d\n",DocTs[dwTsNo].GetState());
    

  1640.             if(NULL ==  DocTs[dwTsNo].GetMessageInTs())
    

  1641.                 printf(" DocTs[dwTsNo].GetMessageInTs() is NULL\n");
    

  1642.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  1643.             if(/*(TS_RUNNING== DocTs[dwTsNo].GetState()) &&*/(NULL != DocTs[dwTsNo].GetMessageInTs() ))
    

  1644.             {
    

  1645. //                printf("OnServerLeave 3333  dwTsNo:%d++++++++++++++++\n",dwTsNo);
    

  1646.                 //如果有任务处理，查找是否有可用其他同类转换服务器空闲
    

  1647.                 bool bFind = FALSE;
    

  1648.                 //如果有同类转换服务器空闲,直接将该任务分配给该服务器，发送任务消息给相关服务器
    

  1649.                 for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DOC_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1650.                 {
    

  1651. //                    printf("OnServerLeave 4444 dwTsNo:%d, dwFreeTsNo:%d++++++++++++++++\n",dwTsNo,dwFreeTsNo);
    

  1652.                     if((TS_FREE== DocTs[dwFreeTsNo].GetState())&&(dwFreeTsNo != dwTsNo))
    

  1653.                     {
    

  1654.                         DocTs[dwFreeTsNo].SetMessageInTs(DocTs[dwTsNo].GetMessageInTs());
    

  1655.                         DocTs[dwFreeTsNo].SetState(TS_RUNNING);
    

  1656.                         DocTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1657.                         DocTs[dwTsNo].SetMessageInTs(NULL);
    

  1658.                         ((AppTaskMessage*)(DocTs[dwFreeTsNo].GetMessageInTs()))->SetTsNum(dwFreeTsNo);
    


  1659. 

  1660.                         TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  1661.                         pTransitionRequest->SetMessageId(((AppTaskMessage*)(DocTs[dwFreeTsNo].GetMessageInTs()))->GetMessageId());
    

  1662.                         pTransitionRequest->SetSrcFile(((AppTaskMessage*)(DocTs[dwFreeTsNo].GetMessageInTs()))->GetFullPathFileName());
    

  1663.                         pTransitionRequest->SetTargetFolder(((AppTaskMessage*)(DocTs[dwFreeTsNo].GetMessageInTs()))->GetTargetFullPathFileName());
    

  1664.                         pTransitionRequest->SetPrefix(((AppTaskMessage*)(DocTs[dwFreeTsNo].GetMessageInTs()))->GetFilePrefix());
    

  1665.                         pTransitionRequest->SetTransType(((AppTaskMessage*)(DocTs[dwFreeTsNo].GetMessageInTs()))->GetMessagePara().unTransDoc.enumTansType);
    


  1666. 

  1667.                         DocTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  1668.                         if(NULL != pTransitionRequest)
    

  1669.                         {
    

  1670.                             delete pTransitionRequest;
    

  1671.                             pTransitionRequest = NULL;
    

  1672.                         }
    

  1673.                         bFind = TRUE;
    

  1674.                         break;
    

  1675.                     }
    

  1676.                 }
    

  1677.                 
    

  1678.                 //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  1679.                 if(FALSE == bFind)
    

  1680.                 {
    

  1681. //                    printf("OnServerLeave 555 dwTsNo:%d ++++++++++++++++\n",dwTsNo);
    

  1682.                     ((AppTaskMessage*)(DocTs[dwTsNo].GetMessageInTs()))->SetPriority(9);                   
    


  1683. 

  1684.                     m_TransDocWaitQueue.push((AppTaskMessage*)(DocTs[dwTsNo].GetMessageInTs()));
    

  1685.                     TaskMessageList::iterator iterIdCheck;
    

  1686.                     for (iterIdCheck=m_TransDocRunQueue.begin(); iterIdCheck!=m_TransDocRunQueue.end(); iterIdCheck++)
    

  1687.                     {
    

  1688. //                        printf("OnServerLeave 6666 dwTsNo:%d,++++++++++++++++\n",dwTsNo);
    

  1689.                         if(*iterIdCheck ==((AppTaskMessage*)(DocTs[dwTsNo].GetMessageInTs())))
    

  1690.                         {
    

  1691. //                            printf("OnServerLeave 7777 dwTsNo:%d:%d++++++++++++++++\n",dwTsNo);
    

  1692.                             m_TransDocRunQueue.erase(iterIdCheck);
    

  1693.                             break;
    

  1694.                         }
    

  1695.                     }
    


  1696. 

  1697.                     ((AppTaskMessage*)(DocTs[dwTsNo].GetMessageInTs()))->SetTsNum(0);                          
    

  1698.                 }
    

  1699.                 
    

  1700. //                break;
    

  1701.             }
    


  1702. 

  1703.             DocTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1704.             DocTs[dwTsNo].SetMessageInTs(NULL);
    

  1705.             break;
    

  1706.         }
    

  1707.     }           
    


  1708. 

  1709.     if( TRUE == bFindServer)
    

  1710.     {
    

  1711.         return ;
    

  1712.     }
    


  1713. 

  1714.     for(u32 dwTsNo =1; dwTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwTsNo++)
    

  1715.     {
    

  1716. //        printf("OnServerLeave 8888++++++++++++++++\n");
    

  1717.         if(&session ==DocWindowsTs[dwTsNo].GetTsSession())
    

  1718.         {
    

  1719.             bFindServer = TRUE;
    

  1720. //            printf("OnServerLeave 9999++++++++++++++++\n");
    

  1721.  //           printf("DocTs[dwTsNo].GetState():%d\n",PPTTs[dwTsNo].GetState());
    

  1722.             if(NULL ==  DocWindowsTs[dwTsNo].GetMessageInTs())
    

  1723.                 printf(" DocWindowsTs[dwTsNo].GetMessageInTs() is NULL\n");
    

  1724.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  1725.             if((NULL != DocWindowsTs[dwTsNo].GetMessageInTs() ))
    

  1726.             {
    

  1727.  //               printf("OnServerLeave aaaa++++++++++++++++\n");
    

  1728.                 //如果有任务处理，查找是否有可用其他同类转换服务器空闲
    

  1729.                 bool bFind = FALSE;
    

  1730.                 //如果有同类转换服务器空闲,直接将该任务分配给该服务器，发送任务消息给相关服务器
    

  1731.                 for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1732.                 {
    

  1733.  //                   printf("OnServerLeave bbbbb++++++++++++++++\n");
    

  1734.  
    

  1735.                     if((TS_FREE== DocWindowsTs[dwFreeTsNo].GetState())&&(dwFreeTsNo != dwTsNo))  
    

  1736.                     {
    

  1737.                         DocWindowsTs[dwFreeTsNo].SetMessageInTs(DocWindowsTs[dwTsNo].GetMessageInTs());
    

  1738.                         DocWindowsTs[dwFreeTsNo].SetState(TS_RUNNING);
    

  1739.                         DocWindowsTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1740.                         DocWindowsTs[dwTsNo].SetMessageInTs(NULL);
    

  1741.                         ((AppTaskMessage*)(DocWindowsTs[dwFreeTsNo].GetMessageInTs()))->SetTsNum(dwFreeTsNo);
    


  1742. 

  1743.                         TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  1744.                         pTransitionRequest->SetMessageId(((AppTaskMessage*)(DocWindowsTs[dwFreeTsNo].GetMessageInTs()))->GetMessageId());
    

  1745.                         pTransitionRequest->SetSrcFile(((AppTaskMessage*)(DocWindowsTs[dwFreeTsNo].GetMessageInTs()))->GetFullPathFileName());
    

  1746.                         pTransitionRequest->SetTargetFolder(((AppTaskMessage*)(DocWindowsTs[dwFreeTsNo].GetMessageInTs()))->GetTargetFullPathFileName());
    

  1747.                         pTransitionRequest->SetPrefix(((AppTaskMessage*)(DocWindowsTs[dwFreeTsNo].GetMessageInTs()))->GetFilePrefix());
    

  1748.                         pTransitionRequest->SetTransType(((AppTaskMessage*)(DocWindowsTs[dwFreeTsNo].GetMessageInTs()))->GetMessagePara().unTransDoc.enumTansType);
    


  1749. 

  1750.                         DocWindowsTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  1751.                         if(NULL != pTransitionRequest)
    

  1752.                         {
    

  1753.                             delete pTransitionRequest;
    

  1754.                             pTransitionRequest = NULL;
    

  1755.                         }
    

  1756.                         bFind = TRUE;
    

  1757.                         break;
    

  1758.                     }
    

  1759.                 }
    


  1760. 

  1761.                 //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  1762.                 if(FALSE == bFind)
    

  1763.                 {
    

  1764.   //                  printf("OnServerLeave cccc++++++++++++++++\n");
    

  1765.                     ((AppTaskMessage*)(DocWindowsTs[dwTsNo].GetMessageInTs()))->SetPriority(9);
    


  1766. 

  1767.                     m_TransDocWindowsWaitQueue.push((AppTaskMessage*)(DocWindowsTs[dwTsNo].GetMessageInTs()));
    

  1768.                     TaskMessageList::iterator iterIdCheck;
    

  1769.                     for (iterIdCheck=m_TransDocWindowsRunQueue.begin(); iterIdCheck!=m_TransDocWindowsRunQueue.end(); iterIdCheck++)
    

  1770.                     {
    

  1771. //                        printf("OnServerLeave dddd++++++++++++++++\n");
    

  1772.                         if(*iterIdCheck ==((AppTaskMessage*)(DocWindowsTs[dwTsNo].GetMessageInTs())))
    

  1773.                         {
    

  1774.  //                           printf("OnServerLeave eeeee++++++++++++++++\n");
    

  1775.                             m_TransDocWindowsRunQueue.erase(iterIdCheck);
    

  1776.                             break;
    

  1777.                         }
    

  1778.                     }   
    


  1779. 

  1780.                     ((AppTaskMessage*)(DocWindowsTs[dwTsNo].GetMessageInTs()))->SetTsNum(0);                    
    

  1781.                 }
    

  1782.                 
    

  1783. //                break;
    

  1784.             }
    


  1785. 

  1786.             DocWindowsTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1787.             DocWindowsTs[dwTsNo].SetMessageInTs(NULL);
    

  1788.             break;
    

  1789.         }
    

  1790.     }      
    


  1791. 

  1792.     if( TRUE == bFindServer)
    

  1793.     {
    

  1794.         return ;
    

  1795.     }
    


  1796. 

  1797.     for(u32 dwTsNo =1; dwTsNo <MAX_DANAMIC_PPT_TRANS_SERVER_NUM; dwTsNo++)
    

  1798.     {
    

  1799. //        printf("OnServerLeave 8888++++++++++++++++\n");
    

  1800.         if(&session ==PPTTs[dwTsNo].GetTsSession())
    

  1801.         {
    

  1802.             bFindServer = TRUE;
    

  1803. //            printf("OnServerLeave 9999++++++++++++++++\n");
    

  1804.  //           printf("DocTs[dwTsNo].GetState():%d\n",PPTTs[dwTsNo].GetState());
    

  1805.             if(NULL ==  PPTTs[dwTsNo].GetMessageInTs())
    

  1806.                 printf(" PPTTs[dwTsNo].GetMessageInTs() is NULL\n");
    

  1807.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  1808.             if(/*(TS_RUNNING== PPTTs[dwTsNo].GetState()) &&*/(NULL != PPTTs[dwTsNo].GetMessageInTs() ))
    

  1809.             {
    

  1810.  //               printf("OnServerLeave aaaa++++++++++++++++\n");
    

  1811.                 //如果有任务处理，查找是否有可用其他同类转换服务器空闲
    

  1812.                 bool bFind = FALSE;
    

  1813.                 //如果有同类转换服务器空闲,直接将该任务分配给该服务器，发送任务消息给相关服务器
    

  1814.                 for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DANAMIC_PPT_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1815.                 {
    

  1816.  //                   printf("OnServerLeave bbbbb++++++++++++++++\n");
    

  1817.  
    

  1818.                     if((TS_FREE== PPTTs[dwFreeTsNo].GetState())&&(dwFreeTsNo != dwTsNo))  
    

  1819.                     {
    

  1820.                         PPTTs[dwFreeTsNo].SetMessageInTs(PPTTs[dwTsNo].GetMessageInTs());
    

  1821.                         PPTTs[dwFreeTsNo].SetState(TS_RUNNING);
    

  1822.                         PPTTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1823.                         PPTTs[dwTsNo].SetMessageInTs(NULL);
    

  1824.                         ((AppTaskMessage*)(PPTTs[dwFreeTsNo].GetMessageInTs()))->SetTsNum(dwFreeTsNo);
    


  1825. 

  1826.                         TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  1827.                         pTransitionRequest->SetMessageId(((AppTaskMessage*)(PPTTs[dwFreeTsNo].GetMessageInTs()))->GetMessageId());
    

  1828.                         pTransitionRequest->SetSrcFile(((AppTaskMessage*)(PPTTs[dwFreeTsNo].GetMessageInTs()))->GetFullPathFileName());
    

  1829.                         pTransitionRequest->SetTargetFolder(((AppTaskMessage*)(PPTTs[dwFreeTsNo].GetMessageInTs()))->GetTargetFullPathFileName());
    

  1830.                         pTransitionRequest->SetPrefix(((AppTaskMessage*)(PPTTs[dwFreeTsNo].GetMessageInTs()))->GetFilePrefix());
    

  1831.                         pTransitionRequest->SetTransType(((AppTaskMessage*)(PPTTs[dwFreeTsNo].GetMessageInTs()))->GetMessagePara().unTransDoc.enumTansType);
    


  1832. 

  1833.                         PPTTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  1834.                         if(NULL != pTransitionRequest)
    

  1835.                         {
    

  1836.                             delete pTransitionRequest;
    

  1837.                             pTransitionRequest = NULL;
    

  1838.                         }
    

  1839.                         bFind = TRUE;
    

  1840.                         break;
    

  1841.                     }
    

  1842.                 }
    


  1843. 

  1844.                 //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  1845.                 if(FALSE == bFind)
    

  1846.                 {
    

  1847.   //                  printf("OnServerLeave cccc++++++++++++++++\n");
    

  1848.                     ((AppTaskMessage*)(PPTTs[dwTsNo].GetMessageInTs()))->SetPriority(9);
    


  1849. 

  1850.                     m_TransDynamicPptWaitQueue.push((AppTaskMessage*)(PPTTs[dwTsNo].GetMessageInTs()));
    

  1851.                     TaskMessageList::iterator iterIdCheck;
    

  1852.                     for (iterIdCheck=m_TransDynamicPptRunQueue.begin(); iterIdCheck!=m_TransDynamicPptRunQueue.end(); iterIdCheck++)
    

  1853.                     {
    

  1854. //                        printf("OnServerLeave dddd++++++++++++++++\n");
    

  1855.                         if(*iterIdCheck ==((AppTaskMessage*)(PPTTs[dwTsNo].GetMessageInTs())))
    

  1856.                         {
    

  1857.  //                           printf("OnServerLeave eeeee++++++++++++++++\n");
    

  1858.                             m_TransDynamicPptRunQueue.erase(iterIdCheck);
    

  1859.                             break;
    

  1860.                         }
    

  1861.                     }   
    


  1862. 

  1863.                     ((AppTaskMessage*)(PPTTs[dwTsNo].GetMessageInTs()))->SetTsNum(0);                    
    

  1864.                 }
    

  1865.                 
    

  1866. //                break;
    

  1867.             }
    


  1868. 

  1869.             PPTTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1870.             PPTTs[dwTsNo].SetMessageInTs(NULL);
    

  1871.             break;
    

  1872.         }
    

  1873.     }      
    


  1874. 

  1875.     if( TRUE == bFindServer)
    

  1876.     {
    

  1877.         return ;
    

  1878.     }
    


  1879. 

  1880.     for(u32 dwTsNo =1; dwTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwTsNo++)
    

  1881.     {
    

  1882.         if(&session ==VideoTs[dwTsNo].GetTsSession())
    

  1883.         {
    

  1884.             bFindServer = TRUE;
    


  1885. 

  1886.             if(NULL ==  VideoTs[dwTsNo].GetMessageInTs())
    

  1887.                 printf(" VideoTs[dwTsNo].GetMessageInTs() is NULL\n");
    

  1888.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  1889.             if((NULL != VideoTs[dwTsNo].GetMessageInTs() ))
    

  1890.             {
    

  1891.                 //如果有任务处理，查找是否有可用其他同类转换服务器空闲
    

  1892.                 bool bFind = FALSE;
    

  1893.                 //如果有同类转换服务器空闲,直接将该任务分配给该服务器，发送任务消息给相关服务器
    

  1894.                 for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  1895.                 {
    

  1896.                     if((TS_FREE== VideoTs[dwFreeTsNo].GetState())&&(dwFreeTsNo != dwTsNo))
    

  1897.                     {
    

  1898.                         VideoTs[dwFreeTsNo].SetMessageInTs(VideoTs[dwTsNo].GetMessageInTs());
    

  1899.                         VideoTs[dwFreeTsNo].SetState(TS_RUNNING);
    

  1900.                         VideoTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  1901.                         VideoTs[dwTsNo].SetMessageInTs(NULL);
    

  1902.                         ((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()))->SetTsNum(dwFreeTsNo);
    

  1903. #if 0
    

  1904.                         TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  1905.                         pTransitionRequest->SetMessageId(((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()))->GetMessageId());
    

  1906.                         pTransitionRequest->SetSrcFile(((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()))->GetFullPathFileName());
    

  1907.                         pTransitionRequest->SetTargetFolder(((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()))->GetTargetFullPathFileName());
    

  1908.                         pTransitionRequest->SetPrefix(((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()))->GetFilePrefix());
    

  1909.                         pTransitionRequest->SetTransType(((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()))->GetMessagePara().unTransDoc.enumTansType);
    


  1910. 

  1911.                         VideoTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  1912.                         if(NULL != pTransitionRequest)
    

  1913.                         {
    

  1914.                             delete pTransitionRequest;
    

  1915.                             pTransitionRequest = NULL;
    

  1916.                         }
    

  1917. #endif
    

  1918.                         AppTaskMessage* pAppTaskMessage = ((AppTaskMessage*)(VideoTs[dwFreeTsNo].GetMessageInTs()));
    

  1919.                         if(APP_MESSAGE_VIDEO_TRANS_TASK == pAppTaskMessage->GetAppMessageType())
    

  1920.                         {
    

  1921.                             TransVideoRequest* pTransVideoRequest = new TransVideoRequest;
    

  1922.                             pTransVideoRequest->SetMessageId(pAppTaskMessage->GetMessageId());
    

  1923.                             pTransVideoRequest->SetSrcFile(pAppTaskMessage->GetFullPathFileName());
    

  1924.                             pTransVideoRequest->SetTargetFolder(pAppTaskMessage->GetTargetFullPathFileName());
    

  1925.                             
    

  1926.                         
    

  1927.                             char cFormat[100];
    

  1928.                             sprintf(cFormat, "%d", pAppTaskMessage->GetMessagePara().unTransVideo.dwFormat);
    

  1929.                             pTransVideoRequest->SetFormat(cFormat);
    

  1930.                         
    

  1931.                             char cBitRate[100];
    

  1932.                             sprintf(cBitRate, "%d", pAppTaskMessage->GetMessagePara().unTransVideo.dwBitrate);
    

  1933.                             pTransVideoRequest->SetBitRate(cBitRate);
    

  1934.                         
    

  1935.                             char cWidth[100];
    

  1936.                             char cHeight[100];
    

  1937.                             string strWidth,strHeight,strResolution;
    

  1938.                             sprintf(cWidth, "%d", pAppTaskMessage->GetMessagePara().unTransVideo.dwResolutionWidth);
    

  1939.                             sprintf(cHeight, "%d", pAppTaskMessage->GetMessagePara().unTransVideo.dwResolutionHeight);
    

  1940.                             strWidth = cWidth;
    

  1941.                             strHeight = cHeight;
    

  1942.                             strResolution = strWidth +"*"+strHeight;
    

  1943.                             pTransVideoRequest->SetResolution(strResolution);
    

  1944.                         
    

  1945.                             VideoTs[dwTsNo].GetTsSession()->SendMessage(*pTransVideoRequest);
    

  1946.                             if(NULL != pTransVideoRequest)
    

  1947.                             {
    

  1948.                                 delete pTransVideoRequest;
    

  1949.                                 pTransVideoRequest = NULL;
    

  1950.                             }
    

  1951.                             break;
    

  1952.                         }
    

  1953.                         else if(APP_MESSAGE_VIDEO_CAPTURE_TASK == pAppTaskMessage->GetAppMessageType())
    

  1954.                         {
    

  1955.                             CapVideoRequest* pCapVideoRequest = new CapVideoRequest;
    

  1956.                             pCapVideoRequest->SetMessageId(pAppTaskMessage->GetMessageId());
    

  1957.                             pCapVideoRequest->SetSrcFile(pAppTaskMessage->GetFullPathFileName());
    

  1958.                             pCapVideoRequest->SetTargetFolder(pAppTaskMessage->GetTargetFullPathFileName());
    

  1959.                             pCapVideoRequest->SetPrefix(pAppTaskMessage->GetFilePrefix());
    

  1960.                         
    

  1961.                             char cStart[100];
    

  1962.                             sprintf(cStart, "%d", pAppTaskMessage->GetMessagePara().unCapVideo.dwStartTIme);
    

  1963.                             pCapVideoRequest->SetStart(cStart);
    

  1964.                         
    

  1965.                             char cCount[100];
    

  1966.                             sprintf(cCount, "%d", pAppTaskMessage->GetMessagePara().unCapVideo.dwPhotoCount);
    

  1967.                             pCapVideoRequest->SetCount(cCount);
    

  1968.                         
    

  1969.                         
    

  1970.                             char cInterval[100];
    

  1971.                             sprintf(cInterval, "%d", pAppTaskMessage->GetMessagePara().unCapVideo.dwSustainedTime);
    

  1972.                             pCapVideoRequest->SetInterval(cInterval);
    

  1973.                             
    

  1974.                             VideoTs[dwTsNo].GetTsSession()->SendMessage(*pCapVideoRequest);
    

  1975.                             if(NULL !=  pCapVideoRequest)
    

  1976.                             {
    

  1977.                                 delete pCapVideoRequest;
    

  1978.                                 pCapVideoRequest = NULL;
    

  1979.                             }
    

  1980.                         }
    

  1981.                         else //if(APP_MESSAGE_VIDEO_INFO_TASK == tAppMessageType)
    

  1982.                         {
    

  1983.                             GetVideoInfoRequest* pVideoInfoRequest = new GetVideoInfoRequest;
    

  1984.                             pVideoInfoRequest->SetMessageId(pAppTaskMessage->GetMessageId());
    

  1985.                             pVideoInfoRequest->SetSrcFile(pAppTaskMessage->GetFullPathFileName());
    

  1986.                             
    

  1987.                             VideoTs[dwTsNo].GetTsSession()->SendMessage(*pVideoInfoRequest);
    

  1988.                             if(NULL !=  pVideoInfoRequest)
    

  1989.                             {
    

  1990.                                 delete pVideoInfoRequest;
    

  1991.                                 pVideoInfoRequest = NULL;
    

  1992.                             }
    

  1993.                         }
    


  1994. 

  1995.                         
    

  1996.                         bFind = TRUE;
    

  1997.                         break;
    

  1998.                     }
    

  1999.                 }
    

  2000.                 
    

  2001.                 //如果没有转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列，并从运行队列删除
    

  2002.                 if(FALSE == bFind)
    

  2003.                 {
    

  2004. //                    printf("OnServerLeave 555 dwTsNo:%d ++++++++++++++++\n",dwTsNo);
    

  2005.                     ((AppTaskMessage*)(VideoTs[dwTsNo].GetMessageInTs()))->SetPriority(9);                   
    


  2006. 

  2007.                     m_VideoWaitQueue.push((AppTaskMessage*)(VideoTs[dwTsNo].GetMessageInTs()));
    

  2008.                     TaskMessageList::iterator iterIdCheck;
    

  2009.                     for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  2010.                     {
    

  2011. //                        printf("OnServerLeave 6666 dwTsNo:%d,++++++++++++++++\n",dwTsNo);
    

  2012.                         if(*iterIdCheck ==((AppTaskMessage*)(VideoTs[dwTsNo].GetMessageInTs())))
    

  2013.                         {
    

  2014.                             m_VideoRunQueue.erase(iterIdCheck);
    

  2015.                             break;
    

  2016.                         }
    

  2017.                     }
    


  2018. 

  2019.                     ((AppTaskMessage*)(VideoTs[dwTsNo].GetMessageInTs()))->SetTsNum(0);                          
    

  2020.                 }
    

  2021.                 
    

  2022. //                break;
    

  2023.             }
    


  2024. 

  2025.             VideoTs[dwTsNo].SetState(TS_UNREGISTERED);
    

  2026.             VideoTs[dwTsNo].SetMessageInTs(NULL);
    

  2027.             break;
    

  2028.         }
    

  2029.     }        
    

  2030. }
    


  2031. 

  2032. void DsManage::OnSessionError(TsSession &session)   //协议解析失败等，一般仅仅需要关闭session    
    

  2033. {
    

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

  2035.     dsLog.Log(TRUE,LOGGER_DEBUG,"OnSessionError enter,session:%d , [%s][%s][%d]\n",&session,__FILE__,__PRETTY_FUNCTION__,__LINE__);        
    


  2036. 

  2037. //    printf("OnSessionError enter++++++++++++++++\n");
    

  2038.     OnServerLeave(session);
    

  2039.     //关闭本session
    

  2040.    session.Close();
    

  2041. }
    


  2042. 

  2043. void DsManage::OnNewTask(AppTaskMessage &taskInfo) 
    

  2044. {
    

  2045.     string strMessageId = taskInfo.GetMessageId();
    

  2046.     //首先检查该任务是否已在运行列表或者等待列表，如果已存在，给应用客户端返回错误码，并返回
    

  2047.     bool bFind = FALSE;  
    

  2048.     bool bFree = FALSE;
    

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

  2050. //    g_Dslogger = Logger::getLogger("DsManage::OnNewTask");
    

  2051.     static int count =0;
    

  2052.     count ++;
    

  2053.     dsLog.Log(TRUE,LOGGER_DEBUG,"OnNewTask,count:%d , [%s][%s][%d]\n",count,__FILE__,__PRETTY_FUNCTION__,__LINE__);       
    


  2054. 


  2055. 

  2056.  //   printf("OnNewTask,count:%d\n",count);
    

  2057.     AppMessageType tAppMessageType = taskInfo.GetAppMessageType();
    

  2058.     if(APP_MESSAGE_DOC_TRANS_TASK == tAppMessageType)
    

  2059.     {
    

  2060.         TaskMessageList::const_iterator iterIdCheck;
    

  2061.         for (iterIdCheck=m_TransDocRunQueue.begin(); iterIdCheck!=m_TransDocRunQueue.end(); iterIdCheck++)
    

  2062.         {
    

  2063.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2064.             if(pTaskMessage->GetMessageId() == strMessageId)
    

  2065.             {
    

  2066.                 bFind = TRUE;
    

  2067.                 break;
    

  2068.             }
    

  2069.         }
    


  2070. 

  2071.         if(FALSE == bFind)
    

  2072.         {
    

  2073.             AppTaskMessage* pTaskMessage;
    

  2074.             TaskMessagePriorityQueue tmpQueue;
    

  2075.             while ( !m_TransDocWaitQueue.empty() )
    

  2076.             {
    

  2077.                 pTaskMessage = m_TransDocWaitQueue.top( );
    

  2078.                 m_TransDocWaitQueue.pop( );
    

  2079.                 if(pTaskMessage->GetMessageId() == strMessageId)
    

  2080.                 {
    

  2081.                     bFind = TRUE;
    

  2082.                 }
    


  2083. 

  2084.                 tmpQueue.push( pTaskMessage );
    

  2085.             }
    

  2086.             while ( !tmpQueue.empty() )
    

  2087.             {
    

  2088.                 pTaskMessage = tmpQueue.top( );
    

  2089.                 tmpQueue.pop( );
    

  2090.                 m_TransDocWaitQueue.push(pTaskMessage );
    

  2091.             }
    

  2092.             
    

  2093.         }
    


  2094. 

  2095.         //检查是否在windows文档转换列表中
    

  2096.         for (iterIdCheck=m_TransDocWindowsRunQueue.begin(); iterIdCheck!=m_TransDocWindowsRunQueue.end(); iterIdCheck++)
    

  2097.         {
    

  2098.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2099.             if(pTaskMessage->GetMessageId() == strMessageId)
    

  2100.             {
    

  2101.                 bFind = TRUE;
    

  2102.                 break;
    

  2103.             }
    

  2104.         }
    


  2105. 

  2106.         if(FALSE == bFind)
    

  2107.         {
    

  2108.             AppTaskMessage* pTaskMessage;
    

  2109.             TaskMessagePriorityQueue tmpQueue;
    

  2110.             while ( !m_TransDocWindowsWaitQueue.empty() )
    

  2111.             {
    

  2112.                 pTaskMessage = m_TransDocWindowsWaitQueue.top( );
    

  2113.                 m_TransDocWindowsWaitQueue.pop( );
    

  2114.                 if(pTaskMessage->GetMessageId() == strMessageId)
    

  2115.                 {
    

  2116.                     bFind = TRUE;
    

  2117.                 }
    


  2118. 

  2119.                 tmpQueue.push( pTaskMessage );
    

  2120.             }
    

  2121.             while ( !tmpQueue.empty() )
    

  2122.             {
    

  2123.                 pTaskMessage = tmpQueue.top( );
    

  2124.                 tmpQueue.pop( );
    

  2125.                 m_TransDocWindowsWaitQueue.push(pTaskMessage );
    

  2126.             }
    

  2127.             
    

  2128.         }        
    


  2129. 

  2130.         if(TRUE == bFind)
    

  2131.         {
    

  2132.             //发送错误信息给应用客户端
    

  2133.             AppDocTransResultMessage* pResult = new AppDocTransResultMessage;
    

  2134.             pResult->SetMessageId(taskInfo.GetMessageId());
    

  2135.             pResult->SetResult(FALSE);
    

  2136.             pResult->SetErrorCode(RET_E_REPEATED_TS_TRANS_TASK);
    

  2137.             pResult->SetAppTargetIp(taskInfo.GetIpAddr());
    

  2138.             pResult->SetAppTargetPort(taskInfo.GetPort());
    

  2139.   
    

  2140.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  2141.             dsLog.Log(TRUE,LOGGER_ERROR,"error message from application client. Repeated Message ID:%s , [%s][%s][%d]\n",taskInfo.GetMessageId().c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);   
    

  2142. //            LOG4CXX_ERROR(g_Dslogger, "error message from application client. Repeated Message ID: ");
    

  2143. //            LOG4CXX_ERROR(g_Dslogger, taskInfo.GetMessageId());
    

  2144.             if(NULL != pResult )
    

  2145.             {
    

  2146.               delete pResult;
    

  2147.                           pResult = NULL;
    


  2148. 

  2149.                         }
    

  2150.             return;
    

  2151.         }
    

  2152.         
    

  2153.         //分发服务器创建一个消息任务的拷贝，避免下层上报的消息在函数返回后被销毁
    

  2154. //        printf("000  target:%s,prefix:%s,type:%d\n",taskInfo.GetTargetFullPathFileName().c_str(),taskInfo.GetFilePrefix().c_str(),taskInfo.GetMessagePara().unTransDoc.enumTansType);        
    

  2155.         AppTaskMessage* pNewAppTaskMessage;
    

  2156.         MessageNew(&pNewAppTaskMessage);
    

  2157.         memcpy(pNewAppTaskMessage,&taskInfo,sizeof(AppTaskMessage));
    

  2158. //                printf("111  target:%s,prefix:%s,type:%d\n",pNewAppTaskMessage->GetTargetFullPathFileName().c_str(),pNewAppTaskMessage->GetFilePrefix().c_str(),pNewAppTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  2159.         //再检查是否有空闲的转换服务器?
    

  2160.         for(u32 dwTsNo =1; dwTsNo <MAX_DOC_TRANS_SERVER_NUM; dwTsNo++)
    

  2161.         {
    

  2162.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  2163.             if(TS_FREE == DocTs[dwTsNo].GetState())
    

  2164.             {            
    

  2165.             
    

  2166.                 TaskTimeInfo tTaskTimeInfo ;
    

  2167.                 if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  2168.                 {
    

  2169.                     return;
    

  2170.                 }
    

  2171.                 pNewAppTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  2172.                 m_TransDocRunQueue.push_back(pNewAppTaskMessage);
    

  2173.                 bFree = TRUE;
    

  2174.                 DocTs[dwTsNo].SetMessageInTs(pNewAppTaskMessage);
    

  2175.                 DocTs[dwTsNo].SetState(TS_RUNNING);
    

  2176.                 pNewAppTaskMessage->SetTsNum(dwTsNo);
    


  2177. 

  2178.                 TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  2179.                 pTransitionRequest->SetMessageId(pNewAppTaskMessage->GetMessageId());
    

  2180.                 pTransitionRequest->SetSrcFile(pNewAppTaskMessage->GetFullPathFileName());
    

  2181.                 pTransitionRequest->SetTargetFolder(pNewAppTaskMessage->GetTargetFullPathFileName());
    

  2182.                 pTransitionRequest->SetPrefix(pNewAppTaskMessage->GetFilePrefix());
    

  2183.                 pTransitionRequest->SetTransType(pNewAppTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  2184. 

  2185. //                printf("222  target:%s,prefix:%s\n",pTransitionRequest->GetTargetFolder().c_str(),pTransitionRequest->GetPrefix().c_str());
    

  2186.                 DocTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  2187.                 if(NULL != pTransitionRequest)
    

  2188.                 {
    

  2189.                     delete pTransitionRequest;
    

  2190.                     pTransitionRequest = NULL;
    

  2191.                 }
    

  2192.                 break;
    

  2193.             }
    

  2194.         }
    

  2195.         
    

  2196.         //如果没有空闲的转换服务器，将该任务加入等待列表
    

  2197.         if(FALSE == bFree)
    

  2198.         {   
    

  2199.             m_TransDocWaitQueue.push(pNewAppTaskMessage);
    

  2200. //            AppTaskMessage* p=m_TransDocWaitQueue.top();
    

  2201. //            printf("333  target:%s,prefix:%s,type:%d\n",p->GetTargetFullPathFileName().c_str(),p->GetFilePrefix().c_str(),p->GetMessagePara().unTransDoc.enumTansType);        
    

  2202.             printf("m_TransDocWaitQueue.size:%d\n",m_TransDocWaitQueue.size());
    

  2203.         }
    

  2204.     }
    

  2205.     else if((APP_MESSAGE_VIDEO_TRANS_TASK == tAppMessageType)||(APP_MESSAGE_VIDEO_CAPTURE_TASK == tAppMessageType)||(APP_MESSAGE_VIDEO_INFO_TASK == tAppMessageType))
    

  2206.     {
    

  2207.         TaskMessageList::const_iterator iterIdCheck;
    

  2208.         for (iterIdCheck=m_VideoRunQueue.begin(); iterIdCheck!=m_VideoRunQueue.end(); iterIdCheck++)
    

  2209.         {
    

  2210.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2211.             if(pTaskMessage->GetMessageId() == strMessageId)
    

  2212.             {
    

  2213.                 bFind = TRUE;
    

  2214.                 break;
    

  2215.             }
    

  2216.         }
    


  2217. 

  2218.         if(FALSE == bFind)
    

  2219.         {
    

  2220.             AppTaskMessage* pTaskMessage;
    

  2221.             TaskMessagePriorityQueue tmpQueue;
    

  2222.             while ( !m_VideoWaitQueue.empty() )
    

  2223.             {
    

  2224.                 pTaskMessage = m_VideoWaitQueue.top( );
    

  2225.                 m_VideoWaitQueue.pop( );
    

  2226.                 if(pTaskMessage->GetMessageId() == strMessageId)
    

  2227.                 {
    

  2228.                     bFind = TRUE;
    

  2229.                 }
    


  2230. 

  2231.                 tmpQueue.push( pTaskMessage );
    

  2232.             }
    

  2233.             while ( !tmpQueue.empty() )
    

  2234.             {
    

  2235.                 pTaskMessage = tmpQueue.top( );
    

  2236.                 tmpQueue.pop( );
    

  2237.                 m_VideoWaitQueue.push(pTaskMessage );
    

  2238.             }
    

  2239.             
    

  2240.         }
    


  2241. 

  2242.         if(TRUE == bFind)
    

  2243.         {
    

  2244.             //发送错误信息给应用客户端
    

  2245.             if(APP_MESSAGE_VIDEO_TRANS_TASK == tAppMessageType)
    

  2246.             {
    

  2247.                 AppVideoTransResultMessage* pResult = new AppVideoTransResultMessage;
    

  2248.                 pResult->SetMessageId(taskInfo.GetMessageId());
    

  2249.                 pResult->SetResult(FALSE);
    

  2250.                 pResult->SetErrorCode(RET_E_REPEATED_TS_TRANS_TASK);
    

  2251.                 pResult->SetAppTargetIp(taskInfo.GetIpAddr());
    

  2252.                 pResult->SetAppTargetPort(taskInfo.GetPort());
    

  2253.       
    

  2254.                 (SessionManager::GetInstance()).SendAppMessage(*pResult);
    


  2255. 

  2256.                                 if(NULL != pResult)
    

  2257.                                 {
    

  2258.                                    delete pResult;
    

  2259.                                    pResult = NULL;
    


  2260. 


  2261. 

  2262.                                 }
    


  2263. 

  2264.   
    

  2265.                                 
    

  2266.             }
    

  2267.             else if(APP_MESSAGE_VIDEO_CAPTURE_TASK == tAppMessageType)
    

  2268.             {
    

  2269.                 AppVideoCaptureResultMessage* pResult = new AppVideoCaptureResultMessage;
    

  2270.                 pResult->SetMessageId(taskInfo.GetMessageId());
    

  2271.                 pResult->SetResult(FALSE);
    

  2272.                 pResult->SetErrorCode(RET_E_REPEATED_TS_TRANS_TASK);
    

  2273.                 pResult->SetAppTargetIp(taskInfo.GetIpAddr());
    

  2274.                 pResult->SetAppTargetPort(taskInfo.GetPort());
    

  2275.       
    

  2276.                 (SessionManager::GetInstance()).SendAppMessage(*pResult);
    


  2277. 

  2278.                                 if(NULL != pResult)
    

  2279.                                 {
    

  2280.                                    delete pResult;
    

  2281.                                    pResult = NULL;
    

  2282.                                 }
    

  2283.             }
    

  2284.             else //if(APP_MESSAGE_VIDEO_INFO_TASK == tAppMessageType)
    

  2285.             {
    

  2286.                 AppVideoInfoResultMessage* pResult = new AppVideoInfoResultMessage;
    

  2287.                 pResult->SetMessageId(taskInfo.GetMessageId());
    

  2288.                 pResult->SetResult(FALSE);
    

  2289.                 pResult->SetErrorCode(RET_E_REPEATED_TS_TRANS_TASK);
    

  2290.                 pResult->SetAppTargetIp(taskInfo.GetIpAddr());
    

  2291.                 pResult->SetAppTargetPort(taskInfo.GetPort());
    

  2292.       
    

  2293.                 (SessionManager::GetInstance()).SendAppMessage(*pResult);
    


  2294. 

  2295.                                 if(NULL != pResult)
    

  2296.                                 {
    

  2297.                                    delete pResult;
    

  2298.                                    pResult = NULL;
    

  2299.                                 }
    

  2300.             }
    

  2301.             dsLog.Log(TRUE,LOGGER_ERROR,"error message from application client. Repeated Message ID:%s , [%s][%s][%d]\n",taskInfo.GetMessageId().c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);   
    

  2302.             return;
    

  2303.         }
    

  2304.         
    

  2305.         //分发服务器创建一个消息任务的拷贝，避免下层上报的消息在函数返回后被销毁
    

  2306. //        printf("000  target:%s,prefix:%s,type:%d\n",taskInfo.GetTargetFullPathFileName().c_str(),taskInfo.GetFilePrefix().c_str(),taskInfo.GetMessagePara().unTransDoc.enumTansType);        
    

  2307.         AppTaskMessage* pNewAppTaskMessage;
    

  2308.         MessageNew(&pNewAppTaskMessage);
    

  2309.         memcpy(pNewAppTaskMessage,&taskInfo,sizeof(AppTaskMessage));
    

  2310. //                printf("111  target:%s,prefix:%s,type:%d\n",pNewAppTaskMessage->GetTargetFullPathFileName().c_str(),pNewAppTaskMessage->GetFilePrefix().c_str(),pNewAppTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  2311.         //再检查是否有空闲的转换服务器?
    

  2312.         for(u32 dwTsNo =1; dwTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwTsNo++)
    

  2313.         {
    

  2314.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  2315.             if(TS_FREE == VideoTs[dwTsNo].GetState())
    

  2316.             {       
    

  2317.                 TaskTimeInfo tTaskTimeInfo ;
    

  2318.                 if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  2319.                 {
    

  2320.                     return;
    

  2321.                 }
    

  2322.                 pNewAppTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);            
    

  2323.                 m_VideoRunQueue.push_back(pNewAppTaskMessage);
    

  2324.                 bFree = TRUE;
    

  2325.                 VideoTs[dwTsNo].SetMessageInTs(pNewAppTaskMessage);
    

  2326.                 VideoTs[dwTsNo].SetState(TS_RUNNING);
    

  2327.                 pNewAppTaskMessage->SetTsNum(dwTsNo);
    


  2328. 

  2329.                 if(APP_MESSAGE_VIDEO_TRANS_TASK == tAppMessageType)
    

  2330.                 {
    

  2331.                     TransVideoRequest* pTransVideoRequest = new TransVideoRequest;
    

  2332.                     pTransVideoRequest->SetMessageId(pNewAppTaskMessage->GetMessageId());
    

  2333.                     pTransVideoRequest->SetSrcFile(pNewAppTaskMessage->GetFullPathFileName());
    

  2334.                     pTransVideoRequest->SetTargetFolder(pNewAppTaskMessage->GetTargetFullPathFileName());
    

  2335.                     
    


  2336. 

  2337.                     char cFormat[100];
    

  2338.                     sprintf(cFormat, "%d", pNewAppTaskMessage->GetMessagePara().unTransVideo.dwFormat);
    

  2339.                     pTransVideoRequest->SetFormat(cFormat);
    


  2340. 

  2341.                     char cBitRate[100];
    

  2342.                     sprintf(cBitRate, "%d", pNewAppTaskMessage->GetMessagePara().unTransVideo.dwBitrate);
    

  2343.                     pTransVideoRequest->SetBitRate(cBitRate);
    


  2344. 

  2345.                     char cWidth[100];
    

  2346.                     char cHeight[100];
    

  2347.                     string strWidth,strHeight,strResolution;
    

  2348.                     sprintf(cWidth, "%d", pNewAppTaskMessage->GetMessagePara().unTransVideo.dwResolutionWidth);
    

  2349.                     sprintf(cHeight, "%d", pNewAppTaskMessage->GetMessagePara().unTransVideo.dwResolutionHeight);
    

  2350.                     strWidth = cWidth;
    

  2351.                     strHeight = cHeight;
    

  2352.                     strResolution = strWidth +"*"+strHeight;
    

  2353.                     pTransVideoRequest->SetResolution(strResolution);
    


  2354. 

  2355.                     VideoTs[dwTsNo].GetTsSession()->SendMessage(*pTransVideoRequest);
    

  2356.                     if(NULL != pTransVideoRequest)
    

  2357.                     {
    

  2358.                         delete pTransVideoRequest;
    

  2359.                         pTransVideoRequest = NULL;
    

  2360.                     }
    

  2361.                     break;
    

  2362.                 }
    

  2363.                 else if(APP_MESSAGE_VIDEO_CAPTURE_TASK == tAppMessageType)
    

  2364.                 {
    

  2365.                     CapVideoRequest* pCapVideoRequest = new CapVideoRequest;
    

  2366.                     pCapVideoRequest->SetMessageId(pNewAppTaskMessage->GetMessageId());
    

  2367.                     pCapVideoRequest->SetSrcFile(pNewAppTaskMessage->GetFullPathFileName());
    

  2368.                     pCapVideoRequest->SetTargetFolder(pNewAppTaskMessage->GetTargetFullPathFileName());
    

  2369.                     pCapVideoRequest->SetPrefix(pNewAppTaskMessage->GetFilePrefix());
    


  2370. 

  2371.                     char cStart[100];
    

  2372.                     sprintf(cStart, "%d", pNewAppTaskMessage->GetMessagePara().unCapVideo.dwStartTIme);
    

  2373.                     pCapVideoRequest->SetStart(cStart);
    


  2374. 

  2375.                     char cCount[100];
    

  2376.                     sprintf(cCount, "%d", pNewAppTaskMessage->GetMessagePara().unCapVideo.dwPhotoCount);
    

  2377.                     pCapVideoRequest->SetCount(cCount);
    


  2378. 


  2379. 

  2380.                     char cInterval[100];
    

  2381.                     sprintf(cInterval, "%d", pNewAppTaskMessage->GetMessagePara().unCapVideo.dwSustainedTime);
    

  2382.                     pCapVideoRequest->SetInterval(cInterval);
    

  2383.                     
    

  2384.                     VideoTs[dwTsNo].GetTsSession()->SendMessage(*pCapVideoRequest);
    

  2385.                     if(NULL !=  pCapVideoRequest)
    

  2386.                     {
    

  2387.                         delete pCapVideoRequest;
    

  2388.                         pCapVideoRequest = NULL;
    

  2389.                     }
    

  2390.                     break;
    

  2391.                 }
    

  2392.                 else //if(APP_MESSAGE_VIDEO_INFO_TASK == tAppMessageType)
    

  2393.                 {
    

  2394.                     GetVideoInfoRequest* pVideoInfoRequest = new GetVideoInfoRequest;
    

  2395.                     pVideoInfoRequest->SetMessageId(pNewAppTaskMessage->GetMessageId());
    

  2396.                     pVideoInfoRequest->SetSrcFile(pNewAppTaskMessage->GetFullPathFileName());
    

  2397.                     
    

  2398.                     VideoTs[dwTsNo].GetTsSession()->SendMessage(*pVideoInfoRequest);
    

  2399.                     if(NULL !=  pVideoInfoRequest)
    

  2400.                     {
    

  2401.                         delete pVideoInfoRequest;
    

  2402.                         pVideoInfoRequest = NULL;
    

  2403.                     }
    

  2404.                     break;
    

  2405.                 }
    

  2406.             }
    

  2407.         }
    

  2408.         
    

  2409.         //如果没有空闲的转换服务器，将该任务加入等待列表
    

  2410.         if(FALSE == bFree)
    

  2411.         {   
    

  2412.             m_VideoWaitQueue.push(pNewAppTaskMessage);
    

  2413. //            AppTaskMessage* p=m_TransDocWaitQueue.top();
    

  2414. //            printf("333  target:%s,prefix:%s,type:%d\n",p->GetTargetFullPathFileName().c_str(),p->GetFilePrefix().c_str(),p->GetMessagePara().unTransDoc.enumTansType);        
    

  2415.             printf("m_VideoWaitQueue.size:%d\n",m_VideoWaitQueue.size());
    

  2416.         }
    

  2417.     }    
    

  2418.     else if(APP_MESSAGE_DYNAMIC_PPT_TRANS_TASK == tAppMessageType)
    

  2419.     {
    

  2420.         TaskMessageList::const_iterator iterIdCheck;
    

  2421.         for (iterIdCheck=m_TransDynamicPptRunQueue.begin(); iterIdCheck!=m_TransDynamicPptRunQueue.end(); iterIdCheck++)
    

  2422.         {
    

  2423.             AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2424.             if(pTaskMessage->GetMessageId() == strMessageId)
    

  2425.             {
    

  2426.                 bFind = TRUE;
    

  2427.                 break;
    

  2428.             }
    

  2429.         }
    


  2430. 

  2431.         if(FALSE == bFind)
    

  2432.         {
    

  2433.             AppTaskMessage* pTaskMessage;
    

  2434.             TaskMessagePriorityQueue tmpQueue;
    

  2435.             while ( !m_TransDynamicPptWaitQueue.empty() )
    

  2436.             {
    

  2437.                 pTaskMessage = m_TransDynamicPptWaitQueue.top( );
    

  2438.                 m_TransDynamicPptWaitQueue.pop( );
    

  2439.                 if(pTaskMessage->GetMessageId() == strMessageId)
    

  2440.                 {
    

  2441.                     bFind = TRUE;
    

  2442.                 }
    


  2443. 

  2444.                 tmpQueue.push( pTaskMessage );
    

  2445.             }
    

  2446.             while ( !tmpQueue.empty() )
    

  2447.             {
    

  2448.                 pTaskMessage = tmpQueue.top( );
    

  2449.                 tmpQueue.pop( );
    

  2450.                 m_TransDynamicPptWaitQueue.push(pTaskMessage );
    

  2451.             }
    

  2452.             
    

  2453.         }
    


  2454. 

  2455.         if(TRUE == bFind)
    

  2456.         {
    

  2457.             //发送错误信息给应用客户端
    

  2458.             //后面跟应用定了协议之后需要创建新的动态PPT的类        
    

  2459.             AppDynamicPptTransResultMessage*  pResult = new AppDynamicPptTransResultMessage; 
    


  2460. 

  2461.             pResult->SetMessageId(taskInfo.GetMessageId());
    

  2462.             pResult->SetResult(FALSE);
    

  2463.             pResult->SetErrorCode(RET_E_REPEATED_TS_TRANS_TASK);
    

  2464.             pResult->SetAppTargetIp(taskInfo.GetIpAddr());
    

  2465.             pResult->SetAppTargetPort(taskInfo.GetPort());
    

  2466.   
    

  2467.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  2468.             dsLog.Log(TRUE,LOGGER_ERROR,"error message from application client. Repeated Message ID:%s , [%s][%s][%d]\n",taskInfo.GetMessageId().c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);               
    

  2469. //            LOG4CXX_ERROR(g_Dslogger, "error message from application client. Repeated Message ID: ");
    

  2470. //            LOG4CXX_ERROR(g_Dslogger, taskInfo.GetMessageId());
    


  2471. 

  2472.             
    

  2473.                                 if(NULL != pResult)
    

  2474.                                 {
    

  2475.                                    delete pResult;
    

  2476.                                    pResult = NULL;
    

  2477.                                 }
    

  2478.              return;
    

  2479.         }
    


  2480. 

  2481.         //分发服务器创建一个消息任务的拷贝，避免下层上报的消息在函数返回后被销毁
    

  2482.   //      printf("aaaa  target:%s,prefix:%s,type:%d\n",taskInfo.GetTargetFullPathFileName().c_str(),taskInfo.GetFilePrefix().c_str(),taskInfo.GetMessagePara().unTransDoc.enumTansType);        
    

  2483.         AppTaskMessage* pNewAppTaskMessage;
    

  2484.         MessageNew(&pNewAppTaskMessage);
    

  2485.         memcpy(pNewAppTaskMessage,&taskInfo,sizeof(AppTaskMessage));
    

  2486. //                printf("bbb  target:%s,prefix:%s,type:%d\n",pNewAppTaskMessage->GetTargetFullPathFileName().c_str(),pNewAppTaskMessage->GetFilePrefix().c_str(),pNewAppTaskMessage->GetMessagePara().unTransDoc.enumTansType);        
    

  2487.         //再检查是否有空闲的转换服务器?       
    

  2488.         for(u32 dwTsNo =1; dwTsNo <MAX_DANAMIC_PPT_TRANS_SERVER_NUM; dwTsNo++)
    

  2489.         {
    

  2490.      //       printf("PPTTs[dwTsNo].GetState():%d,dwTsNo:%d\n",PPTTs[dwTsNo].GetState(),dwTsNo);
    

  2491.             //如果有空闲的转换服务器，将该任务提交到转换服务器，发送消息给转换服务器，并将它加入运行列表
    

  2492.             if(TS_FREE == PPTTs[dwTsNo].GetState())
    

  2493.             {
    

  2494.         //        printf("find free ppt server dwtsno:%d\n",dwTsNo);
    

  2495.                 TaskTimeInfo tTaskTimeInfo ;
    

  2496.                 if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  2497.                 {
    

  2498.                     return;
    

  2499.                 }
    

  2500.                 pNewAppTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);         
    

  2501.                 m_TransDynamicPptRunQueue.push_back(pNewAppTaskMessage);
    

  2502.                 bFree = TRUE;
    

  2503.                 PPTTs[dwTsNo].SetMessageInTs(pNewAppTaskMessage);
    

  2504.                 PPTTs[dwTsNo].SetState(TS_RUNNING);
    

  2505.                 pNewAppTaskMessage->SetTsNum(dwTsNo);
    


  2506. 

  2507.                 TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  2508.                 pTransitionRequest->SetMessageId(pNewAppTaskMessage->GetMessageId());
    

  2509.                 pTransitionRequest->SetSrcFile(pNewAppTaskMessage->GetFullPathFileName());
    

  2510.                 pTransitionRequest->SetTargetFolder(pNewAppTaskMessage->GetTargetFullPathFileName());
    

  2511.                 pTransitionRequest->SetPrefix(pNewAppTaskMessage->GetFilePrefix());
    

  2512.                 pTransitionRequest->SetTransType(pNewAppTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  2513. 

  2514.  //               printf("ccc  target:%s,prefix:%s\n",pTransitionRequest->GetTargetFolder().c_str(),pTransitionRequest->GetPrefix().c_str());
    

  2515.                 PPTTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  2516.                 if(NULL != pTransitionRequest)
    

  2517.                 {
    

  2518.                     delete pTransitionRequest;
    

  2519.                     pTransitionRequest = NULL;
    

  2520.                 }
    

  2521.                 break;
    

  2522.             }
    

  2523.         }
    


  2524. 

  2525.         //如果没有空闲的转换服务器，将该任务加入等待列表
    

  2526.         if(FALSE == bFree)
    

  2527.         {   
    

  2528.             m_TransDynamicPptWaitQueue.push(pNewAppTaskMessage);
    

  2529.             AppTaskMessage* p=m_TransDynamicPptWaitQueue.top();
    

  2530.  //           printf("dddd  target:%s,prefix:%s,type:%d\n",p->GetTargetFullPathFileName().c_str(),p->GetFilePrefix().c_str(),p->GetMessagePara().unTransDoc.enumTansType);        
    

  2531.  //           printf("m_TransDocWaitQueue.size:%d\n",m_TransDynamicPptWaitQueue.size());
    

  2532.         }
    

  2533.     }        
    

  2534.     else
    

  2535.     {
    

  2536.         //error
    

  2537.     }
    


  2538. 


  2539. 

  2540. }
    


  2541. 

  2542. s32 DsManage::OnTimer()
    

  2543. {
    

  2544.     //初始化是否存在四种队列超时任务
    

  2545.     bool bFindPPT = FALSE;
    

  2546.     bool bFindVideo = FALSE;
    

  2547.     bool bFindDoc = FALSE;
    

  2548.     bool bFindDocWindows = FALSE;
    

  2549.     TaskTimeInfo tTaskTimeInfo;
    

  2550.     if(FALSE == DsGetTimeInfo(&tTaskTimeInfo))
    

  2551.     {
    

  2552.         return -1;
    

  2553.     }    
    


  2554. 

  2555.     //检查视频转换列表
    

  2556.     TaskMessageList::iterator iterIdCheck;
    

  2557.     for (iterIdCheck=g_cDsManage.m_VideoRunQueue.begin(); iterIdCheck!=g_cDsManage.m_VideoRunQueue.end(); iterIdCheck++)
    

  2558.     {    
    

  2559.         AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2560.         string strMessageId;
    


  2561. 

  2562.         if(MAX_VIDEO_TASK_TIMEOUT_MINUTES == (((tTaskTimeInfo.m_wHour)*60+tTaskTimeInfo.m_wMinute)-((pTaskMessage->GetTaskTimeInfo()->m_wHour)*60+pTaskMessage->GetTaskTimeInfo()->m_wMinute)))
    

  2563.         {
    

  2564.             bFindVideo= TRUE;
    

  2565.             AppMessageType tAppMessageType = pTaskMessage->GetAppMessageType();
    


  2566. 

  2567.             if(APP_MESSAGE_VIDEO_TRANS_TASK == tAppMessageType)
    

  2568.             {
    

  2569.                 AppVideoTransResultMessage* pResult = new AppVideoTransResultMessage;
    

  2570.                 //报告失败
    

  2571.                 
    

  2572.                 //连接和发送转换结果给应用客户端
    

  2573.                 strMessageId = pTaskMessage->GetMessageId();
    

  2574.                 pResult->SetMessageId(strMessageId);
    

  2575.                 pResult->SetResult(FALSE);
    

  2576.                 pResult->SetErrorCode(RET_E_EXCUTE_TASK_TIMEOUT);
    

  2577.                 pResult->SetTargetFullPathFileName("");
    

  2578.                 //根据转换结果执行相应处理
    

  2579.                 string strAppTargetIp;
    

  2580.                 u32 dwAppTargetPort;
    

  2581.                 if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  2582.                 {
    

  2583.                     pResult->SetAppTargetIp(strAppTargetIp);
    

  2584.                     pResult->SetAppTargetPort(dwAppTargetPort);
    

  2585.                 }
    

  2586.                 else
    

  2587.                 {
    

  2588.                 //error
    

  2589.                 }
    


  2590. 

  2591.                 g_cDsManage.VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  2592.                 g_cDsManage.VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  2593.                 //将该任务从运行队列移除，并归还给空闲队列
    

  2594.                 pTaskMessage->Initialize();
    

  2595.                 g_cDsManage.m_FreeMessageQueue.push_back(pTaskMessage);
    

  2596.                 g_cDsManage.m_VideoRunQueue.erase(iterIdCheck);            
    

  2597.                 (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  2598.                 if(NULL != pResult)
    

  2599.                 {
    

  2600.                     delete pResult;
    

  2601.                     pResult = NULL;
    

  2602.                 }
    


  2603. 

  2604.                 break;                 
    

  2605.             }
    

  2606.             else if(APP_MESSAGE_VIDEO_CAPTURE_TASK == tAppMessageType)
    

  2607.             {
    

  2608.                 AppVideoCaptureResultMessage* pResult = new AppVideoCaptureResultMessage;
    

  2609.                 //报告失败
    

  2610.                 
    

  2611.                 //连接和发送转换结果给应用客户端
    

  2612.                 strMessageId = pTaskMessage->GetMessageId();
    

  2613.                 pResult->SetMessageId(strMessageId);
    

  2614.                 pResult->SetResult(FALSE);
    

  2615.                 pResult->SetErrorCode(RET_E_EXCUTE_TASK_TIMEOUT);
    

  2616.                 pResult->SetCount(0);
    

  2617.                 //根据转换结果执行相应处理
    

  2618.                 string strAppTargetIp;
    

  2619.                 u32 dwAppTargetPort;
    

  2620.                 if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  2621.                 {
    

  2622.                     pResult->SetAppTargetIp(strAppTargetIp);
    

  2623.                     pResult->SetAppTargetPort(dwAppTargetPort);
    

  2624.                 }
    

  2625.                 else
    

  2626.                 {
    

  2627.                 //error
    

  2628.                 }
    


  2629. 

  2630.                 g_cDsManage.VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  2631.                 g_cDsManage.VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  2632.                 //将该任务从运行队列移除，并归还给空闲队列
    

  2633.                 pTaskMessage->Initialize();
    

  2634.                 g_cDsManage.m_FreeMessageQueue.push_back(pTaskMessage);
    

  2635.                 g_cDsManage.m_VideoRunQueue.erase(iterIdCheck);            
    

  2636.                 (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  2637.                 if(NULL != pResult)
    

  2638.                 {
    

  2639.                     delete pResult;
    

  2640.                     pResult = NULL;
    

  2641.                 }
    


  2642. 

  2643.                 break;                 
    


  2644. 

  2645.             }
    

  2646.             else if(APP_MESSAGE_VIDEO_INFO_TASK == tAppMessageType)
    

  2647.             {
    

  2648.                 AppVideoInfoResultMessage* pResult = new AppVideoInfoResultMessage;
    

  2649.                 //报告失败
    

  2650.                 
    

  2651.                 //连接和发送转换结果给应用客户端
    

  2652.                 strMessageId = pTaskMessage->GetMessageId();
    

  2653.                 pResult->SetMessageId(strMessageId);
    

  2654.                 pResult->SetResult(FALSE);
    

  2655.                 pResult->SetErrorCode(RET_E_EXCUTE_TASK_TIMEOUT);
    

  2656.                 pResult->SetDuration(0);
    

  2657.                 pResult->SetResolution("");
    

  2658.                 pResult->SetAudioCode("");
    

  2659.                 pResult->SetVideoCode("");
    

  2660.                 pResult->SetAudioTrack("");
    

  2661.                 pResult->SetVideoType("");
    

  2662.                 pResult->SetFrameRate(0);
    

  2663.                 pResult->SetBitRate(0);
    

  2664.                 //根据转换结果执行相应处理
    

  2665.                 string strAppTargetIp;
    

  2666.                 u32 dwAppTargetPort;
    

  2667.                 if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  2668.                 {
    

  2669.                     pResult->SetAppTargetIp(strAppTargetIp);
    

  2670.                     pResult->SetAppTargetPort(dwAppTargetPort);
    

  2671.                 }
    

  2672.                 else
    

  2673.                 {
    

  2674.                 //error
    

  2675.                 }
    


  2676. 

  2677.                 g_cDsManage.VideoTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  2678.                 g_cDsManage.VideoTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  2679.                 //将该任务从运行队列移除，并归还给空闲队列
    

  2680.                 pTaskMessage->Initialize();
    

  2681.                 g_cDsManage.m_FreeMessageQueue.push_back(pTaskMessage);
    

  2682.                 g_cDsManage.m_VideoRunQueue.erase(iterIdCheck);            
    

  2683.                 (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  2684.                 if(NULL != pResult)
    

  2685.                 {
    

  2686.                     delete pResult;
    

  2687.                     pResult = NULL;
    

  2688.                 }
    


  2689. 

  2690.                 break;                 
    

  2691.                 
    

  2692.             }
    

  2693.             else
    

  2694.             {
    

  2695.                 //错误日志
    

  2696.             }
    


  2697. 

  2698.         }
    

  2699.     }
    


  2700. 

  2701.     if(TRUE == bFindVideo)
    

  2702.     {
    

  2703.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  2704.         //如果有，为其分配一个可用的空闲服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  2705.         if( !g_cDsManage.m_VideoWaitQueue.empty() )
    

  2706.         {
    

  2707.             for(u32 dwTsNo =1; dwTsNo <MAX_VIDEO_TRANS_SERVER_NUM; dwTsNo++)
    

  2708.             {
    

  2709.                 if(TS_FREE == g_cDsManage.VideoTs[dwTsNo].GetState())
    

  2710.                 {
    

  2711.                     AppTaskMessage*  pTaskMessage = g_cDsManage.m_VideoWaitQueue.top( );
    

  2712.                     AppMessageType tAppMessageType = pTaskMessage->GetAppMessageType();                                       
    

  2713.                     g_cDsManage.m_VideoWaitQueue.pop( );          
    

  2714.                     //设置时间
    

  2715.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  2716.                     g_cDsManage.m_VideoRunQueue.push_back(pTaskMessage);
    

  2717.                                             
    

  2718.                     g_cDsManage.VideoTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  2719.                     g_cDsManage.VideoTs[dwTsNo].SetState(TS_RUNNING);
    

  2720.                     pTaskMessage->SetTsNum(dwTsNo);
    

  2721.                     
    

  2722.                     if(APP_MESSAGE_VIDEO_TRANS_TASK == tAppMessageType)
    

  2723.                     {
    

  2724.                         TransVideoRequest* pTransVideoRequest = new TransVideoRequest;
    

  2725.                         pTransVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  2726.                         pTransVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  2727.                         pTransVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  2728.                         
    

  2729.                     
    

  2730.                         char cFormat[100];
    

  2731.                         sprintf(cFormat, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwFormat);
    

  2732.                         pTransVideoRequest->SetFormat(cFormat);
    

  2733.                     
    

  2734.                         char cBitRate[100];
    

  2735.                         sprintf(cBitRate, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwBitrate);
    

  2736.                         pTransVideoRequest->SetBitRate(cBitRate);
    

  2737.                     
    

  2738.                         char cWidth[100];
    

  2739.                         char cHeight[100];
    

  2740.                         string strWidth,strHeight,strResolution;
    

  2741.                         sprintf(cWidth, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionWidth);
    

  2742.                         sprintf(cHeight, "%d", pTaskMessage->GetMessagePara().unTransVideo.dwResolutionHeight);
    

  2743.                         strWidth = cWidth;
    

  2744.                         strHeight = cHeight;
    

  2745.                         strResolution = strWidth +"*"+strHeight;
    

  2746.                         pTransVideoRequest->SetResolution(strResolution);
    

  2747.                     
    

  2748.                         g_cDsManage.VideoTs[dwTsNo].GetTsSession()->SendMessage(*pTransVideoRequest);
    

  2749.                         if(NULL != pTransVideoRequest)
    

  2750.                         {
    

  2751.                             delete pTransVideoRequest;
    

  2752.                             pTransVideoRequest = NULL;
    

  2753.                         }
    

  2754.                     
    

  2755.                     }
    

  2756.                     else if(APP_MESSAGE_VIDEO_CAPTURE_TASK == tAppMessageType)
    

  2757.                     {
    

  2758.                         CapVideoRequest* pCapVideoRequest = new CapVideoRequest;
    

  2759.                         pCapVideoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  2760.                         pCapVideoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  2761.                         pCapVideoRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  2762.                         pCapVideoRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  2763.                     
    

  2764.                         char cStart[100];
    

  2765.                         sprintf(cStart, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwStartTIme);
    

  2766.                         pCapVideoRequest->SetStart(cStart);
    

  2767.                     
    

  2768.                         char cCount[100];
    

  2769.                         sprintf(cCount, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwPhotoCount);
    

  2770.                         pCapVideoRequest->SetCount(cCount);
    

  2771.                     
    

  2772.                     
    

  2773.                         char cInterval[100];
    

  2774.                         sprintf(cInterval, "%d", pTaskMessage->GetMessagePara().unCapVideo.dwSustainedTime);
    

  2775.                         pCapVideoRequest->SetInterval(cInterval);
    

  2776.                         
    

  2777.                         g_cDsManage.VideoTs[dwTsNo].GetTsSession()->SendMessage(*pCapVideoRequest);
    

  2778.                         if(NULL !=  pCapVideoRequest)
    

  2779.                         {
    

  2780.                             delete pCapVideoRequest;
    

  2781.                             pCapVideoRequest = NULL;
    

  2782.                         }
    

  2783.                     
    

  2784.                     }
    

  2785.                     else //if(APP_MESSAGE_VIDEO_INFO_TASK == tAppMessageType)
    

  2786.                     {
    

  2787.                         GetVideoInfoRequest* pVideoInfoRequest = new GetVideoInfoRequest;
    

  2788.                         pVideoInfoRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  2789.                         pVideoInfoRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  2790.                         
    

  2791.                         g_cDsManage.VideoTs[dwTsNo].GetTsSession()->SendMessage(*pVideoInfoRequest);
    

  2792.                         if(NULL !=  pVideoInfoRequest)
    

  2793.                         {
    

  2794.                             delete pVideoInfoRequest;
    

  2795.                             pVideoInfoRequest = NULL;
    

  2796.                         }
    

  2797.                     
    

  2798.                     }
    


  2799. 

  2800.                     break;
    

  2801.                 }
    

  2802.    
    

  2803.              }
    

  2804.         
    

  2805.          }        
    


  2806. 

  2807.     }
    


  2808. 

  2809.     //检查动态ppt 列表
    

  2810.     for (iterIdCheck=g_cDsManage.m_TransDynamicPptRunQueue.begin(); iterIdCheck!=g_cDsManage.m_TransDynamicPptRunQueue.end(); iterIdCheck++)
    

  2811.     {
    

  2812.         AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2813.         string strMessageId;
    


  2814. 

  2815.         if(MAX_DYNAMIC_PPT_TASK_TIMEOUT_MINUTES <= (((tTaskTimeInfo.m_wHour)*60+tTaskTimeInfo.m_wMinute)-((pTaskMessage->GetTaskTimeInfo()->m_wHour)*60+pTaskMessage->GetTaskTimeInfo()->m_wMinute)))
    

  2816.         {
    

  2817.             bFindPPT = TRUE;
    

  2818.             //报告失败
    

  2819.             AppDynamicPptTransResultMessage*  pResult = new AppDynamicPptTransResultMessage;
    

  2820.             //连接和发送转换结果给应用客户端
    

  2821.             strMessageId = pTaskMessage->GetMessageId();
    

  2822.             pResult->SetMessageId(strMessageId);
    

  2823.             pResult->SetResult(FALSE);
    

  2824.             pResult->SetErrorCode(RET_E_EXCUTE_TASK_TIMEOUT);   
    

  2825.             pResult->SetPages(0); 
    

  2826.     
    

  2827.             //根据转换结果执行相应处理
    

  2828.             string strAppTargetIp;
    

  2829.             u32 dwAppTargetPort;
    

  2830.             if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  2831.             {
    

  2832.                 pResult->SetAppTargetIp(strAppTargetIp);
    

  2833.                 pResult->SetAppTargetPort(dwAppTargetPort);
    

  2834.             }
    

  2835.             else
    

  2836.             {
    

  2837.             //error
    

  2838.             }
    


  2839. 

  2840.             g_cDsManage.PPTTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  2841.             g_cDsManage.PPTTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  2842.             //将该任务从运行队列移除，并归还给空闲队列
    

  2843.             pTaskMessage->Initialize();
    

  2844.             g_cDsManage.m_FreeMessageQueue.push_back(pTaskMessage);
    

  2845.             g_cDsManage.m_TransDynamicPptRunQueue.erase(iterIdCheck);            
    

  2846.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  2847.             if(NULL != pResult)
    

  2848.             {
    

  2849.                 delete pResult;
    

  2850.                 pResult = NULL;
    

  2851.             }
    


  2852. 

  2853.             break; 
    


  2854. 

  2855.         }
    

  2856.         
    

  2857.     }
    


  2858. 

  2859.     if(TRUE == bFindPPT)
    

  2860.     {
    

  2861.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  2862.         //如果有，为其分配一个可用的空闲服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  2863.         if( !g_cDsManage.m_TransDynamicPptWaitQueue.empty() )
    

  2864.         {
    

  2865.             for(u32 dwTsNo =1; dwTsNo <MAX_DANAMIC_PPT_TRANS_SERVER_NUM; dwTsNo++)
    

  2866.             {
    

  2867.                 if(TS_FREE == g_cDsManage.PPTTs[dwTsNo].GetState())
    

  2868.                 {
    

  2869.                     AppTaskMessage*  pTaskMessage = g_cDsManage.m_TransDynamicPptWaitQueue.top( );
    

  2870.                     g_cDsManage.m_TransDynamicPptWaitQueue.pop( );          
    

  2871.                     //设置时间
    

  2872.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  2873.                     g_cDsManage.m_TransDynamicPptRunQueue.push_back(pTaskMessage);
    

  2874.                                             
    

  2875.                     g_cDsManage.PPTTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  2876.                     g_cDsManage.PPTTs[dwTsNo].SetState(TS_RUNNING);
    

  2877.                     pTaskMessage->SetTsNum(dwTsNo);
    

  2878.                     TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  2879.                     pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  2880.                     pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  2881.                     pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  2882.                     pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  2883.                     pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  2884.         
    

  2885.                     g_cDsManage.PPTTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  2886.                     if(NULL !=  pTransitionRequest)
    

  2887.                     {
    

  2888.                         delete pTransitionRequest; 
    

  2889.                         pTransitionRequest = NULL;
    

  2890.                     }
    

  2891.                     break;
    

  2892.                 }
    

  2893.    
    

  2894.              }
    

  2895.         
    

  2896.          }        
    


  2897. 

  2898.     }
    


  2899. 

  2900.     //检查linux文档转换列表
    

  2901.     for (iterIdCheck=g_cDsManage.m_TransDocRunQueue.begin(); iterIdCheck!=g_cDsManage.m_TransDocRunQueue.end(); iterIdCheck++)
    

  2902.     {
    

  2903.         AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  2904.         string strMessageId;
    

  2905.         
    

  2906.         if(MAX_DOC_TASK_TIMEOUT_MINUTES <= (((tTaskTimeInfo.m_wHour)*60+tTaskTimeInfo.m_wMinute)-((pTaskMessage->GetTaskTimeInfo()->m_wHour)*60+pTaskMessage->GetTaskTimeInfo()->m_wMinute)))
    

  2907.         {
    

  2908.             bFindDoc = TRUE;
    

  2909.             //将该任务交给windows版本文档转换处理，同时从运行队列删除
    

  2910.             bool bFindWindows = FALSE;
    

  2911.             //查找是否存在空闲windows 转换服务器，如果找到，把任务交给它重新处理,并添加到运行队列中，发送任务消息给相关服务器
    

  2912.             for(u32 dwFreeTsNo =1; dwFreeTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwFreeTsNo++)
    

  2913.             {   
    

  2914.                 if((TS_FREE== g_cDsManage.DocWindowsTs[dwFreeTsNo].GetState()))
    

  2915.                 {
    

  2916.                     g_cDsManage.DocWindowsTs[dwFreeTsNo].SetMessageInTs(pTaskMessage);
    

  2917.                     g_cDsManage.DocWindowsTs[dwFreeTsNo].SetState(TS_RUNNING);                            
    

  2918.                     g_cDsManage.DocTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  2919.                     g_cDsManage.DocTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);
    


  2920. 

  2921.                     TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  2922.                     pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  2923.                     pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  2924.                     pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  2925.                     pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  2926.                     pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    


  2927. 

  2928.                     g_cDsManage.DocWindowsTs[dwFreeTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  2929.                     if(NULL != pTransitionRequest)
    

  2930.                     {
    

  2931.                         delete pTransitionRequest;
    

  2932.                         pTransitionRequest = NULL;
    

  2933.                     }
    


  2934. 

  2935.                     pTaskMessage->SetTsNum(dwFreeTsNo);
    

  2936.                     bFindWindows = TRUE;
    

  2937.                     //将该任务添加到windows版本文档转换运行队列中
    

  2938.                     TaskTimeInfo tNewTaskTimeInfo ;
    

  2939.                     if(FALSE == DsGetTimeInfo(&tNewTaskTimeInfo))
    

  2940.                     {
    

  2941.                         return -1;
    

  2942.                     }
    

  2943.                     pTaskMessage->SetTaskTimeInfo(tNewTaskTimeInfo);
    

  2944.                     
    

  2945.                     g_cDsManage.m_TransDocWindowsRunQueue.push_back(pTaskMessage);
    

  2946.                     break;
    

  2947.                 }
    

  2948.             }
    

  2949.             //如果没有windows 转换服务器空闲，则提升该任务优先级到最高，将该任务加入等待队列
    

  2950.             if(FALSE == bFindWindows)
    

  2951.             {
    

  2952.                 pTaskMessage->SetPriority(9);
    

  2953.                 g_cDsManage.m_TransDocWindowsWaitQueue.push(pTaskMessage);
    

  2954.             }
    


  2955. 

  2956.             //将该任务从linux版文档转换服务器运行队列移除
    

  2957.             g_cDsManage.DocTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  2958.             g_cDsManage.DocTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL);             
    

  2959.             g_cDsManage.m_TransDocRunQueue.erase(iterIdCheck); 
    

  2960.             
    

  2961.             break;
    

  2962.         }        
    

  2963.         
    

  2964.     }
    


  2965. 

  2966.     if(TRUE == bFindDoc)
    

  2967.     {
    

  2968.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  2969.         //如果有，为其分配一个可用的空闲服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  2970.         if( !g_cDsManage.m_TransDocWaitQueue.empty() )
    

  2971.         {
    

  2972.             for(u32 dwTsNo =1; dwTsNo <MAX_DOC_TRANS_SERVER_NUM; dwTsNo++)
    

  2973.             {
    

  2974.                 if(TS_FREE == g_cDsManage.DocTs[dwTsNo].GetState())
    

  2975.                 {
    

  2976.                     AppTaskMessage*  pTaskMessage = g_cDsManage.m_TransDocWaitQueue.top( );
    

  2977.                     g_cDsManage.m_TransDocWaitQueue.pop( );          
    

  2978.                     //设置时间
    

  2979.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  2980.                     g_cDsManage.m_TransDocRunQueue.push_back(pTaskMessage);
    

  2981.                                             
    

  2982.                     g_cDsManage.DocTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  2983.                     g_cDsManage.DocTs[dwTsNo].SetState(TS_RUNNING);
    

  2984.                     pTaskMessage->SetTsNum(dwTsNo);
    

  2985.                     TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  2986.                     pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  2987.                     pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  2988.                     pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  2989.                     pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  2990.                     pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  2991.         
    

  2992.                     g_cDsManage.DocTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  2993.                     if(NULL !=  pTransitionRequest)
    

  2994.                     {
    

  2995.                         delete pTransitionRequest; 
    

  2996.                         pTransitionRequest = NULL;
    

  2997.                     }
    

  2998.                     break;
    

  2999.                 }
    

  3000.    
    

  3001.              }
    

  3002.         
    

  3003.          }        
    


  3004. 

  3005.     }
    


  3006. 


  3007. 

  3008.     //检查windows文档转换列表
    

  3009.     for (iterIdCheck=g_cDsManage.m_TransDocWindowsRunQueue.begin(); iterIdCheck!=g_cDsManage.m_TransDocWindowsRunQueue.end(); iterIdCheck++)
    

  3010.     {    
    

  3011.         AppTaskMessage* pTaskMessage = *iterIdCheck;
    

  3012.         string strMessageId;
    


  3013. 

  3014.         if(MAX_DOC_TASK_TIMEOUT_MINUTES <= (((tTaskTimeInfo.m_wHour)*60+tTaskTimeInfo.m_wMinute)-((pTaskMessage->GetTaskTimeInfo()->m_wHour)*60+pTaskMessage->GetTaskTimeInfo()->m_wMinute)))
    

  3015.         {
    

  3016.             bFindDocWindows = TRUE;
    

  3017.             //报告失败
    

  3018.             AppDocTransResultMessage*  pResult = new AppDocTransResultMessage;
    

  3019.             //连接和发送转换结果给应用客户端
    

  3020.             strMessageId = pTaskMessage->GetMessageId();
    

  3021.             pResult->SetMessageId(strMessageId);
    

  3022.             pResult->SetResult(FALSE);
    

  3023.             pResult->SetErrorCode(RET_E_EXCUTE_TASK_TIMEOUT);   
    

  3024.             pResult->SetPages(0); 
    

  3025.     
    

  3026.             //根据转换结果执行相应处理
    

  3027.             string strAppTargetIp;
    

  3028.             u32 dwAppTargetPort;
    

  3029.             if(pTaskMessage->GetAppTargetInfo(strAppTargetIp,dwAppTargetPort))
    

  3030.             {
    

  3031.                 pResult->SetAppTargetIp(strAppTargetIp);
    

  3032.                 pResult->SetAppTargetPort(dwAppTargetPort);
    

  3033.             }
    

  3034.             else
    

  3035.             {
    

  3036.             //error
    

  3037.             }
    


  3038. 

  3039.             g_cDsManage.DocWindowsTs[pTaskMessage->GetTsNum()].SetState(TS_FREE);
    

  3040.             g_cDsManage.DocWindowsTs[pTaskMessage->GetTsNum()].SetMessageInTs(NULL); 
    

  3041.             //将该任务从运行队列移除，并归还给空闲队列
    

  3042.             pTaskMessage->Initialize();
    

  3043.             g_cDsManage.m_FreeMessageQueue.push_back(pTaskMessage);
    

  3044.             g_cDsManage.m_TransDocWindowsRunQueue.erase(iterIdCheck);            
    

  3045.             (SessionManager::GetInstance()).SendAppMessage(*pResult);
    

  3046.             if(NULL != pResult)
    

  3047.             {
    

  3048.                 delete pResult;
    

  3049.                 pResult = NULL;
    

  3050.             }
    


  3051. 

  3052.             break; 
    


  3053. 

  3054.         }
    

  3055.         
    

  3056.     }
    


  3057. 

  3058.     if(TRUE == bFindDocWindows)
    

  3059.     {
    

  3060.         //检查任务等待队列是否有转换任务在等待,没有则直接返回 
    

  3061.         //如果有，为其分配一个可用的空闲服务器，并发送转换命令给转换服务器，同时将该任务添加到运行队列
    

  3062.         if( !g_cDsManage.m_TransDocWindowsWaitQueue.empty() )
    

  3063.         {
    

  3064.             for(u32 dwTsNo =1; dwTsNo <MAX_DOC_WINDOWS_TRANS_SERVER_NUM; dwTsNo++)
    

  3065.             {
    

  3066.                 if(TS_FREE == g_cDsManage.DocWindowsTs[dwTsNo].GetState())
    

  3067.                 {
    

  3068.                     AppTaskMessage*  pTaskMessage = g_cDsManage.m_TransDocWindowsWaitQueue.top( );
    

  3069.                     g_cDsManage.m_TransDocWindowsWaitQueue.pop( );          
    

  3070.                     //设置时间
    

  3071.                     pTaskMessage->SetTaskTimeInfo(tTaskTimeInfo);
    

  3072.                     g_cDsManage.m_TransDocWindowsRunQueue.push_back(pTaskMessage);
    

  3073.                                             
    

  3074.                     g_cDsManage.DocWindowsTs[dwTsNo].SetMessageInTs(pTaskMessage);
    

  3075.                     g_cDsManage.DocWindowsTs[dwTsNo].SetState(TS_RUNNING);
    

  3076.                     pTaskMessage->SetTsNum(dwTsNo);
    

  3077.                     TransitionRequest* pTransitionRequest = new TransitionRequest;
    

  3078.                     pTransitionRequest->SetMessageId(pTaskMessage->GetMessageId());
    

  3079.                     pTransitionRequest->SetSrcFile(pTaskMessage->GetFullPathFileName());
    

  3080.                     pTransitionRequest->SetTargetFolder(pTaskMessage->GetTargetFullPathFileName());
    

  3081.                     pTransitionRequest->SetPrefix(pTaskMessage->GetFilePrefix());
    

  3082.                     pTransitionRequest->SetTransType(pTaskMessage->GetMessagePara().unTransDoc.enumTansType);
    

  3083.         
    

  3084.                     g_cDsManage.DocWindowsTs[dwTsNo].GetTsSession()->SendMessage(*pTransitionRequest);
    

  3085.                     if(NULL !=  pTransitionRequest)
    

  3086.                     {
    

  3087.                         delete pTransitionRequest; 
    

  3088.                         pTransitionRequest = NULL;
    

  3089.                     }
    

  3090.                     break;
    

  3091.                 }
    


  3092. 

  3093.              }
    

  3094.         
    

  3095.          }        
    


  3096. 

  3097.     }
    


  3098. 

  3099. }
    


  3100.


回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-11 09:30 | 显示全部楼层
本帖最后由 keer_zu 于 2015-8-12 09:45 编辑

2 ------
复制

  1. 


  2. 

  3. #include <cassert>
    


  4. 

  5. #ifdef _WIN32
    

  6. #include <WS2tcpip.h>
    

  7. #else
    

  8. #include <arpa/inet.h>
    

  9. //#include <sys/types.h>
    

  10. //#include <sys/socket.h>
    

  11. //#include <netinet/in.h>
    

  12. #endif
    

  13. #include <errno.h>
    

  14. #include <memory.h>
    

  15. #ifndef __NO_LOGGER__
    


  16. 

  17. #include "interfaceapiimp.h"
    

  18. #endif
    


  19. 


  20. 

  21. #include "connbaseimp.h"
    

  22. #include "eventlooperimp.h"
    

  23. using namespace cdy;
    


  24. 

  25. Connector::Connector(const std::string &host, short port, IConnectorAcceptorSink *sink)
    

  26.         : m_imp(new ConnectorImp(host, port, sink, this))
    

  27. {
    

  28. }
    

  29.         
    

  30. Connector::~Connector()
    

  31. {
    

  32.         m_imp->Cancel();
    

  33.         delete m_imp;
    

  34.         m_imp = NULL;
    

  35. }
    


  36. 

  37. //@param timeout means the connect timeout value in millesecond.
    

  38. int Connector::Connect(long timeout)
    

  39. {
    

  40.         if (m_imp)
    

  41.                 return m_imp->Connect(timeout);
    

  42.         return -1;
    

  43. }
    

  44.         
    

  45. void Connector::Cancel()
    

  46. {
    

  47.         if (m_imp)
    

  48.                 m_imp->Cancel();
    

  49. }
    


  50. 

  51. Acceptor::Acceptor(const std::string &addr, short port, IConnectorAcceptorSink *sink)
    

  52.         : m_imp(new AcceptorImp(addr, port, sink, this))
    

  53. {
    

  54. }
    


  55. 

  56. Acceptor::~Acceptor()
    

  57. {
    

  58.         delete m_imp;
    

  59.         m_imp = NULL;
    

  60. }
    


  61. 

  62. int Acceptor::StartListen()
    

  63. {
    

  64.         if (m_imp)
    

  65.                 return m_imp->StartListen();
    

  66.         return -1;
    

  67. }
    

  68.         
    

  69. void Acceptor::Stop()
    

  70. {
    

  71.         if (m_imp)
    

  72.                 m_imp->Stop();
    

  73. }
    


  74. 

  75. Connection::~Connection()
    

  76. {
    

  77. }
    


  78. 

  79. bool StrToAddress(const string &str, short port, struct sockaddr_in *addr)
    

  80. {
    

  81.         if (!addr)
    

  82.                 return false;
    

  83.                 
    

  84.     addr->sin_family = AF_INET;  
    

  85.     addr->sin_port = htons(port);  
    

  86. #ifdef WIN32  
    

  87.     addr->sin_addr.S_un.S_addr = inet_addr(str.c_str());  
    

  88. #else  
    

  89.     addr->sin_addr.s_addr = inet_addr(str.data());  
    

  90. #endif  
    

  91.     memset(addr->sin_zero, 0x00, 8);
    

  92.         return true;
    

  93. }
    


  94. 

  95. int SockAddrConvert(sockaddr_storage *addr, socklen_t len, string &str, short &port)
    

  96. {
    

  97.         char ipstr[INET6_ADDRSTRLEN];
    


  98. 

  99.         if (addr->ss_family == AF_INET){
    

  100.                 struct sockaddr_in *s = (struct sockaddr_in *)addr;
    

  101.                 port = ntohs(s->sin_port);
    

  102.                 inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof(ipstr));
    

  103.         } else { // AF_INET6
    

  104.                 struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
    

  105.                 port = ntohs(s->sin6_port);
    

  106.                 inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof(ipstr));
    

  107.         }
    


  108. 

  109.         str.assign(ipstr);
    

  110.         return 0;
    

  111. }
    


  112. 

  113. int GetPeerAddress(evutil_socket_t sock, string &saddr, short &port)
    

  114. {
    

  115.         struct sockaddr_storage addr;
    

  116.         socklen_t sockLen = sizeof(addr);
    


  117. 

  118.         if (getpeername(sock, (struct sockaddr*)&addr, &sockLen) != 0){
    

  119.                 int err = evutil_socket_geterror(sock);
    

  120.                 return err;
    

  121.         }
    


  122. 

  123.         return SockAddrConvert(&addr, sockLen, saddr, port);
    

  124. }
    


  125. 

  126. static void on_connect(evutil_socket_t sock, short events, void * args)
    

  127. {
    

  128.         ConnectorImp *connector = (ConnectorImp*)args;
    

  129.         string addr;
    

  130.         short port = 0;
    

  131.         int err = 0;
    

  132.         if (events & EV_TIMEOUT)
    

  133.                 err = -1;
    

  134.         else
    

  135.                 err = GetPeerAddress(sock, addr, port);
    


  136. 

  137.         if (connector){
    

  138.                 connector->OnConnectResult(sock, err, addr, port);
    

  139.         }
    

  140. }
    


  141. 

  142. static void on_accept(evutil_socket_t sock, short events, void * args)
    

  143. {
    

  144.         AcceptorImp *acceptor = (AcceptorImp*)args;
    

  145.         string saddr;
    

  146.         short port = 0;
    

  147.         sockaddr_storage addr;
    

  148. #ifdef WIN32  
    

  149.         int addrLen = sizeof(addr);
    

  150. #else
    

  151.         socklen_t addrLen = sizeof(addr);
    

  152. #endif
    

  153.         
    

  154.         int err = 0;
    

  155.         if (events & EV_TIMEOUT)
    

  156.                 err = -1;
    

  157.         if (acceptor){
    

  158.                 evutil_socket_t newSock = accept(sock, (sockaddr*)&addr, &addrLen);
    

  159.                 err = GetPeerAddress(newSock, saddr, port);
    

  160.                 acceptor->OnConnectResult(newSock, err, saddr, port);
    

  161.         }
    

  162. }
    


  163. 

  164. static void on_read(evutil_socket_t sock, short events, void * args)
    

  165. {
    

  166.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  167.         ConnectionImp *conn = (ConnectionImp*)args;
    

  168.         logerUser.Debug("%s  conn:0x%x\n",__FUNCTION__,conn);
    

  169.         if (events & EV_READ){
    

  170.                 if (conn){
    

  171.                         conn->OnRead(sock);
    

  172.                 }
    

  173.         }
    

  174. }
    


  175. 

  176. static void on_write(evutil_socket_t sock, short events, void * args)
    

  177. {
    

  178.         ConnectionImp *conn = (ConnectionImp*)args;
    

  179.         if (events & EV_WRITE){
    

  180.                 if (conn){
    

  181.                         conn->OnWrite(sock);
    

  182.                 }
    

  183.         }
    

  184. }
    


  185. 

  186. AcceptorImp::AcceptorImp(const std::string &addr, short port, IConnectorAcceptorSink *sink, Acceptor *wrapper)
    

  187.         : m_addr(addr)
    

  188.         , m_port(port)
    

  189.         , m_sink(sink)
    

  190.         , m_fd(-1)
    

  191.         , m_evBase(NULL)
    

  192.         , m_connectEvent(NULL)
    

  193.         , m_wrapper(wrapper)
    

  194. {
    

  195. }
    


  196. 

  197. int AcceptorImp::StartListen()
    

  198. {
    

  199.         struct sockaddr_in addr;
    

  200.         
    

  201.         if (!StrToAddress(m_addr, m_port, &addr))
    

  202.                 return -1;
    

  203.         
    

  204.         m_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    

  205.         if (evutil_make_socket_nonblocking(m_fd) != 0)
    

  206.                 return -1;
    

  207.         
    

  208.         if (evutil_make_listen_socket_reuseable(m_fd) != 0)
    

  209.                 return -1;
    


  210. 

  211.         if (bind(m_fd, (struct sockaddr*)&addr, sizeof(addr)) != 0)
    

  212.                 return -1;
    

  213.                 
    

  214.         EventLooperImp &evLooper = (EventLooperImp&)EventLooper::GetInstance();
    

  215.         m_evBase = evLooper.CurrentEvBase();
    

  216.         m_connectEvent = event_new(m_evBase, m_fd, EV_READ | EV_PERSIST, on_accept, (void*)this);
    

  217.         event_add(m_connectEvent, NULL);
    

  218.         
    

  219.         return listen(m_fd, 5);
    

  220. }
    


  221. 

  222. void AcceptorImp::Stop()
    

  223. {
    

  224.     evutil_closesocket(m_fd);
    

  225.     m_fd = -1;
    

  226.     if (m_connectEvent)
    

  227.     {
    

  228.         event_del(m_connectEvent);
    

  229.     }
    

  230.     m_connectEvent = NULL;
    

  231.     
    

  232. }
    


  233. 

  234. void AcceptorImp::OnConnectResult(evutil_socket_t sock, int error, string &peerAddr, short peerPort)
    

  235. {
    

  236.         if (!m_sink)
    

  237.                 return;
    

  238.         
    

  239.         ConnectionImp *conn = NULL;
    

  240.         if (!error){
    

  241.                 conn = new ConnectionImp(sock, m_evBase);
    

  242.                 conn->SetPeerAddress(peerAddr);
    

  243.                 conn->SetPeerPort(peerPort);
    

  244.         }
    

  245.         m_sink->OnConnection(conn, this->m_wrapper);
    

  246. }
    


  247. 

  248. ConnectorImp::ConnectorImp(const string &host, short port, IConnectorAcceptorSink *sink, Connector *wrapper)
    

  249.         : m_peerAddr(host)
    

  250.         , m_peerPort(port)
    

  251.         , m_sink(sink)
    

  252.         , m_fd(-1)
    

  253.         , m_evBase(NULL)
    

  254.         , m_connectEvent(NULL)
    

  255.         , m_wrapper(wrapper)
    

  256. {
    

  257.         EventLooperImp &el = (EventLooperImp&)EventLooper::GetInstance();
    

  258.         m_evBase = el.CurrentEvBase();
    

  259. }
    


  260. 

  261. ConnectorImp::~ConnectorImp()
    

  262. {
    

  263.         Cancel();
    


  264. 

  265.         if (m_fd != -1){
    

  266.                 evutil_closesocket(m_fd);
    

  267.                 m_fd = -1;
    

  268.         }
    


  269. 

  270.         event_del(m_connectEvent);
    

  271.         event_free(m_connectEvent);
    

  272.         m_connectEvent = NULL;
    

  273. }
    


  274. 

  275. int ConnectorImp::Connect(long timeout)
    

  276. {
    

  277.         struct timeval tv = {timeout/1000, (timeout%1000)*1000};
    

  278.         struct sockaddr_in peerAddr;
    

  279.         if (!StrToAddress(m_peerAddr, m_peerPort, &peerAddr))
    

  280.                 return -1;
    

  281.         
    

  282.         m_connecting = true;
    

  283.         m_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    

  284.         evutil_make_socket_nonblocking(m_fd); 
    

  285.         
    

  286.         m_connectEvent = event_new(m_evBase, m_fd, EV_WRITE, on_connect, (void*)this);
    

  287.         event_add(m_connectEvent, &tv);
    

  288.         connect(m_fd, (struct sockaddr*)&peerAddr, sizeof(peerAddr));
    

  289.         return 0;
    

  290. }
    


  291. 

  292. void ConnectorImp::Cancel()
    

  293. {
    

  294.         if (!m_connecting)
    

  295.                 return;
    


  296. 

  297.         m_sink = NULL;
    

  298.         evutil_closesocket(m_fd);
    

  299.         m_fd = -1;
    

  300.         
    

  301.         event_del(m_connectEvent);
    

  302.         event_free(m_connectEvent);
    

  303.         m_connectEvent = NULL;
    

  304. }
    


  305. 

  306. void ConnectorImp::OnConnectResult(evutil_socket_t sock, int error, string &peerAddr, short peerPort)
    

  307. {
    

  308.         m_connecting = false;
    


  309. 

  310.         if (!m_sink)
    

  311.                 return;
    

  312.         
    

  313.         ConnectionImp *conn = NULL;
    

  314.         if (!error){
    

  315.                 conn = new ConnectionImp(sock, m_evBase);
    

  316.                 conn->SetPeerAddress(peerAddr);
    

  317.                 conn->SetPeerPort(peerPort);
    

  318.                 m_fd = -1; //to avoid close it later.
    

  319.         }
    

  320.         m_sink->OnConnection(conn, this->m_wrapper);
    

  321. }
    


  322. 

  323. ConnectionImp::ConnectionImp(evutil_socket_t fd, struct event_base *evBase)
    

  324.         : m_sink(NULL)
    

  325.         , m_peerPort(0)
    

  326.         , m_fd(fd)
    

  327.         , m_evBase(evBase)
    

  328.         , m_closing(false)
    

  329. {
    

  330.         m_readEvent = event_new(m_evBase, m_fd, EV_READ | EV_PERSIST, on_read, (void*)this);
    

  331.         m_writeEvent = event_new(m_evBase, m_fd, EV_WRITE, on_write, (void*)this);
    


  332. 

  333.         event_add(m_readEvent, NULL);
    

  334.         //event_add(m_writeEvent, NULL);
    

  335.         m_writeBuffer = evbuffer_new();
    

  336. }
    


  337. 

  338. ConnectionImp::~ConnectionImp()
    

  339. {
    

  340.         Close();
    

  341. }
    


  342. 

  343. int ConnectionImp::Send(const char *data, int len)
    

  344. {
    

  345.         if (m_closing)
    

  346.                 return -1;
    

  347.                 
    

  348.         size_t left = evbuffer_get_length(m_writeBuffer);
    

  349.         if (evbuffer_add(m_writeBuffer, data, len) != 0)
    

  350.                 return -1;
    

  351.         
    

  352.         int rt = 0;
    

  353.         if (left != 0){
    

  354.                 rt = event_add(m_writeEvent, NULL);
    

  355.         } else {
    

  356.                 rt = evbuffer_write(m_writeBuffer, m_fd);
    

  357.         }
    

  358.         return rt;
    

  359. }
    


  360. 

  361. const std::string& ConnectionImp::GetPeerAddress()
    

  362. {
    

  363.         return m_peerAddr;
    

  364. }
    


  365. 

  366. short ConnectionImp::GetPeerPort()
    

  367. {
    

  368.         return m_peerPort;
    

  369. }
    


  370. 

  371. void ConnectionImp::OnRead(evutil_socket_t sock)
    

  372. {
    

  373.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  374.         logerUser.Debug("OnRead");
    

  375.         assert (sock == m_fd);
    

  376.         int sz = recv(sock, m_readBuffer, MAX_READ_LEN, 0);
    

  377.         int err;
    

  378.         if(sz <= 0){
    

  379. #ifdef WIN32
    

  380.                 err = WSAGetLastError();
    

  381. #else
    

  382.                 err = errno;
    

  383. #endif
    

  384.                 if (err == EWOULDBLOCK || err == EAGAIN)
    

  385.                         return;
    

  386.                 
    

  387.                 IConnectionSink *sink = m_sink;
    

  388.                 Close();
    

  389.                 if (sink){
    

  390.                         sink->OnDisconnect(err, this);
    

  391.                 }
    

  392.         } else {
    

  393.                 if (m_sink){
    

  394.                         m_sink->OnData(m_readBuffer, sz, this);
    

  395.                 }
    

  396.         }
    

  397. }
    


  398. 

  399. void ConnectionImp::OnWrite(evutil_socket_t sock)
    

  400. {
    

  401.         assert (sock == m_fd);
    

  402.         size_t left = evbuffer_get_length(m_writeBuffer);
    

  403.         
    

  404.         if (left != 0){
    

  405.                 int sz = evbuffer_write(m_writeBuffer, m_fd);
    

  406.                 
    

  407.                 if (sz < 0){
    

  408.                         int err;
    

  409. #ifdef WIN32
    

  410.                         err = WSAGetLastError();
    

  411. #else
    

  412.                         err = errno;
    

  413. #endif
    

  414.                         if (err != EWOULDBLOCK && err != EAGAIN){
    

  415.                                 IConnectionSink *sink = m_sink;
    

  416.                                 Close();
    

  417.                                 if (sink){
    

  418.                                         sink->OnDisconnect(err, this);
    

  419.                                 }
    

  420.                         }
    

  421.                 } else if ((size_t)sz < left){
    

  422.                         event_add(m_writeEvent, NULL);
    

  423.                 }
    

  424.         }
    

  425. }
    

  426.         
    

  427. void ConnectionImp::Close()
    

  428. {
    

  429.         if (m_closing)
    

  430.                 return;
    

  431.                 
    

  432.         m_closing = true;
    

  433.         m_sink = NULL;
    

  434.         evutil_closesocket(m_fd);
    

  435.         
    

  436.         m_fd = -1;
    

  437.         event_del(m_readEvent);
    

  438.         event_free(m_readEvent);
    

  439.         m_readEvent = NULL;
    

  440.         event_del(m_writeEvent);
    

  441.         event_free(m_writeEvent);
    

  442.         m_writeEvent = NULL;
    

  443.         evbuffer_free(m_writeBuffer);
    

  444.         m_writeBuffer = NULL;
    

  445. }
    


  446. 


  447. 

  448. void ConnectionImp::SetPeerAddress(const string addr)
    

  449. {
    

  450.         m_peerAddr.assign(addr);
    

  451. }
    


  452. 

  453. void ConnectionImp::SetPeerPort(short port)
    

  454. {
    

  455.         m_peerPort = port;
    

  456. }


回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-11 09:31 | 显示全部楼层
本帖最后由 keer_zu 于 2015-8-12 09:51 编辑

3 ---------

复制
  1. #include <iostream>
    

  2. #include "interfaceapiimp.h"
    


  3. 

  4. #include <log4cxx/logger.h>
    

  5. #include <log4cxx/logstring.h>
    

  6. #include <log4cxx/propertyconfigurator.h>
    


  7. 

  8. using namespace log4cxx;
    

  9. extern LoggerPtr g_logger;
    


  10. 

  11. using namespace std;
    


  12. 


  13. 

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

  15. {
    

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

  17.         string newFrame;
    

  18.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  19.         
    

  20.         if(buf == NULL){
    

  21.                 logerUser.Error("buf == NULL %d\n",__LINE__);
    

  22.         }
    

  23. //        LoggerUser& logerUser = LoggerUser::GetInstance();
    


  24. 

  25. //        cout << "OnData" <<"len:" << length <<endl;
    

  26. build_frame:
    

  27.         for(i=0;i<len;i++){
    

  28.                 if(buf[i + count] == '\0'){
    

  29.                         count = i;
    

  30.                         goto recv_process;
    

  31.                 } else {
    

  32.                         m_rdBuffer.push_back(buf[i + count]);
    

  33.                 }
    

  34.         }
    


  35. 

  36.         if(i == len)
    

  37.                 return;
    


  38. 

  39. recv_process:
    


  40. 

  41.         newFrame.clear();
    

  42.         
    

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


  44. 

  45. //        cout << "len:" << newFrame.length() <<endl;
    

  46.     if(count >0)
    

  47.     {
    

  48.             OnFrame(newFrame);
    

  49.     }
    

  50.         m_rdBuffer.clear();
    


  51. 

  52.         if(len > count + 2){
    

  53.                 
    

  54.                 count += 1;
    

  55.                 len = len - count - 1;
    

  56.                 
    

  57.                 goto build_frame;
    

  58.         }
    


  59. 

  60.         return;
    

  61. }
    


  62. 


  63. 


  64. 

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

  66. {
    

  67.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  68.         
    

  69.         if(conn == NULL){
    

  70.                 logerUser.Fatal("%s:SessionImp::%s:%d  error param",__FILE__,__FUNCTION__,__LINE__);
    

  71.                 return;
    

  72.         }
    

  73.         
    

  74.         m_connection = conn;
    

  75. }
    


  76. 

  77. void SessionImp::SendMessage(string &str)
    

  78. {
    

  79.         int ret;
    

  80.         LoggerUser& logerUser = LoggerUser::GetInstance();
    


  81. 

  82.         if(m_connection != NULL){
    

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


  84. 

  85.                 if(ret < 0){
    

  86.                         logerUser.Fatal("%s:SessionImp::%s:%d",__FILE__,__FUNCTION__,__LINE__);
    

  87.                 }
    


  88. 

  89.         }
    

  90.         
    

  91. }
    


  92. 


  93. 


  94. 

  95. TsSessionImp::TsSessionImp(ITsSessionUser *sessionUser,TsSession *tssession)
    

  96. {
    

  97.         m_sessionUser = sessionUser;
    

  98.         m_tssession = tssession;
    

  99.         m_sessionType = SESSION_TS;
    

  100. }
    


  101. 

  102. void TsSessionImp::SetSessionUser(ITsSessionUser *sessionUser)
    

  103. {
    

  104.         m_sessionUser = sessionUser;
    

  105. }
    


  106. 


  107. 


  108. 

  109. void TsSessionImp::SendMessage(TsMessageBase &msg)
    

  110. {
    

  111.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  112.         logerUser.Debug("%s:%s:%d \n",__FILE__,__FUNCTION__,__LINE__);
    

  113.         string json;
    

  114.         
    

  115.         if(msg.Encode(json)){      
    

  116.               json = json +'\0';
    

  117.                 printf(" TsSessionImp::SendMessage:%s\n",json.c_str());
    

  118.                 m_connection->Send(json.data(),json.length());
    

  119.         } else {
    

  120.                 logerUser.Error("%s:%s:%d   TsMessageBase.Encode error!\n",__FILE__,__FUNCTION__,__LINE__);
    

  121.         }
    

  122. }
    


  123. 

  124. void TsSessionImp::Close()
    

  125. {
    

  126.         // close connect
    

  127.         struct TsSessionInfo *tsSessionInfo;
    

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


  129. 

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

  131.         
    

  132.         m_connection->Close();
    


  133. 

  134.         if (this->m_connection){
    

  135.                 delete this->m_connection;
    

  136.                 this->m_connection = NULL;
    

  137.         }
    


  138. 

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

  140.                 tsSessionInfo = *tlit;
    

  141.                 if(tsSessionInfo != NULL){
    

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

  143.                                 
    

  144.                                 smi.m_tsSessionList.erase(tlit);   
    


  145. 

  146.                                 delete tsSessionInfo;
    

  147.                                 
    

  148.                                 break;
    

  149.                         }
    

  150.                 }
    

  151.         }
    


  152. 

  153.         delete this;
    

  154. }
    


  155. 


  156. 

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

  158. {
    

  159.         ProcessFrame(buf,length);
    

  160. }
    


  161. 

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

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

  164. {
    


  165. 

  166. }
    

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

  168.         // will not get this callback.
    

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

  170. {
    

  171.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  172.         
    


  173. 

  174.         logerUser.Debug("%s:%s:%d    conn: 0x%x \n",__FILE__,__FUNCTION__,__LINE__,conn);
    

  175.         logerUser.Debug("%s:%s:%d    m_connection: 0x%x \n",__FILE__,__FUNCTION__,__LINE__,this->m_connection);
    


  176. 


  177. 


  178. 

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


  180. 

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

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

  183.         
    

  184.         Close();
    

  185. }
    


  186. 

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

  188. {
    

  189.         struct TsSessionInfo *tsSessionInfo;
    

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

  191.         ITsSessionUser* tsSessionUser;
    


  192. 

  193.         LoggerUser& logerUser = LoggerUser::GetInstance();
    


  194. 

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

  196.         ITsSessionUser* itsu= smi.GetSessionUser();
    

  197.         if(itsu == NULL){
    

  198.                 logerUser.Error("%s:%s:%d   smi.GetSessionUser() == NULL\n",__FILE__,__FUNCTION__,__LINE__);
    

  199.                 return 0;
    

  200.         }
    

  201.         
    

  202.         TsMessageCodec tmc;
    

  203.         TsMessageBase* pTsMsg = tmc.Decode(frame);
    

  204.         if (pTsMsg == NULL) {
    

  205.                 itsu->OnSessionError(*this->m_tssession);
    

  206.                 logerUser.Error("message Decode error! frame:%s\n",frame.c_str());
    

  207.                 
    

  208.                 return 0;
    

  209.         }
    


  210. 


  211. 

  212.         //logerUser.Debug("[url=home.php?mod=space&uid=72445]@[/url] ts session:  type:%d",pTsMsg->GetTsMessageType());
    

  213.         switch(pTsMsg->GetTsMessageType()){
    

  214.                 case TS_MESSAGE_SVR_REGISTER:
    

  215.                         itsu->OnRegister(*((RegisterInfo*) pTsMsg),*this->m_tssession);
    

  216.                         break;
    


  217. 

  218.                 case TS_MESSAGE_ACCEPT_TASK:   //TS_MESSAGE_TRANSMIT
    

  219.                         break;
    


  220. 

  221.                 case TS_MESSAGE_TRANS_RESULT:
    

  222.                         itsu->OnTaskResult(*((TaskResult*)pTsMsg),*this->m_tssession);
    

  223.                         break;
    


  224. 

  225.                 case TS_MESSAGE_LINK_RESPONSE:  // OnServerLeave is called when heartbeat is not received
    

  226.                         for(it = smi.m_tsSessionList.begin();it != smi.m_tsSessionList.end();it ++) {
    

  227.                                 tsSessionInfo = *it;
    

  228.                                 if(tsSessionInfo != NULL){
    

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

  230.                                                 tsSessionInfo->timeOut = 0;
    

  231.                                                 break;
    

  232.                                         }
    

  233.                                 }
    

  234.                         }
    


  235. 

  236.                         break;
    

  237.                 default:
    

  238.                         break;
    


  239. 

  240.         
    

  241.         }
    


  242. 

  243.                         if(NULL != pTsMsg){
    

  244.                                 delete pTsMsg;
    

  245.                         }
    


  246. 

  247.         return 1;
    

  248. }
    


  249. 

  250.         
    


  251. 


  252. 

  253. /////////////////// /// app accept session /////////////////////
    


  254. 


  255. 

  256. void AppServerSessionImp::SetEventListener(IAppEventListener *eventListener)
    

  257. {
    

  258.         m_eventListener = eventListener;
    

  259. }
    


  260. 


  261. 

  262. void AppServerSessionImp::SendMessage(AppMessageBase &msg)
    

  263. {
    

  264.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  265.         logerUser.Debug("%s:%s:%d \n",__FILE__,__FUNCTION__,__LINE__);
    

  266.         
    

  267.         string json;
    


  268. 

  269.         if(msg.Encode(json)){
    

  270.                 json = json + '\0';
    

  271.                 m_connection->Send(json.data(),json.length());
    

  272.         } else {
    

  273.                 logerUser.Fatal("message encode error! %s:%s:%d \n",__FILE__,__FUNCTION__,__LINE__);
    

  274.         }
    

  275.         
    

  276. }
    


  277. 

  278. void AppServerSessionImp::Close()
    

  279. {
    

  280.         m_connection->Close();
    


  281. 

  282.         if (this->m_connection){
    

  283.                 delete this->m_connection;
    

  284.                 this->m_connection = NULL;
    

  285.         }
    


  286. 

  287.         delete this;
    

  288. }
    


  289. 

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

  291. {
    


  292. 


  293. 

  294.         ProcessFrame(buf,length);
    


  295. 


  296. 

  297. }
    


  298. 

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

  300. {
    


  301. 

  302. }
    


  303. 

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

  305. {
    

  306.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  307.         
    

  308.         struct TsSessionInfo *tsSessionInfo;
    

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

  310.         
    

  311.         cout << "app server OnDisconnect from " << conn->GetPeerAddress() << ":" << conn->GetPeerPort() << endl;
    


  312. 

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

  314.         smi.OnSessionClose(*this);
    


  315. 

  316.         Close();
    

  317. }
    


  318. 

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

  320. {
    

  321.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  322.         logerUser.Debug("server session:%d",__LINE__);
    


  323. 

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


  325. 

  326.         AppMessageCodec amc;
    


  327. 

  328. #ifdef __old_solution__
    

  329.         AppMessageBase* pAppMsg = amc.Decode(frame);
    

  330.         if (pAppMsg == NULL) {
    

  331.                 printf("onframe decode error\n");
    

  332.                 logerUser.Fatal("message Decode error! %s : %s : %d",__FILE__,__FUNCTION__,__LINE__);
    

  333.                 return 0;
    

  334.         }
    

  335.         
    

  336.         IAppEventListener* iael = smi.GetAppEventListener();
    

  337.         if(iael == NULL){
    

  338.                 logerUser.Error("GetAppEventListener error! %s : %s : %d",__FILE__,__FUNCTION__,__LINE__);
    

  339.                 return 0;
    

  340.         }
    


  341. 

  342.         switch(pAppMsg->GetAppMessageType()){
    

  343.                 case APP_MESSAGE_VIDEO_TRANS_TASK:
    

  344.                 case APP_MESSAGE_PRINT_SCREEN_TASK:
    

  345.                 case APP_MESSAGE_DOC_TRANS_TASK:
    

  346.                 case APP_MESSAGE_DYNAMIC_PPT_TRANS_TASK:            
    

  347.                         iael->OnNewTask(*(AppTaskMessage *)pAppMsg);
    

  348.                         break;
    


  349. 

  350.                 default:
    

  351.                         break;
    


  352. 

  353.         }
    


  354. 

  355.         if(NULL != pAppMsg){
    

  356.                 delete pAppMsg;
    

  357.         }
    

  358. #endif
    

  359.         return 1;
    

  360. }
    


  361. 


  362. 


  363. 


  364. 


  365. 

  366. //////////////////////// app connect session ///////////////////
    


  367. 

  368. void AppClientSessionImp::SendMessage(AppMessageBase &msg)
    

  369. {
    

  370.         string json;
    


  371. 

  372.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  373.         logerUser.Debug("%s:%s:%d \n",__FILE__,__FUNCTION__,__LINE__);
    


  374. 

  375.         if(msg.Encode(json)){
    

  376. //                cout << json.data() << " app c ****$ length:" << json.length() << endl;
    

  377.                 json = json + '\0';
    

  378.                 m_connection->Send(json.data(),json.length());
    

  379.         } else {
    

  380.                 logerUser.Error("message Encode error! %s : %s : %d",__FILE__,__FUNCTION__,__LINE__);
    

  381.         }
    

  382. }
    


  383. 

  384. void AppClientSessionImp::Close()
    

  385. {
    

  386.         if(m_connection != NULL)
    

  387.                 m_connection->Close();
    


  388. 

  389.         if (this->m_connection){
    

  390.                 delete this->m_connection;
    

  391.                 this->m_connection = NULL;
    

  392.         }
    


  393. 

  394.         delete this;
    

  395. }
    


  396. 

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

  398. {
    

  399.         
    

  400.         ProcessFrame(buf,length);
    

  401.         
    

  402. }
    


  403. 

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

  405. {
    


  406. 

  407. }
    


  408. 

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

  410. {
    

  411.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  412.         
    

  413.         cout << "app client OnDisconnect from " << conn->GetPeerAddress() << ":" << conn->GetPeerPort() << endl;
    

  414.         
    

  415.         logerUser.Debug(" connection:0x%x",conn);
    


  416. 

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

  418.         smi.OnSessionClose(*this);
    


  419. 

  420.         Close();
    

  421. }
    


  422. 

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

  424. {
    

  425.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  426.         logerUser.Debug("client session:%d",__LINE__);
    

  427.         string recv_frame;
    


  428. 

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


  430. 


  431. 

  432.         AppMessageCodec amc;
    


  433. 

  434. #ifdef __old_solution__
    

  435.         AppMessageBase* pAppMsg = amc.Decode(frame);
    

  436.         if (pAppMsg == NULL) {
    

  437.                 logerUser.Fatal("message Decode error! %s : %s : %d",__FILE__,__FUNCTION__,__LINE__);
    

  438.                 return 0;
    

  439.         }
    

  440.         
    

  441.         switch(pAppMsg->GetAppMessageType()){
    


  442. 

  443.                 case APP_MESSAGE_RESPONSE:
    

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

  445.                         smi.OnSessionClose(*this);
    


  446. 

  447.                         Close();
    

  448.                         break;
    

  449.                 default:
    

  450.                         break;
    

  451.         }
    


  452. 

  453.         if(NULL != pAppMsg){
    

  454.                 delete pAppMsg;
    

  455.         }
    


  456. 

  457.         return 1;
    

  458. #endif
    

  459. }
    


  460. 


  461. 

  462. /////////////////////////////// TsClientSessionImp /////////////////////////////////////////////////////
    


  463. 

  464. void TsClientSessionImp::SendMessage(TsMessageBase &msg)
    

  465. {
    

  466.         string json;
    


  467. 

  468.         LoggerUser& logerUser = LoggerUser::GetInstance();
    

  469.         logerUser.Debug("%s:%s:%d \n",__FILE__,__FUNCTION__,__LINE__);
    


  470. 

  471.         if(msg.Encode(json)){
    

  472. //                cout << json.data() << " app c ****$ length:" << json.length() << endl;
    

  473.                 json = json + '\0';
    

  474.                 m_connection->Send(json.data(),json.length());
    

  475.         } else {
    

  476.                 logerUser.Error("message Encode error! %s : %s : %d",__FILE__,__FUNCTION__,__LINE__);
    

  477.         }
    

  478. }
    


  479. 


  480. 

  481. void TsClientSessionImp::Close()
    

  482. {
    


  483. 

  484. }
    


  485. 


  486. 

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

  488. {
    


  489. 

  490. }
    


  491. 

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

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

  494. {
    


  495. 

  496. }
    


  497. 

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

  499. // will not get this callback.
    

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

  501. {
    


  502. 

  503. }
    


  504. 

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

  506. {
    


  507. 

  508. }
    


  509. 


  510.


回复

收藏 举报

laoxu 发表于 2015-8-11 15:51 | 显示全部楼层
都不是好代码，一句注释也未有~~~~~  :dizzy:
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-11 17:35 | 显示全部楼层
laoxu 发表于 2015-8-11 15:51
都不是好代码，一句注释也未有~~~~~

:lol
回复

收藏 举报

qhdjxy 发表于 2015-8-11 19:24 | 显示全部楼层
太长了。。。
回复

收藏 举报

angus118 发表于 2015-8-11 20:18 | 显示全部楼层
太长不看
回复

收藏 举报

fangzimo 发表于 2015-8-12 08:33 | 显示全部楼层
21ic应该有一个编辑代码的文本框，借鉴一下其他论坛上代码的发布方式，可以收起来，这样就不会感觉太长，不想看了
回复

收藏 举报

ticomi 发表于 2015-8-12 08:37 | 显示全部楼层
贴代码时注意将代码贴规范，写的也要规范，看起来才容易！
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-12 09:51 | 显示全部楼层
laoxu 发表于 2015-8-11 15:51
都不是好代码，一句注释也未有~~~~~

先从代码风格看。
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-12 09:52 | 显示全部楼层
laoxu 发表于 2015-8-11 15:51
都不是好代码，一句注释也未有~~~~~

先从代 码 风 格 看。
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-12 09:52 | 显示全部楼层
fangzimo 发表于 2015-8-12 08:33
21ic应该有一个编辑代码的文本框，借鉴一下其他论坛上代码的发布方式，可以收起来，这样就不会感觉太长，不 ...

改了
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-12 09:52 | 显示全部楼层
fangzimo 发表于 2015-8-12 08:33
21ic应该有一个编辑代码的文本框，借鉴一下其他论坛上代码的发布方式，可以收起来，这样就不会感觉太长，不 ...

改了
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-12 09:52 | 显示全部楼层
fangzimo 发表于 2015-8-12 08:33
21ic应该有一个编辑代码的文本框，借鉴一下其他论坛上代码的发布方式，可以收起来，这样就不会感觉太长，不 ...

改过了。
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-12 09:53 | 显示全部楼层
ticomi 发表于 2015-8-12 08:37
贴代码时注意将代码贴规范，写的也要规范，看起来才容易！

改过了
回复

收藏 举报

ningling_21 发表于 2015-8-13 09:29 | 显示全部楼层
keer_zu 发表于 2015-8-12 09:53
改过了

都是楼主的作品？
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-13 09:31 | 显示全部楼层
ningling_21 发表于 2015-8-13 09:29
都是楼主的作品？

三个人的。
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-13 17:29 | 显示全部楼层
yyy71cj 发表于 2015-8-13 16:30
我有个建议，最好是先把框架理出来看下……

有些人代码一开始就没有考虑什么框架，有些一看就知道什么框架。
回复

收藏 举报

 楼主| keer_zu 发表于 2015-8-14 09:32 | 显示全部楼层
yyy71cj 发表于 2015-8-14 07:23
抽出函数级的模块结构来也成，好歹也表现一个模块与数据流的关系来

可以吧定义类的头文件给出来，应该一目了然了。
回复

收藏 举报

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

本版积分规则

keer_zu

1488

主题

12949

帖子

55

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