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