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 venkat.puvvada 1.65 String providerModuleName = *(ctrlParms->providerModuleName);
|
121 kumpf 1.58 String moduleFileName = *(ctrlParms->fileName);
122 String location = *(ctrlParms->location);
|
123 r.kieninger 1.14
|
124 venkat.puvvada 1.48 CMPIProvider *pr = 0;
|
125 venkat.puvvada 1.56 OpProviderHolder * ph =
126 reinterpret_cast < OpProviderHolder * >(ret);
|
127 r.kieninger 1.14
|
128 venkat.puvvada 1.65 pr = _lookupProvider (providerName, providerModuleName);
|
129 r.kieninger 1.14
|
130 venkat.puvvada 1.48 if (pr->getStatus () != CMPIProvider::INITIALIZED)
131 {
132 pr->setLocation (location);
133 _initProvider (pr, moduleFileName);
|
134 r.kieninger 1.14
|
135 venkat.puvvada 1.48 if (pr->getStatus () != CMPIProvider::INITIALIZED)
136 {
|
137 dave.sudlik 1.50 MessageLoaderParms parms(
138 "ProviderManager.CMPI.CMPILocalProviderManager."
139 "CANNOT_INIT_PROVIDER",
140 "Failed to initialize the provider $0.",
141 pr->getName());
|
142 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
|
143 dave.sudlik 1.50 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
|
144 venkat.puvvada 1.48 }
145 }
|
146 r.kieninger 1.15
|
147 r.kieninger 1.13
|
148 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
149 "Returning Provider %s",
150 (const char*)providerName.getCString()));
|
151 r.kieninger 1.13
152
|
153 venkat.puvvada 1.48 ph->SetProvider (pr);
154 ph->GetProvider ().update_idle_timer ();
155 break;
156 }
|
157 schuur 1.1
|
158 venkat.puvvada 1.48 case UNLOAD_PROVIDER:
159 {
|
160 r.kieninger 1.15
|
161 ms.aruran 1.49 PEG_TRACE_CSTRING(
162 TRC_PROVIDERMANAGER,
|
163 marek 1.55 Tracer::LEVEL3,
|
164 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl:\
165 UNLOAD_PROVIDER");
|
166 venkat.puvvada 1.48 CMPIProvider *pr = 0;
|
167 venkat.puvvada 1.65 pr = _lookupProvider (
168 *ctrlParms->providerName,
169 *ctrlParms->providerModuleName);
|
170 venkat.puvvada 1.57
|
171 kumpf 1.62 // The provider table must be locked before unloading.
|
172 venkat.puvvada 1.57 AutoMutex lock (_providerTableMutex);
|
173 venkat.puvvada 1.48 if ((pr->getStatus () == CMPIProvider::INITIALIZED))
174 {
|
175 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
176 "Unloading CMPIProvider: %s",
177 (const char*)pr->getName().getCString()));
|
178 venkat.puvvada 1.57 _unloadProvider(pr);
179 }
180 if (pr->getStatus () == CMPIProvider::UNINITIALIZED)
181 {
|
182 venkat.puvvada 1.65 _removeProvider(pr->getNameWithType(), pr->getModuleName());
|
183 venkat.puvvada 1.48 delete pr;
184 }
185 else
186 {
|
187 venkat.puvvada 1.57 // Provider could not be unloaded due to pending operations.
188 ccode = -1;
|
189 venkat.puvvada 1.48 }
190 break;
191 }
|
192 r.kieninger 1.14
|
193 venkat.puvvada 1.48 case UNLOAD_ALL_PROVIDERS:
|
194 konrad.r 1.24 {
|
195 ms.aruran 1.49 PEG_TRACE_CSTRING(
196 TRC_PROVIDERMANAGER,
|
197 marek 1.55 Tracer::LEVEL3,
|
198 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl: \
199 UNLOAD_ALL_PROVIDERS");
|
200 venkat.puvvada 1.48 CMPILocalProviderManager *myself =
201 reinterpret_cast < CMPILocalProviderManager * >(parm);
202 CMPIProvider *provider = 0;
203 // Locked provider mutex.
204 AutoMutex lock (_providerTableMutex);
|
205 venkat.puvvada 1.57 Array<CMPIProvider*> unloadPendingProviders;
|
206 venkat.puvvada 1.48
|
207 ms.aruran 1.49 PEG_TRACE((
208 TRC_PROVIDERMANAGER,
|
209 marek 1.55 Tracer::LEVEL3,
|
210 venkat.puvvada 1.48 "providers in cache = %d", myself->_providers.size ()));
211 ProviderTable::Iterator i = myself->_providers.start ();
212 try
213 {
214 for (; i != 0; i++)
215 {
|
216 r.kieninger 1.15
|
217 venkat.puvvada 1.48 provider = i.value ();
218 PEGASUS_ASSERT (provider != 0);
|
219 kumpf 1.62 if (provider->getStatus () ==
|
220 venkat.puvvada 1.48 CMPIProvider::UNINITIALIZED)
221 {
222 // Delete the skeleton.
223 delete provider;
224 continue;
225 }
226 else
227 {
|
228 venkat.puvvada 1.64 // Force unload.
229 _unloadProvider (provider, true);
|
230 venkat.puvvada 1.57 if (provider->getStatus () ==
231 CMPIProvider::UNINITIALIZED)
232 {
233 delete provider;
234 }
|
235 venkat.puvvada 1.48 }
236 }
|
237 venkat.puvvada 1.57
|
238 venkat.puvvada 1.48 // All the providers are removed. Clear the hash-table
239 _providers.clear ();
|
240 konrad.r 1.24 }
|
241 venkat.puvvada 1.48 catch (...)
|
242 konrad.r 1.24 {
|
243 ms.aruran 1.49 PEG_TRACE_CSTRING(
244 TRC_PROVIDERMANAGER,
245 Tracer::LEVEL2,
|
246 venkat.puvvada 1.48 "Unexpected Exception in UNLOAD_ALL_PROVIDERS.");
|
247 konrad.r 1.24 }
|
248 venkat.puvvada 1.48 break;
|
249 konrad.r 1.24 }
|
250 venkat.puvvada 1.48 case UNLOAD_IDLE_PROVIDERS:
|
251 r.kieninger 1.14 {
|
252 ms.aruran 1.49 PEG_TRACE_CSTRING(
253 TRC_PROVIDERMANAGER,
|
254 marek 1.55 Tracer::LEVEL3,
|
255 ms.aruran 1.49 "CMPILocalProviderManager::_provider_ctrl: \
256 UNLOAD_IDLE_PROVIDERS");
|
257 venkat.puvvada 1.48 AutoMutex lock (_providerTableMutex);
258
259 quantum++;
260 CMPILocalProviderManager *myself =
261 reinterpret_cast < CMPILocalProviderManager * >(parm);
262 Uint32 numProviders = myself->_providers.size ();
|
263 konrad.r 1.24
|
264 venkat.puvvada 1.48 if (numProviders)
|
265 r.kieninger 1.14 {
|
266 venkat.puvvada 1.48 // Rather than removing the provider immediately while
267 // iterating through the list we remember all candidates
268 // for unload in a simple array.
269 CMPIProvider **unloadProviderArray =
270 new CMPIProvider *[numProviders];
271 Uint32 upaIndex = 0;
|
272 konrad.r 1.24
|
273 venkat.puvvada 1.48 try
|
274 r.kieninger 1.14 {
|
275 venkat.puvvada 1.48 struct timeval now;
276 Time::gettimeofday (&now);
277 ProviderTable::Iterator i = myself->_providers.start();
|
278 konrad.r 1.24
|
279 venkat.puvvada 1.48 for (; i != 0; i++)
280 {
|
281 kumpf 1.58 CMPIProvider* provider = i.value();
|
282 venkat.puvvada 1.48 PEGASUS_ASSERT (provider != 0);
|
283 r.kieninger 1.15
|
284 kumpf 1.62 if (provider->getStatus () ==
|
285 venkat.puvvada 1.48 CMPIProvider::UNINITIALIZED)
286 {
287 continue;
288 }
289
|
290 venkat.puvvada 1.56 if (provider->getQuantum() == quantum)
|
291 venkat.puvvada 1.48 {
292 continue;
293 }
294
|
295 venkat.puvvada 1.56 provider->setQuantum(quantum);
|
296 venkat.puvvada 1.48
|
297 venkat.puvvada 1.56 if (provider->getCurrentOperations())
|
298 venkat.puvvada 1.48 {
|
299 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
300 "CMPIProvider has pending operations: %s",
301 (const char*)
302 provider->getName().getCString()));
|
303 konrad.r 1.24
|
304 venkat.puvvada 1.48 continue;
305 }
|
306 r.kieninger 1.14
|
307 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
308 "Checking timeout data for CMPIProvider: %s",
309 (const char*)provider->getName().getCString()));
|
310 venkat.puvvada 1.48 struct timeval timeout = { 0, 0};
311 provider->get_idle_timer (&timeout);
312
|
313 ms.aruran 1.49 PEG_TRACE_CSTRING(
314 TRC_PROVIDERMANAGER,
|
315 venkat.puvvada 1.48 Tracer::LEVEL4,
|
316 kumpf 1.62 provider->unload_ok ()?
317 " provider->unload_ok() returns: true" :
|
318 venkat.puvvada 1.48 " provider->unload_ok() returns: false");
319
320 if (provider->unload_ok () == true &&
321 (now.tv_sec - timeout.tv_sec) >
322 ((Sint32) myself->_idle_timeout))
323 {
324 // Remember this provider to be unloaded
325 unloadProviderArray[upaIndex] = provider;
326 upaIndex++;
327 }
|
328 kumpf 1.62 //else cout<<"--- NOT unloaded: "+
|
329 venkat.puvvada 1.48 // provider->getName()<<endl;
330 }
|
331 r.kieninger 1.14
|
332 kumpf 1.62 // Now finally we unload all providers that we
|
333 venkat.puvvada 1.48 // identified as candidates above.
334 for (Uint32 index = 0; index < upaIndex; index++)
335 {
|
336 kumpf 1.62 CMPIProvider *provider =
|
337 venkat.puvvada 1.48 unloadProviderArray[index];
|
338 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
339 "Now trying to unload CMPIProvider %s",
340 (const char*)provider->getName().getCString()));
|
341 venkat.puvvada 1.48 {
342 // lock the provider mutex
343
|
344 venkat.puvvada 1.56 AutoMutex pr_lock (provider->getStatusMutex());
|
345 venkat.puvvada 1.48
346 if (provider->tryTerminate () == false)
347 {
|
348 kumpf 1.62 // provider not unloaded -- we are
|
349 venkat.puvvada 1.48 // respecting this!
|
350 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,
|
351 venkat.puvvada 1.48 Tracer::LEVEL4,
|
352 thilo.boehm 1.59 "Provider refused to unload: %s",
353 (const char*)
354 unloadProviderArray[index]
355 ->getName().getCString()));
|
356 venkat.puvvada 1.48 continue;
357 }
358
|
359 venkat.puvvada 1.56 PEGASUS_ASSERT (provider->getModule() != 0);
|
360 venkat.puvvada 1.48
361 // unload provider module
|
362 venkat.puvvada 1.56 provider->getModule()->unloadModule ();
|
363 marek 1.54 PEG_TRACE((
364 TRC_PROVIDERMANAGER,
365 Tracer::LEVEL3,
|
366 venkat.puvvada 1.48 "CMPILocalProviderManager::_provider_crtl"
|
367 marek 1.54 " - Unload provider %s",
368 (const char*)
369 provider->getName().getCString()));
|
370 konrad.r 1.24
|
371 kumpf 1.62 // Note: The deleting of the cimom handle is
372 // being moved after the call to
373 // unloadModule() based on a previous fix for
374 // bug 3669 and consistency with other
375 // provider managers. Do not move it back
|
376 venkat.puvvada 1.48 // before the call to unloadModule().
|
377 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
378 "Destroying CMPIProvider's CIMOM Handle %s",
379 (const char*)
380 provider->getName().getCString()));
381
|
382 venkat.puvvada 1.56 delete provider->getCIMOMHandle();
|
383 venkat.puvvada 1.48
384 // set provider status to UNINITIALIZED
385 provider->reset ();
386 }
387 }
388 }
389 catch (...)
|
390 konrad.r 1.24 {
|
391 ms.aruran 1.49 PEG_TRACE_CSTRING(
392 TRC_PROVIDERMANAGER,
|
393 marek 1.55 Tracer::LEVEL1,
|
394 venkat.puvvada 1.48 "Unexpected Exception in UNLOAD_IDLE_PROVIDERS.");
|
395 r.kieninger 1.14 }
|
396 venkat.puvvada 1.48 delete [] unloadProviderArray;
397 } // if there are any providers
398 break;
399 }
|
400 konrad.r 1.24
|
401 venkat.puvvada 1.48 default:
402 ccode = -1;
403 break;
404 }
405 PEG_METHOD_EXIT ();
406 return(ccode);
407 }
|
408 dave.sudlik 1.39
|
409 konrad.r 1.24
|
410 dave.sudlik 1.39
|
411 venkat.puvvada 1.48 /*
|
412 kumpf 1.62 * The reaper function polls out the threads from the global list
413 * (_finishedThreadList), joins them deletes them, and removes them from the
|
414 venkat.puvvada 1.48 * CMPIProvider specific list.
415 */
416 ThreadReturnType PEGASUS_THREAD_CDECL CMPILocalProviderManager::_reaper(
417 void *parm)
418 {
|
419 ms.aruran 1.49 PEG_METHOD_ENTER(
420 TRC_PROVIDERMANAGER,
421 "CMPILocalProviderManager::_reaper()");
|
422 venkat.puvvada 1.48 Thread *myself = reinterpret_cast<Thread *>(parm);
423 do
424 {
425 _pollingSem.wait();
426 // All of the threads are finished working. We just need to reap 'em
427 cleanupThreadRecord *rec = 0;
|
428 dave.sudlik 1.39
|
429 venkat.puvvada 1.48 while (_finishedThreadList.size() >0)
430 {
431 // Pull of the the threads from the global list.
432 rec = _finishedThreadList.remove_front();
|
433 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
434 "-- Reaping the thread from %s",
435 (const char*)rec->provider->getName().getCString()));
|
436 ms.aruran 1.49
|
437 venkat.puvvada 1.48 rec->thread->join();
438
439 // Remove the thread for the CMPIProvider.
440 rec->provider->threadDelete(rec->thread);
441
442 // Delete the thread.
443 delete rec->thread;
444 delete rec;
445 }
|
446 r.kieninger 1.14 }
|
447 venkat.puvvada 1.48 while (_stopPolling.get() == 0);
|
448 kumpf 1.52
|
449 ms.aruran 1.49 PEG_METHOD_EXIT();
|
450 kumpf 1.52 return ThreadReturnType(0);
|
451 schuur 1.1 }
|
452 venkat.puvvada 1.53
|
453 venkat.puvvada 1.65 Boolean CMPILocalProviderManager::isProviderActive(
454 const String &providerName,
455 const String &providerModuleName)
|
456 venkat.puvvada 1.53 {
457 PEG_METHOD_ENTER(
458 TRC_PROVIDERMANAGER,
459 "CMPILocalProviderManager::isProviderActive()");
460
461 AutoMutex mtx(_providerTableMutex);
462 String lProviderName("L");
463 lProviderName.append(providerName);
464 String rProviderName("R");
465 rProviderName.append(providerName);
466
|
467 venkat.puvvada 1.65 ProviderKey lpKey(lProviderName, providerModuleName);
468 ProviderKey rpKey(rProviderName, providerModuleName);
469 Boolean active = _providers.contains(lpKey) || _providers.contains(rpKey);
|
470 venkat.puvvada 1.53
471 PEG_METHOD_EXIT();
472
473 return active;
474 }
475
|
476 konrad.r 1.30 /*
|
477 kumpf 1.62 // Cleanup the thread and upon deletion of it, call the CMPIProvider'
|
478 venkat.puvvada 1.48 // "threadDeleted". to not, all the CMPIProvider '
479 // Note that this function is called from the thread that finished with
|
480 kumpf 1.62 // running the providers function, and returns immediately while scheduling
481 // the a cleanup procedure. If you want to wait until the thread is truly
|
482 venkat.puvvada 1.48 // deleted, call 'waitUntilThreadsDone' - but DO NOT do it in the the thread
483 // that the Thread owns - you will wait forever.
484 //
485 // @argument t Thread that is not NULL and finished with running the provider
486 // function.
487 // @argument p CMPIProvider in which the 't' Thread was running.
|
488 konrad.r 1.30 */
|
489 venkat.puvvada 1.48 void CMPILocalProviderManager::cleanupThread(Thread *t, CMPIProvider *p)
|
490 konrad.r 1.30 {
|
491 ms.aruran 1.49 PEG_METHOD_ENTER(
492 TRC_PROVIDERMANAGER,
493 "CMPILocalProviderManager::cleanupThread()");
494
|
495 venkat.puvvada 1.48 PEGASUS_ASSERT( t != 0 && p != 0 );
496
497 PEGASUS_ASSERT ( p->isThreadOwner(t) );
498 // The mutex guards against a race condition for _reaperThread creation.
499 AutoMutex lock(_reaperMutex);
|
500 konrad.r 1.30
501 // Put the Thread and the CMPIProvider on the global list.
|
502 venkat.puvvada 1.48 cleanupThreadRecord *record = new cleanupThreadRecord(t, p);
503 _finishedThreadList.insert_back(record);
|
504 konrad.r 1.30
|
505 venkat.puvvada 1.48 if (_reaperThread == 0)
|
506 konrad.r 1.30 {
|
507 venkat.puvvada 1.48 _reaperThread = new Thread(_reaper, NULL, false);
508 ThreadStatus rtn = PEGASUS_THREAD_OK;
509 while ((rtn = _reaperThread->run()) != PEGASUS_THREAD_OK)
510 {
511 if (rtn == PEGASUS_THREAD_INSUFFICIENT_RESOURCES)
512 Threads::yield();
513 else
514 {
|
515 ms.aruran 1.49 PEG_TRACE_CSTRING(
516 TRC_PROVIDERMANAGER,
|
517 marek 1.55 Tracer::LEVEL1,
|
518 venkat.puvvada 1.48 "Could not allocate thread to take care of deleting "
519 "user threads. ");
520 delete _reaperThread; _reaperThread = 0;
|
521 ms.aruran 1.49 PEG_METHOD_EXIT();
|
522 venkat.puvvada 1.48 return;
|
523 kumpf 1.62 }
|
524 venkat.puvvada 1.48 }
|
525 marek 1.46 }
|
526 venkat.puvvada 1.48 // Wake up the reaper.
527 _pollingSem.signal();
|
528 ms.aruran 1.49 PEG_METHOD_EXIT();
|
529 konrad.r 1.30
530 }
531
|
532 venkat.puvvada 1.65 OpProviderHolder CMPILocalProviderManager::getRemoteProvider (
533 const String & location,
534 const String & providerName,
535 const String & providerModuleName)
|
536 konrad.r 1.24 {
|
537 venkat.puvvada 1.56 OpProviderHolder ph;
|
538 venkat.puvvada 1.48 CTRL_STRINGS
539 strings;
540 Sint32
541 ccode;
542 const String
543 proxy ("CMPIRProxyProvider");
544
545 String
546 rproviderName ("R");
|
547 ms.aruran 1.49 PEG_METHOD_ENTER(
548 TRC_PROVIDERMANAGER,
549 "ProvidertManager::getRemoteProvider()");
|
550 venkat.puvvada 1.48
551 rproviderName.append (providerName);
552
553 strings.fileName = &proxy;
554 strings.providerName = &rproviderName;
|
555 venkat.puvvada 1.65 strings.providerModuleName = &providerModuleName;
|
556 venkat.puvvada 1.48 strings.location = &location;
557
558 try
559 {
560 ccode = _provider_ctrl (GET_PROVIDER, &strings, &ph);
561 }
562 catch (const Exception & e)
563 {
|
564 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
565 "--- Exception loading proxy: %s",
566 (const char*)e.getMessage().getCString()));
|
567 ms.aruran 1.49
|
568 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
569 throw;
570 }
571 catch (...)
572 {
|
573 ms.aruran 1.49 PEG_TRACE_CSTRING(
574 TRC_PROVIDERMANAGER,
|
575 marek 1.55 Tracer::LEVEL1,
|
576 ms.aruran 1.49 "--- Unexpected exception in loading proxy provider: ---");
|
577 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
578 throw;
579 }
580
|
581 konrad.r 1.24 PEG_METHOD_EXIT ();
|
582 venkat.puvvada 1.48 return ph;
|
583 schuur 1.1 }
584
|
585 venkat.puvvada 1.65 OpProviderHolder CMPILocalProviderManager::getProvider (
586 const String & fileName,
587 const String & providerName,
588 const String & providerModuleName)
|
589 r.kieninger 1.14 {
|
590 venkat.puvvada 1.56 OpProviderHolder ph;
|
591 ms.aruran 1.49 CTRL_STRINGS strings;
592 Sint32 ccode;
593
594 String lproviderName ("L");
595
596 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider()");
|
597 venkat.puvvada 1.48
598 if (fileName.size() == 0)
599 {
|
600 thilo.boehm 1.36 throw Exception(MessageLoaderParms(
|
601 venkat.puvvada 1.48 "ProviderManager.CMPI.CMPILocalProviderManager.CANNOT_FIND_LIBRARY",
602 "For provider $0 the library name was empty. Check provider "
603 "registered location.",
604 providerName));
605
606 }
607 lproviderName.append (providerName);
608 strings.fileName = &fileName;
609 strings.providerName = &lproviderName;
|
610 venkat.puvvada 1.65 strings.providerModuleName = &providerModuleName;
|
611 venkat.puvvada 1.48 strings.location = &String::EMPTY;
612
613 try
614 {
615 ccode = _provider_ctrl (GET_PROVIDER, &strings, &ph);
616 }
617 catch (const Exception & e)
618 {
|
619 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
620 "--- Exception loading local provider: %s",
621 (const char*)e.getMessage().getCString()));
|
622 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
623 throw;
624 }
625 catch (...)
626 {
|
627 ms.aruran 1.49 PEG_TRACE_CSTRING(
628 TRC_PROVIDERMANAGER,
|
629 marek 1.55 Tracer::LEVEL1,
|
630 ms.aruran 1.49 "--- Unexpected exception in loading local provider ---");
|
631 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
632 throw;
633 }
|
634 schuur 1.1
635
|
636 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
637 return(ph);
|
638 schuur 1.1
639 }
640
|
641 venkat.puvvada 1.57 Boolean CMPILocalProviderManager::unloadProvider(
|
642 ms.aruran 1.49 const String & fileName,
|
643 venkat.puvvada 1.65 const String & providerName,
644 const String & providerModuleName)
|
645 r.kieninger 1.14 {
|
646 venkat.puvvada 1.48 CTRL_STRINGS strings;
|
647 ms.aruran 1.49 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider()");
|
648 venkat.puvvada 1.48
649 String lproviderName ("L");
650 String rproviderName ("R");
651 lproviderName.append (providerName);
652 rproviderName.append (providerName);
|
653 konrad.r 1.25
|
654 venkat.puvvada 1.48 strings.fileName = &fileName;
655 strings.providerName = &lproviderName;
|
656 venkat.puvvada 1.65 strings.providerModuleName = &providerModuleName;
|
657 venkat.puvvada 1.48 strings.location = &String::EMPTY;
|
658 venkat.puvvada 1.57
659 int lproviderStatus = 0;
660 int rproviderStatus = 0;
661 lproviderStatus = _provider_ctrl (UNLOAD_PROVIDER, &strings, (void *) 0);
|
662 konrad.r 1.25
|
663 venkat.puvvada 1.48 strings.providerName = &rproviderName;
|
664 konrad.r 1.25
|
665 venkat.puvvada 1.57 rproviderStatus = _provider_ctrl (UNLOAD_PROVIDER, &strings, (void *) 0);
|
666 venkat.puvvada 1.48
667 PEG_METHOD_EXIT ();
|
668 venkat.puvvada 1.57 return lproviderStatus != -1 && rproviderStatus != -1;
|
669 r.kieninger 1.14 }
670
|
671 venkat.puvvada 1.48 void CMPILocalProviderManager::shutdownAllProviders ()
|
672 r.kieninger 1.14 {
|
673 venkat.puvvada 1.48 _provider_ctrl (UNLOAD_ALL_PROVIDERS, (void *) this, (void *) 0);
|
674 r.kieninger 1.13 }
675
676
|
677 venkat.puvvada 1.48 Boolean CMPILocalProviderManager::hasActiveProviders ()
|
678 r.kieninger 1.14 {
|
679 ms.aruran 1.49 PEG_METHOD_ENTER(
680 TRC_PROVIDERMANAGER,
681 "ProviderManager::hasActiveProviders()");
|
682 r.kieninger 1.14
|
683 venkat.puvvada 1.48 try
684 {
685 AutoMutex lock (_providerTableMutex);
|
686 ms.aruran 1.49 PEG_TRACE((
687 TRC_PROVIDERMANAGER,
688 Tracer::LEVEL4,
|
689 venkat.puvvada 1.48 "providers in _providers table = %d", _providers.size ()));
690
691 // Iterate through the _providers table looking for an active provider
692 for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
693 {
694 if (i.value ()->getStatus () == CMPIProvider::INITIALIZED)
695 {
696 PEG_METHOD_EXIT ();
697 return true;
698 }
699 }
700 }
701 catch (...)
702 {
703 // Unexpected exception; do not assume that no providers are loaded
|
704 ms.aruran 1.49 PEG_TRACE_CSTRING(
705 TRC_PROVIDERMANAGER,
|
706 marek 1.55 Tracer::LEVEL1,
|
707 venkat.puvvada 1.48 "Unexpected Exception in hasActiveProviders.");
708 PEG_METHOD_EXIT ();
709 return true;
710 }
|
711 r.kieninger 1.14
|
712 venkat.puvvada 1.48 // No active providers were found in the _providers table
713 PEG_METHOD_EXIT ();
714 return false;
|
715 r.kieninger 1.14 }
716
|
717 venkat.puvvada 1.48 void CMPILocalProviderManager::unloadIdleProviders ()
|
718 r.kieninger 1.14 {
|
719 ms.aruran 1.49 PEG_METHOD_ENTER(
720 TRC_PROVIDERMANAGER,
721 "ProviderManager::unloadIdleProviders()");
|
722 r.kieninger 1.14
|
723 kumpf 1.41 try
|
724 r.kieninger 1.14 {
|
725 kumpf 1.41 _provider_ctrl (UNLOAD_IDLE_PROVIDERS, this, (void *) 0);
|
726 r.kieninger 1.14 }
|
727 kumpf 1.41 catch (...)
|
728 r.kieninger 1.14 {
|
729 ms.aruran 1.49 PEG_TRACE_CSTRING(
730 TRC_PROVIDERMANAGER,
731 Tracer::LEVEL2,
|
732 kumpf 1.41 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
|
733 r.kieninger 1.14 }
|
734 kumpf 1.41
735 PEG_METHOD_EXIT ();
|
736 schuur 1.1 }
737
|
738 venkat.puvvada 1.48 Array <CMPIProvider *>CMPILocalProviderManager::
739 getIndicationProvidersToEnable()
|
740 carolann.graves 1.17 {
|
741 ms.aruran 1.49 PEG_METHOD_ENTER(
742 TRC_PROVIDERMANAGER,
743 "CMPILocalProviderManager::getIndicationProvidersToEnable()");
|
744 carolann.graves 1.17
|
745 venkat.puvvada 1.48 Array < CMPIProvider * >enableProviders;
746
|
747 ms.aruran 1.49 PEG_TRACE((
748 TRC_PROVIDERMANAGER,
749 Tracer::LEVEL4,
|
750 venkat.puvvada 1.48 "Number of providers in _providers table = %d",
751 _providers.size ()));
|
752 carolann.graves 1.17
|
753 venkat.puvvada 1.48 try
754 {
755 AutoMutex
756 lock (_providerTableMutex);
|
757 carolann.graves 1.17
758 //
|
759 venkat.puvvada 1.48 // Iterate through the _providers table
|
760 carolann.graves 1.17 //
|
761 venkat.puvvada 1.48 for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
762 {
763 //
764 // Enable any indication provider with current subscriptions
765 //
766 CMPIProvider *
767 provider = i.value ();
768 if (provider->testSubscriptions ())
769 {
770 enableProviders.append (provider);
771 }
772 }
773
774 }
775 catch (const CIMException & e)
776 {
|
777 thilo.boehm 1.59 PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL1,
778 "CIMException in getIndicationProvidersToEnable: %s",
779 (const char*)e.getMessage().getCString()));
|
780 venkat.puvvada 1.48 }
781 catch (const Exception & e)
782 {
|
783 thilo.boehm 1.59 PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL1,
784 "Exception in getIndicationProvidersToEnable: %s",
785 (const char*)e.getMessage().getCString()));
|
786 venkat.puvvada 1.48 }
787 catch (...)
788 {
|
789 ms.aruran 1.49 PEG_TRACE_CSTRING(
790 TRC_DISCARDED_DATA,
|
791 marek 1.55 Tracer::LEVEL1,
|
792 venkat.puvvada 1.48 "Unexpected error in getIndicationProvidersToEnable");
793 }
|
794 carolann.graves 1.17
|
795 ms.aruran 1.49 PEG_TRACE((
796 TRC_PROVIDERMANAGER,
797 Tracer::LEVEL4,
|
798 venkat.puvvada 1.48 "Number of indication providers to enable = %d",
799 enableProviders.size ()));
|
800 carolann.graves 1.17
|
801 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
802 return enableProviders;
803 }
|
804 carolann.graves 1.17
|
805 venkat.puvvada 1.48 CMPIProvider *CMPILocalProviderManager::_initProvider(
806 CMPIProvider * provider,
807 const String & moduleFileName)
808 {
|
809 ms.aruran 1.49 PEG_METHOD_ENTER(
810 TRC_PROVIDERMANAGER,
811 "CMPILocalProviderManager::_initProvider()");
|
812 r.kieninger 1.14
|
813 venkat.puvvada 1.48 CMPIProviderModule *module = 0;
814 ProviderVector base;
|
815 kumpf 1.18
|
816 konrad.r 1.24 {
|
817 venkat.puvvada 1.48 // lock the providerTable mutex
818 AutoMutex lock (_providerTableMutex);
819
820 // lookup provider module
821 module = _lookupModule (moduleFileName);
822 } // unlock the providerTable mutex
823
824 Boolean moduleLoaded = false;
825 Boolean deleteProvider = false;
826 String exceptionMsg = moduleFileName;
|
827 konrad.r 1.26 {
|
828 venkat.puvvada 1.48 // lock the provider status mutex
|
829 venkat.puvvada 1.56 AutoMutex lock (provider->getStatusMutex());
|
830 venkat.puvvada 1.48
|
831 venkat.puvvada 1.56 if (provider->getStatus() == CMPIProvider::INITIALIZED)
|
832 venkat.puvvada 1.48 {
|
833 ms.aruran 1.49 PEG_METHOD_EXIT();
|
834 venkat.puvvada 1.48 // Initialization is already complete
835 return provider;
836 }
837
|
838 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
839 "Loading/Linking Provider Module %s",
840 (const char*)moduleFileName.getCString()));
|
841 venkat.puvvada 1.48
842 // load the provider
843 try
844 {
|
845 venkat.puvvada 1.56 base = module->load (provider->getNameWithType());
|
846 venkat.puvvada 1.48 moduleLoaded = true;
847 }
848 catch (const Exception &e)
849 {
850 exceptionMsg = e.getMessage();
|
851 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
852 "Exception caught Loading/Linking Provider Module %s"
853 " error is: %s",
854 (const char*)moduleFileName.getCString(),
855 (const char*)exceptionMsg.getCString()));
|
856 venkat.puvvada 1.48 deleteProvider =true;
857 }
858 catch (...)
859 {
|
860 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
861 "Unknown exception caught Loading/Linking Provider Module %s",
862 (const char*)moduleFileName.getCString()));
|
863 venkat.puvvada 1.48 exceptionMsg = moduleFileName;
864 deleteProvider = true;
865 }
866
867 if (!deleteProvider)
868 {
869 // initialize the provider
|
870 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
871 "Initializing Provider %s",
872 (const char*)provider->getName().getCString()));
|
873 venkat.puvvada 1.48
874 CIMOMHandle *cimomHandle = new CIMOMHandle ();
875 provider->set (module, base, cimomHandle);
|
876 venkat.puvvada 1.56 provider->setQuantum(0);
|
877 venkat.puvvada 1.48
878 try
879 {
|
880 venkat.puvvada 1.56 provider->initialize (*(provider->getCIMOMHandle()));
|
881 venkat.puvvada 1.48 }
882 catch (const Exception &e)
883 {
|
884 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
885 "Problem initializing %s: %s",
886 (const char*)provider->getName().getCString(),
887 (const char*)e.getMessage().getCString()));
|
888 venkat.puvvada 1.48 deleteProvider = true;
889 exceptionMsg = e.getMessage();
890 }
891 catch (...)
892 {
|
893 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
894 "Unknown problem initializing %s",
895 (const char*)provider->getName().getCString()));
|
896 venkat.puvvada 1.48 deleteProvider = true;
897 exceptionMsg = provider->getName();
898 }
899 } // unlock the provider status mutex
|
900 konrad.r 1.26 }
|
901 venkat.puvvada 1.48 /* We wait until this moment to delete the provider b/c we need
902 be outside the scope for the AutoMutex for the provider. */
903 if (deleteProvider)
904 {
905 // Note: The deleting of the cimom handle is being
906 // moved after the call to unloadModule() based on
907 // a previous fix for bug 3669 and consistency with
908 // other provider managers. Do not move it back before
909 // the call to unloadModule().
910
911 // unload provider module
912 if (moduleLoaded)
913 {
914 module->unloadModule();
915 }
916
917 // delete the cimom handle
|
918 venkat.puvvada 1.56 delete provider->getCIMOMHandle();
|
919 venkat.puvvada 1.48 // set provider status to UNINITIALIZED
920 provider->reset ();
921
922 AutoMutex lock (_providerTableMutex);
|
923 venkat.puvvada 1.65 _removeProvider(provider->getNameWithType(), provider->getModuleName());
|
924 venkat.puvvada 1.48 delete provider;
|
925 konrad.r 1.26
|
926 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
927 throw Exception(exceptionMsg);
|
928 r.kieninger 1.14 }
929
|
930 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
931 return(provider);
|
932 r.kieninger 1.14 }
933
|
934 venkat.puvvada 1.57 void CMPILocalProviderManager::_unloadProvider (
935 CMPIProvider * provider,
936 Boolean forceUnload)
|
937 r.kieninger 1.14 {
|
938 venkat.puvvada 1.48 //
939 // NOTE: It is the caller's responsibility to make sure that
940 // the ProviderTable mutex is locked before calling this method.
941 //
|
942 thilo.boehm 1.59 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
|
943 ms.aruran 1.49 "CMPILocalProviderManager::_unloadProvider()");
944
|
945 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
946 "Unloading Provider %s",(const char*)provider->getName().getCString()));
|
947 r.kieninger 1.14
|
948 venkat.puvvada 1.57 if (provider->getCurrentOperations() && !forceUnload)
|
949 r.kieninger 1.14 {
|
950 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
951 "Provider cannot be unloaded due to pending operations: %s",
952 (const char*)provider->getName().getCString()));
|
953 r.kieninger 1.14 }
|
954 venkat.puvvada 1.48 else
|
955 r.kieninger 1.14 {
|
956 venkat.puvvada 1.57 if (provider->getCurrentOperations())
|
957 kumpf 1.62 {
|
958 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
959 "Terminating Provider with pending operations %s",
960 (const char*)provider->getName().getCString()));
|
961 venkat.puvvada 1.57 }
962 else
963 {
|
964 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
965 "Terminating Provider %s",
966 (const char*)provider->getName().getCString()));
|
967 venkat.puvvada 1.57 }
|
968 r.kieninger 1.14
|
969 venkat.puvvada 1.48 // lock the provider mutex
|
970 venkat.puvvada 1.56 AutoMutex pr_lock (provider->getStatusMutex());
|
971 r.kieninger 1.14
|
972 venkat.puvvada 1.48 try
973 {
974 provider->terminate ();
975 }
976 catch (...)
977 {
|
978 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
979 "Error occured terminating CMPI provider %s",
980 (const char*)provider->getName().getCString()));
|
981 venkat.puvvada 1.48 }
|
982 r.kieninger 1.14
|
983 venkat.puvvada 1.57 if (provider->getStatus() == CMPIProvider::UNINITIALIZED)
984 {
|
985 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
986 "Unload provider module %s for provider %s",
987 (const char*)
988 provider->getModule()->getFileName().getCString(),
989 (const char*)provider->getName().getCString()));
|
990 venkat.puvvada 1.57 // unload provider module
|
991 thilo.boehm 1.59 provider->getModule()->unloadModule();
|
992 r.kieninger 1.14
|
993 venkat.puvvada 1.57 // delete the cimom handle
|
994 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
995 "Destroying CMPIProvider's CIMOM Handle %s",
996 (const char*)provider->getName().getCString()));
|
997 kumpf 1.62
|
998 venkat.puvvada 1.57 delete provider->getCIMOMHandle();
999 PEGASUS_ASSERT (provider->getModule() != 0);
|
1000 r.kieninger 1.14
1001
|
1002 venkat.puvvada 1.57 // set provider status to UNINITIALIZED
1003 provider->reset ();
|
1004 r.kieninger 1.14
|
1005 venkat.puvvada 1.57 // Do not delete the provider. The function calling this function
1006 // takes care of that.
1007 }
|
1008 r.kieninger 1.14 }
|
1009 r.kieninger 1.13
|
1010 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
|
1011 dj.gorey 1.6 }
1012
|
1013 venkat.puvvada 1.65 Boolean CMPILocalProviderManager::_removeProvider(
1014 const String & providerName,
1015 const String & providerModuleName)
1016 {
1017 ProviderKey providerKey(providerName, providerModuleName);
1018
1019 AutoMutex lock (_providerTableMutex);
1020 return _providers.remove(providerKey);
1021 }
1022
|
1023 venkat.puvvada 1.48 CMPIProvider * CMPILocalProviderManager::_lookupProvider(
|
1024 venkat.puvvada 1.65 const String & providerName,
1025 const String & providerModuleName)
1026
|
1027 r.kieninger 1.14 {
|
1028 ms.aruran 1.49 PEG_METHOD_ENTER(
1029 TRC_PROVIDERMANAGER,
1030 "CMPILocalProviderManager::_lookupProvider()");
|
1031 venkat.puvvada 1.65
1032 ProviderKey providerKey(providerName, providerModuleName);
1033
|
1034 venkat.puvvada 1.48 // lock the providerTable mutex
1035 AutoMutex lock (_providerTableMutex);
1036 // look up provider in cache
1037 CMPIProvider *pr = 0;
|
1038 venkat.puvvada 1.65
1039 if (true == _providers.lookup (providerKey, pr))
|
1040 r.kieninger 1.14 {
|
1041 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1042 "Found Provider %s in CMPI Provider Manager Cache",
1043 (const char*)providerName.getCString()));
|
1044 r.kieninger 1.14 }
|
1045 venkat.puvvada 1.48 else
|
1046 r.kieninger 1.14 {
|
1047 venkat.puvvada 1.48 // create provider
|
1048 venkat.puvvada 1.65 pr = new CMPIProvider (providerName, providerModuleName, 0, 0);
|
1049 venkat.puvvada 1.48 // insert provider in provider table
|
1050 venkat.puvvada 1.65 _providers.insert (providerKey, pr);
|
1051 r.kieninger 1.14
|
1052 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1053 "Created provider %s",(const char*)pr->getName().getCString()));
|
1054 r.kieninger 1.14 }
|
1055 dj.gorey 1.6
|
1056 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1057 return(pr);
|
1058 dj.gorey 1.6 }
1059
1060
|
1061 venkat.puvvada 1.48 CMPIProviderModule * CMPILocalProviderManager::_lookupModule(
1062 const String & moduleFileName)
|
1063 r.kieninger 1.14 {
|
1064 ms.aruran 1.49 PEG_METHOD_ENTER(
1065 TRC_PROVIDERMANAGER,
1066 "CMPILocalProviderManager::_lookupModule()");
|
1067 r.kieninger 1.14
|
1068 venkat.puvvada 1.48 // look up provider module in cache
1069 CMPIProviderModule *module = 0;
|
1070 r.kieninger 1.14
|
1071 venkat.puvvada 1.48 if (true == _modules.lookup (moduleFileName, module))
|
1072 r.kieninger 1.14 {
|
1073 venkat.puvvada 1.48 // found provider module in cache
|
1074 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1075 "Found Provider Module %s in Provider Manager Cache",
1076 (const char*)moduleFileName.getCString()));
|
1077 dj.gorey 1.6
|
1078 konrad.r 1.24 }
|
1079 venkat.puvvada 1.48 else
|
1080 konrad.r 1.24 {
|
1081 venkat.puvvada 1.48 // provider module not found in cache, create provider module
|
1082 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1083 "Creating CMPI Provider Module %s",
1084 (const char*)moduleFileName.getCString()));
|
1085 r.kieninger 1.14
|
1086 venkat.puvvada 1.48 module = new CMPIProviderModule (moduleFileName);
|
1087 r.kieninger 1.14
|
1088 venkat.puvvada 1.48 // insert provider module in module table
1089 _modules.insert (moduleFileName, module);
|
1090 r.kieninger 1.14 }
|
1091 dj.gorey 1.6
|
1092 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1093 return(module);
|
1094 schuur 1.1 }
1095
1096 PEGASUS_NAMESPACE_END
|
1097 kumpf 1.62
|
Return to
CMPILocalProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI