pegasus/src/Pegasus/Provider/InternalCIMOMHandleRep.cpp - annotate

Return to InternalCIMOMHandleRep.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Provider

1 karl 1.21 //%2006////////////////////////////////////////////////////////////////////////
2 david.dillard 1.9 //
3 karl 1.12 // 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 david.dillard 1.9 // IBM Corp.; EMC Corporation, The Open Group.
7 karl 1.12 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; 8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 karl 1.13 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; 10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 karl 1.21 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; 12 // EMC Corporation; Symantec Corporation; The Open Group.
13 david.dillard 1.9 // 14 // Permission is hereby granted, free of charge, to any person obtaining a copy 15 // of this software and associated documentation files (the "Software"), to 16 // deal in the Software without restriction, including without limitation the 17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 18 // sell copies of the Software, and to permit persons to whom the Software is 19 // furnished to do so, subject to the following conditions:
20 karl 1.21 //
21 david.dillard 1.9 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 29 // 30 //============================================================================== 31 // 32 // Author: Chip Vincent (cvincent@us.ibm.com) 33 //
34 chip 1.17 // Modified By: 35 // Carol Ann Krug Graves, Hewlett-Packard Company (carolann_graves@hp.com) 36 // Mike Day, IBM (mdday@us.ibm.com) 37 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) 38 // Seema Gupta, (gseema@in.ibm.com for PEP135) 39 // Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090
40 david.dillard 1.9 // 41 //%///////////////////////////////////////////////////////////////////////////// 42 43 44 #include <Pegasus/Common/Constants.h> 45 #include <Pegasus/Common/XmlWriter.h> 46 #include <Pegasus/Common/Thread.h> 47 #include <Pegasus/Common/CIMMessage.h> 48 #include <Pegasus/Common/Tracer.h>
49 chip 1.17 #include <Pegasus/Common/AutoPtr.h>
50 david.dillard 1.9 51 #ifdef PEGASUS_OS_OS400 52 #include <qycmutilu2.H> 53 #include "OS400ConvertChar.h" 54 #include "CIMOMHandleOS400UserState.h" 55 #include "CIMOMHandleOS400SystemState.h" 56 #endif 57 58 #include "InternalCIMOMHandleRep.h" 59 60 PEGASUS_NAMESPACE_BEGIN 61
62 chip 1.17 InternalCIMOMHandleMessageQueue::InternalCIMOMHandleMessageQueue(void)
63 david.dillard 1.9 : MessageQueue(PEGASUS_QUEUENAME_INTERNALCLIENT),
64 chip 1.17 _output_qid(0), 65 _return_qid(0),
66 mike 1.22 _response(0)
67 david.dillard 1.9 {
68 chip 1.17 // output queue is the binary message handler
69 david.dillard 1.9 MessageQueue* out = MessageQueue::lookup(PEGASUS_QUEUENAME_BINARY_HANDLER); 70
71 chip 1.17 PEGASUS_ASSERT(out != 0);
72 david.dillard 1.9
73 chip 1.17 _output_qid = out->getQueueId();
74 a.arora 1.11
75 chip 1.17 // input queue is this 76 _return_qid = getQueueId();
77 a.arora 1.11 } 78
79 chip 1.17 InternalCIMOMHandleMessageQueue::~InternalCIMOMHandleMessageQueue(void)
80 david.dillard 1.9 { 81 try 82 {
83 chip 1.17 // ATTN: release any unprocessed responses
84 mike 1.24 _response.clear();
85 david.dillard 1.9 }
86 chip 1.17 catch(...)
87 david.dillard 1.9 { 88 } 89 } 90
91 chip 1.17 void InternalCIMOMHandleMessageQueue::handleEnqueue(void)
92 david.dillard 1.9 {
93 chip 1.17 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleMessageQueue::handleEnqueue");
94 david.dillard 1.9 95 Message* message = dequeue(); 96
97 chip 1.17 switch(message->getType())
98 david.dillard 1.9 {
99 chip 1.17 /* 100 case CIM_GET_CLASS_REQUEST_MESSAGE: 101 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE: 102 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE: 103 case CIM_CREATE_CLASS_REQUEST_MESSAGE: 104 case CIM_MODIFY_CLASS_REQUEST_MESSAGE: 105 case CIM_DELETE_CLASS_REQUEST_MESSAGE: 106 case CIM_GET_INSTANCE_REQUEST_MESSAGE: 107 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: 108 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: 109 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: 110 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: 111 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: 112 case CIM_EXEC_QUERY_REQUEST_MESSAGE: 113 case CIM_ASSOCIATORS_REQUEST_MESSAGE: 114 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: 115 case CIM_REFERENCES_REQUEST_MESSAGE: 116 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: 117 case CIM_GET_PROPERTY_REQUEST_MESSAGE: 118 case CIM_SET_PROPERTY_REQUEST_MESSAGE: 119 case CIM_INVOKE_METHOD_REQUEST_MESSAGE: 120 chip 1.17 sendRequest(message);
121 david.dillard 1.9
122 chip 1.17 break; 123 */
124 david.dillard 1.9 case CIM_GET_CLASS_RESPONSE_MESSAGE: 125 case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE: 126 case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE: 127 case CIM_CREATE_CLASS_RESPONSE_MESSAGE: 128 case CIM_MODIFY_CLASS_RESPONSE_MESSAGE: 129 case CIM_DELETE_CLASS_RESPONSE_MESSAGE: 130 case CIM_GET_INSTANCE_RESPONSE_MESSAGE: 131 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE: 132 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE: 133 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE: 134 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE: 135 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE: 136 case CIM_EXEC_QUERY_RESPONSE_MESSAGE: 137 case CIM_ASSOCIATORS_RESPONSE_MESSAGE: 138 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE: 139 case CIM_REFERENCES_RESPONSE_MESSAGE: 140 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE: 141 case CIM_GET_PROPERTY_RESPONSE_MESSAGE: 142 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
143 kumpf 1.15 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
144 mike 1.22 _response.enqueue(message);
145 chip 1.17
146 david.dillard 1.9 break;
147 chip 1.17 default: 148 PEG_TRACE_STRING( 149 TRC_DISCARDED_DATA, 150 Tracer::LEVEL2, 151 "Error: unexpected message type"); 152 153 delete message;
154 david.dillard 1.9
155 chip 1.17 break;
156 david.dillard 1.9 }
157 chip 1.17
158 david.dillard 1.9 PEG_METHOD_EXIT(); 159 } 160
161 chip 1.17 CIMResponseMessage* InternalCIMOMHandleMessageQueue::sendRequest(CIMRequestMessage* request)
162 david.dillard 1.9 {
163 chip 1.17 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::sendRequest"); 164 165 AutoMutex autoMutex(_mutex); 166 167 // update message to include routing information 168 request->dest = _output_qid; 169 request->queueIds.push(_return_qid); 170 request->queueIds.push(_output_qid); 171 172 // locate destination 173 MessageQueueService* service = 174 dynamic_cast<MessageQueueService *>( 175 MessageQueue::lookup(_output_qid)); 176 177 PEGASUS_ASSERT(service != 0);
178 david.dillard 1.9
179 chip 1.17 // forward request 180 if(service->SendForget(request) == false)
181 david.dillard 1.9 {
182 chip 1.17 PEG_METHOD_EXIT(); 183 throw Exception("Failed to send message"); 184 }
185 david.dillard 1.9
186 chip 1.17 // wait for response 187 CIMResponseMessage* response =
188 mike 1.22 dynamic_cast<CIMResponseMessage *>(_response.dequeue_wait());
189 david.dillard 1.9 190 PEG_METHOD_EXIT();
191 chip 1.17 return(response); 192 } 193 194 static void _deleteContentLanguage(void* data) 195 { 196 if(data != 0) 197 {
198 kumpf 1.19 ContentLanguageList* cl = static_cast<ContentLanguageList*>(data);
199 chip 1.17 200 delete cl; 201 }
202 david.dillard 1.9 } 203
204 chip 1.17 static OperationContext _filterOperationContext(const OperationContext& context)
205 david.dillard 1.9 {
206 chip 1.17 OperationContext temp; 207 208 #ifdef PEGASUS_OS_OS400 209 // on OS/400, do not allow the provider set the user name for the request 210 // get the user name from the current thread. 211 char os400UserName[11]; 212 213 if(ycmGetCurrentUser(os400UserName) == 0) 214 { 215 throw CIMException( 216 CIM_ERR_FAILED, 217 MessageLoaderParms( 218 "Common.CIMOMHandleOS400UserState.UNKNOWN_ERROR", 219 "An internal error occurred during the processing of the CIMOM handle")); 220 }
221 david.dillard 1.9
222 chip 1.17 EtoA(os400UserName); 223 temp.insert(IdentityContainer(String(os400UserName))); 224 #else
225 a.dunfey 1.23 if(context.contains(IdentityContainer::NAME))
226 david.dillard 1.9 {
227 chip 1.17 // propagate the identity container if it exists (get() with throw 228 // an exception if it does not) 229 temp.insert(context.get(IdentityContainer::NAME));
230 david.dillard 1.9 }
231 a.dunfey 1.23 else
232 david.dillard 1.9 {
233 chip 1.17 temp.insert(IdentityContainer(String::EMPTY));
234 david.dillard 1.9 }
235 chip 1.17 #endif 236
237 a.dunfey 1.23 if(context.contains(AcceptLanguageListContainer::NAME))
238 david.dillard 1.9 {
239 chip 1.17 // propagate the accept languages container if it exists (get() with throw 240 // an exception if it does not exist) 241 temp.insert(context.get(AcceptLanguageListContainer::NAME));
242 david.dillard 1.9 }
243 a.dunfey 1.23 else
244 chip 1.17 { 245 // If the container is not found then try to use the
246 kumpf 1.19 // AcceptLanguageList from the current thread 247 AcceptLanguageList* pal = Thread::getLanguages();
248 david.dillard 1.9
249 chip 1.17 if(pal != 0)
250 david.dillard 1.9 {
251 chip 1.17 temp.insert(AcceptLanguageListContainer(*pal));
252 david.dillard 1.9 }
253 dave.sudlik 1.20 else 254 { 255 temp.insert(AcceptLanguageListContainer(AcceptLanguageList())); 256 }
257 chip 1.17 }
258 david.dillard 1.9
259 a.dunfey 1.23 if(context.contains(ContentLanguageListContainer::NAME))
260 chip 1.17 { 261 // propagate the accept languages container if it exists (get() with throw 262 // an exception if it does not) 263 temp.insert(context.get(ContentLanguageListContainer::NAME));
264 david.dillard 1.9 }
265 a.dunfey 1.23 else
266 david.dillard 1.9 {
267 kumpf 1.19 temp.insert(ContentLanguageListContainer(ContentLanguageList()));
268 david.dillard 1.9 } 269
270 a.dunfey 1.23 return temp;
271 chip 1.17 } 272 273 InternalCIMOMHandleRep::InternalCIMOMHandleRep() 274 { 275 } 276 277 InternalCIMOMHandleRep::~InternalCIMOMHandleRep() 278 { 279 }
280 david.dillard 1.9 281 #ifdef PEGASUS_OS_OS400
282 chip 1.17 InternalCIMOMHandleRep::InternalCIMOMHandleRep(Uint32 os400UserStateKey) 283 : _chOS400(os400UserStateKey) 284 { 285 } 286 287 void InternalCIMOMHandleRep::setOS400ProfileHandle(const char* profileHandle) 288 { 289 memcpy(os400PH, profileHandle, 12); 290 }
291 david.dillard 1.9 #endif
292 chip 1.17 293 CIMResponseMessage* InternalCIMOMHandleRep::do_request(CIMRequestMessage* request) 294 { 295 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::do_request"); 296 297 #ifdef PEGASUS_OS_OS400 298 // On OS/400, this code runs in a system state thread. Swap the 299 // thread profile to be able to access server resources. 300 if(CIMOMHandleOS400SystemState::setProfileHandle(os400PH) != CIM_ERR_SUCCESS)
301 konrad.r 1.16 {
302 chip 1.17 PEG_METHOD_EXIT(); 303 throw Exception("Could not set profile handle");
304 konrad.r 1.16 }
305 chip 1.17 #endif
306 david.dillard 1.9
307 chip 1.17 /* 308 Uint32 timeout = 0;
309 david.dillard 1.9 310 try 311 { 312 const TimeoutContainer* p = dynamic_cast<const TimeoutContainer*>( 313 &(context.get(TimeoutContainer::NAME))); 314 if (p) 315 { 316 timeout = p->getTimeOut(); 317 } 318 }
319 chip 1.17 catch(Exception &)
320 david.dillard 1.9 { 321 } 322 323 try 324 {
325 chip 1.17 if(timeout)
326 david.dillard 1.9 { 327 _msg_avail.time_wait(timeout); 328 } 329 else 330 { 331 _msg_avail.wait(); 332 } 333 }
334 chip 1.17 catch(TimeOut&)
335 david.dillard 1.9 { 336 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2, 337 "timeout waiting for response"); 338 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( 339 "Provider.CIMOMHandle.EMPTY_CIM_RESPONSE", 340 "Empty CIM Response")); 341 }
342 chip 1.17 catch(...)
343 david.dillard 1.9 { 344 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2, 345 "Unexpected Exception"); 346 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( 347 "Provider.CIMOMHandle.EMPTY_CIM_RESPONSE", 348 "Empty CIM Response")); 349 }
350 chip 1.17 / 351 352 Message temp = _queue.sendRequest(request); 353 354 CIMResponseMessage* response = dynamic_cast<CIMResponseMessage*>(temp); 355 356 if(response == 0)
357 david.dillard 1.9 {
358 chip 1.17 delete response; 359 360 PEG_METHOD_EXIT(); 361 throw PEGASUS_CIM_EXCEPTION_L( 362 CIM_ERR_FAILED, 363 MessageLoaderParms( 364 "Provider.CIMOMHandle.EMPTY_CIM_RESPONSE", 365 "Empty CIM Response"));
366 david.dillard 1.9 } 367
368 chip 1.17 if(response->cimException.getCode() != CIM_ERR_SUCCESS)
369 david.dillard 1.9 {
370 chip 1.17 CIMException e(response->cimException);
371 david.dillard 1.9 372 delete response;
373 chip 1.17 374 PEG_METHOD_EXIT(); 375 throw e;
376 david.dillard 1.9 } 377
378 a.dunfey 1.23 if(response->operationContext.contains(ContentLanguageListContainer::NAME))
379 chip 1.17 { 380 // If the response has a Content-Language then save it into thread-specific storage 381 ContentLanguageListContainer container = 382 response->operationContext.get(ContentLanguageListContainer::NAME); 383 384 if(container.getLanguages().size() > 0) 385 { 386 Thread* currentThread = Thread::getCurrent(); 387 388 if(currentThread != 0) 389 { 390 // deletes the old tsd and creates a new one 391 currentThread->put_tsd( 392 "cimomHandleContentLanguages", 393 _deleteContentLanguage,
394 kumpf 1.19 sizeof(ContentLanguageList*), 395 new ContentLanguageList(container.getLanguages()));
396 chip 1.17 } 397 } 398 }
399 david.dillard 1.9 400 PEG_METHOD_EXIT();
401 a.dunfey 1.23 return response;
402 david.dillard 1.9 } 403 404 405 // 406 // CIM Operations 407 // 408 409 CIMClass InternalCIMOMHandleRep::getClass( 410 const OperationContext & context, 411 const CIMNamespaceName& nameSpace, 412 const CIMName& className, 413 Boolean localOnly, 414 Boolean includeQualifiers, 415 Boolean includeClassOrigin, 416 const CIMPropertyList& propertyList) 417 { 418 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::getClass"); 419
420 chip 1.17 #ifdef PEGASUS_OS_OS400
421 david.dillard 1.9 // If this is running in user-state, then run the request 422 // through the user-state layer 423 if (_chOS400.hasKey()) 424 {
425 chip 1.17 CIMClass cimClass = 426 _chOS400.getClass( 427 context, 428 nameSpace, 429 className, 430 localOnly, 431 includeQualifiers, 432 includeClassOrigin, 433 propertyList); 434 435 PEG_METHOD_EXIT(); 436 return(cimClass); 437 } 438 #endif 439 440 // encode request 441 CIMGetClassRequestMessage* request = 442 new CIMGetClassRequestMessage( 443 XmlWriter::getNextMessageId(),
444 david.dillard 1.9 nameSpace, 445 className, 446 localOnly, 447 includeQualifiers, 448 includeClassOrigin,
449 chip 1.17 propertyList, 450 QueueIdStack()); 451 452 // copy and adjust, as needed, the operation context 453 request->operationContext = _filterOperationContext(context);
454 dave.sudlik 1.20 // request->operationContext.get(AcceptLanguageListContainer::NAME);
455 chip 1.17 456 AutoPtr<CIMGetClassResponseMessage> response; 457 458 try 459 { 460 response.reset(dynamic_cast<CIMGetClassResponseMessage*>( 461 do_request(request)));
462 david.dillard 1.9
463 chip 1.17 if(response.get() == 0) 464 { 465 PEG_TRACE_STRING( 466 TRC_CIMOM_HANDLE, 467 Tracer::LEVEL2, 468 "Incorrect response type in CIMOMHandle");
469 david.dillard 1.9
470 chip 1.17 throw CIMException(CIM_ERR_FAILED); 471 }
472 david.dillard 1.9 }
473 chip 1.17 catch(CIMException &)
474 david.dillard 1.9 {
475 chip 1.17 PEG_METHOD_EXIT();
476 david.dillard 1.9 throw; 477 }
478 chip 1.17 catch(...)
479 david.dillard 1.9 {
480 chip 1.17 PEG_TRACE_STRING( 481 TRC_CIMOM_HANDLE, 482 Tracer::LEVEL2,
483 david.dillard 1.9 "Exception caught in CIMOMHandle");
484 chip 1.17 485 PEG_METHOD_EXIT(); 486 throw CIMException( 487 CIM_ERR_FAILED, 488 MessageLoaderParms( 489 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 490 "Exception caught in CIMOMHandle"));
491 david.dillard 1.9 } 492 493 CIMClass cimClass = response->cimClass; 494 495 PEG_METHOD_EXIT();
496 chip 1.17 return(cimClass);
497 david.dillard 1.9 } 498 499 500 Array<CIMClass> InternalCIMOMHandleRep::enumerateClasses( 501 const OperationContext & context, 502 const CIMNamespaceName& nameSpace, 503 const CIMName& className, 504 Boolean deepInheritance, 505 Boolean localOnly, 506 Boolean includeQualifiers, 507 Boolean includeClassOrigin) 508 { 509 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 510 "InternalCIMOMHandleRep::enumerateClasses"); 511
512 chip 1.17 #ifdef PEGASUS_OS_OS400
513 david.dillard 1.9 // If this is running in user-state, then run the request 514 // through the user-state layer 515 if (_chOS400.hasKey()) 516 {
517 chip 1.17 Array<CIMClass> cimClasses = 518 _chOS400.enumerateClasses( 519 context, 520 nameSpace, 521 className, 522 deepInheritance, 523 localOnly, 524 includeQualifiers, 525 includeClassOrigin); 526 527 PEG_METHOD_EXIT(); 528 return(cimClasses); 529 } 530 #endif
531 david.dillard 1.9 532 CIMEnumerateClassesRequestMessage* request = 533 new CIMEnumerateClassesRequestMessage( 534 XmlWriter::getNextMessageId(), 535 nameSpace, 536 className, 537 deepInheritance, 538 localOnly, 539 includeQualifiers, 540 includeClassOrigin,
541 chip 1.17 QueueIdStack());
542 david.dillard 1.9
543 chip 1.17 // copy and adjust, as needed, the operation context 544 request->operationContext = _filterOperationContext(context);
545 david.dillard 1.9
546 chip 1.17 AutoPtr<CIMEnumerateClassesResponseMessage> response;
547 david.dillard 1.9 548 try 549 {
550 chip 1.17 response.reset(dynamic_cast<CIMEnumerateClassesResponseMessage*>( 551 do_request(request))); 552 553 if(response.get() == 0) 554 { 555 PEG_TRACE_STRING( 556 TRC_CIMOM_HANDLE, 557 Tracer::LEVEL2, 558 "Incorrect response type in CIMOMHandle"); 559 560 throw CIMException(CIM_ERR_FAILED); 561 }
562 david.dillard 1.9 }
563 chip 1.17 catch(CIMException &)
564 david.dillard 1.9 {
565 chip 1.17 PEG_METHOD_EXIT();
566 david.dillard 1.9 throw; 567 }
568 chip 1.17 catch(...)
569 david.dillard 1.9 {
570 chip 1.17 PEG_TRACE_STRING( 571 TRC_CIMOM_HANDLE, 572 Tracer::LEVEL2,
573 david.dillard 1.9 "Exception caught in CIMOMHandle");
574 chip 1.17 575 PEG_METHOD_EXIT(); 576 throw CIMException( 577 CIM_ERR_FAILED, 578 MessageLoaderParms( 579 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 580 "Exception caught in CIMOMHandle"));
581 david.dillard 1.9 }
582 chip 1.17
583 david.dillard 1.9 Array<CIMClass> cimClasses = response->cimClasses;
584 chip 1.17
585 david.dillard 1.9 PEG_METHOD_EXIT();
586 chip 1.17 return(cimClasses);
587 david.dillard 1.9 } 588 589 590 Array<CIMName> InternalCIMOMHandleRep::enumerateClassNames( 591 const OperationContext & context, 592 const CIMNamespaceName &nameSpace, 593 const CIMName& className, 594 Boolean deepInheritance) 595 { 596 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 597 "InternalCIMOMHandleRep::enumerateClassNames"); 598
599 chip 1.17 #ifdef PEGASUS_OS_OS400
600 david.dillard 1.9 // If this is running in user-state, then run the request 601 // through the user-state layer 602 if (_chOS400.hasKey()) 603 {
604 chip 1.17 Array<CIMName> cimClassNames = 605 _chOS400.enumerateClassNames( 606 context, 607 nameSpace, 608 className, 609 deepInheritance); 610 611 PEG_METHOD_EXIT(); 612 return(cimClassNames); 613 } 614 #endif
615 david.dillard 1.9 616 CIMEnumerateClassNamesRequestMessage* request = 617 new CIMEnumerateClassNamesRequestMessage(
618 chip 1.17 XmlWriter::getNextMessageId(), 619 nameSpace, 620 className, 621 deepInheritance, 622 QueueIdStack()); 623 624 // copy and adjust, as needed, the operation context 625 request->operationContext = _filterOperationContext(context);
626 david.dillard 1.9
627 chip 1.17 AutoPtr<CIMEnumerateClassNamesResponseMessage> response;
628 david.dillard 1.9 629 try 630 {
631 chip 1.17 response.reset(dynamic_cast<CIMEnumerateClassNamesResponseMessage*>( 632 do_request(request))); 633 634 if(response.get() == 0) 635 { 636 PEG_TRACE_STRING( 637 TRC_CIMOM_HANDLE, 638 Tracer::LEVEL2, 639 "Incorrect response type in CIMOMHandle"); 640 641 throw CIMException(CIM_ERR_FAILED); 642 }
643 david.dillard 1.9 }
644 chip 1.17 catch(CIMException &)
645 david.dillard 1.9 {
646 chip 1.17 PEG_METHOD_EXIT();
647 david.dillard 1.9 throw; 648 }
649 chip 1.17 catch(...)
650 david.dillard 1.9 {
651 chip 1.17 PEG_TRACE_STRING( 652 TRC_CIMOM_HANDLE, 653 Tracer::LEVEL2,
654 david.dillard 1.9 "Exception caught in CIMOMHandle");
655 chip 1.17 656 PEG_METHOD_EXIT(); 657 throw CIMException( 658 CIM_ERR_FAILED, 659 MessageLoaderParms( 660 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 661 "Exception caught in CIMOMHandle"));
662 david.dillard 1.9 } 663
664 chip 1.17 Array<CIMName> cimClassNames = response->classNames; 665
666 david.dillard 1.9 PEG_METHOD_EXIT();
667 chip 1.17 return(cimClassNames);
668 david.dillard 1.9 } 669 670 671 void InternalCIMOMHandleRep::createClass( 672 const OperationContext & context, 673 const CIMNamespaceName& nameSpace, 674 const CIMClass& newClass) 675 { 676 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::createClass"); 677
678 chip 1.17 #ifdef PEGASUS_OS_OS400
679 david.dillard 1.9 // If this is running in user-state, then run the request 680 // through the user-state layer 681 if (_chOS400.hasKey()) 682 { 683 _chOS400.createClass( 684 context, 685 nameSpace, 686 newClass);
687 chip 1.17 688 PEG_METHOD_EXIT();
689 david.dillard 1.9 return; 690 }
691 chip 1.17 #endif
692 david.dillard 1.9 693 CIMCreateClassRequestMessage* request = 694 new CIMCreateClassRequestMessage( 695 XmlWriter::getNextMessageId(), 696 nameSpace, 697 newClass,
698 chip 1.17 QueueIdStack());
699 david.dillard 1.9
700 chip 1.17 // copy and adjust, as needed, the operation context 701 request->operationContext = _filterOperationContext(context);
702 david.dillard 1.9
703 chip 1.17 AutoPtr<CIMCreateClassResponseMessage> response;
704 david.dillard 1.9 705 try 706 {
707 chip 1.17 response.reset(dynamic_cast<CIMCreateClassResponseMessage*>( 708 do_request(request))); 709 710 if(response.get() == 0) 711 { 712 PEG_TRACE_STRING( 713 TRC_CIMOM_HANDLE, 714 Tracer::LEVEL2, 715 "Incorrect response type in CIMOMHandle"); 716 717 throw CIMException(CIM_ERR_FAILED); 718 }
719 david.dillard 1.9 }
720 chip 1.17 catch(CIMException &)
721 david.dillard 1.9 {
722 chip 1.17 PEG_METHOD_EXIT();
723 david.dillard 1.9 throw; 724 }
725 chip 1.17 catch(...)
726 david.dillard 1.9 {
727 chip 1.17 PEG_TRACE_STRING( 728 TRC_CIMOM_HANDLE, 729 Tracer::LEVEL2,
730 david.dillard 1.9 "Exception caught in CIMOMHandle");
731 chip 1.17 732 PEG_METHOD_EXIT(); 733 throw CIMException( 734 CIM_ERR_FAILED, 735 MessageLoaderParms( 736 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 737 "Exception caught in CIMOMHandle"));
738 david.dillard 1.9 } 739 740 PEG_METHOD_EXIT(); 741 return; 742 } 743 744 745 void InternalCIMOMHandleRep::modifyClass( 746 const OperationContext & context, 747 const CIMNamespaceName &nameSpace, 748 const CIMClass& modifiedClass) 749 { 750 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::modifyClass"); 751
752 chip 1.17 #ifdef PEGASUS_OS_OS400
753 david.dillard 1.9 // If this is running in user-state, then run the request 754 // through the user-state layer 755 if (_chOS400.hasKey()) 756 { 757 _chOS400.modifyClass( 758 context, 759 nameSpace, 760 modifiedClass);
761 chip 1.17 762 PEG_METHOD_EXIT();
763 david.dillard 1.9 return; 764 }
765 chip 1.17 #endif
766 david.dillard 1.9 767 CIMModifyClassRequestMessage* request = 768 new CIMModifyClassRequestMessage( 769 XmlWriter::getNextMessageId(), 770 nameSpace, 771 modifiedClass,
772 chip 1.17 QueueIdStack());
773 david.dillard 1.9
774 chip 1.17 // copy and adjust, as needed, the operation context 775 request->operationContext = _filterOperationContext(context); 776 777 AutoPtr<CIMModifyClassResponseMessage> response;
778 david.dillard 1.9 779 try 780 {
781 chip 1.17 response.reset(dynamic_cast<CIMModifyClassResponseMessage*>( 782 do_request(request))); 783 784 if(response.get() == 0) 785 { 786 PEG_TRACE_STRING( 787 TRC_CIMOM_HANDLE, 788 Tracer::LEVEL2, 789 "Incorrect response type in CIMOMHandle"); 790 791 throw CIMException(CIM_ERR_FAILED); 792 }
793 david.dillard 1.9 }
794 chip 1.17 catch(CIMException &)
795 david.dillard 1.9 {
796 chip 1.17 PEG_METHOD_EXIT();
797 david.dillard 1.9 throw; 798 }
799 chip 1.17 catch(...)
800 david.dillard 1.9 {
801 chip 1.17 PEG_TRACE_STRING( 802 TRC_CIMOM_HANDLE, 803 Tracer::LEVEL2,
804 david.dillard 1.9 "Exception caught in CIMOMHandle");
805 chip 1.17 806 PEG_METHOD_EXIT(); 807 throw CIMException( 808 CIM_ERR_FAILED, 809 MessageLoaderParms( 810 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 811 "Exception caught in CIMOMHandle"));
812 david.dillard 1.9 } 813 814 PEG_METHOD_EXIT(); 815 return; 816 } 817 818 819 void InternalCIMOMHandleRep::deleteClass( 820 const OperationContext & context, 821 const CIMNamespaceName &nameSpace, 822 const CIMName& className) 823 { 824 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::deleteClass"); 825
826 chip 1.17 #ifdef PEGASUS_OS_OS400
827 david.dillard 1.9 // If this is running in user-state, then run the request 828 // through the user-state layer 829 if (_chOS400.hasKey()) 830 { 831 _chOS400.deleteClass( 832 context, 833 nameSpace, 834 className);
835 chip 1.17 836 PEG_METHOD_EXIT();
837 david.dillard 1.9 return; 838 }
839 chip 1.17 #endif
840 david.dillard 1.9 841 // encode request 842 CIMDeleteClassRequestMessage* request = 843 new CIMDeleteClassRequestMessage( 844 XmlWriter::getNextMessageId(), 845 nameSpace, 846 className,
847 chip 1.17 QueueIdStack()); 848 849 // copy and adjust, as needed, the operation context 850 request->operationContext = _filterOperationContext(context);
851 david.dillard 1.9
852 chip 1.17 AutoPtr<CIMDeleteClassResponseMessage> response;
853 david.dillard 1.9
854 chip 1.17 try 855 { 856 response.reset(dynamic_cast<CIMDeleteClassResponseMessage*>( 857 do_request(request))); 858 859 if(response.get() == 0) 860 { 861 PEG_TRACE_STRING( 862 TRC_CIMOM_HANDLE, 863 Tracer::LEVEL2, 864 "Incorrect response type in CIMOMHandle"); 865 866 throw CIMException(CIM_ERR_FAILED); 867 }
868 david.dillard 1.9 }
869 chip 1.17 catch(CIMException &)
870 david.dillard 1.9 {
871 chip 1.17 PEG_METHOD_EXIT();
872 david.dillard 1.9 throw; 873 }
874 chip 1.17 catch(...)
875 david.dillard 1.9 {
876 chip 1.17 PEG_TRACE_STRING( 877 TRC_CIMOM_HANDLE, 878 Tracer::LEVEL2,
879 david.dillard 1.9 "Exception caught in CIMOMHandle");
880 chip 1.17 881 PEG_METHOD_EXIT(); 882 throw CIMException( 883 CIM_ERR_FAILED, 884 MessageLoaderParms( 885 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 886 "Exception caught in CIMOMHandle"));
887 david.dillard 1.9 }
888 chip 1.17
889 david.dillard 1.9 PEG_METHOD_EXIT(); 890 return; 891 } 892 893 894 CIMInstance InternalCIMOMHandleRep::getInstance( 895 const OperationContext & context, 896 const CIMNamespaceName &nameSpace, 897 const CIMObjectPath& instanceName, 898 Boolean localOnly, 899 Boolean includeQualifiers, 900 Boolean includeClassOrigin, 901 const CIMPropertyList& propertyList) 902 { 903 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::getInstance"); 904
905 chip 1.17 #ifdef PEGASUS_OS_OS400
906 david.dillard 1.9 // If this is running in user-state, then run the request 907 // through the user-state layer 908 if (_chOS400.hasKey()) 909 {
910 chip 1.17 CIMInstance cimInstance = 911 _chOS400.getInstance( 912 context, 913 nameSpace, 914 instanceName, 915 localOnly, 916 includeQualifiers, 917 includeClassOrigin, 918 propertyList); 919 920 PEG_METHOD_EXIT(); 921 return(cimInstance);
922 david.dillard 1.9 }
923 chip 1.17 #endif
924 david.dillard 1.9 925 // encode request 926 CIMGetInstanceRequestMessage* request = 927 new CIMGetInstanceRequestMessage( 928 XmlWriter::getNextMessageId(), 929 nameSpace, 930 instanceName, 931 localOnly, 932 includeQualifiers, 933 includeClassOrigin, 934 propertyList,
935 chip 1.17 QueueIdStack()); 936 937 // copy and adjust, as needed, the operation context 938 request->operationContext = _filterOperationContext(context);
939 david.dillard 1.9
940 chip 1.17 AutoPtr<CIMGetInstanceResponseMessage> response;
941 david.dillard 1.9 942 try 943 {
944 chip 1.17 response.reset(dynamic_cast<CIMGetInstanceResponseMessage*>( 945 do_request(request))); 946 947 if(response.get() == 0) 948 { 949 PEG_TRACE_STRING( 950 TRC_CIMOM_HANDLE, 951 Tracer::LEVEL2, 952 "Incorrect response type in CIMOMHandle"); 953 954 throw CIMException(CIM_ERR_FAILED); 955 }
956 david.dillard 1.9 }
957 chip 1.17 catch(CIMException &)
958 david.dillard 1.9 {
959 chip 1.17 PEG_METHOD_EXIT();
960 david.dillard 1.9 throw; 961 }
962 chip 1.17 catch(...)
963 david.dillard 1.9 {
964 chip 1.17 PEG_TRACE_STRING( 965 TRC_CIMOM_HANDLE, 966 Tracer::LEVEL2,
967 david.dillard 1.9 "Exception caught in CIMOMHandle");
968 chip 1.17 969 PEG_METHOD_EXIT(); 970 throw CIMException( 971 CIM_ERR_FAILED, 972 MessageLoaderParms( 973 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 974 "Exception caught in CIMOMHandle"));
975 david.dillard 1.9 } 976 977 CIMInstance cimInstance = response->cimInstance; 978 979 PEG_METHOD_EXIT(); 980 return(cimInstance); 981 } 982 983 Array<CIMInstance> InternalCIMOMHandleRep::enumerateInstances( 984 const OperationContext & context, 985 const CIMNamespaceName &nameSpace, 986 const CIMName& className, 987 Boolean deepInheritance, 988 Boolean localOnly, 989 Boolean includeQualifiers, 990 Boolean includeClassOrigin, 991 const CIMPropertyList& propertyList) 992 { 993 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 994 "InternalCIMOMHandleRep::enumerateInstances"); 995
996 chip 1.17 #ifdef PEGASUS_OS_OS400
997 david.dillard 1.9 // If this is running in user-state, then run the request 998 // through the user-state layer 999 if (_chOS400.hasKey()) 1000 {
1001 chip 1.17 Array<CIMInstance> cimInstances = 1002 _chOS400.enumerateInstances( 1003 context, 1004 nameSpace, 1005 className, 1006 deepInheritance, 1007 localOnly, 1008 includeQualifiers, 1009 includeClassOrigin, 1010 propertyList); 1011 1012 PEG_METHOD_EXIT(); 1013 return(cimInstances);
1014 david.dillard 1.9 }
1015 chip 1.17 #endif
1016 david.dillard 1.9 1017 // encode request 1018 CIMEnumerateInstancesRequestMessage* request = 1019 new CIMEnumerateInstancesRequestMessage( 1020 XmlWriter::getNextMessageId(), 1021 nameSpace, 1022 className, 1023 deepInheritance, 1024 localOnly, 1025 includeQualifiers, 1026 includeClassOrigin, 1027 propertyList,
1028 chip 1.17 QueueIdStack());
1029 david.dillard 1.9
1030 chip 1.17 // copy and adjust, as needed, the operation context 1031 request->operationContext = _filterOperationContext(context); 1032 1033 AutoPtr<CIMEnumerateInstancesResponseMessage> response;
1034 david.dillard 1.9 1035 try 1036 {
1037 chip 1.17 response.reset(dynamic_cast<CIMEnumerateInstancesResponseMessage*>( 1038 do_request(request))); 1039 1040 if(response.get() == 0) 1041 { 1042 PEG_TRACE_STRING( 1043 TRC_CIMOM_HANDLE, 1044 Tracer::LEVEL2, 1045 "Incorrect response type in CIMOMHandle"); 1046 1047 throw CIMException(CIM_ERR_FAILED); 1048 }
1049 david.dillard 1.9 }
1050 chip 1.17 catch(CIMException &)
1051 david.dillard 1.9 {
1052 chip 1.17 PEG_METHOD_EXIT();
1053 david.dillard 1.9 throw; 1054 }
1055 chip 1.17 catch(...)
1056 david.dillard 1.9 {
1057 chip 1.17 PEG_TRACE_STRING( 1058 TRC_CIMOM_HANDLE, 1059 Tracer::LEVEL2,
1060 david.dillard 1.9 "Exception caught in CIMOMHandle");
1061 chip 1.17 1062 PEG_METHOD_EXIT(); 1063 throw CIMException( 1064 CIM_ERR_FAILED, 1065 MessageLoaderParms( 1066 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1067 "Exception caught in CIMOMHandle"));
1068 david.dillard 1.9 } 1069 1070 Array<CIMInstance> cimInstances = response->cimNamedInstances; 1071 1072 PEG_METHOD_EXIT(); 1073 return(cimInstances); 1074 } 1075 1076 1077 Array<CIMObjectPath> InternalCIMOMHandleRep::enumerateInstanceNames( 1078 const OperationContext & context, 1079 const CIMNamespaceName &nameSpace, 1080 const CIMName& className) 1081 { 1082 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 1083 "InternalCIMOMHandleRep::enumerateInstanceNames"); 1084
1085 chip 1.17 #ifdef PEGASUS_OS_OS400
1086 david.dillard 1.9 // If this is running in user-state, then run the request 1087 // through the user-state layer 1088 if (_chOS400.hasKey()) 1089 {
1090 chip 1.17 Array<CIMObjectPath> cimObjectPaths = 1091 _chOS400.enumerateInstanceNames( 1092 context, 1093 nameSpace, 1094 className); 1095 1096 PEG_METHOD_EXIT(); 1097 return(cimObjectPaths);
1098 david.dillard 1.9 }
1099 chip 1.17 #endif
1100 david.dillard 1.9 1101 // encode request 1102 CIMEnumerateInstanceNamesRequestMessage* request = 1103 new CIMEnumerateInstanceNamesRequestMessage( 1104 XmlWriter::getNextMessageId(), 1105 nameSpace, 1106 className,
1107 chip 1.17 QueueIdStack());
1108 david.dillard 1.9
1109 chip 1.17 // copy and adjust, as needed, the operation context 1110 request->operationContext = _filterOperationContext(context); 1111 1112 AutoPtr<CIMEnumerateInstanceNamesResponseMessage> response;
1113 david.dillard 1.9 1114 try 1115 {
1116 chip 1.17 response.reset(dynamic_cast<CIMEnumerateInstanceNamesResponseMessage*>( 1117 do_request(request))); 1118 1119 if(response.get() == 0) 1120 { 1121 PEG_TRACE_STRING( 1122 TRC_CIMOM_HANDLE, 1123 Tracer::LEVEL2, 1124 "Incorrect response type in CIMOMHandle"); 1125 1126 throw CIMException(CIM_ERR_FAILED); 1127 }
1128 david.dillard 1.9 }
1129 chip 1.17 catch(CIMException &)
1130 david.dillard 1.9 {
1131 chip 1.17 PEG_METHOD_EXIT();
1132 david.dillard 1.9 throw; 1133 }
1134 chip 1.17 catch(...)
1135 david.dillard 1.9 {
1136 chip 1.17 PEG_TRACE_STRING( 1137 TRC_CIMOM_HANDLE, 1138 Tracer::LEVEL2,
1139 david.dillard 1.9 "Exception caught in CIMOMHandle");
1140 chip 1.17 1141 PEG_METHOD_EXIT(); 1142 throw CIMException( 1143 CIM_ERR_FAILED, 1144 MessageLoaderParms( 1145 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1146 "Exception caught in CIMOMHandle"));
1147 david.dillard 1.9 } 1148
1149 chip 1.17 Array<CIMObjectPath> cimObjectPaths = response->instanceNames;
1150 david.dillard 1.9 1151 PEG_METHOD_EXIT();
1152 chip 1.17 return(cimObjectPaths);
1153 david.dillard 1.9 } 1154 1155 CIMObjectPath InternalCIMOMHandleRep::createInstance( 1156 const OperationContext & context, 1157 const CIMNamespaceName &nameSpace, 1158 const CIMInstance& newInstance) 1159 { 1160 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 1161 "InternalCIMOMHandleRep::createInstance"); 1162
1163 chip 1.17 #ifdef PEGASUS_OS_OS400
1164 david.dillard 1.9 // If this is running in user-state, then run the request 1165 // through the user-state layer 1166 if (_chOS400.hasKey()) 1167 {
1168 chip 1.17 CIMObjectPath cimReference = 1169 _chOS400.createInstance( 1170 context, 1171 nameSpace, 1172 newInstance); 1173 1174 PEG_METHOD_EXIT(); 1175 return(cimReference);
1176 david.dillard 1.9 }
1177 chip 1.17 #endif
1178 david.dillard 1.9 1179 CIMCreateInstanceRequestMessage* request = 1180 new CIMCreateInstanceRequestMessage( 1181 XmlWriter::getNextMessageId(), 1182 nameSpace, 1183 newInstance,
1184 chip 1.17 QueueIdStack());
1185 david.dillard 1.9
1186 chip 1.17 // copy and adjust, as needed, the operation context 1187 request->operationContext = _filterOperationContext(context); 1188 1189 AutoPtr<CIMCreateInstanceResponseMessage> response;
1190 david.dillard 1.9 1191 try 1192 {
1193 chip 1.17 response.reset(dynamic_cast<CIMCreateInstanceResponseMessage*>( 1194 do_request(request))); 1195 1196 if(response.get() == 0) 1197 { 1198 PEG_TRACE_STRING( 1199 TRC_CIMOM_HANDLE, 1200 Tracer::LEVEL2, 1201 "Incorrect response type in CIMOMHandle"); 1202 1203 throw CIMException(CIM_ERR_FAILED); 1204 }
1205 david.dillard 1.9 }
1206 chip 1.17 catch(CIMException &)
1207 david.dillard 1.9 {
1208 chip 1.17 PEG_METHOD_EXIT();
1209 david.dillard 1.9 throw; 1210 }
1211 chip 1.17 catch(...)
1212 david.dillard 1.9 {
1213 chip 1.17 PEG_TRACE_STRING( 1214 TRC_CIMOM_HANDLE, 1215 Tracer::LEVEL2,
1216 david.dillard 1.9 "Exception caught in CIMOMHandle");
1217 chip 1.17 1218 PEG_METHOD_EXIT(); 1219 throw CIMException( 1220 CIM_ERR_FAILED, 1221 MessageLoaderParms( 1222 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1223 "Exception caught in CIMOMHandle"));
1224 david.dillard 1.9 } 1225 1226 CIMObjectPath cimReference = response->instanceName; 1227 1228 PEG_METHOD_EXIT(); 1229 return(cimReference); 1230 } 1231 1232 1233 void InternalCIMOMHandleRep::modifyInstance( 1234 const OperationContext & context, 1235 const CIMNamespaceName &nameSpace, 1236 const CIMInstance& modifiedInstance, 1237 Boolean includeQualifiers, 1238 const CIMPropertyList& propertyList) 1239 { 1240 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 1241 "InternalCIMOMHandleRep::modifyInstance"); 1242
1243 chip 1.17 #ifdef PEGASUS_OS_OS400
1244 david.dillard 1.9 // If this is running in user-state, then run the request 1245 // through the user-state layer 1246 if (_chOS400.hasKey()) 1247 { 1248 _chOS400.modifyInstance( 1249 context, 1250 nameSpace, 1251 modifiedInstance, 1252 includeQualifiers, 1253 propertyList);
1254 chip 1.17 1255 PEG_METHOD_EXIT();
1256 david.dillard 1.9 return; 1257 }
1258 chip 1.17 #endif
1259 david.dillard 1.9 1260 CIMModifyInstanceRequestMessage* request = 1261 new CIMModifyInstanceRequestMessage( 1262 XmlWriter::getNextMessageId(), 1263 nameSpace, 1264 modifiedInstance, 1265 includeQualifiers, 1266 propertyList,
1267 chip 1.17 QueueIdStack());
1268 david.dillard 1.9
1269 chip 1.17 // copy and adjust, as needed, the operation context 1270 request->operationContext = _filterOperationContext(context);
1271 david.dillard 1.9
1272 chip 1.17 AutoPtr<CIMModifyInstanceResponseMessage> response;
1273 david.dillard 1.9 1274 try 1275 {
1276 chip 1.17 response.reset(dynamic_cast<CIMModifyInstanceResponseMessage*>( 1277 do_request(request))); 1278 1279 if(response.get() == 0) 1280 { 1281 PEG_TRACE_STRING( 1282 TRC_CIMOM_HANDLE, 1283 Tracer::LEVEL2, 1284 "Incorrect response type in CIMOMHandle"); 1285 1286 throw CIMException(CIM_ERR_FAILED); 1287 }
1288 david.dillard 1.9 }
1289 chip 1.17 catch(CIMException &)
1290 david.dillard 1.9 {
1291 chip 1.17 PEG_METHOD_EXIT();
1292 david.dillard 1.9 throw; 1293 }
1294 chip 1.17 catch(...)
1295 david.dillard 1.9 {
1296 chip 1.17 PEG_TRACE_STRING( 1297 TRC_CIMOM_HANDLE, 1298 Tracer::LEVEL2,
1299 david.dillard 1.9 "Exception caught in CIMOMHandle");
1300 chip 1.17 1301 PEG_METHOD_EXIT(); 1302 throw CIMException( 1303 CIM_ERR_FAILED, 1304 MessageLoaderParms( 1305 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1306 "Exception caught in CIMOMHandle"));
1307 david.dillard 1.9 } 1308 1309 PEG_METHOD_EXIT(); 1310 return; 1311 } 1312 1313 1314 void InternalCIMOMHandleRep::deleteInstance( 1315 const OperationContext & context, 1316 const CIMNamespaceName &nameSpace, 1317 const CIMObjectPath& instanceName) 1318 { 1319 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 1320 "InternalCIMOMHandleRep::deleteInstance"); 1321
1322 chip 1.17 #ifdef PEGASUS_OS_OS400
1323 david.dillard 1.9 // If this is running in user-state, then run the request 1324 // through the user-state layer 1325 if (_chOS400.hasKey()) 1326 { 1327 _chOS400.deleteInstance( 1328 context, 1329 nameSpace, 1330 instanceName);
1331 chip 1.17 1332 PEG_METHOD_EXIT();
1333 david.dillard 1.9 return; 1334 }
1335 chip 1.17 #endif
1336 david.dillard 1.9 1337 CIMDeleteInstanceRequestMessage* request = 1338 new CIMDeleteInstanceRequestMessage( 1339 XmlWriter::getNextMessageId(), 1340 nameSpace, 1341 instanceName,
1342 chip 1.17 QueueIdStack());
1343 david.dillard 1.9
1344 chip 1.17 // copy and adjust, as needed, the operation context 1345 request->operationContext = _filterOperationContext(context);
1346 david.dillard 1.9
1347 chip 1.17 AutoPtr<CIMDeleteInstanceResponseMessage> response;
1348 david.dillard 1.9 1349 try 1350 {
1351 chip 1.17 response.reset(dynamic_cast<CIMDeleteInstanceResponseMessage*>( 1352 do_request(request))); 1353 1354 if(response.get() == 0) 1355 { 1356 PEG_TRACE_STRING( 1357 TRC_CIMOM_HANDLE, 1358 Tracer::LEVEL2, 1359 "Incorrect response type in CIMOMHandle"); 1360 1361 throw CIMException(CIM_ERR_FAILED); 1362 }
1363 david.dillard 1.9 }
1364 chip 1.17 catch(CIMException &)
1365 david.dillard 1.9 {
1366 chip 1.17 PEG_METHOD_EXIT();
1367 david.dillard 1.9 throw; 1368 }
1369 chip 1.17 catch(...)
1370 david.dillard 1.9 {
1371 chip 1.17 PEG_TRACE_STRING( 1372 TRC_CIMOM_HANDLE, 1373 Tracer::LEVEL2,
1374 david.dillard 1.9 "Exception caught in CIMOMHandle");
1375 chip 1.17 1376 PEG_METHOD_EXIT(); 1377 throw CIMException( 1378 CIM_ERR_FAILED, 1379 MessageLoaderParms( 1380 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1381 "Exception caught in CIMOMHandle"));
1382 david.dillard 1.9 } 1383 1384 PEG_METHOD_EXIT(); 1385 return; 1386 } 1387 1388 1389 Array<CIMObject> InternalCIMOMHandleRep::execQuery( 1390 const OperationContext & context, 1391 const CIMNamespaceName &nameSpace, 1392 const String& queryLanguage, 1393 const String& query) 1394 { 1395 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::execQuery"); 1396
1397 chip 1.17 #ifdef PEGASUS_OS_OS400
1398 david.dillard 1.9 // If this is running in user-state, then run the request 1399 // through the user-state layer 1400 if (_chOS400.hasKey()) 1401 {
1402 chip 1.17 Array<CIMObject> cimObjects = 1403 _chOS400.execQuery( 1404 context, 1405 nameSpace, 1406 queryLanguage, 1407 query); 1408 1409 PEG_METHOD_EXIT(); 1410 return(cimObjects);
1411 david.dillard 1.9 }
1412 chip 1.17 #endif
1413 david.dillard 1.9 1414 CIMExecQueryRequestMessage* request = 1415 new CIMExecQueryRequestMessage( 1416 XmlWriter::getNextMessageId(), 1417 nameSpace, 1418 queryLanguage, 1419 query,
1420 chip 1.17 QueueIdStack());
1421 david.dillard 1.9
1422 chip 1.17 // copy and adjust, as needed, the operation context 1423 request->operationContext = _filterOperationContext(context);
1424 david.dillard 1.9
1425 chip 1.17 AutoPtr<CIMExecQueryResponseMessage> response;
1426 david.dillard 1.9 1427 try 1428 {
1429 chip 1.17 response.reset(dynamic_cast<CIMExecQueryResponseMessage*>( 1430 do_request(request))); 1431 1432 if(response.get() == 0) 1433 { 1434 PEG_TRACE_STRING( 1435 TRC_CIMOM_HANDLE, 1436 Tracer::LEVEL2, 1437 "Incorrect response type in CIMOMHandle"); 1438 1439 throw CIMException(CIM_ERR_FAILED); 1440 }
1441 david.dillard 1.9 }
1442 chip 1.17 catch(CIMException &)
1443 david.dillard 1.9 {
1444 chip 1.17 PEG_METHOD_EXIT();
1445 david.dillard 1.9 throw; 1446 }
1447 chip 1.17 catch(...)
1448 david.dillard 1.9 {
1449 chip 1.17 PEG_TRACE_STRING( 1450 TRC_CIMOM_HANDLE, 1451 Tracer::LEVEL2,
1452 david.dillard 1.9 "Exception caught in CIMOMHandle");
1453 chip 1.17 1454 PEG_METHOD_EXIT(); 1455 throw CIMException( 1456 CIM_ERR_FAILED, 1457 MessageLoaderParms( 1458 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1459 "Exception caught in CIMOMHandle"));
1460 david.dillard 1.9 } 1461 1462 Array<CIMObject> cimObjects = response->cimObjects; 1463 1464 PEG_METHOD_EXIT(); 1465 return(cimObjects); 1466 } 1467 1468 1469 Array<CIMObject> InternalCIMOMHandleRep::associators( 1470 const OperationContext & context, 1471 const CIMNamespaceName &nameSpace, 1472 const CIMObjectPath& objectName, 1473 const CIMName& assocClass, 1474 const CIMName& resultClass, 1475 const String& role, 1476 const String& resultRole, 1477 Boolean includeQualifiers, 1478 Boolean includeClassOrigin, 1479 const CIMPropertyList& propertyList) 1480 { 1481 david.dillard 1.9 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::associators"); 1482
1483 chip 1.17 #ifdef PEGASUS_OS_OS400
1484 david.dillard 1.9 // If this is running in user-state, then run the request 1485 // through the user-state layer 1486 if (_chOS400.hasKey()) 1487 {
1488 chip 1.17 Array<CIMObject> cimObjects = 1489 _chOS400.associators( 1490 context, 1491 nameSpace, 1492 objectName, 1493 assocClass, 1494 resultClass, 1495 role, 1496 resultRole, 1497 includeQualifiers, 1498 includeClassOrigin, 1499 propertyList); 1500 1501 PEG_METHOD_EXIT(); 1502 return(cimObjects); 1503 } 1504 #endif 1505 1506 CIMAssociatorsRequestMessage* request = 1507 new CIMAssociatorsRequestMessage( 1508 XmlWriter::getNextMessageId(),
1509 david.dillard 1.9 nameSpace, 1510 objectName, 1511 assocClass, 1512 resultClass, 1513 role, 1514 resultRole, 1515 includeQualifiers, 1516 includeClassOrigin,
1517 chip 1.17 propertyList, 1518 QueueIdStack());
1519 david.dillard 1.9
1520 chip 1.17 // copy and adjust, as needed, the operation context 1521 request->operationContext = _filterOperationContext(context);
1522 david.dillard 1.9
1523 chip 1.17 AutoPtr<CIMAssociatorsResponseMessage> response;
1524 david.dillard 1.9 1525 try 1526 {
1527 chip 1.17 response.reset(dynamic_cast<CIMAssociatorsResponseMessage*>( 1528 do_request(request))); 1529 1530 if(response.get() == 0) 1531 { 1532 PEG_TRACE_STRING( 1533 TRC_CIMOM_HANDLE, 1534 Tracer::LEVEL2, 1535 "Incorrect response type in CIMOMHandle"); 1536 1537 throw CIMException(CIM_ERR_FAILED); 1538 }
1539 david.dillard 1.9 }
1540 chip 1.17 catch(CIMException &)
1541 david.dillard 1.9 {
1542 chip 1.17 PEG_METHOD_EXIT();
1543 david.dillard 1.9 throw; 1544 }
1545 chip 1.17 catch(...)
1546 david.dillard 1.9 {
1547 chip 1.17 PEG_TRACE_STRING( 1548 TRC_CIMOM_HANDLE, 1549 Tracer::LEVEL2,
1550 david.dillard 1.9 "Exception caught in CIMOMHandle");
1551 chip 1.17 1552 PEG_METHOD_EXIT(); 1553 throw CIMException( 1554 CIM_ERR_FAILED, 1555 MessageLoaderParms( 1556 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1557 "Exception caught in CIMOMHandle"));
1558 david.dillard 1.9 } 1559 1560 Array<CIMObject> cimObjects = response->cimObjects; 1561 1562 PEG_METHOD_EXIT(); 1563 return(cimObjects); 1564 } 1565 1566 1567 Array<CIMObjectPath> InternalCIMOMHandleRep::associatorNames( 1568 const OperationContext & context, 1569 const CIMNamespaceName &nameSpace, 1570 const CIMObjectPath& objectName, 1571 const CIMName& assocClass, 1572 const CIMName& resultClass, 1573 const String& role, 1574 const String& resultRole) 1575 { 1576 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 1577 "InternalCIMOMHandleRep::associatorNames"); 1578
1579 chip 1.17 #ifdef PEGASUS_OS_OS400
1580 david.dillard 1.9 // If this is running in user-state, then run the request 1581 // through the user-state layer 1582 if (_chOS400.hasKey()) 1583 {
1584 chip 1.17 Array<CIMObjectPath> cimObjectPaths = 1585 _chOS400.associatorNames( 1586 context, 1587 nameSpace, 1588 objectName, 1589 assocClass, 1590 resultClass, 1591 role, 1592 resultRole); 1593 1594 PEG_METHOD_EXIT(); 1595 return(cimObjectPaths);
1596 david.dillard 1.9 }
1597 chip 1.17 #endif
1598 david.dillard 1.9 1599 CIMAssociatorNamesRequestMessage* request = 1600 new CIMAssociatorNamesRequestMessage( 1601 XmlWriter::getNextMessageId(), 1602 nameSpace, 1603 objectName, 1604 assocClass, 1605 resultClass, 1606 role, 1607 resultRole,
1608 chip 1.17 QueueIdStack());
1609 david.dillard 1.9
1610 chip 1.17 // copy and adjust, as needed, the operation context 1611 request->operationContext = _filterOperationContext(context);
1612 david.dillard 1.9
1613 chip 1.17 AutoPtr<CIMAssociatorNamesResponseMessage> response;
1614 david.dillard 1.9 1615 try 1616 {
1617 chip 1.17 response.reset(dynamic_cast<CIMAssociatorNamesResponseMessage*>( 1618 do_request(request))); 1619 1620 if(response.get() == 0) 1621 { 1622 PEG_TRACE_STRING( 1623 TRC_CIMOM_HANDLE, 1624 Tracer::LEVEL2, 1625 "Incorrect response type in CIMOMHandle"); 1626 1627 throw CIMException(CIM_ERR_FAILED); 1628 }
1629 david.dillard 1.9 }
1630 chip 1.17 catch(CIMException &)
1631 david.dillard 1.9 {
1632 chip 1.17 PEG_METHOD_EXIT();
1633 david.dillard 1.9 throw; 1634 }
1635 chip 1.17 catch(...)
1636 david.dillard 1.9 {
1637 chip 1.17 PEG_TRACE_STRING( 1638 TRC_CIMOM_HANDLE, 1639 Tracer::LEVEL2,
1640 david.dillard 1.9 "Exception caught in CIMOMHandle");
1641 chip 1.17 1642 PEG_METHOD_EXIT(); 1643 throw CIMException( 1644 CIM_ERR_FAILED, 1645 MessageLoaderParms( 1646 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1647 "Exception caught in CIMOMHandle"));
1648 david.dillard 1.9 } 1649 1650 Array<CIMObjectPath> cimObjectPaths = response->objectNames; 1651 1652 PEG_METHOD_EXIT(); 1653 return(cimObjectPaths); 1654 } 1655 1656 1657 Array<CIMObject> InternalCIMOMHandleRep::references( 1658 const OperationContext & context, 1659 const CIMNamespaceName &nameSpace, 1660 const CIMObjectPath& objectName, 1661 const CIMName& resultClass, 1662 const String& role, 1663 Boolean includeQualifiers, 1664 Boolean includeClassOrigin, 1665 const CIMPropertyList& propertyList) 1666 { 1667 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::references"); 1668
1669 chip 1.17 #ifdef PEGASUS_OS_OS400
1670 david.dillard 1.9 // If this is running in user-state, then run the request 1671 // through the user-state layer 1672 if (_chOS400.hasKey()) 1673 {
1674 chip 1.17 Array<CIMObject> cimObjects = 1675 _chOS400.references( 1676 context, 1677 nameSpace, 1678 objectName, 1679 resultClass, 1680 role, 1681 includeQualifiers, 1682 includeClassOrigin, 1683 propertyList); 1684 1685 PEG_METHOD_EXIT(); 1686 return(cimObjects);
1687 david.dillard 1.9 }
1688 chip 1.17 #endif
1689 david.dillard 1.9 1690 CIMReferencesRequestMessage* request = 1691 new CIMReferencesRequestMessage( 1692 XmlWriter::getNextMessageId(), 1693 nameSpace, 1694 objectName, 1695 resultClass, 1696 role, 1697 includeQualifiers, 1698 includeClassOrigin, 1699 propertyList,
1700 chip 1.17 QueueIdStack());
1701 david.dillard 1.9
1702 chip 1.17 // copy and adjust, as needed, the operation context 1703 request->operationContext = _filterOperationContext(context);
1704 david.dillard 1.9
1705 chip 1.17 AutoPtr<CIMReferencesResponseMessage> response;
1706 david.dillard 1.9 1707 try 1708 {
1709 chip 1.17 response.reset(dynamic_cast<CIMReferencesResponseMessage*>( 1710 do_request(request))); 1711 1712 if(response.get() == 0) 1713 { 1714 PEG_TRACE_STRING( 1715 TRC_CIMOM_HANDLE, 1716 Tracer::LEVEL2, 1717 "Incorrect response type in CIMOMHandle"); 1718 1719 throw CIMException(CIM_ERR_FAILED); 1720 }
1721 david.dillard 1.9 }
1722 chip 1.17 catch(CIMException &)
1723 david.dillard 1.9 {
1724 chip 1.17 PEG_METHOD_EXIT();
1725 david.dillard 1.9 throw; 1726 }
1727 chip 1.17 catch(...)
1728 david.dillard 1.9 {
1729 chip 1.17 PEG_TRACE_STRING( 1730 TRC_CIMOM_HANDLE, 1731 Tracer::LEVEL2,
1732 david.dillard 1.9 "Exception caught in CIMOMHandle");
1733 chip 1.17 1734 PEG_METHOD_EXIT(); 1735 throw CIMException( 1736 CIM_ERR_FAILED, 1737 MessageLoaderParms( 1738 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1739 "Exception caught in CIMOMHandle"));
1740 david.dillard 1.9 } 1741 1742 Array<CIMObject> cimObjects = response->cimObjects; 1743 1744 PEG_METHOD_EXIT(); 1745 return(cimObjects); 1746 } 1747 1748 1749 Array<CIMObjectPath> InternalCIMOMHandleRep::referenceNames( 1750 const OperationContext & context, 1751 const CIMNamespaceName &nameSpace, 1752 const CIMObjectPath& objectName, 1753 const CIMName& resultClass, 1754 const String& role) 1755 { 1756 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 1757 "InternalCIMOMHandleRep::referenceNames"); 1758
1759 chip 1.17 #ifdef PEGASUS_OS_OS400
1760 david.dillard 1.9 // If this is running in user-state, then run the request 1761 // through the user-state layer 1762 if (_chOS400.hasKey()) 1763 {
1764 chip 1.17 Array<CIMObjectPath> cimObjectPaths = 1765 _chOS400.referenceNames( 1766 context, 1767 nameSpace, 1768 objectName, 1769 resultClass, 1770 role); 1771 1772 PEG_METHOD_EXIT(); 1773 return(cimObjectPaths);
1774 david.dillard 1.9 }
1775 chip 1.17 #endif
1776 david.dillard 1.9 1777 CIMReferenceNamesRequestMessage* request = 1778 new CIMReferenceNamesRequestMessage( 1779 XmlWriter::getNextMessageId(), 1780 nameSpace, 1781 objectName, 1782 resultClass, 1783 role,
1784 chip 1.17 QueueIdStack());
1785 david.dillard 1.9
1786 chip 1.17 // copy and adjust, as needed, the operation context 1787 request->operationContext = _filterOperationContext(context);
1788 david.dillard 1.9
1789 chip 1.17 AutoPtr<CIMReferenceNamesResponseMessage> response;
1790 david.dillard 1.9 1791 try 1792 {
1793 chip 1.17 response.reset(dynamic_cast<CIMReferenceNamesResponseMessage*>( 1794 do_request(request))); 1795 1796 if(response.get() == 0) 1797 { 1798 PEG_TRACE_STRING( 1799 TRC_CIMOM_HANDLE, 1800 Tracer::LEVEL2, 1801 "Incorrect response type in CIMOMHandle"); 1802 1803 throw CIMException(CIM_ERR_FAILED); 1804 }
1805 david.dillard 1.9 }
1806 chip 1.17 catch(CIMException &)
1807 david.dillard 1.9 {
1808 chip 1.17 PEG_METHOD_EXIT();
1809 david.dillard 1.9 throw; 1810 }
1811 chip 1.17 catch(...)
1812 david.dillard 1.9 {
1813 chip 1.17 PEG_TRACE_STRING( 1814 TRC_CIMOM_HANDLE, 1815 Tracer::LEVEL2,
1816 david.dillard 1.9 "Exception caught in CIMOMHandle");
1817 chip 1.17 1818 PEG_METHOD_EXIT(); 1819 throw CIMException( 1820 CIM_ERR_FAILED, 1821 MessageLoaderParms( 1822 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1823 "Exception caught in CIMOMHandle"));
1824 david.dillard 1.9 } 1825 1826 Array<CIMObjectPath> cimObjectPaths = response->objectNames; 1827 1828 PEG_METHOD_EXIT(); 1829 return(cimObjectPaths); 1830 } 1831 1832 1833 CIMValue InternalCIMOMHandleRep::getProperty( 1834 const OperationContext & context, 1835 const CIMNamespaceName &nameSpace, 1836 const CIMObjectPath& instanceName, 1837 const CIMName& propertyName) 1838 { 1839 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::getProperty"); 1840
1841 chip 1.17 #ifdef PEGASUS_OS_OS400
1842 david.dillard 1.9 // If this is running in user-state, then run the request 1843 // through the user-state layer 1844 if (_chOS400.hasKey()) 1845 {
1846 chip 1.17 CIMValue cimValue = 1847 _chOS400.getProperty( 1848 context, 1849 nameSpace, 1850 instanceName, 1851 propertyName); 1852 1853 PEG_METHOD_EXIT(); 1854 return(cimValue);
1855 david.dillard 1.9 }
1856 chip 1.17 #endif
1857 david.dillard 1.9 1858 CIMGetPropertyRequestMessage* request = 1859 new CIMGetPropertyRequestMessage(
1860 chip 1.17 XmlWriter::getNextMessageId(), 1861 nameSpace, 1862 instanceName, 1863 propertyName, 1864 QueueIdStack());
1865 david.dillard 1.9
1866 chip 1.17 // copy and adjust, as needed, the operation context 1867 request->operationContext = _filterOperationContext(context);
1868 david.dillard 1.9
1869 chip 1.17 AutoPtr<CIMGetPropertyResponseMessage> response;
1870 david.dillard 1.9 1871 try 1872 {
1873 chip 1.17 response.reset(dynamic_cast<CIMGetPropertyResponseMessage*>( 1874 do_request(request))); 1875 1876 if(response.get() == 0) 1877 { 1878 PEG_TRACE_STRING( 1879 TRC_CIMOM_HANDLE, 1880 Tracer::LEVEL2, 1881 "Incorrect response type in CIMOMHandle"); 1882 1883 throw CIMException(CIM_ERR_FAILED); 1884 }
1885 david.dillard 1.9 }
1886 chip 1.17 catch(CIMException &)
1887 david.dillard 1.9 {
1888 chip 1.17 PEG_METHOD_EXIT();
1889 david.dillard 1.9 throw; 1890 }
1891 chip 1.17 catch(...)
1892 david.dillard 1.9 {
1893 chip 1.17 PEG_TRACE_STRING( 1894 TRC_CIMOM_HANDLE, 1895 Tracer::LEVEL2,
1896 david.dillard 1.9 "Exception caught in CIMOMHandle");
1897 chip 1.17 1898 PEG_METHOD_EXIT(); 1899 throw CIMException( 1900 CIM_ERR_FAILED, 1901 MessageLoaderParms( 1902 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1903 "Exception caught in CIMOMHandle"));
1904 david.dillard 1.9 } 1905 1906 CIMValue cimValue = response->value; 1907 1908 PEG_METHOD_EXIT(); 1909 return(cimValue); 1910 } 1911 1912 1913 void InternalCIMOMHandleRep::setProperty( 1914 const OperationContext & context, 1915 const CIMNamespaceName &nameSpace, 1916 const CIMObjectPath& instanceName, 1917 const CIMName& propertyName, 1918 const CIMValue& newValue) 1919 { 1920 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::setProperty"); 1921
1922 chip 1.17 #ifdef PEGASUS_OS_OS400
1923 david.dillard 1.9 // If this is running in user-state, then run the request 1924 // through the user-state layer 1925 if (_chOS400.hasKey()) 1926 { 1927 _chOS400.setProperty( 1928 context, 1929 nameSpace, 1930 instanceName, 1931 propertyName, 1932 newValue);
1933 chip 1.17 1934 PEG_METHOD_EXIT();
1935 david.dillard 1.9 return; 1936 }
1937 chip 1.17 #endif
1938 david.dillard 1.9 1939 CIMSetPropertyRequestMessage* request = 1940 new CIMSetPropertyRequestMessage( 1941 XmlWriter::getNextMessageId(), 1942 nameSpace, 1943 instanceName, 1944 propertyName, 1945 newValue,
1946 chip 1.17 QueueIdStack());
1947 david.dillard 1.9
1948 chip 1.17 // copy and adjust, as needed, the operation context 1949 request->operationContext = _filterOperationContext(context);
1950 david.dillard 1.9
1951 chip 1.17 AutoPtr<CIMSetPropertyResponseMessage> response;
1952 david.dillard 1.9 1953 try 1954 {
1955 chip 1.17 response.reset(dynamic_cast<CIMSetPropertyResponseMessage*>( 1956 do_request(request))); 1957 1958 if(response.get() == 0) 1959 { 1960 PEG_TRACE_STRING( 1961 TRC_CIMOM_HANDLE, 1962 Tracer::LEVEL2, 1963 "Incorrect response type in CIMOMHandle"); 1964 1965 throw CIMException(CIM_ERR_FAILED); 1966 }
1967 david.dillard 1.9 }
1968 chip 1.17 catch(CIMException &)
1969 david.dillard 1.9 {
1970 chip 1.17 PEG_METHOD_EXIT();
1971 david.dillard 1.9 throw; 1972 }
1973 chip 1.17 catch(...)
1974 david.dillard 1.9 {
1975 chip 1.17 PEG_TRACE_STRING( 1976 TRC_CIMOM_HANDLE, 1977 Tracer::LEVEL2,
1978 david.dillard 1.9 "Exception caught in CIMOMHandle");
1979 chip 1.17 1980 PEG_METHOD_EXIT(); 1981 throw CIMException( 1982 CIM_ERR_FAILED, 1983 MessageLoaderParms( 1984 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 1985 "Exception caught in CIMOMHandle"));
1986 david.dillard 1.9 } 1987 1988 PEG_METHOD_EXIT(); 1989 return; 1990 } 1991 1992 1993 CIMValue InternalCIMOMHandleRep::invokeMethod( 1994 const OperationContext & context, 1995 const CIMNamespaceName &nameSpace, 1996 const CIMObjectPath& instanceName, 1997 const CIMName& methodName, 1998 const Array<CIMParamValue>& inParameters, 1999 Array<CIMParamValue>& outParameters) 2000 { 2001 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::invokeMethod"); 2002
2003 chip 1.17 #ifdef PEGASUS_OS_OS400
2004 david.dillard 1.9 // If this is running in user-state, then run the request 2005 // through the user-state layer 2006 if (_chOS400.hasKey()) 2007 {
2008 chip 1.17 CIMValue cimValue = 2009 _chOS400.invokeMethod( 2010 context, 2011 nameSpace, 2012 instanceName, 2013 methodName, 2014 inParameters, 2015 outParameters); 2016 2017 PEG_METHOD_EXIT(); 2018 return(cimValue);
2019 david.dillard 1.9 }
2020 chip 1.17 #endif
2021 david.dillard 1.9 2022 CIMInvokeMethodRequestMessage* request = 2023 new CIMInvokeMethodRequestMessage( 2024 XmlWriter::getNextMessageId(), 2025 nameSpace, 2026 instanceName, 2027 methodName, 2028 inParameters,
2029 chip 1.17 QueueIdStack()); 2030 2031 // copy and adjust, as needed, the operation context 2032 request->operationContext = _filterOperationContext(context);
2033 david.dillard 1.9
2034 chip 1.17 AutoPtr<CIMInvokeMethodResponseMessage> response;
2035 david.dillard 1.9 2036 try 2037 {
2038 chip 1.17 response.reset(dynamic_cast<CIMInvokeMethodResponseMessage*>( 2039 do_request(request))); 2040 2041 if(response.get() == 0) 2042 { 2043 PEG_TRACE_STRING( 2044 TRC_CIMOM_HANDLE, 2045 Tracer::LEVEL2, 2046 "Incorrect response type in CIMOMHandle"); 2047 2048 throw CIMException(CIM_ERR_FAILED); 2049 }
2050 david.dillard 1.9 }
2051 chip 1.17 catch(CIMException &)
2052 david.dillard 1.9 {
2053 chip 1.17 PEG_METHOD_EXIT();
2054 david.dillard 1.9 throw; 2055 }
2056 chip 1.17 catch(...)
2057 david.dillard 1.9 {
2058 chip 1.17 PEG_TRACE_STRING( 2059 TRC_CIMOM_HANDLE, 2060 Tracer::LEVEL2,
2061 david.dillard 1.9 "Exception caught in CIMOMHandle");
2062 chip 1.17 2063 PEG_METHOD_EXIT(); 2064 throw CIMException( 2065 CIM_ERR_FAILED, 2066 MessageLoaderParms( 2067 "Provider.CIMOMHandle.CAUGHT_EXCEPTION", 2068 "Exception caught in CIMOMHandle"));
2069 david.dillard 1.9 } 2070
2071 chip 1.17 CIMValue cimValue = response->retValue;
2072 kumpf 1.15 outParameters = response->outParameters;
2073 david.dillard 1.9 2074 PEG_METHOD_EXIT();
2075 chip 1.17 return(cimValue);
2076 david.dillard 1.9 } 2077 2078 2079 // 2080 // Public CIMOMHandle Methods 2081 // 2082 2083 void InternalCIMOMHandleRep::disallowProviderUnload() 2084 {
2085 chip 1.17 #ifdef PEGASUS_OS_OS400
2086 david.dillard 1.9 // If this is running in user-state, then run the request 2087 // through the user-state layer 2088 if (_chOS400.hasKey()) 2089 { 2090 _chOS400.disallowProviderUnload(); 2091 return; 2092 }
2093 chip 1.17 #endif
2094 david.dillard 1.9 2095 CIMOMHandleRep::disallowProviderUnload(); 2096 } 2097 2098 void InternalCIMOMHandleRep::allowProviderUnload() 2099 {
2100 chip 1.17 #ifdef PEGASUS_OS_OS400
2101 david.dillard 1.9 // If this is running in user-state, then run the request 2102 // through the user-state layer 2103 if (_chOS400.hasKey()) 2104 { 2105 _chOS400.allowProviderUnload(); 2106 return; 2107 }
2108 chip 1.17 #endif
2109 david.dillard 1.9 2110 CIMOMHandleRep::allowProviderUnload(); 2111 } 2112 2113 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES 2114 OperationContext InternalCIMOMHandleRep::getResponseContext() 2115 { 2116 OperationContext ctx; 2117 2118 Thread* curThrd = Thread::getCurrent(); 2119 if (curThrd == NULL) 2120 {
2121 kumpf 1.19 ctx.insert(ContentLanguageListContainer(ContentLanguageList()));
2122 david.dillard 1.9 } 2123 else 2124 {
2125 kumpf 1.19 ContentLanguageList* contentLangs = (ContentLanguageList*)
2126 david.dillard 1.9 curThrd->reference_tsd("cimomHandleContentLanguages"); 2127 curThrd->dereference_tsd();
2128 chip 1.17
2129 david.dillard 1.9 if (contentLangs == NULL) 2130 {
2131 kumpf 1.19 ctx.insert(ContentLanguageListContainer(ContentLanguageList()));
2132 david.dillard 1.9 } 2133 else 2134 { 2135 ctx.insert(ContentLanguageListContainer(*contentLangs)); 2136 // delete the old tsd to free the memory 2137 curThrd->delete_tsd("cimomHandleContentLanguages"); 2138 } 2139 } 2140 2141 return ctx; 2142 } 2143 #endif 2144 2145 PEGASUS_NAMESPACE_END

No CVS admin address has been configured