发新帖本帖赏金 10.00元(功能说明)我要提问
12下一页
返回列表
打印

一步一步完善我的设计(5):各个模块编码码

[复制链接]
2739|25
手机看帖
扫描二维码
随时随地手机跟帖
沙发
keer_zu|  楼主 | 2016-6-8 11:34 | 只看该作者
AddTask.h

#ifndef __ADD_TASK_H__
#define __ADD_TASK_H__
#include <stdio.h>
#include <iostream>
#include <string>
#include <vector>
#include "json/json.h"
#include "InterfaceApi.h"
#include "Disptacher.h"
#include "Log4cxxWrapper.h"
#include "Task.h"


using namespace std;

class CommandDb;


class AddTask
{
        AddTask *next; // 1. "next" pointer in the base class
       
protected:
        vector<string> m_commandNames;
        TaskDb *m_taskDb;
        Disptacher *m_disptacher;
        CommandDb* m_commandDb;

public:
        AddTask();
       
        bool IsThisTaskType(const string cmdName)
        {
                vector<string>::iterator it;
               
                for (it = m_commandNames.begin(); it != m_commandNames.end(); ++ it){
                        if(cmdName == *it)
                                return true;
                }

                return false;
        }
        virtual void GetInfo() = 0;

        virtual bool TaskSubmit(Task* task) = 0;
               
        void setNext(AddTask *n)
        {
                next = n;
        }
        void add(AddTask *n)
        {
                if (next)
                        next->add(n);
                else
                        next = n;
        }
        virtual void AddSpacificTask(Json::Value& value,AppServerSession *appServerSion)
        {
                if(next != NULL)
                        next->AddSpacificTask(value,appServerSion);
                else {   // this command does not exist;
                        printf("error");
                        // TODO: log
                }
        }

        Task* BuildBasicTask(Json::Value& value);
       
        bool DoAppResponse(string commandName,AppServerSession *session,Task* task);

};

class AddVideoTask : public AddTask
{
        AddVideoTask();
public:
        virtual void GetInfo(){}
        virtual bool TaskSubmit(Task*);
        static AddVideoTask& GetInstance();
        virtual void AddSpacificTask(Json::Value& value,AppServerSession *appServerSion);       
};

class AddDocTask : public AddTask
{
        AddDocTask();
public:
        virtual void GetInfo(){}
        virtual bool TaskSubmit(Task*);
        static AddDocTask& GetInstance();
        virtual void AddSpacificTask(Json::Value& value,AppServerSession *appServerSion);
};

class AddDpptTask : public AddTask
{
        AddDpptTask();
public:
        virtual void GetInfo(){}
        virtual bool TaskSubmit(Task*);
        static AddDpptTask& GetInstance();
        virtual void AddSpacificTask(Json::Value& value,AppServerSession *appServerSion);
};

class AddNoUseTsTask : public AddTask
{
        AddNoUseTsTask();
public:
        virtual void GetInfo(){}
        virtual bool TaskSubmit(Task*);
        static AddNoUseTsTask& GetInstance();
        virtual void AddSpacificTask(Json::Value& value,AppServerSession *appServerSion);
};

#endif

使用特权

评论回复

打赏榜单

21ic小喇叭 打赏了 10.00 元 2016-06-12
理由:分享打赏

板凳
keer_zu|  楼主 | 2016-6-8 11:35 | 只看该作者
AddTask.cpp

#include "AddTask.h"
#include "TsManager.h"
#include "CommandDb.h"
#include "error.h"


using namespace std;
using namespace cdy;

//extern CommandDb GCommandDb;

extern TaskDocumentDb GTaskDocumentDb;
extern TaskVideoDb GTaskVideoDb;
extern TaskDpptDb GTaskDpptDb;
extern TaskNoUseTsDb GTaskNoUseTsDb;


//==========================  AddTask ===========================

AddTask::AddTask()
{
        next = NULL;
        m_commandDb = &CommandDb::GetInstance();//&GCommandDb;
}

Task* AddTask::BuildBasicTask(Json::Value& value)
{
        Task *task;

        task = m_taskDb->GetTask();
               
        if(!value["priority"].isNull() && value["priority"].isIntegral()){
                task->SetPriority(value["priority"].asInt());
        } else {
                // TODO: LOG
                return NULL;
        }

        if(!value["id"].isNull() && value["id"].isString()){
                task->SetTaskId(value["id"].asString());
        } else {
                // TODO: LOG
                return NULL;
        }

        task->Init();
        task->SetCmdValue(value);
        task->SetDisptacher(m_disptacher);
        task->SetCommand(m_commandDb->GetCommand(value["command"].asString()));
       

        if(!value["host"].isNull() && value["host"].isString()){
                task->m_appTargetIp = value["host"].asString();            
        } else {
                // TODO: log
                return NULL;            
        }   

        if(!value["port"].isNull() && value["port"].isIntegral()){
                task->m_appTargetPort = value["port"].asInt();            
        } else {
                //dsLog.Log(FALSE,LOGGER_ERROR,"Error message from application client. No port. :%s, [%s][%s][%d]\n",strRecv.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);                                               
                return NULL;
        }

        return task;
}


bool AddTask::DoAppResponse(string commandName,AppServerSession *session,Task* task)
{
        string msg;
        Command *cmd;
        Json::Value valueAppRes;
        LoggerWrapper dsLog= LoggerWrapper::GetInstance();

        cmd = m_commandDb->GetCommand(commandName);
        if(!cmd)
                return false;
       
        if(m_disptacher->DuplicateTaskCheck(task->GetTaskId())){
                cmd->BuildAppResponse(valueAppRes,0,"");
        } else {
                cmd->BuildAppResponse(valueAppRes,RET_E_REPEATED_TS_TRANS_TASK,"App task message id is repeated!");
                msg = valueAppRes.toStyledString() + '\0';
                session->SendMessage(msg);
                dsLog.Log(true,LOGGER_ERROR,"%s:%s:%d   App task message id is repeated!\n",__FILE__,__PRETTY_FUNCTION__,__LINE__);
                return false;
        }

        msg = valueAppRes.toStyledString() + '\0';
        session->SendMessage(msg);
       
        return true;
}

//========================  AddVideoTask =========================
AddVideoTask& AddVideoTask::GetInstance()
{
        static  AddVideoTask instance_;
        return instance_;        
}


AddVideoTask::AddVideoTask()
{
        m_commandDb->GetCommandNameInSpecificTaskType(VideoTask,m_commandNames);
       
        m_taskDb = &GTaskVideoDb;
        m_disptacher = &VideoDisptacher::GetInstance();//&GVideoDisptacher;
}

void AddVideoTask::AddSpacificTask(Json::Value& value,AppServerSession *appServerSion)
{
        Task* task;

        if(IsThisTaskType(value["command"].asString())) {
                task = BuildBasicTask(value);
                if(!task)
                        return;
               
                if(!DoAppResponse(value["command"].asString(),appServerSion,task))
                        return;

                if(!TaskSubmit(task)){
                       
                }

                return;
               
        } else {
                AddTask::AddSpacificTask(value,appServerSion);
        }
}

bool AddVideoTask::TaskSubmit(Task* task)
{
        return m_disptacher->Submit(task);
}





//=========================  AddDocTask ==========================

AddDocTask& AddDocTask::GetInstance()
{
        static  AddDocTask instance_;
        return instance_;        
}

AddDocTask::AddDocTask()
{
        m_commandDb->GetCommandNameInSpecificTaskType(DocTask,m_commandNames);
       
        m_taskDb = &GTaskDocumentDb;

        m_disptacher = &DocDisptacher::GetInstance();//GDocDisptacher;
}

void AddDocTask::AddSpacificTask(Json::Value& value,AppServerSession *appServerSion)
{
        Task* task;
       
        if(IsThisTaskType(value["command"].asString())) {
                task = BuildBasicTask(value);
                if(!task)
                        return;

                TaskDocument* td = dynamic_cast<TaskDocument*>(task);
               
                if(!value["docServerType"].isNull()){
                        if(value["docServerType"].isString() &&
                                (value["docServerType"].asString() == "LINUX" ||
                                value["docServerType"].asString() == "WPS" ||
                                value["docServerType"].asString() == "OFFICE" )
                        )
                                td->SetIsSpecific(true);
                        else
                                td->SetIsSpecific(false);
                } else {
                        td->SetIsSpecific(false);
                }
               
                if(!DoAppResponse(value["command"].asString(),appServerSion,task))
                        return;

                if(!TaskSubmit(task)){
                       
                }

                return;
        } else {
                AddTask::AddSpacificTask(value,appServerSion);
        }
}

bool AddDocTask::TaskSubmit(Task* task)
{
        return m_disptacher->Submit(task);
}


//========================  AddDpptTask ==========================
AddDpptTask& AddDpptTask::GetInstance()
{
        static  AddDpptTask instance_;
        return instance_;        
}

AddDpptTask::AddDpptTask()
{
        m_commandDb->GetCommandNameInSpecificTaskType(DpptTask,m_commandNames);
       
        m_taskDb = &GTaskDpptDb;

        m_disptacher = &DpptDisptacher::GetInstance();//&GDpptDisptacher;
}

void AddDpptTask::AddSpacificTask(Json::Value& value,AppServerSession *appServerSion)
{
        Task *task;
       
        if(IsThisTaskType(value["command"].asString())){
                task = BuildBasicTask(value);
                if(!task)
                        return;
               
                if(!DoAppResponse(value["command"].asString(),appServerSion,task))
                        return;

                if(!TaskSubmit(task)){
                       
                }

                return;
        } else {
                AddTask::AddSpacificTask(value,appServerSion);
        }
}

bool AddDpptTask::TaskSubmit(Task* task)
{
        return m_disptacher->Submit(task);
}



//====================== AddNoUseTsTask ===========================
AddNoUseTsTask& AddNoUseTsTask::GetInstance()
{
        static  AddNoUseTsTask instance_;
        return instance_;        
}

AddNoUseTsTask::AddNoUseTsTask()
{
        m_commandDb->GetCommandNameInSpecificTaskType(NoTsTask,m_commandNames);
        m_taskDb = &GTaskNoUseTsDb;
       
}

