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