acdx.cpp

一个c++实现的acd的例子。 ----ACDCommandListener.cpp ---ACDCommandListenerThread.cpp ---ACDConfig.cpp ---a

 /*=============================================================

 
 Function:
		core call ACD entry


 Author: Leon Wang <[e-mail]  [e-mail]>
==============================================================*/

#include "stdafx.h"

#include "acdx.h"
#include <algorithm>
#include <IOSTREAM.h>
#include "endpoint.h"
#include "H323Utils.h"
#include "socket/lock.h"
//#include <VECTOR>
class Lock;

Lock g_lock("global_lock");// creat mutex   alias list
Lock g_lock_pend("pendlist");

//##ModelId=424BB647014F
ACDX* ACDX::instance = 0;

//##ModelId=424BB64700D2
ACDX::ACDX()
{

}

//##ModelId=424BB64700D3
ACDX::~ACDX()
{
	if (gkclient != NULL ) {
		delete gkclient;
		gkclient = NULL;
	}
	if (backlog != NULL) {
		delete backlog;
		backlog = NULL;
	}
	if (houseKeeping != NULL) {
		delete houseKeeping;
		houseKeeping = NULL;
			
	}
	if (commandListener != NULL) {
		delete commandListener;
		commandListener = NULL;
	}
	
}
/*
 start major logic
*/
//##ModelId=424BB64700F2
void ACDX::Start()
{
	
     // read ACDX config
	    config = ACDConfig::getInstance();
        gkHost = config->getConfigKey("Main","gnugk_host", "127.0.0.1");
        gkPort = config->getConfigKey("Main","gnugk_port", 7000);
        listenPort = config->getConfigKey("Main","listen_port", 7001);
        redirLocation = config->getConfigKey("Main","redir_location", "http://www.google.com/");
        distribution = config->getDistributionAlgorithm();
		// connect to the gatekeeper
		gkclient = new GkClient();
		gkclient->init(ACDX::getInstance(), gkHost, gkPort);// first parameter send acdx instance -> gkclient
		backlog = new CCallBacklog(gkclient);
		houseKeeping = new HouseKeeper();
		houseKeeping->init(this, backlog);
		CString logfile = config->getConfigKey("Main","logfile", "");
		int debugLevel = config->getConfigKey("Main","debug", 0);
		Logger::setDebug(debugLevel);
		//print welcome screen
		Logger::log("--- GnuGk ACDX config ---");
        Logger::log("GnuGk host: " + gkHost);
		char ch[8];
		itoa(gkPort,ch,10);

        Logger::log("GnuGk status port: " + CString(ch));
		itoa(listenPort,ch,10);
        Logger::log("ACDX listen port: " + CString(ch));
		itoa(distribution,ch,10);
        Logger::log("ACDX distribution algo: " +  CString(ch));
        Logger::log("ACDX redir location: " + redirLocation);
        Logger::log("ACDX logfile: " + logfile);
		itoa(debugLevel,ch,10);
        Logger::log("ACDX debug level: " + CString(ch));
        Logger::log("--- starting ACDX ---");
		memset(ch,0,sizeof(ch));
		//Logger logger;
		if (logfile.GetLength()>0) {
			Logger::setLogfile(logfile);
		}
	    //begin call gkclient thread
		//new Thread(gkclient).start();//thread gk
		//DWORD ip = inet_addr("192.168.1.43");
		unsigned long hThread_gk = _beginthreadex(0,0,
											GkClient::_RUN,
											gkclient,0,0);

		// perview list function over [3/28/2005]

		//waitQueues.startWaitQueues(gkclient); // not need now --> change it in furture
        
        // start listening for commands to the ACD
        commandListener = new ACDCommandListener();
        commandListener->init(this,listenPort, redirLocation); // first parameter is acdx point

        //HTTP server monitor
		
		unsigned long hThread_commandListener = _beginthreadex(0,0,
											ACDCommandListener::_RUN,
											commandListener,0,0);
			
			
        //new Thread(houseKeeping).start();//thread housekeeping

		//unsigned long hThread_houseKeeping = _beginthreadex(0,0,
		//									HouseKeeper::_RUN,
		//									houseKeeping,0,0);




		WaitForSingleObject((HANDLE)hThread_gk, INFINITE);
		WaitForSingleObject((HANDLE)hThread_commandListener, INFINITE);
		//WaitForSingleObject((HANDLE)hThread_houseKeeping, INFINITE);

}

/**
* Singleton access.
* @return singleton object
*/

//##ModelId=424BB64700E2
ACDX* ACDX::getInstance() {
	if (instance == 0) {
		 instance = new ACDX();
	}
	return instance;
    }



//##ModelId=424BB64700C3
void ACDX::addAlias(CString _alias, CString _epid)
{

	if (!aliasById(_alias, _epid).isOK) {
        Agent* newAgent = new Agent(_epid, _alias);
		//newAgent->alias = "";
		if (g_lock.lock()) {
			aliasList.push_back(*newAgent);
			g_lock.unlock();
		}

        // check if we have pending calls for this now available agent
        backlog->checkPending(newAgent,aliasList);
	}
     
}

    /**
     * Endpoint has unregistered, get rid of all it's aliases.
     * Also cancel all pending calls.
     * @param _epid
     */