void AddNoUseTsTask::AddSpacificTask(Json::Value& value,AppServerSession *appServerSion)
{
        Task* task;
       
        if(IsThisTaskType(value["command"].asString())){
                task = BuildBasicTask(value);
                if(!task)
                        return;
               
                if(!DoAppResponse(value["command"].asString(),appServerSion,task))
                        return;

                if(!TaskSubmit(task)){
                       
                }

                return;
        } else {
                AddTask::AddSpacificTask(value,appServerSion);
        }
}

bool AddNoUseTsTask::TaskSubmit(Task* task)
{
         Json::Value appResult;
         bool ret;
         string appResultMsg;
         SessionManager& sm = SessionManager::GetInstance();
         
        Command* cmd = task->GetCommand();
       
        if(cmd->IsProvidedResult()){
                ret = cmd->BuildAppResult(task->GetCmdValue(),appResult);
                if(!ret){
                       
                        return false;
                }

                appResultMsg = appResult.toStyledString();

                sm.SendAppMessage(task->m_appTargetIp,task->m_appTargetPort,appResultMsg,task);
        }
}



使用特权

评论回复
地板
keer_zu|  楼主 | 2016-6-8 11:36 | 只看该作者
CommandDb.h

#ifndef __COMMAND_DB_H__
#define __COMMAND_DB_H__
#include <string>
#include "json/json.h"
#include "TsManager.h"
//#include "Task.h"

using namespace std;


typedef enum{
        DocTask = 0,
        VideoTask,
        DpptTask,
        NoTsTask
}TaskType;

class Command
{
protected:
        string m_commandName;
        TsProperty m_tsProperty;
        bool m_isUseTs;
        TsType m_tsType;
        TaskType m_taskType;
        bool m_isProvidedResult;
        string m_tsResultName;
public:
        Command();
        virtual ~Command();

        string GetCommansName(){ return m_commandName;}
        bool IsProvidedResult(){return m_isProvidedResult;}
        TsType GetTsType(){return m_tsType;}
        TaskType GetTaskType(){return m_taskType;}
        string GetTaskResultName(){return m_tsResultName;};
       
        virtual bool BuildTsCmd(const Json::Value& appCmd,Json::Value& tsCmd);
        virtual bool BuildTsResponse(const Json::Value& tsResult,Json::Value& tsResponse);
       
        virtual bool BuildAppResult(const Json::Value& tsResult,Json::Value& appResult);
        virtual bool BuildAppResult(ErrorInfo info,Json::Value& appResult);
        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail) = 0;
};


///////////////////////////////// specific command //////////////////////////////////////
class CommandServerStatus : public Command
{
public:
        CommandServerStatus()
        {
                m_commandName = "server_status_task";
                m_isUseTs = false;
                m_taskType = NoTsTask;
                m_isProvidedResult = true;
        }
       
        ~CommandServerStatus();
        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);
        virtual bool BuildAppResult(const Json::Value& appCmd,Json::Value& appResult);

};


class CommandVideoMessage : public Command
{
public:
        CommandVideoMessage()
        {
                m_commandName = "video_message_task";
                m_isUseTs = true;
                m_tsType = TS_VIDEO;
                m_tsProperty = TS_LIGHT;
                m_taskType = VideoTask;
                m_isProvidedResult = true;
                m_tsResultName = "Message";
        }

        ~CommandVideoMessage(){}

        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};


class CommandVideoTrans : public Command
{
public:
        CommandVideoTrans()
        {
                m_commandName = "video_trans_task";
                m_isUseTs = true;
                m_tsType = TS_VIDEO;
                m_tsProperty = TS_HEAVY;
                m_taskType = VideoTask;
                m_isProvidedResult = true;
                m_tsResultName = "Transfer";
        }

        ~CommandVideoTrans(){}

        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);
};

class CommandPrintScreen : public Command
{
public:
        CommandPrintScreen()
        {
                m_commandName = "print_screen_task";
                m_isUseTs = true;
                m_tsType = TS_VIDEO;
                m_tsProperty = TS_LIGHT;
                m_taskType = VideoTask;
                m_isProvidedResult = true;
                m_tsResultName = "CapVideo";
        }
        ~CommandPrintScreen(){}

        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};

class CommandVideoCut : public Command
{
public:
        CommandVideoCut()
        {
                m_commandName = "video_cut_task";
                m_isUseTs = true;
                m_tsType = TS_VIDEO;
                m_tsProperty = TS_LIGHT;
                m_taskType = VideoTask;
                m_isProvidedResult = true;
                m_tsResultName = "VideoCut";
        }

        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};

class CommandVideoMerge : public Command
{
public:
        CommandVideoMerge()
        {
                m_commandName = "video_merge_task";
                m_isUseTs = true;
                m_tsType = TS_VIDEO;
                m_tsProperty = TS_HEAVY;
                m_taskType = VideoTask;
                m_isProvidedResult = true;
                m_tsResultName = "VideoMerge";
        }

        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};


class CommandDocTrans : public Command
{
public:
        CommandDocTrans()
        {
                m_commandName = "doc_trans_task";
                m_isUseTs = true;
                m_taskType = DocTask;
                m_isProvidedResult = true;
               
        }
        static bool GetServerTypes(vector<string>& CommandNames)
        {
                CommandNames.push_back("DOC_WPS");
                CommandNames.push_back("DOC_OFFICE");
                CommandNames.push_back("DOC_LINUX");
        }
        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};


class CommandDynamicPptTrans : public Command
{
public:
        CommandDynamicPptTrans()
        {
                m_commandName = "dynamic_ppt_trans_task";
                m_isUseTs = true;
                m_tsType = TS_DYNAMIC_PPT;
                m_taskType = DpptTask;
                m_isProvidedResult = true;
        }
        static void GetServerTypes(vector<string>& CommandNames)
        {
                CommandNames.push_back("DYNAMIC_PPT");
        }
        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};

class CommandTaskProgress : public Command
{
public:
        CommandTaskProgress()
        {
                m_commandName = "task_progress_request";
                m_isUseTs = false;
                m_taskType = NoTsTask;
                m_isProvidedResult = true;
        }

        virtual bool  BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail);

};

/////////////////////////////////  CommandDb  ///////////////////////////////////////

class CommandDb
{
        CommandDb();
public:
        static CommandDb& GetInstance()
        {
                static CommandDb instance_;
                return instance_;
        }
        ~CommandDb();
        bool AddCommand(Command* cmd);
        bool GetCommandNameInSpecificTaskType(TaskType taskType,vector<string>& CommandNames);
        bool GetResultNameInSpecificTaskType(TaskType taskType,vector<string>& CommandNames);
        Command* GetCommand(string cmdName);
private:
        map<string,Command*> m_commands;
};
#endif

使用特权

评论回复
5
keer_zu|  楼主 | 2016-6-8 11:37 | 只看该作者
CommandDb.cpp


#include "CommandDb.h"
#include "TsManager.h"

CommandServerStatus GCmdServerStatus;
CommandVideoMessage GCmdVideoMessage;
CommandVideoTrans GCmdVideoTrans;
CommandPrintScreen GCmdPrintScreen;
CommandVideoMerge GCmdVideoMerge;
CommandDocTrans GCmdDocTrans;
CommandDynamicPptTrans GCmdDynamicPptTrans;


//CommandDb GCommandDb;


////////////////////////////////////// Command //////////////////////////////////////////

Command::Command()
{

}

Command::~Command()
{

}


bool Command::BuildTsCmd(const Json::Value& appCmd,Json::Value& tsCmd)
{

        return true;
}

bool Command::BuildTsResponse(const Json::Value& tsResult,Json::Value& tsResponse)
{

        return true;
}


bool Command::BuildAppResult(ErrorInfo info,Json::Value& appResult)
{

        return true;
}

bool Command::BuildAppResult(const Json::Value& tsResult,Json::Value& appResult)
{

}


//////////////////////////////////// CommandServerStatus ///////////////////////////////////////////

//CommandServerStatus::CommandServerStatus()


CommandServerStatus::~CommandServerStatus()
{

}

bool  CommandServerStatus::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}

bool CommandServerStatus::BuildAppResult(const Json::Value& appCmd,Json::Value& appResult)
{

        return true;
}

////////////////////////////////////// CommandVideoMessage //////////////////////////////////////
bool  CommandVideoMessage::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}
////////////////////////////////////// CommandVideoTrans ///////////////////////////////////////
bool  CommandVideoTrans::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}

///////////////////////////////////// CommandPrintScreen ///////////////////////////////////////
bool CommandPrintScreen::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}

///////////////////////////////////// CommandVideoCut /////////////////////////////////////////
bool CommandVideoCut::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}


///////////////////////////////////// CommandVideoMerge //////////////////////////////////////
bool CommandVideoMerge::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}


//////////////////////////////////// CommandDocTrans ////////////////////////////////////////
bool CommandDocTrans::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}

/////////////////////////////////// CommandDynamicPptTrans //////////////////////////////////
bool CommandDynamicPptTrans::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}


///////////////////////////////// CommandTaskProgress ///////////////////////////////////////
bool CommandTaskProgress::BuildAppResponse(Json::Value& appResponse,unsigned int errorCode,string ErrorDetail)
{

        return true;
}


/////////////////////////////////////// CommandDb ////////////////////////////////////////
CommandDb::CommandDb()
{
        AddCommand(&GCmdServerStatus);
        AddCommand(&GCmdVideoMessage);
        AddCommand(&GCmdVideoTrans);
        AddCommand(&GCmdPrintScreen);
        AddCommand(&GCmdVideoMerge);
        AddCommand(&GCmdDocTrans);
        AddCommand(&GCmdDynamicPptTrans);
}

CommandDb::~CommandDb()
{

}


bool CommandDb::AddCommand(Command* cmd)
{
        m_commands[cmd->GetCommansName()] = cmd;
        return true;
}


bool CommandDb::GetCommandNameInSpecificTaskType(TaskType taskType,vector<string>& CommandNames)
{
        map<string,Command *>::iterator it;
       
        for(it=m_commands.begin();it!=m_commands.end();++it){
                if(it->second->GetTaskType() == taskType)
                        CommandNames.push_back(it->first);
        }

        return true;
}

