1 schuur 1.1 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // of this software and associated documentation files (the "Software"), to
8 // deal in the Software without restriction, including without limitation the
9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 // sell copies of the Software, and to permit persons to whom the Software is
11 // furnished to do so, subject to the following conditions:
12 //
13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 //
22 schuur 1.1 //==============================================================================
23 //
24 // Author: Chip Vincent (cvincent@us.ibm.com)
25 //
26 // Modified By: Yi Zhou, Hewlett-Packard Company(yi_zhou@hp.com)
27 // Mike Day IBM Corporation (mdday@us.ibm.com)
28 // Adrian Schuur, schuur@de.ibm.com
|
29 dj.gorey 1.6 // Dan Gorey, IBM djgorey@us.ibm.com
|
30 schuur 1.1 //
31 //%/////////////////////////////////////////////////////////////////////////////
32
33 #include <Pegasus/Common/Constants.h>
34 #include <Pegasus/Common/Tracer.h>
35 #include <Pegasus/Common/PegasusVersion.h>
36
37 #include <Pegasus/ProviderManager2/CMPI/CMPIProvider.h>
38 #include <Pegasus/ProviderManager2/CMPI/CMPIProviderModule.h>
39 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
40
|
41 kumpf 1.9 #include "CMPILocalProviderManager.h"
42
|
43 schuur 1.3 PEGASUS_USING_STD;
|
44 schuur 1.1 PEGASUS_NAMESPACE_BEGIN
45
|
46 schuur 1.8 #undef IDLE_LIMIT
47 #define IDLE_LIMIT 50
|
48 schuur 1.1 CMPILocalProviderManager::CMPILocalProviderManager(void)
|
49 kumpf 1.9 : _idle_timeout(IDLE_LIMIT)
|
50 schuur 1.1 {
51 }
52
53 CMPILocalProviderManager::~CMPILocalProviderManager(void)
54 {
55 Uint32 ccode;
56
|
57 schuur 1.2 // _provider_ctrl(UNLOAD_ALL_PROVIDERS, this, &ccode);
|
58 dj.gorey 1.6
|
59 schuur 1.1 }
60
61 Sint32 CMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret)
62 {
63
64 static Uint32 quantum;
65 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_provider_ctrl");
66
67 Sint32 ccode = 0;
68 CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);
69
70 switch(code)
71 {
72
73 case GET_PROVIDER:
74 {
75
76 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
77 "_provider_ctrl::GET_PROVIDER");
78
|
79 dj.gorey 1.6 String providerName = *(parms->providerName);
80 String moduleFileName = *(parms->fileName);
81 String interfaceName = *(parms->interfaceName);
82 CMPIProvider *pr = 0;
|
83 schuur 1.1 CMPIProvider::OpProviderHolder* ph =
84 reinterpret_cast< CMPIProvider::OpProviderHolder* >( ret );
85
|
86 dj.gorey 1.6 pr = _lookupProvider(providerName);
87
88 if(pr->getStatus() != CMPIProvider::INITIALIZED)
|
89 schuur 1.1 {
|
90 dj.gorey 1.6 _initProvider(pr,moduleFileName, interfaceName);
|
91 schuur 1.1 }
92
|
93 dj.gorey 1.6 if(pr->_status != CMPIProvider::INITIALIZED)
|
94 schuur 1.1 {
|
95 dj.gorey 1.6 PEG_METHOD_EXIT();
96 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,"provider initialization failed");
|
97 schuur 1.1 }
98
99
100 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
101 dj.gorey 1.6 "Returning Provider" + providerName);
|
102 schuur 1.1
|
103 dj.gorey 1.6
|
104 schuur 1.1 ph->SetProvider( pr );
|
105 dj.gorey 1.6 ph->GetProvider().update_idle_timer();
|
106 schuur 1.1 break;
107 }
108
109 case UNLOAD_PROVIDER:
110 {
111
112 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
113 "_provider_ctrl::UNLOAD_PROVIDER");
|
114 dj.gorey 1.6 CMPIProvider *pr = _lookupProvider(*(parms->providerName));
|
115 schuur 1.1
|
116 dj.gorey 1.6 if((pr->getStatus() == CMPIProvider::INITIALIZED))
|
117 schuur 1.1 {
|
118 dj.gorey 1.6
|
119 schuur 1.1
|
120 dj.gorey 1.6 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
121 "Unloading CMPIProvider" + pr->_name );
|
122 schuur 1.1
|
123 dj.gorey 1.6 AutoMutex lock(_providerTableMutex);
124 _unloadProvider(pr);
|
125 schuur 1.1 }
126 break;
127 }
128
129 case LOOKUP_PROVIDER:
130 {
131
132 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
133 "_provider_ctrl::LOOKUP_PROVIDER");
134
|
135 dj.gorey 1.6 AutoMutex lock(_providerTableMutex);
136
|
137 schuur 1.1 if(true == _providers.lookup(*(parms->providerName),
138 *(reinterpret_cast<CMPIProvider * *>(ret))))
139 {
140 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
141 "Found CMPIProvider in cache: " +
142 *(parms->providerName));
143
144 (*(reinterpret_cast<CMPIProvider * *>(ret)))->update_idle_timer();
145 }
146 else
147 {
148
149 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
150 "Could not find CMPIProvider in cache: " +
151 *(parms->providerName));
152 ccode = -1;
153 }
154
155 break;
156 }
157
158 schuur 1.1 case LOOKUP_MODULE:
159 {
160
161 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
162 "_provider_ctrl::LOOKUP_MODULE");
163
|
164 dj.gorey 1.6 AutoMutex lock(_providerTableMutex);
165
|
166 schuur 1.1 if(false == _modules.lookup(*(parms->fileName),
167 *(reinterpret_cast<CMPIProviderModule * *>(ret))))
168 {
169 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
170 "Could not find CMPIProvider Module in cache: " +
171 *(parms->fileName));
172 ccode = -1;
173 }
174
175 break;
176 }
177
178 case INSERT_PROVIDER:
179 {
180
181 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
182 "_provider_ctrl::INSERT_PROVIDER");
|
183 dj.gorey 1.6
184 AutoMutex lock(_providerTableMutex);
185
|
186 schuur 1.1 if(false == _providers.insert(
187 *(parms->providerName),
188 *reinterpret_cast<CMPIProvider * *>(parm)))
189 ccode = -1;
190 break;
191 }
192 case INSERT_MODULE:
193 {
194 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
195 "_provider_ctrl::INSERT_MODULE");
|
196 dj.gorey 1.6 AutoMutex lock(_providerTableMutex);
|
197 schuur 1.1 if(false == _modules.insert(
198 *(parms->fileName),
199 *reinterpret_cast<CMPIProviderModule * *>(parm)))
200 ccode = -1;
201 break;
202 }
|
203 dj.gorey 1.6
|
204 schuur 1.1 case UNLOAD_ALL_PROVIDERS:
205 {
206 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
207 "_provider_ctrl::UNLOAD_ALL_PROVIDERS");
208 CMPILocalProviderManager *myself = reinterpret_cast<CMPILocalProviderManager *>(parm);
209 CMPIProvider * provider;
|
210 dj.gorey 1.6 AutoMutex lock(_providerTableMutex);
211 Tracer::trace(TRC_PROVIDERMANAGER,Tracer::LEVEL4,
212 "providers in cache = %d", myself->_providers.size());
|
213 schuur 1.1 ProviderTable::Iterator i = myself->_providers.start();
214 try
215 {
216 for(; i != 0; i++)
217 {
218 provider = i.value();
|
219 dj.gorey 1.6 PEGASUS_ASSERT(provider!=0);
220 if(provider->getStatus()==CMPIProvider::UNINITIALIZED)
|
221 schuur 1.1 {
222 continue;
223 }
|
224 dj.gorey 1.6 else
|
225 schuur 1.1 {
|
226 dj.gorey 1.6 _unloadProvider(provider);
|
227 schuur 1.1 }
228 }
|
229 dj.gorey 1.6
|
230 schuur 1.1 }
231 catch(...)
232 {
233 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
234 "Unexpected Exception in UNLOAD_ALL_PROVIDERS.");
235 }
236 break;
237 }
238
239 case UNLOAD_IDLE_PROVIDERS:
240 {
241 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
242 "_provider_ctrl::UNLOAD_IDLE_PROVIDERS");
|
243 dj.gorey 1.6 AutoMutex lock(_providerTableMutex);
|
244 schuur 1.1
245 quantum++;
246 CMPILocalProviderManager *myself = reinterpret_cast<CMPILocalProviderManager *>(parm);
247 CMPIProvider * provider;
248
249 if(myself->_providers.size())
250 {
251 try
252 {
253 struct timeval now;
254 gettimeofday(&now, NULL);
255 ProviderTable::Iterator i = myself->_providers.start();
256 for(; i != 0 ; i++)
257 {
258 provider = i.value();
|
259 dj.gorey 1.6 PEGASUS_ASSERT(provider != 0);
260 if(provider->getStatus() == CMPIProvider::UNINITIALIZED)
|
261 schuur 1.1 {
262 continue;
263 }
264
265 if(provider->_quantum == quantum)
266 {
267 continue;
268 }
269
270 provider->_quantum = quantum;
271
272 if(provider->_current_operations.value())
273 {
274 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
275 "CMPIProvider has pending operations: " +
276 provider->getName());
|
277 dj.gorey 1.6
|
278 schuur 1.1 continue;
279 }
280
281 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
282 "Checking timeout data for CMPIProvider: " +
283 provider->getName());
284 struct timeval timeout = {0,0};
285 provider->get_idle_timer(&timeout);
286 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
287 " provider->unload_ok() returns: " +
288 provider->unload_ok() ? "true" : "false" );
289
290 if(provider->unload_ok() == true &&
291 ( now.tv_sec - timeout.tv_sec) > ((Sint32)myself->_idle_timeout))
292 {
|
293 dj.gorey 1.6 AutoMutex pr_lock(provider->_statusMutex);
|
294 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
295 "ProviderManager::_provider_crtl - Unload idle provider $0",
296 provider->getName());
297
298 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
299 "Trying to Terminate CMPIProvider " + provider->getName());
300 try
301 {
302 if(false == provider->tryTerminate())
303 {
304 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
305 "CMPIProvider Refused Termination " + provider->getName());
306
307 continue;
308 }
309 else
310 {
311 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
312 "CMPIProvider terminated: " + provider->getName());
|
313 schuur 1.8 }
|
314 schuur 1.1 }
315 catch(...)
316 {
317 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
318 "Exception terminating " +
319 provider->getName());
|
320 dj.gorey 1.6
|
321 schuur 1.1 continue;
322 }
|
323 dj.gorey 1.6 PEGASUS_ASSERT(provider->_module!=0);
|
324 schuur 1.1 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
325 dj.gorey 1.6 "unloading provider module " + provider->getName());
326 provider->_module->unloadModule();
|
327 schuur 1.1
|
328 dj.gorey 1.6
|
329 schuur 1.1 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
330 "Destroying CMPIProvider's CIMOM Handle: " +
331 provider->getName());
|
332 schuur 1.8 _providers.remove(provider->getName());
|
333 schuur 1.1 delete provider->_cimom_handle;
|
334 dj.gorey 1.6 provider->reset();
|
335 schuur 1.8 delete provider;
|
336 schuur 1.1 }
337 }
338 }
339 catch(...)
340 {
341 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
342 "Unexpected Exception in UNLOAD_IDLE_PROVIDERS.");
343 }
344 } // if there are any providers
345 break;
346 }
347
348 default:
349 ccode = -1;
350 break;
351 }
352 PEG_METHOD_EXIT();
353 return(ccode);
354 }
355
356 CMPIProvider * CMPILocalProviderManager::_getResolver
357 schuur 1.1 (const String & fileName, const String & interfaceType)
358 {
359 CMPIProvider *pr;
360 String id(interfaceType+String("::")+fileName);
361 if (true == _resolvers.lookup(id,pr)) {
362 return pr;
363 }
364 return NULL;
365 }
366
367 CMPIResolverModule *CMPILocalProviderManager::_loadResolver
368 (const String & fileName)
369 {
370 CMPIResolverModule *rm=new CMPIResolverModule(fileName);
371 rm->load();
372 return rm;
373 }
374
375 CMPIProvider::OpProviderHolder CMPILocalProviderManager::getProvider(
376 const String & fileName,
377 const String & providerName,
378 schuur 1.1 const String & interfaceName)
379 {
380 CMPIProvider::OpProviderHolder ph;
381 CTRL_STRINGS strings;
382 Sint32 ccode;
383 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider");
384 strings.fileName = &fileName;
385 strings.providerName = &providerName;
386 strings.interfaceName = &interfaceName;
387
388 try {
389 ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );
390 }
391 catch (Exception e) {
|
392 schuur 1.3 cerr<<"--- loading proxy: "<<e.getMessage()<<endl;
|
393 schuur 1.1 PEG_METHOD_EXIT();
394 throw;
395 }
396 catch(...) {
397 PEG_METHOD_EXIT();
398 throw;
399 }
400
401
402 PEG_METHOD_EXIT();
403 return(ph);
404
405 }
406
407 void CMPILocalProviderManager::unloadProvider(
408 const String & fileName,
409 const String & providerName)
410 {
411 CTRL_STRINGS strings;
412 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider");
413 strings.fileName = &fileName;
414 schuur 1.1 strings.providerName = &providerName;
415 _provider_ctrl(UNLOAD_PROVIDER, &strings, (void *)0);
416 PEG_METHOD_EXIT();
417 }
418
419 void CMPILocalProviderManager::shutdownAllProviders(void)
420 {
421
422 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::shutdownAllProviders");
423 _provider_ctrl(UNLOAD_ALL_PROVIDERS, (void *)this, (void *)0);
424 PEG_METHOD_EXIT();
425 }
426
427
|
428 kumpf 1.9 Boolean CMPILocalProviderManager::hasActiveProviders()
|
429 schuur 1.1 {
|
430 kumpf 1.9 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
431 "ProviderManager::hasActiveProviders");
432
433 try
|
434 schuur 1.1 {
|
435 kumpf 1.9 AutoMutex lock(_providerTableMutex);
436 Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
437 "providers in _providers table = %d", _providers.size());
438
439 // Iterate through the _providers table looking for an active provider
440 for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
|
441 schuur 1.1 {
|
442 kumpf 1.9 if (i.value()->getStatus() == CMPIProvider::INITIALIZED)
443 {
444 PEG_METHOD_EXIT();
445 return true;
446 }
|
447 schuur 1.1 }
448 }
|
449 kumpf 1.9 catch (...)
450 {
451 // Unexpected exception; do not assume that no providers are loaded
452 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
453 "Unexpected Exception in hasActiveProviders.");
454 PEG_METHOD_EXIT();
455 return true;
456 }
457
458 // No active providers were found in the _providers table
|
459 schuur 1.1 PEG_METHOD_EXIT();
|
460 kumpf 1.9 return false;
|
461 schuur 1.1 }
462
|
463 kumpf 1.9 void CMPILocalProviderManager::unloadIdleProviders(void)
|
464 schuur 1.1 {
|
465 kumpf 1.9 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
466 "ProviderManager::unloadIdleProviders");
|
467 schuur 1.1
|
468 kumpf 1.9 static struct timeval first = {0,0}, now, last = {0,0};
469
470 if(first.tv_sec == 0)
|
471 schuur 1.1 {
|
472 kumpf 1.9 gettimeofday(&first, NULL);
|
473 schuur 1.1 }
|
474 kumpf 1.9 gettimeofday(&now, NULL);
475
476 if (((now.tv_sec - first.tv_sec) > IDLE_LIMIT) &&
477 ((now.tv_sec - last.tv_sec) > IDLE_LIMIT))
|
478 schuur 1.1 {
|
479 kumpf 1.9 gettimeofday(&last, NULL);
480 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
481 "Checking for Idle providers to unload.");
482 try
483 {
484 _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);
485 }
486 catch(...)
487 {
488 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
489 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
490 }
|
491 schuur 1.1 }
492 PEG_METHOD_EXIT();
|
493 dj.gorey 1.6 }
494
|
495 kumpf 1.9
|
496 dj.gorey 1.6 CMPIProvider* CMPILocalProviderManager::_initProvider(
497 CMPIProvider * provider,
498 const String & moduleFileName,
499 const String & interfaceName)
500 {
501 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_initProvider");
502
503 CMPIProviderModule *module = 0;
504 ProviderVector base;
505
506 {
507 // lock the providerTable mutex
508 AutoMutex lock(_providerTableMutex);
509
510 // lookup provider module
511 module = _lookupModule(moduleFileName, interfaceName);
512
513 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
514 "Loading/Linking Provider Module " + moduleFileName);
515
516 // load the provider
517 dj.gorey 1.6 try
518 {
519 base = module->load(provider->_name);
520 }
521 catch(...)
522 {
523 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
524 "Exception caught Loading/Linking Provider Module " +
525 moduleFileName);
526 PEG_METHOD_EXIT();
527 throw;
528 }
529 } // unlock the providerTable mutex
530
531 // initialize the provider
532 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
533 "Initializing Provider " + provider->_name);
534
535 //
536 // Set the undoModuleLoad flag to true here, so that if the
537 // initialize() throws an exception, we can unload the provider
538 dj.gorey 1.6 // module.
539 //
540 Boolean undoModuleLoad = true;
541
542 { // lock the provider mutex
543 AutoMutex pr_lock(provider->_statusMutex);
544
545 // check provider status
546 if (provider->_status == CMPIProvider::UNINITIALIZED)
547 {
548 CIMOMHandle *cimomHandle = new CIMOMHandle();
549 provider->set(module, base, cimomHandle);
550 provider->_quantum=0;
551
552 try
553 {
554 provider->initialize(*(provider->_cimom_handle));
555 undoModuleLoad = false;
556 }
557 catch(...)
558 {
|
559 schuur 1.8 _providers.remove(provider->getName());
|
560 dj.gorey 1.6 // delete the cimom handle
561 delete provider->_cimom_handle;
562 // set provider status to UNINITIALIZED
|
563 schuur 1.8 provider->reset();
564 delete provider;
|
565 dj.gorey 1.6 }
566 }
567 } // unlock the provider mutex
568
569 // if we did not initialize the provider, unload the provider module
570 if (undoModuleLoad)
571 {
572 // lock the providerTable mutex
573 AutoMutex lock(_providerTableMutex);
574
575 // unload provider module
576 module->unloadModule();
577 }
578
579 PEG_METHOD_EXIT();
580 return(provider);
581 }
582
583
584 void CMPILocalProviderManager::_unloadProvider( CMPIProvider * provider)
585 {
586 dj.gorey 1.6 //
587 // NOTE: It is the caller's responsibility to make sure that
588 // the ProviderTable mutex is locked before calling this method.
589 //
590 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_unloadProvider");
591
592 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
593 "Unloading Provider " + provider->_name );
594
595 if ( provider->_current_operations.value())
596 {
597 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
598 "Provider cannot be unloaded due to pending operations: " +
599 provider->_name );
600 }
601 else
602 {
603 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
604 "Terminating Provider " + provider->_name );
605
606 // lock the provider mutex
607 dj.gorey 1.6 AutoMutex pr_lock(provider->_statusMutex);
608
609 try
610 {
611 provider->terminate();
612 }
613 catch(...)
614 {
615 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
616 "Error occured terminating CMPI provider " + provider->_name );
617 }
618
619 // delete the cimom handle
620 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
621 "Destroying CMPIProvider's CIMOM Handle " + provider->_name );
|
622 schuur 1.8 _providers.remove(provider->getName());
|
623 dj.gorey 1.6 delete provider->_cimom_handle;
624
625 PEGASUS_ASSERT(provider->_module != 0);
626
627 // unload provider module
628 provider->_module->unloadModule();
629
630 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
631 "CMPILocalProviderManager::_provider_crtl - Unload provider $0",
632 provider->getName());
633
634 // set provider status to UNINITIALIZED
|
635 schuur 1.8 provider->reset();
636 delete provider;
|
637 dj.gorey 1.6 }
638
639 PEG_METHOD_EXIT();
640 }
641
642 CMPIProvider * CMPILocalProviderManager::_lookupProvider(
643 const String & providerName)
644 {
645 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_lookupProvider");
646
647 // lock the providerTable mutex
648 AutoMutex lock(_providerTableMutex);
649
650 // look up provider in cache
651 CMPIProvider * pr = 0;
652 if ( true == _providers.lookup(providerName, pr) )
653 {
654 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
655 "Found Provider " + providerName +
656 " in CMPI Provider Manager Cache");
657 }
658 dj.gorey 1.6 else
659 {
660 // create provider
661 pr = new CMPIProvider(providerName, 0, 0);
662
663 // insert provider in provider table
664 _providers.insert(providerName, pr);
665
666 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
667 "Created provider " + pr->getName());
668 }
669
670 PEG_METHOD_EXIT();
671 return (pr);
672 }
673
674
675 CMPIProviderModule * CMPILocalProviderManager::_lookupModule(
676 const String & moduleFileName,
677 const String & interfaceName)
678 {
679 dj.gorey 1.6 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_lookupModule");
680
681 // look up provider module in cache
682 CMPIProviderModule * module = 0;
683
684 if ( true == _modules.lookup(moduleFileName, module) )
685 {
686 // found provider module in cache
687 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
688 "Found Provider Module" + moduleFileName +
689 " in Provider Manager Cache");
690
691 }
692 else
693 {
694 // provider module not found in cache, create provider module
695 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
696 "Creating CMPI Provider Module " + moduleFileName);
697
698 module = new CMPIProviderModule(moduleFileName, interfaceName);
699
700 dj.gorey 1.6 // insert provider module in module table
701 _modules.insert(moduleFileName, module);
702 }
703
704 PEG_METHOD_EXIT();
705 return (module);
|
706 schuur 1.1 }
707
708 PEGASUS_NAMESPACE_END
709
|
Return to
CMPILocalProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI