axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From susan...@apache.org
Subject cvs commit: xml-axis/c/src/engine SharedObject.h SharedObject.cpp SessionScopeHandlerPool.h SessionScopeHandlerPool.cpp SerializerPool.h SerializerPool.cpp RequestScopeHandlerPool.h RequestScopeHandlerPool.cpp DeserializerPool.h DeserializerPool.cpp AppScopeHandlerPool.h AppScopeHandlerPool.cpp Main.c HandlerPool.h HandlerPool.cpp HandlerLoader.h HandlerLoader.cpp HandlerChain.h HandlerChain.cpp AxisEngine.h AxisEngine.cpp Axis.cpp
Date Wed, 13 Aug 2003 14:07:47 GMT
susantha    2003/08/13 07:07:47

  Modified:    c/src/engine Main.c HandlerPool.h HandlerPool.cpp
                        HandlerLoader.h HandlerLoader.cpp HandlerChain.h
                        HandlerChain.cpp AxisEngine.h AxisEngine.cpp
                        Axis.cpp
  Added:       c/src/engine SharedObject.h SharedObject.cpp
                        SessionScopeHandlerPool.h
                        SessionScopeHandlerPool.cpp SerializerPool.h
                        SerializerPool.cpp RequestScopeHandlerPool.h
                        RequestScopeHandlerPool.cpp DeserializerPool.h
                        DeserializerPool.cpp AppScopeHandlerPool.h
                        AppScopeHandlerPool.cpp
  Log:
  After making code base thread safe. Also changed Module writing API accordingly. WSDD module too improved.
  
  Revision  Changes    Path
  1.6       +13 -12    xml-axis/c/src/engine/Main.c
  
  Index: Main.c
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/Main.c,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- Main.c	5 Aug 2003 12:28:09 -0000	1.5
  +++ Main.c	13 Aug 2003 14:07:47 -0000	1.6
  @@ -68,10 +68,10 @@
   #include <malloc.h>
   #include "../common/Packet.h"
   
  -extern int process_request(soapstream *);
  +extern int process_request(Ax_soapstream *str);
   
   //soap request with headers
  -char* ip = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope \
  +//char* ip = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope \
   			xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" \
   			xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" \
   			xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"> \
  @@ -79,7 +79,7 @@
   			soapenv:mustUnderstand=\"true\" >Hello Req Header Val</t:Transaction></soapenv:Header> \
   			<soapenv:Body><add soapenv:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><op1 xsi:type=\"xsd:int\">3</op1><op2 xsi:type=\"xsd:int\">4</op2></add></soapenv:Body></soapenv:Envelope>";
   
  -//char* ip = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><soapenv:Body><add soapenv:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><op1 xsi:type=\"xsd:int\">3</op1><op2 xsi:type=\"xsd:int\">4</op2></add></soapenv:Body></soapenv:Envelope>";
  +char* ip = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><soapenv:Body><add soapenv:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><op1 xsi:type=\"xsd:int\">3</op1><op2 xsi:type=\"xsd:int\">4</op2></add></soapenv:Body></soapenv:Envelope>";
   
   //	char* ip = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><soapenv:Body><echo soapenv:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"><op1 xsi:type=\"xsd:string\">Hello World!</op1></echo></soapenv:Body></soapenv:Envelope>";
   
  @@ -181,26 +181,27 @@
   		</Point>\
   		</enc:Array> </EchoPointArray></soapenv:Body></soapenv:Envelope>";
   
  -int main() {	
  -	
  -	soapstream* str = (soapstream*)malloc(sizeof(soapstream));
  +int main() 
  +{		
  +	Ax_soapstream* str = (Ax_soapstream*)malloc(sizeof(Ax_soapstream));
   	str->trtype = APTHTTP;
  +	str->sessionid = "somesessionid";
  +	str->so.http.ip_method = AXIS_HTTP_POST;
   
  -	str->so.http.ip_method=POST;
  -
  -	str->so.http.ip_headers = (header*)malloc(sizeof(header));
  +	str->so.http.ip_headers = (Ax_header*)malloc(sizeof(Ax_header));
   	str->so.http.ip_headers->headername = SOAPACTIONHEADER;
  -	str->so.http.ip_headers->headervalue = "\"Maths\"";	
  +	str->so.http.ip_headers->headervalue = "\"CalculatorService\"";	
   	str->so.http.ip_headercount = 1;
   
   	printf("soap request :\n %s\n", ip);
   
  +	initialize_module();
   	process_request(str);	
   
   	return 0;
   }
   
  -int send_response_bytes(char * res) {
  +int send_response_bytes(char * res, void* pOutputStream) {
   
   	printf("sending SOAP response : \n%s\n", res);
   
  @@ -218,7 +219,7 @@
   	return 0;
   }
   
  -int send_transport_information(soapstream* sSoapstream) {
  +int send_transport_information(Ax_soapstream* sSoapstream) {
   
   	return 0;
   }
  
  
  
  1.2       +18 -40    xml-axis/c/src/engine/HandlerPool.h
  
  Index: HandlerPool.h
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/HandlerPool.h,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- HandlerPool.h	25 Jun 2003 05:13:45 -0000	1.1
  +++ HandlerPool.h	13 Aug 2003 14:07:47 -0000	1.2
  @@ -64,6 +64,7 @@
   // HandlerPool.h: interface for the HandlerPool class.
   //
   //////////////////////////////////////////////////////////////////////
  +#pragma warning (disable : 4503)
   
   #if !defined(AFX_HANDLERPOOL_H__6C2A4C96_7115_43C6_9EFA_CDAC9247D109__INCLUDED_)
   #define AFX_HANDLERPOOL_H__6C2A4C96_7115_43C6_9EFA_CDAC9247D109__INCLUDED_
  @@ -77,8 +78,9 @@
   #include "../common/BasicHandler.h"
   #include "HandlerLoader.h"
   #include "HandlerChain.h"
  +#include "SharedObject.h"
   
  -#include <map>
  +#include <list>
   #include <string>
   
   using namespace std;
  @@ -87,52 +89,28 @@
    *
    *
    */
  -class HandlerPool  
  +class HandlerPool : protected SharedObject
   {
   private:
  -	class LoadedHandler {
  -	public:
  -		HandlerLoader* m_DL;
  -		BasicHandler* m_Handler;
  -		LoadedHandler(string &sFile, int nOptions=0);
  -		~LoadedHandler();
  -	};
  +	int GetHandler(BasicHandler** ppHandler, string& sSessionId, int nScope, int nLibId);
  +	int PoolHandler(string& sSessionId, BasicHandler* pHandler, int nScope, int nLibId);
  +	int GetHandlerChain(string& sSessionId, HandlerChain** pChain, const WSDDHandlerList* pHandlerList);
   public:
  -	void UnloadWebService(WSDDService* pService);
  -	BasicHandler* LoadWebService(WSDDService* pService);
  -	void UnLoadServiceRequestFlowHandlers(WSDDHandlerList *pHandlerList);
  -	void UnLoadServiceResponseFlowHandlers(WSDDHandlerList *pHandlerList);
  -	int LoadServiceResponseFlowHandlers(WSDDHandlerList* pHandlerList);
  -	int LoadServiceRequestFlowHandlers(WSDDHandlerList* pHandlerList);
  -	HandlerChain* GetTransportRequestFlowHandlerChain(AXIS_PROTOCOL_TYPE Protocol);
  -	HandlerChain* GetTransportResponseFlowHandlerChain(AXIS_PROTOCOL_TYPE Protocol);
  -	HandlerChain* GetGlobalResponseFlowHandlerChain();
  -	HandlerChain* GetGlobalRequestFlowHandlerChain();
  -	HandlerChain* GetServiceRequestFlowHandlerChain();
  -	HandlerChain* GetServiceResponseFlowHandlerChain();
  -	//Following will load handlers and keep them in private members.
  -	int LoadTransportRequestFlowHandlers(AXIS_PROTOCOL_TYPE Protocol, WSDDHandlerList* pHandlerList);
  -	int LoadTransportResponseFlowHandlers(AXIS_PROTOCOL_TYPE Protocol, WSDDHandlerList* pHandlerList);
  -	int LoadGlobalResponseFlowHandlers(WSDDHandlerList* pHandlerList);
  -	int LoadGlobalRequestFlowHandlers(WSDDHandlerList* pHandlerList);
  +	int GetGlobalRequestFlowHandlerChain(HandlerChain** ppChain, string& sSessionId);
  +	int GetGlobalResponseFlowHandlerChain(HandlerChain** ppChain, string& sSessionId);
  +	int GetTransportRequestFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, AXIS_PROTOCOL_TYPE Protocol);
  +	int GetTransportResponseFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, AXIS_PROTOCOL_TYPE Protocol);
  +	int GetRequestFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, const WSDDService* pService);
  +	int GetResponseFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, const WSDDService* pService);
  +	void PoolHandlerChain(HandlerChain* pChain, string& sSessionId);
  +
  +	int GetWebService(BasicHandler** ppHandler, string& sSessionId, const WSDDHandler* pService);
  +	void PoolWebService(string& sSessionId, BasicHandler* pHandler, const WSDDHandler* pHandlerInfo);
   
   	HandlerPool();
   	virtual ~HandlerPool();
   private:
  -	BasicHandler* GetHandler(WSDDHandler* pHandlerInfo);
  -	int UnLoadHandler(WSDDHandler* pHandlerInfo);
  -	BasicHandler* LoadHandler(WSDDHandler* pHandlerInfo);
  -
  -private:
  -	void UnloadHandlerList(WSDDHandlerList *pHandlerList);
  -	HandlerChain* LoadHandlerChain(WSDDHandlerList* pHandlerList);
  -	map<string, LoadedHandler*> m_Handlers; //all handlers will be retained here
  -	HandlerChain* m_pGReqFChain; //Global Handler chain(Request)
  -	HandlerChain* m_pGResFChain; //Global Handler chain(Response)
  -	HandlerChain* m_pServiceReqFChain; //Service specific Handler chain(Request)
  -	HandlerChain* m_pServiceResFChain; //Service specific Handler chain(Response)
  -	map<AXIS_PROTOCOL_TYPE, HandlerChain*> m_TReqFChains; //Transport Handler chains (Request)
  -	map<AXIS_PROTOCOL_TYPE, HandlerChain*> m_TResFChains; //Transport Handler chains (Response)
  +	list<HandlerChain*> m_ChainStore;
   };
   
   #endif // !defined(AFX_HANDLERPOOL_H__6C2A4C96_7115_43C6_9EFA_CDAC9247D109__INCLUDED_)
  
  
  
  1.6       +177 -197  xml-axis/c/src/engine/HandlerPool.cpp
  
  Index: HandlerPool.cpp
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/HandlerPool.cpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- HandlerPool.cpp	5 Aug 2003 05:48:37 -0000	1.5
  +++ HandlerPool.cpp	13 Aug 2003 14:07:47 -0000	1.6
  @@ -66,279 +66,259 @@
   //////////////////////////////////////////////////////////////////////
   
   #include "HandlerPool.h"
  -
  +#include "AppScopeHandlerPool.h"
  +#include "RequestScopeHandlerPool.h"
  +#include "SessionScopeHandlerPool.h"
  +#include "../wsdd/WSDDDeployment.h"
   //////////////////////////////////////////////////////////////////////
   // Construction/Destruction
   //////////////////////////////////////////////////////////////////////
   #include "../common/Debug.h"
   
  +extern AppScopeHandlerPool g_AppScopeHandlerPool;
  +extern RequestScopeHandlerPool g_RequestScopeHandlerPool;
  +extern SessionScopeHandlerPool g_SessionScopeHandlerPool;
  +extern WSDDDeployment g_WSDDDeployment;
  +
   HandlerPool::HandlerPool()
   {
  -	m_pGReqFChain = NULL;
  -	m_pGResFChain = NULL;
  -	m_pServiceReqFChain = NULL;
  -	m_pServiceResFChain = NULL;	
   }
   
   HandlerPool::~HandlerPool()
   {
  -	//unload all the handlers
  -	LoadedHandler* pLh = NULL;
  -	for (map<string, LoadedHandler*>::iterator it = m_Handlers.begin();
  -	it != m_Handlers.end(); it++)
  -	{
  -		pLh = (*it).second;
  -		pLh->m_DL->Finalize();
  -		delete pLh;
  -	}
  -	m_Handlers.clear();
  -
  -	//delete all handlers and chains etc
  -	if(m_pGReqFChain) delete m_pGReqFChain;
  -	if(m_pGResFChain) delete m_pGResFChain;
  -	if(m_pServiceReqFChain) delete m_pServiceReqFChain;
  -	if(m_pServiceResFChain) delete m_pServiceResFChain;
  -
  -	map<AXIS_PROTOCOL_TYPE, HandlerChain*>::iterator it1;
  -	for (it1 = m_TReqFChains.begin();it1 != m_TReqFChains.end(); it1++)
  -	{
  -		delete (*it1).second;
  -	}
  -	for (it1 = m_TResFChains.begin();it1 != m_TResFChains.end(); it1++)
  -	{
  -		delete (*it1).second;
  -	}
  -}
  -
  -HandlerPool::LoadedHandler::LoadedHandler(string &sFile, int nOptions)
  -{
  -	m_DL = new HandlerLoader(sFile, nOptions);
  -	m_Handler = NULL;
   }
   
  -HandlerPool::LoadedHandler::~LoadedHandler()
  +int HandlerPool::GetHandler(BasicHandler** ppHandler, string& sSessionId, int nScope, int nLibId)
   {
  -	delete m_DL;
  -}
  +	*ppHandler = NULL;
  +	int Status = FAIL;
   
  -BasicHandler* HandlerPool::LoadHandler(WSDDHandler *pHandlerInfo)
  -{
  -	LoadedHandler* pLh = NULL;
  -	if (pHandlerInfo) 
  +	switch (nScope)
   	{
  -    
  -		pLh = new LoadedHandler(pHandlerInfo->GetLibName(), RTLD_LAZY);
  -
  -		if (SUCCESS == pLh->m_DL->Initialize())
  -		{
  -
  -			BasicHandler* pBh = pLh->m_DL->GetHandler();
  -      //BasicHandler* pBh = NULL;
  -			if (pBh) 
  +	case AH_APPLICATION:
  +		do {
  +			if ((Status = g_AppScopeHandlerPool.GetInstance(ppHandler, nLibId)) == SUCCESS)
   			{
  -				pLh->m_Handler = pBh;
  -				//Add to m_Handlers - place holder
  -				m_Handlers[pHandlerInfo->GetLibName()] = pLh;
  -				return pBh;
  +				return Status;
  +			}
  +			else if (Status == HANDLER_BEING_USED)
  +			{ //block this thread not this object
  +				#ifdef WIN32
  +				Sleep(0);
  +				#else
  +				sleep(0);
  +				#endif
   			}
   			else
   			{
  -				//something wrong
  -        return NULL;
  +				return Status;
   			}
  -		}
  -		else
  -		{
  -			//Uninitialize, unload and delete pLh
  -		}
  +		} while (Status == HANDLER_BEING_USED);
  +		break;
  +	case AH_SESSION:
  +		return g_SessionScopeHandlerPool.GetInstance(sSessionId, ppHandler, nLibId);
  +	case AH_REQUEST:
  +		return g_RequestScopeHandlerPool.GetInstance(ppHandler, nLibId);
   	}
  -	return NULL;
  +	return Status;
   }
   
  -int HandlerPool::UnLoadHandler(WSDDHandler *pHandlerInfo)
  +int HandlerPool::PoolHandler(string& sSessionId, BasicHandler* pHandler, int nScope, int nLibId)
   {
  -	LoadedHandler* pLh = NULL;
  -	if (m_Handlers.find(pHandlerInfo->GetLibName()) != m_Handlers.end())
  +	switch (nScope)
   	{
  -		pLh = m_Handlers[pHandlerInfo->GetLibName()];
  -		pLh->m_DL->Finalize();
  -		m_Handlers.erase(pHandlerInfo->GetLibName());
  -		delete pLh;
  -		return SUCCESS;
  +	case AH_APPLICATION:
  +		g_AppScopeHandlerPool.PutInstance(pHandler, nLibId);
  +		break;
  +	case AH_SESSION:
  +		g_SessionScopeHandlerPool.PutInstance(sSessionId, pHandler, nLibId);
  +		break;
  +	case AH_REQUEST:
  +		g_RequestScopeHandlerPool.PutInstance(pHandler, nLibId);
  +		break;
   	}
  -	return FAIL;
  +	return SUCCESS;
   }
   
  -BasicHandler* HandlerPool::GetHandler(WSDDHandler *pHandlerInfo)
  +int HandlerPool::GetGlobalRequestFlowHandlerChain(HandlerChain** ppChain, string& sSessionId)
   {
  -	if (m_Handlers.find(pHandlerInfo->GetLibName()) != m_Handlers.end())
  +	const WSDDHandlerList* pHandlerList = g_WSDDDeployment.GetGlobalRequestFlowHandlers();
  +	if (pHandlerList)
   	{
  -		return m_Handlers[pHandlerInfo->GetLibName()]->m_Handler;
  +		return GetHandlerChain(sSessionId, ppChain, pHandlerList);
   	}
  -	return NULL;
  -}
  -
  -HandlerChain* HandlerPool::GetGlobalRequestFlowHandlerChain()
  -{
  -	return m_pGReqFChain;
  -}
  -
  -HandlerChain* HandlerPool::GetGlobalResponseFlowHandlerChain()
  -{
  -	return m_pGResFChain;
  -}
  -
  -HandlerChain* HandlerPool::GetTransportRequestFlowHandlerChain(AXIS_PROTOCOL_TYPE Protocol)
  -{
  -	if (m_TReqFChains.find(Protocol) != m_TReqFChains.end())
  -		return m_TReqFChains[Protocol];
  -	return NULL;
  -}
  -
  -HandlerChain* HandlerPool::GetTransportResponseFlowHandlerChain(AXIS_PROTOCOL_TYPE Protocol)
  -{
  -	if (m_TReqFChains.find(Protocol) != m_TReqFChains.end())
  -		return m_TResFChains[Protocol];
  -	return NULL;
  -}
  -
  -HandlerChain* HandlerPool::GetServiceRequestFlowHandlerChain()
  -{
  -	return m_pServiceReqFChain;
  -}
  -
  -HandlerChain* HandlerPool::GetServiceResponseFlowHandlerChain()
  -{
  -	return m_pServiceResFChain;
  -}
  -
  -int HandlerPool::LoadTransportRequestFlowHandlers(AXIS_PROTOCOL_TYPE Protocol, WSDDHandlerList* pHandlerList)
  -{
  -	HandlerChain* pHc = LoadHandlerChain(pHandlerList);
  -	if (pHc)
  +	else
   	{
  -		m_TReqFChains[Protocol] = pHc;
  -		return SUCCESS;
  +		*ppChain = NULL;
  +		return SUCCESS; //NO_HANDLERS_CONFIGURED
   	}
  -	return FAIL;
   }
   
  -int HandlerPool::LoadTransportResponseFlowHandlers(AXIS_PROTOCOL_TYPE Protocol, WSDDHandlerList* pHandlerList)
  +int HandlerPool::GetGlobalResponseFlowHandlerChain(HandlerChain** ppChain, string& sSessionId)
   {
  -	HandlerChain* pHc = LoadHandlerChain(pHandlerList);
  -	if (pHc)
  +	const WSDDHandlerList* pHandlerList = g_WSDDDeployment.GetGlobalResponseFlowHandlers();
  +	if (pHandlerList)
  +	{
  +		return GetHandlerChain(sSessionId, ppChain, pHandlerList);
  +	}
  +	else
   	{
  -		m_TResFChains[Protocol] = pHc;
  -		return SUCCESS;
  +		*ppChain = NULL;
  +		return SUCCESS; //NO_HANDLERS_CONFIGURED
   	}
  -	return FAIL;
   }
   
  -int HandlerPool::LoadGlobalResponseFlowHandlers(WSDDHandlerList* pHandlerList)
  +int HandlerPool::GetTransportRequestFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, AXIS_PROTOCOL_TYPE Protocol)
   {
  -	m_pGResFChain = LoadHandlerChain(pHandlerList);
  -	return (m_pGResFChain != NULL) ? SUCCESS:FAIL;
  +	const WSDDHandlerList* pHandlerList = g_WSDDDeployment.GetTransportRequestFlowHandlers(Protocol);
  +	if (pHandlerList)
  +	{
  +		return GetHandlerChain(sSessionId, ppChain, pHandlerList);
  +	}
  +	else
  +	{
  +		*ppChain = NULL;
  +		return SUCCESS; //NO_HANDLERS_CONFIGURED
  +	}
   }
   
  -int HandlerPool::LoadGlobalRequestFlowHandlers(WSDDHandlerList* pHandlerList)
  +int HandlerPool::GetTransportResponseFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, AXIS_PROTOCOL_TYPE Protocol)
   {
  -	m_pGReqFChain = LoadHandlerChain(pHandlerList);
  -	return (m_pGReqFChain != NULL) ? SUCCESS:FAIL;
  +	const WSDDHandlerList* pHandlerList = g_WSDDDeployment.GetTransportResponseFlowHandlers(Protocol);
  +	if (pHandlerList)
  +	{
  +		return GetHandlerChain(sSessionId, ppChain, pHandlerList);
  +	}
  +	else
  +	{
  +		*ppChain = NULL;
  +		return SUCCESS; //NO_HANDLERS_CONFIGURED
  +	}
   }
   
  -int HandlerPool::LoadServiceRequestFlowHandlers(WSDDHandlerList *pHandlerList)
  +int HandlerPool::GetRequestFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, const WSDDService* pService)
   {
  -	m_pServiceReqFChain = LoadHandlerChain(pHandlerList);
  -	return (m_pServiceReqFChain != NULL) ? SUCCESS:FAIL;
  +	const WSDDHandlerList* pHandlerList = pService->GetRequestFlowHandlers();
  +	if (pHandlerList)
  +	{
  +		return GetHandlerChain(sSessionId, ppChain, pHandlerList);
  +	}
  +	else
  +	{
  +		*ppChain = NULL;
  +		return SUCCESS; //NO_HANDLERS_CONFIGURED
  +	}
   }
   
  -int HandlerPool::LoadServiceResponseFlowHandlers(WSDDHandlerList *pHandlerList)
  +int HandlerPool::GetResponseFlowHandlerChain(HandlerChain** ppChain, string& sSessionId, const WSDDService* pService)
   {
  -	m_pServiceResFChain = LoadHandlerChain(pHandlerList);
  -	return (m_pServiceResFChain != NULL) ? SUCCESS:FAIL;
  +	const WSDDHandlerList* pHandlerList = pService->GetResponseFlowHandlers();
  +	if (pHandlerList)
  +	{
  +		return GetHandlerChain(sSessionId, ppChain, pHandlerList);
  +	}
  +	else
  +	{
  +		*ppChain = NULL;
  +		return SUCCESS; //NO_HANDLERS_CONFIGURED
  +	}
   }
   
  -void HandlerPool::UnLoadServiceRequestFlowHandlers(WSDDHandlerList *pHandlerList)
  +int HandlerPool::GetHandlerChain(string& sSessionId, HandlerChain** ppChain, const WSDDHandlerList *pHandlerList)
   {
  -	UnloadHandlerList(pHandlerList);
  -	delete m_pServiceReqFChain;
  -	m_pServiceReqFChain = NULL;
  -}
  +	lock();
  +	*ppChain = NULL;
  +	HandlerChain* pChain;
  +	//check m_ChainStore to get a HandlerChain
  +	if (!m_ChainStore.empty())
  +	{
  +		pChain = m_ChainStore.front();
  +		m_ChainStore.pop_front();
  +		pChain->Init();
  +	}
  +	else
  +	{
  +		pChain = new HandlerChain();
  +	}
   
  -void HandlerPool::UnLoadServiceResponseFlowHandlers(WSDDHandlerList *pHandlerList)
  -{
  -	UnloadHandlerList(pHandlerList);
  -	delete m_pServiceResFChain;
  -	m_pServiceResFChain = NULL;
  -}
  +	WSDDHandler* pWSDDH;
  +	BasicHandler* pBH;
  +	int Status = SUCCESS;
   
  -HandlerChain* HandlerPool::LoadHandlerChain(WSDDHandlerList *pHandlerList)
  -{
  -	DEBUG1("HandlerPool::LoadHandlerChain");
  -	int nLoaded = 0;
  -	HandlerChain* pHc = NULL;
  -	if (pHandlerList && !pHandlerList->empty())
  +	for (WSDDHandlerList::const_iterator it = pHandlerList->begin(); it != pHandlerList->end(); it++)
   	{
  -		pHc = new HandlerChain();
  -		//BasicHandler* pBh = NULL;;
  -		Handler* pH = NULL;
  -		for (WSDDHandlerList::iterator it=pHandlerList->begin(); it != pHandlerList->end(); it++)
  +		pWSDDH = (*it);
  +		if ((Status = GetHandler(&pBH, sSessionId, pWSDDH->GetScope(),pWSDDH->GetLibId())) == SUCCESS)
   		{
  -			//if ((pBh = LoadHandler(*it)) != NULL)
  -			DEBUG1("BEFORE BasicHandler *pBh = LoadHandler(*it);");
  -			BasicHandler *pBh = LoadHandler(*it);
  -			DEBUG1("AFTER BasicHandler *pBh = LoadHandler(*it);");
  -			if (pBh)
  +			if (NORMAL_HANDLER == pBH->GetType())
   			{
  -				DEBUG1("BEFORE pH = static_cast<Handler*>(pBh);");
  -				if (pBh->GetType() == NORMAL_HANDLER)
  -					pH = static_cast<Handler*>(pBh);
  -				else
  -					pH = NULL;
  -				DEBUG1("AFTER pH = static_cast<Handler*>(pBh);");
  -				if (pH)
  -				{          
  -					DEBUG1("if (pH)");
  -					pH->SetOptionList((*it)->GetOptionList());
  -					nLoaded++;
  -					pHc->AddHandler(pH);
  -				}
  -				else
  -				{
  -					return NULL;
  -				}
  +				pChain->AddHandler(static_cast<Handler*>(pBH), pWSDDH->GetScope(), pWSDDH->GetLibId());
  +			}
  +			else
  +			{
  +				Status = WRONG_HANDLER_TYPE;
  +				break;
   			}
   		}
  -		if (0!=nLoaded) 
  +		else
   		{
  -			return pHc;
  +			break;
   		}
  -		else 
  +	}
  +	if (Status != SUCCESS) //some failure so undo whatever done here
  +	{
  +		string nosession = SESSIONLESSHANDLERS;
  +		for (pChain->m_itCurrHandler = pChain->m_HandlerList.begin(); pChain->m_itCurrHandler != pChain->m_HandlerList.end(); pChain->m_itCurrHandler++)
   		{
  -			delete pHc;
  -			return NULL;
  +			if ((*pChain->m_itCurrHandler).m_pHandler != NULL)
  +			{
  +				PoolHandler(nosession, (*pChain->m_itCurrHandler).m_pHandler, (*pChain->m_itCurrHandler).m_nScope, (*pChain->m_itCurrHandler).m_nLibId);
  +			}
   		}
  +		pChain->Fini();
  +		m_ChainStore.push_back(pChain);
  +		unlock();
  +		return Status;
  +	}
  +	else
  +	{
  +		*ppChain = pChain;
  +		unlock();
  +		return Status;
   	}
  -	return NULL;
   }
   
  -void HandlerPool::UnloadHandlerList(WSDDHandlerList *pHandlerList)
  +void HandlerPool::PoolHandlerChain(HandlerChain* pChain, string& sSessionId)
   {
  -	if (pHandlerList && !pHandlerList->empty()) {
  -		for (WSDDHandlerList::iterator it=pHandlerList->begin();
  -		it != pHandlerList->end(); it++)
  +	for (pChain->m_itCurrHandler = pChain->m_HandlerList.begin(); pChain->m_itCurrHandler != pChain->m_HandlerList.end(); pChain->m_itCurrHandler++)
  +	{
  +		if ((*pChain->m_itCurrHandler).m_pHandler != NULL)
   		{
  -			UnLoadHandler(*it);
  +			PoolHandler(sSessionId, (*pChain->m_itCurrHandler).m_pHandler, (*pChain->m_itCurrHandler).m_nScope, (*pChain->m_itCurrHandler).m_nLibId);
   		}
   	}
  +	pChain->Fini();
  +	lock();
  +	m_ChainStore.push_back(pChain);
  +	unlock();
   }
   
  -BasicHandler* HandlerPool::LoadWebService(WSDDService* pService)
  +int HandlerPool::GetWebService(BasicHandler** ppHandler, string& sSessionId, const WSDDHandler* pService)
   {
  -	return LoadHandler(pService);
  +	int Status;
  +	if ((Status = GetHandler(ppHandler, sSessionId, pService->GetScope(), pService->GetLibId())) == SUCCESS)
  +	{
  +		if (SUCCESS != (Status = (*ppHandler)->Init()))
  +		{
  +			(*ppHandler)->Fini();
  +			PoolHandler(sSessionId, *ppHandler, pService->GetScope(), pService->GetLibId());
  +			*ppHandler = NULL;
  +		}
  +	}
  +	return Status;
   }
   
  -void HandlerPool::UnloadWebService(WSDDService* pService)
  +void HandlerPool::PoolWebService(string& sSessionId, BasicHandler* pHandler, const WSDDHandler *pHandlerInfo)
   {
  -	UnLoadHandler(pService);
  +	PoolHandler(sSessionId, pHandler, pHandlerInfo->GetScope(), pHandlerInfo->GetLibId());
   }
  
  
  
  1.2       +32 -17    xml-axis/c/src/engine/HandlerLoader.h
  
  Index: HandlerLoader.h
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/HandlerLoader.h,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- HandlerLoader.h	25 Jun 2003 05:13:45 -0000	1.1
  +++ HandlerLoader.h	13 Aug 2003 14:07:47 -0000	1.2
  @@ -67,7 +67,9 @@
   #include "../common/MessageData.h"
   #include "../common/GDefine.h"
   #include "../common/WrapperClassHandler.h"
  +#include "SharedObject.h"
   
  +#include <map>
   #include <string>
   
   using namespace std;
  @@ -85,29 +87,42 @@
   #else //Linux
   #include <dlfcn.h>
   #define DLHandler void*
  -
   #endif
   
  -class HandlerLoader {
  +//status codes
  +#define HANDLER_INIT_FAIL	1
  +#define CREATION_FAILED		2
  +#define LOADLIBRARY_FAILED	3
  +#define LIBRARY_PATH_EMPTY	4
  +#define HANDLER_NOT_LOADED	5
  +#define HANDLER_BEING_USED	6
  +#define GET_HANDLER_FAILED	7
  +#define WRONG_HANDLER_TYPE	8
  +#define NO_HANDLERS_CONFIGURED	9
  +
  +class HandlerLoader : protected SharedObject
  +{
   private:
  -	BasicHandler* m_pClass;
  -	string m_sLib;
  -	int m_nLoadOptions;
  -	DLHandler m_Handler;
  -	CREATE_OBJECT m_Create;
  -	DELETE_OBJECT m_Delete;
  +	typedef struct HandlerInformation
  +	{
  +		string m_sLib;
  +		int m_nLoadOptions;
  +		DLHandler m_Handler;
  +		CREATE_OBJECT m_Create;
  +		DELETE_OBJECT m_Delete;
  +		int m_nObjCount;
  +	} HandlerInformation;
  +
  +	map<int, HandlerInformation*> m_HandlerInfoList;
  +
   public:
  -	BasicHandler* GetHandler();
  -	HandlerLoader(string &sFile, int nOptions=RTLD_LAZY);
  +	int CreateHandler(BasicHandler** pHandler, int nLibId);
  +	int DeleteHandler(BasicHandler* pHandler, int nLibId);
  +	HandlerLoader();
   	~HandlerLoader();
  -	int Initialize();
  -	int Invoke(MessageData *pMsg);
  -	int Finalize();
   private:
  -	int LoadLib();
  -	CREATE_OBJECT GetCreate();
  -	DELETE_OBJECT GetDelete();
  -	int UnloadLib();
  +	int LoadLib(HandlerInformation* pHandlerInfo);
  +	int UnloadLib(HandlerInformation* pHandlerInfo);
   };
   
   
  
  
  
  1.4       +102 -91   xml-axis/c/src/engine/HandlerLoader.cpp
  
  Index: HandlerLoader.cpp
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/HandlerLoader.cpp,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- HandlerLoader.cpp	4 Aug 2003 06:36:43 -0000	1.3
  +++ HandlerLoader.cpp	13 Aug 2003 14:07:47 -0000	1.4
  @@ -64,125 +64,136 @@
   #include "HandlerLoader.h"
   #include <stdio.h>
   #include "../common/Debug.h"
  +#include "../wsdd/WSDDDeployment.h"
   
  -HandlerLoader::HandlerLoader(string &sFile, int nOptions)
  -{
  -	m_sLib = sFile.c_str();
  -	m_nLoadOptions = nOptions;
  -	m_Handler = 0;
  -	m_pClass = NULL;
  -}
  +extern WSDDDeployment g_WSDDDeployment;
   
  -HandlerLoader::~HandlerLoader()
  +HandlerLoader::HandlerLoader()
   {
  -	if (m_pClass)
  -		m_Delete(m_pClass);
  -	if (m_Handler != 0)
  -		UnloadLib(); 
   }
   
  -int HandlerLoader::Initialize()
  +HandlerLoader::~HandlerLoader()
   {
  -	if (0 == m_Handler)
  -	{    
  -    DEBUG1("if (0 == m_Handler):HandlerLoader::Initialize()");
  -            
  -		if (LoadLib())
  -		{      
  -//			printf("LoadLib success\n");
  -			m_Create = GetCreate();
  -			m_Delete = GetDelete();
  -			if (!m_Create || !m_Delete)
  -			{
  -//				printf("could not get function pointers\n");
  -				UnloadLib();
  -				m_Handler = 0;
  -				return FAIL;
  -			}
  -			m_Create(&m_pClass);
  -			return SUCCESS;
  -		}
  -		else 
  -		{
  -//			printf("LoadLib failed\n");
  -			return FAIL;
  -		}
  +	lock();
  +	HandlerInformation* pHandlerInfo = NULL;
  +	for (map<int, HandlerInformation*>::iterator it = m_HandlerInfoList.begin(); it != m_HandlerInfoList.end(); it++)
  +	{
  +		pHandlerInfo = (*it).second;
  +		if (pHandlerInfo->m_nObjCount != 0); //it seems that some objects created have not been deleted - unexpected
  +		UnloadLib(pHandlerInfo);
  +		delete pHandlerInfo;
   	}
  -	return SUCCESS;
  +	unlock();
   }
   
  -int HandlerLoader::Invoke(MessageData *pMsg)
  +int HandlerLoader::DeleteHandler(BasicHandler* pHandler, int nLibId)
   {
  -	if (m_pClass)
  +	lock();
  +	if (m_HandlerInfoList.find(nLibId) != m_HandlerInfoList.end())
   	{
  -		return m_pClass->Invoke(pMsg);
  +		HandlerInformation* pHandlerInfo = m_HandlerInfoList[nLibId];
  +		pHandlerInfo->m_nObjCount--;
  +		pHandlerInfo->m_Delete(pHandler);
  +		if (pHandlerInfo->m_nObjCount == 0); //time to unload the DLL
  +		unlock();
  +		return SUCCESS;
   	}
  -	return FAIL;
  -}
  -
  -int HandlerLoader::Finalize()
  -{
  -	m_Delete(m_pClass);
  -	m_pClass = NULL;
  -	UnloadLib();
  -	m_Handler = 0;
  -	return SUCCESS;
  -}
  -
  -int HandlerLoader::LoadLib()
  -{
  -  
  -  DEBUG2("in HandlerLoader::LoadLib(), Lib is :", m_sLib.c_str());
  -   	
  -#ifdef WIN32
  -	m_Handler = LoadLibrary(m_sLib.c_str());
  -#else //Linux
  -  
  -	m_Handler = dlopen(m_sLib.c_str(), m_nLoadOptions);
  -  
  -  DEBUG1("after m_Handler = dlopen(m_sLib.c_str(), m_nLoadOptions);");
  -   
  -  
  -      	if (!m_Handler)
  +	else
   	{
  -    
  -//		printf("Error is :%s\n",dlerror());
  +		unlock();
  +		return HANDLER_NOT_LOADED;
   	}
  -  
  -#endif
  -	return (m_Handler != 0);
  -}
  -
  -CREATE_OBJECT HandlerLoader::GetCreate()
  -{
  -#ifdef WIN32
  -	return (CREATE_OBJECT)GetProcAddress(m_Handler,CREATE_FUNCTION);
  -#else //Linux
  -	return (CREATE_OBJECT)dlsym(m_Handler,CREATE_FUNCTION);
  -#endif
   }
   
  -DELETE_OBJECT HandlerLoader::GetDelete()
  +int HandlerLoader::LoadLib(HandlerInformation* pHandlerInfo)
   {
  +	DEBUG2("in HandlerLoader::LoadLib(), Lib is :", pHandlerInfo->m_sLib.c_str());
   #ifdef WIN32
  -	return (DELETE_OBJECT)GetProcAddress(m_Handler,DELETE_FUNCTION);
  +	pHandlerInfo->m_Handler = LoadLibrary(pHandlerInfo->m_sLib.c_str());
   #else //Linux
  -	return (DELETE_OBJECT)dlsym(m_Handler,DELETE_FUNCTION);
  +	pHandlerInfo->m_Handler = dlopen(pHandlerInfo->m_sLib.c_str(), pHandlerInfo->m_nLoadOptions);
  +	DEBUG1("after m_Handler = dlopen(pHandlerInfo->m_sLib.c_str(), pHandlerInfo->m_nLoadOptions);");  
   #endif
  +	return (pHandlerInfo->m_Handler != 0)?SUCCESS:FAIL;
   }
   
  -int HandlerLoader::UnloadLib()
  +int HandlerLoader::UnloadLib(HandlerInformation* pHandlerInfo)
   {
   #ifdef WIN32
  -	FreeLibrary(m_Handler);
  +	FreeLibrary(pHandlerInfo->m_Handler);
   #else //Linux
  -	dlclose(m_Handler);
  +	dlclose(pHandlerInfo->m_Handler);
   #endif
   	return SUCCESS;
   }
   
  -BasicHandler* HandlerLoader::GetHandler()
  +int HandlerLoader::CreateHandler(BasicHandler** pHandler, int nLibId)
   {
  -	BasicHandler* pH = m_pClass;
  -	return pH;
  +	lock();
  +	*pHandler = NULL;
  +	HandlerInformation* pHandlerInfo = NULL;
  +	if (m_HandlerInfoList.find(nLibId) == m_HandlerInfoList.end())
  +	{
  +		HandlerInformation* pHandlerInfo = new HandlerInformation();
  +		pHandlerInfo->m_sLib = g_WSDDDeployment.GetLibName(nLibId);
  +		if (pHandlerInfo->m_sLib.empty())
  +		{
  +			delete pHandlerInfo;
  +			unlock();
  +			return LIBRARY_PATH_EMPTY;
  +		}
  +		pHandlerInfo->m_nLoadOptions = RTLD_LAZY;
  +		if (SUCCESS == LoadLib(pHandlerInfo))
  +		{  
  +			#ifdef WIN32
  +			pHandlerInfo->m_Create = (CREATE_OBJECT)GetProcAddress(pHandlerInfo->m_Handler,CREATE_FUNCTION);
  +			pHandlerInfo->m_Delete = (DELETE_OBJECT)GetProcAddress(pHandlerInfo->m_Handler,DELETE_FUNCTION);
  +			#else //Linux
  +			pHandlerInfo->m_Create = (CREATE_OBJECT)dlsym(pHandlerInfo->m_Handler,CREATE_FUNCTION);
  +			pHandlerInfo->m_Delete = (DELETE_OBJECT)dlsym(pHandlerInfo->m_Handler,DELETE_FUNCTION);
  +			#endif		
  +			if (!pHandlerInfo->m_Create || !pHandlerInfo->m_Delete)
  +			{
  +				UnloadLib(pHandlerInfo);
  +				delete pHandlerInfo;
  +				unlock();
  +				return LOADLIBRARY_FAILED;
  +			}
  +			else //success
  +			{
  +				m_HandlerInfoList[nLibId] = pHandlerInfo;
  +			}
  +		}
  +		else 
  +		{
  +			unlock();
  +			return LOADLIBRARY_FAILED;
  +		}
  +	}
  +	
  +	pHandlerInfo = m_HandlerInfoList[nLibId];
  +	BasicHandler* pBH = NULL;
  +	pHandlerInfo->m_Create(&pBH);
  +	if (pBH)
  +	{
  +		if (SUCCESS == pBH->Init())
  +		{
  +			pHandlerInfo->m_nObjCount++;
  +			*pHandler = pBH;
  +			unlock();
  +			return SUCCESS;
  +		}
  +		else
  +		{
  +			pBH->Fini();
  +			delete pBH;
  +			unlock();
  +			return HANDLER_INIT_FAIL;
  +		}
  +	}
  +	else
  +	{
  +		unlock();
  +		return CREATION_FAILED;
  +	}
   }
  
  
  
  1.5       +13 -4     xml-axis/c/src/engine/HandlerChain.h
  
  Index: HandlerChain.h
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/HandlerChain.h,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- HandlerChain.h	4 Aug 2003 06:36:43 -0000	1.4
  +++ HandlerChain.h	13 Aug 2003 14:07:47 -0000	1.5
  @@ -80,18 +80,27 @@
   
   class HandlerChain : public BasicHandler  
   {
  +	friend class HandlerPool;
  +private:
  +	typedef struct ChainItem
  +	{
  +		Handler* m_pHandler;
  +		int m_nScope;
  +		int m_nLibId;
  +	} ChainItem;
   public:
  -	int AddHandler(Handler* pHandler);
  +	int AddHandler(Handler* pHandler, int nScope, int nLibId);
   	HandlerChain();
   	virtual ~HandlerChain();
  -
   	int Invoke(IMessageData* pMsg);
   	void OnFault(IMessageData* pMsg);
   	int GetType(){return CHAIN_HANDLER;};
  +	int Init();
  +	int Fini();
   
   private:
  -	list<Handler*> m_HandlerList;
  -  list<Handler*>::iterator m_itCurrHandler;
  +	list<ChainItem> m_HandlerList;
  +	list<ChainItem>::iterator m_itCurrHandler;
   };
   
   #endif // !defined(AFX_HANDLERCHAIN_H__675E51BF_2FD7_4860_B3DE_F8B5A978EB99__INCLUDED_)
  
  
  
  1.5       +21 -10    xml-axis/c/src/engine/HandlerChain.cpp
  
  Index: HandlerChain.cpp
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/HandlerChain.cpp,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- HandlerChain.cpp	15 Jul 2003 05:38:03 -0000	1.4
  +++ HandlerChain.cpp	13 Aug 2003 14:07:47 -0000	1.5
  @@ -84,17 +84,13 @@
   
   int HandlerChain::Invoke(IMessageData* pMsg)
   {
  -  
  -  DEBUG1("HandlerChain::Invoke(IMessageData* pMsg)");
  -  
  +	DEBUG1("HandlerChain::Invoke(IMessageData* pMsg)");
   	m_itCurrHandler = m_HandlerList.begin();
   	while (m_itCurrHandler != m_HandlerList.end())
   	{
  -    DEBUG1("while (m_itCurrHandler != m_HandlerList.end())");
  -		if (SUCCESS == (*m_itCurrHandler)->Invoke(pMsg))
  +		if (SUCCESS == (*m_itCurrHandler).m_pHandler->Invoke(pMsg))
   		{
   			m_itCurrHandler++;
  -      DEBUG1("if (SUCCESS == (*m_itCurrHandler)->Invoke(pMsg))");
   		}
   		else
   		{
  @@ -102,7 +98,7 @@
   			return FAIL;
   		}
   	}
  -  DEBUG1("HandlerChain::Invoke end");
  +	DEBUG1("HandlerChain::Invoke end");
   	return SUCCESS;
   }
   
  @@ -110,14 +106,29 @@
   {
   	while (m_itCurrHandler != m_HandlerList.begin())
   	{
  -		(*m_itCurrHandler)->OnFault(pMsg);
  +		(*m_itCurrHandler).m_pHandler->OnFault(pMsg);
   		m_itCurrHandler--;
   	}
   }
   
  -int HandlerChain::AddHandler(Handler *pHandler)
  +int HandlerChain::AddHandler(Handler* pHandler, int nScope, int nLibId)
   {
  -	m_HandlerList.push_back(pHandler);
  +	ChainItem item;
  +	item.m_pHandler = pHandler;
  +	item.m_nScope = nScope;
  +	item.m_nLibId = nLibId;
  +	m_HandlerList.push_back(item);
  +	return SUCCESS;
  +}
   
  +int HandlerChain::Init()
  +{
  +	m_HandlerList.clear();
   	return SUCCESS;
  +}
  +
  +int HandlerChain::Fini()
  +{
  +	m_HandlerList.clear();
  +	return SUCCESS;	
   }
  
  
  
  1.5       +18 -19    xml-axis/c/src/engine/AxisEngine.h
  
  Index: AxisEngine.h
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/AxisEngine.h,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- AxisEngine.h	27 Jul 2003 09:59:47 -0000	1.4
  +++ AxisEngine.h	13 Aug 2003 14:07:47 -0000	1.5
  @@ -67,36 +67,35 @@
   #define __AXISENGINE_INCLUDED__
   
   #include "../common/GDefine.h"
  -#include "../common/BasicHandler.h"
  -#include "../wsdd/WSDDDeployment.h"
  -#include "HandlerPool.h"
  -
   #include "../common/Packet.h"
  +#include "../soap/SoapSerializer.h"
  +#include "../soap/SoapDeSerializer.h"
  +#include "../common/BasicHandler.h"
  +#include "../common/MessageData.h"
  +#include "HandlerChain.h"
   
  -class AxisEngine // : public BasicHandler
  +class AxisEngine 
   {
   private:	
  -	static AxisEngine* m_pObject; //Singleton object.
   	SoapSerializer* m_pSZ;
   	SoapDeSerializer* m_pDZ;
  -	WSDDDeployment* m_pWSDD;
  -	HandlerPool* m_pHandlerPool;
  -//  string m_sResponse;
  -private:
  +	HandlerChain* m_pGReqFChain;
  +	HandlerChain* m_pGResFChain;
  +	HandlerChain* m_pTReqFChain;
  +	HandlerChain* m_pTResFChain;
  +	HandlerChain* m_pSReqFChain;
  +	HandlerChain* m_pSResFChain;
   	BasicHandler* m_pWebService;
  -	int Initialize();
  -	void UnInitialize();
  -	AxisEngine();
  -
   public:
  +	AxisEngine();
   	~AxisEngine();
  -
  +	int Process(Ax_soapstream* soap);
  +private:
   	int Invoke(MessageData* pMsg);
   	void OnFault(MessageData* pMsg);
  -
  -	static AxisEngine* GetAxisEngine();
  -	int Process(soapstream* soap);
  -	WSDDDeployment* getWSDDDeployment();
  +	int Initialize();
  +	int InitializeHandlers(string& sSessionId, AXIS_PROTOCOL_TYPE protocol);
  +	void UnInitialize();
   };
   
   #endif
  
  
  
  1.14      +238 -349  xml-axis/c/src/engine/AxisEngine.cpp
  
  Index: AxisEngine.cpp
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/AxisEngine.cpp,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- AxisEngine.cpp	1 Aug 2003 07:05:02 -0000	1.13
  +++ AxisEngine.cpp	13 Aug 2003 14:07:47 -0000	1.14
  @@ -64,21 +64,12 @@
   #include <stdio.h>
   #include "AxisEngine.h"
   #include "../common/AxisException.h"
  -#include "../common/MessageData.h"
  -#include "../soap/SoapSerializer.h"
  -#include "../soap/SoapDeSerializer.h"
  -#include "../soap/SoapFaults.h"
  -#include "../soap/URIMapping.h"
   #include "../common/Debug.h"
   #include "../common/Packet.h"
  -
  -
  -#ifdef WIN32
  -//#define WSDDFILEPATH "./Axis/conf/server.wsdd"
  -#define WSDDFILEPATH "C:/Apache/Axis/server.wsdd"
  -#else //For linux
  -#define WSDDFILEPATH "/usr/local/axiscpp/axis/server.wsdd"
  -#endif
  +#include "../wsdd/WSDDDeployment.h"
  +#include "HandlerPool.h"
  +#include "DeserializerPool.h"
  +#include "SerializerPool.h"
   
   //extern int send_response_bytes(char * res);
   
  @@ -86,344 +77,253 @@
   
   //extern int send_transport_information(soapstream *);
   
  -
  -AxisEngine* AxisEngine::m_pObject = NULL;
  +extern DeserializerPool g_DeserializerPool;
  +extern SerializerPool g_SerializerPool;
  +extern HandlerPool g_HandlerPool;
  +extern WSDDDeployment g_WSDDDeployment;
   
   AxisEngine::AxisEngine()
   {
  -	//Create Serializer and Deserializer
  -	m_pSZ = new SoapSerializer();
  -	m_pDZ = new SoapDeSerializer();  
  -	m_pWSDD = new WSDDDeployment();
  -	m_pHandlerPool = new HandlerPool();
  +	m_pSZ = NULL;
  +	m_pDZ = NULL;  
  +	m_pGReqFChain = NULL;
  +	m_pGResFChain = NULL;
  +	m_pTReqFChain = NULL;
  +	m_pTResFChain = NULL;
  +	m_pSReqFChain = NULL;
  +	m_pSResFChain = NULL;
   	m_pWebService = NULL;
  -  
  -  //printf("Done WSDD\n");
   }
   
   AxisEngine::~AxisEngine()
   {
  -	delete m_pSZ;
  -	delete m_pDZ;
  -	delete m_pWSDD;
  -	delete m_pHandlerPool;
  -	//unload xerces DLL
  -	XMLPlatformUtils::Terminate();
  -}
  -
  -WSDDDeployment * AxisEngine::getWSDDDeployment()
  -{
  -	if(m_pWSDD)
  -	{
  -		return m_pWSDD; 
  -	}
  -	return NULL;
   }
   
  -AxisEngine* AxisEngine::GetAxisEngine()
  +int AxisEngine::Process(Ax_soapstream* soap) 
   {
  -	if (!m_pObject)
  -	{
  -		try
  -		{
  -      DEBUG1("AxisEngine::GetAxisEngine()");
  -			XMLPlatformUtils::Initialize();
  -			m_pObject = new AxisEngine();
  -			if (!m_pObject) return NULL;
  -			if(SUCCESS != m_pObject->Initialize())
  -			{
  -				m_pObject->UnInitialize();
  -				delete m_pObject;
  -				m_pObject = NULL;
  -				return NULL;
  +	int Status;
  +	AXIS_TRY
  +		DEBUG1("AxisEngine::Process");
  +		MessageData* pMsg = NULL;
  +		const WSDDService* pService = NULL;
  +		string sSessionId = soap->sessionid;
  +		int nSoapVersion;
  +
  +		do {
  +			//create and populate MessageData
  +			if (SUCCESS != Initialize())
  +			{
  +				nSoapVersion = m_pDZ->GetVersion();
  +				nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion;
  +				m_pSZ->setSoapVersion((SOAP_VERSION)nSoapVersion);
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADSRV));
  +				break; //do .. while(0)
  +			}
  +			pMsg = new MessageData();
  +			pMsg->m_Protocol = soap->trtype;
  +			pMsg->SetSerializer(m_pSZ);
  +			pMsg->SetDeSerializer(m_pDZ);
  +    
  +			if (SUCCESS != m_pDZ->SetInputStream(soap->str.ip_stream))
  +			{
  +				nSoapVersion = m_pDZ->GetVersion();
  +				nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion;
  +				m_pSZ->setSoapVersion((SOAP_VERSION)nSoapVersion);
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SOAPCONTENTERROR));
  +				break; //do .. while(0)
   			}
  -		}
  -		catch (...)
  -		{
  -			return NULL;
  -		}	
  -	}
  -	return m_pObject;
  -}
   
  -int AxisEngine::Process(soapstream* soap) 
  -{
  +			char* cService= getheader(soap, SOAPACTIONHEADER);
  +			string service = (cService == NULL)? "" : cService;
  +		  
  +			DEBUG2("string service = ",service.c_str());
  +     
  +			if (service.empty()) 
  +			{
  +				nSoapVersion = pMsg->m_pDZ->GetVersion();
  +				nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion;
  +				m_pSZ->setSoapVersion((SOAP_VERSION)nSoapVersion);
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SOAPACTIONEMPTY));
  +				break; //do .. while(0)
  +			}
  +			if (service.find('\"') != string::npos) //if there are quotes remove them.
  +			{
  +				service = service.substr(1, service.length() - 2);
  +			}
   
  -  try
  -  {
  -    DEBUG1("AxisEngine::Process");
  - 
  -	  MessageData* pMsg = NULL;
  -	  MemBufInputSource* pSoapInput = NULL;
  -	  WSDDHandlerList* pHandlerList = NULL;
  -	  WSDDService* pService = NULL;
  -	  do {
  -		  //Initialize Serializer and Deserializer objects
  -		  m_pSZ->init();
  -		  m_pDZ->Init();
  -		  //create and populate MessageData
  -		  pMsg = new MessageData();
  -		  pMsg->m_Protocol = soap->trtype;
  -		  pMsg->SetSerializer(m_pSZ);
  -		  pMsg->SetDeSerializer(m_pDZ);
  -    
  -		  //Adding SoapEnvelop and SoapBody to Serializer
  -		  SoapEnvelope* pEnv = new SoapEnvelope();
  -		  pMsg->m_pSZ->setSoapEnvelope(pEnv);
  -		  pMsg->m_pSZ->setSoapBody(new SoapBody());
  -
  -		  //---------------------start--------------------------
  -
  -		  //Deserialize
  -		  //---------START XERCES SAX2 SPCIFIC CODE---------//
  -          //a huge buffer to store the whole soap request stream
  -		  char hugebuffer[10000];
  -         //to store the number of chars returned by get_request_bytes
  -		  int nChars = 0;
  -          //request a huge number of bytes to get the whole soap request
  -          //when pull parsing is used this should change
  -		  get_request_bytes(hugebuffer, 10000, &nChars);
  -		  DEBUG1(hugebuffer);      
  -          //if no soap then quit
  -		  if (nChars <= 0) break;
  -		  pSoapInput = new MemBufInputSource((const unsigned char*)hugebuffer, nChars ,"bufferid",false);
  -
  -		  if (SUCCESS != m_pDZ->SetStream(pSoapInput)) //this parses the full soap request.
  -		  {
  -			  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SOAPCONTENTERROR));
  -			  break; //do .. while(0)
  -		  }
  -		  //---------END XERCES SAX2 SPCIFIC CODE---------//
  +			//get service description object from the WSDD
  +			pService = g_WSDDDeployment.GetService(service);
  +			if (!pService) 
  +			{
  +				nSoapVersion = pMsg->m_pDZ->GetVersion();
  +				nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion;
  +				m_pSZ->setSoapVersion((SOAP_VERSION)nSoapVersion);
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SERVICENOTFOUND));
  +				break; //do .. while(0)
  +			}
   
  -		  int nSoapVersion = pMsg->m_pDZ->GetVersion();
  +			pMsg->SetService(pService);
  +			
  +			//check for soap version in the request and decide whether we support it or not
  +			//if we do not support send a soapfault with version mismatch.		  
  +			nSoapVersion = pMsg->m_pDZ->GetVersion();
  +			if (nSoapVersion == VERSION_LAST) //version not supported
  +			{
  +				m_pSZ->setSoapVersion(SOAP_VER_1_2);
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_VERSION_MISMATCH));
  +				break; //do .. while(0)		
  +			}		  
   
  -		  //Set Soap version in the Serializer
  -		  pMsg->m_pSZ->setSoapVersion((SOAP_VERSION)nSoapVersion);
   
  -		  //---------------------end--------------------------
  -		  
  +			//Set Soap version in the Serializer and the envelope
  +			if (SUCCESS != m_pSZ->setSoapVersion((SOAP_VERSION)nSoapVersion))
  +			{
  +			  m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SOAPCONTENTERROR));
  +			  break; //do .. while(0)
  +			}
   
  -		  char* cService= getheader(soap, SOAPACTIONHEADER);
  -			string service;
  -		  if(cService==NULL) {
  -				service="";
  -		  }else {
  -				service= cService;
  -		  }
  -		  
  -		  DEBUG2("string service = Maths :",service.c_str());
  -     
  -		  if (service.empty()) 
  -		  {
  -			  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SOAPACTIONEMPTY));
  +			SoapMethod* pSm = m_pDZ->GetMethod();
  +			if (pSm) 
  +			{
  +				string method = pSm->getMethodName();
  +				DEBUG2("pSm->getMethodName(); :", method.c_str());
  +				if (!method.empty())
  +				{
  +					if (pService->IsAllowedMethod(method))
  +					{          
  +						//load actual web service handler
  +						if (SUCCESS != g_HandlerPool.GetWebService(&m_pWebService, sSessionId, pService))
  +						{
  +            				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADSRV));
  +							//Error couldnot load web service
  +							break; //do .. while(0)
  +						}
  +					}
  +					else
  +					{
  +						m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_METHODNOTALLOWED));
  +						//method is not an exposed allowed method
  +						break; //do .. while(0)
  +					}
  +				}
  +				else
  +				{
  +					m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_NOSOAPMETHOD));
  +					//no method to be invoked
  +					break; //do .. while(0)
  +				}
  +			}
  +			//Get Global and Transport Handlers
  +			if(SUCCESS != (Status = InitializeHandlers(sSessionId, soap->trtype)))
  +			{
  +			  m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADHDL));
   			  break; //do .. while(0)
  -		  }
  -		  service = service.substr(1, service.length() - 2);
  -		  pService = m_pWSDD->GetService(service);
  -		  if (!pService) {
  -			  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_SERVICENOTFOUND));
  +			}
  +    		//Get Service specific Handlers from the pool if configured any
  +			if(SUCCESS != (Status = g_HandlerPool.GetRequestFlowHandlerChain(&m_pSReqFChain, sSessionId, pService)))
  +			{        
  +			  m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADHDL));
   			  break; //do .. while(0)
  -		  }
  -
  -      pMsg->SetService(pService);
  -
  -			
  -		  //check for soap version in the request and decide whether we support it or not
  -		  //if we do not support send a soapfault with version mismatch.		  
  -		  if (nSoapVersion == VERSION_LAST) //version not supported
  -		  {
  -			  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_VERSION_MISMATCH));
  -			  break; //do .. while(0)		
  -		  }		  
  -
  -		  //add namespace URIs of the SoapEnvelope of the response corresponding to the soap version.
  -		  Attribute* pNS = new Attribute(g_sObjSoapEnvVersionsStruct[nSoapVersion].pchEnvelopePrefix,
  -			  "xmlns","",g_sObjSoapEnvVersionsStruct[nSoapVersion].pchEnvelopeNamespaceUri);
  -		  pEnv->addNamespaceDecl(pNS);
  -		  //add namespace URIs for xsd and xsi
  -		  pNS = new Attribute("xsd","xmlns","","http://www.w3.org/2001/XMLSchema");
  -		  pEnv->addNamespaceDecl(pNS);
  -		  pNS = new Attribute("xsi","xmlns","","http://www.w3.org/2001/XMLSchema-instance");
  -		  pEnv->addNamespaceDecl(pNS);
  -
  -		  SoapMethod* pSm = m_pDZ->GetMethod();
  -		  if (pSm) 
  -		  {
  -			  string method = pSm->getMethodName();
  -      
  -        DEBUG2("pSm->getMethodName(); :", method.c_str());
  -          
  -			  if (!method.empty())
  -			  {
  -				  //this is done here when we use SAX parser
  -				  //if we use XML pull parser this check is done within the invoke method of the wrapper class
  -				  if (pService->IsAllowedMethod(method))
  -				  {          
  -					  //load actual web service handler
  -         
  -					  m_pWebService = m_pHandlerPool->LoadWebService(pService);
  -
  -                    
  -					  if (!m_pWebService)
  -					  {
  -            
  -						  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADSRV));
  -						  //Error couldnot load web service
  -						  break; //do .. while(0)
  -					  }
  -				  }
  -				  else
  -				  {
  -					  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_METHODNOTALLOWED));
  -					  //method is not an exposed allowed method
  -					  break; //do .. while(0)
  -				  }
  -			  }
  -			  else
  -			  {
  -				  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_NOSOAPMETHOD));
  -				  //no method to be invoked
  -				  break; //do .. while(0)
  -			  }
  -		  }
  -		  //create any service specific handlers
  -    
  -		  pHandlerList = pService->GetRequestFlowHandlers();
  +			}
  +			if(SUCCESS != (Status = g_HandlerPool.GetResponseFlowHandlerChain(&m_pSResFChain, sSessionId, pService)))
  +			{        
  +			  m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADHDL));
  +			  break; //do .. while(0)
  +			}
   
  -      DEBUG1("after pService->GetRequestFlowHandlers();");
  -       
  -		  if (pHandlerList)
  -		  {
  -
  -			  if(SUCCESS != m_pHandlerPool->LoadServiceRequestFlowHandlers(pHandlerList))
  -			  {        
  -				  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADHDL));
  -				  break; //do .. while(0)
  -			  }
  -		  }
  -    
  -		  pHandlerList = pService->GetResponseFlowHandlers();
  -    
  -		  if (pHandlerList)
  -		  {
  -			  if(SUCCESS != m_pHandlerPool->LoadServiceResponseFlowHandlers(pHandlerList))
  -			  {
  -				  pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_COULDNOTLOADHDL));
  -				  break; //do .. while(0)
  -			  }
  -		  }
  -		  Invoke(pMsg); //we generate response in the same way even if this has failed
  -	  }
  -	  while(0);
  -	  //and handlers may add headers to the Serializer.
  -	  //Invoke all handlers including the webservice
  -	  //in case of failure coresponding soap fault message will be sent
  -	  if (pMsg) delete pMsg; //MessageData is no longer needed
  -	  if (pSoapInput) delete pSoapInput; //this should not be done if we use progressive parsing
  -	  //set soap version to the serializer.
  -	  //Serialize
  -	  send_transport_information(soap);
  -	  int iStatus= m_pSZ->getStream();
  -      
  -	  //soap->so.http.op_soap = new char(sResponse.length() + 1); 
  -	  //strcpy(soap->so.http.op_soap, sResponse.c_str());
  -  #ifndef _DEBUG //this caused program to crash in debug mode
  -	  m_pSZ->init();
  -  #endif 
  -	//unload webservice handler
  -  #ifndef WIN32 //this crashes in Win32 at stl map::find(..) function - I cannot find what is wrong.
  -	  if (m_pWebService) m_pHandlerPool->UnloadWebService(pService);
  -	  //Unload service specific handlers
  -	  pHandlerList = pService->GetRequestFlowHandlers();
  -	  if (pHandlerList)
  -		  m_pHandlerPool->UnLoadServiceRequestFlowHandlers(pHandlerList);
  -	  pHandlerList = pService->GetResponseFlowHandlers();
  -	  if (pHandlerList)
  -		  m_pHandlerPool->UnLoadServiceResponseFlowHandlers(pHandlerList);
  -  #endif
  -	  return SUCCESS;
  - }
  - catch(exception* e)
  - {
  -   //todo
  -   /*
  -    An exception derived from exception which is not handled will be handled here.
  -    You can call a method in AxisModule which may unload the AxisEngine
  -    from the webserver and report the error. You can also write this
  -    in a logfile specific to axis.
  -   */
  -   DEBUG1(e->what());   
  -   delete(e);
  - }
  - catch(...)
  - {
  -   //todo
  -   /*
  -    An unknown exception which is not handled will be handled here.
  -    You can call a method in AxisModule which may unload the AxisEngine
  -    from the webserver and report the error. You can also write this
  -    in a logfile specific to axis.
  -   */
  -   DEBUG1("UNKNOWN EXCEPTION");
  - }
  +			//and handlers may add headers to the Serializer.
  +			//Invoke all handlers including the webservice
  +			//in case of failure coresponding soap fault message will be set
  +			Status = Invoke(pMsg); //we generate response in the same way even if this has failed
  +		}
  +		while(0);
  +		if (pMsg) delete pMsg; //MessageData is no longer needed
  +		//send any transoport information like http headers first
  +		send_transport_information(soap);
  +		//Serialize
  +		m_pSZ->SetOutputStream(soap->str.ip_stream);
  +
  +		//Pool back the Service specific handlers
  +		if (m_pSReqFChain) g_HandlerPool.PoolHandlerChain(m_pSReqFChain, sSessionId);
  +		if (m_pSResFChain) g_HandlerPool.PoolHandlerChain(m_pSResFChain, sSessionId);
  +		//Pool back the webservice
  +		if (m_pWebService) g_HandlerPool.PoolWebService(sSessionId, m_pWebService, pService); 
  +		return Status;
  +	AXIS_CATCH(exception* e)
  +		//todo
  +		/*
  +		An exception derived from exception which is not handled will be handled here.
  +		You can call a method in AxisModule which may unload the AxisEngine
  +		from the webserver and report the error. You can also write this
  +		in a logfile specific to axis.
  +		*/
  +		#ifdef _DEBUG
  +		DEBUG1(e->what());   
  +		delete(e);
  +		#endif
  +	AXIS_CATCH(...)
  +		//todo
  +		/*
  +		An unknown exception which is not handled will be handled here.
  +		You can call a method in AxisModule which may unload the AxisEngine
  +		from the webserver and report the error. You can also write this
  +		in a logfile specific to axis.
  +		*/
  +		DEBUG1("UNKNOWN EXCEPTION");
  +	AXIS_ENDCATCH
  +	return Status;
   }
   
   int AxisEngine::Invoke(MessageData* pMsg)
   {
   	enum AE_LEVEL {AE_START=1, AE_TRH, AE_GLH, AE_SERH, AE_SERV};
  -	HandlerChain* pChain;
  -	int ret = FAIL;
  +	int Status = FAIL;
   	int level = AE_START;
   	do
   	{
   		//invoke transport request handlers
  -		pChain = m_pHandlerPool->GetTransportRequestFlowHandlerChain(pMsg->m_Protocol);
  -		if (pChain) {
  -			if(SUCCESS != pChain->Invoke(pMsg))
  +		if (m_pTReqFChain) {
  +			if(SUCCESS != (Status = m_pTReqFChain->Invoke(pMsg)))
   			{
  -				pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_HANDLERFAILED));
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_HANDLERFAILED));
   				break; //do .. while (0)
   			}
   
   		}
  -    DEBUG1("AFTER pChain = m_pHandlerPool->GetTransportRequestFlowHandlerChain");
  +		DEBUG1("AFTER invoke transport request handlers");
   		level++; // AE_TRH
   		//invoke global request handlers
  -		pChain = m_pHandlerPool->GetGlobalRequestFlowHandlerChain();
  -		if (pChain)
  +		if (m_pGReqFChain)
   		{
  -			if(SUCCESS != pChain->Invoke(pMsg))
  +			if(SUCCESS != (Status = m_pGReqFChain->Invoke(pMsg)))
   			{
  -				pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_HANDLERFAILED));
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_HANDLERFAILED));
   				break; //do .. while (0)
   			}		
   		}
  -    DEBUG1("AFTER pChain = m_pHandlerPool->GetGlobalRequestFlowHandlerChain();");
  +		DEBUG1("AFTER invoke global request handlers");
   		level++; //AE_GLH
   		//invoke service specific request handlers
  -		pChain = m_pHandlerPool->GetServiceRequestFlowHandlerChain();
  -		if (pChain)
  +		if (m_pSReqFChain)
   		{
  -			if(SUCCESS != pChain->Invoke(pMsg))
  +			if(SUCCESS != (Status = m_pSReqFChain->Invoke(pMsg)))
   			{
  -				pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_HANDLERFAILED));
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_HANDLERFAILED));
   				break; //do .. while (0)
   			}
  -      DEBUG1("if(SUCCESS == pChain->Invoke(pMsg))");
   		}
  -    DEBUG1("AFTER pChain = m_pHandlerPool->GetServiceRequestFlowHandlerChain();");
  +		DEBUG1("AFTER invoke service specific request handlers");
   		level++; //AE_SERH
   		//call actual web service handler
  -
   		if (m_pWebService)
  -			if (SUCCESS != m_pWebService->Invoke(pMsg))
  +		{
  +			if (SUCCESS != (Status = m_pWebService->Invoke(pMsg)))
   			{
  -				pMsg->m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_WEBSERVICEFAILED));
  +				m_pSZ->setSoapFault(SoapFault::getSoapFault(SF_WEBSERVICEFAILED));
   				break;
  -			}
  -
  -    DEBUG1("if (m_pWebService)");      
  -         
  +			}        
  +		}
  +		DEBUG1("AFTER call actual web service handler");
   		level++; //AE_SERV
   	}
   	while(0);
  @@ -433,37 +333,32 @@
   	switch (level)
   	{
   	case AE_SERV: //everything success
  -    ret = SUCCESS;
  -		//invoke service specific response handlers
  +		Status = SUCCESS;
   		//no break;
   	case AE_SERH: //actual web service handler has failed
   		//invoke web service specific response handlers
  -    pChain = m_pHandlerPool->GetServiceResponseFlowHandlerChain();
  -		if (pChain)
  +		if (m_pSResFChain)
   		{
  -			pChain->Invoke(pMsg);
  -      
  +			m_pSResFChain->Invoke(pMsg);
   		}
   		//no break;
   	case AE_GLH: //web service specific handlers have failed
   		//invoke global response handlers
  -		pChain = m_pHandlerPool->GetGlobalResponseFlowHandlerChain();
  -		if (pChain)
  +		if (m_pGResFChain)
   		{
  -			pChain->Invoke(pMsg);
  +			m_pGResFChain->Invoke(pMsg);
   		}
   		//no break;
   	case AE_TRH: //global handlers have failed
  -		pChain = m_pHandlerPool->GetTransportResponseFlowHandlerChain(pMsg->m_Protocol);
  -		if (pChain) 
  +		if (m_pTResFChain) 
   		{
  -			pChain->Invoke(pMsg);
  +			m_pTResFChain->Invoke(pMsg);
   		}
   		//no break;
   	case AE_START:;//transport handlers have failed
   	};
  -  DEBUG1("end axisengine process()");
  -	return ret;
  +	DEBUG1("end axisengine process()");
  +	return Status;
   }
   
   void AxisEngine::OnFault(MessageData* pMsg)
  @@ -473,44 +368,21 @@
   
   int AxisEngine::Initialize()
   {
  -	string str(WSDDFILEPATH);
  -	TypeMapping::Initialize();
  -	URIMapping::Initialize();
  -	SoapFault::initialize();
  -  
  -  DEBUG1("AxisEngine::Initialize()");
  -      
  -	if (SUCCESS != m_pWSDD->LoadWSDD(str)) return FAIL;
  -  
  -	//Load Global Handlers to the pool if configured any
  -	WSDDHandlerList* pHandlerList = m_pWSDD->GetGlobalRequestFlowHandlers();
  -	if (pHandlerList)
  -		if(SUCCESS != m_pHandlerPool->LoadGlobalRequestFlowHandlers(pHandlerList))
  -			return FAIL;
  -	pHandlerList = m_pWSDD->GetGlobalResponseFlowHandlers();
  -	if (pHandlerList)
  -		if(SUCCESS != m_pHandlerPool->LoadGlobalResponseFlowHandlers(pHandlerList))
  -			return FAIL;
  -
  -	//Load Transport Handlers to the pool if configured any
  -	WSDDTransport* pTransport = m_pWSDD->GetTransport();
  -	if (pTransport) {
  -		//HTTP
  -		pHandlerList = pTransport->GetRequestFlowHandlers(APTHTTP);
  -		if (pHandlerList)
  -			if(SUCCESS != m_pHandlerPool->LoadTransportRequestFlowHandlers(APTHTTP, pHandlerList))
  -				return FAIL;
  -		//FTP
  -		pHandlerList = pTransport->GetRequestFlowHandlers(APTFTP);
  -		if (pHandlerList)
  -			if(SUCCESS != m_pHandlerPool->LoadTransportRequestFlowHandlers(APTFTP, pHandlerList))
  -				return FAIL;
  -		//SMTP
  -		pHandlerList = pTransport->GetRequestFlowHandlers(APTSMTP);
  -		if (pHandlerList)
  -			if(SUCCESS != m_pHandlerPool->LoadTransportRequestFlowHandlers(APTSMTP, pHandlerList))
  -				return FAIL;
  +	int Status;
  +	//Create and initialize Serializer and Deserializer objects
  +	if (SUCCESS != (Status = g_SerializerPool.GetInstance(&m_pSZ))) return Status;
  +	if (SUCCESS != (Status = m_pSZ->Init()))
  +	{
  +		g_SerializerPool.PutInstance(m_pSZ);
  +		return Status;
  +	}
  +	if (SUCCESS != (Status = g_DeserializerPool.GetInstance(&m_pDZ))) return Status;
  +	if (SUCCESS != (Status = m_pDZ->Init()))
  +	{
  +		g_DeserializerPool.PutInstance(m_pDZ);
  +		return Status;
   	}
  +
   	return SUCCESS;
   }
   
  @@ -518,4 +390,21 @@
   {
   	//nothing to do with m_pWSDD because its destructor deletes its objects
   	//nothing to do with m_pHandlerPool because its destructor deletes its objects
  -}
  \ No newline at end of file
  +}
  +
  +int AxisEngine::InitializeHandlers(string &sSessionId, AXIS_PROTOCOL_TYPE protocol)
  +{
  +	int Status = SUCCESS;  
  +	//Get Global Handlers from the pool if configured any
  +	if(SUCCESS != (Status = g_HandlerPool.GetGlobalRequestFlowHandlerChain(&m_pGReqFChain, sSessionId)))
  +		return Status;
  +	if(SUCCESS != (Status = g_HandlerPool.GetGlobalResponseFlowHandlerChain(&m_pGResFChain, sSessionId)))
  +		return Status;
  +
  +	//Get Transport Handlers from the pool if configured any
  +	if(SUCCESS != (Status = g_HandlerPool.GetTransportRequestFlowHandlerChain(&m_pTReqFChain, sSessionId, protocol)))
  +		return Status;
  +	if(SUCCESS != (Status = g_HandlerPool.GetTransportResponseFlowHandlerChain(&m_pTResFChain, sSessionId, protocol)))
  +		return Status;
  +	return Status;
  +}
  
  
  
  1.6       +95 -57    xml-axis/c/src/engine/Axis.cpp
  
  Index: Axis.cpp
  ===================================================================
  RCS file: /home/cvs/xml-axis/c/src/engine/Axis.cpp,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- Axis.cpp	27 Jul 2003 10:03:33 -0000	1.5
  +++ Axis.cpp	13 Aug 2003 14:07:47 -0000	1.6
  @@ -1,3 +1,5 @@
  +#pragma warning (disable : 4503)
  +
   #include "AxisEngine.h"
   #include "../common/Debug.h"
   #include <stdio.h>
  @@ -7,51 +9,81 @@
   #include <string>
   #include <map>
   
  -#define res(X); send_response_bytes(X);
  +#include "../soap/SoapFaults.h"
  +#include "../soap/URIMapping.h"
  +#include "HandlerLoader.h"
  +#include "AppScopeHandlerPool.h"
  +#include "RequestScopeHandlerPool.h"
  +#include "SessionScopeHandlerPool.h"
  +#include "HandlerPool.h"
  +#include "SerializerPool.h"
  +#include "DeserializerPool.h"
  +#include "../wsdd/WSDDDeployment.h"
  +
  +#define BYTESTOREAD 64
  +//the relative location of the wsdl files hardcoded
  +#define WSDLDIRECTORY	"./Axis/wsdl/"
  +
  +#ifdef WIN32
  +#ifdef AXIS_APACHE1_3
  +#define WSDDFILEPATH "./Axis/conf/server.wsdd"
  +#else
  +#define WSDDFILEPATH "C:/Axis/conf/server.wsdd"
  +#endif
  +#else //For linux
  +#ifdef AXIS_APACHE1_3
  +#define WSDDFILEPATH "./Axis/conf/server.wsdd"
  +#else
  +#define WSDDFILEPATH "/usr/local/axiscpp/axis/server.wsdd"
  +#endif
  +#endif
   
  +//define all global variables of the axisengine
  +#ifdef _DEBUG
   unsigned char chEBuf[1024];
  +#endif
   
  -extern "C" int process_request(soapstream *str)
  -{
  -DEBUG1("in axis.cpp");	
  -	AxisEngine* engine = AxisEngine::GetAxisEngine();	
  -	int ret = FAIL;
  -	char * wsdlloc = NULL;
  -	char * uri = NULL;
  -	int pos=0;
  -	int slashcount=0;
  -	int len = 0;
  -
  -	FILE * outfile;
  -	const int bytestoread = 6;
  -	char oneword [bytestoread];
  -	oneword[bytestoread-1] = '\0';
  +//synchronized global variables.
  +HandlerLoader g_HandlerLoader;
  +AppScopeHandlerPool g_AppScopeHandlerPool;
  +RequestScopeHandlerPool g_RequestScopeHandlerPool;
  +SessionScopeHandlerPool g_SessionScopeHandlerPool;
  +DeserializerPool g_DeserializerPool;
  +SerializerPool g_SerializerPool;
  +HandlerPool g_HandlerPool;
  +//un synchronized read-only global variables.
  +WSDDDeployment g_WSDDDeployment;
   
  +extern "C" int process_request(Ax_soapstream *str)
  +{
  +	DEBUG1("in axis.cpp");	
  +	int Status = FAIL;
  +	FILE * WsddFile;
  +	char ReadBuffer[BYTESTOREAD];
  +	ReadBuffer[0] = '\0';
   
  -	const WSDDServiceMap * svsmap = NULL;
  +	const WSDDServiceMap* pSrvMap = NULL;
   	WSDDServiceMap::const_iterator iter;
  -	WSDDService * svs = NULL;
  -	//the location of the wsdl files hardcoded
  -	string svr("./Axis/wsdl/");
  +	WSDDService* pService = NULL;
   
  -	switch(str->trtype)
  +	switch (str->trtype)
   	{
   		case APTHTTP:
   			//Handle the POST method
  -			if(str->so.http.ip_method==POST)
  +			if (str->so.http.ip_method == AXIS_HTTP_POST)
   			{
  -DEBUG1("method is POST");                
  +				DEBUG1("method is POST");
  +				AxisEngine* engine = new AxisEngine();	
   				if (engine)
   				{
  -					ret = engine->Process(str);
  -					DEBUG1("ret = engine->Process(str);");
  +					Status = engine->Process(str);
  +					DEBUG1("Status = engine->Process(str);");
   				    DEBUG1("are we successful?");            
  -					ret = SUCCESS;
  +					Status = SUCCESS;
   				}
   			}
  -
   			//Handler the GET method
  -			if(str->so.http.ip_method==GET)
  +			if (str->so.http.ip_method == AXIS_HTTP_GET)
   			{
   				//get the uri path
   				//i.e "/abc/xyz/" part of http://somehost/abc/xyz/
  @@ -68,64 +100,70 @@
   				{	
   					bNoSlash = true;
   				}
  +
   				if (sUriWOAxis.empty())
   				{
  -					svsmap = engine->getWSDDDeployment()->GetWSDDServiceMap();
  -					//dep = engine->getWSDDDeployment();
  -					//svsmap = depGetWSDDServiceMap();
  -					res("<html><body>\
  +					pSrvMap = g_WSDDDeployment.GetWSDDServiceMap();
  +					send_response_bytes("<html><body>\
   						<h1 align=\"center\">Welcome to Axis C++</h1>\
   						<br>\
   						<h2>List of Deployed Web services<br></h2>\
   						<h3>click on the links to view the WSDL</h3>\
   						<br>\
  -						<table width=\"400\">");
  +						<table width=\"400\">", str->str.op_stream);
   
  -					for (iter=svsmap->begin();iter!=svsmap->end();iter++)
  +					for (iter = pSrvMap->begin();iter != pSrvMap->end();iter++)
   					{
  -						svs = iter->second;
  -						res("<tr><td width=\"200\">");
  -						res((char *)svs->GetServiceName().c_str());
  -						res("</td><td width=\"200\"><a href=\"./");
  -						if (bNoSlash) send_response_bytes("axis/"); 
  -						send_response_bytes((char *)svs->GetServiceName().c_str());
  -						send_response_bytes("?wsdl");
  -						send_response_bytes("\">wsdl</a></td>");
  -						res("</tr>");
  +						pService = iter->second;
  +						send_response_bytes("<tr><td width=\"200\">", str->str.op_stream);
  +						send_response_bytes((char *)pService->GetServiceName().c_str(), str->str.op_stream);
  +						send_response_bytes("</td><td width=\"200\"><a href=\"./", str->str.op_stream);
  +						if (bNoSlash) send_response_bytes("axis/", str->str.op_stream); 
  +						send_response_bytes((char *)pService->GetServiceName().c_str(), str->str.op_stream);
  +						send_response_bytes("?wsdl", str->str.op_stream);
  +						send_response_bytes("\">wsdl</a></td>", str->str.op_stream);
  +						send_response_bytes("</tr>", str->str.op_stream);
   					}
  -					res("</table></body></html>");
  +					send_response_bytes("</table></body></html>", str->str.op_stream);
   				}
   				else 
   				{
  -					sServiceName = "./Axis/wsdl/" + sUriWOAxis + ".wsdl";
  +					sServiceName = WSDLDIRECTORY + sUriWOAxis + ".wsdl";
   					//check whether wsdl file is available
  -					if((outfile = fopen(sServiceName.c_str(),"r"))==NULL)
  +					if((WsddFile = fopen(sServiceName.c_str(),"r"))==NULL)
   					{
  -						send_response_bytes("<h3>Url not available</h3>");
  +						send_response_bytes("<h3>Url not available</h3>", str->str.op_stream);
   						//handle the error
   					}
   					else
   					{
   						int charcount = 0;
  -						int acc = 0;	
  -						while((charcount=fread(oneword,1,bytestoread-1, outfile)) != 0)
  +						while((charcount = fread(ReadBuffer, 1, BYTESTOREAD-1, WsddFile)) != 0)
   						{
  -							*(oneword+charcount) = '\0';
  -							send_response_bytes(oneword);
  +							*(ReadBuffer + charcount) = '\0';
  +							send_response_bytes(ReadBuffer, str->str.op_stream);
     						}
  -						ret = SUCCESS;
  -						fclose(outfile);
  +						Status = SUCCESS;
  +						fclose(WsddFile);
   					}
   				}
   			}
   		break;
   
   		default:
  -			send_response_bytes("Unknown Protocol");
  +			send_response_bytes("Unknown Protocol", str->str.op_stream);
   		break;
   	}
  -	svsmap = NULL;
  -	svs =NULL;
  -	return ret;
  +	return Status;
   }
   
  +extern "C" int initialize_module()
  +{
  +	TypeMapping::Initialize();
  +	URIMapping::Initialize();
  +	SoapFault::initialize();
  +	XMLPlatformUtils::Initialize();
  +	string ConfFile = WSDDFILEPATH;
  +	if (SUCCESS != g_WSDDDeployment.LoadWSDD(ConfFile)) return FAIL;
  +	return SUCCESS;
  +}
  
  
  
  1.1                  xml-axis/c/src/engine/SharedObject.h
  
  Index: SharedObject.h
  ===================================================================
  // SharedObject.h: interface for the SharedObject class.
  //
  //////////////////////////////////////////////////////////////////////
  #pragma warning (disable : 4786)
  
  #if !defined(AFX_SHAREDOBJECT_H__0805D25C_2F7E_4B19_BECE_0A8BFE9F0830__INCLUDED_)
  #define AFX_SHAREDOBJECT_H__0805D25C_2F7E_4B19_BECE_0A8BFE9F0830__INCLUDED_
  
  #if _MSC_VER > 1000
  #pragma once
  #endif // _MSC_VER > 1000
  
  class SharedObject  
  {
  public:
  	SharedObject();
  	virtual ~SharedObject();
  protected:
  	int unlock();
  	int lock();
  private:
  	volatile bool m_bLocked;
  };
  
  #endif // !defined(AFX_SHAREDOBJECT_H__0805D25C_2F7E_4B19_BECE_0A8BFE9F0830__INCLUDED_)
  
  
  
  1.1                  xml-axis/c/src/engine/SharedObject.cpp
  
  Index: SharedObject.cpp
  ===================================================================
  // SharedObject.cpp: implementation of the SharedObject class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #include "SharedObject.h"
  #ifdef WIN32
  #include <Windows.h>
  #else
  
  #endif
  //////////////////////////////////////////////////////////////////////
  // Construction/Destruction
  //////////////////////////////////////////////////////////////////////
  
  SharedObject::SharedObject()
  {
  	m_bLocked = false;
  }
  
  SharedObject::~SharedObject()
  {
  
  }
  //Following functions should be improved to avoid chances of failure
  //using platform specific mechanisms
  int SharedObject::lock()
  {
  	while (m_bLocked)
  	{
  #ifdef WIN32
  		Sleep(0);
  #else
  		sleep(0);
  #endif
  	}
  	m_bLocked = true;
  	return 0;
  }
  
  int SharedObject::unlock()
  {
  	m_bLocked = false;
  	return 0;
  }
  
  
  
  1.1                  xml-axis/c/src/engine/SessionScopeHandlerPool.h
  
  Index: SessionScopeHandlerPool.h
  ===================================================================
  // SessionScopeHandlerPool.h: interface for the SessionScopeHandlerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #if !defined(AFX_SESSIONSCOPEHANDLERPOOL_H__8F0188D8_B30B_43F9_8F06_8E209D7B8ABE__INCLUDED_)
  #define AFX_SESSIONSCOPEHANDLERPOOL_H__8F0188D8_B30B_43F9_8F06_8E209D7B8ABE__INCLUDED_
  
  #if _MSC_VER > 1000
  #pragma once
  #endif // _MSC_VER > 1000
  
  #define SESSIONLESSHANDLERS	"0aaaaa"
  
  #include "SharedObject.h"
  #include "../common/BasicHandler.h"
  
  #include <map>
  #include <list>
  #include <string>
  
  using namespace std;
  
  class SessionScopeHandlerPool : protected SharedObject  
  {
  public:
  	SessionScopeHandlerPool();
  	virtual ~SessionScopeHandlerPool();
  private:
  	typedef map<string, list<BasicHandler*> > SessionHandlers;
  	map<int, SessionHandlers*> m_Handlers;
  public:
  	int GetInstance(string& sSessionId, BasicHandler** pHandler, int nLibId);
  	int PutInstance(string& sSessionId, BasicHandler* pHandler, int nLibId);
  	void EndSession(string& sSessionId);
  };
  
  #endif // !defined(AFX_SESSIONSCOPEHANDLERPOOL_H__8F0188D8_B30B_43F9_8F06_8E209D7B8ABE__INCLUDED_)
  
  
  
  1.1                  xml-axis/c/src/engine/SessionScopeHandlerPool.cpp
  
  Index: SessionScopeHandlerPool.cpp
  ===================================================================
  // SessionScopeHandlerPool.cpp: implementation of the SessionScopeHandlerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  #pragma warning (disable : 4503)
  
  #include "SessionScopeHandlerPool.h"
  #include "HandlerLoader.h"
  
  //////////////////////////////////////////////////////////////////////
  // Construction/Destruction
  //////////////////////////////////////////////////////////////////////
  extern HandlerLoader g_HandlerLoader;
  
  SessionScopeHandlerPool::SessionScopeHandlerPool()
  {
  
  }
  
  SessionScopeHandlerPool::~SessionScopeHandlerPool()
  {
  
  }
  
  int SessionScopeHandlerPool::GetInstance(string& sSessionId, BasicHandler** pHandler, int nLibId)
  {
  	lock();
  	int Status;
  	if (m_Handlers.find(nLibId) != m_Handlers.end()) 
  	{
  		SessionHandlers* pSesHandlers = m_Handlers[nLibId];
  		if (pSesHandlers->find(sSessionId) != pSesHandlers->end())
  		{
  			list<BasicHandler*> &HandlerList = ((*pSesHandlers)[sSessionId]);
  			if (HandlerList.empty())
  			{
  				//check in the store for reuse
  				if ((*pSesHandlers)[SESSIONLESSHANDLERS].empty())
  				{
  					unlock();
  					return g_HandlerLoader.CreateHandler(pHandler, nLibId);
  				}
  				else
  				{
  					*pHandler = (*pSesHandlers)[SESSIONLESSHANDLERS].front();
  					(*pSesHandlers)[SESSIONLESSHANDLERS].pop_front();
  					unlock();
  					return SUCCESS;
  				}
  			}
  			else
  			{
  				*pHandler = HandlerList.front();
  				HandlerList.pop_front();
  				unlock();
  				return SUCCESS;
  			}
  			unlock();
  			return g_HandlerLoader.CreateHandler(pHandler, nLibId);
  		}
  		else //no handler list for this session id
  		{
  			//check in the store for reuse
  			if ((*pSesHandlers)[SESSIONLESSHANDLERS].empty())
  			{
  				unlock();
  				return g_HandlerLoader.CreateHandler(pHandler, nLibId);
  			}
  			else
  			{
  				*pHandler = (*pSesHandlers)[SESSIONLESSHANDLERS].front();
  				(*pSesHandlers)[SESSIONLESSHANDLERS].pop_front();
  				unlock();
  				return SUCCESS;
  			}
  		}
  	}
  	else //not even the handler DLL loaded
  	{
  		Status = g_HandlerLoader.CreateHandler(pHandler, nLibId);
  		if (SUCCESS == Status)
  		{
  			//this just creates the entry in m_Handlers so that next time we know that the DLL is loaded
  			SessionHandlers* pNewSH = new SessionHandlers;
  			pNewSH->clear();
  			m_Handlers[nLibId] = pNewSH;	
  		}
  		unlock();
  		return Status;
  	}
  }
  
  int SessionScopeHandlerPool::PutInstance(string& sSessionId, BasicHandler* pHandler, int nLibId)
  {
  	lock();
  	SessionHandlers* pSesHandlers;
  	if (m_Handlers.find(nLibId) != m_Handlers.end())
  	{
  		pSesHandlers = m_Handlers[nLibId];
  	}
  	else // this is unexpected situation. anyway do it
  	{
  		pSesHandlers = new SessionHandlers;
  		pSesHandlers->clear();
  		m_Handlers[nLibId] = pSesHandlers;	
  	}
  	list<BasicHandler*> &HandlerList = ((*pSesHandlers)[sSessionId]);
  	HandlerList.push_back(pHandler);
  	unlock();
  	return SUCCESS;
  }
  
  void SessionScopeHandlerPool::EndSession(string& sSessionId)
  {
  	//traverse all the lists and remove corresponding handlers if any and put to SESSIONLESSHANDLERS	
  }
  
  
  
  1.1                  xml-axis/c/src/engine/SerializerPool.h
  
  Index: SerializerPool.h
  ===================================================================
  // SerializerPool.h: interface for the SerializerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #if !defined(AFX_SERIALIZERPOOL_H__45283A27_9196_4ACF_952F_88C564A4BD40__INCLUDED_)
  #define AFX_SERIALIZERPOOL_H__45283A27_9196_4ACF_952F_88C564A4BD40__INCLUDED_
  
  #if _MSC_VER > 1000
  #pragma once
  #endif // _MSC_VER > 1000
  
  #include "SharedObject.h"
  #include "../soap/SoapSerializer.h"
  #include "../common/GDefine.h"
  #include <list>
  
  using namespace std;
  
  class SerializerPool : protected SharedObject  
  {
  public:
  	SerializerPool();
  	virtual ~SerializerPool();
  private:
  	list<SoapSerializer*> m_SZList;
  public:
  	int GetInstance(SoapSerializer** ppSZ);
  	int PutInstance(SoapSerializer* pSZ);
  };
  
  #endif // !defined(AFX_SERIALIZERPOOL_H__45283A27_9196_4ACF_952F_88C564A4BD40__INCLUDED_)
  
  
  
  1.1                  xml-axis/c/src/engine/SerializerPool.cpp
  
  Index: SerializerPool.cpp
  ===================================================================
  // SerializerPool.cpp: implementation of the SerializerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #include "SerializerPool.h"
  
  //////////////////////////////////////////////////////////////////////
  // Construction/Destruction
  //////////////////////////////////////////////////////////////////////
  
  SerializerPool::SerializerPool()
  {
  
  }
  
  SerializerPool::~SerializerPool()
  {
  
  }
  
  //pooling should be implemented
  int SerializerPool::GetInstance(SoapSerializer** ppSZ)
  {
  	//TODO
  	*ppSZ = new SoapSerializer();
  	return SUCCESS;
  }
  
  int SerializerPool::PutInstance(SoapSerializer* pSZ)
  {
  	//TODO
  	delete pSZ;
  	return SUCCESS;
  }
  
  
  
  1.1                  xml-axis/c/src/engine/RequestScopeHandlerPool.h
  
  Index: RequestScopeHandlerPool.h
  ===================================================================
  // RequestScopeHandlerPool.h: interface for the RequestScopeHandlerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #if !defined(AFX_REQUESTSCOPEHANDLERPOOL_H__310FD607_517E_4644_8922_0B1CFDE9E5BE__INCLUDED_)
  #define AFX_REQUESTSCOPEHANDLERPOOL_H__310FD607_517E_4644_8922_0B1CFDE9E5BE__INCLUDED_
  
  #if _MSC_VER > 1000
  #pragma once
  #endif // _MSC_VER > 1000
  
  #include "SharedObject.h"
  #include "../common/BasicHandler.h"
  
  #include <map>
  #include <list>
  #include <string>
  
  using namespace std;
  
  class RequestScopeHandlerPool : protected SharedObject  
  {
  public:
  	RequestScopeHandlerPool();
  	virtual ~RequestScopeHandlerPool();
  private:
  	map<int, list<BasicHandler*> > m_Handlers;
  public:
  	int GetInstance(BasicHandler** pHandler, int nLibId);
  	int PutInstance(BasicHandler* pHandler, int nLibId);
  };
  
  #endif // !defined(AFX_REQUESTSCOPEHANDLERPOOL_H__310FD607_517E_4644_8922_0B1CFDE9E5BE__INCLUDED_)
  
  
  
  1.1                  xml-axis/c/src/engine/RequestScopeHandlerPool.cpp
  
  Index: RequestScopeHandlerPool.cpp
  ===================================================================
  // RequestScopeHandlerPool.cpp: implementation of the RequestScopeHandlerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #include "RequestScopeHandlerPool.h"
  #include "HandlerLoader.h"
  
  //////////////////////////////////////////////////////////////////////
  // Construction/Destruction
  //////////////////////////////////////////////////////////////////////
  extern HandlerLoader g_HandlerLoader;
  
  RequestScopeHandlerPool::RequestScopeHandlerPool()
  {
  
  }
  
  RequestScopeHandlerPool::~RequestScopeHandlerPool()
  {
  
  }
  
  int RequestScopeHandlerPool::GetInstance(BasicHandler** pHandler, int nLibId)
  {
  	lock();
  	int Status;
  	if (m_Handlers.find(nLibId) != m_Handlers.end()) 
  	{
  		if (m_Handlers[nLibId].empty())
  		{
  			Status = g_HandlerLoader.CreateHandler(pHandler, nLibId);
  			if (SUCCESS == Status)
  			{
  				//this just creates the entry in m_Handlers so that next time we know that the DLL is loaded
  				m_Handlers[nLibId].clear();	
  			}
  			unlock();
  			return Status;
  		}
  		else
  		{
  			*pHandler = m_Handlers[nLibId].front();
  			m_Handlers[nLibId].pop_front();
  			unlock();
  			return SUCCESS;
  		}
  	}
  	else //not even the handler DLL loaded
  	{
  		Status = g_HandlerLoader.CreateHandler(pHandler, nLibId);
  		if (SUCCESS == Status)
  		{
  			//this just creates the entry in m_Handlers so that next time we know that the DLL is loaded
  			m_Handlers[nLibId].clear();	
  		}
  		unlock();
  		return Status;
  	}
  }
  
  int RequestScopeHandlerPool::PutInstance(BasicHandler* pHandler, int nLibId)
  {
  	lock();
  	m_Handlers[nLibId].push_back(pHandler);
  	unlock();
  	return SUCCESS;
  }
  
  
  
  1.1                  xml-axis/c/src/engine/DeserializerPool.h
  
  Index: DeserializerPool.h
  ===================================================================
  // DeserializerPool.h: interface for the DeserializerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #if !defined(AFX_DESERIALIZERPOOL_H__702116EF_3134_4ED4_8252_BEC1FC30E825__INCLUDED_)
  #define AFX_DESERIALIZERPOOL_H__702116EF_3134_4ED4_8252_BEC1FC30E825__INCLUDED_
  
  #if _MSC_VER > 1000
  #pragma once
  #endif // _MSC_VER > 1000
  
  #include "SharedObject.h"
  #include "../soap/SoapDeSerializer.h"
  #include "../common/GDefine.h"
  #include <list>
  
  using namespace std;
  
  class DeserializerPool : protected SharedObject  
  {
  public:
  	DeserializerPool();
  	virtual ~DeserializerPool();
  private:
  	list<SoapDeSerializer*> m_DZList;
  public:
  	int GetInstance(SoapDeSerializer** ppDZ);
  	int PutInstance(SoapDeSerializer* pDZ);
  };
  
  #endif // !defined(AFX_DESERIALIZERPOOL_H__702116EF_3134_4ED4_8252_BEC1FC30E825__INCLUDED_)
  
  
  
  1.1                  xml-axis/c/src/engine/DeserializerPool.cpp
  
  Index: DeserializerPool.cpp
  ===================================================================
  // DeserializerPool.cpp: implementation of the DeserializerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #include "DeserializerPool.h"
  
  //////////////////////////////////////////////////////////////////////
  // Construction/Destruction
  //////////////////////////////////////////////////////////////////////
  
  DeserializerPool::DeserializerPool()
  {
  
  }
  
  DeserializerPool::~DeserializerPool()
  {
  
  }
  
  int DeserializerPool::GetInstance(SoapDeSerializer** ppSZ)
  {
  	//TODO
  	*ppSZ = new SoapDeSerializer();
  	return SUCCESS;
  }
  
  int DeserializerPool::PutInstance(SoapDeSerializer* pSZ)
  {
  	//TODO
  	delete pSZ;
  	return SUCCESS;
  }
  
  
  
  1.1                  xml-axis/c/src/engine/AppScopeHandlerPool.h
  
  Index: AppScopeHandlerPool.h
  ===================================================================
  // AppScopeHandlerPool.h: interface for the AppScopeHandlerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #if !defined(AFX_APPSCOPEHANDLERPOOL_H__A94BE166_F35A_40B9_8B17_9ED3D1886503__INCLUDED_)
  #define AFX_APPSCOPEHANDLERPOOL_H__A94BE166_F35A_40B9_8B17_9ED3D1886503__INCLUDED_
  
  #if _MSC_VER > 1000
  #pragma once
  #endif // _MSC_VER > 1000
  
  #include "SharedObject.h"
  #include "../common/BasicHandler.h"
  
  #include <map>
  #include <list>
  #include <string>
  
  using namespace std;
  
  class AppScopeHandlerPool : protected SharedObject 
  {
  public:
  	AppScopeHandlerPool();
  	virtual ~AppScopeHandlerPool();
  private:
  	map<int, list<BasicHandler*> > m_Handlers;
  public:
  	int GetInstance(BasicHandler** pHandler, int nLibId);
  	int PutInstance(BasicHandler* pHandler, int nLibId);
  };
  
  #endif // !defined(AFX_APPSCOPEHANDLERPOOL_H__A94BE166_F35A_40B9_8B17_9ED3D1886503__INCLUDED_)
  
  
  
  1.1                  xml-axis/c/src/engine/AppScopeHandlerPool.cpp
  
  Index: AppScopeHandlerPool.cpp
  ===================================================================
  // AppScopeHandlerPool.cpp: implementation of the AppScopeHandlerPool class.
  //
  //////////////////////////////////////////////////////////////////////
  
  #include "AppScopeHandlerPool.h"
  #include "HandlerLoader.h"
  
  //////////////////////////////////////////////////////////////////////
  // Construction/Destruction
  //////////////////////////////////////////////////////////////////////
  extern HandlerLoader g_HandlerLoader;
  
  //this class does not do the object level blocking. Instead expects the 
  //thread level blocking and waiting by the caller thread.
  AppScopeHandlerPool::AppScopeHandlerPool()
  {
  
  }
  
  AppScopeHandlerPool::~AppScopeHandlerPool()
  {
  
  }
  
  //this method does not block the object. Instead expects that the calling thread 
  //MUST block itself and wait if the requested handler is not found.
  int AppScopeHandlerPool::GetInstance(BasicHandler** pHandler, int nLibId)
  {
  	lock();
  	int Status;
  	if (m_Handlers.find(nLibId) != m_Handlers.end()) 
  	{
  		if (m_Handlers[nLibId].empty()) 
  		// this means that the object is being used by some other thread
  		// but we cannot create any more objects because this is an application
  		// scope object. So just return HANDLER_BEING_USED
  		{
  			unlock();
  			return HANDLER_BEING_USED;
  		}
  		else
  		{
  			*pHandler = m_Handlers[nLibId].front();
  			m_Handlers[nLibId].pop_front();
  			unlock();
  			return SUCCESS;
  		}
  	}
  	else //not even the handler DLL loaded
  	{
  		Status = g_HandlerLoader.CreateHandler(pHandler, nLibId);
  		if (SUCCESS == Status)
  		{
  			//this just creates the entry in m_Handlers so that next time we know that the DLL is loaded
  			m_Handlers[nLibId].clear();	
  		}
  		unlock();
  		return Status;
  	}
  }
  
  int AppScopeHandlerPool::PutInstance(BasicHandler* pHandler, int nLibId)
  {
  	lock();
  	m_Handlers[nLibId].push_back(pHandler);
  	unlock();
  	return SUCCESS;
  }
  
  
  

Mime
View raw message