bool CommandDb::GetResultNameInSpecificTaskType(TaskType taskType,vector<string>& CommandNames)
{
        map<string,Command *>::iterator it;

        if(taskType == NoTsTask){
               
                return false;
        }

        if(taskType == DpptTask){
                CommandDocTrans::GetServerTypes(CommandNames);
                return true;
        }

        if(taskType == DocTask){
                CommandDynamicPptTrans::GetServerTypes(CommandNames);
                return true;
        }
       
        for(it=m_commands.begin();it!=m_commands.end();++it){
                if(it->second->GetTaskType() == taskType)
                        CommandNames.push_back(it->second->GetTaskResultName());
        }

        return true;
}

Command* CommandDb::GetCommand(string cmdName)
{
        if(m_commands.find(cmdName) != m_commands.end()){
                return m_commands[cmdName];
        } else {
                return NULL;
        }
}

使用特权

评论回复
6
keer_zu|  楼主 | 2016-6-8 11:38 | 只看该作者
#ifndef __DISPTACHER_H__
#define __DISPTACHER_H__

#include <stdio.h>
#include <iostream>
#include <string>
#include <vector>
#include "json/json.h"
//#include "InterfaceApi.h"
#include "TsQueue.h"
#include "TaskQueue.h"


class Disptacher {
public:
        Disptacher(){}

        bool DuplicateTaskCheck(string id)
        {
                return !(m_taskRunQueue->CheckSameTaskId(id) || m_taskWaitQueue->CheckSameTaskId(id));
        }

        virtual bool Submit(Task *task) = 0;

protected:
        TaskWaitQueue* m_taskWaitQueue;
        TaskRunQueue* m_taskRunQueue;
        map<string,TsQueue*>m_tsQueues;
        //vector<string> m_commandNames;

};

class DocDisptacher : public Disptacher
{
        map<int,string> m_tsPriority;
        DocDisptacher();
public:
        static DocDisptacher& GetInstance();
        virtual bool Submit(Task *task);

        bool GetDocTsPriority();
};

class VideoDisptacher : public Disptacher
{
        VideoDisptacher();
public:
        static VideoDisptacher& GetInstance();
        virtual bool Submit(Task *task);
};

class DpptDisptacher : public Disptacher
{
        DpptDisptacher();
public:
        static DpptDisptacher& GetInstance();
        virtual bool Submit(Task *task);
};

#endif


Disptacher.h

使用特权

评论回复
7
keer_zu|  楼主 | 2016-6-8 11:39 | 只看该作者
Disptacher.cpp


#include "Disptacher.h"
#include "AddTask.h"
//#include "TsManager.h"
//#include "CommandDb.h"
#include "error.h"
#include "Log4cxxWrapper.h"
#include <algorithm>
#include <memory>
#include "ConfigManager.h"

#include "CommandDb.h"



//using namespace std;
using namespace cdy;


extern TaskWaitQueue GDocTaskWaitQueue;
extern TaskWaitQueue GVideoTaskWaitQueue;
extern TaskWaitQueue GDpptTaskWaitQueue;
extern TaskWaitQueue GNoTsTaskTaskWaitQueue;


extern TaskRunQueue GDocTaskRunQueue;
extern TaskRunQueue GVideoTaskRunQueue;
extern TaskRunQueue GDpptTaskRunQueue;
extern TaskRunQueue GNoTsTaskRunQueue;

extern TsQueue GVideoTsQueue;
extern TsQueue GDocOpenofficeTsQueue;
extern TsQueue GDocWpsTsQueue;
extern TsQueue GDocOfficeTsQueue;
extern TsQueue GDpptTsQueue;



string ToUpperString(string str)  
{  
        string tmpstr= str;
        transform(tmpstr.begin(), tmpstr.end(), tmpstr.begin(), (int (*)(int))toupper);  
        return tmpstr;
}  
string ToLowerString(string str)  
{  
        string tmpstr= str;
        transform(tmpstr.begin(), tmpstr.end(), tmpstr.begin(), (int (*)(int))tolower);  
        return tmpstr;
}


bool CheckNoSameName(map<int,string>& mp, int count)
{
        for(int i=0;i<count-1;i++){
                for(int j=i+1;j<count;j++){
                        if(mp[i] == mp[j]){
                                return false;
                        }
                }
        }
        return true;
}


//////////////////////////////// Disptacher //////////////////////////////////




//////////////////////////////// DocDisptacher ///////////////////////////////

DocDisptacher::DocDisptacher()
{
        m_taskWaitQueue = &GDocTaskWaitQueue;
        m_taskRunQueue = &GDocTaskRunQueue;

        GetDocTsPriority();
       
        m_tsQueues["linux"] = &GDocOpenofficeTsQueue;
        m_tsQueues["wps"] = &GDocWpsTsQueue;
        m_tsQueues["office"] = &GDocOfficeTsQueue;

        GetDocTsPriority();
}

DocDisptacher& DocDisptacher::GetInstance()
{
        static DocDisptacher instance_;
        return instance_;
}

bool DocDisptacher::Submit(Task *task)
{
        TsQueue* tsq;
        TransServer* ts = NULL;
        int i;
        Json::Value tsCmd;
        Json::Value appResponse;
        LoggerWrapper dsLog= LoggerWrapper::GetInstance();
        Command* cmd;
        bool ret;
/*
        if(task->m_triedTimes >= task->m_maxTryTimes){
                cmd = task->GetCommand();
               
                ret = cmd->BuildAppResponse(appResponse,errorCode, string ErrorDetail);
        }
*/       
        for(i = 0;i < m_tsPriority.size();i ++){
                tsq = m_tsQueues[m_tsPriority[0]];
                ts = tsq->GetTsIdle();
                if(ts){
                        task->m_alreadyTriedTsType.push_back(i);
                        task->m_alreadyTriedTsId.push_back(ts->GetId());

                        break;
                }
        }

        if(ts){
                Command* cmd = task->GetCommand();
                if(!cmd->BuildTsCmd(task->GetCmdValue(),tsCmd)){
                        dsLog.Log(true,LOGGER_ERROR,"build doc ts cmd error !!!!!, [%s][%s][%d]\n",__FILE__,__PRETTY_FUNCTION__,__LINE__);
                        return false;
                }

                ts->SetTask(task);

                string tsMsg = tsCmd.toStyledString() + '\0';
                TsSession* session = ts->GetSession();
                session->SendMessage(tsMsg);
                task->m_triedTimes += 1;
                m_taskRunQueue->PushTask(task,session);
               
        } else {
                m_taskWaitQueue->PushTask(task);
        }
}

#define MAX_DOCUMENT_SEVER_TYPE_NUM 3
bool DocDisptacher::GetDocTsPriority()
{
        Json::Value  value;  
        std::auto_ptr<Json::Reader> pJsonParser(new Json::Reader(Json::Features::strictMode()));

        LoggerWrapper dsLog= LoggerWrapper::GetInstance();

        string strTsPriority = "\"TsPriority\":" + ConfigManager::GetTsPriority();
        string strWholeJson = "{"+strTsPriority+"}";
        //string strPriorityArray[MAX_DOCUMENT_SEVER_TYPE_NUM];

        map<string,TsQueue*> tsQueue;
       
        if(pJsonParser->parse(strWholeJson,value)){
                const Json::Value TsPriority = value["TsPriority"];

                if((!value["TsPriority"].isNull()) && (value["TsPriority"].isArray()) && (MAX_DOCUMENT_SEVER_TYPE_NUM == TsPriority.size()) ){
                        for (unsigned int i = 0; i < TsPriority.size(); i++){
                                if(TsPriority[i].isString()){
                                        if(( "LINUX" == ToUpperString(TsPriority[i].asString()))||( "OFFICE" == ToUpperString(TsPriority[i].asString()))||( "WPS" == ToUpperString(TsPriority[i].asString()))){
                                                m_tsPriority[i] = TsPriority[i].asString();
                                               
                                        } else {
                                                dsLog.Log(true,LOGGER_ERROR,"error config file. Invalid TsPriority format  . :%s , [%s][%s][%d]\n",strTsPriority.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);               
                                                return false;
                                        }
                                } else {
                                        dsLog.Log(true,LOGGER_ERROR,"error config file. Invalid TsPriority format  . :%s , [%s][%s][%d]\n",strTsPriority.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);               
                                        return false;            
                                }
                        }
                        if(!CheckNoSameName(m_tsPriority,MAX_DOCUMENT_SEVER_TYPE_NUM)){
                                dsLog.Log(true,LOGGER_ERROR,"error config file. Invalid TsPriority format  . :%s , [%s][%s][%d]\n",strTsPriority.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);               
                                return false;               
                        }
                } else{
  
                        dsLog.Log(true,LOGGER_ERROR,"error config file. Invalid TsPriority format . :%s , [%s][%s][%d]\n",strTsPriority.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);               
                        return false;            
                }

        } else{
                dsLog.Log(true,LOGGER_ERROR,"error config file. Invalid TsPriority format  . :%s , [%s][%s][%d]\n",strTsPriority.c_str(),__FILE__,__PRETTY_FUNCTION__,__LINE__);               
                return false;            
        }   

        return true;

}

///////////////////////////////// VideoDisptacher /////////////////////////////

VideoDisptacher::VideoDisptacher()
{
        m_taskWaitQueue = &GVideoTaskWaitQueue;
        m_taskRunQueue = &GVideoTaskRunQueue;
        m_tsQueues["Video1"] = &GVideoTsQueue;
}

VideoDisptacher& VideoDisptacher::GetInstance()
{
        static VideoDisptacher instance_;
        return instance_;
}

bool VideoDisptacher::Submit(Task *task)
{
        TsQueue* tsq;
        TransServer* ts = NULL;
        Json::Value tsCmd;
        LoggerWrapper dsLog= LoggerWrapper::GetInstance();
       

        tsq = m_tsQueues["Video1"];
        ts = tsq->GetTsIdle();
        if(ts){
                task->m_alreadyTriedTsId.push_back(ts->GetId());

                Command* cmd = task->GetCommand();
                if(!cmd->BuildTsCmd(task->GetCmdValue(),tsCmd)){
                        dsLog.Log(true,LOGGER_ERROR,"build doc ts cmd error !!!!!, [%s][%s][%d]\n",__FILE__,__PRETTY_FUNCTION__,__LINE__);
                        return false;
                }

                string tsMsg = tsCmd.toStyledString() + '\0';
                TsSession* session = ts->GetSession();
                session->SendMessage(tsMsg);
                task->m_triedTimes += 1;
                m_taskRunQueue->PushTask(task,session);
        } else {
                m_taskWaitQueue->PushTask(task);
        }

}

