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 kumpf 1.4         (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE) ||
188           	(request->getType() == CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE))

189 kumpf 1.1     {
190                   // Provider information is in OperationContext
191                   ProviderIdContainer pidc = (ProviderIdContainer)
192                       request->operationContext.get(ProviderIdContainer::NAME);
193                   providerModule = pidc.getModule();
194               }
195               else if (dynamic_cast<CIMIndicationRequestMessage*>(request) != 0)
196               {
197                   // Provider information is in CIMIndicationRequestMessage
198                   CIMIndicationRequestMessage* indReq =
199                       dynamic_cast<CIMIndicationRequestMessage*>(request);
200                   providerModule = indReq->providerModule;
201               }
202               else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
203               {
204                   // Provider information is in CIMEnableModuleRequestMessage
205                   CIMEnableModuleRequestMessage* emReq =
206                       dynamic_cast<CIMEnableModuleRequestMessage*>(request);
207                   providerModule = emReq->providerModule;
208               }
209               else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)
210 kumpf 1.1     {
211                   // Provider information is in CIMDisableModuleRequestMessage
212                   CIMDisableModuleRequestMessage* dmReq =
213                       dynamic_cast<CIMDisableModuleRequestMessage*>(request);
214                   providerModule = dmReq->providerModule;
215               }
216               else if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)
217               {
218                   // This operation is not provider-specific
219               }
220               else
221               {
222                   // Error: Unrecognized message type.
223                   PEGASUS_ASSERT(0);
224                   CIMResponseMessage* resp = new CIMResponseMessage(
225                       0, request->messageId, CIMException(),
226                       request->queueIds.copyAndPop());
227                   resp->synch_response(request);
228                   OperationResponseHandler handler(request, resp);
229                   handler.setStatus(CIM_ERR_FAILED, "Unknown message type.");
230                   response = resp;
231 kumpf 1.1     }
232           
233               //
234               // Forward the request to the appropriate ProviderManager(s)
235               //
236           
237               if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)
238               {
239                   // Send CIMStopAllProvidersRequestMessage to all ProviderManagers

240 kumpf 1.5         ReadLock tableLock(_providerManagerTableLock);

241 kumpf 1.1         for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
242                   {
243                       ProviderManagerContainer* pmc=_providerManagerTable[i];
244                       Message* resp = pmc->getProviderManager()->processMessage(request);
245                       if (resp)
246                       {

247 kumpf 1.3                 delete resp;

248 kumpf 1.1             }
249                   }

250 kumpf 1.3 
251                   response = new CIMStopAllProvidersResponseMessage(
252                       request->messageId,
253                       CIMException(),
254                       request->queueIds.copyAndPop());

255 kumpf 1.1     }
256               else
257               {
258                   // Retrieve the provider interface type
259                   String interfaceType;
260                   CIMValue itValue = providerModule.getProperty(
261                       providerModule.findProperty("InterfaceType")).getValue();
262                   itValue.get(interfaceType);
263           
264                   // Look up the appropriate ProviderManager by InterfaceType
265                   ProviderManager* pm = _lookupProviderManager(interfaceType);
266                   response = pm->processMessage(request);
267               }
268           
269               // preserve message key
270               response->setKey(request->getKey());
271           
272               // set HTTP method in response from request
273               response->setHttpMethod(request->getHttpMethod());
274           
275               PEG_METHOD_EXIT();
276 kumpf 1.1     return response;
277           }
278           
279           // ATTN: May need to add interfaceVersion parameter to further constrain lookup
280           ProviderManager* BasicProviderManagerRouter::_lookupProviderManager(
281               const String& interfaceType)
282           {
283               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
284                   "BasicProviderManagerRouter::_lookupProviderManager");
285           
286               //
287               // Search for this InterfaceType in the table of loaded ProviderManagers
288               //
289               {
290                   ReadLock tableLock(_providerManagerTableLock);
291           
292                   // find provider manager for specified provider interface type
293                   for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
294                   {
295                       if (interfaceType == _providerManagerTable[i]->getInterfaceName())
296                       {
297 kumpf 1.1                 ProviderManagerContainer* pmc=_providerManagerTable[i];
298                           PEG_METHOD_EXIT();
299                           return pmc->getProviderManager();
300                       }
301                   }
302               }
303           
304               //
305               // Load the ProviderManager for this InterfaceType and add it to the table
306               //
307               {
308                   WriteLock tableLock(_providerManagerTableLock);
309           
310                   // ATTN: this section is a temporary solution to populate the list of
311                   // enabled provider managers for a given distribution.  It includes
312                   // another temporary solution for converting a generic file name into
313                   // a file name useable by each platform.
314           
315           #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
316                   if (interfaceType == "C++Default")
317                   {
318 kumpf 1.1             ProviderManagerContainer* pmc = new ProviderManagerContainer(
319                           LIBRARY_NAME_DEFAULTPM, "DEFAULT", "C++Default",
320                           _indicationCallback);
321                       _providerManagerTable.append(pmc);
322                       return pmc->getProviderManager();
323                   }
324           #endif
325           
326           #if defined(ENABLE_CMPI_PROVIDER_MANAGER)
327                   if (interfaceType == "CMPI")
328                   {
329                       ProviderManagerContainer* pmc = new ProviderManagerContainer(
330                           LIBRARY_NAME_CMPIPM, "CMPI", "CMPI", _indicationCallback);
331                       _providerManagerTable.append(pmc);
332                       return pmc->getProviderManager();
333                   }
334           #endif
335           
336           #if defined(ENABLE_JMPI_PROVIDER_MANAGER)
337                   if (interfaceType == "JMPI")
338                   {
339 kumpf 1.1             ProviderManagerContainer* pmc = new ProviderManagerContainer(
340                           LIBRARY_NAME_JMPIPM, "JMPI", "JMPI", _indicationCallback);
341                       _providerManagerTable.append(pmc);
342                       return pmc->getProviderManager();
343                   }
344           #endif
345                   // END TEMP SECTION
346               }
347           
348               // Error: ProviderManager not found for the specified interface type
349               PEGASUS_ASSERT(0);
350               PEG_METHOD_EXIT();
351               return 0;
352           }
353           

