1 karl 1.7 //%2003////////////////////////////////////////////////////////////////////////
|
2 chip 1.1 //
|
3 karl 1.7 // 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 schuur 1.19 //
|
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 kumpf 1.28 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
|
33 kumpf 1.31 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
34 chip 1.1 //
35 //%/////////////////////////////////////////////////////////////////////////////
36
37 #include "DefaultProviderManager.h"
38
39 #include <Pegasus/Common/CIMMessage.h>
40 #include <Pegasus/Common/OperationContext.h>
41 #include <Pegasus/Common/Destroyer.h>
42 #include <Pegasus/Common/Tracer.h>
43 #include <Pegasus/Common/StatisticalData.h>
44 #include <Pegasus/Common/Logger.h>
45 #include <Pegasus/Common/MessageLoader.h> //l10n
46
|
47 schuur 1.12 #include <Pegasus/Common/QueryExpression.h>
48 #include <Pegasus/ProviderManager2/QueryExpressionFactory.h>
49
|
50 chip 1.1 #include <Pegasus/ProviderManager2/Default/Provider.h>
|
51 schuur 1.21 #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
|
52 chip 1.1
|
53 schuur 1.14 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
|
54 kumpf 1.28 #include <Pegasus/ProviderManager2/ProviderType.h>
|
55 chip 1.1
56 PEGASUS_NAMESPACE_BEGIN
57
58 // auto variable to protect provider during operations
59 class pm_service_op_lock
60 {
61 private:
62 pm_service_op_lock(void);
63
64 public:
65 pm_service_op_lock(Provider *provider) : _provider(provider)
66 {
67 _provider->protect();
68 }
69
70 ~pm_service_op_lock(void)
71 {
72 _provider->unprotect();
73 }
74
75 Provider * _provider;
76 chip 1.1 };
77
78 //
79 // Provider module status
80 //
81 static const Uint16 _MODULE_OK = 2;
82 static const Uint16 _MODULE_STOPPING = 9;
83 static const Uint16 _MODULE_STOPPED = 10;
84
85
|
86 kumpf 1.31 //
87 // Default Provider Manager
88 //
|
89 chip 1.1 DefaultProviderManager::DefaultProviderManager(void)
90 {
91 }
92
93 DefaultProviderManager::~DefaultProviderManager(void)
94 {
95 }
96
|
97 dj.gorey 1.25 Message * DefaultProviderManager::processMessage(Message * request)
|
98 chip 1.1 {
99 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
100 "DefaultProviderManager::processMessage()");
101
102 Message * response = 0;
103
104 // pass the request message to a handler method based on message type
105 switch(request->getType())
106 {
107 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
|
108 dj.gorey 1.25 response = handleGetInstanceRequest(request);
|
109 chip 1.1
110 break;
111 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
|
112 dj.gorey 1.25 response = handleEnumerateInstancesRequest(request);
|
113 chip 1.1
114 break;
115 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
|
116 dj.gorey 1.25 response = handleEnumerateInstanceNamesRequest(request);
|
117 chip 1.1
118 break;
119 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
|
120 dj.gorey 1.25 response = handleCreateInstanceRequest(request);
|
121 chip 1.1
122 break;
123 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
|
124 dj.gorey 1.25 response = handleModifyInstanceRequest(request);
|
125 chip 1.1
126 break;
127 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
|
128 dj.gorey 1.25 response = handleDeleteInstanceRequest(request);
|
129 chip 1.1
130 break;
131 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
|
132 dj.gorey 1.25 response = handleExecQueryRequest(request);
|
133 chip 1.1
134 break;
135 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
|
136 dj.gorey 1.25 response = handleAssociatorsRequest(request);
|
137 chip 1.1
138 break;
139 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
|
140 dj.gorey 1.25 response = handleAssociatorNamesRequest(request);
|
141 chip 1.1
142 break;
143 case CIM_REFERENCES_REQUEST_MESSAGE:
|
144 dj.gorey 1.25 response = handleReferencesRequest(request);
|
145 chip 1.1
146 break;
147 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
|
148 dj.gorey 1.25 response = handleReferenceNamesRequest(request);
|
149 chip 1.1
150 break;
151 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
|
152 dj.gorey 1.25 response = handleGetPropertyRequest(request);
|
153 chip 1.1
154 break;
155 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
|
156 dj.gorey 1.25 response = handleSetPropertyRequest(request);
|
157 chip 1.1
158 break;
159 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
160 dj.gorey 1.25 response = handleInvokeMethodRequest(request);
|
161 chip 1.1
162 break;
163 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
164 dj.gorey 1.25 response = handleCreateSubscriptionRequest(request);
|
165 chip 1.1
166 break;
167 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
168 dj.gorey 1.25 response = handleModifySubscriptionRequest(request);
|
169 chip 1.1
170 break;
171 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
|
172 dj.gorey 1.25 response = handleDeleteSubscriptionRequest(request);
|
173 chip 1.1
174 break;
175 case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:
|
176 dj.gorey 1.25 response = handleEnableIndicationsRequest(request);
|
177 chip 1.1
178 break;
179 case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:
|
180 dj.gorey 1.25 response = handleDisableIndicationsRequest(request);
|
181 chip 1.1
182 break;
|
183 schuur 1.14 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
184 dj.gorey 1.25 response = handleExportIndicationRequest(request);
|
185 schuur 1.14 break;
186
|
187 chip 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
|
188 dj.gorey 1.25 response = handleDisableModuleRequest(request);
|
189 chip 1.1
190 break;
191 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
|
192 dj.gorey 1.25 response = handleEnableModuleRequest(request);
|
193 chip 1.1
194 break;
195 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
|
196 dj.gorey 1.25 response = handleStopAllProvidersRequest(request);
|
197 chip 1.1
198 break;
|
199 kumpf 1.30 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
200 response = handleInitializeProviderRequest(request);
201
202 break;
|
203 chip 1.1 default:
|
204 dj.gorey 1.25 response = handleUnsupportedRequest(request);
|
205 chip 1.1
206 break;
207 }
208
209 PEG_METHOD_EXIT();
210
211 return(response);
212 }
213
|
214 dj.gorey 1.25 Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message)
|
215 chip 1.1 {
216 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");
217
218 PEG_METHOD_EXIT();
219
220 // a null response implies unsupported or unknown operation
221 return(0);
222 }
223
|
224 kumpf 1.30 Message * DefaultProviderManager::handleInitializeProviderRequest(
225 const Message * message)
226 {
227 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
228 "DefaultProviderManager::handleInitializeProviderRequest");
229
230 CIMInitializeProviderRequestMessage * request =
231 dynamic_cast<CIMInitializeProviderRequestMessage *>
232 (const_cast<Message *>(message));
233
234 PEGASUS_ASSERT(request != 0);
235
236 CIMInitializeProviderResponseMessage * response =
237 new CIMInitializeProviderResponseMessage(
238 request->messageId,
239 CIMException(),
240 request->queueIds.copyAndPop());
241
242 // preserve message key
243 response->setKey(request->getKey());
244
245 kumpf 1.30 // Set HTTP method in response from request
246 response->setHttpMethod(request->getHttpMethod());
247
248 OperationResponseHandler handler(request, response);
249
250 try
251 {
252 // resolve provider name
253 ProviderName name = _resolveProviderName(
254 request->operationContext.get(ProviderIdContainer::NAME));
255
256 // get cached or load new provider module
257 OpProviderHolder ph =
258 providerManager.getProvider(name.getPhysicalName(),
259 name.getLogicalName(), String::EMPTY);
260
261 }
262 catch(CIMException & e)
263 {
264 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
265 "CIMException: " + e.getMessage());
266 kumpf 1.30
267 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage());
268 }
269 catch(Exception & e)
270 {
271 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
272 "Exception: " + e.getMessage());
273
274 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage());
275 }
276 catch(...)
277 {
278 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
279 "Exception: Unknown");
280
281 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
282 }
283
284 PEG_METHOD_EXIT();
285
286 return(response);
287 kumpf 1.30 }
288
|
289 dj.gorey 1.25 Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message)
|
290 chip 1.1 {
291 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");
292
293 CIMGetInstanceRequestMessage * request =
294 dynamic_cast<CIMGetInstanceRequestMessage *>(const_cast<Message *>(message));
295
296 PEGASUS_ASSERT(request != 0);
297
298 CIMGetInstanceResponseMessage * response =
299 new CIMGetInstanceResponseMessage(
300 request->messageId,
301 CIMException(),
302 request->queueIds.copyAndPop(),
303 CIMInstance());
304
305 PEGASUS_ASSERT(response != 0);
306
307 // preserve message key
308 response->setKey(request->getKey());
309
310 // Set HTTP method in response from request
311 chip 1.1 response->setHttpMethod(request->getHttpMethod());
312
313 // create a handler for this request
314 GetInstanceResponseHandler handler(request, response);
315
316 try
317 {
318 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
319 "DefaultProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
320 System::getHostName(),
321 request->nameSpace.getString(),
322 request->instanceName.getClassName().getString());
323
324 // make target object path
325 CIMObjectPath objectPath(
326 System::getHostName(),
327 request->nameSpace,
328 request->instanceName.getClassName(),
329 request->instanceName.getKeyBindings());
330
|
331 chip 1.5 // resolve provider name
|
332 kumpf 1.28 ProviderName name = _resolveProviderName(
333 request->operationContext.get(ProviderIdContainer::NAME));
|
334 chip 1.1
335 // get cached or load new provider module
336 OpProviderHolder ph =
|
337 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
338 chip 1.1
339 // convert arguments
340 OperationContext context;
341
342 context.insert(IdentityContainer(request->userName));
343 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
344 context.insert(ContentLanguageListContainer(request->contentLanguages));
345
346 CIMPropertyList propertyList(request->propertyList);
347
348 // forward request
349 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
350 "Calling provider.getInstance: " +
351 ph.GetProvider().getName());
352
353 pm_service_op_lock op_lock(&ph.GetProvider());
354
355 STAT_GETSTARTTIME;
356
357 ph.GetProvider().getInstance(
358 context,
359 chip 1.1 objectPath,
360 request->includeQualifiers,
361 request->includeClassOrigin,
362 propertyList,
363 handler);
364
365 STAT_PMS_PROVIDEREND;
366 }
367 catch(CIMException & e)
368 {
369 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
370 "Exception: " + e.getMessage());
371
372 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
373 }
374 catch(Exception & e)
375 {
376 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
377 "Exception: " + e.getMessage());
|
378 chip 1.2
|
379 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
380 }
381 catch(...)
382 {
383 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
384 "Exception: Unknown");
|
385 chip 1.2
|
386 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
387 }
388
389 PEG_METHOD_EXIT();
390
391 return(response);
392 }
393
|
394 dj.gorey 1.25 Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message)
|
395 chip 1.1 {
396 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");
397
398 CIMEnumerateInstancesRequestMessage * request =
399 dynamic_cast<CIMEnumerateInstancesRequestMessage *>(const_cast<Message *>(message));
400
401 PEGASUS_ASSERT(request != 0);
402
403 CIMEnumerateInstancesResponseMessage * response =
404 new CIMEnumerateInstancesResponseMessage(
405 request->messageId,
406 CIMException(),
407 request->queueIds.copyAndPop(),
408 Array<CIMInstance>());
409
410 PEGASUS_ASSERT(response != 0);
411
412 // preserve message key
413 response->setKey(request->getKey());
414
415 // Set HTTP method in response from request
416 chip 1.1 response->setHttpMethod (request->getHttpMethod ());
417
418 // create a handler for this request
419 EnumerateInstancesResponseHandler handler(request, response);
420
421 try
422 {
423 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
424 "DefaultProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
425 System::getHostName(),
426 request->nameSpace.getString(),
427 request->className.getString());
428
429 // make target object path
430 CIMObjectPath objectPath(
431 System::getHostName(),
432 request->nameSpace,
433 request->className);
434
|
435 chip 1.5 // resolve provider name
|
436 kumpf 1.28 ProviderName name = _resolveProviderName(
437 request->operationContext.get(ProviderIdContainer::NAME));
|
438 chip 1.1
439 // get cached or load new provider module
|
440 schuur 1.12 OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),
|
441 dj.gorey 1.25 name.getLogicalName(), String::EMPTY);
|
442 chip 1.1
443 // convert arguments
444 OperationContext context;
445
446 context.insert(IdentityContainer(request->userName));
447 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
448 context.insert(ContentLanguageListContainer(request->contentLanguages));
449
450 CIMPropertyList propertyList(request->propertyList);
451
452 // forward request
453 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
454 "Calling provider.enumerateInstances: " +
455 ph.GetProvider().getName());
456
457 pm_service_op_lock op_lock(&ph.GetProvider());
458
459 STAT_GETSTARTTIME;
460
461 ph.GetProvider().enumerateInstances(
462 context,
463 chip 1.1 objectPath,
464 request->includeQualifiers,
465 request->includeClassOrigin,
466 propertyList,
467 handler);
468
469 STAT_PMS_PROVIDEREND;
470 }
471 catch(CIMException & e)
472 {
473 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
474 "Exception: " + e.getMessage());
|
475 chip 1.2
|
476 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
477 }
478 catch(Exception & e)
479 {
480 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
481 "Exception: " + e.getMessage());
|
482 chip 1.2
|
483 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
484 }
485 catch(...)
486 {
487 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
488 "Exception: Unknown");
|
489 chip 1.2
|
490 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
491 }
492
493 PEG_METHOD_EXIT();
494
495 return(response);
496 }
497
|
498 dj.gorey 1.25 Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message)
|
499 chip 1.1 {
500 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");
501
502 CIMEnumerateInstanceNamesRequestMessage * request =
503 dynamic_cast<CIMEnumerateInstanceNamesRequestMessage *>(const_cast<Message *>(message));
504
505 PEGASUS_ASSERT(request != 0);
506
507 CIMEnumerateInstanceNamesResponseMessage * response =
508 new CIMEnumerateInstanceNamesResponseMessage(
509 request->messageId,
510 CIMException(),
511 request->queueIds.copyAndPop(),
512 Array<CIMObjectPath>());
513
514 PEGASUS_ASSERT(response != 0);
515
516 // preserve message key
517 response->setKey(request->getKey());
518
519 //set HTTP method in response from request
520 chip 1.1 response->setHttpMethod(request->getHttpMethod());;
521
522 // create a handler for this request
523 EnumerateInstanceNamesResponseHandler handler(request, response);
524
525 // process the request
526 try
527 {
528 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
529 "DefaultProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
530 System::getHostName(),
531 request->nameSpace.getString(),
532 request->className.getString());
533
534 // make target object path
535 CIMObjectPath objectPath(
536 System::getHostName(),
537 request->nameSpace,
538 request->className);
539
|
540 chip 1.5 // resolve provider name
|
541 kumpf 1.28 ProviderName name = _resolveProviderName(
542 request->operationContext.get(ProviderIdContainer::NAME));
|
543 chip 1.1
544 // get cached or load new provider module
545 OpProviderHolder ph =
|
546 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
|
547 chip 1.1
548 // convert arguments
549 OperationContext context;
550
551 context.insert(IdentityContainer(request->userName));
552 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
553 context.insert(ContentLanguageListContainer(request->contentLanguages));
554
555 // forward request
556 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
557 "Calling provider.enumerateInstanceNames: " +
558 ph.GetProvider().getName());
559
560 pm_service_op_lock op_lock(&ph.GetProvider());
561
562 STAT_GETSTARTTIME;
563
564 ph.GetProvider().enumerateInstanceNames(
565 context,
566 objectPath,
567 handler);
568 chip 1.1
569 STAT_PMS_PROVIDEREND;
570 }
571 catch(CIMException & e)
572 {
573 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
574 "Exception: " + e.getMessage());
|
575 chip 1.2
|
576 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
577 }
578 catch(Exception & e)
579 {
580 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
581 "Exception: " + e.getMessage());
|
582 chip 1.2
|
583 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
584 }
585 catch(...)
586 {
587 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
588 "Exception: Unknown");
|
589 chip 1.2
|
590 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
591 }
592
593 PEG_METHOD_EXIT();
594
595 return(response);
596 }
597
|
598 dj.gorey 1.25 Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message)
|
599 chip 1.1 {
600 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");
601
602 CIMCreateInstanceRequestMessage * request =
603 dynamic_cast<CIMCreateInstanceRequestMessage *>(const_cast<Message *>(message));
604
605 PEGASUS_ASSERT(request != 0);
606
607 // create response message
608 CIMCreateInstanceResponseMessage * response =
609 new CIMCreateInstanceResponseMessage(
610 request->messageId,
611 CIMException(),
612 request->queueIds.copyAndPop(),
613 CIMObjectPath());
614
615 PEGASUS_ASSERT(response != 0);
616
617 // preserve message key
618 response->setKey(request->getKey());
619
620 chip 1.1 // Set HTTP method in response from request
621 response->setHttpMethod (request->getHttpMethod ());
622
623 // create a handler for this request
624 CreateInstanceResponseHandler handler(request, response);
625
626 try
627 {
628 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
629 "DefaultProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
630 System::getHostName(),
631 request->nameSpace.getString(),
632 request->newInstance.getPath().getClassName().getString());
633
634 // make target object path
635 CIMObjectPath objectPath(
636 System::getHostName(),
637 request->nameSpace,
638 request->newInstance.getPath().getClassName(),
639 request->newInstance.getPath().getKeyBindings());
640
|
641 chip 1.5 // resolve provider name
|
642 kumpf 1.28 ProviderName name = _resolveProviderName(
643 request->operationContext.get(ProviderIdContainer::NAME));
|
644 chip 1.1
645 // get cached or load new provider module
646 OpProviderHolder ph =
|
647 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
648 chip 1.1
649 // convert arguments
650 OperationContext context;
651
652 context.insert(IdentityContainer(request->userName));
653 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
654 context.insert(ContentLanguageListContainer(request->contentLanguages));
655
656 // forward request
657 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
658 "Calling provider.createInstance: " +
659 ph.GetProvider().getName());
660
661 pm_service_op_lock op_lock(&ph.GetProvider());
662
663 STAT_GETSTARTTIME;
664
665 ph.GetProvider().createInstance(
666 context,
667 objectPath,
668 request->newInstance,
669 chip 1.1 handler);
670
671 STAT_PMS_PROVIDEREND;
672 }
673 catch(CIMException & e)
674 {
675 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
676 "Exception: " + e.getMessage());
|
677 chip 1.2
|
678 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
679 }
680 catch(Exception & e)
681 {
682 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
683 "Exception: " + e.getMessage());
|
684 chip 1.2
|
685 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
686 }
687 catch(...)
688 {
689 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
690 "Exception: Unknown");
|
691 chip 1.2
|
692 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
693 }
694
695 PEG_METHOD_EXIT();
696
697 return(response);
698 }
699
|
700 dj.gorey 1.25 Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message)
|
701 chip 1.1 {
702 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");
703
704 CIMModifyInstanceRequestMessage * request =
705 dynamic_cast<CIMModifyInstanceRequestMessage *>(const_cast<Message *>(message));
706
707 PEGASUS_ASSERT(request != 0);
708
709 // create response message
710 CIMModifyInstanceResponseMessage * response =
711 new CIMModifyInstanceResponseMessage(
712 request->messageId,
713 CIMException(),
714 request->queueIds.copyAndPop());
715
716 PEGASUS_ASSERT(response != 0);
717
718 // preserve message key
719 response->setKey(request->getKey());
720
721 // Set HTTP method in response from request
722 chip 1.1 response->setHttpMethod (request->getHttpMethod ());
723
724 // create a handler for this request
725 ModifyInstanceResponseHandler handler(request, response);
726
727 try
728 {
729 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
730 "DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
731 System::getHostName(),
732 request->nameSpace.getString(),
733 request->modifiedInstance.getPath().getClassName().getString());
734
735 // make target object path
736 CIMObjectPath objectPath(
737 System::getHostName(),
738 request->nameSpace,
739 request->modifiedInstance.getPath ().getClassName(),
740 request->modifiedInstance.getPath ().getKeyBindings());
741
|
742 chip 1.5 // resolve provider name
|
743 kumpf 1.28 ProviderName name = _resolveProviderName(
744 request->operationContext.get(ProviderIdContainer::NAME));
|
745 chip 1.1
746 // get cached or load new provider module
747 OpProviderHolder ph =
|
748 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
749 chip 1.1
750 // convert arguments
751 OperationContext context;
752
753 context.insert(IdentityContainer(request->userName));
754 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
755 context.insert(ContentLanguageListContainer(request->contentLanguages));
756
757 CIMPropertyList propertyList(request->propertyList);
758
759 // forward request
760 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
761 "Calling provider.modifyInstance: " +
762 ph.GetProvider().getName());
763
764 pm_service_op_lock op_lock(&ph.GetProvider());
765
766 STAT_GETSTARTTIME;
767
768 ph.GetProvider().modifyInstance(
769 context,
770 chip 1.1 objectPath,
771 request->modifiedInstance,
772 request->includeQualifiers,
773 propertyList,
774 handler);
775
776 STAT_PMS_PROVIDEREND;
777 }
778 catch(CIMException & e)
779 {
780 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
781 "Exception: " + e.getMessage());
|
782 chip 1.2
|
783 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
784 }
785 catch(Exception & e)
786 {
787 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
788 "Exception: " + e.getMessage());
|
789 chip 1.2
|
790 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
791 }
792 catch(...)
793 {
794 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
795 "Exception: Unknown");
|
796 chip 1.2
|
797 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
798 }
799
800 PEG_METHOD_EXIT();
801
802 return(response);
803 }
804
|
805 dj.gorey 1.25 Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message)
|
806 chip 1.1 {
807 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");
808
809 CIMDeleteInstanceRequestMessage * request =
810 dynamic_cast<CIMDeleteInstanceRequestMessage *>(const_cast<Message *>(message));
811
812 PEGASUS_ASSERT(request != 0);
813
814 // create response message
815 CIMDeleteInstanceResponseMessage * response =
816 new CIMDeleteInstanceResponseMessage(
817 request->messageId,
818 CIMException(),
819 request->queueIds.copyAndPop());
820
821 PEGASUS_ASSERT(response != 0);
822
823 // preserve message key
824 response->setKey(request->getKey());
825
826 // Set HTTP method in response from request
827 chip 1.1 response->setHttpMethod (request->getHttpMethod ());
828
829 // create a handler for this request
830 DeleteInstanceResponseHandler handler(request, response);
831
832 try
833 {
834 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
835 "DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
836 System::getHostName(),
837 request->nameSpace.getString(),
838 request->instanceName.getClassName().getString());
839
840 // make target object path
841 CIMObjectPath objectPath(
842 System::getHostName(),
843 request->nameSpace,
844 request->instanceName.getClassName(),
845 request->instanceName.getKeyBindings());
846
|
847 chip 1.5 // resolve provider name
|
848 kumpf 1.28 ProviderName name = _resolveProviderName(
849 request->operationContext.get(ProviderIdContainer::NAME));
|
850 chip 1.1
851 // get cached or load new provider module
852 OpProviderHolder ph =
|
853 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
854 chip 1.1
855 // convert arguments
856 OperationContext context;
857
858 context.insert(IdentityContainer(request->userName));
859 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
860 context.insert(ContentLanguageListContainer(request->contentLanguages));
861
862 // forward request
863 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
864 "Calling provider.deleteInstance: " +
865 ph.GetProvider().getName());
866
867 pm_service_op_lock op_lock(&ph.GetProvider());
868
869 STAT_GETSTARTTIME;
870
871 ph.GetProvider().deleteInstance(
872 context,
873 objectPath,
874 handler);
875 chip 1.1
876 STAT_PMS_PROVIDEREND;
877 }
878 catch(CIMException & e)
879 {
880 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
881 "Exception: " + e.getMessage());
|
882 chip 1.2
|
883 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
884 }
885 catch(Exception & e)
886 {
887 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
888 "Exception: " + e.getMessage());
|
889 chip 1.2
|
890 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
891 }
892 catch(...)
893 {
894 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
895 "Exception: Unknown");
|
896 chip 1.2
|
897 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
898 }
899
900 PEG_METHOD_EXIT();
901
902 return(response);
903 }
904
|
905 dj.gorey 1.25 Message * DefaultProviderManager::handleExecQueryRequest(const Message * message)
|
906 chip 1.1 {
|
907 schuur 1.12 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");
|
908 chip 1.1
909 CIMExecQueryRequestMessage * request =
910 dynamic_cast<CIMExecQueryRequestMessage *>(const_cast<Message *>(message));
911
912 PEGASUS_ASSERT(request != 0);
913
914 CIMExecQueryResponseMessage * response =
915 new CIMExecQueryResponseMessage(
916 request->messageId,
|
917 schuur 1.12 CIMException(),
|
918 chip 1.1 request->queueIds.copyAndPop(),
919 Array<CIMObject>());
920
921 PEGASUS_ASSERT(response != 0);
922
923 // preserve message key
924 response->setKey(request->getKey());
925
926 // Set HTTP method in response from request
|
927 schuur 1.12 response->setHttpMethod (request->getHttpMethod ());
928
929 // create a handler for this request
930 ExecQueryResponseHandler handler(request, response);
931
932 try
933 {
934 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
935 "DefaultProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",
936 System::getHostName(),
937 request->nameSpace.getString(),
938 request->className.getString());
939
940 // make target object path
941 CIMObjectPath objectPath(
942 System::getHostName(),
943 request->nameSpace,
944 request->className);
945
946 // resolve provider name
|
947 kumpf 1.28 ProviderName name = _resolveProviderName(
948 request->operationContext.get(ProviderIdContainer::NAME));
|
949 schuur 1.12
950 // get cached or load new provider module
951 OpProviderHolder ph =
952 providerManager.getProvider(name.getPhysicalName(),
|
953 dj.gorey 1.25 name.getLogicalName(), String::EMPTY);
|
954 schuur 1.12
955 if (dynamic_cast<CIMInstanceQueryProvider*>(ph.GetCIMProvider()) == 0) {
956 String errorString = " instance provider is registered supporting execQuery "
|
957 dj.gorey 1.25 "but is not a CIMQueryInstanceProvider subclass.";
|
958 schuur 1.12 throw CIMException(CIM_ERR_FAILED,"ProviderLoadFailure (" + name.getPhysicalName() + ":" +
|
959 dj.gorey 1.25 name.getLogicalName() + "):" + errorString);
|
960 schuur 1.12 }
961
962 // convert arguments
963 OperationContext context;
964
965 context.insert(IdentityContainer(request->userName));
966 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
967 context.insert(ContentLanguageListContainer(request->contentLanguages));
968
|
969 schuur 1.18 QueryExpression qx(QueryExpressionFactory::routeBuildQueryExpressionRep
970 (request->queryLanguage,request->query));
|
971 schuur 1.12
972 // forward request
973 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
974 "Calling provider.executeQueryRequest: " +
975 ph.GetProvider().getName());
976
977 pm_service_op_lock op_lock(&ph.GetProvider());
978
979 STAT_GETSTARTTIME;
980
981 ph.GetProvider().execQuery(
982 context,
983 objectPath,
984 qx,
985 handler);
986
987 STAT_PMS_PROVIDEREND;
988 }
989 catch(CIMException & e)
990 {
991 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
992 schuur 1.12 "Exception: " + e.getMessage());
993
994 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
995 }
996 catch(Exception & e)
997 {
998 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
999 "Exception: " + e.getMessage());
1000
1001 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1002 }
1003 catch(...)
1004 {
1005 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1006 "Exception: Unknown");
|
1007 chip 1.1
|
1008 schuur 1.12 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1009 }
|
1010 chip 1.1
1011 PEG_METHOD_EXIT();
1012
1013 return(response);
1014 }
1015
|
1016 dj.gorey 1.25 Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message)
|
1017 chip 1.1 {
1018 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");
1019
1020 CIMAssociatorsRequestMessage * request =
1021 dynamic_cast<CIMAssociatorsRequestMessage *>(const_cast<Message *>(message));
1022
1023 PEGASUS_ASSERT(request != 0);
1024
1025 CIMAssociatorsResponseMessage * response =
1026 new CIMAssociatorsResponseMessage(
1027 request->messageId,
1028 CIMException(),
1029 request->queueIds.copyAndPop(),
1030 Array<CIMObject>());
1031
1032 PEGASUS_ASSERT(response != 0);
1033
1034 // preserve message key
1035 response->setKey(request->getKey());
1036
1037 // create a handler for this request
1038 chip 1.1 AssociatorsResponseHandler handler(request, response);
1039
1040 // process the request
1041 try
1042 {
1043 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1044 "DefaultProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
1045 System::getHostName(),
1046 request->nameSpace.getString(),
1047 request->objectName.getClassName().getString());
1048
1049 // make target object path
1050 CIMObjectPath objectPath(
1051 System::getHostName(),
1052 request->nameSpace,
1053 request->objectName.getClassName());
1054
1055 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1056
|
1057 schuur 1.19 CIMObjectPath assocPath(
1058 System::getHostName(),
1059 request->nameSpace,
1060 request->assocClass.getString());
1061
|
1062 chip 1.5 // resolve provider name
|
1063 kumpf 1.28 ProviderName name = _resolveProviderName(
1064 request->operationContext.get(ProviderIdContainer::NAME));
|
1065 chip 1.2
1066 // get cached or load new provider module
1067 OpProviderHolder ph =
|
1068 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1069 chip 1.2
1070 // convert arguments
1071 OperationContext context;
1072
1073 context.insert(IdentityContainer(request->userName));
1074 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1075 context.insert(ContentLanguageListContainer(request->contentLanguages));
|
1076 chip 1.1
|
1077 chip 1.2 // ATTN KS STAT_GETSTARTTIME;
1078 pm_service_op_lock op_lock(&ph.GetProvider());
|
1079 chip 1.1
|
1080 chip 1.2 ph.GetProvider().associators(
1081 context,
1082 objectPath,
1083 request->assocClass,
1084 request->resultClass,
1085 request->role,
1086 request->resultRole,
1087 request->includeQualifiers,
1088 request->includeClassOrigin,
1089 request->propertyList.getPropertyNameArray(),
1090 handler);
|
1091 chip 1.1
|
1092 chip 1.2 STAT_PMS_PROVIDEREND;
|
1093 chip 1.1 }
1094 catch(CIMException & e)
1095 {
1096 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1097 "Exception: " + e.getMessage());
|
1098 chip 1.2
|
1099 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1100 }
1101 catch(Exception & e)
1102 {
1103 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1104 "Exception: " + e.getMessage());
|
1105 chip 1.2
|
1106 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1107 }
1108 catch(...)
1109 {
1110 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1111 "Exception: Unknown");
|
1112 chip 1.2
|
1113 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1114 }
1115
1116 PEG_METHOD_EXIT();
1117
1118 return(response);
1119 }
1120
|
1121 dj.gorey 1.25 Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message)
|
1122 chip 1.1 {
1123 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest");
1124
1125 CIMAssociatorNamesRequestMessage * request =
1126 dynamic_cast<CIMAssociatorNamesRequestMessage *>(const_cast<Message *>(message));
1127
1128 PEGASUS_ASSERT(request != 0);
1129
1130 CIMAssociatorNamesResponseMessage * response =
1131 new CIMAssociatorNamesResponseMessage(
1132 request->messageId,
1133 CIMException(),
1134 request->queueIds.copyAndPop(),
1135 Array<CIMObjectPath>());
1136
1137 PEGASUS_ASSERT(response != 0);
1138
1139 // preserve message key
1140 response->setKey(request->getKey());
1141
1142 // Set HTTP method in response from request
1143 chip 1.1 response->setHttpMethod(request->getHttpMethod());
1144
1145 // create a handler for this request
1146 AssociatorNamesResponseHandler handler(request, response);
1147
1148 // process the request
1149 try
1150 {
1151 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1152 "DefaultProviderManager::handleAssociationNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1153 System::getHostName(),
1154 request->nameSpace.getString(),
1155 request->objectName.getClassName().getString());
1156
1157 // make target object path
1158 CIMObjectPath objectPath(
1159 System::getHostName(),
1160 request->nameSpace,
1161 request->objectName.getClassName());
1162
1163 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1164 chip 1.1
|
1165 schuur 1.19 CIMObjectPath assocPath(
1166 System::getHostName(),
1167 request->nameSpace,
1168 request->assocClass.getString());
1169
|
1170 chip 1.5 // resolve provider name
|
1171 kumpf 1.28 ProviderName name = _resolveProviderName(
1172 request->operationContext.get(ProviderIdContainer::NAME));
|
1173 chip 1.2
1174 // get cached or load new provider module
1175 OpProviderHolder ph =
|
1176 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1177 chip 1.2
1178 // convert arguments
1179 OperationContext context;
|
1180 chip 1.1
|
1181 chip 1.2 context.insert(IdentityContainer(request->userName));
1182 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1183 context.insert(ContentLanguageListContainer(request->contentLanguages));
|
1184 chip 1.1
|
1185 chip 1.2 pm_service_op_lock op_lock(&ph.GetProvider());
|
1186 chip 1.1
|
1187 chip 1.2 ph.GetProvider().associatorNames(
1188 context,
1189 objectPath,
1190 request->assocClass,
1191 request->resultClass,
1192 request->role,
1193 request->resultRole,
1194 handler);
|
1195 chip 1.1
|
1196 chip 1.2 STAT_PMS_PROVIDEREND;
|
1197 chip 1.1 }
1198 catch(CIMException & e)
1199 {
|
1200 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1201 "Exception: " + e.getMessage());
1202
|
1203 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1204 }
1205 catch(Exception & e)
1206 {
|
1207 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1208 "Exception: " + e.getMessage());
1209
|
1210 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1211 }
1212 catch(...)
1213 {
1214 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1215 "Exception: Unknown");
|
1216 chip 1.2
|
1217 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1218 }
1219
1220 PEG_METHOD_EXIT();
1221
1222 return(response);
1223 }
1224
|
1225 dj.gorey 1.25 Message * DefaultProviderManager::handleReferencesRequest(const Message * message)
|
1226 chip 1.1 {
1227 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");
1228
1229 CIMReferencesRequestMessage * request =
1230 dynamic_cast<CIMReferencesRequestMessage *>(const_cast<Message *>(message));
1231
1232 PEGASUS_ASSERT(request != 0);
1233
1234 CIMReferencesResponseMessage * response =
1235 new CIMReferencesResponseMessage(
1236 request->messageId,
1237 CIMException(),
1238 request->queueIds.copyAndPop(),
1239 Array<CIMObject>());
1240
1241 PEGASUS_ASSERT(response != 0);
1242
1243 // preserve message key
1244 response->setKey(request->getKey());
1245
1246 // Set HTTP method in response from request
1247 chip 1.1 response->setHttpMethod (request->getHttpMethod ());
1248
1249 // create a handler for this request
1250 ReferencesResponseHandler handler(request, response);
1251
1252 // process the request
1253 try
1254 {
1255 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1256 "DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
1257 System::getHostName(),
1258 request->nameSpace.getString(),
1259 request->objectName.getClassName().getString());
1260
1261 // make target object path
1262 CIMObjectPath objectPath(
1263 System::getHostName(),
1264 request->nameSpace,
1265 request->objectName.getClassName());
1266
1267 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1268 chip 1.1
|
1269 schuur 1.19 CIMObjectPath resultPath(
1270 System::getHostName(),
1271 request->nameSpace,
1272 request->resultClass.getString());
1273
|
1274 chip 1.5 // resolve provider name
|
1275 kumpf 1.28 ProviderName name = _resolveProviderName(
1276 request->operationContext.get(ProviderIdContainer::NAME));
|
1277 chip 1.2
1278 // get cached or load new provider module
1279 OpProviderHolder ph =
|
1280 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1281 chip 1.2
1282 // convert arguments
1283 OperationContext context;
1284
1285 context.insert(IdentityContainer(request->userName));
1286 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1287 context.insert(ContentLanguageListContainer(request->contentLanguages));
1288
1289 STAT_GETSTARTTIME;
|
1290 chip 1.1
|
1291 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1292 "Calling provider.references: " +
1293 ph.GetProvider().getName());
|
1294 chip 1.1
|
1295 chip 1.2 pm_service_op_lock op_lock(&ph.GetProvider());
|
1296 chip 1.1
|
1297 chip 1.2 ph.GetProvider().references(
1298 context,
1299 objectPath,
1300 request->resultClass,
1301 request->role,
1302 request->includeQualifiers,
1303 request->includeClassOrigin,
1304 request->propertyList.getPropertyNameArray(),
1305 handler);
|
1306 chip 1.1
|
1307 chip 1.2 STAT_PMS_PROVIDEREND;
|
1308 chip 1.1 }
1309 catch(CIMException & e)
1310 {
1311 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1312 "Exception: " + e.getMessage());
|
1313 chip 1.2
|
1314 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1315 }
1316 catch(Exception & e)
1317 {
1318 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1319 "Exception: " + e.getMessage());
|
1320 chip 1.2
|
1321 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1322 }
1323 catch(...)
1324 {
1325 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1326 "Exception: Unknown");
|
1327 chip 1.2
|
1328 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1329 }
1330
1331 PEG_METHOD_EXIT();
1332
1333 return(response);
1334 }
1335
|
1336 dj.gorey 1.25 Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message)
|
1337 chip 1.1 {
1338 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");
1339
1340 CIMReferenceNamesRequestMessage * request =
1341 dynamic_cast<CIMReferenceNamesRequestMessage *>(const_cast<Message *>(message));
1342
1343 PEGASUS_ASSERT(request != 0);
1344
1345 CIMReferenceNamesResponseMessage * response =
1346 new CIMReferenceNamesResponseMessage(
1347 request->messageId,
1348 CIMException(),
1349 request->queueIds.copyAndPop(),
1350 Array<CIMObjectPath>());
1351
1352 // preserve message key
1353 response->setKey(request->getKey());
1354
1355 // Set HTTP method in response from request
1356 response->setHttpMethod (request->getHttpMethod ());
1357
1358 chip 1.1 // create a handler for this request
1359 ReferenceNamesResponseHandler handler(request, response);
1360
1361 // process the request
1362 try
1363 {
1364 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1365 "DefaultProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1366 System::getHostName(),
1367 request->nameSpace.getString(),
1368 request->objectName.getClassName().getString());
1369
1370 // make target object path
1371 CIMObjectPath objectPath(
1372 System::getHostName(),
1373 request->nameSpace,
1374 request->objectName.getClassName());
1375
1376 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1377
|
1378 schuur 1.19 CIMObjectPath resultPath(
1379 System::getHostName(),
1380 request->nameSpace,
1381 request->resultClass.getString());
1382
|
1383 chip 1.5 // resolve provider name
|
1384 kumpf 1.28 ProviderName name = _resolveProviderName(
1385 request->operationContext.get(ProviderIdContainer::NAME));
|
1386 chip 1.1
|
1387 chip 1.2 // get cached or load new provider module
1388 OpProviderHolder ph =
|
1389 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1390 chip 1.1
|
1391 chip 1.2 // convert arguments
1392 OperationContext context;
|
1393 chip 1.1
|
1394 chip 1.2 context.insert(IdentityContainer(request->userName));
1395 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1396 context.insert(ContentLanguageListContainer(request->contentLanguages));
|
1397 chip 1.1
|
1398 chip 1.2 STAT_GETSTARTTIME;
|
1399 chip 1.1
|
1400 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1401 "Calling provider.referenceNames: " +
1402 ph.GetProvider().getName());
|
1403 chip 1.1
|
1404 chip 1.2 pm_service_op_lock op_lock(&ph.GetProvider());
|
1405 chip 1.1
|
1406 chip 1.2 ph.GetProvider().referenceNames(
1407 context,
1408 objectPath,
1409 request->resultClass,
1410 request->role,
1411 handler);
|
1412 chip 1.1
|
1413 chip 1.2 STAT_PMS_PROVIDEREND;
|
1414 chip 1.1 }
1415 catch(CIMException & e)
1416 {
1417 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1418 "Exception: " + e.getMessage());
|
1419 chip 1.2
|
1420 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1421 }
1422 catch(Exception & e)
1423 {
1424 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1425 "Exception: " + e.getMessage());
|
1426 chip 1.2
|
1427 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1428 }
1429 catch(...)
1430 {
1431 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1432 "Exception: Unknown");
|
1433 chip 1.2
|
1434 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1435 }
1436
1437 PEG_METHOD_EXIT();
1438
1439 return(response);
1440 }
1441
|
1442 dj.gorey 1.25 Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message)
|
1443 chip 1.1 {
1444 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");
1445
1446 CIMGetPropertyRequestMessage * request =
1447 dynamic_cast<CIMGetPropertyRequestMessage *>(const_cast<Message *>(message));
1448
1449 PEGASUS_ASSERT(request != 0);
1450
1451 // create response message
1452 CIMGetPropertyResponseMessage * response =
1453 new CIMGetPropertyResponseMessage(
1454 request->messageId,
1455 CIMException(),
1456 request->queueIds.copyAndPop(),
1457 CIMValue());
1458
1459 PEGASUS_ASSERT(response != 0);
1460
1461 // preserve message key
1462 response->setKey(request->getKey());
1463
1464 chip 1.1 // Set HTTP method in response from request
1465 response->setHttpMethod(request->getHttpMethod());
1466
1467 GetPropertyResponseHandler handler(request, response);
1468
1469 try
1470 {
1471 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1472 "DefaultProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
1473 System::getHostName(),
1474 request->nameSpace.getString(),
1475 request->instanceName.getClassName().getString());
1476
1477 // make target object path
1478 CIMObjectPath objectPath(
1479 System::getHostName(),
1480 request->nameSpace,
1481 request->instanceName.getClassName(),
1482 request->instanceName.getKeyBindings());
1483
|
1484 chip 1.5 // resolve provider name
|
1485 kumpf 1.28 ProviderName name = _resolveProviderName(
1486 request->operationContext.get(ProviderIdContainer::NAME));
|
1487 chip 1.1
1488 // get cached or load new provider module
1489 OpProviderHolder ph =
|
1490 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1491 chip 1.1
1492 // convert arguments
1493 OperationContext context;
1494
1495 context.insert(IdentityContainer(request->userName));
1496 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1497 context.insert(ContentLanguageListContainer(request->contentLanguages));
1498
1499 CIMName propertyName = request->propertyName;
1500
1501 STAT_GETSTARTTIME;
1502
1503 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1504 "Calling provider.getProperty: " +
1505 ph.GetProvider().getName());
1506
1507 // forward request
1508 pm_service_op_lock op_lock(&ph.GetProvider());
1509
1510 ph.GetProvider().getProperty(
1511 context,
1512 chip 1.1 objectPath,
1513 propertyName,
1514 handler);
1515
1516 STAT_PMS_PROVIDEREND;
1517 }
1518 catch(CIMException & e)
1519 {
1520 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1521 "Exception: " + e.getMessage());
|
1522 chip 1.2
|
1523 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1524 }
1525 catch(Exception & e)
1526 {
1527 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1528 "Exception: " + e.getMessage());
|
1529 chip 1.2
|
1530 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1531 }
1532 catch(...)
1533 {
1534 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1535 "Exception: Unknown");
|
1536 chip 1.2
|
1537 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1538 }
1539
1540 PEG_METHOD_EXIT();
1541
1542 return(response);
1543 }
1544
|
1545 dj.gorey 1.25 Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message)
|
1546 chip 1.1 {
1547 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");
1548
1549 CIMSetPropertyRequestMessage * request =
1550 dynamic_cast<CIMSetPropertyRequestMessage *>(const_cast<Message *>(message));
1551
1552 PEGASUS_ASSERT(request != 0);
1553
1554 // create response message
1555 //l10n
1556 CIMSetPropertyResponseMessage * response =
1557 new CIMSetPropertyResponseMessage(
1558 request->messageId,
1559 PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
1560 "ProviderManager.DefaultProviderManager.NOT_IMPLEMENTED",
1561 "not implemented")),
1562 request->queueIds.copyAndPop());
1563
1564 PEGASUS_ASSERT(response != 0);
1565
1566 // preserve message key
1567 chip 1.1 response->setKey(request->getKey());
1568
1569 // Set HTTP method in response from request
1570 response->setHttpMethod(request->getHttpMethod());
1571
1572 SetPropertyResponseHandler handler(request, response);
1573
1574 try
1575 {
1576 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1577 "DefaultProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
1578 System::getHostName(),
1579 request->nameSpace.getString(),
1580 request->instanceName.getClassName().getString());
1581
1582 // make target object path
1583 CIMObjectPath objectPath(
1584 System::getHostName(),
1585 request->nameSpace,
1586 request->instanceName.getClassName(),
1587 request->instanceName.getKeyBindings());
1588 chip 1.1
|
1589 chip 1.5 // resolve provider name
|
1590 kumpf 1.28 ProviderName name = _resolveProviderName(
1591 request->operationContext.get(ProviderIdContainer::NAME));
|
1592 chip 1.1
1593 // get cached or load new provider module
1594 OpProviderHolder ph =
|
1595 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1596 chip 1.1
1597 // convert arguments
1598 OperationContext context;
1599
1600 context.insert(IdentityContainer(request->userName));
1601 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1602 context.insert(ContentLanguageListContainer(request->contentLanguages));
1603
1604 CIMName propertyName = request->propertyName;
1605 CIMValue propertyValue = request->newValue;
1606
1607 STAT_GETSTARTTIME;
1608
1609 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1610 "Calling provider.setProperty: " +
1611 ph.GetProvider().getName());
1612
1613 // forward request
1614 pm_service_op_lock op_lock(&ph.GetProvider());
1615
1616 ph.GetProvider().setProperty(
1617 chip 1.1 context,
1618 objectPath,
1619 propertyName,
1620 propertyValue,
1621 handler);
1622
1623 STAT_PMS_PROVIDEREND;
1624 }
1625 catch(CIMException & e)
1626 {
1627 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1628 "Exception: " + e.getMessage());
|
1629 chip 1.2
|
1630 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1631 }
1632 catch(Exception & e)
1633 {
1634 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1635 "Exception: " + e.getMessage());
|
1636 chip 1.2
|
1637 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1638 }
1639 catch(...)
1640 {
1641 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1642 "Exception: Unknown");
|
1643 chip 1.2
|
1644 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1645 }
1646
1647 PEG_METHOD_EXIT();
1648
1649 return(response);
1650 }
1651
|
1652 dj.gorey 1.25 Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message)
|
1653 chip 1.1 {
1654 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");
1655
1656 CIMInvokeMethodRequestMessage * request =
1657 dynamic_cast<CIMInvokeMethodRequestMessage *>(const_cast<Message *>(message));
1658
1659 PEGASUS_ASSERT(request != 0);
1660
1661 // create response message
1662 CIMInvokeMethodResponseMessage * response =
1663 new CIMInvokeMethodResponseMessage(
1664 request->messageId,
1665 CIMException(),
1666 request->queueIds.copyAndPop(),
1667 CIMValue(),
1668 Array<CIMParamValue>(),
1669 request->methodName);
1670
1671 PEGASUS_ASSERT(response != 0);
1672
1673 // propagate message key
1674 chip 1.1 response->setKey(request->getKey());
1675
1676 // Set HTTP method in response from request
1677 response->setHttpMethod (request->getHttpMethod ());
1678
1679 // create a handler for this request
1680 InvokeMethodResponseHandler handler(request, response);
1681
1682 try
1683 {
1684 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1685 "DefaultProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
1686 System::getHostName(),
1687 request->nameSpace.getString(),
1688 request->instanceName.getClassName().getString());
1689
1690 // make target object path
1691 CIMObjectPath objectPath(
1692 System::getHostName(),
1693 request->nameSpace,
1694 request->instanceName.getClassName(),
1695 chip 1.1 request->instanceName.getKeyBindings());
1696
|
1697 chip 1.5 // resolve provider name
|
1698 kumpf 1.28 ProviderName name = _resolveProviderName(
1699 request->operationContext.get(ProviderIdContainer::NAME));
|
1700 chip 1.1
1701 // get cached or load new provider module
1702 OpProviderHolder ph =
|
1703 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1704 chip 1.1
1705 // convert arguments
1706 OperationContext context;
1707
1708 context.insert(IdentityContainer(request->userName));
1709 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1710 context.insert(ContentLanguageListContainer(request->contentLanguages));
1711
1712 CIMObjectPath instanceReference(request->instanceName);
1713
1714 // ATTN: propagate namespace
1715 instanceReference.setNameSpace(request->nameSpace);
1716
1717 // forward request
1718 STAT_GETSTARTTIME;
1719
1720 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1721 "Calling provider.invokeMethod: " +
1722 ph.GetProvider().getName());
1723
1724 pm_service_op_lock op_lock(&ph.GetProvider());
1725 chip 1.1
1726 ph.GetProvider().invokeMethod(
1727 context,
1728 instanceReference,
1729 request->methodName,
1730 request->inParameters,
1731 handler);
1732
1733 STAT_PMS_PROVIDEREND;
1734 }
1735 catch(CIMException & e)
1736 {
1737 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1738 "Exception: " + e.getMessage());
|
1739 chip 1.2
|
1740 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1741 }
1742 catch(Exception & e)
1743 {
1744 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1745 "Exception: " + e.getMessage());
|
1746 chip 1.2
|
1747 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1748 }
1749 catch(...)
1750 {
1751 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1752 "Exception: Unknown");
|
1753 chip 1.2
|
1754 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
1755 }
1756
1757 PEG_METHOD_EXIT();
1758
1759 return(response);
1760 }
1761
|
1762 dj.gorey 1.25 Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message)
|
1763 chip 1.1 {
1764 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");
1765
1766 CIMCreateSubscriptionRequestMessage * request =
1767 dynamic_cast<CIMCreateSubscriptionRequestMessage *>(const_cast<Message *>(message));
1768
1769 PEGASUS_ASSERT(request != 0);
1770
1771 CIMCreateSubscriptionResponseMessage * response =
1772 new CIMCreateSubscriptionResponseMessage(
1773 request->messageId,
1774 CIMException(),
1775 request->queueIds.copyAndPop());
1776
1777 PEGASUS_ASSERT(response != 0);
1778
1779 // preserve message key
1780 response->setKey(request->getKey());
1781
1782 // Set HTTP method in response from request
1783 response->setHttpMethod (request->getHttpMethod ());
1784 chip 1.1
1785 OperationResponseHandler handler(request, response);
1786
1787 try
1788 {
|
1789 chip 1.2 String temp;
1790
1791 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1792 {
1793 temp.append(request->classNames[i].getString());
1794
1795 if(i == (n - 1))
1796 {
1797 temp.append(", ");
1798 }
1799 }
1800
1801 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1802 "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Class name(s): $2",
1803 System::getHostName(),
1804 request->nameSpace.getString(),
1805 temp);
1806
|
1807 schuur 1.18 String physicalName=_resolvePhysicalName(
1808 request->providerModule.getProperty(
1809 request->providerModule.findProperty("Location")).getValue().toString());
1810
|
1811 schuur 1.20 ProviderName name(
|
1812 schuur 1.18 request->provider.getProperty(request->provider.findProperty
1813 ("Name")).getValue ().toString (),
1814 physicalName,
1815 request->providerModule.getProperty(request->providerModule.findProperty
1816 ("InterfaceType")).getValue().toString(),
1817 0);
|
1818 chip 1.1
1819 // get cached or load new provider module
1820 OpProviderHolder ph =
|
1821 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1822 dj.gorey 1.25
|
1823 chip 1.1 // convert arguments
1824 OperationContext context;
1825
1826 context.insert(IdentityContainer(request->userName));
1827 context.insert(SubscriptionInstanceContainer
1828 (request->subscriptionInstance));
1829 context.insert(SubscriptionFilterConditionContainer
1830 (request->condition, request->queryLanguage));
1831 context.insert(SubscriptionLanguageListContainer
1832 (request->acceptLanguages));
1833 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1834 context.insert(ContentLanguageListContainer(request->contentLanguages));
1835
1836 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
1837
1838 Array<CIMObjectPath> classNames;
1839
1840 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1841 {
1842 CIMObjectPath className(
1843 System::getHostName(),
1844 chip 1.1 request->nameSpace,
1845 request->classNames[i]);
1846
1847 classNames.append(className);
1848 }
1849
1850 CIMPropertyList propertyList = request->propertyList;
1851
1852 Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy;
1853
1854 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1855 "Calling provider.createSubscription: " +
1856 ph.GetProvider().getName());
1857
1858 pm_service_op_lock op_lock(&ph.GetProvider());
1859
1860 ph.GetProvider().createSubscription(
1861 context,
1862 subscriptionName,
1863 classNames,
1864 propertyList,
1865 chip 1.1 repeatNotificationPolicy);
1866 }
1867 catch(CIMException & e)
1868 {
1869 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1870 "Exception: " + e.getMessage());
|
1871 chip 1.2
|
1872 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
1873 }
1874 catch(Exception & e)
1875 {
1876 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1877 "Exception: " + e.getMessage());
|
1878 chip 1.2
|
1879 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
1880 }
1881 catch(...)
1882 {
1883 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1884 "Exception: Unknown");
|
1885 chip 1.2
|
1886 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown Error");
1887 }
1888
1889 PEG_METHOD_EXIT();
1890
1891 return(response);
1892 }
1893
|
1894 dj.gorey 1.25 Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message)
|
1895 chip 1.1 {
1896 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");
1897
1898 CIMModifySubscriptionRequestMessage * request =
1899 dynamic_cast<CIMModifySubscriptionRequestMessage *>(const_cast<Message *>(message));
1900
1901 PEGASUS_ASSERT(request != 0);
1902
1903 CIMModifySubscriptionResponseMessage * response =
1904 new CIMModifySubscriptionResponseMessage(
1905 request->messageId,
1906 CIMException(),
1907 request->queueIds.copyAndPop());
1908
1909 PEGASUS_ASSERT(response != 0);
1910
1911 // preserve message key
1912 response->setKey(request->getKey());
1913
1914 // Set HTTP method in response from request
1915 response->setHttpMethod (request->getHttpMethod ());
1916 chip 1.1
1917 OperationResponseHandler handler(request, response);
1918
1919 try
1920 {
|
1921 chip 1.2 String temp;
1922
1923 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1924 {
1925 temp.append(request->classNames[i].getString());
1926
1927 if(i == (n - 1))
1928 {
1929 temp.append(", ");
1930 }
1931 }
1932
1933 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1934 schuur 1.18 "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Class name(s): $2",
|
1935 chip 1.2 System::getHostName(),
1936 request->nameSpace.getString(),
1937 temp);
1938
|
1939 schuur 1.18 String physicalName=_resolvePhysicalName(
1940 request->providerModule.getProperty(
1941 request->providerModule.findProperty("Location")).getValue().toString());
1942
|
1943 schuur 1.20 ProviderName name(
|
1944 schuur 1.18 request->provider.getProperty(request->provider.findProperty
1945 ("Name")).getValue ().toString (),
1946 physicalName,
1947 request->providerModule.getProperty(request->providerModule.findProperty
1948 ("InterfaceType")).getValue().toString(),
1949 0);
|
1950 chip 1.1
1951 // get cached or load new provider module
1952 OpProviderHolder ph =
|
1953 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
1954 dj.gorey 1.25
|
1955 chip 1.1 // convert arguments
1956 OperationContext context;
1957
1958 context.insert(IdentityContainer(request->userName));
1959 context.insert(SubscriptionInstanceContainer
1960 (request->subscriptionInstance));
1961 context.insert(SubscriptionFilterConditionContainer
1962 (request->condition, request->queryLanguage));
1963 context.insert(SubscriptionLanguageListContainer
1964 (request->acceptLanguages));
1965 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
1966 context.insert(ContentLanguageListContainer(request->contentLanguages));
1967
1968 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
1969
1970 Array<CIMObjectPath> classNames;
1971
1972 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1973 {
1974 CIMObjectPath className(
1975 System::getHostName(),
1976 chip 1.1 request->nameSpace,
1977 request->classNames[i]);
1978
1979 classNames.append(className);
1980 }
1981
1982 CIMPropertyList propertyList = request->propertyList;
1983
1984 Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy;
1985
1986 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1987 "Calling provider.modifySubscription: " +
1988 ph.GetProvider().getName());
1989
1990 pm_service_op_lock op_lock(&ph.GetProvider());
1991
1992 ph.GetProvider().modifySubscription(
1993 context,
1994 subscriptionName,
1995 classNames,
1996 propertyList,
1997 chip 1.1 repeatNotificationPolicy);
1998 }
1999 catch(CIMException & e)
2000 {
2001 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2002 "Exception: " + e.getMessage());
|
2003 chip 1.2
|
2004 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
2005 }
2006 catch(Exception & e)
2007 {
2008 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2009 "Exception: " + e.getMessage());
|
2010 chip 1.2
|
2011 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
2012 }
2013 catch(...)
2014 {
2015 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2016 "Exception: Unknown");
|
2017 chip 1.2
|
2018 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown Error");
2019 }
2020
2021 PEG_METHOD_EXIT();
2022
2023 return(response);
2024 }
2025
|
2026 dj.gorey 1.25 Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message)
|
2027 chip 1.1 {
2028 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");
2029
2030 CIMDeleteSubscriptionRequestMessage * request =
2031 dynamic_cast<CIMDeleteSubscriptionRequestMessage *>(const_cast<Message *>(message));
2032
2033 PEGASUS_ASSERT(request != 0);
2034
2035 CIMDeleteSubscriptionResponseMessage * response =
2036 new CIMDeleteSubscriptionResponseMessage(
2037 request->messageId,
2038 CIMException(),
2039 request->queueIds.copyAndPop());
2040
2041 PEGASUS_ASSERT(response != 0);
2042
2043 // preserve message key
2044 response->setKey(request->getKey());
2045
2046 // Set HTTP method in response from request
2047 response->setHttpMethod(request->getHttpMethod());
2048 chip 1.1
2049 OperationResponseHandler handler(request, response);
2050
2051 try
2052 {
|
2053 chip 1.2 String temp;
2054
2055 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)
2056 {
2057 temp.append(request->classNames[i].getString());
2058
2059 if(i == (n - 1))
2060 {
2061 temp.append(", ");
2062 }
2063 }
2064
2065 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2066 "DefaultProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Class name(s): $2",
2067 System::getHostName(),
2068 request->nameSpace.getString(),
2069 temp);
2070
|
2071 schuur 1.18 String physicalName=_resolvePhysicalName(
2072 request->providerModule.getProperty(
2073 request->providerModule.findProperty("Location")).getValue().toString());
2074
|
2075 schuur 1.20 ProviderName name(
|
2076 schuur 1.18 request->provider.getProperty(request->provider.findProperty
2077 ("Name")).getValue ().toString (),
2078 physicalName,
2079 request->providerModule.getProperty(request->providerModule.findProperty
2080 ("InterfaceType")).getValue().toString(),
2081 0);
|
2082 chip 1.1
2083 // get cached or load new provider module
2084 OpProviderHolder ph =
|
2085 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
2086 dj.gorey 1.25
|
2087 chip 1.1 // convert arguments
2088 OperationContext context;
2089
2090 context.insert(IdentityContainer(request->userName));
2091 context.insert(SubscriptionInstanceContainer
2092 (request->subscriptionInstance));
2093 context.insert(SubscriptionLanguageListContainer
2094 (request->acceptLanguages));
2095 context.insert(AcceptLanguageListContainer(request->acceptLanguages));
2096 context.insert(ContentLanguageListContainer(request->contentLanguages));
2097
2098 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
2099
2100 Array<CIMObjectPath> classNames;
2101
2102 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)
2103 {
2104 CIMObjectPath className(
2105 System::getHostName(),
2106 request->nameSpace,
2107 request->classNames[i]);
2108 chip 1.1
2109 classNames.append(className);
2110 }
2111
2112 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2113 "Calling provider.deleteSubscription: " +
2114 ph.GetProvider().getName());
2115
2116 pm_service_op_lock op_lock(&ph.GetProvider());
2117
2118 ph.GetProvider().deleteSubscription(
2119 context,
2120 subscriptionName,
2121 classNames);
2122 }
2123 catch(CIMException & e)
2124 {
2125 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2126 "Exception: " + e.getMessage());
|
2127 chip 1.2
|
2128 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
2129 }
2130 catch(Exception & e)
2131 {
2132 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2133 "Exception: " + e.getMessage());
|
2134 chip 1.2
|
2135 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
2136 }
2137 catch(...)
2138 {
2139 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2140 "Exception: Unknown");
|
2141 chip 1.2
|
2142 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown Error");
2143 }
2144
2145 PEG_METHOD_EXIT();
2146
2147 return(response);
2148 }
2149
|
2150 dj.gorey 1.25 Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message)
|
2151 chip 1.1 {
2152 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest");
2153
2154 CIMEnableIndicationsRequestMessage * request =
2155 dynamic_cast<CIMEnableIndicationsRequestMessage *>(const_cast<Message *>(message));
2156
2157 PEGASUS_ASSERT(request != 0);
2158
2159 CIMEnableIndicationsResponseMessage * response =
2160 new CIMEnableIndicationsResponseMessage(
2161 request->messageId,
2162 CIMException(),
2163 request->queueIds.copyAndPop());
2164
2165 PEGASUS_ASSERT(response != 0);
2166
2167 // preserve message key
2168 response->setKey(request->getKey());
2169
2170 // Set HTTP method in response from request
2171 response->setHttpMethod(request->getHttpMethod());
2172 chip 1.1
2173 response->dest = request->queueIds.top();
2174
|
2175 schuur 1.14 EnableIndicationsResponseHandler *handler =
|
2176 kumpf 1.29 new EnableIndicationsResponseHandler(
2177 request, response, request->provider, _indicationCallback);
|
2178 chip 1.1
2179 try
2180 {
|
2181 schuur 1.14 String physicalName=_resolvePhysicalName(
2182 request->providerModule.getProperty(
|
2183 dj.gorey 1.25 request->providerModule.findProperty("Location")).getValue().toString());
|
2184 schuur 1.14
|
2185 schuur 1.20 ProviderName name(
|
2186 schuur 1.16 request->provider.getProperty(request->provider.findProperty
|
2187 schuur 1.14 ("Name")).getValue ().toString (),
|
2188 dj.gorey 1.25 physicalName,
|
2189 schuur 1.14 request->providerModule.getProperty(request->providerModule.findProperty
2190 ("InterfaceType")).getValue().toString(),
2191 0);
|
2192 chip 1.1
2193 // get cached or load new provider module
2194 OpProviderHolder ph =
|
2195 schuur 1.14 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
2196 chip 1.1
2197 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2198 "Calling provider.enableIndications: " +
2199 ph.GetProvider().getName());
|
2200 schuur 1.14
2201 pm_service_op_lock op_lock(&ph.GetProvider());
|
2202 schuur 1.23 ph.GetProvider().protect();
|
2203 schuur 1.14
|
2204 chip 1.1 ph.GetProvider().enableIndications(*handler);
2205
2206
2207 // if no exception, store the handler so it is persistent for as
2208 // long as the provider has indications enabled.
2209 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2210 "Storing indication handler for " + ph.GetProvider().getName());
2211
2212 _insertEntry(ph.GetProvider(), handler);
2213 }
2214 catch(CIMException & e)
2215 {
2216 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2217 "Exception: " + e.getMessage());
|
2218 schuur 1.14
|
2219 chip 1.1 response->cimException = CIMException(e);
2220 }
2221 catch(Exception & e)
2222 {
2223 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2224 "Exception: " + e.getMessage());
2225 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
2226 "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",
2227 "Internal Error"));
2228 }
2229 catch(...)
2230 {
2231 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2232 "Exception: Unknown");
2233 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
2234 "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",
2235 "Unknown Error"));
2236 }
2237
2238 PEG_METHOD_EXIT();
2239
2240 chip 1.1 return(response);
2241 }
2242
|
2243 dj.gorey 1.25 Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message)
|
2244 chip 1.1 {
2245 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest");
2246
2247 CIMDisableIndicationsRequestMessage * request =
2248 dynamic_cast<CIMDisableIndicationsRequestMessage *>(const_cast<Message *>(message));
2249
2250 PEGASUS_ASSERT(request != 0);
2251
2252 CIMDisableIndicationsResponseMessage * response =
2253 new CIMDisableIndicationsResponseMessage(
2254 request->messageId,
2255 CIMException(),
2256 request->queueIds.copyAndPop());
2257
2258 // preserve message key
2259 response->setKey(request->getKey());
2260
2261 // Set HTTP method in response from request
2262 response->setHttpMethod (request->getHttpMethod ());
2263
2264 OperationResponseHandler handler(request, response);
2265 chip 1.1
2266 try
2267 {
|
2268 schuur 1.14 String physicalName=_resolvePhysicalName(
2269 request->providerModule.getProperty(
|
2270 dj.gorey 1.25 request->providerModule.findProperty("Location")).getValue().toString());
|
2271 schuur 1.14
|
2272 schuur 1.20 ProviderName name(
|
2273 schuur 1.16 request->provider.getProperty(request->provider.findProperty
|
2274 schuur 1.14 ("Name")).getValue ().toString (),
|
2275 dj.gorey 1.25 physicalName,
|
2276 schuur 1.14 request->providerModule.getProperty(request->providerModule.findProperty
2277 ("InterfaceType")).getValue().toString(),
|
2278 chip 1.6 0);
|
2279 chip 1.1
2280 // get cached or load new provider module
2281 OpProviderHolder ph =
|
2282 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
|
2283 chip 1.1
2284 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2285 "Calling provider.disableIndications: " +
2286 ph.GetProvider().getName());
2287
2288 ph.GetProvider().disableIndications();
2289
2290 ph.GetProvider().unprotect();
2291
2292 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2293 "Removing and Destroying indication handler for " +
2294 ph.GetProvider().getName());
2295
2296 delete _removeEntry(_generateKey(ph.GetProvider()));
2297 }
2298
2299 catch(CIMException & e)
2300 {
2301 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2302 "Exception: " + e.getMessage());
|
2303 chip 1.2
|
2304 chip 1.1 response->cimException = CIMException(e);
2305 }
2306 catch(Exception & e)
2307 {
2308 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2309 "Exception: " + e.getMessage());
|
2310 chip 1.2 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
|
2311 chip 1.1 "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",
2312 "Internal Error"));
2313 }
2314 catch(...)
2315 {
2316 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2317 "Exception: Unknown");
|
2318 chip 1.2 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
|
2319 chip 1.1 "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",
2320 "Unknown Error"));
2321 }
2322
2323 PEG_METHOD_EXIT();
2324
2325 return(response);
2326 }
2327
|
2328 dj.gorey 1.25 Message *DefaultProviderManager::handleExportIndicationRequest(const Message *message)
|
2329 schuur 1.14 {
2330 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManagerService::handlExportIndicationRequest");
2331
2332 CIMExportIndicationRequestMessage * request =
2333 dynamic_cast<CIMExportIndicationRequestMessage *>(const_cast<Message *>(message));
2334
2335 PEGASUS_ASSERT(request != 0);
2336
2337 CIMExportIndicationResponseMessage * response =
2338 new CIMExportIndicationResponseMessage(
2339 request->messageId,
2340 CIMException(),
2341 request->queueIds.copyAndPop());
2342
2343 PEGASUS_ASSERT(response != 0);
2344
2345 // preserve message key
2346 response->setKey(request->getKey());
2347
2348 // Set HTTP method in response from request
2349 response->setHttpMethod (request->getHttpMethod ());
2350 schuur 1.14
2351 OperationResponseHandler handler(request, response);
2352
2353 try
2354 {
|
2355 kumpf 1.28 // resolve provider name
2356 ProviderName name = _resolveProviderName(
2357 request->operationContext.get(ProviderIdContainer::NAME));
|
2358 schuur 1.14
|
2359 kumpf 1.28 // get cached or load new provider module
|
2360 schuur 1.14 OpProviderHolder ph =
2361 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2362
2363 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
2364 dj.gorey 1.25 "Calling provider.: " +
2365 ph.GetProvider().getName());
|
2366 schuur 1.14
2367 OperationContext context;
2368
2369 //L10N_TODO
2370 //l10n
2371 // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent. This
2372 // does not appear to be hooked-up. When it is added, need to
2373 // make sure that Content-Language is set in the consume msg.
2374 // NOTE: A-L is not needed to be set in the consume msg.
2375 // add the langs to the context
2376 context.insert(ContentLanguageListContainer(request->contentLanguages));
2377
2378 CIMInstance indication_copy = request->indicationInstance;
2379 pm_service_op_lock op_lock(&ph.GetProvider());
2380
2381 ph.GetProvider().consumeIndication(context,
|
2382 dj.gorey 1.25 request->destinationPath,
2383 indication_copy);
|
2384 schuur 1.14
2385 }
2386
2387 catch(CIMException & e)
2388 {
2389 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2390 "Exception: " + e.getMessage());
2391
2392 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
2393 }
2394 catch(Exception & e)
2395 {
2396 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2397 "Exception: " + e.getMessage());
2398
2399 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
2400 }
2401 catch(...)
2402 {
2403 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2404 "Exception: Unknown");
2405 schuur 1.14
2406 handler.setStatus(CIM_ERR_FAILED, "Unknown Error");
2407 }
2408
2409 PEG_METHOD_EXIT();
2410
2411 return(response);
2412 }
2413
2414
2415
2416
|
2417 chip 1.1 //
2418 // This function disables a provider module if disableProviderOnly is not true,
2419 // otherwise, disables a provider. Disable provider module means that
2420 // block all the providers which contain in the module and unload the
2421 // providers.
2422 // Disable provider means unload the provider and the provider is not blocked.
2423 //
2424 // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider.
2425 //
|
2426 dj.gorey 1.25 Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message)
|
2427 chip 1.1 {
2428 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");
|
2429 schuur 1.19
|
2430 chip 1.1 CIMDisableModuleRequestMessage * request =
2431 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
2432
2433 PEGASUS_ASSERT(request != 0);
|
2434 dj.gorey 1.25
|
2435 schuur 1.18 Array<Uint16> operationalStatus;
2436 CIMException cimException;
|
2437 chip 1.1
|
2438 schuur 1.18 try
|
2439 chip 1.1 {
|
2440 schuur 1.18 // get provider module name
2441 String moduleName;
2442 CIMInstance mInstance = request->providerModule;
2443 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
|
2444 kumpf 1.28 PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
2445 mInstance.getProperty(pos).getValue().get(moduleName);
|
2446 chip 1.1
|
2447 schuur 1.18 Boolean disableProviderOnly = request->disableProviderOnly;
2448
|
2449 chip 1.1 //
|
2450 kumpf 1.28 // Unload providers
|
2451 chip 1.1 //
|
2452 schuur 1.18 Array<CIMInstance> _pInstances = request->providers;
2453 Array<Boolean> _indicationProviders = request->indicationProviders;
|
2454 dj.gorey 1.25
|
2455 schuur 1.18 String physicalName=_resolvePhysicalName(
2456 mInstance.getProperty(
2457 mInstance.findProperty("Location")).getValue().toString());
|
2458 dj.gorey 1.25
|
2459 schuur 1.18 for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)
|
2460 chip 1.1 {
|
2461 schuur 1.18 String pName(_pInstances[i].getProperty(
2462 _pInstances[i].findProperty("Name")).getValue().toString());
|
2463 chip 1.1
|
2464 schuur 1.18 Sint16 ret_value = providerManager.disableProvider(physicalName,pName);
|
2465 chip 1.1
|
2466 schuur 1.18 if (ret_value == 0)
2467 {
|
2468 schuur 1.23 // disable failed since there are pending requests,
|
2469 kumpf 1.28 // stop trying to disable other providers in this module.
2470 operationalStatus.append(_MODULE_OK);
2471 break;
|
2472 dj.gorey 1.25 }
|
2473 kumpf 1.28 else if (ret_value == 1) // Success
|
2474 dj.gorey 1.25 {
|
2475 schuur 1.18 // if It is an indication provider
|
2476 dj.gorey 1.25 // remove the entry from the table since the
|
2477 schuur 1.18 // provider has been disabled
2478 if (_indicationProviders[i])
|
2479 dj.gorey 1.25 {
|
2480 kumpf 1.27 delete _removeEntry(_generateKey(pName,physicalName));
|
2481 dj.gorey 1.25 }
2482 }
|
2483 schuur 1.18 else
2484 {
|
2485 dj.gorey 1.25 // disable failed for other reason, throw exception
|
2486 schuur 1.18 throw PEGASUS_CIM_EXCEPTION_L(
2487 CIM_ERR_FAILED,
2488 MessageLoaderParms(
2489 "ProviderManager.ProviderManagerService."
2490 "DISABLE_PROVIDER_FAILED",
2491 "Failed to disable the provider."));
2492 }
2493 }
2494 }
2495 catch(CIMException & e)
2496 {
|
2497 dj.gorey 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
2498 schuur 1.18 "Exception: " + e.getMessage());
2499 cimException = e;
2500 }
2501 catch(Exception & e)
2502 {
|
2503 dj.gorey 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
2504 schuur 1.18 "Exception: " + e.getMessage());
2505 cimException = CIMException(CIM_ERR_FAILED, e.getMessage());
2506 }
2507 catch(...)
2508 {
|
2509 dj.gorey 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
2510 schuur 1.18 "Exception: Unknown");
2511 //l10n
2512 //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");
2513 cimException = PEGASUS_CIM_EXCEPTION_L(
2514 CIM_ERR_FAILED,
2515 MessageLoaderParms(
2516 "ProviderManager.ProviderManagerService.UNKNOWN_ERROR",
2517 "Unknown Error"));
|
2518 chip 1.1 }
2519
|
2520 kumpf 1.28 if (cimException.getCode() == CIM_ERR_SUCCESS)
2521 {
2522 // Status is set to OK if a provider was busy
2523 if (operationalStatus.size() == 0)
2524 {
2525 operationalStatus.append(_MODULE_STOPPED);
2526 }
2527 }
2528 else
2529 {
2530 // If exception occurs, module is not stopped
2531 operationalStatus.append(_MODULE_OK);
2532 }
2533
|
2534 chip 1.1 CIMDisableModuleResponseMessage * response =
2535 new CIMDisableModuleResponseMessage(
|
2536 kumpf 1.28 request->messageId,
2537 CIMException(),
2538 request->queueIds.copyAndPop(),
2539 operationalStatus);
|
2540 chip 1.1
2541 // preserve message key
2542 response->setKey(request->getKey());
2543
2544 // Set HTTP method in response from request
2545 response->setHttpMethod (request->getHttpMethod ());
2546
2547 PEG_METHOD_EXIT();
2548
2549 return(response);
2550 }
2551
|
2552 dj.gorey 1.25 Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message)
|
2553 chip 1.1 {
2554 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest");
2555
2556 CIMEnableModuleRequestMessage * request =
2557 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
2558
2559 PEGASUS_ASSERT(request != 0);
2560
2561 Array<Uint16> operationalStatus;
2562 operationalStatus.append(_MODULE_OK);
2563
2564 CIMEnableModuleResponseMessage * response =
2565 new CIMEnableModuleResponseMessage(
|
2566 kumpf 1.28 request->messageId,
2567 CIMException(),
2568 request->queueIds.copyAndPop(),
2569 operationalStatus);
|
2570 chip 1.1
2571 // preserve message key
2572 response->setKey(request->getKey());
2573
2574 // Set HTTP method in response from request
2575 response->setHttpMethod (request->getHttpMethod ());
2576
2577 PEG_METHOD_EXIT();
2578 return(response);
2579 }
2580
|
2581 dj.gorey 1.25 Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message)
|
2582 chip 1.1 {
2583 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");
2584
2585 CIMStopAllProvidersRequestMessage * request =
2586 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
2587
2588 PEGASUS_ASSERT(request != 0);
2589
2590 CIMStopAllProvidersResponseMessage * response =
2591 new CIMStopAllProvidersResponseMessage(
2592 request->messageId,
2593 CIMException(),
2594 request->queueIds.copyAndPop());
2595
2596 PEGASUS_ASSERT(response != 0);
2597
2598 // preserve message key
2599 response->setKey(request->getKey());
2600
2601 // Set HTTP method in response from request
2602 response->setHttpMethod (request->getHttpMethod ());
2603 chip 1.1
2604 // tell the provider manager to shutdown all the providers
|
2605 schuur 1.10 providerManager.shutdownAllProviders();
|
2606 chip 1.1
2607 PEG_METHOD_EXIT();
2608
2609 return(response);
2610 }
2611
2612 void DefaultProviderManager::_insertEntry (
2613 const Provider & provider,
2614 const EnableIndicationsResponseHandler *handler)
2615 {
2616 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
2617 "DefaultProviderManager::_insertEntry");
2618
2619 String tableKey = _generateKey
2620 (provider);
2621
2622 _responseTable.insert (tableKey, const_cast<EnableIndicationsResponseHandler *>(handler));
2623
2624 PEG_METHOD_EXIT();
2625 }
2626
2627 chip 1.1 EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry(
2628 const String & key)
2629 {
2630 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
2631 "DefaultProviderManager::_removeEntry");
2632 EnableIndicationsResponseHandler *ret = 0;
2633
2634 _responseTable.lookup(key, ret);
|
2635 dj.gorey 1.25 _responseTable.remove(key); // why is this needed ? - we get killed when removed...
|
2636 chip 1.1
2637 PEG_METHOD_EXIT();
2638
2639 return(ret);
2640 }
2641
2642 String DefaultProviderManager::_generateKey (
2643 const Provider & provider)
2644 {
2645 String tableKey;
2646
2647 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
2648 "DefaultProviderManager::_generateKey");
2649
2650 //
2651 // Append provider key values to key
2652 //
2653 String providerName = provider.getName();
2654 String providerFileName = provider.getModule()->getFileName();
2655 tableKey.append (providerName);
2656 tableKey.append (providerFileName);
2657 chip 1.1
2658 PEG_METHOD_EXIT();
2659
2660 return(tableKey);
|
2661 schuur 1.18 }
2662
2663 String DefaultProviderManager::_generateKey (
2664 const String & providerName,
2665 const String & providerFileName)
2666 {
2667 String tableKey;
2668
2669 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
2670 "DefaultProviderManagerService::_generateKey");
2671
2672 //
2673 // Append providerName and providerFileName to key
2674 //
2675 tableKey.append (providerName);
2676 tableKey.append (providerFileName);
2677
2678 PEG_METHOD_EXIT ();
2679 return tableKey;
|
2680 chip 1.5 }
2681
|
2682 kumpf 1.28 ProviderName DefaultProviderManager::_resolveProviderName(
2683 const ProviderIdContainer & providerId)
|
2684 chip 1.5 {
|
2685 kumpf 1.28 String providerName;
2686 String fileName;
2687 String interfaceName;
2688 CIMValue genericValue;
2689
2690 genericValue = providerId.getProvider().getProperty(
2691 providerId.getProvider().findProperty("Name")).getValue();
2692 genericValue.get(providerName);
2693
2694 genericValue = providerId.getModule().getProperty(
2695 providerId.getModule().findProperty("Location")).getValue();
2696 genericValue.get(fileName);
2697 fileName = _resolvePhysicalName(fileName);
2698
2699 // ATTN: This attribute is probably not required
2700 genericValue = providerId.getModule().getProperty(
2701 providerId.getModule().findProperty("InterfaceType")).getValue();
2702 genericValue.get(interfaceName);
|
2703 chip 1.5
|
2704 kumpf 1.28 // Check if the provider module is blocked
2705 Array<Uint16> operationalStatus;
2706 Uint32 pos = providerId.getModule().findProperty(
2707 CIMName("OperationalStatus"));
2708 PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
2709 providerId.getModule().getProperty(pos).getValue().get(operationalStatus);
|
2710 schuur 1.14
|
2711 kumpf 1.28 for(Uint32 i = 0; i < operationalStatus.size(); i++)
2712 {
2713 if(operationalStatus[i] == _MODULE_STOPPED ||
2714 operationalStatus[i] == _MODULE_STOPPING)
2715 {
2716 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,
2717 MessageLoaderParms(
2718 "ProviderManager.ProviderManagerService.PROVIDER_BLOCKED",
2719 "provider blocked."));
2720 }
2721 }
|
2722 chip 1.5
|
2723 kumpf 1.28 return ProviderName(providerName, fileName, interfaceName, 0);
|
2724 schuur 1.23 }
2725
|
2726 kumpf 1.31 Boolean DefaultProviderManager::hasActiveProviders()
2727 {
2728 return providerManager.hasActiveProviders();
2729 }
2730
2731 void DefaultProviderManager::unloadIdleProviders()
|
2732 schuur 1.23 {
|
2733 kumpf 1.31 providerManager.unloadIdleProviders();
|
2734 chip 1.1 }
2735
|
2736 kumpf 1.26 PEGASUS_NAMESPACE_END
|
Return to
DefaultProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Default