//////////////////////////////// DpptDisptacher ///////////////////////////////

DpptDisptacher::DpptDisptacher()
{
        m_taskWaitQueue = &GDpptTaskWaitQueue;
        m_taskRunQueue = &GDpptTaskRunQueue;
        m_tsQueues["Dppt1"] = &GDpptTsQueue;
}


DpptDisptacher& DpptDisptacher::GetInstance()
{
        static DpptDisptacher instance_;
        return instance_;
}


bool DpptDisptacher::Submit(Task *task)
{
        TsQueue* tsq;
        TransServer* ts = NULL;
        Json::Value tsCmd;
        LoggerWrapper dsLog= LoggerWrapper::GetInstance();
       

        tsq = m_tsQueues["Dppt1"];
        ts = tsq->GetTsIdle();
        if(ts){
                task->m_alreadyTriedTsId.push_back(ts->GetId());

                Command* cmd = task->GetCommand();
                if(!cmd->BuildTsCmd(task->GetCmdValue(),tsCmd)){
                        dsLog.Log(true,LOGGER_ERROR,"build doc ts cmd error !!!!!, [%s][%s][%d]\n",__FILE__,__PRETTY_FUNCTION__,__LINE__);
                        return false;
                }

                string tsMsg = tsCmd.toStyledString() + '\0';
                TsSession* session = ts->GetSession();
                session->SendMessage(tsMsg);
                task->m_triedTimes += 1;
                m_taskRunQueue->PushTask(task,session);
        } else {
                m_taskWaitQueue->PushTask(task);
        }
}

使用特权

评论回复
8
keer_zu|  楼主 | 2016-6-8 11:40 | 只看该作者
Message.h



#ifndef __MESSAGE_H__
#define __MESSAGE_H__

#include "InterfaceApi.h"
#include "AddTask.h"
#include "TaskResult.h"
//#include "TsInterface.h"

typedef enum{
        TsRegistMsg = 0,
        TsResultMsg,
        TsUpdateMsg,
        TsLinkResponse
}TsMsgType;


class Message
{
public:
        Message(){}
        virtual ~Message(){}
};

class AppMessage : public Message
{
public:
       
};

class TsMessage : public Message
{
protected:
        string m_type;
        TsMsgType m_tsMsgType;
        string m_serverType;
public:
        virtual ~TsMessage(){}
        TsMessage(){}
        TsMsgType GetTsMsgType(){return m_tsMsgType;}

        string GetServerType(){return m_serverType;}
       
};


class TsResultMessage : public TsMessage
{

public:
        TsResultMessage(string serverType)
        {
                m_type = "TransResult";
                m_tsMsgType = TsUpdateMsg;
                m_serverType = serverType;
        }
public:
        //string m_serverType;
};

class TsRegistMessage : public TsMessage
{

public:
        TsRegistMessage(string serverType)
        {
                m_type = "SvrRegister";
                m_tsMsgType = TsRegistMsg;
                m_serverType = serverType;
        }

        bool BuildResponse(int errCode,const string& errorDetial,string& response);
};



class TsUpdateMessage : public TsMessage
{
public:
        TsUpdateMessage(string serverType)
        {
                m_type = "TaskProgress";
                m_tsMsgType = TsUpdateMsg;
                m_serverType = serverType;
        }
};

class TsMessageDb
{
        TsMessageDb();
public:
        static TsMessageDb& GetInstance()
        {
                static TsMessageDb instance_;
                return instance_;
        }
        bool AddMessage(TsMessage *msg);
        bool GetServerTypeInSpecificType(TsMsgType msgType,vector<string>& tsMessages);
        TsMessage* GetMessage(TsMsgType msgType,string serverType);
private:
        vector<TsMessage *> m_tsMessages;
};


class TsMessageHandle
{
        TsMessageHandle* next;
public:
        TsMessageHandle(){}
        bool IsThisMsg(string type)
        {
                if(type == m_type)
                        return true;
                else
                        return false;
        }
        void setNext(TsMessageHandle *n)
        {
                next = n;
        }
        void add(TsMessageHandle *n)
        {
                if (next)
                        next->add(n);
                else
                        next = n;
        }
        virtual void SpacificHandle(Json::Value& value,TsSession* tsSession)
        {
                if(next != NULL)
                        next->SpacificHandle(value,tsSession);
                else {   // this command does not exist;
                        printf("error");
                        // TODO: log
                }
        }
protected:
        string m_type;
};

class TsRegistMessageHandle : public TsMessageHandle
{
        ITsRegister* m_register;
       

        TsRegistMessageHandle(ITsRegister* reg)
        {
                m_register = reg;
                m_type = "SvrRegister";
        }
public:
        virtual void SpacificHandle(Json::Value& value,TsSession* tsSession);
        static TsRegistMessageHandle& GetInstance(ITsRegister* reg)
        {
                static  TsRegistMessageHandle instance_(reg);
                return instance_;        
        }
};

class TsResultMessageHandle : public TsMessageHandle
{
        //ITaskResult* m_taskResult;
        TaskResult* m_taskResult;
        TsResultMessageHandle(/*ITaskResult* tr*/)
        {
                //m_taskResult = tr;
                m_type = "TransResult";
                m_taskResult = &DocTaskResult::GetInstance();

                VideoTaskResult &videoTaskResult = VideoTaskResult::GetInstance();
                DpptTaskResult &dpptTaskResult = DpptTaskResult::GetInstance();

                m_taskResult->add(&videoTaskResult);
                m_taskResult->add(&dpptTaskResult);
        }
public:
        virtual void SpacificHandle(Json::Value& value,TsSession* tsSession);
        static TsResultMessageHandle& GetInstance()
        {
                static  TsResultMessageHandle instance_;
                return instance_;        
        }
};

class TsUpdateMessageHandle : public TsMessageHandle
{
        ITsUpdateInfo* m_updataInfo;
        TsUpdateMessageHandle(ITsUpdateInfo* ui):m_updataInfo(ui)
                {m_type = "TaskProgress";}
public:
        virtual void SpacificHandle(Json::Value& value,TsSession* tsSession);
        static TsUpdateMessageHandle& GetInstance(ITsUpdateInfo* ui)
        {
                static  TsUpdateMessageHandle instance_(ui);
                return instance_;        
        }
};

class MessageAnalyzer
{
public:
       
};

class TsMessageAnalyzer : public MessageAnalyzer,public ITsNewFrame
{
        TsMessageAnalyzer();
        //TaskResult* m_taskResult;
        TsMessageHandle* m_messageHandle;
public:
        ~TsMessageAnalyzer();
        static TsMessageAnalyzer& GetInstance();
        virtual void OnNewFrame(TsSession* tsServerSion,const string frame);
};

class AppMessageAnalyzer : public MessageAnalyzer,public IAppNewFrame
{
        AppMessageAnalyzer();
        AddTask* m_addTask;
public:
        ~AppMessageAnalyzer();
        static AppMessageAnalyzer& GetInstance();
        virtual void OnNewFrame(AppServerSession *appServerSion,string frame);
};


class testITsRegister : public ITsRegister
{
public:
        virtual void OnRegister(Json::Value& value,TsSession *session){}
};

#endif

使用特权

评论回复
9
keer_zu|  楼主 | 2016-6-8 11:41 | 只看该作者
Message.cpp



#include "Message.h"
#include <memory>.
#include "json/json.h"
#include "Log4cxxWrapper.h"
#include "TsManager.h"

using namespace std;

TsResultMessage  tsDpptResult("DYNAMIC_PPT");
TsResultMessage  tsDocWindowsResult("DOC_WINDOWS");
TsResultMessage  tsDocResult("DOC");
TsResultMessage  tsDocWpsResult("DOC_WPS");
TsResultMessage  tsTransferResult("Transfer");
TsResultMessage  tsVideoCutResult("VideoCut");
TsResultMessage  tsVideoMergeResult("VideoMerge");
TsResultMessage  tsCapVideoResult("CapVideo");
TsResultMessage  tsMessageResult("Message");
TsRegistMessage  tsRegistMessage("");
//TsLinkResponseMessage tsLinkResponseMessage("");
TsUpdateMessage tsUpdateMessage("");

//////////////////////////////// TsRegistMessage /////////////////////////////////////////

bool TsRegistMessage::BuildResponse(int errCode,const string& errorDetial,string& response)
{

        return true;
}

TsMessageDb::TsMessageDb()
{
        AddMessage(&tsDpptResult);
        AddMessage(&tsDocWindowsResult);
        AddMessage(&tsDocResult);
        AddMessage(&tsDocWpsResult);
        AddMessage(&tsTransferResult);
        AddMessage(&tsVideoCutResult);
        AddMessage(&tsVideoMergeResult);
        AddMessage(&tsCapVideoResult);
        AddMessage(&tsMessageResult);
        AddMessage(&tsRegistMessage);
//        AddMessage(&tsLinkResponseMessage);
        AddMessage(&tsUpdateMessage);
}

bool TsMessageDb::AddMessage(TsMessage * msg)
{
        m_tsMessages.push_back(msg);
        return true;
}

bool TsMessageDb::GetServerTypeInSpecificType(TsMsgType msgType, vector < string > & tsMessages)
{
        vector<TsMessage *>::iterator t ;
        for(t=m_tsMessages.begin(); t!=m_tsMessages.end(); t++){
                if((*t)->GetTsMsgType() == msgType)
                        tsMessages.push_back((*t)->GetServerType());
        }
       
        return true;
}

TsMessage* TsMessageDb::GetMessage(TsMsgType msgType, string serverType)
{
        TsMessage* message = NULL;
        vector<TsMessage *>::iterator t ;
        for(t=m_tsMessages.begin(); t!=m_tsMessages.end(); t++){
                if((*t)->GetTsMsgType() == msgType && (*t)->GetServerType() == serverType){
                        message = *t;
                        break;
                }
        }
       
        return message;
}
//////////////////////////////// TsRegistMessageHandle /////////////////////////////

