1 martin 1.60 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.61 //
|
3 martin 1.60 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
|
9 martin 1.61 //
|
10 martin 1.60 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
|
16 martin 1.61 //
|
17 martin 1.60 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.61 //
|
20 martin 1.60 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.61 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.60 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
27 martin 1.61 //
|
28 martin 1.60 //////////////////////////////////////////////////////////////////////////
|
29 schuur 1.1 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
|
32 schuur 1.10 #include "CMPI_Version.h"
33
|
34 schuur 1.1 #include <Pegasus/Common/Constants.h>
|
35 mike 1.38 #include <Pegasus/Common/Time.h>
|
36 schuur 1.1 #include <Pegasus/Common/Tracer.h>
37 #include <Pegasus/Common/PegasusVersion.h>
38
|
39 konrad.r 1.26 #include <Pegasus/Common/MessageLoader.h>
|
40 venkat.puvvada 1.57 #include <Pegasus/Config/ConfigManager.h>
|
41 konrad.r 1.26
|
42 schuur 1.1 #include <Pegasus/ProviderManager2/CMPI/CMPIProvider.h>
43 #include <Pegasus/ProviderManager2/CMPI/CMPIProviderModule.h>
|
44 konrad.r 1.30 #include <Pegasus/ProviderManager2/CMPI/CMPILocalProviderManager.h>
|
45 kumpf 1.9
|
46 schuur 1.3 PEGASUS_USING_STD;
|
47 schuur 1.1 PEGASUS_NAMESPACE_BEGIN
|
48 konrad.r 1.27
|
49 konrad.r 1.30 /* Thread deletion specific */
50 Semaphore CMPILocalProviderManager::_pollingSem(0);
51 AtomicInt CMPILocalProviderManager::_stopPolling(0);
52 Thread *CMPILocalProviderManager::_reaperThread = 0;
|
53 kumpf 1.62 List<CMPILocalProviderManager::cleanupThreadRecord,Mutex>
|
54 venkat.puvvada 1.48 CMPILocalProviderManager::_finishedThreadList;
|
55 mike 1.38 Mutex CMPILocalProviderManager::_reaperMutex;
|
56 konrad.r 1.30
|
57 venkat.puvvada 1.48 CMPILocalProviderManager::CMPILocalProviderManager ():
|
58 r.kieninger 1.51 _idle_timeout (PEGASUS_PROVIDER_IDLE_TIMEOUT_SECONDS)
|
59 r.kieninger 1.14 {
|
60 ms.aruran 1.49 PEG_METHOD_ENTER(
61 TRC_PROVIDERMANAGER,
62 "CMPILocalProviderManager::CMPILocalProviderManager()");
63 PEG_METHOD_EXIT();
|
64 schuur 1.1 }
65
|
66 venkat.puvvada 1.48 CMPILocalProviderManager::~CMPILocalProviderManager ()
|
67 r.kieninger 1.14 {
|
68 venkat.puvvada 1.48 Uint32 ccode;
|
69 ms.aruran 1.49 PEG_METHOD_ENTER(
70 TRC_PROVIDERMANAGER,
71 "MPILocalProviderManager::~CMPILocalProviderManager()");
|
72 dj.gorey 1.6
|
73 venkat.puvvada 1.48 _provider_ctrl (UNLOAD_ALL_PROVIDERS, this, &ccode);
|
74 kumpf 1.62 // Since all of the providers are deleted we can delete the
|
75 venkat.puvvada 1.48 // modules too.
76 for (ModuleTable::Iterator j = _modules.start (); j != 0; j++)
|
77 konrad.r 1.24 {
|
78 venkat.puvvada 1.48 CMPIProviderModule *module = j.value ();
79 delete module;
|
80 konrad.r 1.24 }
|
81 konrad.r 1.30
|
82 venkat.puvvada 1.48 if (_reaperThread)
|
83 konrad.r 1.30 {
|
84 venkat.puvvada 1.48 AutoMutex lock(_reaperMutex);
85 _stopPolling++;
86 _pollingSem.signal();
87 // Wait until it finishes itself.
|
88 kumpf 1.62 _reaperThread->join();
89 delete _reaperThread;
|
90 venkat.puvvada 1.48 _reaperThread = 0;
91 }
92 PEGASUS_ASSERT(_finishedThreadList.size() == 0);
|
93 ms.aruran 1.49 PEG_METHOD_EXIT();
|
94 schuur 1.1 }
95
|
96 venkat.puvvada 1.48 Sint32 CMPILocalProviderManager::_provider_ctrl (
|
97 kumpf 1.62 CTRL code,
98 void *parm,
|
99 venkat.puvvada 1.48 void *ret)
|
100 r.kieninger 1.14 {
|
101 r.kieninger 1.13
|
102 venkat.puvvada 1.48 static Uint32 quantum;
|
103 ms.aruran 1.49 PEG_METHOD_ENTER(
104 TRC_PROVIDERMANAGER,
105 "CMPILocalProviderManager::_provider_ctrl()");
|
106 r.kieninger 1.13
|
107 venkat.puvvada 1.48 Sint32 ccode = 0;
|
108 kumpf 1.58 CTRL_STRINGS *ctrlParms = reinterpret_cast < CTRL_STRINGS * >(parm);
|
109 r.kieninger 1.13
|
110 venkat.puvvada 1.48 switch (code)
|
111 r.kieninger 1.14 {
|
112 venkat.puvvada 1.48 case GET_PROVIDER:
113 {
|
114 ms.aruran 1.49 PEG_TRACE_CSTRING(
115 TRC_PROVIDERMANAGER,
|
116 marek 1.55 Tracer::LEVEL3,
|
117 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:GET_PROVIDER()");
|
118 r.kieninger 1.14
|
119 kumpf 1.58 String providerName = *(ctrlParms->providerName);
120 String moduleFileName = *(ctrlParms->fileName);
121 String location = *(ctrlParms->location);
|
122 r.kieninger 1.14
|
123 venkat.puvvada 1.48 CMPIProvider *pr = 0;
|
124 venkat.puvvada 1.56 OpProviderHolder * ph =
125 reinterpret_cast < OpProviderHolder * >(ret);
|
126 r.kieninger 1.14
|
127 venkat.puvvada 1.48 pr = _lookupProvider (providerName);
|
128 r.kieninger 1.14
|
129 venkat.puvvada 1.48 if (pr->getStatus () != CMPIProvider::INITIALIZED)
130 {
131 pr->setLocation (location);
132 _initProvider (pr, moduleFileName);
|
133 r.kieninger 1.14
|
134 venkat.puvvada 1.48 if (pr->getStatus () != CMPIProvider::INITIALIZED)
135 {
|
136 dave.sudlik 1.50 MessageLoaderParms parms(
137 "ProviderManager.CMPI.CMPILocalProviderManager."
138 "CANNOT_INIT_PROVIDER",
139 "Failed to initialize the provider $0.",
140 pr->getName());
|
141 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
|
142 dave.sudlik 1.50 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
|
143 venkat.puvvada 1.48 }
144 }
|
145 r.kieninger 1.15
|
146 r.kieninger 1.13
|
147 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
148 "Returning Provider %s",
149 (const char*)providerName.getCString()));
|
150 r.kieninger 1.13
151
|
152 venkat.puvvada 1.48 ph->SetProvider (pr);
153 ph->GetProvider ().update_idle_timer ();
154 break;
155 }
|
156 schuur 1.1
|
157 venkat.puvvada 1.48 case UNLOAD_PROVIDER:
158 {
|
159 r.kieninger 1.15
|
160 ms.aruran 1.49 PEG_TRACE_CSTRING(
161 TRC_PROVIDERMANAGER,
|
162 marek 1.55 Tracer::LEVEL3,
|
163 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:\
164 UNLOAD_PROVIDER");
|
165 venkat.puvvada 1.48 CMPIProvider *pr = 0;
|
166 kumpf 1.58 pr = _lookupProvider (*(ctrlParms->providerName));
|
167 venkat.puvvada 1.57
|
168 kumpf 1.62 // The provider table must be locked before unloading.
|
169 venkat.puvvada 1.57 AutoMutex lock (_providerTableMutex);
|
170 venkat.puvvada 1.48 if ((pr->getStatus () == CMPIProvider::INITIALIZED))
171 {
|
172 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
173 "Unloading CMPIProvider: %s",
174 (const char*)pr->getName().getCString()));
|
175 venkat.puvvada 1.57 _unloadProvider(pr);
176 }
177 if (pr->getStatus () == CMPIProvider::UNINITIALIZED)
178 {
|
179 venkat.puvvada 1.56 _providers.remove (pr->getNameWithType());
|
180 venkat.puvvada 1.48 delete pr;
181 }
182 else
183 {
|
184 venkat.puvvada 1.57 // Provider could not be unloaded due to pending operations.
185 ccode = -1;
|
186 venkat.puvvada 1.48 }
187 break;
188 }
|
189 r.kieninger 1.14
|
190 venkat.puvvada 1.48 case LOOKUP_PROVIDER:
191 {
|
192 schuur 1.1
|
193 ms.aruran 1.49 PEG_TRACE_CSTRING(
194 TRC_PROVIDERMANAGER,
|
195 marek 1.55 Tracer::LEVEL3,
|
196 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:\
197 LOOKUP_PROVIDER");
|
198 konrad.r 1.24
|
199 venkat.puvvada 1.48 AutoMutex lock (_providerTableMutex);
|
200 schuur 1.1
|
201 kumpf 1.58 if (true == _providers.lookup (*(ctrlParms->providerName),
|
202 venkat.puvvada 1.48 *(reinterpret_cast <
203 CMPIProvider * *>(ret))))
204 {
|
205 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
206 "Found CMPIProvider in cache: %s",
207 (const char*)ctrlParms->providerName->getCString()));
|
208 schuur 1.1
|
209 venkat.puvvada 1.48 (*(reinterpret_cast < CMPIProvider * *>(ret)))->
210 update_idle_timer ();
211 }
212 else
213 {
|
214 konrad.r 1.24
|
215 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
216 "Could not find CMPIProvider in cache: %s",
217 (const char*)ctrlParms->providerName->getCString()));
|
218 venkat.puvvada 1.48 ccode = -1;
219 }
|
220 konrad.r 1.24
|
221 venkat.puvvada 1.48 break;
222 }
|
223 dj.gorey 1.6
|
224 venkat.puvvada 1.48 case LOOKUP_MODULE:
225 {
|
226 schuur 1.1
|
227 thilo.boehm 1.59 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER,Tracer::LEVEL3,
|
228 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:LOOKUP_MODULE");
|
229 schuur 1.1
|
230 venkat.puvvada 1.48 AutoMutex lock (_providerTableMutex);
|
231 schuur 1.1
|
232 kumpf 1.58 if (false == _modules.lookup (*(ctrlParms->fileName),
|
233 venkat.puvvada 1.48 *(reinterpret_cast <
234 CMPIProviderModule * *>(ret))))
235 {
|
236 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,
237 "Could not find CMPIProvider Module in cache: %s",
238 (const char*)ctrlParms->fileName->getCString()));
|
239 venkat.puvvada 1.48 ccode = -1;
240 }
|
241 schuur 1.1
|
242 venkat.puvvada 1.48 break;
243 }
|
244 schuur 1.1
|
245 venkat.puvvada 1.48 case INSERT_PROVIDER:
246 {
|
247 schuur 1.1
|
248 ms.aruran 1.49 PEG_TRACE_CSTRING(
249 TRC_PROVIDERMANAGER,
|
250 marek 1.55 Tracer::LEVEL3,
|
251 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:\
252 INSERT_PROVIDER");
|
253 r.kieninger 1.14
|
254 venkat.puvvada 1.48 AutoMutex lock (_providerTableMutex);
|
255 schuur 1.1
|
256 kumpf 1.58 if (false == _providers.insert (*(ctrlParms->providerName),
|
257 venkat.puvvada 1.48 *reinterpret_cast <
258 CMPIProvider * *>(parm)))
259 ccode = -1;
260 break;
261 }
262 case INSERT_MODULE:
263 {
|
264 ms.aruran 1.49 PEG_TRACE_CSTRING(
265 TRC_PROVIDERMANAGER,
|
266 marek 1.55 Tracer::LEVEL3,
|
267 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:INSERT_MODULE");
|
268 venkat.puvvada 1.48 AutoMutex lock (_providerTableMutex);
|
269 kumpf 1.58 if (false == _modules.insert (*(ctrlParms->fileName),
|
270 venkat.puvvada 1.48 *reinterpret_cast <
271 CMPIProviderModule * *>(parm)))
272 ccode = -1;
273 break;
274 }
|
275 dj.gorey 1.6
|
276 venkat.puvvada 1.48 case UNLOAD_ALL_PROVIDERS:
|
277 konrad.r 1.24 {
|
278 ms.aruran 1.49 PEG_TRACE_CSTRING(
279 TRC_PROVIDERMANAGER,
|
280 marek 1.55 Tracer::LEVEL3,
|
281 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl: \
282 UNLOAD_ALL_PROVIDERS");
|
283 venkat.puvvada 1.48 CMPILocalProviderManager *myself =
284 reinterpret_cast < CMPILocalProviderManager * >(parm);
285 CMPIProvider *provider = 0;
286 // Locked provider mutex.
287 AutoMutex lock (_providerTableMutex);
|
288 venkat.puvvada 1.57 Array<CMPIProvider*> unloadPendingProviders;
|
289 venkat.puvvada 1.48
|
290 ms.aruran 1.49 PEG_TRACE((
291 TRC_PROVIDERMANAGER,
|
292 marek 1.55 Tracer::LEVEL3,
|
293 venkat.puvvada 1.48 "providers in cache = %d", myself->_providers.size ()));
294 ProviderTable::Iterator i = myself->_providers.start ();
295 try
296 {
297 for (; i != 0; i++)
298 {
|
299 r.kieninger 1.15
|
300 venkat.puvvada 1.48 provider = i.value ();
301 PEGASUS_ASSERT (provider != 0);
|
302 kumpf 1.62 if (provider->getStatus () ==
|
303 venkat.puvvada 1.48 CMPIProvider::UNINITIALIZED)
304 {
305 // Delete the skeleton.
306 delete provider;
307 continue;
308 }
309 else
310 {
311 _unloadProvider (provider);
|
312 venkat.puvvada 1.57 if (provider->getStatus () ==
313 CMPIProvider::UNINITIALIZED)
314 {
315 delete provider;
316 }
317 else
318 {
319 unloadPendingProviders.append(provider);
320 }
|
321 venkat.puvvada 1.48 }
322 }
|
323 venkat.puvvada 1.57
324 if (unloadPendingProviders.size())
325 {
326 _terminateUnloadPendingProviders(
327 unloadPendingProviders);
328 }
|
329 venkat.puvvada 1.48 // All the providers are removed. Clear the hash-table
330 _providers.clear ();
|
331 konrad.r 1.24 }
|
332 venkat.puvvada 1.48 catch (...)
|
333 konrad.r 1.24 {
|
334 ms.aruran 1.49 PEG_TRACE_CSTRING(
335 TRC_PROVIDERMANAGER,
336 Tracer::LEVEL2,
|
337 venkat.puvvada 1.48 "Unexpected Exception in UNLOAD_ALL_PROVIDERS.");
|
338 konrad.r 1.24 }
|
339 venkat.puvvada 1.48 break;
|
340 konrad.r 1.24 }
|
341 venkat.puvvada 1.48 case UNLOAD_IDLE_PROVIDERS:
|
342 r.kieninger 1.14 {
|
343 ms.aruran 1.49 PEG_TRACE_CSTRING(
344 TRC_PROVIDERMANAGER,
|
345 marek 1.55 Tracer::LEVEL3,
|
346 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl: \
347 UNLOAD_IDLE_PROVIDERS");
|
348 venkat.puvvada 1.48 AutoMutex lock (_providerTableMutex);
349
350 quantum++;
351 CMPILocalProviderManager *myself =
352 reinterpret_cast < CMPILocalProviderManager * >(parm);
353 Uint32 numProviders = myself->_providers.size ();
|
354 konrad.r 1.24
|
355 venkat.puvvada 1.48 if (numProviders)
|
356 r.kieninger 1.14 {
|
357 venkat.puvvada 1.48 // Rather than removing the provider immediately while
358 // iterating through the list we remember all candidates
359 // for unload in a simple array.
360 CMPIProvider **unloadProviderArray =
361 new CMPIProvider *[numProviders];
362 Uint32 upaIndex = 0;
|
363 konrad.r 1.24
|
364 venkat.puvvada 1.48 try
|
365 r.kieninger 1.14 {
|
366 venkat.puvvada 1.48 struct timeval now;
367 Time::gettimeofday (&now);
368 ProviderTable::Iterator i = myself->_providers.start();
|
369 konrad.r 1.24
|
370 venkat.puvvada 1.48 for (; i != 0; i++)
371 {
|
372 kumpf 1.58 CMPIProvider* provider = i.value();
|
373 venkat.puvvada 1.48 PEGASUS_ASSERT (provider != 0);
|
374 r.kieninger 1.15
|
375 kumpf 1.62 if (provider->getStatus () ==
|
376 venkat.puvvada 1.48 CMPIProvider::UNINITIALIZED)
377 {
378 continue;
379 }
380
|
381 venkat.puvvada 1.56 if (provider->getQuantum() == quantum)
|
382 venkat.puvvada 1.48 {
383 continue;
384 }
385
|
386 venkat.puvvada 1.56 provider->setQuantum(quantum);
|
387 venkat.puvvada 1.48
|
388 venkat.puvvada 1.56 if (provider->getCurrentOperations())
|
389 venkat.puvvada 1.48 {
|
390 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
391 "CMPIProvider has pending operations: %s",
392 (const char*)
393 provider->getName().getCString()));
|
394 konrad.r 1.24
|
395 venkat.puvvada 1.48 continue;
396 }
|
397 r.kieninger 1.14
|
398 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
399 "Checking timeout data for CMPIProvider: %s",
400 (const char*)provider->getName().getCString()));
|
401 venkat.puvvada 1.48 struct timeval timeout = { 0, 0};
402 provider->get_idle_timer (&timeout);
403
|
404 ms.aruran 1.49 PEG_TRACE_CSTRING(
405 TRC_PROVIDERMANAGER,
|
406 venkat.puvvada 1.48 Tracer::LEVEL4,
|
407 kumpf 1.62 provider->unload_ok ()?
408 " provider->unload_ok() returns: true" :
|
409 venkat.puvvada 1.48 " provider->unload_ok() returns: false");
410
411 if (provider->unload_ok () == true &&
412 (now.tv_sec - timeout.tv_sec) >
413 ((Sint32) myself->_idle_timeout))
414 {
415 // Remember this provider to be unloaded
416 unloadProviderArray[upaIndex] = provider;
417 upaIndex++;
418 }
|
419 kumpf 1.62 //else cout<<"--- NOT unloaded: "+
|
420 venkat.puvvada 1.48 // provider->getName()<<endl;
421 }
|
422 r.kieninger 1.14
|
423 kumpf 1.62 // Now finally we unload all providers that we
|
424 venkat.puvvada 1.48 // identified as candidates above.
425 for (Uint32 index = 0; index < upaIndex; index++)
426 {
|
427 kumpf 1.62 CMPIProvider *provider =
|
428 venkat.puvvada 1.48 unloadProviderArray[index];
|
429 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
430 "Now trying to unload CMPIProvider %s",
431 (const char*)provider->getName().getCString()));
|
432 venkat.puvvada 1.48 {
433 // lock the provider mutex
434
|
435 venkat.puvvada 1.56 AutoMutex pr_lock (provider->getStatusMutex());
|
436 venkat.puvvada 1.48
437 if (provider->tryTerminate () == false)
438 {
|
439 kumpf 1.62 // provider not unloaded -- we are
|
440 venkat.puvvada 1.48 // respecting this!
|
441 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,
|
442 venkat.puvvada 1.48 Tracer::LEVEL4,
|
443 thilo.boehm 1.59 "Provider refused to unload: %s",
444 (const char*)
445 unloadProviderArray[index]
446 ->getName().getCString()));
|
447 venkat.puvvada 1.48 continue;
448 }
449
|
450 venkat.puvvada 1.56 PEGASUS_ASSERT (provider->getModule() != 0);
|
451 venkat.puvvada 1.48
452 // unload provider module
|
453 venkat.puvvada 1.56 provider->getModule()->unloadModule ();
|
454 marek 1.54 PEG_TRACE((
455 TRC_PROVIDERMANAGER,
456 Tracer::LEVEL3,
|
457 venkat.puvvada 1.48 "CMPILocalProviderManager::_provider_crtl"
|
458 marek 1.54 " - Unload provider %s",
459 (const char*)
460 provider->getName().getCString()));
|
461 konrad.r 1.24
|
462 kumpf 1.62 // Note: The deleting of the cimom handle is
463 // being moved after the call to
464 // unloadModule() based on a previous fix for
465 // bug 3669 and consistency with other
466 // provider managers. Do not move it back
|
467 venkat.puvvada 1.48 // before the call to unloadModule().
|
468 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
469 "Destroying CMPIProvider's CIMOM Handle %s",
470 (const char*)
471 provider->getName().getCString()));
472
|
473 venkat.puvvada 1.56 delete provider->getCIMOMHandle();
|
474 venkat.puvvada 1.48
475 // set provider status to UNINITIALIZED
476 provider->reset ();
477 }
478 }
479 }
480 catch (...)
|
481 konrad.r 1.24 {
|
482 ms.aruran 1.49 PEG_TRACE_CSTRING(
483 TRC_PROVIDERMANAGER,
|
484 marek 1.55 Tracer::LEVEL1,
|
485 venkat.puvvada 1.48 "Unexpected Exception in UNLOAD_IDLE_PROVIDERS.");
|
486 r.kieninger 1.14 }
|
487 venkat.puvvada 1.48 delete [] unloadProviderArray;
488 } // if there are any providers
489 break;
490 }
|
491 konrad.r 1.24
|
492 venkat.puvvada 1.48 default:
493 ccode = -1;
494 break;
495 }
496 PEG_METHOD_EXIT ();
497 return(ccode);
498 }
|
499 dave.sudlik 1.39
|
500 konrad.r 1.24
|
501 dave.sudlik 1.39
|
502 venkat.puvvada 1.48 /*
|
503 kumpf 1.62 * The reaper function polls out the threads from the global list
504 * (_finishedThreadList), joins them deletes them, and removes them from the
|
505 venkat.puvvada 1.48 * CMPIProvider specific list.
506 */
507 ThreadReturnType PEGASUS_THREAD_CDECL CMPILocalProviderManager::_reaper(
508 void *parm)
509 {
|
510 ms.aruran 1.49 PEG_METHOD_ENTER(
511 TRC_PROVIDERMANAGER,
512 "CMPILocalProviderManager::_reaper()");
|
513 venkat.puvvada 1.48 Thread *myself = reinterpret_cast<Thread *>(parm);
514 do
515 {
516 _pollingSem.wait();
517 // All of the threads are finished working. We just need to reap 'em
518 cleanupThreadRecord *rec = 0;
|
519 dave.sudlik 1.39
|
520 venkat.puvvada 1.48 while (_finishedThreadList.size() >0)
521 {
522 // Pull of the the threads from the global list.
523 rec = _finishedThreadList.remove_front();
|
524 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
525 "-- Reaping the thread from %s",
526 (const char*)rec->provider->getName().getCString()));
|
527 ms.aruran 1.49
|
528 venkat.puvvada 1.48 rec->thread->join();
529
530 // Remove the thread for the CMPIProvider.
531 rec->provider->threadDelete(rec->thread);
532
533 // Delete the thread.
534 delete rec->thread;
535 delete rec;
536 }
|
537 r.kieninger 1.14 }
|
538 venkat.puvvada 1.48 while (_stopPolling.get() == 0);
|
539 kumpf 1.52
|
540 ms.aruran 1.49 PEG_METHOD_EXIT();
|
541 kumpf 1.52 return ThreadReturnType(0);
|
542 schuur 1.1 }
|
543 venkat.puvvada 1.53
544 Boolean CMPILocalProviderManager::isProviderActive(const String &providerName)
545 {
546 PEG_METHOD_ENTER(
547 TRC_PROVIDERMANAGER,
548 "CMPILocalProviderManager::isProviderActive()");
549
550 AutoMutex mtx(_providerTableMutex);
551 String lProviderName("L");
552 lProviderName.append(providerName);
553 String rProviderName("R");
554 rProviderName.append(providerName);
555
556 Boolean active = _providers.contains(lProviderName) ||
557 _providers.contains(rProviderName);
558
559 PEG_METHOD_EXIT();
560
561 return active;
562 }
563
|
564 konrad.r 1.30 /*
|
565 kumpf 1.62 // Cleanup the thread and upon deletion of it, call the CMPIProvider'
|
566 venkat.puvvada 1.48 // "threadDeleted". to not, all the CMPIProvider '
567 // Note that this function is called from the thread that finished with
|
568 kumpf 1.62 // running the providers function, and returns immediately while scheduling
569 // the a cleanup procedure. If you want to wait until the thread is truly
|
570 venkat.puvvada 1.48 // deleted, call 'waitUntilThreadsDone' - but DO NOT do it in the the thread
571 // that the Thread owns - you will wait forever.
572 //
573 // @argument t Thread that is not NULL and finished with running the provider
574 // function.
575 // @argument p CMPIProvider in which the 't' Thread was running.
|
576 konrad.r 1.30 */
|
577 venkat.puvvada 1.48 void CMPILocalProviderManager::cleanupThread(Thread *t, CMPIProvider *p)
|
578 konrad.r 1.30 {
|
579 ms.aruran 1.49 PEG_METHOD_ENTER(
580 TRC_PROVIDERMANAGER,
581 "CMPILocalProviderManager::cleanupThread()");
582
|
583 venkat.puvvada 1.48 PEGASUS_ASSERT( t != 0 && p != 0 );
584
585 PEGASUS_ASSERT ( p->isThreadOwner(t) );
586 // The mutex guards against a race condition for _reaperThread creation.
587 AutoMutex lock(_reaperMutex);
|
588 konrad.r 1.30
589 // Put the Thread and the CMPIProvider on the global list.
|
590 venkat.puvvada 1.48 cleanupThreadRecord *record = new cleanupThreadRecord(t, p);
591 _finishedThreadList.insert_back(record);
|
592 konrad.r 1.30
|
593 venkat.puvvada 1.48 if (_reaperThread == 0)
|
594 konrad.r 1.30 {
|
595 venkat.puvvada 1.48 _reaperThread = new Thread(_reaper, NULL, false);
596 ThreadStatus rtn = PEGASUS_THREAD_OK;
597 while ((rtn = _reaperThread->run()) != PEGASUS_THREAD_OK)
598 {
599 if (rtn == PEGASUS_THREAD_INSUFFICIENT_RESOURCES)
600 Threads::yield();
601 else
602 {
|
603 ms.aruran 1.49 PEG_TRACE_CSTRING(
604 TRC_PROVIDERMANAGER,
|
605 marek 1.55 Tracer::LEVEL1,
|
606 venkat.puvvada 1.48 "Could not allocate thread to take care of deleting "
607 "user threads. ");
608 delete _reaperThread; _reaperThread = 0;
|
609 ms.aruran 1.49 PEG_METHOD_EXIT();
|
610 venkat.puvvada 1.48 return;
|
611 kumpf 1.62 }
|
612 venkat.puvvada 1.48 }
|
613 marek 1.46 }
|
614 venkat.puvvada 1.48 // Wake up the reaper.
615 _pollingSem.signal();
|
616 ms.aruran 1.49 PEG_METHOD_EXIT();
|
617 konrad.r 1.30
618 }
619
|
620 venkat.puvvada 1.56 OpProviderHolder CMPILocalProviderManager::
|
621 venkat.puvvada 1.48 getRemoteProvider (const String & location, const String & providerName)
|
622 konrad.r 1.24 {
|
623 venkat.puvvada 1.56 OpProviderHolder ph;
|
624 venkat.puvvada 1.48 CTRL_STRINGS
625 strings;
626 Sint32
627 ccode;
628 const String
629 proxy ("CMPIRProxyProvider");
630
631 String
632 rproviderName ("R");
|
633 ms.aruran 1.49 PEG_METHOD_ENTER(
634 TRC_PROVIDERMANAGER,
635 "ProvidertManager::getRemoteProvider()");
|
636 venkat.puvvada 1.48
637 rproviderName.append (providerName);
638
639 strings.fileName = &proxy;
640 strings.providerName = &rproviderName;
641 strings.location = &location;
642
643 try
644 {
645 ccode = _provider_ctrl (GET_PROVIDER, &strings, &ph);
646 }
647 catch (const Exception & e)
648 {
|
649 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
650 "--- Exception loading proxy: %s",
651 (const char*)e.getMessage().getCString()));
|
652 ms.aruran 1.49
|
653 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
654 throw;
655 }
656 catch (...)
657 {
|
658 ms.aruran 1.49 PEG_TRACE_CSTRING(
659 TRC_PROVIDERMANAGER,
|
660 marek 1.55 Tracer::LEVEL1,
|
661 ms.aruran 1.49 "--- Unexpected exception in loading proxy provider: ---");
|
662 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
663 throw;
664 }
665
|
666 konrad.r 1.24 PEG_METHOD_EXIT ();
|
667 venkat.puvvada 1.48 return ph;
|
668 schuur 1.1 }
669
|
670 venkat.puvvada 1.56 OpProviderHolder CMPILocalProviderManager::
|
671 venkat.puvvada 1.48 getProvider (const String & fileName, const String & providerName)
|
672 r.kieninger 1.14 {
|
673 venkat.puvvada 1.56 OpProviderHolder ph;
|
674 ms.aruran 1.49 CTRL_STRINGS strings;
675 Sint32 ccode;
676
677 String lproviderName ("L");
678
679 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider()");
|
680 venkat.puvvada 1.48
681 if (fileName.size() == 0)
682 {
|
683 thilo.boehm 1.36 throw Exception(MessageLoaderParms(
|
684 venkat.puvvada 1.48 "ProviderManager.CMPI.CMPILocalProviderManager.CANNOT_FIND_LIBRARY",
685 "For provider $0 the library name was empty. Check provider "
686 "registered location.",
687 providerName));
688
689 }
690 lproviderName.append (providerName);
691 strings.fileName = &fileName;
692 strings.providerName = &lproviderName;
693 strings.location = &String::EMPTY;
694
695 try
696 {
697 ccode = _provider_ctrl (GET_PROVIDER, &strings, &ph);
698 }
699 catch (const Exception & e)
700 {
|
701 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
702 "--- Exception loading local provider: %s",
703 (const char*)e.getMessage().getCString()));
|
704 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
705 throw;
706 }
707 catch (...)
708 {
|
709 ms.aruran 1.49 PEG_TRACE_CSTRING(
710 TRC_PROVIDERMANAGER,
|
711 marek 1.55 Tracer::LEVEL1,
|
712 ms.aruran 1.49 "--- Unexpected exception in loading local provider ---");
|
713 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
714 throw;
715 }
|
716 schuur 1.1
717
|
718 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
719 return(ph);
|
720 schuur 1.1
721 }
722
|
723 venkat.puvvada 1.57 Boolean CMPILocalProviderManager::unloadProvider(
|
724 ms.aruran 1.49 const String & fileName,
|
725 venkat.puvvada 1.48 const String & providerName)
|
726 r.kieninger 1.14 {
|
727 venkat.puvvada 1.48 CTRL_STRINGS strings;
|
728 ms.aruran 1.49 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider()");
|
729 venkat.puvvada 1.48
730 String lproviderName ("L");
731 String rproviderName ("R");
732 lproviderName.append (providerName);
733 rproviderName.append (providerName);
|
734 konrad.r 1.25
|
735 venkat.puvvada 1.48 strings.fileName = &fileName;
736 strings.providerName = &lproviderName;
737 strings.location = &String::EMPTY;
|
738 venkat.puvvada 1.57
739 int lproviderStatus = 0;
740 int rproviderStatus = 0;
741 lproviderStatus = _provider_ctrl (UNLOAD_PROVIDER, &strings, (void *) 0);
|
742 konrad.r 1.25
|
743 venkat.puvvada 1.48 strings.providerName = &rproviderName;
|
744 konrad.r 1.25
|
745 venkat.puvvada 1.57 rproviderStatus = _provider_ctrl (UNLOAD_PROVIDER, &strings, (void *) 0);
|
746 venkat.puvvada 1.48
747 PEG_METHOD_EXIT ();
|
748 venkat.puvvada 1.57 return lproviderStatus != -1 && rproviderStatus != -1;
|
749 r.kieninger 1.14 }
750
|
751 venkat.puvvada 1.48 void CMPILocalProviderManager::shutdownAllProviders ()
|
752 r.kieninger 1.14 {
|
753 venkat.puvvada 1.48 _provider_ctrl (UNLOAD_ALL_PROVIDERS, (void *) this, (void *) 0);
|
754 r.kieninger 1.13 }
755
756
|
757 venkat.puvvada 1.48 Boolean CMPILocalProviderManager::hasActiveProviders ()
|
758 r.kieninger 1.14 {
|
759 ms.aruran 1.49 PEG_METHOD_ENTER(
760 TRC_PROVIDERMANAGER,
761 "ProviderManager::hasActiveProviders()");
|
762 r.kieninger 1.14
|
763 venkat.puvvada 1.48 try
764 {
765 AutoMutex lock (_providerTableMutex);
|
766 ms.aruran 1.49 PEG_TRACE((
767 TRC_PROVIDERMANAGER,
768 Tracer::LEVEL4,
|
769 venkat.puvvada 1.48 "providers in _providers table = %d", _providers.size ()));
770
771 // Iterate through the _providers table looking for an active provider
772 for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
773 {
774 if (i.value ()->getStatus () == CMPIProvider::INITIALIZED)
775 {
776 PEG_METHOD_EXIT ();
777 return true;
778 }
779 }
780 }
781 catch (...)
782 {
783 // Unexpected exception; do not assume that no providers are loaded
|
784 ms.aruran 1.49 PEG_TRACE_CSTRING(
785 TRC_PROVIDERMANAGER,
|
786 marek 1.55 Tracer::LEVEL1,
|
787 venkat.puvvada 1.48 "Unexpected Exception in hasActiveProviders.");
788 PEG_METHOD_EXIT ();
789 return true;
790 }
|
791 r.kieninger 1.14
|
792 venkat.puvvada 1.48 // No active providers were found in the _providers table
793 PEG_METHOD_EXIT ();
794 return false;
|
795 r.kieninger 1.14 }
796
|
797 venkat.puvvada 1.48 void CMPILocalProviderManager::unloadIdleProviders ()
|
798 r.kieninger 1.14 {
|
799 ms.aruran 1.49 PEG_METHOD_ENTER(
800 TRC_PROVIDERMANAGER,
801 "ProviderManager::unloadIdleProviders()");
|
802 r.kieninger 1.14
|
803 kumpf 1.41 try
|
804 r.kieninger 1.14 {
|
805 kumpf 1.41 _provider_ctrl (UNLOAD_IDLE_PROVIDERS, this, (void *) 0);
|
806 r.kieninger 1.14 }
|
807 kumpf 1.41 catch (...)
|
808 r.kieninger 1.14 {
|
809 ms.aruran 1.49 PEG_TRACE_CSTRING(
810 TRC_PROVIDERMANAGER,
811 Tracer::LEVEL2,
|
812 kumpf 1.41 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
|
813 r.kieninger 1.14 }
|
814 kumpf 1.41
815 PEG_METHOD_EXIT ();
|
816 schuur 1.1 }
817
|
818 venkat.puvvada 1.48 Array <CMPIProvider *>CMPILocalProviderManager::
819 getIndicationProvidersToEnable()
|
820 carolann.graves 1.17 {
|
821 ms.aruran 1.49 PEG_METHOD_ENTER(
822 TRC_PROVIDERMANAGER,
823 "CMPILocalProviderManager::getIndicationProvidersToEnable()");
|
824 carolann.graves 1.17
|
825 venkat.puvvada 1.48 Array < CMPIProvider * >enableProviders;
826
|
827 ms.aruran 1.49 PEG_TRACE((
828 TRC_PROVIDERMANAGER,
829 Tracer::LEVEL4,
|
830 venkat.puvvada 1.48 "Number of providers in _providers table = %d",
831 _providers.size ()));
|
832 carolann.graves 1.17
|
833 venkat.puvvada 1.48 try
834 {
835 AutoMutex
836 lock (_providerTableMutex);
|
837 carolann.graves 1.17
838 //
|
839 venkat.puvvada 1.48 // Iterate through the _providers table
|
840 carolann.graves 1.17 //
|
841 venkat.puvvada 1.48 for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
842 {
843 //
844 // Enable any indication provider with current subscriptions
845 //
846 CMPIProvider *
847 provider = i.value ();
848 if (provider->testSubscriptions ())
849 {
850 enableProviders.append (provider);
851 }
852 }
853
854 }
855 catch (const CIMException & e)
856 {
|
857 thilo.boehm 1.59 PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL1,
858 "CIMException in getIndicationProvidersToEnable: %s",
859 (const char*)e.getMessage().getCString()));
|
860 venkat.puvvada 1.48 }
861 catch (const Exception & e)
862 {
|
863 thilo.boehm 1.59 PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL1,
864 "Exception in getIndicationProvidersToEnable: %s",
865 (const char*)e.getMessage().getCString()));
|
866 venkat.puvvada 1.48 }
867 catch (...)
868 {
|
869 ms.aruran 1.49 PEG_TRACE_CSTRING(
870 TRC_DISCARDED_DATA,
|
871 marek 1.55 Tracer::LEVEL1,
|
872 venkat.puvvada 1.48 "Unexpected error in getIndicationProvidersToEnable");
873 }
|
874 carolann.graves 1.17
|
875 ms.aruran 1.49 PEG_TRACE((
876 TRC_PROVIDERMANAGER,
877 Tracer::LEVEL4,
|
878 venkat.puvvada 1.48 "Number of indication providers to enable = %d",
879 enableProviders.size ()));
|
880 carolann.graves 1.17
|
881 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
882 return enableProviders;
883 }
|
884 carolann.graves 1.17
|
885 venkat.puvvada 1.48 CMPIProvider *CMPILocalProviderManager::_initProvider(
886 CMPIProvider * provider,
887 const String & moduleFileName)
888 {
|
889 ms.aruran 1.49 PEG_METHOD_ENTER(
890 TRC_PROVIDERMANAGER,
891 "CMPILocalProviderManager::_initProvider()");
|
892 r.kieninger 1.14
|
893 venkat.puvvada 1.48 CMPIProviderModule *module = 0;
894 ProviderVector base;
|
895 kumpf 1.18
|
896 konrad.r 1.24 {
|
897 venkat.puvvada 1.48 // lock the providerTable mutex
898 AutoMutex lock (_providerTableMutex);
899
900 // lookup provider module
901 module = _lookupModule (moduleFileName);
902 } // unlock the providerTable mutex
903
904 Boolean moduleLoaded = false;
905 Boolean deleteProvider = false;
906 String exceptionMsg = moduleFileName;
|
907 konrad.r 1.26 {
|
908 venkat.puvvada 1.48 // lock the provider status mutex
|
909 venkat.puvvada 1.56 AutoMutex lock (provider->getStatusMutex());
|
910 venkat.puvvada 1.48
|
911 venkat.puvvada 1.56 if (provider->getStatus() == CMPIProvider::INITIALIZED)
|
912 venkat.puvvada 1.48 {
|
913 ms.aruran 1.49 PEG_METHOD_EXIT();
|
914 venkat.puvvada 1.48 // Initialization is already complete
915 return provider;
916 }
917
|
918 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
919 "Loading/Linking Provider Module %s",
920 (const char*)moduleFileName.getCString()));
|
921 venkat.puvvada 1.48
922 // load the provider
923 try
924 {
|
925 venkat.puvvada 1.56 base = module->load (provider->getNameWithType());
|
926 venkat.puvvada 1.48 moduleLoaded = true;
927 }
928 catch (const Exception &e)
929 {
930 exceptionMsg = e.getMessage();
|
931 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
932 "Exception caught Loading/Linking Provider Module %s"
933 " error is: %s",
934 (const char*)moduleFileName.getCString(),
935 (const char*)exceptionMsg.getCString()));
|
936 venkat.puvvada 1.48 deleteProvider =true;
937 }
938 catch (...)
939 {
|
940 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
941 "Unknown exception caught Loading/Linking Provider Module %s",
942 (const char*)moduleFileName.getCString()));
|
943 venkat.puvvada 1.48 exceptionMsg = moduleFileName;
944 deleteProvider = true;
945 }
946
947 if (!deleteProvider)
948 {
949 // initialize the provider
|
950 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
951 "Initializing Provider %s",
952 (const char*)provider->getName().getCString()));
|
953 venkat.puvvada 1.48
954 CIMOMHandle *cimomHandle = new CIMOMHandle ();
955 provider->set (module, base, cimomHandle);
|
956 venkat.puvvada 1.56 provider->setQuantum(0);
|
957 venkat.puvvada 1.48
958 try
959 {
|
960 venkat.puvvada 1.56 provider->initialize (*(provider->getCIMOMHandle()));
|
961 venkat.puvvada 1.48 }
962 catch (const Exception &e)
963 {
|
964 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
965 "Problem initializing %s: %s",
966 (const char*)provider->getName().getCString(),
967 (const char*)e.getMessage().getCString()));
|
968 venkat.puvvada 1.48 deleteProvider = true;
969 exceptionMsg = e.getMessage();
970 }
971 catch (...)
972 {
|
973 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
974 "Unknown problem initializing %s",
975 (const char*)provider->getName().getCString()));
|
976 venkat.puvvada 1.48 deleteProvider = true;
977 exceptionMsg = provider->getName();
978 }
979 } // unlock the provider status mutex
|
980 konrad.r 1.26 }
|
981 venkat.puvvada 1.48 /* We wait until this moment to delete the provider b/c we need
982 be outside the scope for the AutoMutex for the provider. */
983 if (deleteProvider)
984 {
985 // Note: The deleting of the cimom handle is being
986 // moved after the call to unloadModule() based on
987 // a previous fix for bug 3669 and consistency with
988 // other provider managers. Do not move it back before
989 // the call to unloadModule().
990
991 // unload provider module
992 if (moduleLoaded)
993 {
994 module->unloadModule();
995 }
996
997 // delete the cimom handle
|
998 venkat.puvvada 1.56 delete provider->getCIMOMHandle();
|
999 venkat.puvvada 1.48 // set provider status to UNINITIALIZED
1000 provider->reset ();
1001
1002 AutoMutex lock (_providerTableMutex);
|
1003 venkat.puvvada 1.56 _providers.remove (provider->getNameWithType());
|
1004 venkat.puvvada 1.48 delete provider;
|
1005 konrad.r 1.26
|
1006 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1007 throw Exception(exceptionMsg);
|
1008 r.kieninger 1.14 }
1009
|
1010 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1011 return(provider);
|
1012 r.kieninger 1.14 }
1013
|
1014 venkat.puvvada 1.57 /*
|
1015 kumpf 1.62 This method is called when CMPIProviderManager receives
1016 CIMStopAllProvidersRequestMessage and
1017 CMPILocalProviderManager::_provider_ctrl() method could not unload the
|
1018 venkat.puvvada 1.57 provider(s) because of pending requests with the provider. We give grace
|
1019 venkat.puvvada 1.63 time of (90% of shutdownTimeout) seconds to the unload pending providers
|
1020 venkat.puvvada 1.57 to unload gracefully before terminating them forcibly. Note that this
1021 happens only when provider is running out-of-process and communication
1022 with CIMServer falied because of pipe read/write failures.
1023 */
1024 void CMPILocalProviderManager::_terminateUnloadPendingProviders(
1025 Array<CMPIProvider*> &unloadPendingProviders)
1026 {
1027 PEG_METHOD_ENTER(
1028 TRC_PROVIDERMANAGER,
1029 "CMPILocalProviderManager::_terminateUnloadPendingProviders()");
1030
1031 PEG_TRACE((
1032 TRC_PROVIDERMANAGER,
1033 Tracer::LEVEL3,
1034 "Unloading %u unload-pending providers.",
1035 unloadPendingProviders.size()));
1036
1037 String configTimeout =
1038 ConfigManager::getInstance()->getCurrentValue("shutdownTimeout");
1039
1040 Uint32 timeoutValue =
1041 venkat.puvvada 1.57 strtol(configTimeout.getCString(), (char **)0, 10);
|
1042 venkat.puvvada 1.63 // Calculate 90% of timeout value, minimum 1 second.
1043 timeoutValue = (Uint32)((timeoutValue - 1) * 0.9);
1044 timeoutValue++;
|
1045 venkat.puvvada 1.57
|
1046 venkat.puvvada 1.63 struct timeval startTime;
1047 struct timeval timeNow;
1048
1049 Time::gettimeofday(&startTime);
1050
1051 for (;;)
|
1052 venkat.puvvada 1.57 {
1053 Boolean unloadPending = false;
1054 for (Uint32 j = 0, n = unloadPendingProviders.size(); j < n; ++j)
1055 {
|
1056 kumpf 1.62 if (unloadPendingProviders[j]->getStatus() ==
|
1057 venkat.puvvada 1.57 CMPIProvider::INITIALIZED)
1058 {
1059 _unloadProvider(unloadPendingProviders[j]);
1060 if (unloadPendingProviders[j]->getStatus()
1061 == CMPIProvider::INITIALIZED)
1062 {
1063 unloadPending = true;
1064 }
1065 }
1066 }
|
1067 venkat.puvvada 1.63 // Get the current time and check if it exceeds
1068 // or equals to timeoutValue.
1069 Time::gettimeofday(&timeNow);
1070 if (((Uint32)(timeNow.tv_sec - startTime.tv_sec)) >= timeoutValue
1071 || !unloadPending)
|
1072 venkat.puvvada 1.57 {
1073 break;
1074 }
1075 Threads::sleep(1000);
1076 }
1077
1078 for (Uint32 j = 0, n = unloadPendingProviders.size(); j < n; ++j)
1079 {
1080 if (unloadPendingProviders[j]->getStatus() ==
1081 CMPIProvider::INITIALIZED)
1082 {
1083 // Force unload
|
1084 kumpf 1.62 _unloadProvider(unloadPendingProviders[j], true);
|
1085 venkat.puvvada 1.57 }
1086 if (unloadPendingProviders[j]->getStatus() ==
1087 CMPIProvider::UNINITIALIZED)
1088 {
1089 delete unloadPendingProviders[j];
1090 }
1091 }
|
1092 r.kieninger 1.14
|
1093 venkat.puvvada 1.57 PEG_METHOD_EXIT();
1094 }
1095
1096 void CMPILocalProviderManager::_unloadProvider (
1097 CMPIProvider * provider,
1098 Boolean forceUnload)
|
1099 r.kieninger 1.14 {
|
1100 venkat.puvvada 1.48 //
1101 // NOTE: It is the caller's responsibility to make sure that
1102 // the ProviderTable mutex is locked before calling this method.
1103 //
|
1104 thilo.boehm 1.59 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
|
1105 ms.aruran 1.49 "CMPILocalProviderManager::_unloadProvider()");
1106
|
1107 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1108 "Unloading Provider %s",(const char*)provider->getName().getCString()));
|
1109 r.kieninger 1.14
|
1110 venkat.puvvada 1.57 if (provider->getCurrentOperations() && !forceUnload)
|
1111 r.kieninger 1.14 {
|
1112 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1113 "Provider cannot be unloaded due to pending operations: %s",
1114 (const char*)provider->getName().getCString()));
|
1115 r.kieninger 1.14 }
|
1116 venkat.puvvada 1.48 else
|
1117 r.kieninger 1.14 {
|
1118 venkat.puvvada 1.57 if (provider->getCurrentOperations())
|
1119 kumpf 1.62 {
|
1120 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
1121 "Terminating Provider with pending operations %s",
1122 (const char*)provider->getName().getCString()));
|
1123 venkat.puvvada 1.57 }
1124 else
1125 {
|
1126 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1127 "Terminating Provider %s",
1128 (const char*)provider->getName().getCString()));
|
1129 venkat.puvvada 1.57 }
|
1130 r.kieninger 1.14
|
1131 venkat.puvvada 1.48 // lock the provider mutex
|
1132 venkat.puvvada 1.56 AutoMutex pr_lock (provider->getStatusMutex());
|
1133 r.kieninger 1.14
|
1134 venkat.puvvada 1.48 try
1135 {
1136 provider->terminate ();
1137 }
1138 catch (...)
1139 {
|
1140 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
1141 "Error occured terminating CMPI provider %s",
1142 (const char*)provider->getName().getCString()));
|
1143 venkat.puvvada 1.48 }
|
1144 r.kieninger 1.14
|
1145 venkat.puvvada 1.57 if (provider->getStatus() == CMPIProvider::UNINITIALIZED)
1146 {
|
1147 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
1148 "Unload provider module %s for provider %s",
1149 (const char*)
1150 provider->getModule()->getFileName().getCString(),
1151 (const char*)provider->getName().getCString()));
|
1152 venkat.puvvada 1.57 // unload provider module
|
1153 thilo.boehm 1.59 provider->getModule()->unloadModule();
|
1154 r.kieninger 1.14
|
1155 venkat.puvvada 1.57 // delete the cimom handle
|
1156 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1157 "Destroying CMPIProvider's CIMOM Handle %s",
1158 (const char*)provider->getName().getCString()));
|
1159 kumpf 1.62
|
1160 venkat.puvvada 1.57 delete provider->getCIMOMHandle();
1161 PEGASUS_ASSERT (provider->getModule() != 0);
|
1162 r.kieninger 1.14
1163
|
1164 venkat.puvvada 1.57 // set provider status to UNINITIALIZED
1165 provider->reset ();
|
1166 r.kieninger 1.14
|
1167 venkat.puvvada 1.57 // Do not delete the provider. The function calling this function
1168 // takes care of that.
1169 }
|
1170 r.kieninger 1.14 }
|
1171 r.kieninger 1.13
|
1172 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
|
1173 dj.gorey 1.6 }
1174
|
1175 venkat.puvvada 1.48 CMPIProvider * CMPILocalProviderManager::_lookupProvider(
1176 const String & providerName)
|
1177 r.kieninger 1.14 {
|
1178 ms.aruran 1.49 PEG_METHOD_ENTER(
1179 TRC_PROVIDERMANAGER,
1180 "CMPILocalProviderManager::_lookupProvider()");
|
1181 venkat.puvvada 1.48 // lock the providerTable mutex
1182 AutoMutex lock (_providerTableMutex);
1183 // look up provider in cache
1184 CMPIProvider *pr = 0;
1185 if (true == _providers.lookup (providerName, pr))
|
1186 r.kieninger 1.14 {
|
1187 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1188 "Found Provider %s in CMPI Provider Manager Cache",
1189 (const char*)providerName.getCString()));
|
1190 r.kieninger 1.14 }
|
1191 venkat.puvvada 1.48 else
|
1192 r.kieninger 1.14 {
|
1193 venkat.puvvada 1.48 // create provider
1194 pr = new CMPIProvider (providerName, 0, 0);
1195 // insert provider in provider table
1196 _providers.insert (providerName, pr);
|
1197 r.kieninger 1.14
|
1198 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1199 "Created provider %s",(const char*)pr->getName().getCString()));
|
1200 r.kieninger 1.14 }
|
1201 dj.gorey 1.6
|
1202 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1203 return(pr);
|
1204 dj.gorey 1.6 }
1205
1206
|
1207 venkat.puvvada 1.48 CMPIProviderModule * CMPILocalProviderManager::_lookupModule(
1208 const String & moduleFileName)
|
1209 r.kieninger 1.14 {
|
1210 ms.aruran 1.49 PEG_METHOD_ENTER(
1211 TRC_PROVIDERMANAGER,
1212 "CMPILocalProviderManager::_lookupModule()");
|
1213 r.kieninger 1.14
|
1214 venkat.puvvada 1.48 // look up provider module in cache
1215 CMPIProviderModule *module = 0;
|
1216 r.kieninger 1.14
|
1217 venkat.puvvada 1.48 if (true == _modules.lookup (moduleFileName, module))
|
1218 r.kieninger 1.14 {
|
1219 venkat.puvvada 1.48 // found provider module in cache
|
1220 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1221 "Found Provider Module %s in Provider Manager Cache",
1222 (const char*)moduleFileName.getCString()));
|
1223 dj.gorey 1.6
|
1224 konrad.r 1.24 }
|
1225 venkat.puvvada 1.48 else
|
1226 konrad.r 1.24 {
|
1227 venkat.puvvada 1.48 // provider module not found in cache, create provider module
|
1228 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1229 "Creating CMPI Provider Module %s",
1230 (const char*)moduleFileName.getCString()));
|
1231 r.kieninger 1.14
|
1232 venkat.puvvada 1.48 module = new CMPIProviderModule (moduleFileName);
|
1233 r.kieninger 1.14
|
1234 venkat.puvvada 1.48 // insert provider module in module table
1235 _modules.insert (moduleFileName, module);
|
1236 r.kieninger 1.14 }
|
1237 dj.gorey 1.6
|
1238 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1239 return(module);
|
1240 schuur 1.1 }
1241
1242 PEGASUS_NAMESPACE_END
|
1243 kumpf 1.62
|
Return to
CMPILocalProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI