| /* -*- C++ -*- */ |
| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * Revision 1.1 2004/08/26 roshan |
| * Added the method "releaseHandlers(string sSessionId)" in order to release the |
| * Handlers once they are used. |
| */ |
| |
| // !!! This include file must be first thing in file !!! |
| #include "../../platforms/PlatformAutoSense.hpp" |
| |
| #include <axis/AxisException.hpp> |
| |
| #include "ClientAxisEngine.h" |
| #include "../../wsdd/WSDDDeployment.h" |
| #include "../HandlerPool.h" |
| #include "../../common/AxisTrace.h" |
| #include "../../common/AxisGenException.h" |
| |
| #include "../../common/AxisTrace.h" |
| |
| extern AXIS_CPP_NAMESPACE_PREFIX WSDDDeployment* g_pWSDDDeployment; |
| extern AXIS_CPP_NAMESPACE_PREFIX HandlerPool* g_pHandlerPool; |
| |
| AXIS_CPP_NAMESPACE_START |
| |
| ClientAxisEngine:: |
| ClientAxisEngine () |
| { |
| logEntryEngine("ClientAxisEngine::ClientAxisEngine") |
| |
| logExit() |
| } |
| |
| ClientAxisEngine:: |
| ~ClientAxisEngine () |
| { |
| logEntryEngine("ClientAxisEngine::~ClientAxisEngine") |
| |
| logExit() |
| } |
| |
| MessageData* ClientAxisEngine:: |
| getMessageData () |
| { |
| return m_pMsgData; |
| } |
| |
| int ClientAxisEngine:: |
| process (SOAPTransport* pSoap) |
| { |
| return process(pSoap, false); |
| } |
| |
| int ClientAxisEngine:: |
| process (SOAPTransport* pSoap, bool noResponse) |
| { |
| logEntryEngine("ClientAxisEngine::process") |
| |
| int Status = AXIS_FAIL; |
| const WSDDService* pService = NULL; |
| |
| try |
| { |
| if (pSoap) |
| { |
| m_pSoap = pSoap; |
| string sSessionId = m_pSoap->getSessionId(); |
| |
| do |
| { |
| // Get the service name that was specified in the second parameter of the call |
| // to setTransportProperty( SOAPACTION_HEADER , "") matches a service name in |
| // the 'service' part of the WSDD file then call that service now. |
| const char* pchService = pSoap->getServiceName(); |
| |
| // Check that there is a valid service name. |
| if( pchService != NULL) |
| { |
| // The convention for the service name appears to be service#port |
| if( strchr( pchService, '#') == NULL) |
| { |
| int iStringLength = strlen( pchService); |
| char * pszService = new char[iStringLength]; |
| |
| memset( pszService, 0, iStringLength); |
| // If there is no # seperator, then strip off the outer quotes. if they exist ! |
| if(strchr(pchService, '"') == NULL) |
| memcpy( pszService, pchService, iStringLength); |
| else |
| memcpy( pszService, pchService + 1, iStringLength - 2); |
| |
| pService = g_pWSDDDeployment->getService( pszService); |
| |
| delete [] pszService; |
| } |
| else |
| { |
| char * pchTempService = new char [strlen(pchService)+1]; |
| |
| // Skip the starting double quote |
| strcpy(pchTempService, pchService+1); |
| |
| // The String returned as the service name has the format "Calculator#add". |
| // So null terminate string at #. |
| *(strchr(pchTempService, '#')) = '\0'; |
| |
| // get service description object from the WSDD Deployment object |
| pService = g_pWSDDDeployment->getService (pchTempService); |
| |
| delete [] pchTempService; |
| } |
| } |
| |
| //Get Global and Transport Handlers |
| Status = initializeHandlers (sSessionId, pSoap->getProtocol()); |
| if (AXIS_SUCCESS != Status) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_HANDLER_INIT_FAILED") |
| |
| throw AxisEngineException(SERVER_ENGINE_HANDLER_INIT_FAILED); |
| } |
| |
| //Get Service specific Handlers from the pool if configured any |
| if (pService != NULL) |
| { |
| Status = g_pHandlerPool->getRequestFlowHandlerChain(&m_pSReqFChain, sSessionId, pService); |
| if (AXIS_SUCCESS != Status) |
| break; |
| |
| Status = g_pHandlerPool->getResponseFlowHandlerChain(&m_pSResFChain, sSessionId, pService); |
| if (AXIS_SUCCESS != Status) |
| break; |
| } |
| |
| // Invoke all handlers and then the remote webservice |
| // we generate response in the same way even if this has failed |
| Status = invoke (m_pMsgData, noResponse); |
| } |
| while (0); |
| |
| //release the handlers |
| releaseHandlers(sSessionId); |
| } |
| } |
| catch(AxisException& e) |
| { |
| /* Throw a AxisGenException here instead of rethrowing the original exception because |
| * the original exception may be an transport exception which will go out of scope when |
| * the transport library is unloaded. |
| */ |
| logRethrowException() |
| |
| throw AxisGenException(e); |
| } |
| |
| logExitWithReturnCode(Status) |
| |
| return Status; |
| } |
| |
| void ClientAxisEngine:: |
| releaseHandlers(string sSessionId) |
| { |
| logEntryEngine("ClientAxisEngine::releaseHandlers") |
| |
| // Pool back the Service specific handlers |
| if (m_pSReqFChain) |
| g_pHandlerPool->poolHandlerChain(m_pSReqFChain, sSessionId); |
| if (m_pSResFChain) |
| g_pHandlerPool->poolHandlerChain(m_pSResFChain, sSessionId); |
| |
| logExit() |
| } |
| |
| int ClientAxisEngine:: |
| invoke (MessageData* pMsg) |
| { |
| return invoke(pMsg, false); |
| } |
| |
| int ClientAxisEngine:: |
| invoke (MessageData* pMsg, bool noResponse) |
| { |
| logEntryEngine("ClientAxisEngine::invoke") |
| |
| enum AE_LEVEL { AE_START = 1, AE_SERH, AE_GLH, AE_TRH, AE_SERV }; |
| int Status = AXIS_FAIL; |
| int level = AE_START; |
| |
| do |
| { |
| // Invoke client side service specific request handlers |
| |
| logDebug("Invoke client side request handlers, if any.") |
| |
| if (m_pSReqFChain) |
| { |
| logDebug("Invoke client side service specific request handlers") |
| |
| if (AXIS_SUCCESS != (Status = m_pSReqFChain->invoke (pMsg))) |
| { |
| logDebug("Invoke of client side service-specific request handlers failed") |
| |
| break; |
| } |
| } |
| |
| level++; //AE_SERH |
| |
| // Invoke global request handlers |
| |
| if (m_pGReqFChain) |
| { |
| logDebug("Invoke global request handlers") |
| |
| if (AXIS_SUCCESS != (Status = m_pGReqFChain->invoke (pMsg))) |
| { |
| logDebug("Invoke of global request handlers failed") |
| |
| break; |
| } |
| } |
| |
| level++; //AE_GLH |
| |
| // Invoke transport request handlers |
| |
| |
| if (m_pTReqFChain) |
| { |
| logDebug("Invoke transport request handlers") |
| |
| if (AXIS_SUCCESS != (Status = m_pTReqFChain->invoke (pMsg))) |
| { |
| logDebug("Invoke of transport request handlers failed") |
| |
| break; |
| } |
| } |
| |
| level++; // AE_TRH |
| |
| // setOutputStream() kicks off serialization step.... |
| if (AXIS_SUCCESS != (Status = m_pSZ->setOutputStream (m_pSoap))) |
| break; |
| |
| m_pSoap->openConnection(); |
| |
| m_pSZ->markEndOfStream(); |
| |
| level++; // AE_SERV |
| |
| pMsg->setPastPivotState (true); |
| |
| if (AXIS_SUCCESS != (Status = m_pDZ->setInputStream (m_pSoap))) |
| break; |
| |
| // Get header and body only if we are expecting a response |
| if (!noResponse || m_pSoap->isThereResponseData()) |
| { |
| // version not supported set status to fail |
| int nSoapVersion = m_pDZ->getVersion (); |
| if (nSoapVersion == VERSION_LAST) |
| Status = AXIS_FAIL; |
| |
| m_pDZ->getHeader (); |
| m_pDZ->getBody (); |
| |
| // If one-way messaging and there is response data, then it must be a fault. |
| if (noResponse) |
| { |
| // initiate fault processing. This will result in an exception being thrown. |
| m_pDZ->initiateFault(NULL); |
| } |
| } |
| } |
| while (0); |
| |
| /* |
| * The case clauses in this switch statement have no breaks. |
| * Hence, if Everything up to web service invocation was successful |
| * then all response handlers are invoked. If there was a failure |
| * at some point the response handlers from that point onwards |
| * are invoked. |
| */ |
| |
| logDebug("Invoke client side response handlers, if any.") |
| |
| switch (level) |
| { |
| case AE_SERV: |
| // everything success |
| Status = AXIS_SUCCESS; |
| |
| // If no response expected, break out. |
| if (noResponse) |
| break; |
| |
| case AE_TRH: |
| // After invoking the transport handlers (at actual service invokation) it has failed |
| if (m_pTResFChain) |
| { |
| logDebug("Invoke client side transport handlers.") |
| |
| m_pTResFChain->invoke (pMsg); |
| } |
| |
| case AE_GLH: |
| // transport handlers have failed invoke global response handlers |
| if (m_pGResFChain) |
| { |
| logDebug("Invoke client side global response handlers.") |
| |
| m_pGResFChain->invoke (pMsg); |
| } |
| |
| case AE_SERH: // global handlers have failed |
| // invoke web service specific response handlers |
| if (m_pSResFChain) |
| { |
| logDebug("Invoke Web service-specific client side handlers.") |
| |
| m_pSResFChain->invoke (pMsg); |
| } |
| |
| case AE_START:; |
| // service specific handlers have failed |
| }; |
| |
| logExitWithReturnCode(Status) |
| |
| return Status; |
| } |
| |
| void ClientAxisEngine:: |
| onFault (MessageData* pMsg) |
| { |
| |
| } |
| |
| AXIS_CPP_NAMESPACE_END |
