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