void TsRegistMessageHandle::SpacificHandle(Json::Value& value,TsSession* tsSession)
{
        if(IsThisMsg(value["type"].asString())){
                if(m_register != NULL){
                        m_register->OnRegister(value, tsSession);
                }
        } else {
                TsMessageHandle::SpacificHandle(value,tsSession);
        }
}


//////////////////////////////// TsResultMessageHandle /////////////////////////////////
void TsResultMessageHandle::SpacificHandle(Json::Value& value,TsSession* tsSession)
{
        if(IsThisMsg(value["type"].asString())){
                if((!value["servertype"].isNull()) &&  (value["servertype"].isString())){
                        m_taskResult->SpacificTaskResult(value,tsSession);
                } else {

                }
        } else {
                TsMessageHandle::SpacificHandle(value,tsSession);
        }
}

////////////////////////////// TsUpdateMessageHandle //////////////////////////////////
void TsUpdateMessageHandle::SpacificHandle(Json::Value& value,TsSession* tsSession)
{
        if(IsThisMsg(value["type"].asString())){
                if(m_updataInfo!= NULL){
                        m_updataInfo->OnUpdateInfo(value, tsSession);
                }
        } else {
                TsMessageHandle::SpacificHandle(value,tsSession);
        }
}

////////////////////////////////  TsMessageAnalyzer  ///////////////////////////////
//class TsRegister;
TsRegister testITR;

TsMessageAnalyzer::TsMessageAnalyzer()
{

        m_messageHandle = &TsRegistMessageHandle::GetInstance(&testITR);

        TsResultMessageHandle& resultHandle = TsResultMessageHandle::GetInstance();
        TsUpdateMessageHandle& updateHandle = TsUpdateMessageHandle::GetInstance(NULL);

        m_messageHandle->add(&resultHandle);
        m_messageHandle->add(&updateHandle);
       
}

TsMessageAnalyzer::~TsMessageAnalyzer()
{

}

TsMessageAnalyzer& TsMessageAnalyzer::GetInstance()
{
        static  TsMessageAnalyzer instance_;
        return instance_;
}

void  TsMessageAnalyzer::OnNewFrame(TsSession* tsServerSion,const string frame)
{
        Json::Value  value;  
        LoggerWrapper dsLog= LoggerWrapper::GetInstance();

        if(tsServerSion == NULL){

                return;
        }

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

        if(pJsonParser->parse(frame,value)){
                if((!value["type"].isNull()) &&  (value["type"].isString())){
                        m_messageHandle->SpacificHandle( value, tsServerSion);
                } else {
                       
                }
        }
}

////////////////////////////////  AppMessageAnalyzer  //////////////////////////////

AppMessageAnalyzer::AppMessageAnalyzer()
{
        m_addTask = &AddDocTask::GetInstance();
        AddVideoTask &addVideoTask = AddVideoTask::GetInstance();
        AddDpptTask &addDpptTask = AddDpptTask::GetInstance();
        AddNoUseTsTask &addNoUseTsTask = AddNoUseTsTask::GetInstance();
       

        m_addTask->add(&addVideoTask);
        m_addTask->add(&addDpptTask);
        m_addTask->add(&addNoUseTsTask);
       
}

AppMessageAnalyzer::~AppMessageAnalyzer()
{

}

AppMessageAnalyzer& AppMessageAnalyzer::GetInstance()
{
        static  AppMessageAnalyzer instance_;
        return instance_;
}

void AppMessageAnalyzer::OnNewFrame(AppServerSession *appServerSion,string frame)
{
        Json::Value  value;  
        LoggerWrapper dsLog= LoggerWrapper::GetInstance();

        if(appServerSion == NULL){

                return;
        }

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

        if(pJsonParser->parse(frame,value)){
                if((!value["command"].isNull()) &&  (value["command"].isString())){
                        m_addTask->AddSpacificTask(value,appServerSion);
                }
        }
       
}



使用特权

评论回复
10
keer_zu|  楼主 | 2016-6-8 11:41 | 只看该作者
Task.h



#ifndef __TASK_H__
#define __TASK_H__
#include <string>
#include <list>
#include "json/json.h"
#include <vector>
//#include "CommandDb.h"


using namespace std;

class Command;
class TransServer;
class Disptacher;
class TsSession;

typedef enum
{
        TASK_HEAVY = 0,
        TASK_LIGHT = 1
}TaskProperty;



typedef struct
{

}ErrorInfo;


class Task
{
private:

protected:
        string m_taskId;
        bool m_isUseTs;
        unsigned int m_taskPriority;
       
        Json::Value m_cmdValue;
       
        Command* m_command;
        TransServer* m_transServer;
        Disptacher* m_disptacher;

        int m_progress;
       
public:
        vector<int> m_alreadyTriedTsType;
        vector<string> m_alreadyTriedTsId;

        int m_triedTimes;
        string m_appTargetIp;
        unsigned int m_appTargetPort;

        int m_maxTryTimes;
        TsSession* m_tsSession;
public:
        virtual ~Task(){}
        Task()
        {
                m_command = NULL;
                m_transServer = NULL;
        }

        void Init()
        {
                m_triedTimes = 0;
        }

        void Release()
        {
                m_alreadyTriedTsType.clear();
                vector<int>(m_alreadyTriedTsType).swap(m_alreadyTriedTsType);

                m_alreadyTriedTsId.clear();
                vector<string>(m_alreadyTriedTsId).swap(m_alreadyTriedTsId);
        }
       
        unsigned int GetPriority()
        {
                return m_taskPriority;
        }

        void SetDisptacher(Disptacher* disp)
        {
                m_disptacher = disp;
        }

        void SetProgress(int progress)
        {
                m_progress = progress;
        }

        int GetProgress()
        {
                return m_progress;
        }

        void SetPriority(unsigned int priority)
        {
                m_taskPriority = priority;
        }

        string GetTaskId()
        {
                return m_taskId;
        }

        void SetTaskId(string id)
        {
                m_taskId = id;
        }

        void SetCmdValue(Json::Value& value)
        {
                m_cmdValue = value;
        }

        Json::Value& GetCmdValue()
        {
                return m_cmdValue;
        }

        Command* GetCommand()
        {
                return m_command;
        }

        void SetCommand(Command* cmd)
        {
                m_command = cmd;
        }

        bool IsExceedMaxTryTimes()
        {
                return (this->m_triedTimes >= this->m_maxTryTimes);
        }

        void ResultReport(Json::Value& value);
};

class TaskDocument : public Task
{
public:
        TaskDocument();
        TaskDocument(string taskId,unsigned int priority){m_taskId = taskId;m_taskPriority = priority;}

        void SetIsSpecific(bool is){m_isSpecificTsType = is;}
        bool GetIsSpecific(){return m_isSpecificTsType;}
private:
        bool m_isSpecificTsType;
};

class TaskVideo : public Task
{
public:
        TaskVideo();
        TaskVideo(string taskId,unsigned int priority){m_taskId = taskId;m_taskPriority = priority;}
};

class TaskDppt : public Task
{
public:
        TaskDppt();
        TaskDppt(string taskId,unsigned int priority){m_taskId = taskId;m_taskPriority = priority;}
};

class TaskNoUseTs : public Task
{
public:
        TaskNoUseTs(){}
        TaskNoUseTs(string taskId,unsigned int priority){m_taskId = taskId;m_taskPriority = priority;}
};



class TaskCmp
{
public:
        bool operator()(Task* a,Task* b)
        {
                if(a->GetPriority() < b->GetPriority())
                        return true;
                else if(a->GetPriority() == b->GetPriority())
                        return a > b;
                else
                        return false;
        }

};

class TaskDb
{
public:
        virtual Task* GetTask() = 0;

        void GiveBackTask(Task *task)
        {
                task->Release();
                m_taskBuf.push_back(task);
        }
protected:
        list<Task*> m_taskBuf;
};

class TaskVideoDb : public TaskDb
{
public:
        virtual Task* GetTask()
        {
                if(!m_taskBuf.empty())
                        return m_taskBuf.front();
                else
                        return new TaskVideo;
        }
};

class TaskDocumentDb : public TaskDb
{
public:
        virtual Task* GetTask()
        {
                if(!m_taskBuf.empty())
                        return m_taskBuf.front();
                else
                        return new TaskDocument;
        }
};

class TaskDpptDb : public TaskDb
{
public:
        virtual Task* GetTask()
        {
                if(!m_taskBuf.empty())
                        return m_taskBuf.front();
                else
                        return new TaskDppt;
        }
};


class TaskNoUseTsDb : public TaskDb
{
public:
        virtual Task* GetTask()
        {
                if(!m_taskBuf.empty())
                        return m_taskBuf.front();
                else
                        return new TaskNoUseTs;
        }
};



#endif

使用特权

评论回复
11
keer_zu|  楼主 | 2016-6-8 11:42 | 只看该作者
Task.cpp


#include "Task.h"
#include "CommandDb.h"
/////////////////////////// Task /////////////////////////////
void Task::ResultReport(Json::Value& value)
{
        Json::Value appResult;
        string result;
        Command* cmd;
        bool ret;
       


        cmd = this->GetCommand();
       
        ret = cmd->BuildAppResult(value,appResult);
        if(ret){
                result = appResult.toStyledString();
                SessionManager::GetInstance().SendAppMessage(this->m_appTargetIp,this->m_appTargetPort,result,this);
        } else {

        }


}


///////////////////////// TaskDocument ///////////////////////
TaskDocument::TaskDocument()
{
        m_maxTryTimes = 3;
}


///////////////////////// TaskVideo ///////////////////////
TaskVideo::TaskVideo()
{
        m_maxTryTimes = 3;
}



///////////////////////// TaskDppt ///////////////////////
TaskDppt::TaskDppt()
{
        m_maxTryTimes = 3;
}

使用特权

评论回复
12
keer_zu|  楼主 | 2016-6-8 11:44 | 只看该作者
TaskQueue.h


#ifndef __TASK_QUEUE_H__
#define __TASK_QUEUE_H__
#include <queue>  
#include <list>
#include "Task.h"