354 kumpf 1.5 Boolean BasicProviderManagerRouter::hasActiveProviders()

355 kumpf 1.1 {
356               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

357 kumpf 1.5         "BasicProviderManagerRouter::hasActiveProviders");

358 kumpf 1.1 

359 kumpf 1.5     ReadLock tableLock(_providerManagerTableLock);

360 kumpf 1.1     for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
361               {
362                   ProviderManagerContainer* pmc = _providerManagerTable[i];

363 kumpf 1.5         if (pmc->getProviderManager()->hasActiveProviders())
364                   {
365                       PEG_METHOD_EXIT();
366                       return true;
367                   }
368               }
369           
370               PEG_METHOD_EXIT();
371               return false;
372           }
373           
374           void BasicProviderManagerRouter::unloadIdleProviders()
375           {
376               PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
377                   "BasicProviderManagerRouter::unloadIdleProviders");
378           
379               //
380               // Save pointers to the ProviderManagerContainers so we don't hold the
381               // _providerManagerTableLock while unloading idle providers
382               //
383               Array<ProviderManagerContainer*> pmcs;
384 kumpf 1.5     {
385                   ReadLock tableLock(_providerManagerTableLock);
386                   for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
387                   {
388                       pmcs.append(_providerManagerTable[i]);
389                   }
390               }
391           
392               //
393               // Unload idle providers in each of the active ProviderManagers
394               // _providerManagerTableLock while unloading idle providers
395               //
396               for (Uint32 i = 0; i < pmcs.size(); i++)
397               {
398                   pmcs[i]->getProviderManager()->unloadIdleProviders();

399 kumpf 1.1     }
400           
401               PEG_METHOD_EXIT();
402           }
403           
404           PEGASUS_NAMESPACE_END