1 chip 1.1 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // of this software and associated documentation files (the "Software"), to
8 // deal in the Software without restriction, including without limitation the
9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 // sell copies of the Software, and to permit persons to whom the Software is
11 // furnished to do so, subject to the following conditions:
12 //
13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 //
22 chip 1.1 //==============================================================================
23 //
24 // Author: Chip Vincent (cvincent@us.ibm.com)
25 //
26 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
27 // (carolann_graves@hp.com)
28 // Mike Day, IBM (mdday@us.ibm.com)
29 // Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators.
|
30 chip 1.9 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
|
31 chip 1.1 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include "ProviderManagerService.h"
35
36 #include <Pegasus/Common/Config.h>
37 #include <Pegasus/Common/Constants.h>
38 #include <Pegasus/Common/CIMMessage.h>
39 #include <Pegasus/Common/Tracer.h>
40 #include <Pegasus/Common/Logger.h>
41 #include <Pegasus/Common/Destroyer.h>
42
|
43 chip 1.6 #include <Pegasus/Config/ConfigManager.h>
44
|
45 chip 1.1 PEGASUS_NAMESPACE_BEGIN
46
|
47 chip 1.13 // BEGIN TEMP SECTION
|
48 chip 1.11 class ProviderManagerContainer
|
49 chip 1.5 {
|
50 chip 1.11 public:
|
51 chip 1.13 ProviderManagerContainer(const String & physicalName, const String & logicalName, const String & interfaceName)
|
52 chip 1.11 {
53 #if defined(PEGASUS_OS_TYPE_WINDOWS)
54 _physicalName = physicalName + String(".dll");
55 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
56 _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
57 _physicalName.append(String("/lib") + physical + String(".sl"));
58 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
59 _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
60 _physicalName.append(String("/lib") + physical + String(".so"));
61 #elif defined(PEGASUS_OS_OS400)
62 _physicalName = physicalName;
63 #else
64 _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
65 _physicalName.append(String("/lib") + physical + String(".so"));
66 #endif
|
67 chip 1.3
|
68 chip 1.11 _logicalName = logicalName;
69
70 _interfaceName = interfaceName;
|
71 chip 1.13
72 _module = ProviderManagerModule(_physicalName);
73
74 _module.load();
75
76 _manager = _module.getProviderManager(_logicalName);
|
77 chip 1.11 }
78
|
79 chip 1.13 ~ProviderManagerContainer(void)
80 {
81 _module.unload();
82 }
83
84 ProviderManager & getProviderManager(void)
85 {
86 return(*_manager);
87 }
88
89 String & getPhysicalName(void)
|
90 chip 1.3 {
|
91 chip 1.11 return(_physicalName);
|
92 chip 1.3 }
93
|
94 chip 1.13 String & getLogicalName(void)
|
95 chip 1.11 {
96 return(_logicalName);
97 }
|
98 chip 1.3
|
99 chip 1.13 String & getInterfaceName(void)
|
100 chip 1.11 {
101 return(_interfaceName);
|
102 chip 1.3 }
103
|
104 chip 1.11 private:
105 String _physicalName;
106 String _logicalName;
107 String _interfaceName;
|
108 chip 1.3
|
109 chip 1.13 ProviderManagerModule _module;
110 ProviderManager * _manager;
111
|
112 chip 1.11 };
|
113 chip 1.13
114 static Array<ProviderManagerContainer> _providerManagers;
|
115 chip 1.11 // END TEMP SECTION
116
117 inline Boolean _isSupportedRequestType(const Message * message)
118 {
119 // ATTN: needs implementation
120
121 // for now, assume all requests are valid
122
123 return(true);
|
124 chip 1.3 }
125
126 inline Boolean _isSupportedResponseType(const Message * message)
127 {
|
128 chip 1.11 // ATTN: needs implementation
129
130 // for now, assume all responses are invalid
|
131 chip 1.3
|
132 chip 1.11 return(false);
|
133 chip 1.3 }
134
|
135 chip 1.1 ProviderManagerService::ProviderManagerService(void)
136 : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
137 {
138 }
139
140 ProviderManagerService::ProviderManagerService(ProviderRegistrationManager * providerRegistrationManager)
141 : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
142 {
|
143 chip 1.10 SetProviderRegistrationManager(providerRegistrationManager);
144
|
145 chip 1.11 // ATTN: this section is a temporary solution to populate the list of enabled
146 // provider managers for a given distribution. it includes another temporary
147 // solution for converting a generic file name into a file name useable by
148 // each platform.
149
150 // BEGIN TEMP SECTION
151 //#if defined(PEGASUS_OS_OS400)
|
152 chip 1.13 //_providerManagers.append(ProviderManagerContainer("QSYS/??????????", "INTERNAL", "INTERNAL"));
|
153 chip 1.11 //#else
|
154 chip 1.13 //_providerManager.append(ProviderManagerContainer("InternalProviderManager", "DEFAULT", "INTERNAL"));
|
155 chip 1.11 //#endif
|
156 chip 1.2
|
157 chip 1.11 #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
158 #if defined(PEGASUS_OS_OS400)
|
159 chip 1.13 _providerManagers.append(ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));
|
160 chip 1.11 #else
|
161 chip 1.13 _providerManagers.append(ProviderManagerContainer("DefaultProviderManager", "DEFAULT", "C++Default"));
|
162 chip 1.11 #endif
163 #endif
|
164 chip 1.2
|
165 chip 1.11 #if defined(ENABLE_CMPI_PROVIDER_MANAGER)
166 #if defined(PEGASUS_OS_OS400)
|
167 chip 1.13 _providerManagers.append(ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));
|
168 chip 1.11 #else
|
169 chip 1.13 _providerManagers.append(ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));
|
170 chip 1.11 #endif
171 #endif
172 // END TEMP SECTION
|
173 chip 1.1 }
174
175 ProviderManagerService::~ProviderManagerService(void)
176 {
177 }
178
179 Boolean ProviderManagerService::messageOK(const Message * message)
180 {
181 PEGASUS_ASSERT(message != 0);
182
|
183 chip 1.3 if(_isSupportedRequestType(message))
|
184 chip 1.1 {
|
185 chip 1.3 return(MessageQueueService::messageOK(message));
|
186 chip 1.1 }
187
|
188 chip 1.3 return(false);
|
189 chip 1.1 }
190
191 void ProviderManagerService::handleEnqueue(void)
192 {
193 Message * message = dequeue();
194
195 handleEnqueue(message);
196 }
197
198 void ProviderManagerService::handleEnqueue(Message * message)
199 {
200 PEGASUS_ASSERT(message != 0);
201
202 AsyncLegacyOperationStart * asyncRequest;
203
204 if(message->_async != NULL)
205 {
206 asyncRequest = static_cast<AsyncLegacyOperationStart *>(message->_async);
207 }
208 else
209 {
210 chip 1.1 asyncRequest = new AsyncLegacyOperationStart(
211 get_next_xid(),
212 0,
213 this->getQueueId(),
214 message,
215 this->getQueueId());
216 }
217
218 _handle_async_request(asyncRequest);
219 }
220
221 void ProviderManagerService::_handle_async_request(AsyncRequest * request)
222 {
223 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
224 "ProviderManagerService::_handle_async_request");
225
226 PEGASUS_ASSERT((request != 0) && (request->op != 0));
227
228 if(request->getType() == async_messages::ASYNC_LEGACY_OP_START)
229 {
230 request->op->processing();
231 chip 1.1
232 _incomingQueue.enqueue(request->op);
233
234 _thread_pool->allocate_and_awaken((void *)this, ProviderManagerService::handleCimOperation);
235 }
236 else
237 {
238 // pass all other operations to the default handler
239 MessageQueueService::_handle_async_request(request);
240 }
241
242 PEG_METHOD_EXIT();
243
244 return;
245 }
246
247 /*
248 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleServiceOperation(void * arg) throw()
249 {
250 // get the service from argument
251 ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);
252 chip 1.1
253 PEGASUS_ASSERT(service != 0);
254
255 // get message from service queue
256 Message * message = service->_incomingQueue.dequeue();
257
258 PEGASUS_ASSERT(message != 0);
259
260 if(service->_incomingQueue.size() == 0)
261 {
262 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
263 "ProviderManagerService::handleCimOperation() called with no op node in queue" );
264
265 PEG_METHOD_EXIT();
266
267 // thread started with no message in queue.
268 return(PEGASUS_THREAD_RETURN(1));
269 }
270
271 AsyncOpNode * op = service->_incomingQueue.dequeue();
272
273 chip 1.1 PEGASUS_ASSERT(op != 0 );
274
275 if(op->_request.count() == 0)
276 {
277 MessageQueue * queue = MessageQueue::lookup(op->_source_queue);
278
279 PEGASUS_ASSERT(queue != 0);
280
281 PEG_METHOD_EXIT();
282
283 // no request in op node
284 return(PEGASUS_THREAD_RETURN(1));
285 }
286
287 return(0);
288 }
289 */
290
291 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleCimOperation(void * arg) throw()
292 {
293 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimOperation");
294 chip 1.1
|
295 chip 1.8 if(arg == 0)
296 {
297 // thread started with invalid argument.
298 return(PEGASUS_THREAD_RETURN(1));
299 }
300
|
301 chip 1.1 // get the service from argument
302 ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);
303
304 if(service->_incomingQueue.size() == 0)
305 {
306 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
307 "ProviderManagerService::handleCimOperation() called with no op node in queue" );
308
309 PEG_METHOD_EXIT();
310
311 // thread started with no message in queue.
312 return(PEGASUS_THREAD_RETURN(1));
313 }
314
315 AsyncOpNode * op = service->_incomingQueue.dequeue();
316
|
317 chip 1.8 if((op == 0) || (op->_request.count() == 0))
|
318 chip 1.1 {
319 MessageQueue * queue = MessageQueue::lookup(op->_source_queue);
320
321 PEGASUS_ASSERT(queue != 0);
322
323 PEG_METHOD_EXIT();
324
325 // no request in op node
326 return(PEGASUS_THREAD_RETURN(1));
327 }
328
329 AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));
330
|
331 chip 1.8 if((request == 0) || (request->getType() != async_messages::ASYNC_LEGACY_OP_START))
|
332 chip 1.1 {
333 // reply with NAK
334
335 PEG_METHOD_EXIT();
336
337 return(PEGASUS_THREAD_RETURN(0));
338 }
339
|
340 chip 1.8 try
|
341 chip 1.1 {
|
342 chip 1.8 Message * legacy = static_cast<AsyncLegacyOperationStart *>(request)->get_action();
|
343 chip 1.1
|
344 chip 1.8 if(_isSupportedRequestType(legacy))
|
345 chip 1.1 {
|
346 chip 1.8 Destroyer<Message> xmessage(legacy);
|
347 chip 1.1
|
348 chip 1.8 // Set the client's requested language into this service thread.
349 // This will allow functions in this service to return messages
350 // in the correct language.
351 CIMMessage * msg = dynamic_cast<CIMMessage *>(legacy);
352
353 if(msg != 0)
354 {
355 AcceptLanguages * langs = new AcceptLanguages(msg->acceptLanguages);
356
357 Thread::setLanguages(langs);
358 }
359 else
360 {
361 Thread::clearLanguages();
362 }
|
363 chip 1.1
364 service->handleCimRequest(op, legacy);
|
365 chip 1.3 }
|
366 chip 1.8 }
367 catch(...)
368 {
369 // ATTN: log error
|
370 chip 1.1 }
371
372 PEG_METHOD_EXIT();
373
374 return(PEGASUS_THREAD_RETURN(0));
375 }
376
|
377 chip 1.8 void ProviderManagerService::handleCimRequest(AsyncOpNode * op, const Message * message)
|
378 chip 1.1 {
379 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimRequest");
380
381 // ATTN: ensure message is a request???
382 CIMMessage * request = dynamic_cast<CIMMessage *>(const_cast<Message *>(message));
383
384 // get request from op node
385 AsyncRequest * async = static_cast<AsyncRequest *>(op->_request.next(0));
386
387 PEGASUS_ASSERT((request != 0) && (async != 0));
388
389 Message * response = 0;
390
|
391 chip 1.11 // get namespace and class name from message
|
392 chip 1.13 String nameSpace;
393 String className;
394
395 switch(message->getType())
396 {
397 case CIM_GET_CLASS_REQUEST_MESSAGE:
398 {
399 const CIMGetClassRequestMessage * p = dynamic_cast<const CIMGetClassRequestMessage *>(message);
400
401 PEGASUS_ASSERT(p != 0);
402
403 nameSpace = p->nameSpace.getString();
404 className = p->className.getString();
405 }
406
407 break;
408 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
409 {
410 const CIMEnumerateClassesRequestMessage * p = dynamic_cast<const CIMEnumerateClassesRequestMessage *>(message);
411
412 PEGASUS_ASSERT(p != 0);
413 chip 1.13
414 nameSpace = p->nameSpace.getString();
415 className = p->className.getString();
416 }
417
418 break;
419 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
420 {
421 const CIMEnumerateClassNamesRequestMessage * p = dynamic_cast<const CIMEnumerateClassNamesRequestMessage *>(message);
422
423 PEGASUS_ASSERT(p != 0);
424
425 nameSpace = p->nameSpace.getString();
426 className = p->className.getString();
427 }
428
429 break;
430 case CIM_CREATE_CLASS_REQUEST_MESSAGE:
431 {
432 const CIMCreateClassRequestMessage * p = dynamic_cast<const CIMCreateClassRequestMessage *>(message);
433
434 chip 1.13 PEGASUS_ASSERT(p != 0);
435
436 nameSpace = p->nameSpace.getString();
437 //className = p->className.getString();
438 }
439
440 break;
441 case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
442 {
443 const CIMModifyClassRequestMessage * p = dynamic_cast<const CIMModifyClassRequestMessage *>(message);
444
445 PEGASUS_ASSERT(p != 0);
446
447 nameSpace = p->nameSpace.getString();
448 //className = p->className.getString();
449 }
450
451 break;
452 case CIM_DELETE_CLASS_REQUEST_MESSAGE:
453 {
454 const CIMDeleteClassRequestMessage * p = dynamic_cast<const CIMDeleteClassRequestMessage *>(message);
455 chip 1.13
456 PEGASUS_ASSERT(p != 0);
|
457 chip 1.11
|
458 chip 1.13 nameSpace = p->nameSpace.getString();
459 className = p->className.getString();
460 }
461
462 break;
463 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
464 {
465 const CIMGetInstanceRequestMessage * p = dynamic_cast<const CIMGetInstanceRequestMessage *>(message);
466
467 PEGASUS_ASSERT(p != 0);
468
469 nameSpace = p->nameSpace.getString();
470 //className = p->className.getString();
471 }
472
473 break;
474 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
475 {
476 const CIMEnumerateInstancesRequestMessage * p = dynamic_cast<const CIMEnumerateInstancesRequestMessage *>(message);
477
478 PEGASUS_ASSERT(p != 0);
479 chip 1.13
480 nameSpace = p->nameSpace.getString();
481 className = p->className.getString();
482 }
483
484 break;
485 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
486 {
487 const CIMEnumerateInstanceNamesRequestMessage * p = dynamic_cast<const CIMEnumerateInstanceNamesRequestMessage *>(message);
488
489 PEGASUS_ASSERT(p != 0);
490
491 nameSpace = p->nameSpace.getString();
492 className = p->className.getString();
493 }
494
495 break;
496 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
497 {
498 const CIMCreateInstanceRequestMessage * p = dynamic_cast<const CIMCreateInstanceRequestMessage *>(message);
499
500 chip 1.13 PEGASUS_ASSERT(p != 0);
501
502 nameSpace = p->nameSpace.getString();
503 //className = p->className.getString();
504 }
505
506 break;
507 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
508 {
509 const CIMModifyInstanceRequestMessage * p = dynamic_cast<const CIMModifyInstanceRequestMessage *>(message);
510
511 PEGASUS_ASSERT(p != 0);
512
513 nameSpace = p->nameSpace.getString();
514 //className = p->className.getString();
515 }
516
517 break;
518 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
519 {
520 const CIMDeleteInstanceRequestMessage * p = dynamic_cast<const CIMDeleteInstanceRequestMessage *>(message);
521 chip 1.13
522 PEGASUS_ASSERT(p != 0);
523
524 nameSpace = p->nameSpace.getString();
525 //className = p->className.getString();
526 }
527
528 break;
529 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
530 break;
531 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
532 {
533 const CIMAssociatorsRequestMessage * p = dynamic_cast<const CIMAssociatorsRequestMessage *>(message);
534
535 PEGASUS_ASSERT(p != 0);
536
537 nameSpace = p->nameSpace.getString();
538 //className = p->className.getString();
539 }
540
541 break;
542 chip 1.13 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
543 {
544 const CIMAssociatorNamesRequestMessage * p = dynamic_cast<const CIMAssociatorNamesRequestMessage *>(message);
545
546 PEGASUS_ASSERT(p != 0);
547
548 nameSpace = p->nameSpace.getString();
549 //className = p->className.getString();
550 }
551
552 break;
553 case CIM_REFERENCES_REQUEST_MESSAGE:
554 {
555 const CIMReferencesRequestMessage * p = dynamic_cast<const CIMReferencesRequestMessage *>(message);
556
557 PEGASUS_ASSERT(p != 0);
558
559 nameSpace = p->nameSpace.getString();
560 //className = p->className.getString();
561 }
562
563 chip 1.13 break;
564 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
565 {
566 const CIMReferenceNamesRequestMessage * p = dynamic_cast<const CIMReferenceNamesRequestMessage *>(message);
567
568 PEGASUS_ASSERT(p != 0);
569
570 nameSpace = p->nameSpace.getString();
571 //className = p->className.getString();
572 }
573
574 break;
575 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
576 {
577 const CIMGetPropertyRequestMessage * p = dynamic_cast<const CIMGetPropertyRequestMessage *>(message);
578
579 PEGASUS_ASSERT(p != 0);
580
581 nameSpace = p->nameSpace.getString();
582 //className = p->className.getString();
583 }
584 chip 1.13
585 break;
586 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
587 {
588 const CIMSetPropertyRequestMessage * p = dynamic_cast<const CIMSetPropertyRequestMessage *>(message);
589
590 PEGASUS_ASSERT(p != 0);
591
592 nameSpace = p->nameSpace.getString();
593 //className = p->className.getString();
594 }
595
596 break;
597 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
598 {
599 const CIMInvokeMethodRequestMessage * p = dynamic_cast<const CIMInvokeMethodRequestMessage *>(message);
600
601 PEGASUS_ASSERT(p != 0);
602
603 nameSpace = p->nameSpace.getString();
604 //className = p->className.getString();
605 chip 1.13 }
606
607 break;
|
608 chip 1.12 /*
|
609 chip 1.13 case CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:
610 {
611 const CIMEnableIndicationsSubscriptionRequestMessage * p = dynamic_cast<const CIMEnableIndicationsRequestMessage *>(message);
612
613 PEGASUS_ASSERT(p != 0);
614
615 nameSpace = p->nameSpace.getString();
616 className = p->className.getString();
617 }
618
619 break;
620 case CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:
621 {
622 const CIMModifyIndicationsRequestMessage * p = dynamic_cast<const CIMModifyIndicationsRequestMessage *>(message);
623
624 PEGASUS_ASSERT(p != 0);
625
626 nameSpace = p->nameSpace.getString();
627 className = p->className.getString();
628 }
629
630 chip 1.13 break;
631 case CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:
632 {
633 const CIMGetClassRequestMessage * p = dynamic_cast<const CIMGetClassRequestMessage *>(message);
634
635 PEGASUS_ASSERT(p != 0);
636
637 nameSpace = p->nameSpace.getString();
638 className = p->className.getString();
639 }
640
641 break;
642 */
643 default:
644 break;
645 }
646
|
647 chip 1.11 ProviderName name(
|
648 chip 1.13 CIMObjectPath(String::EMPTY, nameSpace, className).toString(),
|
649 chip 1.11 String::EMPTY,
650 String::EMPTY,
651 String::EMPTY,
652 0);
653
|
654 chip 1.1 // find provider manager
|
655 chip 1.13 name = ProviderRegistrar().findProvider(name);
|
656 chip 1.11
657 // find provider manager for provider interface
|
658 chip 1.14 for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)
659 {
660 if(String::equalNoCase(name.getInterfaceName(), _providerManagers[i].getInterfaceName()))
661 {
662 try
663 {
664 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
665 "ProviderManagerService::handleCimRequest() passing control to provider manager.");
|
666 chip 1.13
|
667 chip 1.14 // forward request
668 response = _providerManagers[0].getProviderManager().processMessage(request);
669 }
670 catch(...)
671 {
672 // ATTN: create response with error message
673 }
|
674 chip 1.1
|
675 chip 1.14 break;
676 }
|
677 chip 1.1 }
678
679 // preserve message key
680 response->setKey(request->getKey());
681
682 // set HTTP method in response from request
683 response->setHttpMethod(request->getHttpMethod());
684
685 AsyncLegacyOperationResult * async_result =
686 new AsyncLegacyOperationResult(
|
687 chip 1.9 async->getKey(),
688 async->getRouting(),
689 op,
690 response);
|
691 chip 1.1
692 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
693
694 PEG_METHOD_EXIT();
695 }
696
697 void ProviderManagerService::unload_idle_providers(void)
698 {
699 }
700
701 PEGASUS_NAMESPACE_END
|
702 chip 1.9
|
Return to
ProviderManagerService.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2