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.23.2.1 _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 CIMOMHandleOpSemaphore opsem(this);
441
442 // encode request
443 CIMGetClassRequestMessage* request =
444 new CIMGetClassRequestMessage(
445 XmlWriter::getNextMessageId(),
|
446 david.dillard 1.9 nameSpace,
447 className,
448 localOnly,
449 includeQualifiers,
450 includeClassOrigin,
|
451 chip 1.17 propertyList,
452 QueueIdStack());
453
454 // copy and adjust, as needed, the operation context
455 request->operationContext = _filterOperationContext(context);
|
456 dave.sudlik 1.20 // request->operationContext.get(AcceptLanguageListContainer::NAME);
|
457 chip 1.17
458 AutoPtr<CIMGetClassResponseMessage> response;
459
460 try
461 {
462 response.reset(dynamic_cast<CIMGetClassResponseMessage*>(
463 do_request(request)));
|
464 david.dillard 1.9
|
465 chip 1.17 if(response.get() == 0)
466 {
467 PEG_TRACE_STRING(
468 TRC_CIMOM_HANDLE,
469 Tracer::LEVEL2,
470 "Incorrect response type in CIMOMHandle");
|
471 david.dillard 1.9
|
472 chip 1.17 throw CIMException(CIM_ERR_FAILED);
473 }
|
474 david.dillard 1.9 }
|
475 chip 1.17 catch(CIMException &)
|
476 david.dillard 1.9 {
|
477 chip 1.17 PEG_METHOD_EXIT();
|
478 david.dillard 1.9 throw;
479 }
|
480 chip 1.17 catch(...)
|
481 david.dillard 1.9 {
|
482 chip 1.17 PEG_TRACE_STRING(
483 TRC_CIMOM_HANDLE,
484 Tracer::LEVEL2,
|
485 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
486 chip 1.17
487 PEG_METHOD_EXIT();
488 throw CIMException(
489 CIM_ERR_FAILED,
490 MessageLoaderParms(
491 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
492 "Exception caught in CIMOMHandle"));
|
493 david.dillard 1.9 }
494
495 CIMClass cimClass = response->cimClass;
496
497 PEG_METHOD_EXIT();
|
498 chip 1.17 return(cimClass);
|
499 david.dillard 1.9 }
500
501
502 Array<CIMClass> InternalCIMOMHandleRep::enumerateClasses(
503 const OperationContext & context,
504 const CIMNamespaceName& nameSpace,
505 const CIMName& className,
506 Boolean deepInheritance,
507 Boolean localOnly,
508 Boolean includeQualifiers,
509 Boolean includeClassOrigin)
510 {
511 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
512 "InternalCIMOMHandleRep::enumerateClasses");
513
|
514 chip 1.17 #ifdef PEGASUS_OS_OS400
|
515 david.dillard 1.9 // If this is running in user-state, then run the request
516 // through the user-state layer
517 if (_chOS400.hasKey())
518 {
|
519 chip 1.17 Array<CIMClass> cimClasses =
520 _chOS400.enumerateClasses(
521 context,
522 nameSpace,
523 className,
524 deepInheritance,
525 localOnly,
526 includeQualifiers,
527 includeClassOrigin);
528
529 PEG_METHOD_EXIT();
530 return(cimClasses);
531 }
532 #endif
|
533 david.dillard 1.9
|
534 chip 1.17 CIMOMHandleOpSemaphore opsem(this);
|
535 david.dillard 1.9
536 CIMEnumerateClassesRequestMessage* request =
537 new CIMEnumerateClassesRequestMessage(
538 XmlWriter::getNextMessageId(),
539 nameSpace,
540 className,
541 deepInheritance,
542 localOnly,
543 includeQualifiers,
544 includeClassOrigin,
|
545 chip 1.17 QueueIdStack());
|
546 david.dillard 1.9
|
547 chip 1.17 // copy and adjust, as needed, the operation context
548 request->operationContext = _filterOperationContext(context);
|
549 david.dillard 1.9
|
550 chip 1.17 AutoPtr<CIMEnumerateClassesResponseMessage> response;
|
551 david.dillard 1.9
552 try
553 {
|
554 chip 1.17 response.reset(dynamic_cast<CIMEnumerateClassesResponseMessage*>(
555 do_request(request)));
556
557 if(response.get() == 0)
558 {
559 PEG_TRACE_STRING(
560 TRC_CIMOM_HANDLE,
561 Tracer::LEVEL2,
562 "Incorrect response type in CIMOMHandle");
563
564 throw CIMException(CIM_ERR_FAILED);
565 }
|
566 david.dillard 1.9 }
|
567 chip 1.17 catch(CIMException &)
|
568 david.dillard 1.9 {
|
569 chip 1.17 PEG_METHOD_EXIT();
|
570 david.dillard 1.9 throw;
571 }
|
572 chip 1.17 catch(...)
|
573 david.dillard 1.9 {
|
574 chip 1.17 PEG_TRACE_STRING(
575 TRC_CIMOM_HANDLE,
576 Tracer::LEVEL2,
|
577 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
578 chip 1.17
579 PEG_METHOD_EXIT();
580 throw CIMException(
581 CIM_ERR_FAILED,
582 MessageLoaderParms(
583 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
584 "Exception caught in CIMOMHandle"));
|
585 david.dillard 1.9 }
|
586 chip 1.17
|
587 david.dillard 1.9 Array<CIMClass> cimClasses = response->cimClasses;
|
588 chip 1.17
|
589 david.dillard 1.9 PEG_METHOD_EXIT();
|
590 chip 1.17 return(cimClasses);
|
591 david.dillard 1.9 }
592
593
594 Array<CIMName> InternalCIMOMHandleRep::enumerateClassNames(
595 const OperationContext & context,
596 const CIMNamespaceName &nameSpace,
597 const CIMName& className,
598 Boolean deepInheritance)
599 {
600 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
601 "InternalCIMOMHandleRep::enumerateClassNames");
602
|
603 chip 1.17 #ifdef PEGASUS_OS_OS400
|
604 david.dillard 1.9 // If this is running in user-state, then run the request
605 // through the user-state layer
606 if (_chOS400.hasKey())
607 {
|
608 chip 1.17 Array<CIMName> cimClassNames =
609 _chOS400.enumerateClassNames(
610 context,
611 nameSpace,
612 className,
613 deepInheritance);
614
615 PEG_METHOD_EXIT();
616 return(cimClassNames);
617 }
618 #endif
|
619 david.dillard 1.9
620 CIMOMHandleOpSemaphore opsem(this);
621
622 CIMEnumerateClassNamesRequestMessage* request =
623 new CIMEnumerateClassNamesRequestMessage(
|
624 chip 1.17 XmlWriter::getNextMessageId(),
625 nameSpace,
626 className,
627 deepInheritance,
628 QueueIdStack());
629
630 // copy and adjust, as needed, the operation context
631 request->operationContext = _filterOperationContext(context);
|
632 david.dillard 1.9
|
633 chip 1.17 AutoPtr<CIMEnumerateClassNamesResponseMessage> response;
|
634 david.dillard 1.9
635 try
636 {
|
637 chip 1.17 response.reset(dynamic_cast<CIMEnumerateClassNamesResponseMessage*>(
638 do_request(request)));
639
640 if(response.get() == 0)
641 {
642 PEG_TRACE_STRING(
643 TRC_CIMOM_HANDLE,
644 Tracer::LEVEL2,
645 "Incorrect response type in CIMOMHandle");
646
647 throw CIMException(CIM_ERR_FAILED);
648 }
|
649 david.dillard 1.9 }
|
650 chip 1.17 catch(CIMException &)
|
651 david.dillard 1.9 {
|
652 chip 1.17 PEG_METHOD_EXIT();
|
653 david.dillard 1.9 throw;
654 }
|
655 chip 1.17 catch(...)
|
656 david.dillard 1.9 {
|
657 chip 1.17 PEG_TRACE_STRING(
658 TRC_CIMOM_HANDLE,
659 Tracer::LEVEL2,
|
660 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
661 chip 1.17
662 PEG_METHOD_EXIT();
663 throw CIMException(
664 CIM_ERR_FAILED,
665 MessageLoaderParms(
666 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
667 "Exception caught in CIMOMHandle"));
|
668 david.dillard 1.9 }
669
|
670 chip 1.17 Array<CIMName> cimClassNames = response->classNames;
671
|
672 david.dillard 1.9 PEG_METHOD_EXIT();
|
673 chip 1.17 return(cimClassNames);
|
674 david.dillard 1.9 }
675
676
677 void InternalCIMOMHandleRep::createClass(
678 const OperationContext & context,
679 const CIMNamespaceName& nameSpace,
680 const CIMClass& newClass)
681 {
682 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::createClass");
683
|
684 chip 1.17 #ifdef PEGASUS_OS_OS400
|
685 david.dillard 1.9 // If this is running in user-state, then run the request
686 // through the user-state layer
687 if (_chOS400.hasKey())
688 {
689 _chOS400.createClass(
690 context,
691 nameSpace,
692 newClass);
|
693 chip 1.17
694 PEG_METHOD_EXIT();
|
695 david.dillard 1.9 return;
696 }
|
697 chip 1.17 #endif
|
698 david.dillard 1.9
699 CIMOMHandleOpSemaphore opsem(this);
700
701 CIMCreateClassRequestMessage* request =
702 new CIMCreateClassRequestMessage(
703 XmlWriter::getNextMessageId(),
704 nameSpace,
705 newClass,
|
706 chip 1.17 QueueIdStack());
|
707 david.dillard 1.9
|
708 chip 1.17 // copy and adjust, as needed, the operation context
709 request->operationContext = _filterOperationContext(context);
|
710 david.dillard 1.9
|
711 chip 1.17 AutoPtr<CIMCreateClassResponseMessage> response;
|
712 david.dillard 1.9
713 try
714 {
|
715 chip 1.17 response.reset(dynamic_cast<CIMCreateClassResponseMessage*>(
716 do_request(request)));
717
718 if(response.get() == 0)
719 {
720 PEG_TRACE_STRING(
721 TRC_CIMOM_HANDLE,
722 Tracer::LEVEL2,
723 "Incorrect response type in CIMOMHandle");
724
725 throw CIMException(CIM_ERR_FAILED);
726 }
|
727 david.dillard 1.9 }
|
728 chip 1.17 catch(CIMException &)
|
729 david.dillard 1.9 {
|
730 chip 1.17 PEG_METHOD_EXIT();
|
731 david.dillard 1.9 throw;
732 }
|
733 chip 1.17 catch(...)
|
734 david.dillard 1.9 {
|
735 chip 1.17 PEG_TRACE_STRING(
736 TRC_CIMOM_HANDLE,
737 Tracer::LEVEL2,
|
738 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
739 chip 1.17
740 PEG_METHOD_EXIT();
741 throw CIMException(
742 CIM_ERR_FAILED,
743 MessageLoaderParms(
744 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
745 "Exception caught in CIMOMHandle"));
|
746 david.dillard 1.9 }
747
748 PEG_METHOD_EXIT();
749 return;
750 }
751
752
753 void InternalCIMOMHandleRep::modifyClass(
754 const OperationContext & context,
755 const CIMNamespaceName &nameSpace,
756 const CIMClass& modifiedClass)
757 {
758 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::modifyClass");
759
|
760 chip 1.17 #ifdef PEGASUS_OS_OS400
|
761 david.dillard 1.9 // If this is running in user-state, then run the request
762 // through the user-state layer
763 if (_chOS400.hasKey())
764 {
765 _chOS400.modifyClass(
766 context,
767 nameSpace,
768 modifiedClass);
|
769 chip 1.17
770 PEG_METHOD_EXIT();
|
771 david.dillard 1.9 return;
772 }
|
773 chip 1.17 #endif
|
774 david.dillard 1.9
775 CIMOMHandleOpSemaphore opsem(this);
776
777 CIMModifyClassRequestMessage* request =
778 new CIMModifyClassRequestMessage(
779 XmlWriter::getNextMessageId(),
780 nameSpace,
781 modifiedClass,
|
782 chip 1.17 QueueIdStack());
|
783 david.dillard 1.9
|
784 chip 1.17 // copy and adjust, as needed, the operation context
785 request->operationContext = _filterOperationContext(context);
786
787 AutoPtr<CIMModifyClassResponseMessage> response;
|
788 david.dillard 1.9
789 try
790 {
|
791 chip 1.17 response.reset(dynamic_cast<CIMModifyClassResponseMessage*>(
792 do_request(request)));
793
794 if(response.get() == 0)
795 {
796 PEG_TRACE_STRING(
797 TRC_CIMOM_HANDLE,
798 Tracer::LEVEL2,
799 "Incorrect response type in CIMOMHandle");
800
801 throw CIMException(CIM_ERR_FAILED);
802 }
|
803 david.dillard 1.9 }
|
804 chip 1.17 catch(CIMException &)
|
805 david.dillard 1.9 {
|
806 chip 1.17 PEG_METHOD_EXIT();
|
807 david.dillard 1.9 throw;
808 }
|
809 chip 1.17 catch(...)
|
810 david.dillard 1.9 {
|
811 chip 1.17 PEG_TRACE_STRING(
812 TRC_CIMOM_HANDLE,
813 Tracer::LEVEL2,
|
814 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
815 chip 1.17
816 PEG_METHOD_EXIT();
817 throw CIMException(
818 CIM_ERR_FAILED,
819 MessageLoaderParms(
820 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
821 "Exception caught in CIMOMHandle"));
|
822 david.dillard 1.9 }
823
824 PEG_METHOD_EXIT();
825 return;
826 }
827
828
829 void InternalCIMOMHandleRep::deleteClass(
830 const OperationContext & context,
831 const CIMNamespaceName &nameSpace,
832 const CIMName& className)
833 {
834 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::deleteClass");
835
|
836 chip 1.17 #ifdef PEGASUS_OS_OS400
|
837 david.dillard 1.9 // If this is running in user-state, then run the request
838 // through the user-state layer
839 if (_chOS400.hasKey())
840 {
841 _chOS400.deleteClass(
842 context,
843 nameSpace,
844 className);
|
845 chip 1.17
846 PEG_METHOD_EXIT();
|
847 david.dillard 1.9 return;
848 }
|
849 chip 1.17 #endif
|
850 david.dillard 1.9
851 CIMOMHandleOpSemaphore opsem(this);
852
853 // encode request
854 CIMDeleteClassRequestMessage* request =
855 new CIMDeleteClassRequestMessage(
856 XmlWriter::getNextMessageId(),
857 nameSpace,
858 className,
|
859 chip 1.17 QueueIdStack());
860
861 // copy and adjust, as needed, the operation context
862 request->operationContext = _filterOperationContext(context);
|
863 david.dillard 1.9
|
864 chip 1.17 AutoPtr<CIMDeleteClassResponseMessage> response;
|
865 david.dillard 1.9
|
866 chip 1.17 try
867 {
868 response.reset(dynamic_cast<CIMDeleteClassResponseMessage*>(
869 do_request(request)));
870
871 if(response.get() == 0)
872 {
873 PEG_TRACE_STRING(
874 TRC_CIMOM_HANDLE,
875 Tracer::LEVEL2,
876 "Incorrect response type in CIMOMHandle");
877
878 throw CIMException(CIM_ERR_FAILED);
879 }
|
880 david.dillard 1.9 }
|
881 chip 1.17 catch(CIMException &)
|
882 david.dillard 1.9 {
|
883 chip 1.17 PEG_METHOD_EXIT();
|
884 david.dillard 1.9 throw;
885 }
|
886 chip 1.17 catch(...)
|
887 david.dillard 1.9 {
|
888 chip 1.17 PEG_TRACE_STRING(
889 TRC_CIMOM_HANDLE,
890 Tracer::LEVEL2,
|
891 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
892 chip 1.17
893 PEG_METHOD_EXIT();
894 throw CIMException(
895 CIM_ERR_FAILED,
896 MessageLoaderParms(
897 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
898 "Exception caught in CIMOMHandle"));
|
899 david.dillard 1.9 }
|
900 chip 1.17
|
901 david.dillard 1.9 PEG_METHOD_EXIT();
902 return;
903 }
904
905
906 CIMInstance InternalCIMOMHandleRep::getInstance(
907 const OperationContext & context,
908 const CIMNamespaceName &nameSpace,
909 const CIMObjectPath& instanceName,
910 Boolean localOnly,
911 Boolean includeQualifiers,
912 Boolean includeClassOrigin,
913 const CIMPropertyList& propertyList)
914 {
915 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::getInstance");
916
|
917 chip 1.17 #ifdef PEGASUS_OS_OS400
|
918 david.dillard 1.9 // If this is running in user-state, then run the request
919 // through the user-state layer
920 if (_chOS400.hasKey())
921 {
|
922 chip 1.17 CIMInstance cimInstance =
923 _chOS400.getInstance(
924 context,
925 nameSpace,
926 instanceName,
927 localOnly,
928 includeQualifiers,
929 includeClassOrigin,
930 propertyList);
931
932 PEG_METHOD_EXIT();
933 return(cimInstance);
|
934 david.dillard 1.9 }
|
935 chip 1.17 #endif
|
936 david.dillard 1.9
937 CIMOMHandleOpSemaphore opsem(this);
938
939 // encode request
940 CIMGetInstanceRequestMessage* request =
941 new CIMGetInstanceRequestMessage(
942 XmlWriter::getNextMessageId(),
943 nameSpace,
944 instanceName,
945 localOnly,
946 includeQualifiers,
947 includeClassOrigin,
948 propertyList,
|
949 chip 1.17 QueueIdStack());
950
951 // copy and adjust, as needed, the operation context
952 request->operationContext = _filterOperationContext(context);
|
953 david.dillard 1.9
|
954 chip 1.17 AutoPtr<CIMGetInstanceResponseMessage> response;
|
955 david.dillard 1.9
956 try
957 {
|
958 chip 1.17 response.reset(dynamic_cast<CIMGetInstanceResponseMessage*>(
959 do_request(request)));
960
961 if(response.get() == 0)
962 {
963 PEG_TRACE_STRING(
964 TRC_CIMOM_HANDLE,
965 Tracer::LEVEL2,
966 "Incorrect response type in CIMOMHandle");
967
968 throw CIMException(CIM_ERR_FAILED);
969 }
|
970 david.dillard 1.9 }
|
971 chip 1.17 catch(CIMException &)
|
972 david.dillard 1.9 {
|
973 chip 1.17 PEG_METHOD_EXIT();
|
974 david.dillard 1.9 throw;
975 }
|
976 chip 1.17 catch(...)
|
977 david.dillard 1.9 {
|
978 chip 1.17 PEG_TRACE_STRING(
979 TRC_CIMOM_HANDLE,
980 Tracer::LEVEL2,
|
981 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
982 chip 1.17
983 PEG_METHOD_EXIT();
984 throw CIMException(
985 CIM_ERR_FAILED,
986 MessageLoaderParms(
987 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
988 "Exception caught in CIMOMHandle"));
|
989 david.dillard 1.9 }
990
991 CIMInstance cimInstance = response->cimInstance;
992
993 PEG_METHOD_EXIT();
994 return(cimInstance);
995 }
996
997 Array<CIMInstance> InternalCIMOMHandleRep::enumerateInstances(
998 const OperationContext & context,
999 const CIMNamespaceName &nameSpace,
1000 const CIMName& className,
1001 Boolean deepInheritance,
1002 Boolean localOnly,
1003 Boolean includeQualifiers,
1004 Boolean includeClassOrigin,
1005 const CIMPropertyList& propertyList)
1006 {
1007 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1008 "InternalCIMOMHandleRep::enumerateInstances");
1009
|
1010 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1011 david.dillard 1.9 // If this is running in user-state, then run the request
1012 // through the user-state layer
1013 if (_chOS400.hasKey())
1014 {
|
1015 chip 1.17 Array<CIMInstance> cimInstances =
1016 _chOS400.enumerateInstances(
1017 context,
1018 nameSpace,
1019 className,
1020 deepInheritance,
1021 localOnly,
1022 includeQualifiers,
1023 includeClassOrigin,
1024 propertyList);
1025
1026 PEG_METHOD_EXIT();
1027 return(cimInstances);
|
1028 david.dillard 1.9 }
|
1029 chip 1.17 #endif
|
1030 david.dillard 1.9
1031 CIMOMHandleOpSemaphore opsem(this);
1032
1033 // encode request
1034 CIMEnumerateInstancesRequestMessage* request =
1035 new CIMEnumerateInstancesRequestMessage(
1036 XmlWriter::getNextMessageId(),
1037 nameSpace,
1038 className,
1039 deepInheritance,
1040 localOnly,
1041 includeQualifiers,
1042 includeClassOrigin,
1043 propertyList,
|
1044 chip 1.17 QueueIdStack());
|
1045 david.dillard 1.9
|
1046 chip 1.17 // copy and adjust, as needed, the operation context
1047 request->operationContext = _filterOperationContext(context);
1048
1049 AutoPtr<CIMEnumerateInstancesResponseMessage> response;
|
1050 david.dillard 1.9
1051 try
1052 {
|
1053 chip 1.17 response.reset(dynamic_cast<CIMEnumerateInstancesResponseMessage*>(
1054 do_request(request)));
1055
1056 if(response.get() == 0)
1057 {
1058 PEG_TRACE_STRING(
1059 TRC_CIMOM_HANDLE,
1060 Tracer::LEVEL2,
1061 "Incorrect response type in CIMOMHandle");
1062
1063 throw CIMException(CIM_ERR_FAILED);
1064 }
|
1065 david.dillard 1.9 }
|
1066 chip 1.17 catch(CIMException &)
|
1067 david.dillard 1.9 {
|
1068 chip 1.17 PEG_METHOD_EXIT();
|
1069 david.dillard 1.9 throw;
1070 }
|
1071 chip 1.17 catch(...)
|
1072 david.dillard 1.9 {
|
1073 chip 1.17 PEG_TRACE_STRING(
1074 TRC_CIMOM_HANDLE,
1075 Tracer::LEVEL2,
|
1076 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1077 chip 1.17
1078 PEG_METHOD_EXIT();
1079 throw CIMException(
1080 CIM_ERR_FAILED,
1081 MessageLoaderParms(
1082 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1083 "Exception caught in CIMOMHandle"));
|
1084 david.dillard 1.9 }
1085
1086 Array<CIMInstance> cimInstances = response->cimNamedInstances;
1087
1088 PEG_METHOD_EXIT();
1089 return(cimInstances);
1090 }
1091
1092
1093 Array<CIMObjectPath> InternalCIMOMHandleRep::enumerateInstanceNames(
1094 const OperationContext & context,
1095 const CIMNamespaceName &nameSpace,
1096 const CIMName& className)
1097 {
1098 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1099 "InternalCIMOMHandleRep::enumerateInstanceNames");
1100
|
1101 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1102 david.dillard 1.9 // If this is running in user-state, then run the request
1103 // through the user-state layer
1104 if (_chOS400.hasKey())
1105 {
|
1106 chip 1.17 Array<CIMObjectPath> cimObjectPaths =
1107 _chOS400.enumerateInstanceNames(
1108 context,
1109 nameSpace,
1110 className);
1111
1112 PEG_METHOD_EXIT();
1113 return(cimObjectPaths);
|
1114 david.dillard 1.9 }
|
1115 chip 1.17 #endif
|
1116 david.dillard 1.9
1117 CIMOMHandleOpSemaphore opsem(this);
1118
1119 // encode request
1120 CIMEnumerateInstanceNamesRequestMessage* request =
1121 new CIMEnumerateInstanceNamesRequestMessage(
1122 XmlWriter::getNextMessageId(),
1123 nameSpace,
1124 className,
|
1125 chip 1.17 QueueIdStack());
|
1126 david.dillard 1.9
|
1127 chip 1.17 // copy and adjust, as needed, the operation context
1128 request->operationContext = _filterOperationContext(context);
1129
1130 AutoPtr<CIMEnumerateInstanceNamesResponseMessage> response;
|
1131 david.dillard 1.9
1132 try
1133 {
|
1134 chip 1.17 response.reset(dynamic_cast<CIMEnumerateInstanceNamesResponseMessage*>(
1135 do_request(request)));
1136
1137 if(response.get() == 0)
1138 {
1139 PEG_TRACE_STRING(
1140 TRC_CIMOM_HANDLE,
1141 Tracer::LEVEL2,
1142 "Incorrect response type in CIMOMHandle");
1143
1144 throw CIMException(CIM_ERR_FAILED);
1145 }
|
1146 david.dillard 1.9 }
|
1147 chip 1.17 catch(CIMException &)
|
1148 david.dillard 1.9 {
|
1149 chip 1.17 PEG_METHOD_EXIT();
|
1150 david.dillard 1.9 throw;
1151 }
|
1152 chip 1.17 catch(...)
|
1153 david.dillard 1.9 {
|
1154 chip 1.17 PEG_TRACE_STRING(
1155 TRC_CIMOM_HANDLE,
1156 Tracer::LEVEL2,
|
1157 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1158 chip 1.17
1159 PEG_METHOD_EXIT();
1160 throw CIMException(
1161 CIM_ERR_FAILED,
1162 MessageLoaderParms(
1163 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1164 "Exception caught in CIMOMHandle"));
|
1165 david.dillard 1.9 }
1166
|
1167 chip 1.17 Array<CIMObjectPath> cimObjectPaths = response->instanceNames;
|
1168 david.dillard 1.9
1169 PEG_METHOD_EXIT();
|
1170 chip 1.17 return(cimObjectPaths);
|
1171 david.dillard 1.9 }
1172
1173 CIMObjectPath InternalCIMOMHandleRep::createInstance(
1174 const OperationContext & context,
1175 const CIMNamespaceName &nameSpace,
1176 const CIMInstance& newInstance)
1177 {
1178 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1179 "InternalCIMOMHandleRep::createInstance");
1180
|
1181 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1182 david.dillard 1.9 // If this is running in user-state, then run the request
1183 // through the user-state layer
1184 if (_chOS400.hasKey())
1185 {
|
1186 chip 1.17 CIMObjectPath cimReference =
1187 _chOS400.createInstance(
1188 context,
1189 nameSpace,
1190 newInstance);
1191
1192 PEG_METHOD_EXIT();
1193 return(cimReference);
|
1194 david.dillard 1.9 }
|
1195 chip 1.17 #endif
|
1196 david.dillard 1.9
1197 CIMOMHandleOpSemaphore opsem(this);
1198
1199 CIMCreateInstanceRequestMessage* request =
1200 new CIMCreateInstanceRequestMessage(
1201 XmlWriter::getNextMessageId(),
1202 nameSpace,
1203 newInstance,
|
1204 chip 1.17 QueueIdStack());
|
1205 david.dillard 1.9
|
1206 chip 1.17 // copy and adjust, as needed, the operation context
1207 request->operationContext = _filterOperationContext(context);
1208
1209 AutoPtr<CIMCreateInstanceResponseMessage> response;
|
1210 david.dillard 1.9
1211 try
1212 {
|
1213 chip 1.17 response.reset(dynamic_cast<CIMCreateInstanceResponseMessage*>(
1214 do_request(request)));
1215
1216 if(response.get() == 0)
1217 {
1218 PEG_TRACE_STRING(
1219 TRC_CIMOM_HANDLE,
1220 Tracer::LEVEL2,
1221 "Incorrect response type in CIMOMHandle");
1222
1223 throw CIMException(CIM_ERR_FAILED);
1224 }
|
1225 david.dillard 1.9 }
|
1226 chip 1.17 catch(CIMException &)
|
1227 david.dillard 1.9 {
|
1228 chip 1.17 PEG_METHOD_EXIT();
|
1229 david.dillard 1.9 throw;
1230 }
|
1231 chip 1.17 catch(...)
|
1232 david.dillard 1.9 {
|
1233 chip 1.17 PEG_TRACE_STRING(
1234 TRC_CIMOM_HANDLE,
1235 Tracer::LEVEL2,
|
1236 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1237 chip 1.17
1238 PEG_METHOD_EXIT();
1239 throw CIMException(
1240 CIM_ERR_FAILED,
1241 MessageLoaderParms(
1242 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1243 "Exception caught in CIMOMHandle"));
|
1244 david.dillard 1.9 }
1245
1246 CIMObjectPath cimReference = response->instanceName;
1247
1248 PEG_METHOD_EXIT();
1249 return(cimReference);
1250 }
1251
1252
1253 void InternalCIMOMHandleRep::modifyInstance(
1254 const OperationContext & context,
1255 const CIMNamespaceName &nameSpace,
1256 const CIMInstance& modifiedInstance,
1257 Boolean includeQualifiers,
1258 const CIMPropertyList& propertyList)
1259 {
1260 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1261 "InternalCIMOMHandleRep::modifyInstance");
1262
|
1263 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1264 david.dillard 1.9 // If this is running in user-state, then run the request
1265 // through the user-state layer
1266 if (_chOS400.hasKey())
1267 {
1268 _chOS400.modifyInstance(
1269 context,
1270 nameSpace,
1271 modifiedInstance,
1272 includeQualifiers,
1273 propertyList);
|
1274 chip 1.17
1275 PEG_METHOD_EXIT();
|
1276 david.dillard 1.9 return;
1277 }
|
1278 chip 1.17 #endif
|
1279 david.dillard 1.9
1280 CIMOMHandleOpSemaphore opsem(this);
1281
1282 CIMModifyInstanceRequestMessage* request =
1283 new CIMModifyInstanceRequestMessage(
1284 XmlWriter::getNextMessageId(),
1285 nameSpace,
1286 modifiedInstance,
1287 includeQualifiers,
1288 propertyList,
|
1289 chip 1.17 QueueIdStack());
|
1290 david.dillard 1.9
|
1291 chip 1.17 // copy and adjust, as needed, the operation context
1292 request->operationContext = _filterOperationContext(context);
|
1293 david.dillard 1.9
|
1294 chip 1.17 AutoPtr<CIMModifyInstanceResponseMessage> response;
|
1295 david.dillard 1.9
1296 try
1297 {
|
1298 chip 1.17 response.reset(dynamic_cast<CIMModifyInstanceResponseMessage*>(
1299 do_request(request)));
1300
1301 if(response.get() == 0)
1302 {
1303 PEG_TRACE_STRING(
1304 TRC_CIMOM_HANDLE,
1305 Tracer::LEVEL2,
1306 "Incorrect response type in CIMOMHandle");
1307
1308 throw CIMException(CIM_ERR_FAILED);
1309 }
|
1310 david.dillard 1.9 }
|
1311 chip 1.17 catch(CIMException &)
|
1312 david.dillard 1.9 {
|
1313 chip 1.17 PEG_METHOD_EXIT();
|
1314 david.dillard 1.9 throw;
1315 }
|
1316 chip 1.17 catch(...)
|
1317 david.dillard 1.9 {
|
1318 chip 1.17 PEG_TRACE_STRING(
1319 TRC_CIMOM_HANDLE,
1320 Tracer::LEVEL2,
|
1321 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1322 chip 1.17
1323 PEG_METHOD_EXIT();
1324 throw CIMException(
1325 CIM_ERR_FAILED,
1326 MessageLoaderParms(
1327 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1328 "Exception caught in CIMOMHandle"));
|
1329 david.dillard 1.9 }
1330
1331 PEG_METHOD_EXIT();
1332 return;
1333 }
1334
1335
1336 void InternalCIMOMHandleRep::deleteInstance(
1337 const OperationContext & context,
1338 const CIMNamespaceName &nameSpace,
1339 const CIMObjectPath& instanceName)
1340 {
1341 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1342 "InternalCIMOMHandleRep::deleteInstance");
1343
|
1344 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1345 david.dillard 1.9 // If this is running in user-state, then run the request
1346 // through the user-state layer
1347 if (_chOS400.hasKey())
1348 {
1349 _chOS400.deleteInstance(
1350 context,
1351 nameSpace,
1352 instanceName);
|
1353 chip 1.17
1354 PEG_METHOD_EXIT();
|
1355 david.dillard 1.9 return;
1356 }
|
1357 chip 1.17 #endif
|
1358 david.dillard 1.9
1359 CIMOMHandleOpSemaphore opsem(this);
1360
1361 CIMDeleteInstanceRequestMessage* request =
1362 new CIMDeleteInstanceRequestMessage(
1363 XmlWriter::getNextMessageId(),
1364 nameSpace,
1365 instanceName,
|
1366 chip 1.17 QueueIdStack());
|
1367 david.dillard 1.9
|
1368 chip 1.17 // copy and adjust, as needed, the operation context
1369 request->operationContext = _filterOperationContext(context);
|
1370 david.dillard 1.9
|
1371 chip 1.17 AutoPtr<CIMDeleteInstanceResponseMessage> response;
|
1372 david.dillard 1.9
1373 try
1374 {
|
1375 chip 1.17 response.reset(dynamic_cast<CIMDeleteInstanceResponseMessage*>(
1376 do_request(request)));
1377
1378 if(response.get() == 0)
1379 {
1380 PEG_TRACE_STRING(
1381 TRC_CIMOM_HANDLE,
1382 Tracer::LEVEL2,
1383 "Incorrect response type in CIMOMHandle");
1384
1385 throw CIMException(CIM_ERR_FAILED);
1386 }
|
1387 david.dillard 1.9 }
|
1388 chip 1.17 catch(CIMException &)
|
1389 david.dillard 1.9 {
|
1390 chip 1.17 PEG_METHOD_EXIT();
|
1391 david.dillard 1.9 throw;
1392 }
|
1393 chip 1.17 catch(...)
|
1394 david.dillard 1.9 {
|
1395 chip 1.17 PEG_TRACE_STRING(
1396 TRC_CIMOM_HANDLE,
1397 Tracer::LEVEL2,
|
1398 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1399 chip 1.17
1400 PEG_METHOD_EXIT();
1401 throw CIMException(
1402 CIM_ERR_FAILED,
1403 MessageLoaderParms(
1404 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1405 "Exception caught in CIMOMHandle"));
|
1406 david.dillard 1.9 }
1407
1408 PEG_METHOD_EXIT();
1409 return;
1410 }
1411
1412
1413 Array<CIMObject> InternalCIMOMHandleRep::execQuery(
1414 const OperationContext & context,
1415 const CIMNamespaceName &nameSpace,
1416 const String& queryLanguage,
1417 const String& query)
1418 {
1419 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::execQuery");
1420
|
1421 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1422 david.dillard 1.9 // If this is running in user-state, then run the request
1423 // through the user-state layer
1424 if (_chOS400.hasKey())
1425 {
|
1426 chip 1.17 Array<CIMObject> cimObjects =
1427 _chOS400.execQuery(
1428 context,
1429 nameSpace,
1430 queryLanguage,
1431 query);
1432
1433 PEG_METHOD_EXIT();
1434 return(cimObjects);
|
1435 david.dillard 1.9 }
|
1436 chip 1.17 #endif
|
1437 david.dillard 1.9
1438 CIMOMHandleOpSemaphore opsem(this);
1439
1440 CIMExecQueryRequestMessage* request =
1441 new CIMExecQueryRequestMessage(
1442 XmlWriter::getNextMessageId(),
1443 nameSpace,
1444 queryLanguage,
1445 query,
|
1446 chip 1.17 QueueIdStack());
|
1447 david.dillard 1.9
|
1448 chip 1.17 // copy and adjust, as needed, the operation context
1449 request->operationContext = _filterOperationContext(context);
|
1450 david.dillard 1.9
|
1451 chip 1.17 AutoPtr<CIMExecQueryResponseMessage> response;
|
1452 david.dillard 1.9
1453 try
1454 {
|
1455 chip 1.17 response.reset(dynamic_cast<CIMExecQueryResponseMessage*>(
1456 do_request(request)));
1457
1458 if(response.get() == 0)
1459 {
1460 PEG_TRACE_STRING(
1461 TRC_CIMOM_HANDLE,
1462 Tracer::LEVEL2,
1463 "Incorrect response type in CIMOMHandle");
1464
1465 throw CIMException(CIM_ERR_FAILED);
1466 }
|
1467 david.dillard 1.9 }
|
1468 chip 1.17 catch(CIMException &)
|
1469 david.dillard 1.9 {
|
1470 chip 1.17 PEG_METHOD_EXIT();
|
1471 david.dillard 1.9 throw;
1472 }
|
1473 chip 1.17 catch(...)
|
1474 david.dillard 1.9 {
|
1475 chip 1.17 PEG_TRACE_STRING(
1476 TRC_CIMOM_HANDLE,
1477 Tracer::LEVEL2,
|
1478 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1479 chip 1.17
1480 PEG_METHOD_EXIT();
1481 throw CIMException(
1482 CIM_ERR_FAILED,
1483 MessageLoaderParms(
1484 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1485 "Exception caught in CIMOMHandle"));
|
1486 david.dillard 1.9 }
1487
1488 Array<CIMObject> cimObjects = response->cimObjects;
1489
1490 PEG_METHOD_EXIT();
1491 return(cimObjects);
1492 }
1493
1494
1495 Array<CIMObject> InternalCIMOMHandleRep::associators(
1496 const OperationContext & context,
1497 const CIMNamespaceName &nameSpace,
1498 const CIMObjectPath& objectName,
1499 const CIMName& assocClass,
1500 const CIMName& resultClass,
1501 const String& role,
1502 const String& resultRole,
1503 Boolean includeQualifiers,
1504 Boolean includeClassOrigin,
1505 const CIMPropertyList& propertyList)
1506 {
1507 david.dillard 1.9 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::associators");
1508
|
1509 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1510 david.dillard 1.9 // If this is running in user-state, then run the request
1511 // through the user-state layer
1512 if (_chOS400.hasKey())
1513 {
|
1514 chip 1.17 Array<CIMObject> cimObjects =
1515 _chOS400.associators(
1516 context,
1517 nameSpace,
1518 objectName,
1519 assocClass,
1520 resultClass,
1521 role,
1522 resultRole,
1523 includeQualifiers,
1524 includeClassOrigin,
1525 propertyList);
1526
1527 PEG_METHOD_EXIT();
1528 return(cimObjects);
1529 }
1530 #endif
1531
1532 CIMOMHandleOpSemaphore opsem(this);
1533
1534 CIMAssociatorsRequestMessage* request =
1535 chip 1.17 new CIMAssociatorsRequestMessage(
1536 XmlWriter::getNextMessageId(),
|
1537 david.dillard 1.9 nameSpace,
1538 objectName,
1539 assocClass,
1540 resultClass,
1541 role,
1542 resultRole,
1543 includeQualifiers,
1544 includeClassOrigin,
|
1545 chip 1.17 propertyList,
1546 QueueIdStack());
|
1547 david.dillard 1.9
|
1548 chip 1.17 // copy and adjust, as needed, the operation context
1549 request->operationContext = _filterOperationContext(context);
|
1550 david.dillard 1.9
|
1551 chip 1.17 AutoPtr<CIMAssociatorsResponseMessage> response;
|
1552 david.dillard 1.9
1553 try
1554 {
|
1555 chip 1.17 response.reset(dynamic_cast<CIMAssociatorsResponseMessage*>(
1556 do_request(request)));
1557
1558 if(response.get() == 0)
1559 {
1560 PEG_TRACE_STRING(
1561 TRC_CIMOM_HANDLE,
1562 Tracer::LEVEL2,
1563 "Incorrect response type in CIMOMHandle");
1564
1565 throw CIMException(CIM_ERR_FAILED);
1566 }
|
1567 david.dillard 1.9 }
|
1568 chip 1.17 catch(CIMException &)
|
1569 david.dillard 1.9 {
|
1570 chip 1.17 PEG_METHOD_EXIT();
|
1571 david.dillard 1.9 throw;
1572 }
|
1573 chip 1.17 catch(...)
|
1574 david.dillard 1.9 {
|
1575 chip 1.17 PEG_TRACE_STRING(
1576 TRC_CIMOM_HANDLE,
1577 Tracer::LEVEL2,
|
1578 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1579 chip 1.17
1580 PEG_METHOD_EXIT();
1581 throw CIMException(
1582 CIM_ERR_FAILED,
1583 MessageLoaderParms(
1584 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1585 "Exception caught in CIMOMHandle"));
|
1586 david.dillard 1.9 }
1587
1588 Array<CIMObject> cimObjects = response->cimObjects;
1589
1590 PEG_METHOD_EXIT();
1591 return(cimObjects);
1592 }
1593
1594
1595 Array<CIMObjectPath> InternalCIMOMHandleRep::associatorNames(
1596 const OperationContext & context,
1597 const CIMNamespaceName &nameSpace,
1598 const CIMObjectPath& objectName,
1599 const CIMName& assocClass,
1600 const CIMName& resultClass,
1601 const String& role,
1602 const String& resultRole)
1603 {
1604 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1605 "InternalCIMOMHandleRep::associatorNames");
1606
|
1607 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1608 david.dillard 1.9 // If this is running in user-state, then run the request
1609 // through the user-state layer
1610 if (_chOS400.hasKey())
1611 {
|
1612 chip 1.17 Array<CIMObjectPath> cimObjectPaths =
1613 _chOS400.associatorNames(
1614 context,
1615 nameSpace,
1616 objectName,
1617 assocClass,
1618 resultClass,
1619 role,
1620 resultRole);
1621
1622 PEG_METHOD_EXIT();
1623 return(cimObjectPaths);
|
1624 david.dillard 1.9 }
|
1625 chip 1.17 #endif
|
1626 david.dillard 1.9
1627 CIMOMHandleOpSemaphore opsem(this);
1628
1629 CIMAssociatorNamesRequestMessage* request =
1630 new CIMAssociatorNamesRequestMessage(
1631 XmlWriter::getNextMessageId(),
1632 nameSpace,
1633 objectName,
1634 assocClass,
1635 resultClass,
1636 role,
1637 resultRole,
|
1638 chip 1.17 QueueIdStack());
|
1639 david.dillard 1.9
|
1640 chip 1.17 // copy and adjust, as needed, the operation context
1641 request->operationContext = _filterOperationContext(context);
|
1642 david.dillard 1.9
|
1643 chip 1.17 AutoPtr<CIMAssociatorNamesResponseMessage> response;
|
1644 david.dillard 1.9
1645 try
1646 {
|
1647 chip 1.17 response.reset(dynamic_cast<CIMAssociatorNamesResponseMessage*>(
1648 do_request(request)));
1649
1650 if(response.get() == 0)
1651 {
1652 PEG_TRACE_STRING(
1653 TRC_CIMOM_HANDLE,
1654 Tracer::LEVEL2,
1655 "Incorrect response type in CIMOMHandle");
1656
1657 throw CIMException(CIM_ERR_FAILED);
1658 }
|
1659 david.dillard 1.9 }
|
1660 chip 1.17 catch(CIMException &)
|
1661 david.dillard 1.9 {
|
1662 chip 1.17 PEG_METHOD_EXIT();
|
1663 david.dillard 1.9 throw;
1664 }
|
1665 chip 1.17 catch(...)
|
1666 david.dillard 1.9 {
|
1667 chip 1.17 PEG_TRACE_STRING(
1668 TRC_CIMOM_HANDLE,
1669 Tracer::LEVEL2,
|
1670 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1671 chip 1.17
1672 PEG_METHOD_EXIT();
1673 throw CIMException(
1674 CIM_ERR_FAILED,
1675 MessageLoaderParms(
1676 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1677 "Exception caught in CIMOMHandle"));
|
1678 david.dillard 1.9 }
1679
1680 Array<CIMObjectPath> cimObjectPaths = response->objectNames;
1681
1682 PEG_METHOD_EXIT();
1683 return(cimObjectPaths);
1684 }
1685
1686
1687 Array<CIMObject> InternalCIMOMHandleRep::references(
1688 const OperationContext & context,
1689 const CIMNamespaceName &nameSpace,
1690 const CIMObjectPath& objectName,
1691 const CIMName& resultClass,
1692 const String& role,
1693 Boolean includeQualifiers,
1694 Boolean includeClassOrigin,
1695 const CIMPropertyList& propertyList)
1696 {
1697 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::references");
1698
|
1699 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1700 david.dillard 1.9 // If this is running in user-state, then run the request
1701 // through the user-state layer
1702 if (_chOS400.hasKey())
1703 {
|
1704 chip 1.17 Array<CIMObject> cimObjects =
1705 _chOS400.references(
1706 context,
1707 nameSpace,
1708 objectName,
1709 resultClass,
1710 role,
1711 includeQualifiers,
1712 includeClassOrigin,
1713 propertyList);
1714
1715 PEG_METHOD_EXIT();
1716 return(cimObjects);
|
1717 david.dillard 1.9 }
|
1718 chip 1.17 #endif
|
1719 david.dillard 1.9
1720 CIMOMHandleOpSemaphore opsem(this);
1721
1722 CIMReferencesRequestMessage* request =
1723 new CIMReferencesRequestMessage(
1724 XmlWriter::getNextMessageId(),
1725 nameSpace,
1726 objectName,
1727 resultClass,
1728 role,
1729 includeQualifiers,
1730 includeClassOrigin,
1731 propertyList,
|
1732 chip 1.17 QueueIdStack());
|
1733 david.dillard 1.9
|
1734 chip 1.17 // copy and adjust, as needed, the operation context
1735 request->operationContext = _filterOperationContext(context);
|
1736 david.dillard 1.9
|
1737 chip 1.17 AutoPtr<CIMReferencesResponseMessage> response;
|
1738 david.dillard 1.9
1739 try
1740 {
|
1741 chip 1.17 response.reset(dynamic_cast<CIMReferencesResponseMessage*>(
1742 do_request(request)));
1743
1744 if(response.get() == 0)
1745 {
1746 PEG_TRACE_STRING(
1747 TRC_CIMOM_HANDLE,
1748 Tracer::LEVEL2,
1749 "Incorrect response type in CIMOMHandle");
1750
1751 throw CIMException(CIM_ERR_FAILED);
1752 }
|
1753 david.dillard 1.9 }
|
1754 chip 1.17 catch(CIMException &)
|
1755 david.dillard 1.9 {
|
1756 chip 1.17 PEG_METHOD_EXIT();
|
1757 david.dillard 1.9 throw;
1758 }
|
1759 chip 1.17 catch(...)
|
1760 david.dillard 1.9 {
|
1761 chip 1.17 PEG_TRACE_STRING(
1762 TRC_CIMOM_HANDLE,
1763 Tracer::LEVEL2,
|
1764 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1765 chip 1.17
1766 PEG_METHOD_EXIT();
1767 throw CIMException(
1768 CIM_ERR_FAILED,
1769 MessageLoaderParms(
1770 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1771 "Exception caught in CIMOMHandle"));
|
1772 david.dillard 1.9 }
1773
1774 Array<CIMObject> cimObjects = response->cimObjects;
1775
1776 PEG_METHOD_EXIT();
1777 return(cimObjects);
1778 }
1779
1780
1781 Array<CIMObjectPath> InternalCIMOMHandleRep::referenceNames(
1782 const OperationContext & context,
1783 const CIMNamespaceName &nameSpace,
1784 const CIMObjectPath& objectName,
1785 const CIMName& resultClass,
1786 const String& role)
1787 {
1788 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
1789 "InternalCIMOMHandleRep::referenceNames");
1790
|
1791 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1792 david.dillard 1.9 // If this is running in user-state, then run the request
1793 // through the user-state layer
1794 if (_chOS400.hasKey())
1795 {
|
1796 chip 1.17 Array<CIMObjectPath> cimObjectPaths =
1797 _chOS400.referenceNames(
1798 context,
1799 nameSpace,
1800 objectName,
1801 resultClass,
1802 role);
1803
1804 PEG_METHOD_EXIT();
1805 return(cimObjectPaths);
|
1806 david.dillard 1.9 }
|
1807 chip 1.17 #endif
|
1808 david.dillard 1.9
1809 CIMOMHandleOpSemaphore opsem(this);
1810
1811 CIMReferenceNamesRequestMessage* request =
1812 new CIMReferenceNamesRequestMessage(
1813 XmlWriter::getNextMessageId(),
1814 nameSpace,
1815 objectName,
1816 resultClass,
1817 role,
|
1818 chip 1.17 QueueIdStack());
|
1819 david.dillard 1.9
|
1820 chip 1.17 // copy and adjust, as needed, the operation context
1821 request->operationContext = _filterOperationContext(context);
|
1822 david.dillard 1.9
|
1823 chip 1.17 AutoPtr<CIMReferenceNamesResponseMessage> response;
|
1824 david.dillard 1.9
1825 try
1826 {
|
1827 chip 1.17 response.reset(dynamic_cast<CIMReferenceNamesResponseMessage*>(
1828 do_request(request)));
1829
1830 if(response.get() == 0)
1831 {
1832 PEG_TRACE_STRING(
1833 TRC_CIMOM_HANDLE,
1834 Tracer::LEVEL2,
1835 "Incorrect response type in CIMOMHandle");
1836
1837 throw CIMException(CIM_ERR_FAILED);
1838 }
|
1839 david.dillard 1.9 }
|
1840 chip 1.17 catch(CIMException &)
|
1841 david.dillard 1.9 {
|
1842 chip 1.17 PEG_METHOD_EXIT();
|
1843 david.dillard 1.9 throw;
1844 }
|
1845 chip 1.17 catch(...)
|
1846 david.dillard 1.9 {
|
1847 chip 1.17 PEG_TRACE_STRING(
1848 TRC_CIMOM_HANDLE,
1849 Tracer::LEVEL2,
|
1850 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1851 chip 1.17
1852 PEG_METHOD_EXIT();
1853 throw CIMException(
1854 CIM_ERR_FAILED,
1855 MessageLoaderParms(
1856 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1857 "Exception caught in CIMOMHandle"));
|
1858 david.dillard 1.9 }
1859
1860 Array<CIMObjectPath> cimObjectPaths = response->objectNames;
1861
1862 PEG_METHOD_EXIT();
1863 return(cimObjectPaths);
1864 }
1865
1866
1867 CIMValue InternalCIMOMHandleRep::getProperty(
1868 const OperationContext & context,
1869 const CIMNamespaceName &nameSpace,
1870 const CIMObjectPath& instanceName,
1871 const CIMName& propertyName)
1872 {
1873 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::getProperty");
1874
|
1875 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1876 david.dillard 1.9 // If this is running in user-state, then run the request
1877 // through the user-state layer
1878 if (_chOS400.hasKey())
1879 {
|
1880 chip 1.17 CIMValue cimValue =
1881 _chOS400.getProperty(
1882 context,
1883 nameSpace,
1884 instanceName,
1885 propertyName);
1886
1887 PEG_METHOD_EXIT();
1888 return(cimValue);
|
1889 david.dillard 1.9 }
|
1890 chip 1.17 #endif
|
1891 david.dillard 1.9
1892 CIMOMHandleOpSemaphore opsem(this);
1893
1894 CIMGetPropertyRequestMessage* request =
1895 new CIMGetPropertyRequestMessage(
|
1896 chip 1.17 XmlWriter::getNextMessageId(),
1897 nameSpace,
1898 instanceName,
1899 propertyName,
1900 QueueIdStack());
|
1901 david.dillard 1.9
|
1902 chip 1.17 // copy and adjust, as needed, the operation context
1903 request->operationContext = _filterOperationContext(context);
|
1904 david.dillard 1.9
|
1905 chip 1.17 AutoPtr<CIMGetPropertyResponseMessage> response;
|
1906 david.dillard 1.9
1907 try
1908 {
|
1909 chip 1.17 response.reset(dynamic_cast<CIMGetPropertyResponseMessage*>(
1910 do_request(request)));
1911
1912 if(response.get() == 0)
1913 {
1914 PEG_TRACE_STRING(
1915 TRC_CIMOM_HANDLE,
1916 Tracer::LEVEL2,
1917 "Incorrect response type in CIMOMHandle");
1918
1919 throw CIMException(CIM_ERR_FAILED);
1920 }
|
1921 david.dillard 1.9 }
|
1922 chip 1.17 catch(CIMException &)
|
1923 david.dillard 1.9 {
|
1924 chip 1.17 PEG_METHOD_EXIT();
|
1925 david.dillard 1.9 throw;
1926 }
|
1927 chip 1.17 catch(...)
|
1928 david.dillard 1.9 {
|
1929 chip 1.17 PEG_TRACE_STRING(
1930 TRC_CIMOM_HANDLE,
1931 Tracer::LEVEL2,
|
1932 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
1933 chip 1.17
1934 PEG_METHOD_EXIT();
1935 throw CIMException(
1936 CIM_ERR_FAILED,
1937 MessageLoaderParms(
1938 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
1939 "Exception caught in CIMOMHandle"));
|
1940 david.dillard 1.9 }
1941
1942 CIMValue cimValue = response->value;
1943
1944 PEG_METHOD_EXIT();
1945 return(cimValue);
1946 }
1947
1948
1949 void InternalCIMOMHandleRep::setProperty(
1950 const OperationContext & context,
1951 const CIMNamespaceName &nameSpace,
1952 const CIMObjectPath& instanceName,
1953 const CIMName& propertyName,
1954 const CIMValue& newValue)
1955 {
1956 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::setProperty");
1957
|
1958 chip 1.17 #ifdef PEGASUS_OS_OS400
|
1959 david.dillard 1.9 // If this is running in user-state, then run the request
1960 // through the user-state layer
1961 if (_chOS400.hasKey())
1962 {
1963 _chOS400.setProperty(
1964 context,
1965 nameSpace,
1966 instanceName,
1967 propertyName,
1968 newValue);
|
1969 chip 1.17
1970 PEG_METHOD_EXIT();
|
1971 david.dillard 1.9 return;
1972 }
|
1973 chip 1.17 #endif
|
1974 david.dillard 1.9
1975 CIMOMHandleOpSemaphore opsem(this);
1976
1977 CIMSetPropertyRequestMessage* request =
1978 new CIMSetPropertyRequestMessage(
1979 XmlWriter::getNextMessageId(),
1980 nameSpace,
1981 instanceName,
1982 propertyName,
1983 newValue,
|
1984 chip 1.17 QueueIdStack());
|
1985 david.dillard 1.9
|
1986 chip 1.17 // copy and adjust, as needed, the operation context
1987 request->operationContext = _filterOperationContext(context);
|
1988 david.dillard 1.9
|
1989 chip 1.17 AutoPtr<CIMSetPropertyResponseMessage> response;
|
1990 david.dillard 1.9
1991 try
1992 {
|
1993 chip 1.17 response.reset(dynamic_cast<CIMSetPropertyResponseMessage*>(
1994 do_request(request)));
1995
1996 if(response.get() == 0)
1997 {
1998 PEG_TRACE_STRING(
1999 TRC_CIMOM_HANDLE,
2000 Tracer::LEVEL2,
2001 "Incorrect response type in CIMOMHandle");
2002
2003 throw CIMException(CIM_ERR_FAILED);
2004 }
|
2005 david.dillard 1.9 }
|
2006 chip 1.17 catch(CIMException &)
|
2007 david.dillard 1.9 {
|
2008 chip 1.17 PEG_METHOD_EXIT();
|
2009 david.dillard 1.9 throw;
2010 }
|
2011 chip 1.17 catch(...)
|
2012 david.dillard 1.9 {
|
2013 chip 1.17 PEG_TRACE_STRING(
2014 TRC_CIMOM_HANDLE,
2015 Tracer::LEVEL2,
|
2016 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
2017 chip 1.17
2018 PEG_METHOD_EXIT();
2019 throw CIMException(
2020 CIM_ERR_FAILED,
2021 MessageLoaderParms(
2022 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
2023 "Exception caught in CIMOMHandle"));
|
2024 david.dillard 1.9 }
2025
2026 PEG_METHOD_EXIT();
2027 return;
2028 }
2029
2030
2031 CIMValue InternalCIMOMHandleRep::invokeMethod(
2032 const OperationContext & context,
2033 const CIMNamespaceName &nameSpace,
2034 const CIMObjectPath& instanceName,
2035 const CIMName& methodName,
2036 const Array<CIMParamValue>& inParameters,
2037 Array<CIMParamValue>& outParameters)
2038 {
2039 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "InternalCIMOMHandleRep::invokeMethod");
2040
|
2041 chip 1.17 #ifdef PEGASUS_OS_OS400
|
2042 david.dillard 1.9 // If this is running in user-state, then run the request
2043 // through the user-state layer
2044 if (_chOS400.hasKey())
2045 {
|
2046 chip 1.17 CIMValue cimValue =
2047 _chOS400.invokeMethod(
2048 context,
2049 nameSpace,
2050 instanceName,
2051 methodName,
2052 inParameters,
2053 outParameters);
2054
2055 PEG_METHOD_EXIT();
2056 return(cimValue);
|
2057 david.dillard 1.9 }
|
2058 chip 1.17 #endif
|
2059 david.dillard 1.9
2060 CIMOMHandleOpSemaphore opsem(this);
2061
2062 CIMInvokeMethodRequestMessage* request =
2063 new CIMInvokeMethodRequestMessage(
2064 XmlWriter::getNextMessageId(),
2065 nameSpace,
2066 instanceName,
2067 methodName,
2068 inParameters,
|
2069 chip 1.17 QueueIdStack());
2070
2071 // copy and adjust, as needed, the operation context
2072 request->operationContext = _filterOperationContext(context);
|
2073 david.dillard 1.9
|
2074 chip 1.17 AutoPtr<CIMInvokeMethodResponseMessage> response;
|
2075 david.dillard 1.9
2076 try
2077 {
|
2078 chip 1.17 response.reset(dynamic_cast<CIMInvokeMethodResponseMessage*>(
2079 do_request(request)));
2080
2081 if(response.get() == 0)
2082 {
2083 PEG_TRACE_STRING(
2084 TRC_CIMOM_HANDLE,
2085 Tracer::LEVEL2,
2086 "Incorrect response type in CIMOMHandle");
2087
2088 throw CIMException(CIM_ERR_FAILED);
2089 }
|
2090 david.dillard 1.9 }
|
2091 chip 1.17 catch(CIMException &)
|
2092 david.dillard 1.9 {
|
2093 chip 1.17 PEG_METHOD_EXIT();
|
2094 david.dillard 1.9 throw;
2095 }
|
2096 chip 1.17 catch(...)
|
2097 david.dillard 1.9 {
|
2098 chip 1.17 PEG_TRACE_STRING(
2099 TRC_CIMOM_HANDLE,
2100 Tracer::LEVEL2,
|
2101 david.dillard 1.9 "Exception caught in CIMOMHandle");
|
2102 chip 1.17
2103 PEG_METHOD_EXIT();
2104 throw CIMException(
2105 CIM_ERR_FAILED,
2106 MessageLoaderParms(
2107 "Provider.CIMOMHandle.CAUGHT_EXCEPTION",
2108 "Exception caught in CIMOMHandle"));
|
2109 david.dillard 1.9 }
2110
|
2111 chip 1.17 CIMValue cimValue = response->retValue;
|
2112 kumpf 1.15 outParameters = response->outParameters;
|
2113 david.dillard 1.9
2114 PEG_METHOD_EXIT();
|
2115 chip 1.17 return(cimValue);
|
2116 david.dillard 1.9 }
2117
2118
2119 //
2120 // Public CIMOMHandle Methods
2121 //
2122
2123 void InternalCIMOMHandleRep::disallowProviderUnload()
2124 {
|
2125 chip 1.17 #ifdef PEGASUS_OS_OS400
|
2126 david.dillard 1.9 // If this is running in user-state, then run the request
2127 // through the user-state layer
2128 if (_chOS400.hasKey())
2129 {
2130 _chOS400.disallowProviderUnload();
2131 return;
2132 }
|
2133 chip 1.17 #endif
|
2134 david.dillard 1.9
2135 CIMOMHandleRep::disallowProviderUnload();
2136 }
2137
2138 void InternalCIMOMHandleRep::allowProviderUnload()
2139 {
|
2140 chip 1.17 #ifdef PEGASUS_OS_OS400
|
2141 david.dillard 1.9 // If this is running in user-state, then run the request
2142 // through the user-state layer
2143 if (_chOS400.hasKey())
2144 {
2145 _chOS400.allowProviderUnload();
2146 return;
2147 }
|
2148 chip 1.17 #endif
|
2149 david.dillard 1.9
2150 CIMOMHandleRep::allowProviderUnload();
2151 }
2152
2153 #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
2154 OperationContext InternalCIMOMHandleRep::getResponseContext()
2155 {
2156 OperationContext ctx;
2157
2158 Thread* curThrd = Thread::getCurrent();
2159 if (curThrd == NULL)
2160 {
|
2161 kumpf 1.19 ctx.insert(ContentLanguageListContainer(ContentLanguageList()));
|
2162 david.dillard 1.9 }
2163 else
2164 {
|
2165 kumpf 1.19 ContentLanguageList* contentLangs = (ContentLanguageList*)
|
2166 david.dillard 1.9 curThrd->reference_tsd("cimomHandleContentLanguages");
2167 curThrd->dereference_tsd();
|
2168 chip 1.17
|
2169 david.dillard 1.9 if (contentLangs == NULL)
2170 {
|
2171 kumpf 1.19 ctx.insert(ContentLanguageListContainer(ContentLanguageList()));
|
2172 david.dillard 1.9 }
2173 else
2174 {
2175 ctx.insert(ContentLanguageListContainer(*contentLangs));
2176 // delete the old tsd to free the memory
2177 curThrd->delete_tsd("cimomHandleContentLanguages");
2178 }
2179 }
2180
2181 return ctx;
2182 }
2183 #endif
2184
2185 PEGASUS_NAMESPACE_END
|
Return to
InternalCIMOMHandleRep.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Provider