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