1 kumpf 1.1 //%2003////////////////////////////////////////////////////////////////////////
  2           //
  3           // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
  4           // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
  5           // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
  6           // IBM Corp.; EMC Corporation, The Open Group.
  7           //
  8           // Permission is hereby granted, free of charge, to any person obtaining a copy
  9           // of this software and associated documentation files (the "Software"), to
 10           // deal in the Software without restriction, including without limitation the
 11           // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 12           // sell copies of the Software, and to permit persons to whom the Software is
 13           // furnished to do so, subject to the following conditions:
 14           //
 15           // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 16           // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 17           // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 18           // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 19           // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 20           // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 21           // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 22 kumpf 1.1 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 23           //
 24           //==============================================================================
 25           //
 26           // Author: Chip Vincent (cvincent@us.ibm.com)
 27           //         Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 28           //
 29           // Modified By:
 30           //
 31           //%/////////////////////////////////////////////////////////////////////////////
 32           
 33           #include "BasicProviderManagerRouter.h"
 34           
 35           #include <Pegasus/Common/Config.h>
 36           #include <Pegasus/Common/CIMMessage.h>
 37           #include <Pegasus/Common/Tracer.h>
 38           #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
 39           #include <Pegasus/ProviderManager2/ProviderManagerModule.h>
 40           #include <Pegasus/ProviderManager2/ProviderManager.h>
 41           
 42           // ProviderManager library names.  Should these be defined elsewhere?
 43 kumpf 1.1 #if defined(PEGASUS_OS_OS400)
 44           # define LIBRARY_NAME_DEFAULTPM "QSYS/QYCMDFTPVM"
 45           # define LIBRARY_NAME_CMPIPM    "QSYS/QYCMCMPIPM"
 46           # define LIBRARY_NAME_JMPIPM    "QSYS/QYCMJMPIPM"
 47           #else
 48           # define LIBRARY_NAME_DEFAULTPM "DefaultProviderManager"
 49           # define LIBRARY_NAME_CMPIPM    "CMPIProviderManager"
 50           # define LIBRARY_NAME_JMPIPM    "JMPIProviderManager"
 51           #endif
 52           
 53           PEGASUS_NAMESPACE_BEGIN
 54           
 55           // BEGIN TEMP SECTION
 56           class ProviderManagerContainer
 57           {
 58           public:
 59               ProviderManagerContainer()
 60               : _manager(0)
 61               {
 62               }
 63           
 64 kumpf 1.1     ProviderManagerContainer(const ProviderManagerContainer & container)
 65               : _manager(0)
 66               {
 67                   *this = container;
 68               }
 69           
 70               ProviderManagerContainer(
 71                   const String& physicalName,
 72                   const String& logicalName,
 73                   const String& interfaceName,
 74                   PEGASUS_INDICATION_CALLBACK indicationCallback)
 75               : _manager(0)
 76               {
 77                   _physicalName = ProviderManager::_resolvePhysicalName(physicalName);
 78           
 79                   _logicalName = logicalName;
 80                   _interfaceName = interfaceName;
 81           
 82                   _module = ProviderManagerModule(_physicalName);
 83                   _module.load();
 84           
 85 kumpf 1.1         _manager = _module.getProviderManager(_logicalName);
 86                   PEGASUS_ASSERT(_manager != 0);
 87           
 88                   _manager->setIndicationCallback(indicationCallback);
 89               }
 90           
 91               ~ProviderManagerContainer()
 92               {
 93                   _module.unload();
 94               }
 95           
 96               ProviderManagerContainer& operator=(
 97                   const ProviderManagerContainer & container)
 98               {
 99                   if (this == &container)
100                   {
101                       return *this;
102                   }
103           
104                   _logicalName = container._logicalName;
105                   _physicalName = container._physicalName;
106 kumpf 1.1         _interfaceName = container._interfaceName;
107           
108                   _module = container._module;
109                   _manager = container._manager;
110           
111                   return *this;
112               }
113           
114               ProviderManager* getProviderManager()
115               {
116                   return _manager;
117               }
118           
119               const String& getPhysicalName() const
120               {
121                   return _physicalName;
122               }
123           
124               const String& getLogicalName() const
125               {
126                   return _logicalName;
127 kumpf 1.1     }
128           
129               const String& getInterfaceName() const
130               {
131                   return _interfaceName;
132               }
133           
134           private:
135               String _physicalName;
136               String _logicalName;
137               String _interfaceName;
138           
139               ProviderManagerModule _module;
140               ProviderManager* _manager;
141           };
142           // END TEMP SECTION
143           
144           
145           PEGASUS_INDICATION_CALLBACK BasicProviderManagerRouter::_indicationCallback = 0;
146           
147           // Private, unimplemented constructor
148 kumpf 1.1 BasicProviderManagerRouter::BasicProviderManagerRouter()
149           {
150           }
151           
152           BasicProviderManagerRouter::BasicProviderManagerRouter(
153               PEGASUS_INDICATION_CALLBACK indicationCallback)
154           {
155               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
156                   "BasicProviderManagerRouter::BasicProviderManagerRouter");
157           
158               _indicationCallback = indicationCallback;
159           
160               PEG_METHOD_EXIT();
161           }
162           
163           BasicProviderManagerRouter::~BasicProviderManagerRouter()
164           {
165               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
166                   "BasicProviderManagerRouter::~BasicProviderManagerRouter");
167               PEG_METHOD_EXIT();
168           }
169 kumpf 1.1 
170           Message* BasicProviderManagerRouter::processMessage(Message * message)
171           {
172               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
173                   "BasicProviderManagerRouter::processMessage");
174           
175               CIMRequestMessage* request = dynamic_cast<CIMRequestMessage *>(message);
176               PEGASUS_ASSERT(request != 0);
177           
178               Message* response = 0;
179           
180               //
181               // Retrieve the ProviderManager routing information
182               //
183           
184               CIMInstance providerModule;
185           
186               if ((dynamic_cast<CIMOperationRequestMessage*>(request) != 0) ||
187                   (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE))
188               {
189                   // Provider information is in OperationContext
190 kumpf 1.1         ProviderIdContainer pidc = (ProviderIdContainer)
191                       request->operationContext.get(ProviderIdContainer::NAME);
192                   providerModule = pidc.getModule();
193               }
194               else if (dynamic_cast<CIMIndicationRequestMessage*>(request) != 0)
195               {
196                   // Provider information is in CIMIndicationRequestMessage
197                   CIMIndicationRequestMessage* indReq =
198                       dynamic_cast<CIMIndicationRequestMessage*>(request);
199                   providerModule = indReq->providerModule;
200               }
201               else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
202               {
203                   // Provider information is in CIMEnableModuleRequestMessage
204                   CIMEnableModuleRequestMessage* emReq =
205                       dynamic_cast<CIMEnableModuleRequestMessage*>(request);
206                   providerModule = emReq->providerModule;
207               }
208               else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)
209               {
210                   // Provider information is in CIMDisableModuleRequestMessage
211 kumpf 1.1         CIMDisableModuleRequestMessage* dmReq =
212                       dynamic_cast<CIMDisableModuleRequestMessage*>(request);
213                   providerModule = dmReq->providerModule;
214               }
215               else if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)
216               {
217                   // This operation is not provider-specific
218               }
219               else
220               {
221                   // Error: Unrecognized message type.
222                   PEGASUS_ASSERT(0);
223                   CIMResponseMessage* resp = new CIMResponseMessage(
224                       0, request->messageId, CIMException(),
225                       request->queueIds.copyAndPop());
226                   resp->synch_response(request);
227                   OperationResponseHandler handler(request, resp);
228                   handler.setStatus(CIM_ERR_FAILED, "Unknown message type.");
229                   response = resp;
230               }
231           
232 kumpf 1.1     //
233               // Forward the request to the appropriate ProviderManager(s)
234               //
235           
236               if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)
237               {
238                   // Send CIMStopAllProvidersRequestMessage to all ProviderManagers
239                   for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
240                   {
241                       ProviderManagerContainer* pmc=_providerManagerTable[i];
242                       Message* resp = pmc->getProviderManager()->processMessage(request);
243                       if (resp)
244                       {
245                           response = resp;
246                       }
247                   }
248               }
249               else
250               {
251                   // Retrieve the provider interface type
252                   String interfaceType;
253 kumpf 1.1         CIMValue itValue = providerModule.getProperty(
254                       providerModule.findProperty("InterfaceType")).getValue();
255                   itValue.get(interfaceType);
256           
257                   // Look up the appropriate ProviderManager by InterfaceType
258                   ProviderManager* pm = _lookupProviderManager(interfaceType);
259                   response = pm->processMessage(request);
260               }
261           
262               // preserve message key
263               response->setKey(request->getKey());
264           
265               // set HTTP method in response from request
266               response->setHttpMethod(request->getHttpMethod());
267           
268               PEG_METHOD_EXIT();
269               return response;
270           }
271           
272           // ATTN: May need to add interfaceVersion parameter to further constrain lookup
273           ProviderManager* BasicProviderManagerRouter::_lookupProviderManager(
274 kumpf 1.1     const String& interfaceType)
275           {
276               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
277                   "BasicProviderManagerRouter::_lookupProviderManager");
278           
279               //
280               // Search for this InterfaceType in the table of loaded ProviderManagers
281               //
282               {
283                   ReadLock tableLock(_providerManagerTableLock);
284           
285                   // find provider manager for specified provider interface type
286                   for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
287                   {
288                       if (interfaceType == _providerManagerTable[i]->getInterfaceName())
289                       {
290                           ProviderManagerContainer* pmc=_providerManagerTable[i];
291                           PEG_METHOD_EXIT();
292                           return pmc->getProviderManager();
293                       }
294                   }
295 kumpf 1.1     }
296           
297               //
298               // Load the ProviderManager for this InterfaceType and add it to the table
299               //
300               {
301                   WriteLock tableLock(_providerManagerTableLock);
302           
303                   // ATTN: this section is a temporary solution to populate the list of
304                   // enabled provider managers for a given distribution.  It includes
305                   // another temporary solution for converting a generic file name into
306                   // a file name useable by each platform.
307           
308           #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
309                   if (interfaceType == "C++Default")
310                   {
311                       ProviderManagerContainer* pmc = new ProviderManagerContainer(
312                           LIBRARY_NAME_DEFAULTPM, "DEFAULT", "C++Default",
313                           _indicationCallback);
314                       _providerManagerTable.append(pmc);
315                       return pmc->getProviderManager();
316 kumpf 1.1         }
317           #endif
318           
319           #if defined(ENABLE_CMPI_PROVIDER_MANAGER)
320                   if (interfaceType == "CMPI")
321                   {
322                       ProviderManagerContainer* pmc = new ProviderManagerContainer(
323                           LIBRARY_NAME_CMPIPM, "CMPI", "CMPI", _indicationCallback);
324                       _providerManagerTable.append(pmc);
325                       return pmc->getProviderManager();
326                   }
327           #endif
328           
329           #if defined(ENABLE_JMPI_PROVIDER_MANAGER)
330                   if (interfaceType == "JMPI")
331                   {
332                       ProviderManagerContainer* pmc = new ProviderManagerContainer(
333                           LIBRARY_NAME_JMPIPM, "JMPI", "JMPI", _indicationCallback);
334                       _providerManagerTable.append(pmc);
335                       return pmc->getProviderManager();
336                   }
337 kumpf 1.1 #endif
338                   // END TEMP SECTION
339               }
340           
341               // Error: ProviderManager not found for the specified interface type
342               PEGASUS_ASSERT(0);
343               PEG_METHOD_EXIT();
344               return 0;
345           }
346           
347           void BasicProviderManagerRouter::unload_idle_providers(void)
348           {
349               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
350                   "BasicProviderManagerRouter::unload_idle_providers");
351           
352               for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
353               {
354                   ProviderManagerContainer* pmc = _providerManagerTable[i];
355                   pmc->getProviderManager()->unload_idle_providers();
356               }
357           
358 kumpf 1.1     PEG_METHOD_EXIT();
359           }
360           
361           PEGASUS_NAMESPACE_END