typedef priority_queue<Task*,vector<Task*>,TaskCmp> TaskPriorityQueue;



class TaskWaitQueue
{
public:
        Task* PopTask();

        Task* GetTaskInSpecId(string taskId);
       
        bool PushTask(Task *task);

        bool CheckSameTaskId(string TaskId);
private:
        TaskPriorityQueue m_queue;
};


class TaskRunQueue
{
public:
        bool PushTask(Task *task,TsSession *session);
        Task* GetTaskInSpecId(string taskId);
        Task* GetTaskInSession(TsSession* session);
        bool DelTask(string taskId);
        bool CheckSameTaskId(string TaskId);
private:
        list<Task *> m_taskList;
};



#endif

使用特权

评论回复
13
keer_zu|  楼主 | 2016-6-8 11:44 | 只看该作者
TaskQueue.cpp



#include "TaskQueue.h"
#include <vector>
#include <iostream>

using namespace std;

TaskWaitQueue GDocTaskWaitQueue;
TaskWaitQueue GVideoTaskWaitQueue;
TaskWaitQueue GDpptTaskWaitQueue;
TaskWaitQueue GNoTsTaskTaskWaitQueue;


TaskRunQueue GDocTaskRunQueue;
TaskRunQueue GVideoTaskRunQueue;
TaskRunQueue GDpptTaskRunQueue;
TaskRunQueue GNoTsTaskRunQueue;

TaskDocumentDb GTaskDocumentDb;
TaskVideoDb GTaskVideoDb;
TaskDpptDb GTaskDpptDb;
TaskNoUseTsDb GTaskNoUseTsDb;


Task* TaskWaitQueue::PopTask()
{
        Task* task;
        if(m_queue.empty())
                return NULL;

        task = m_queue.top( );
        m_queue.pop();

        return task;
}

Task* TaskWaitQueue::GetTaskInSpecId(string taskId)
{
        int i;
        vector<Task *> *vtor = (vector<Task *> *)&m_queue;

        for( int i = 0 ; i < vtor->size(); i++ ){
                if(((Task *)(vtor->operator [](i)))->GetTaskId() == taskId)
                        return (Task *)(vtor->operator [](i));
        }

        return NULL;
}

bool TaskWaitQueue::PushTask(Task* task)
{
        task->m_tsSession = NULL;
         m_queue.push(task);

         return true;
}


bool TaskWaitQueue::CheckSameTaskId(string id)
{
        int i;
        vector<Task *> *vtor = (vector<Task *> *)&m_queue;

        for( int i = 0 ; i < vtor->size(); i++ ){
                if(((Task *)(vtor->operator [](i)))->GetTaskId() == id)
                        return true;
        }
       
        return false;
}
////////////////////////// TaskRunQueue //////////////////////////////////

bool TaskRunQueue::PushTask(Task* task,TsSession* session)
{
        task->m_tsSession = session;
        m_taskList.push_back(task);

        return true;
}

Task* TaskRunQueue::GetTaskInSpecId(string taskId)
{
        list<Task *>::iterator it;
       
        for(it = m_taskList.begin();it != m_taskList.end();it ++){
                if((*it)->GetTaskId() == taskId){
                        return (Task *)(*it);
                }
        }

        return NULL;
}

Task* TaskRunQueue::GetTaskInSession(TsSession* session)
{
        list<Task *>::iterator it;
       
        for(it = m_taskList.begin();it != m_taskList.end();it ++){
                if((*it)->m_tsSession == session){
                        return (Task *)(*it);
                }
        }

        return NULL;
}

bool TaskRunQueue::DelTask(string taskId)
{
        list<Task *>::iterator it;
        bool ret = false;

        for(it = m_taskList.begin();it != m_taskList.end();it ++){
                if((*it)->GetTaskId() == taskId){
                        (*it)->m_tsSession = NULL;
                        m_taskList.erase(it);
                        ret = true;
                }
        }

        return ret;
}

bool TaskRunQueue::CheckSameTaskId(string taskId)
{
        list<Task *>::iterator it;
        bool ret = false;

        for(it = m_taskList.begin();it != m_taskList.end();it ++){
                if((*it)->GetTaskId() == taskId){
                        ret = true;
                }
        }

        return ret;
}



使用特权

评论回复
14
keer_zu|  楼主 | 2016-6-8 11:48 | 只看该作者
TaskResult.h



#ifndef __TASK_RESULT_H__
#define __TASK_RESULT_H__

#include <iostream>
#include <string>
#include <vector>
#include "TsInterface.h"
#include "json/json.h"
#include "InterfaceApi.h"
#include "Disptacher.h"
#include "Log4cxxWrapper.h"
//#include "CommandDb.h"

class CommandDb;




class TaskResult// : public ITaskResult
{
        TaskResult *next; // 1. "next" pointer in the base class
       
protected:
        vector<string> m_resultNames;
        TaskDb *m_taskDb;
        Disptacher *m_disptacher;
        CommandDb* m_commandDb;
        TaskRunQueue* m_taskRunQueue;

public:
        TaskResult();
       
        bool IsThisTaskType(const string resultName)
        {
                vector<string>::iterator it;
               
                for (it = m_resultNames.begin(); it != m_resultNames.end(); ++ it){
                        if(resultName == *it)
                                return true;
                }

                return false;
        }


       
               
        void setNext(TaskResult *n)
        {
                next = n;
        }
        void add(TaskResult *n)
        {
                if (next)
                        next->add(n);
                else
                        next = n;
        }
        virtual void SpacificTaskResult(Json::Value& value,TsSession* tsServerSion)
        {
                if(next != NULL)
                        next->SpacificTaskResult(value,tsServerSion);
                else {   // this command does not exist;
                        printf("error");
                        // TODO: log
                }
        }

        void DoTaskRresult(Json::Value& value,TsSession* session)
        {
                Task* task;
                string errorcode;
               
                task = m_taskRunQueue->GetTaskInSession(session);
                if(!task){
                        // TODO: log
                        return;
                }
               
                errorcode = value["errorcode"].asString();
                if(atoi(errorcode.c_str()) != 0){
                        if(task->IsExceedMaxTryTimes()){
                                // TODO: log
                                task->ResultReport(value);
                                m_taskRunQueue->DelTask(task->GetTaskId());
                                m_taskDb->GiveBackTask(task);
                        } else {
                                m_disptacher->Submit(task);
                        }

                        return;
                }
               
                task->ResultReport(value);
                m_taskRunQueue->DelTask(task->GetTaskId());
                m_taskDb->GiveBackTask(task);

                return;
        }

};

class VideoTaskResult : public TaskResult
{
        VideoTaskResult();
public:

        static VideoTaskResult& GetInstance();
        virtual void SpacificTaskResult(Json::Value& value,TsSession* tsServerSion);       
};

class DocTaskResult : public TaskResult
{
        DocTaskResult();
public:

        static DocTaskResult& GetInstance();
        virtual void SpacificTaskResult(Json::Value& value,TsSession* tsServerSion);
};

class DpptTaskResult : public TaskResult
{
        DpptTaskResult();
public:

        static DpptTaskResult& GetInstance();
        virtual void SpacificTaskResult(Json::Value& value,TsSession* tsServerSion);
};




#endif

使用特权

评论回复
15
keer_zu|  楼主 | 2016-6-8 11:49 | 只看该作者
TaskResult.cpp


#include "TaskResult.h"
#include "CommandDb.h"

extern TaskVideoDb GTaskVideoDb;

extern TaskDocumentDb GTaskDocumentDb;
extern TaskDpptDb GTaskDpptDb;

extern TaskRunQueue GDocTaskRunQueue;
extern TaskRunQueue GVideoTaskRunQueue;
extern TaskRunQueue GDpptTaskRunQueue;

////////////////////////////////////// TaskResult /////////////////////////////////////////

TaskResult::TaskResult()
{
        next = NULL;
        m_commandDb = &CommandDb::GetInstance();
}


//////////////////////////////////// VideoTaskResult //////////////////////////////////////


VideoTaskResult& VideoTaskResult::GetInstance()
{
        static  VideoTaskResult instance_;
        return instance_;        
}


VideoTaskResult::VideoTaskResult()
{
        m_commandDb->GetResultNameInSpecificTaskType(VideoTask,m_resultNames);
       
        m_taskDb = &GTaskVideoDb;
        m_disptacher = &VideoDisptacher::GetInstance();
        m_taskRunQueue = &GVideoTaskRunQueue;
}

void VideoTaskResult::SpacificTaskResult(Json::Value& value,TsSession* session)
{
        if(IsThisTaskType(value["servertype"].asString())) {
               
                cout << "---  video result!" << endl;
                DoTaskRresult(value,session);
        } else {
                TaskResult::SpacificTaskResult(value,session);
        }
}


//////////////////////////////////// DocTaskResult //////////////////////////////////////


DocTaskResult& DocTaskResult::GetInstance()
{
        static  DocTaskResult instance_;
        return instance_;        
}


DocTaskResult::DocTaskResult()
{
        m_commandDb->GetResultNameInSpecificTaskType(DocTask,m_resultNames);
       
        m_taskDb = &GTaskDocumentDb;
        m_disptacher = &DocDisptacher::GetInstance();//GDocDisptacher;
        m_taskRunQueue = &GDocTaskRunQueue;
}

void DocTaskResult::SpacificTaskResult(Json::Value& value,TsSession* session)
{
        Task* task;

        if(IsThisTaskType(value["servertype"].asString())) {
               
                cout << "---  Doc result!" << endl;
                DoTaskRresult(value,session);
               
        } else {
                TaskResult::SpacificTaskResult(value,session);
        }
}

//////////////////////////////////// DpptTaskResult //////////////////////////////////////


DpptTaskResult& DpptTaskResult::GetInstance()
{
        static  DpptTaskResult instance_;
        return instance_;        
}


DpptTaskResult::DpptTaskResult()
{
        m_commandDb->GetResultNameInSpecificTaskType(DpptTask,m_resultNames);
       
        m_taskDb = &GTaskDpptDb;
        m_disptacher = &DpptDisptacher::GetInstance();//&GDpptDisptacher;
        m_taskRunQueue = &GDpptTaskRunQueue;
}

