| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| * |
| * 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. |
| * |
| * @author Sanjaya Singharage |
| * @author Roshan Weerasuriya (roshan@jkcs.slt.lk, roshan@opensource.lk) |
| * @author Susantha Kumara (skumara@virtusa.com, susantha@opensource.lk) |
| * |
| */ |
| |
| // !!! This include file must be first thing in file !!! |
| #include "../platforms/PlatformAutoSense.hpp" |
| |
| #include "WSDDDeployment.h" |
| #include "WSDDDocument.h" |
| |
| #include <axis/GDefine.hpp> |
| #include "../common/AxisConfig.h" |
| #include "AxisWsddException.h" |
| |
| #include "../common/AxisTrace.h" |
| |
| AXIS_CPP_NAMESPACE_START |
| |
| |
| WSDDDeployment:: |
| WSDDDeployment() |
| { |
| logEntryEngine("WSDDDeployment::WSDDDeployment") |
| |
| m_DeployedServices = NULL; |
| m_sAux = ""; |
| m_pTransportHandlers = NULL; |
| m_GlobalResponseHandlers = NULL; |
| m_GlobalRequestHandlers = NULL; |
| m_DeplType = DT_DEPLOYMENT; |
| m_pLibNameIdMap = new map<AxisString, int>; |
| |
| logExit() |
| } |
| |
| WSDDDeployment:: |
| ~WSDDDeployment() |
| { |
| logEntryEngine("WSDDDeployment::~WSDDDeployment") |
| |
| WSDDHandlerList::iterator iter; |
| delete m_pTransportHandlers; |
| |
| if(m_GlobalRequestHandlers) |
| for(iter=m_GlobalRequestHandlers->begin(); iter!=m_GlobalRequestHandlers->end(); iter++) |
| delete (*iter); |
| |
| if(m_GlobalResponseHandlers) |
| for(iter=m_GlobalResponseHandlers->begin(); iter!=m_GlobalResponseHandlers->end(); iter++) |
| delete (*iter); |
| |
| WSDDServiceMap::iterator iter2; |
| if(m_DeployedServices) |
| for(iter2=m_DeployedServices->begin(); iter2!=m_DeployedServices->end(); iter2++) |
| delete ((*iter2).second); |
| |
| delete m_DeployedServices; |
| delete m_pLibNameIdMap; |
| |
| logExit() |
| } |
| |
| const WSDDHandlerList* WSDDDeployment:: |
| getGlobalRequestFlowHandlers() |
| { |
| return m_GlobalRequestHandlers; |
| } |
| |
| const WSDDHandlerList* WSDDDeployment:: |
| getGlobalResponseFlowHandlers() |
| { |
| return m_GlobalResponseHandlers; |
| } |
| |
| int WSDDDeployment:: |
| updateWSDD(const AxisChar* sWSDD) |
| { |
| WSDDDocument* doc = new WSDDDocument(m_pLibNameIdMap); |
| int rc = doc->updateDeployment(sWSDD, this); |
| delete doc; |
| |
| if (AXIS_SUCCESS == rc) |
| saveWSDD(); |
| |
| return rc; |
| } |
| |
| int WSDDDeployment:: |
| loadWSDD( const AxisChar * sWSDD) |
| { |
| logEntryEngine("WSDDDeployment::loadWSDD") |
| |
| m_sWSDDPath = std::string( sWSDD); |
| |
| WSDDDocument *doc = new WSDDDocument( m_pLibNameIdMap); |
| |
| int rc = doc->getDeployment( sWSDD, this); |
| |
| delete doc; |
| |
| if (AXIS_FAIL == rc) |
| { |
| logThrowException("AxisWsddException - SERVER_WSDD_FILE_NOT_FOUND") |
| |
| throw AxisWsddException(SERVER_WSDD_FILE_NOT_FOUND); |
| } |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int WSDDDeployment:: |
| saveWSDD() |
| { |
| int Status = AXIS_FAIL; |
| /* TODO we have to rename the existing server.wsdd to server.wsdd.old |
| * and if anything went wrong we have to rename it back to server.wsdd |
| */ |
| FILE* file = fopen(m_sWSDDPath.c_str(), "w"); |
| if(!file) |
| return AXIS_FAIL; |
| |
| do |
| { |
| if (fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n", file) < 0) |
| break; |
| |
| if (fputs("<deployment xmlns=\"http://xml.apache.org/axis/wsdd/" |
| "\" xmlns:C=\"http://xml.apache.org/axis/wsdd/providers/C\" xmlns:" |
| "CPP=\"http://xml.apache.org/axis/wsdd/providers/CPP\">\n", |
| file) < 0) |
| break; |
| |
| if (fputs("\t<globalConfiguration>\n", file) < 0) |
| break; |
| |
| WSDDHandlerList::iterator iter; |
| if(m_GlobalRequestHandlers) |
| { |
| if (fputs("\t\t<requestFlow>\n", file) < 0) |
| break; |
| |
| for(iter=m_GlobalRequestHandlers->begin(); iter!=m_GlobalRequestHandlers->end(); iter++) |
| (*iter)->updateWSDD(file, 3); |
| |
| if (fputs("\t\t</requestFlow>\n", file) < 0) |
| break; |
| } |
| |
| if(m_GlobalResponseHandlers) |
| { |
| if (fputs("\t\t<responseFlow>\n", file) < 0) |
| break; |
| |
| for(iter=m_GlobalResponseHandlers->begin(); iter!=m_GlobalResponseHandlers->end(); iter++) |
| (*iter)->updateWSDD(file, 3); |
| |
| if (fputs("\t\t</responseFlow>\n", file) < 0) |
| break; |
| } |
| |
| if (fputs("\t</globalConfiguration>\n", file) < 0) |
| break; |
| |
| if(m_pTransportHandlers) |
| m_pTransportHandlers->updateWSDD(file, 3); |
| |
| WSDDServiceMap::iterator iter2; |
| if(m_DeployedServices) |
| for(iter2=m_DeployedServices->begin(); iter2!=m_DeployedServices->end(); iter2++) |
| ((*iter2).second)->updateWSDD(file, 1); |
| |
| if (fputs("</deployment>", file) < 0) |
| break; |
| } |
| while(0); |
| |
| fflush(file); |
| fclose(file); |
| if (AXIS_SUCCESS != Status) |
| { |
| /*TODO use the previous server.wsdd file itself. Undo renaming*/ |
| } |
| return AXIS_SUCCESS; |
| } |
| |
| |
| const WSDDService* WSDDDeployment:: |
| getService(const AxisChar* sServiceName) |
| { |
| logSetFunctionNameEngine("WSDDDeployment::getService") |
| |
| WSDDServiceMap::iterator iter; |
| if (!m_DeployedServices) |
| return NULL; |
| |
| try |
| { |
| iter = m_DeployedServices->find(sServiceName); |
| if (iter != m_DeployedServices->end()) |
| return (*iter).second; |
| else |
| return NULL; |
| } |
| catch(exception& e) |
| { |
| e = e; |
| |
| logThrowExceptionWithData("AxisWsddException - SERVER_WSDD_EXCEPTION", e.what()) |
| |
| throw AxisWsddException(SERVER_WSDD_EXCEPTION); |
| } |
| } |
| |
| const WSDDServiceMap* WSDDDeployment:: |
| getWSDDServiceMap() const |
| { |
| return m_DeployedServices; |
| } |
| |
| const AxisChar* WSDDDeployment:: |
| getLibName(int nLibId) |
| { |
| for (map<AxisString, int>::iterator it = m_pLibNameIdMap->begin(); |
| it != m_pLibNameIdMap->end(); it++) |
| { |
| if ((*it).second == nLibId) |
| return (*it).first.c_str(); |
| } |
| |
| return NULL; |
| } |
| |
| int WSDDDeployment:: |
| addService(WSDDService* pService) |
| { |
| logEntryEngine("WSDDDeployment::addService") |
| |
| if (!m_DeployedServices) |
| m_DeployedServices = new WSDDServiceMap; |
| |
| if (m_DeployedServices->find(pService->getServiceName()) != m_DeployedServices->end()) |
| { |
| logWarning("The service already exists and the attempt to re-deploy is ignored.") |
| } |
| else |
| (*m_DeployedServices)[pService->getServiceName()] = pService; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int WSDDDeployment:: |
| addHandler(bool bGlobal, bool bRequestFlow, WSDDHandler* pHandler, AXIS_PROTOCOL_TYPE protocol) |
| { |
| logEntryEngine("WSDDDeployment::addHandler") |
| |
| if (pHandler) |
| { |
| logDebugArg4("Adding handler %s, global=%s, request=%s, response=%s", |
| pHandler->getLibName(), |
| bGlobal ? "yes" : "no", |
| bRequestFlow ? "yes" : "no", |
| bRequestFlow ? "no" : "yes") |
| } |
| |
| if (bGlobal) |
| { |
| if (bRequestFlow) |
| { |
| if(!m_GlobalRequestHandlers) |
| m_GlobalRequestHandlers = new WSDDHandlerList; |
| m_GlobalRequestHandlers->push_back(pHandler); |
| } |
| else |
| { |
| if(!m_GlobalResponseHandlers) |
| m_GlobalResponseHandlers = new WSDDHandlerList; |
| m_GlobalResponseHandlers->push_back(pHandler); |
| } |
| } |
| else /* transport */ |
| { |
| if (!m_pTransportHandlers) |
| m_pTransportHandlers = new WSDDTransport(); |
| m_pTransportHandlers->addHandler(bRequestFlow, protocol, pHandler); |
| } |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| const WSDDHandlerList* WSDDDeployment:: |
| getTransportRequestFlowHandlers(AXIS_PROTOCOL_TYPE protocol) |
| { |
| if (!m_pTransportHandlers) |
| return NULL; |
| return m_pTransportHandlers->getRequestFlowHandlers(protocol); |
| } |
| |
| const WSDDHandlerList* WSDDDeployment:: |
| getTransportResponseFlowHandlers(AXIS_PROTOCOL_TYPE protocol) |
| { |
| if (!m_pTransportHandlers) |
| return NULL; |
| return m_pTransportHandlers->getResponseFlowHandlers(protocol); |
| } |
| |
| int WSDDDeployment:: |
| removeService(WSDDService* pService) |
| { |
| if (m_DeployedServices && |
| (m_DeployedServices->find(pService->getServiceName()) != m_DeployedServices->end())) |
| { |
| WSDDService* pTheService = (*m_DeployedServices)[pService->getServiceName()]; |
| m_pLibNameIdMap->erase(pTheService->getLibName()); |
| m_DeployedServices->erase(pService->getServiceName()); |
| delete pTheService; |
| delete pService; |
| return AXIS_SUCCESS; |
| } |
| return AXIS_NO_SUCH_SERVICE; |
| } |
| |
| int WSDDDeployment:: |
| removeHandler(bool bGlobal, bool bRequestFlow, WSDDHandler* pHandler, AXIS_PROTOCOL_TYPE protocol) |
| { |
| m_pLibNameIdMap->erase(pHandler->getLibName()); |
| if (bGlobal) |
| { |
| WSDDHandlerList* pTempList = bRequestFlow ? m_GlobalRequestHandlers : m_GlobalResponseHandlers; |
| if(pTempList) |
| for (WSDDHandlerList::iterator itr=pTempList->begin(); itr != pTempList->end(); itr++) |
| if (strcmp((*itr)->getLibName(), pHandler->getLibName()) == 0) |
| { |
| pTempList->remove(*itr); |
| delete (*itr); |
| delete pHandler; |
| return AXIS_SUCCESS; |
| } |
| } |
| else /* transport */ |
| { |
| if (!m_pTransportHandlers) |
| return AXIS_NO_SUCH_HANDLER; |
| return m_pTransportHandlers->removeHandler(bRequestFlow, protocol, pHandler); |
| } |
| |
| return AXIS_NO_SUCH_HANDLER; |
| } |
| |
| DEPLOYMENTTYPE WSDDDeployment:: |
| getDeploymentType() const |
| { |
| return m_DeplType; |
| } |
| |
| void WSDDDeployment:: |
| setDeploymentType(DEPLOYMENTTYPE nType) |
| { |
| m_DeplType = nType; |
| } |
| |
| AXIS_CPP_NAMESPACE_END |