//##ModelId=424BB64700B4
void ACDX::removeAllAliases(CString _epid)
{
	std::list<Agent>::iterator AliasElement;
	Alias alias;
	for(AliasElement= aliasList.begin();AliasElement!=aliasList.end();AliasElement++)
	{
		alias = (Alias)*AliasElement;
		if (_epid==alias.getEpid()) {
			if (g_lock.lock()) {
				if(!aliasList.empty())
				   AliasElement = aliasList.erase(AliasElement); //here this return element is  next call
				g_lock.unlock();
			}
			
		}
	}

    backlog->removeAllRequests(_epid);
}
/**
     * Set _all_ aliases on this endpoint with this CRV to available.
     * @param _epid endpoint ID
     * @param _crv  CRV
     */
//##ModelId=424BB64700A6
void ACDX::setAliasAvailable(CString _epid, CString _crv)
{
	std::list<Agent>::iterator agentElment;
	Agent _agent;

     Agent agent = agentByCrv(_epid, _crv);  // find first alias
     while ((agent.isOK) && (_crv.GetLength() > 0)) 
	 {
		 // in alias list update element
		 for(agentElment = aliasList.begin(); agentElment != aliasList.end();agentElment++)
		 {
			 _agent = *agentElment;
			 if (agent.getAlias()==_agent.getAlias()) {
				 if (g_lock.lock()) {
					agentElment->setState(Alias::AVAILABLE);
					agentElment->setLastCall();
					agentElment->setLastTime();
					agentElment->setCrv("");
					backlog->checkPending((&(Agent)*agentElment),aliasList); //------> need test it agent in checkpending
					g_lock.unlock();
				 }// if lock
			 }//if alias ==
		 }// for
			 
           // check if we have pending calls for this now available agent
         //backlog->checkPending(&agent); //------> need test it agent in checkpending
         agent = agentByCrv(_epid, _crv);    // find next alias
      }
}
    /**
     * Set this alias on this endpoint to TALKING and remember the CRV.
     * @param _alias    H.323 alias
     * @param _crv      CRV
     */
//##ModelId=424BB6470095
void ACDX::setAliasTalking(CString _alias, CString _crv)
{
	std::list<Agent>::iterator aliasElement;
	Alias _alias_temp;
    Alias alias = aliasByName(_alias);
      if (alias.isOK) {
		for(aliasElement = aliasList.begin(); aliasElement != aliasList.end();aliasElement++)
		{
			_alias_temp = (Alias)*aliasElement;
			if (alias.getAlias()== _alias_temp.getAlias()) {
			  if (g_lock.lock()) {
				  aliasElement->setState(Alias::TALKING);
				  aliasElement->setCrv(_crv);
				  g_lock.unlock();
			  }// lock

			}//if ==
		}//for
      }//if isok
}

//##ModelId=424BB6470094
void ACDX::clearAllAliasStates()
{
	aliasList.clear();
}

//##ModelId=42198D1803E6
//synchronized
//##ModelId=424BB6470088
void ACDX::agentSanityCheck()
{

		if (!g_lock.lock()) {
			return;
		}
	
	std::list<Agent>::iterator aliasElement;
	Alias alias;
	for(aliasElement = aliasList.begin(); aliasElement != aliasList.end(); aliasElement++ )
	{
		//alias =  (Alias)*aliasElement;
		aliasElement->setState(Alias::AVAILABLE);
	}
 	g_lock.unlock();
    gkclient->getCurrentCalls();
}

//##ModelId=424BB6470133
Alias ACDX::aliasByName(CString _alias)
{
	std::list<Agent>::iterator aliasElement;
	Alias alias;
	for(aliasElement = aliasList.begin(); aliasElement != aliasList.end(); aliasElement++ )
	{
		alias =  (Alias)*aliasElement;
		if (_alias==alias.getAlias()) {
			alias.isOK = TRUE;
			return alias;
		}
	}
	return alias;
}
/*
void ACDX::_aliasById (CString _alias, CString _epid,Alias& StringToPrint) {
//  cout << StringToPrint << endl;
	cout<<StringToPrint.getAlias()<<endl;
}
*/

// get alisas by endpoint id
// from alias list 
//##ModelId=424BB6470130
Alias ACDX::aliasById(CString _alias, CString _epid)
{
	std::list<Agent>::iterator aliasElement;
	Alias alias;

	//std::for_each (aliasList.begin(),aliasList.end(),PrintIt(_alias,_epid));
	for(aliasElement = aliasList.begin(); aliasElement != aliasList.end(); ++aliasElement ) {
		alias =  (Alias)*aliasElement;
        if (_alias==alias.getAlias() && _epid==alias.getEpid()) {
			alias.isOK = TRUE;
			return alias;
         }
     }
  return alias;
}

//##ModelId=424BB6470121
Agent ACDX::agentByCrv(CString _epid, CString _crv)
{
	std::list<Agent>::iterator aliasElement;
	Agent agent;
	for(aliasElement = aliasList.begin(); aliasElement != aliasList.end(); ++aliasElement ) 
	{
		agent =  *aliasElement;

		if (_epid==agent.getEpid() && _crv==agent.getCrv())
		{
			agent.isOK = TRUE;
			return agent;
		}
	}
	return agent;
}

//##ModelId=42198D1803D5
// major route call for queue logic
//##ModelId=424BB6470077
void ACDX::routeCall(CString queue, 
					 CString callerEndId, 
					 CString callRef,