void DpptTaskResult::SpacificTaskResult(Json::Value& value,TsSession* session)
{
        Task* task;

        if(IsThisTaskType(value["servertype"].asString())) {
               
                cout << "---  Dppt result!" << endl;
                DoTaskRresult(value,session);
               
        } else {
                TaskResult::SpacificTaskResult(value,session);
        }
}

使用特权

评论回复
16
keer_zu|  楼主 | 2016-6-8 11:51 | 只看该作者
TransServer.h



#ifndef __TRANS_SERVER_H__
#define __TRANS_SERVER_H__
#include <string>
#include <list>
#include "Task.h"
using namespace std;

class TsSession;

typedef enum{
        TsIdle = 0,
        TsRunning
}TsState;

typedef enum{
        DocTrans = 0,
        VideoTrans,
        DpptTrans
}ServerType;

typedef enum{
        OpenofficeDocTrans = 0,
        WpsDocTrans,
        OfficeDocTrans
}DocTransType;


class TransServer
{
public:
        virtual ~TransServer(){}
        TransServer(){m_tsState = TsIdle;}
        string GetId()
        {
                return m_tsId;
        }

        void SetId(string& id)
        {
                m_tsId = id;
        }

        ServerType GetServerType()
        {
                return m_serverType;
        }

        TsState GetState()
        {
                return m_tsState;
        }

        void SetState(TsState state)
        {
                m_tsState = state;
        }

        void SetSession(TsSession* session)
        {
                m_session = session;
        }

        TsSession* GetSession()
        {
                return m_session;
        }

        void Release()
        {
                m_task = NULL;
                m_session = NULL;
        }

        void SetTask(Task* task)
        {
                m_task = task;
        }

        Task* GetTask()
        {
                return m_task;
        }
private:
        string m_tsId;
       
protected:
        TsSession* m_session;
        ServerType m_serverType;
        TsState m_tsState;
        Task* m_task;
};

class DocTransServer : public TransServer
{

public:
        DocTransServer(){}
        DocTransServer(string& id,DocTransType type)
        {
                SetId(id);
                m_serverType = DocTrans;
                m_docTransType = type;
        }
private:
        DocTransType m_docTransType;
};


class VideoTransServer : public TransServer
{
public:
        VideoTransServer(){}
        VideoTransServer(string& id)
        {
                SetId(id);
                m_serverType = VideoTrans;
        }
};

class DpptTransServer : public TransServer
{
public:
        DpptTransServer(){}
        DpptTransServer(string& id)
        {
                SetId(id);
                m_serverType = DpptTrans;
        }
};


class TransServerDb
{
public:
        virtual TransServer* GetTransServer() = 0;

        void GiveBackTransServer(TransServer *ts)
        {
                ts->Release();
                m_transServerBuf.push_back(ts);
        }
protected:
        list<TransServer*> m_transServerBuf;
};

class DocTransServerDb : public TransServerDb
{
        DocTransServerDb(){}
public:
        static DocTransServerDb& GetInstance()
        {
                static DocTransServerDb instance_;
                return instance_;
        }
        virtual TransServer* GetTransServer()
        {
                if(!m_transServerBuf.empty())
                        return m_transServerBuf.front();
                else
                        return new DocTransServer;               
        }
};

class VideoTransServerDb : public TransServerDb
{
        VideoTransServerDb(){}
public:
        static VideoTransServerDb& GetInstance()
        {
                static VideoTransServerDb instance_;
                return instance_;
        }
        virtual TransServer* GetTransServer()
        {
                if(!m_transServerBuf.empty())
                        return m_transServerBuf.front();
                else
                        return new VideoTransServer;               
        }
};

class DpptTransServerDb : public TransServerDb
{
        DpptTransServerDb(){}
public:
        static DpptTransServerDb& GetInstance()
        {
                static DpptTransServerDb instance_;
                return instance_;
        }
        virtual TransServer* GetTransServer()
        {
                if(!m_transServerBuf.empty())
                        return m_transServerBuf.front();
                else
                        return new DpptTransServer;               
        }
};

#endif

使用特权

评论回复
17
keer_zu|  楼主 | 2016-6-8 11:51 | 只看该作者
TransServer.cpp



#include "TransServer.h"


使用特权

评论回复
18
keer_zu|  楼主 | 2016-6-8 11:53 | 只看该作者
TsManager.h


#ifndef __TS_MANAGER_H__
#define __TS_MANAGER_H__

#include "Message.h"
#include "TsInterface.h"

typedef enum
{

        TS_DOCUMENT_LINUX = 0,

        TS_DOCUMENT_OFFICE = 1,

        TS_DOCUMENT_WPS = 2,

        TS_VIDEO = 3,

        TS_DYNAMIC_PPT =4

} TsType;


typedef enum
{
        TS_HEAVY = 0,
        TS_LIGHT = 1
}TsProperty;

class AddTransServer;

class TsRegister : public ITsRegister
{
        AddTransServer *m_addTransServer;
public:
        TsRegister();
        virtual void OnRegister(Json::Value& value,TsSession *session);
};

class AddTransServer
{
        AddTransServer *next;
protected:
        TsQueue *m_tsQueue;
        string m_serverType;

public:
        AddTransServer();
        void AddTsTransaction(Json::Value& value,TsSession*);
        void setNext(AddTransServer *n)
        {
                next = n;
        }
        void add(AddTransServer *n)
        {
                if (next)
                        next->add(n);
                else
                        next = n;
        }
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*session)
        {
                if(next != NULL)
                        next->AddSpacificTransServer(value,session);
                else {   // this command does not exist;
                        printf("error");
                        // TODO: log
                }
        }

};

class AddDocTransServer : public AddTransServer
{
public:
        AddDocTransServer();
        //static AddDocTransServer& GetInstance();
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*TsSession);
};

class AddOpenofficeTransServer : public AddDocTransServer
{
        AddOpenofficeTransServer();
public:
        static AddOpenofficeTransServer& GetInstance();
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*TsSession);
};


class AddWpsTransServer : public AddDocTransServer
{
        AddWpsTransServer();
public:
        static AddWpsTransServer& GetInstance();
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*TsSession);
};

class AddOfficeTransServer : public AddDocTransServer
{
        AddOfficeTransServer();
public:
        static AddOfficeTransServer& GetInstance();
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*TsSession);
};


class AddVideoTransServer : public AddTransServer
{
        AddVideoTransServer();
public:
        static AddVideoTransServer& GetInstance();
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*TsSession);
};


class AddDpptTransServer : public AddTransServer
{
        AddDpptTransServer();
public:
        static AddDpptTransServer& GetInstance();
        virtual void AddSpacificTransServer(Json::Value& value,TsSession*TsSession);
};

class TsLeaveHandler;

class TransServerLeave : public ITsServerLeave
{
        TransServerLeave();
        TsLeaveHandler* m_tsLeaveHandler;
public:
        static TransServerLeave& GetInstance();
        virtual void OnServerLeave(TsSession &session);
};

class TsLeaveHandler
{
        TsLeaveHandler* next;
protected:
        TsQueue* m_tsQueue;
        TransServerDb* m_tsDb;
        Disptacher* m_disptacher;
public:
        TransServer* FindSession(TsSession* session);
        void setNext(TsLeaveHandler *n)
        {
                next = n;
        }
        void add(TsLeaveHandler *n)
        {
                if (next)
                        next->add(n);
                else
                        next = n;
        }
        virtual void SpacificTsLeave(TsSession* TsSession)
        {
                if(next != NULL)
                        next->SpacificTsLeave(TsSession);
                else {   // this command does not exist;
                        printf("error");
                        // TODO: log
                }
        }

        void ProcessTsAndTask(TransServer *ts)
        {
                Task* task;
               
                m_tsQueue->DelTs(ts);
                ts->SetState(TsIdle);
                ts->SetSession(NULL);
                ts->Release();

                m_tsDb->GiveBackTransServer(ts);

                task = ts->GetTask();
                m_disptacher->Submit(task);
        }

};

class TsDocLeaveHandler : public TsLeaveHandler
{
public:
        TsDocLeaveHandler()
        {

        }
};

class TsOpenofficeLeaveHandler : public TsDocLeaveHandler
{
        TsOpenofficeLeaveHandler();
public:
        static TsOpenofficeLeaveHandler& GetInstance();

        virtual void SpacificTsLeave(TsSession* session);
};

class TsWpsLeaveHandler : public TsDocLeaveHandler
{
        TsWpsLeaveHandler();
public:
        static TsWpsLeaveHandler& GetInstance();

        virtual void SpacificTsLeave(TsSession* session);
};

class TsOfficeLeaveHandler : public TsDocLeaveHandler
{
        TsOfficeLeaveHandler();
public:
        static TsOfficeLeaveHandler& GetInstance();

        virtual void SpacificTsLeave(TsSession* session);
};


class TsVideoLeaveHandler : public TsLeaveHandler
{
        TsVideoLeaveHandler();
public:
        static TsVideoLeaveHandler& GetInstance();

        virtual void SpacificTsLeave(TsSession* session);
};



class TsDpptLeaveHandler : public TsLeaveHandler
{
        TsDpptLeaveHandler();
public:
        static TsDpptLeaveHandler& GetInstance();

        virtual void SpacificTsLeave(TsSession* session);
};


#endif

使用特权

评论回复
19
keer_zu|  楼主 | 2016-6-8 11:53 | 只看该作者
TsManager.cpp


#include "TsManager.h"


extern  TsQueue GVideoTsQueue;
extern  TsQueue GDocOpenofficeTsQueue;
extern  TsQueue GDocWpsTsQueue;
extern  TsQueue GDocOfficeTsQueue;
extern  TsQueue GDpptTsQueue;
/////////////////////// TsRegister ////////////////////

TsRegister::TsRegister()
{
        m_addTransServer = &AddOpenofficeTransServer::GetInstance();
        m_addTransServer->add(&AddWpsTransServer::GetInstance());
        m_addTransServer->add(&AddOfficeTransServer::GetInstance());
        m_addTransServer->add(&AddVideoTransServer::GetInstance());
        m_addTransServer->add(&AddDpptTransServer::GetInstance());
}

void TsRegister::OnRegister(Json::Value& value,TsSession *session)
{
        m_addTransServer->AddSpacificTransServer(value,session);
}

