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 Thread *myself = reinterpret_cast<Thread *>(parm);
422 do
423 {
424 _pollingSem.wait();
425 // All of the threads are finished working. We just need to reap 'em
426 cleanupThreadRecord *rec = 0;
|
427 dave.sudlik 1.39
|
428 venkat.puvvada 1.48 while (_finishedThreadList.size() >0)
429 {
430 // Pull of the the threads from the global list.
431 rec = _finishedThreadList.remove_front();
|
432 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
433 "-- Reaping the thread from %s",
434 (const char*)rec->provider->getName().getCString()));
|
435 ms.aruran 1.49
|
436 venkat.puvvada 1.48 rec->thread->join();
437
438 // Remove the thread for the CMPIProvider.
439 rec->provider->threadDelete(rec->thread);
440
441 // Delete the thread.
442 delete rec->thread;
443 delete rec;
444 }
|
445 r.kieninger 1.14 }
|
446 venkat.puvvada 1.48 while (_stopPolling.get() == 0);
|
447 kumpf 1.52
|
448 ms.aruran 1.49 PEG_METHOD_EXIT();
|
449 kumpf 1.52 return ThreadReturnType(0);
|
450 schuur 1.1 }
|
451 venkat.puvvada 1.53
|
452 venkat.puvvada 1.65 Boolean CMPILocalProviderManager::isProviderActive(
453 const String &providerName,
454 const String &providerModuleName)
|
455 venkat.puvvada 1.53 {
456 PEG_METHOD_ENTER(
457 TRC_PROVIDERMANAGER,
458 "CMPILocalProviderManager::isProviderActive()");
459
460 AutoMutex mtx(_providerTableMutex);
461 String lProviderName("L");
462 lProviderName.append(providerName);
463 String rProviderName("R");
464 rProviderName.append(providerName);
465
|
466 venkat.puvvada 1.65 ProviderKey lpKey(lProviderName, providerModuleName);
467 ProviderKey rpKey(rProviderName, providerModuleName);
468 Boolean active = _providers.contains(lpKey) || _providers.contains(rpKey);
|
469 venkat.puvvada 1.53
470 PEG_METHOD_EXIT();
471
472 return active;
473 }
474
|
475 konrad.r 1.30 /*
|
476 kumpf 1.62 // Cleanup the thread and upon deletion of it, call the CMPIProvider'
|
477 venkat.puvvada 1.48 // "threadDeleted". to not, all the CMPIProvider '
478 // Note that this function is called from the thread that finished with
|
479 kumpf 1.62 // running the providers function, and returns immediately while scheduling
480 // the a cleanup procedure. If you want to wait until the thread is truly
|
481 venkat.puvvada 1.48 // deleted, call 'waitUntilThreadsDone' - but DO NOT do it in the the thread
482 // that the Thread owns - you will wait forever.
483 //
484 // @argument t Thread that is not NULL and finished with running the provider
485 // function.
486 // @argument p CMPIProvider in which the 't' Thread was running.
|
487 konrad.r 1.30 */
|
488 venkat.puvvada 1.48 void CMPILocalProviderManager::cleanupThread(Thread *t, CMPIProvider *p)
|
489 konrad.r 1.30 {
|
490 ms.aruran 1.49 PEG_METHOD_ENTER(
491 TRC_PROVIDERMANAGER,
492 "CMPILocalProviderManager::cleanupThread()");
493
|
494 venkat.puvvada 1.48 PEGASUS_ASSERT( t != 0 && p != 0 );
495
496 PEGASUS_ASSERT ( p->isThreadOwner(t) );
497 // The mutex guards against a race condition for _reaperThread creation.
498 AutoMutex lock(_reaperMutex);
|
499 konrad.r 1.30
500 // Put the Thread and the CMPIProvider on the global list.
|
501 venkat.puvvada 1.48 cleanupThreadRecord *record = new cleanupThreadRecord(t, p);
502 _finishedThreadList.insert_back(record);
|
503 konrad.r 1.30
|
504 venkat.puvvada 1.48 if (_reaperThread == 0)
|
505 konrad.r 1.30 {
|
506 venkat.puvvada 1.48 _reaperThread = new Thread(_reaper, NULL, false);
|
507 venkat.puvvada 1.66
508 if (_reaperThread->run() != PEGASUS_THREAD_OK)
|
509 venkat.puvvada 1.48 {
|
510 venkat.puvvada 1.66 PEG_TRACE_CSTRING(
511 TRC_PROVIDERMANAGER,
512 Tracer::LEVEL1,
513 "Could not allocate thread to take care of deleting "
514 "user threads, will be cleaned up later.");
515
516 delete _reaperThread;
517 _reaperThread = 0;
518 PEG_METHOD_EXIT();
519 return;
|
520 venkat.puvvada 1.48 }
|
521 marek 1.46 }
|
522 venkat.puvvada 1.48 // Wake up the reaper.
523 _pollingSem.signal();
|
524 ms.aruran 1.49 PEG_METHOD_EXIT();
|
525 konrad.r 1.30
526 }
527
|
528 venkat.puvvada 1.65 OpProviderHolder CMPILocalProviderManager::getRemoteProvider (
529 const String & location,
530 const String & providerName,
531 const String & providerModuleName)
|
532 konrad.r 1.24 {
|
533 venkat.puvvada 1.56 OpProviderHolder ph;
|
534 venkat.puvvada 1.48 CTRL_STRINGS
535 strings;
536 Sint32
537 ccode;
538 const String
539 proxy ("CMPIRProxyProvider");
540
541 String
542 rproviderName ("R");
|
543 ms.aruran 1.49 PEG_METHOD_ENTER(
544 TRC_PROVIDERMANAGER,
545 "ProvidertManager::getRemoteProvider()");
|
546 venkat.puvvada 1.48
547 rproviderName.append (providerName);
548
549 strings.fileName = &proxy;
550 strings.providerName = &rproviderName;
|
551 venkat.puvvada 1.65 strings.providerModuleName = &providerModuleName;
|
552 venkat.puvvada 1.48 strings.location = &location;
553
554 try
555 {
556 ccode = _provider_ctrl (GET_PROVIDER, &strings, &ph);
557 }
558 catch (const Exception & e)
559 {
|
560 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
561 "--- Exception loading proxy: %s",
562 (const char*)e.getMessage().getCString()));
|
563 ms.aruran 1.49
|
564 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
565 throw;
566 }
567 catch (...)
568 {
|
569 ms.aruran 1.49 PEG_TRACE_CSTRING(
570 TRC_PROVIDERMANAGER,
|
571 marek 1.55 Tracer::LEVEL1,
|
572 ms.aruran 1.49 "--- Unexpected exception in loading proxy provider: ---");
|
573 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
574 throw;
575 }
576
|
577 konrad.r 1.24 PEG_METHOD_EXIT ();
|
578 venkat.puvvada 1.48 return ph;
|
579 schuur 1.1 }
580
|
581 venkat.puvvada 1.65 OpProviderHolder CMPILocalProviderManager::getProvider (
582 const String & fileName,
583 const String & providerName,
584 const String & providerModuleName)
|
585 r.kieninger 1.14 {
|
586 venkat.puvvada 1.56 OpProviderHolder ph;
|
587 ms.aruran 1.49 CTRL_STRINGS strings;
588 Sint32 ccode;
589
590 String lproviderName ("L");
591
592 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider()");
|
593 venkat.puvvada 1.48
594 if (fileName.size() == 0)
595 {
|
596 thilo.boehm 1.36 throw Exception(MessageLoaderParms(
|
597 venkat.puvvada 1.48 "ProviderManager.CMPI.CMPILocalProviderManager.CANNOT_FIND_LIBRARY",
598 "For provider $0 the library name was empty. Check provider "
599 "registered location.",
600 providerName));
601
602 }
603 lproviderName.append (providerName);
604 strings.fileName = &fileName;
605 strings.providerName = &lproviderName;
|
606 venkat.puvvada 1.65 strings.providerModuleName = &providerModuleName;
|
607 venkat.puvvada 1.48 strings.location = &String::EMPTY;
608
609 try
610 {
611 ccode = _provider_ctrl (GET_PROVIDER, &strings, &ph);
612 }
613 catch (const Exception & e)
614 {
|
615 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
616 "--- Exception loading local provider: %s",
617 (const char*)e.getMessage().getCString()));
|
618 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
619 throw;
620 }
621 catch (...)
622 {
|
623 ms.aruran 1.49 PEG_TRACE_CSTRING(
624 TRC_PROVIDERMANAGER,
|
625 marek 1.55 Tracer::LEVEL1,
|
626 ms.aruran 1.49 "--- Unexpected exception in loading local provider ---");
|
627 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
628 throw;
629 }
|
630 schuur 1.1
631
|
632 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
633 return(ph);
|
634 schuur 1.1
635 }
636
|
637 venkat.puvvada 1.57 Boolean CMPILocalProviderManager::unloadProvider(
|
638 ms.aruran 1.49 const String & fileName,
|
639 venkat.puvvada 1.65 const String & providerName,
640 const String & providerModuleName)
|
641 r.kieninger 1.14 {
|
642 venkat.puvvada 1.48 CTRL_STRINGS strings;
|
643 ms.aruran 1.49 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider()");
|
644 venkat.puvvada 1.48
645 String lproviderName ("L");
646 String rproviderName ("R");
647 lproviderName.append (providerName);
648 rproviderName.append (providerName);
|
649 konrad.r 1.25
|
650 venkat.puvvada 1.48 strings.fileName = &fileName;
651 strings.providerName = &lproviderName;
|
652 venkat.puvvada 1.65 strings.providerModuleName = &providerModuleName;
|
653 venkat.puvvada 1.48 strings.location = &String::EMPTY;
|
654 venkat.puvvada 1.57
655 int lproviderStatus = 0;
656 int rproviderStatus = 0;
657 lproviderStatus = _provider_ctrl (UNLOAD_PROVIDER, &strings, (void *) 0);
|
658 konrad.r 1.25
|
659 venkat.puvvada 1.48 strings.providerName = &rproviderName;
|
660 konrad.r 1.25
|
661 venkat.puvvada 1.57 rproviderStatus = _provider_ctrl (UNLOAD_PROVIDER, &strings, (void *) 0);
|
662 venkat.puvvada 1.48
663 PEG_METHOD_EXIT ();
|
664 venkat.puvvada 1.57 return lproviderStatus != -1 && rproviderStatus != -1;
|
665 r.kieninger 1.14 }
666
|
667 venkat.puvvada 1.48 void CMPILocalProviderManager::shutdownAllProviders ()
|
668 r.kieninger 1.14 {
|
669 venkat.puvvada 1.48 _provider_ctrl (UNLOAD_ALL_PROVIDERS, (void *) this, (void *) 0);
|
670 r.kieninger 1.13 }
671
672
|
673 venkat.puvvada 1.48 Boolean CMPILocalProviderManager::hasActiveProviders ()
|
674 r.kieninger 1.14 {
|
675 ms.aruran 1.49 PEG_METHOD_ENTER(
676 TRC_PROVIDERMANAGER,
677 "ProviderManager::hasActiveProviders()");
|
678 r.kieninger 1.14
|
679 venkat.puvvada 1.48 try
680 {
681 AutoMutex lock (_providerTableMutex);
|
682 ms.aruran 1.49 PEG_TRACE((
683 TRC_PROVIDERMANAGER,
684 Tracer::LEVEL4,
|
685 venkat.puvvada 1.48 "providers in _providers table = %d", _providers.size ()));
686
687 // Iterate through the _providers table looking for an active provider
688 for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
689 {
690 if (i.value ()->getStatus () == CMPIProvider::INITIALIZED)
691 {
692 PEG_METHOD_EXIT ();
693 return true;
694 }
695 }
696 }
697 catch (...)
698 {
699 // Unexpected exception; do not assume that no providers are loaded
|
700 ms.aruran 1.49 PEG_TRACE_CSTRING(
701 TRC_PROVIDERMANAGER,
|
702 marek 1.55 Tracer::LEVEL1,
|
703 venkat.puvvada 1.48 "Unexpected Exception in hasActiveProviders.");
704 PEG_METHOD_EXIT ();
705 return true;
706 }
|
707 r.kieninger 1.14
|
708 venkat.puvvada 1.48 // No active providers were found in the _providers table
709 PEG_METHOD_EXIT ();
710 return false;
|
711 r.kieninger 1.14 }
712
|
713 venkat.puvvada 1.48 void CMPILocalProviderManager::unloadIdleProviders ()
|
714 r.kieninger 1.14 {
|
715 ms.aruran 1.49 PEG_METHOD_ENTER(
716 TRC_PROVIDERMANAGER,
717 "ProviderManager::unloadIdleProviders()");
|
718 r.kieninger 1.14
|
719 kumpf 1.41 try
|
720 r.kieninger 1.14 {
|
721 kumpf 1.41 _provider_ctrl (UNLOAD_IDLE_PROVIDERS, this, (void *) 0);
|
722 r.kieninger 1.14 }
|
723 kumpf 1.41 catch (...)
|
724 r.kieninger 1.14 {
|
725 ms.aruran 1.49 PEG_TRACE_CSTRING(
726 TRC_PROVIDERMANAGER,
727 Tracer::LEVEL2,
|
728 kumpf 1.41 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
|
729 r.kieninger 1.14 }
|
730 kumpf 1.41
731 PEG_METHOD_EXIT ();
|
732 schuur 1.1 }
733
|
734 venkat.puvvada 1.48 Array <CMPIProvider *>CMPILocalProviderManager::
735 getIndicationProvidersToEnable()
|
736 carolann.graves 1.17 {
|
737 ms.aruran 1.49 PEG_METHOD_ENTER(
738 TRC_PROVIDERMANAGER,
739 "CMPILocalProviderManager::getIndicationProvidersToEnable()");
|
740 carolann.graves 1.17
|
741 venkat.puvvada 1.48 Array < CMPIProvider * >enableProviders;
742
|
743 ms.aruran 1.49 PEG_TRACE((
744 TRC_PROVIDERMANAGER,
745 Tracer::LEVEL4,
|
746 venkat.puvvada 1.48 "Number of providers in _providers table = %d",
747 _providers.size ()));
|
748 carolann.graves 1.17
|
749 venkat.puvvada 1.48 try
750 {
751 AutoMutex
752 lock (_providerTableMutex);
|
753 carolann.graves 1.17
754 //
|
755 venkat.puvvada 1.48 // Iterate through the _providers table
|
756 carolann.graves 1.17 //
|
757 venkat.puvvada 1.48 for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
758 {
759 //
760 // Enable any indication provider with current subscriptions
761 //
762 CMPIProvider *
763 provider = i.value ();
764 if (provider->testSubscriptions ())
765 {
766 enableProviders.append (provider);
767 }
768 }
769
770 }
771 catch (const CIMException & e)
772 {
|
773 thilo.boehm 1.59 PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL1,
774 "CIMException in getIndicationProvidersToEnable: %s",
775 (const char*)e.getMessage().getCString()));
|
776 venkat.puvvada 1.48 }
777 catch (const Exception & e)
778 {
|
779 thilo.boehm 1.59 PEG_TRACE((TRC_DISCARDED_DATA,Tracer::LEVEL1,
780 "Exception in getIndicationProvidersToEnable: %s",
781 (const char*)e.getMessage().getCString()));
|
782 venkat.puvvada 1.48 }
783 catch (...)
784 {
|
785 ms.aruran 1.49 PEG_TRACE_CSTRING(
786 TRC_DISCARDED_DATA,
|
787 marek 1.55 Tracer::LEVEL1,
|
788 venkat.puvvada 1.48 "Unexpected error in getIndicationProvidersToEnable");
789 }
|
790 carolann.graves 1.17
|
791 ms.aruran 1.49 PEG_TRACE((
792 TRC_PROVIDERMANAGER,
793 Tracer::LEVEL4,
|
794 venkat.puvvada 1.48 "Number of indication providers to enable = %d",
795 enableProviders.size ()));
|
796 carolann.graves 1.17
|
797 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
798 return enableProviders;
799 }
|
800 carolann.graves 1.17
|
801 venkat.puvvada 1.48 CMPIProvider *CMPILocalProviderManager::_initProvider(
802 CMPIProvider * provider,
803 const String & moduleFileName)
804 {
|
805 ms.aruran 1.49 PEG_METHOD_ENTER(
806 TRC_PROVIDERMANAGER,
807 "CMPILocalProviderManager::_initProvider()");
|
808 r.kieninger 1.14
|
809 venkat.puvvada 1.48 CMPIProviderModule *module = 0;
810 ProviderVector base;
|
811 kumpf 1.18
|
812 konrad.r 1.24 {
|
813 venkat.puvvada 1.48 // lock the providerTable mutex
814 AutoMutex lock (_providerTableMutex);
815
816 // lookup provider module
817 module = _lookupModule (moduleFileName);
818 } // unlock the providerTable mutex
819
820 Boolean moduleLoaded = false;
821 Boolean deleteProvider = false;
822 String exceptionMsg = moduleFileName;
|
823 konrad.r 1.26 {
|
824 venkat.puvvada 1.48 // lock the provider status mutex
|
825 venkat.puvvada 1.56 AutoMutex lock (provider->getStatusMutex());
|
826 venkat.puvvada 1.48
|
827 venkat.puvvada 1.56 if (provider->getStatus() == CMPIProvider::INITIALIZED)
|
828 venkat.puvvada 1.48 {
|
829 ms.aruran 1.49 PEG_METHOD_EXIT();
|
830 venkat.puvvada 1.48 // Initialization is already complete
831 return provider;
832 }
833
|
834 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
835 "Loading/Linking Provider Module %s",
836 (const char*)moduleFileName.getCString()));
|
837 venkat.puvvada 1.48
838 // load the provider
839 try
840 {
|
841 venkat.puvvada 1.56 base = module->load (provider->getNameWithType());
|
842 venkat.puvvada 1.48 moduleLoaded = true;
843 }
844 catch (const Exception &e)
845 {
846 exceptionMsg = e.getMessage();
|
847 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
848 "Exception caught Loading/Linking Provider Module %s"
849 " error is: %s",
850 (const char*)moduleFileName.getCString(),
851 (const char*)exceptionMsg.getCString()));
|
852 venkat.puvvada 1.48 deleteProvider =true;
853 }
854 catch (...)
855 {
|
856 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
857 "Unknown exception caught Loading/Linking Provider Module %s",
858 (const char*)moduleFileName.getCString()));
|
859 venkat.puvvada 1.48 exceptionMsg = moduleFileName;
860 deleteProvider = true;
861 }
862
863 if (!deleteProvider)
864 {
865 // initialize the provider
|
866 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
867 "Initializing Provider %s",
868 (const char*)provider->getName().getCString()));
|
869 venkat.puvvada 1.48
870 CIMOMHandle *cimomHandle = new CIMOMHandle ();
871 provider->set (module, base, cimomHandle);
|
872 venkat.puvvada 1.56 provider->setQuantum(0);
|
873 venkat.puvvada 1.48
874 try
875 {
|
876 venkat.puvvada 1.56 provider->initialize (*(provider->getCIMOMHandle()));
|
877 venkat.puvvada 1.48 }
878 catch (const Exception &e)
879 {
|
880 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
881 "Problem initializing %s: %s",
882 (const char*)provider->getName().getCString(),
883 (const char*)e.getMessage().getCString()));
|
884 venkat.puvvada 1.48 deleteProvider = true;
885 exceptionMsg = e.getMessage();
886 }
887 catch (...)
888 {
|
889 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
890 "Unknown problem initializing %s",
891 (const char*)provider->getName().getCString()));
|
892 venkat.puvvada 1.48 deleteProvider = true;
893 exceptionMsg = provider->getName();
894 }
895 } // unlock the provider status mutex
|
896 konrad.r 1.26 }
|
897 venkat.puvvada 1.48 /* We wait until this moment to delete the provider b/c we need
898 be outside the scope for the AutoMutex for the provider. */
899 if (deleteProvider)
900 {
901 // Note: The deleting of the cimom handle is being
902 // moved after the call to unloadModule() based on
903 // a previous fix for bug 3669 and consistency with
904 // other provider managers. Do not move it back before
905 // the call to unloadModule().
906
907 // unload provider module
908 if (moduleLoaded)
909 {
910 module->unloadModule();
911 }
912
913 // delete the cimom handle
|
914 venkat.puvvada 1.56 delete provider->getCIMOMHandle();
|
915 venkat.puvvada 1.48 // set provider status to UNINITIALIZED
916 provider->reset ();
917
918 AutoMutex lock (_providerTableMutex);
|
919 venkat.puvvada 1.65 _removeProvider(provider->getNameWithType(), provider->getModuleName());
|
920 venkat.puvvada 1.48 delete provider;
|
921 konrad.r 1.26
|
922 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
923 throw Exception(exceptionMsg);
|
924 r.kieninger 1.14 }
925
|
926 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
927 return(provider);
|
928 r.kieninger 1.14 }
929
|
930 venkat.puvvada 1.57 void CMPILocalProviderManager::_unloadProvider (
931 CMPIProvider * provider,
932 Boolean forceUnload)
|
933 r.kieninger 1.14 {
|
934 venkat.puvvada 1.48 //
935 // NOTE: It is the caller's responsibility to make sure that
936 // the ProviderTable mutex is locked before calling this method.
937 //
|
938 thilo.boehm 1.59 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
|
939 ms.aruran 1.49 "CMPILocalProviderManager::_unloadProvider()");
940
|
941 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
942 "Unloading Provider %s",(const char*)provider->getName().getCString()));
|
943 r.kieninger 1.14
|
944 venkat.puvvada 1.57 if (provider->getCurrentOperations() && !forceUnload)
|
945 r.kieninger 1.14 {
|
946 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
947 "Provider cannot be unloaded due to pending operations: %s",
948 (const char*)provider->getName().getCString()));
|
949 r.kieninger 1.14 }
|
950 venkat.puvvada 1.48 else
|
951 r.kieninger 1.14 {
|
952 venkat.puvvada 1.57 if (provider->getCurrentOperations())
|
953 kumpf 1.62 {
|
954 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
955 "Terminating Provider with pending operations %s",
956 (const char*)provider->getName().getCString()));
|
957 venkat.puvvada 1.57 }
958 else
959 {
|
960 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
961 "Terminating Provider %s",
962 (const char*)provider->getName().getCString()));
|
963 venkat.puvvada 1.57 }
|
964 r.kieninger 1.14
|
965 venkat.puvvada 1.48 // lock the provider mutex
|
966 venkat.puvvada 1.56 AutoMutex pr_lock (provider->getStatusMutex());
|
967 r.kieninger 1.14
|
968 venkat.puvvada 1.48 try
969 {
970 provider->terminate ();
971 }
972 catch (...)
973 {
|
974 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,
975 "Error occured terminating CMPI provider %s",
976 (const char*)provider->getName().getCString()));
|
977 venkat.puvvada 1.48 }
|
978 r.kieninger 1.14
|
979 venkat.puvvada 1.57 if (provider->getStatus() == CMPIProvider::UNINITIALIZED)
980 {
|
981 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
982 "Unload provider module %s for provider %s",
983 (const char*)
984 provider->getModule()->getFileName().getCString(),
985 (const char*)provider->getName().getCString()));
|
986 venkat.puvvada 1.57 // unload provider module
|
987 thilo.boehm 1.59 provider->getModule()->unloadModule();
|
988 r.kieninger 1.14
|
989 venkat.puvvada 1.57 // delete the cimom handle
|
990 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
991 "Destroying CMPIProvider's CIMOM Handle %s",
992 (const char*)provider->getName().getCString()));
|
993 kumpf 1.62
|
994 venkat.puvvada 1.57 delete provider->getCIMOMHandle();
995 PEGASUS_ASSERT (provider->getModule() != 0);
|
996 r.kieninger 1.14
997
|
998 venkat.puvvada 1.57 // set provider status to UNINITIALIZED
999 provider->reset ();
|
1000 r.kieninger 1.14
|
1001 venkat.puvvada 1.57 // Do not delete the provider. The function calling this function
1002 // takes care of that.
1003 }
|
1004 r.kieninger 1.14 }
|
1005 r.kieninger 1.13
|
1006 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
|
1007 dj.gorey 1.6 }
1008
|
1009 venkat.puvvada 1.65 Boolean CMPILocalProviderManager::_removeProvider(
1010 const String & providerName,
1011 const String & providerModuleName)
1012 {
1013 ProviderKey providerKey(providerName, providerModuleName);
1014
1015 AutoMutex lock (_providerTableMutex);
1016 return _providers.remove(providerKey);
1017 }
1018
|
1019 venkat.puvvada 1.48 CMPIProvider * CMPILocalProviderManager::_lookupProvider(
|
1020 venkat.puvvada 1.65 const String & providerName,
1021 const String & providerModuleName)
1022
|
1023 r.kieninger 1.14 {
|
1024 ms.aruran 1.49 PEG_METHOD_ENTER(
1025 TRC_PROVIDERMANAGER,
1026 "CMPILocalProviderManager::_lookupProvider()");
|
1027 venkat.puvvada 1.65
1028 ProviderKey providerKey(providerName, providerModuleName);
1029
|
1030 venkat.puvvada 1.48 // lock the providerTable mutex
1031 AutoMutex lock (_providerTableMutex);
1032 // look up provider in cache
1033 CMPIProvider *pr = 0;
|
1034 venkat.puvvada 1.65
1035 if (true == _providers.lookup (providerKey, pr))
|
1036 r.kieninger 1.14 {
|
1037 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1038 "Found Provider %s in CMPI Provider Manager Cache",
1039 (const char*)providerName.getCString()));
|
1040 r.kieninger 1.14 }
|
1041 venkat.puvvada 1.48 else
|
1042 r.kieninger 1.14 {
|
1043 venkat.puvvada 1.48 // create provider
|
1044 venkat.puvvada 1.65 pr = new CMPIProvider (providerName, providerModuleName, 0, 0);
|
1045 venkat.puvvada 1.48 // insert provider in provider table
|
1046 venkat.puvvada 1.65 _providers.insert (providerKey, pr);
|
1047 r.kieninger 1.14
|
1048 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1049 "Created provider %s",(const char*)pr->getName().getCString()));
|
1050 r.kieninger 1.14 }
|
1051 venkat.puvvada 1.66.6.1 pr->update_idle_timer();
|
1052 dj.gorey 1.6
|
1053 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1054 return(pr);
|
1055 dj.gorey 1.6 }
1056
1057
|
1058 venkat.puvvada 1.48 CMPIProviderModule * CMPILocalProviderManager::_lookupModule(
1059 const String & moduleFileName)
|
1060 r.kieninger 1.14 {
|
1061 ms.aruran 1.49 PEG_METHOD_ENTER(
1062 TRC_PROVIDERMANAGER,
1063 "CMPILocalProviderManager::_lookupModule()");
|
1064 r.kieninger 1.14
|
1065 venkat.puvvada 1.48 // look up provider module in cache
1066 CMPIProviderModule *module = 0;
|
1067 r.kieninger 1.14
|
1068 venkat.puvvada 1.48 if (true == _modules.lookup (moduleFileName, module))
|
1069 r.kieninger 1.14 {
|
1070 venkat.puvvada 1.48 // found provider module in cache
|
1071 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1072 "Found Provider Module %s in Provider Manager Cache",
1073 (const char*)moduleFileName.getCString()));
|
1074 dj.gorey 1.6
|
1075 konrad.r 1.24 }
|
1076 venkat.puvvada 1.48 else
|
1077 konrad.r 1.24 {
|
1078 venkat.puvvada 1.48 // provider module not found in cache, create provider module
|
1079 thilo.boehm 1.59 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
1080 "Creating CMPI Provider Module %s",
1081 (const char*)moduleFileName.getCString()));
|
1082 r.kieninger 1.14
|
1083 venkat.puvvada 1.48 module = new CMPIProviderModule (moduleFileName);
|
1084 r.kieninger 1.14
|
1085 venkat.puvvada 1.48 // insert provider module in module table
1086 _modules.insert (moduleFileName, module);
|
1087 r.kieninger 1.14 }
|
1088 dj.gorey 1.6
|
1089 venkat.puvvada 1.48 PEG_METHOD_EXIT ();
1090 return(module);
|
1091 schuur 1.1 }
1092
1093 PEGASUS_NAMESPACE_END
|
1094 kumpf 1.62
|
Return to
CMPILocalProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI