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