////////////////////// AddTransServer /////////////////////
AddTransServer::AddTransServer()
{

}
void AddTransServer::AddTsTransaction(Json::Value & value, TsSession* session)
{
        TsRegistMessage* regMessage;
        TsMessage* message;
        int errorCode;
        string errorDetail;
        string msg;
       
        message = TsMessageDb::GetInstance().GetMessage(TsRegistMsg,m_serverType);
        if(!message){
                // TODO:log
                return;
        }
       
        if(regMessage = dynamic_cast<TsRegistMessage *>(message)){
               
        } else {
                // TODO:log
                return;
        }
       
       
        if(m_tsQueue->CheckSameTs(value["id"].asString())){
                errorCode = 1;  // TODO:
                errorDetail = "Repeat ts id!";
                regMessage->BuildResponse(errorCode,errorDetail,msg);
                session->SendMessage(msg);
        } else {

                TransServer* ts = VideoTransServerDb::GetInstance().GetTransServer();
                m_tsQueue->PushTs(ts);
                errorCode = 0;
                errorDetail = "";
                regMessage->BuildResponse(errorCode,errorDetail,msg);
                session->SendMessage(msg);
               
        }

}

///////////////////// AddDocTransServer //////////////////

AddDocTransServer::AddDocTransServer()
{
       
}

void AddDocTransServer::AddSpacificTransServer(Json::Value& value,TsSession*session)
{

}

///////////////////AddOpenofficeTransServer /////////////////
AddOpenofficeTransServer::AddOpenofficeTransServer()
{
        m_tsQueue = &GDocOfficeTsQueue;
        m_serverType = "DOC";
}

AddOpenofficeTransServer& AddOpenofficeTransServer::GetInstance()
{
        static  AddOpenofficeTransServer instance_;
        return instance_;        
}

void AddOpenofficeTransServer::AddSpacificTransServer(Json::Value& value,TsSession*session)
{
       
        if(value["servertype"] == m_serverType){
                AddTsTransaction(value,session);

        } else {
                AddTransServer::AddSpacificTransServer(value,session);
        }
}

///////////////////AddWpsTransServer /////////////////
AddWpsTransServer::AddWpsTransServer()
{
        m_tsQueue = &GDocWpsTsQueue;
        m_serverType = "DOC_WPS";
}

AddWpsTransServer& AddWpsTransServer::GetInstance()
{
        static  AddWpsTransServer instance_;
        return instance_;        
}

void AddWpsTransServer::AddSpacificTransServer(Json::Value& value,TsSession*session)
{
       
        if(value["servertype"] == m_serverType){
               
                AddTsTransaction(value,session);

        } else {
                AddTransServer::AddSpacificTransServer(value,session);
        }
}

///////////////////AddOfficeTransServer /////////////////
AddOfficeTransServer::AddOfficeTransServer()
{
        m_tsQueue = &GDocWpsTsQueue;
        m_serverType = "DOC_WINDOWS";
}

AddOfficeTransServer& AddOfficeTransServer::GetInstance()
{
        static  AddOfficeTransServer instance_;
        return instance_;        
}

void AddOfficeTransServer::AddSpacificTransServer(Json::Value& value,TsSession*session)
{

        if(value["servertype"] == m_serverType){
                AddTsTransaction(value,session);

        } else {
                AddTransServer::AddSpacificTransServer(value,session);
        }
}

//////////////////// AddVideoTransServer ///////////////////

AddVideoTransServer::AddVideoTransServer()
{
        m_tsQueue = &GVideoTsQueue;
        m_serverType = "VIDEO";
}

AddVideoTransServer& AddVideoTransServer::GetInstance()
{
        static  AddVideoTransServer instance_;
        return instance_;        
}

void AddVideoTransServer::AddSpacificTransServer(Json::Value& value,TsSession* session)
{
       
        if(value["servertype"].asString() == m_serverType){

                AddTsTransaction(value,session);

        } else {
                AddTransServer::AddSpacificTransServer(value,session);
        }
}

////////////////////// AddDpptTransServer //////////////////

AddDpptTransServer::AddDpptTransServer()
{
        m_tsQueue = &GDpptTsQueue;
        m_serverType = "DYNAMIC_PPT";
}

AddDpptTransServer& AddDpptTransServer::GetInstance()
{
        static  AddDpptTransServer instance_;
        return instance_;        
}

void AddDpptTransServer::AddSpacificTransServer(Json::Value& value,TsSession*session)
{
        if(value["servertype"] == m_serverType){
                AddTsTransaction(value,session);

        } else {
                AddTransServer::AddSpacificTransServer(value,session);
        }
}

///////////////////// TsServerLeave  ////////////////////////////

TransServerLeave::TransServerLeave()
{
        m_tsLeaveHandler = &TsVideoLeaveHandler::GetInstance();
        m_tsLeaveHandler->add(&TsOpenofficeLeaveHandler::GetInstance());
        m_tsLeaveHandler->add(&TsOfficeLeaveHandler::GetInstance());
        m_tsLeaveHandler->add(&TsWpsLeaveHandler::GetInstance());
        m_tsLeaveHandler->add(&TsDpptLeaveHandler::GetInstance());
}

TransServerLeave& TransServerLeave::GetInstance()
{
        static  TransServerLeave instance_;
        return instance_;        
}

void TransServerLeave::OnServerLeave(TsSession &session)
{

}

//////////////////////////////// TsLeaveHandler //////////////////////////////
TransServer* TsLeaveHandler::FindSession(TsSession* session)
{
        return m_tsQueue->GetTransServer(session);
}
////////////////////////// TsOpenofficeLeaveHandler ///////////////////////////
TsOpenofficeLeaveHandler::TsOpenofficeLeaveHandler()
{
        m_tsQueue = &GDocOpenofficeTsQueue;
        m_tsDb = &DocTransServerDb::GetInstance();
        m_disptacher = &DocDisptacher::GetInstance();
}

TsOpenofficeLeaveHandler& TsOpenofficeLeaveHandler::GetInstance()
{
        static TsOpenofficeLeaveHandler instance_;
        return instance_;

}


void TsOpenofficeLeaveHandler::SpacificTsLeave(TsSession* session)
{
        TransServer* ts;
       
        ts = FindSession(session);
        if(ts != NULL){
                ProcessTsAndTask(ts);
        } else {
                TsLeaveHandler::SpacificTsLeave(session);
        }
}


////////////////////////// TsOfficeLeaveHandler ///////////////////////////
TsOfficeLeaveHandler::TsOfficeLeaveHandler()
{
        m_tsQueue = &GDocOfficeTsQueue;
        m_tsDb = &DocTransServerDb::GetInstance();
        m_disptacher = &DocDisptacher::GetInstance();
}

TsOfficeLeaveHandler& TsOfficeLeaveHandler::GetInstance()
{
        static TsOfficeLeaveHandler instance_;
        return instance_;

}


void TsOfficeLeaveHandler::SpacificTsLeave(TsSession* session)
{
        TransServer* ts;
       
        if(ts = FindSession(session)){
                ProcessTsAndTask(ts);
        } else {
                TsLeaveHandler::SpacificTsLeave(session);
        }
}

////////////////////////// TsWpsLeaveHandler ///////////////////////////
TsWpsLeaveHandler::TsWpsLeaveHandler()
{
        m_tsQueue = &GDocWpsTsQueue;
        m_tsDb = &DocTransServerDb::GetInstance();
        m_disptacher = &DocDisptacher::GetInstance();
}

TsWpsLeaveHandler& TsWpsLeaveHandler::GetInstance()
{
        static TsWpsLeaveHandler instance_;
        return instance_;

}



void TsWpsLeaveHandler::SpacificTsLeave(TsSession* session)
{
        TransServer* ts;
       
        if(ts = FindSession(session)){
                ProcessTsAndTask(ts);
        } else {
                TsLeaveHandler::SpacificTsLeave(session);
        }
}



/////////////////////////// TsVideoLeaveHandler //////////////////////////////
TsVideoLeaveHandler::TsVideoLeaveHandler()
{
        m_tsQueue = &GVideoTsQueue;
        m_tsDb = &VideoTransServerDb::GetInstance();
        m_disptacher = &VideoDisptacher::GetInstance();
}

TsVideoLeaveHandler& TsVideoLeaveHandler::GetInstance()
{
        static TsVideoLeaveHandler instance_;
        return instance_;
}


void TsVideoLeaveHandler::SpacificTsLeave(TsSession* session)
{
        TransServer* ts;
       
        if(ts = FindSession(session)){
                ProcessTsAndTask(ts);
        } else {
                TsLeaveHandler::SpacificTsLeave(session);
        }
}

/////////////////////////// TsDpptLeaveHandler ////////////////////////////////
TsDpptLeaveHandler::TsDpptLeaveHandler()
{
        m_tsQueue = &GDpptTsQueue;
        m_tsDb = &DpptTransServerDb::GetInstance();
        m_disptacher = &DpptDisptacher::GetInstance();
}

TsDpptLeaveHandler& TsDpptLeaveHandler::GetInstance()
{
        static TsDpptLeaveHandler instance_;
        return instance_;
}


void TsDpptLeaveHandler::SpacificTsLeave(TsSession* session)
{
        TransServer* ts;
       
        if(ts = FindSession(session)){
                ProcessTsAndTask(ts);
        } else {
                TsLeaveHandler::SpacificTsLeave(session);
        }
}

使用特权

评论回复
20
keer_zu|  楼主 | 2016-6-8 11:54 | 只看该作者
TsQueue.h


#ifndef __TS_QUEUE_H__
#define __TS_QUEUE_H__

#include <list>
#include "TransServer.h"

class TsQueue
{
public:
        bool PushTs(TransServer* ts);
        TransServer* GetTsInSpecId(string tsId);
        bool DelTs(string tsId);
        bool DelTs(TransServer *ts);
        bool CheckSameTs(string tsId);

        TransServer* GetTsIdle();
        TransServer* GetTransServer(TsSession* session);
private:
        list<TransServer *> m_tsList;
};



#endif

使用特权

评论回复
发新帖 本帖赏金 10.00元(功能说明)我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

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

1352

主题

12436

帖子

53

粉丝