1 mike 1.1 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to
7 // deal in the Software without restriction, including without limitation the
8 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
9 // sell copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
13 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
14 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
15 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
16 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
17 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
19 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 //
21 //==============================================================================
22 mike 1.1 //
23 // Author: Mike Brasher (mbrasher@bmc.com)
24 //
25 // Modified By:
26 //
27 //%/////////////////////////////////////////////////////////////////////////////
28
29 #include <Pegasus/Common/XmlWriter.h>
30 #include <Pegasus/Common/CIMMessage.h>
31 #include <Pegasus/Common/Destroyer.h>
32 #include "CIMOMHandle.h"
33
34 PEGASUS_NAMESPACE_BEGIN
35
36 CIMOMHandle::CIMOMHandle(
37 MessageQueue* outputQueue,
38 CIMRepository* repository)
39 :
40 _outputQueue(outputQueue),
41 _repository(repository)
42 {
43 mike 1.1 _inputQueue = new MessageQueue;
44 }
45
46 CIMOMHandle::~CIMOMHandle()
47 {
48 delete _inputQueue;
49 }
50
51 CIMClass CIMOMHandle::getClass(
52 const String& nameSpace,
53 const String& className,
54 Boolean localOnly,
55 Boolean includeQualifiers,
56 Boolean includeClassOrigin,
57 const Array<String>& propertyList)
58 {
59 Message* request = new CIMGetClassRequestMessage(
60 XmlWriter::getNextMessageId(),
61 nameSpace,
62 className,
63 localOnly,
64 mike 1.1 includeQualifiers,
65 includeClassOrigin,
66 propertyList,
67 _inputQueue->getQueueId());
68
69 _outputQueue->enqueue(request);
70
71 Message* message = _inputQueue->dequeue();
72
73 CIMGetClassResponseMessage* response = (CIMGetClassResponseMessage*)message;
74
75 _checkError(response);
76
77 return response->cimClass;
78 }
79
80 CIMInstance CIMOMHandle::getInstance(
81 const String& nameSpace,
82 const CIMReference& instanceName,
83 Boolean localOnly,
84 Boolean includeQualifiers,
85 mike 1.1 Boolean includeClassOrigin,
86 const Array<String>& propertyList)
87 {
88 Message* request = new CIMGetInstanceRequestMessage(
89 XmlWriter::getNextMessageId(),
90 nameSpace,
91 instanceName,
92 localOnly,
93 includeQualifiers,
94 includeClassOrigin,
95 propertyList,
96 _inputQueue->getQueueId());
97
98 _outputQueue->enqueue(request);
99
100 Message* message = _inputQueue->dequeue();
101
102 CIMGetInstanceResponseMessage* response
103 = (CIMGetInstanceResponseMessage*)message;
104
105 _checkError(response);
106 mike 1.1
107 return response->cimInstance;
108 }
109
110
111 void CIMOMHandle::deleteClass(
112 const String& nameSpace,
113 const String& className)
114 {
115 Message* request = new CIMDeleteClassRequestMessage(
116 XmlWriter::getNextMessageId(),
117 nameSpace,
118 className,
119 _inputQueue->getQueueId());
120
121 _outputQueue->enqueue(request);
122
123 Message* message = _inputQueue->dequeue();
124
125 CIMDeleteClassResponseMessage* response
126 = (CIMDeleteClassResponseMessage*)message;
127 mike 1.1
128 _checkError(response);
129 }
130
131
132 void CIMOMHandle::deleteInstance(
133 const String& nameSpace,
134 const CIMReference& instanceName)
135 {
136 Message* request = new CIMDeleteInstanceRequestMessage(
137 XmlWriter::getNextMessageId(),
138 nameSpace,
139 instanceName,
140 _inputQueue->getQueueId());
141
142 _outputQueue->enqueue(request);
143
144 Message* message = _inputQueue->dequeue();
145
146 CIMDeleteInstanceResponseMessage* response
147 = (CIMDeleteInstanceResponseMessage*)message;
148 mike 1.1
149 _checkError(response);
150 }
151
152
153 void CIMOMHandle::createClass(
154 const String& nameSpace,
155 const CIMClass& newClass)
156 {
157 Message* request = new CIMCreateClassRequestMessage(
158 XmlWriter::getNextMessageId(),
159 nameSpace,
160 newClass,
161 _inputQueue->getQueueId());
162
163 _outputQueue->enqueue(request);
164
165 Message* message = _inputQueue->dequeue();
166
167 CIMCreateClassResponseMessage* response
168 = (CIMCreateClassResponseMessage*)message;
169 mike 1.1
170 _checkError(response);
171 }
172
173 void CIMOMHandle::createInstance(
174 const String& nameSpace,
175 const CIMInstance& newInstance)
176 {
177 Message* request = new CIMCreateInstanceRequestMessage(
178 XmlWriter::getNextMessageId(),
179 nameSpace,
180 newInstance,
181 _inputQueue->getQueueId());
182
183 _outputQueue->enqueue(request);
184
185 Message* message = _inputQueue->dequeue();
186
187 CIMCreateInstanceResponseMessage* response
188 = (CIMCreateInstanceResponseMessage*)message;
189
190 mike 1.1 _checkError(response);
191 }
192
193
194 void CIMOMHandle::modifyClass(
195 const String& nameSpace,
196 const CIMClass& modifiedClass)
197 {
198 Message* request = new CIMModifyClassRequestMessage(
199 XmlWriter::getNextMessageId(),
200 nameSpace,
201 modifiedClass,
202 _inputQueue->getQueueId());
203
204 _outputQueue->enqueue(request);
205
206 Message* message = _inputQueue->dequeue();
207
208 CIMModifyClassResponseMessage* response
209 = (CIMModifyClassResponseMessage*)message;
210
211 mike 1.1 _checkError(response);
212 }
213
214
215 void CIMOMHandle::modifyInstance(
216 const String& nameSpace,
217 const CIMInstance& modifiedInstance)
218 {
219 Message* request = new CIMModifyInstanceRequestMessage(
220 XmlWriter::getNextMessageId(),
221 nameSpace,
222 modifiedInstance,
223 _inputQueue->getQueueId());
224
225 _outputQueue->enqueue(request);
226
227 Message* message = _inputQueue->dequeue();
228
229 CIMModifyInstanceResponseMessage* response
230 = (CIMModifyInstanceResponseMessage*)message;
231
232 mike 1.1 _checkError(response);
233 }
234
235
236 Array<CIMClass> CIMOMHandle::enumerateClasses(
237 const String& nameSpace,
238 const String& className,
239 Boolean deepInheritance,
240 Boolean localOnly,
241 Boolean includeQualifiers,
242 Boolean includeClassOrigin)
243 {
244 Message* request = new CIMEnumerateClassesRequestMessage(
245 XmlWriter::getNextMessageId(),
246 nameSpace,
247 className,
248 deepInheritance,
249 localOnly,
250 includeQualifiers,
251 includeClassOrigin,
252 _inputQueue->getQueueId());
253 mike 1.1
254 _outputQueue->enqueue(request);
255
256 Message* message = _inputQueue->dequeue();
257
258 CIMEnumerateClassesResponseMessage* response
259 = (CIMEnumerateClassesResponseMessage*)message;
260
261 _checkError(response);
262
263 return response->cimClasses;
264 }
265
266 Array<String> CIMOMHandle::enumerateClassNames(
267 const String& nameSpace,
268 const String& className,
269 Boolean deepInheritance)
270 {
271 Message* request = new CIMEnumerateClassNamesRequestMessage(
272 XmlWriter::getNextMessageId(),
273 nameSpace,
274 mike 1.1 className,
275 deepInheritance,
276 _inputQueue->getQueueId());
277
278 _outputQueue->enqueue(request);
279
280 Message* message = _inputQueue->dequeue();
281
282 CIMEnumerateClassNamesResponseMessage* response
283 = (CIMEnumerateClassNamesResponseMessage*)message;
284
285 _checkError(response);
286
287 return response->classNames;
288 }
289
290
291 Array<CIMInstance> CIMOMHandle::enumerateInstances(
292 const String& nameSpace,
293 const String& className,
294 Boolean deepInheritance,
295 mike 1.1 Boolean localOnly,
296 Boolean includeQualifiers,
297 Boolean includeClassOrigin,
298 const Array<String>& propertyList)
299 {
300 Message* request = new CIMEnumerateInstancesRequestMessage(
301 XmlWriter::getNextMessageId(),
302 nameSpace,
303 className,
304 deepInheritance,
305 localOnly,
306 includeQualifiers,
307 includeClassOrigin,
308 propertyList,
309 _inputQueue->getQueueId());
310
311 _outputQueue->enqueue(request);
312
313 Message* message = _inputQueue->dequeue();
314
315 CIMEnumerateInstancesResponseMessage* response
316 mike 1.1 = (CIMEnumerateInstancesResponseMessage*)message;
317
318 _checkError(response);
319
320 return response->cimInstances;
321 }
322
323
324 Array<CIMReference> CIMOMHandle::enumerateInstanceNames(
325 const String& nameSpace,
326 const String& className)
327 {
328 Message* request = new CIMEnumerateInstanceNamesRequestMessage(
329 XmlWriter::getNextMessageId(),
330 nameSpace,
331 className,
332 _inputQueue->getQueueId());
333
334 _outputQueue->enqueue(request);
335
336 Message* message = _inputQueue->dequeue();
337 mike 1.1
338 CIMEnumerateInstanceNamesResponseMessage* response
339 = (CIMEnumerateInstanceNamesResponseMessage*)message;
340
341 _checkError(response);
342
343 return response->instanceNames;
344 }
345
346 Array<CIMInstance> CIMOMHandle::execQuery(
347 const String& queryLanguage,
348 const String& query)
349 {
350 Message* request = new CIMExecQueryRequestMessage(
351 XmlWriter::getNextMessageId(),
352 queryLanguage,
353 query,
354 _inputQueue->getQueueId());
355
356 _outputQueue->enqueue(request);
357
358 mike 1.1 Message* message = _inputQueue->dequeue();
359
360 CIMExecQueryResponseMessage* response
361 = (CIMExecQueryResponseMessage*)message;
362
363 _checkError(response);
364
365 return response->cimInstances;
366 }
367
368 Array<CIMObjectWithPath> CIMOMHandle::associators(
369 const String& nameSpace,
370 const CIMReference& objectName,
371 const String& assocClass,
372 const String& resultClass,
373 const String& role,
374 const String& resultRole,
375 Boolean includeQualifiers,
376 Boolean includeClassOrigin,
377 const Array<String>& propertyList)
378 {
379 mike 1.1 Message* request = new CIMAssociatorsRequestMessage(
380 XmlWriter::getNextMessageId(),
381 nameSpace,
382 objectName,
383 assocClass,
384 resultClass,
385 role,
386 resultRole,
387 includeQualifiers,
388 includeClassOrigin,
389 propertyList,
390 _inputQueue->getQueueId());
391
392 _outputQueue->enqueue(request);
393
394 Message* message = _inputQueue->dequeue();
395
396 CIMAssociatorsResponseMessage* response
397 = (CIMAssociatorsResponseMessage*)message;
398
399 _checkError(response);
400 mike 1.1
401 return response->cimObjects;
402 }
403
404 Array<CIMReference> CIMOMHandle::associatorNames(
405 const String& nameSpace,
406 const CIMReference& objectName,
407 const String& assocClass,
408 const String& resultClass,
409 const String& role,
410 const String& resultRole)
411 {
412 Message* request = new CIMAssociatorNamesRequestMessage(
413 XmlWriter::getNextMessageId(),
414 nameSpace,
415 objectName,
416 assocClass,
417 resultClass,
418 role,
419 resultRole,
420 _inputQueue->getQueueId());
421 mike 1.1
422 _outputQueue->enqueue(request);
423
424 Message* message = _inputQueue->dequeue();
425
426 CIMAssociatorNamesResponseMessage* response
427 = (CIMAssociatorNamesResponseMessage*)message;
428
429 _checkError(response);
430
431 return response->objectNames;
432 }
433
434 Array<CIMObjectWithPath> CIMOMHandle::references(
435 const String& nameSpace,
436 const CIMReference& objectName,
437 const String& resultClass,
438 const String& role,
439 Boolean includeQualifiers,
440 Boolean includeClassOrigin,
441 const Array<String>& propertyList)
442 mike 1.1 {
443 Message* request = new CIMReferencesRequestMessage(
444 XmlWriter::getNextMessageId(),
445 nameSpace,
446 objectName,
447 resultClass,
448 role,
449 includeQualifiers,
450 includeClassOrigin,
451 propertyList,
452 _inputQueue->getQueueId());
453
454 _outputQueue->enqueue(request);
455
456 Message* message = _inputQueue->dequeue();
457
458 CIMReferencesResponseMessage* response
459 = (CIMReferencesResponseMessage*)message;
460
461 _checkError(response);
462
463 mike 1.1 return response->cimObjects;
464 }
465
466 Array<CIMReference> CIMOMHandle::referenceNames(
467 const String& nameSpace,
468 const CIMReference& objectName,
469 const String& resultClass,
470 const String& role)
471 {
472 Message* request = new CIMReferenceNamesRequestMessage(
473 XmlWriter::getNextMessageId(),
474 nameSpace,
475 objectName,
476 resultClass,
477 role,
478 _inputQueue->getQueueId());
479
480 _outputQueue->enqueue(request);
481
482 Message* message = _inputQueue->dequeue();
483
484 mike 1.1 CIMReferenceNamesResponseMessage* response
485 = (CIMReferenceNamesResponseMessage*)message;
486
487 _checkError(response);
488
489 return response->objectNames;
490 }
491
492 CIMValue CIMOMHandle::getProperty(
493 const String& nameSpace,
494 const CIMReference& instanceName,
495 const String& propertyName)
496 {
497 Message* request = new CIMGetPropertyRequestMessage(
498 XmlWriter::getNextMessageId(),
499 nameSpace,
500 instanceName,
501 propertyName,
502 _inputQueue->getQueueId());
503
504 _outputQueue->enqueue(request);
505 mike 1.1
506 Message* message = _inputQueue->dequeue();
507
508 CIMGetPropertyResponseMessage* response
509 = (CIMGetPropertyResponseMessage*)message;
510
511 _checkError(response);
512
513 return response->value;
514 }
515
516 void CIMOMHandle::setProperty(
517 const String& nameSpace,
518 const CIMReference& instanceName,
519 const String& propertyName,
520 const CIMValue& newValue)
521 {
522 Message* request = new CIMSetPropertyRequestMessage(
523 XmlWriter::getNextMessageId(),
524 nameSpace,
525 instanceName,
526 mike 1.1 propertyName,
527 newValue,
528 _inputQueue->getQueueId());
529
530 _outputQueue->enqueue(request);
531
532 Message* message = _inputQueue->dequeue();
533
534 CIMSetPropertyResponseMessage* response
535 = (CIMSetPropertyResponseMessage*)message;
536
537 _checkError(response);
538 }
539
540 CIMQualifierDecl CIMOMHandle::getQualifier(
541 const String& nameSpace,
542 const String& qualifierName)
543 {
544 Message* request = new CIMGetQualifierRequestMessage(
545 XmlWriter::getNextMessageId(),
546 nameSpace,
547 mike 1.1 qualifierName,
548 _inputQueue->getQueueId());
549
550 _outputQueue->enqueue(request);
551
552 Message* message = _inputQueue->dequeue();
553
554 CIMGetQualifierResponseMessage* response
555 = (CIMGetQualifierResponseMessage*)message;
556
557 _checkError(response);
558
559 return response->cimQualifierDecl;
560 }
561
562 void CIMOMHandle::setQualifier(
563 const String& nameSpace,
564 const CIMQualifierDecl& qualifierDeclaration)
565 {
566 Message* request = new CIMSetQualifierRequestMessage(
567 XmlWriter::getNextMessageId(),
568 mike 1.1 nameSpace,
569 qualifierDeclaration,
570 _inputQueue->getQueueId());
571
572 _outputQueue->enqueue(request);
573
574 Message* message = _inputQueue->dequeue();
575
576 CIMSetQualifierResponseMessage* response
577 = (CIMSetQualifierResponseMessage*)message;
578
579 _checkError(response);
580 }
581
582 void CIMOMHandle::deleteQualifier(
583 const String& nameSpace,
584 const String& qualifierName)
585 {
586 Message* request = new CIMDeleteQualifierRequestMessage(
587 XmlWriter::getNextMessageId(),
588 nameSpace,
589 mike 1.1 qualifierName,
590 _inputQueue->getQueueId());
591
592 _outputQueue->enqueue(request);
593
594 Message* message = _inputQueue->dequeue();
595
596 CIMDeleteQualifierResponseMessage* response
597 = (CIMDeleteQualifierResponseMessage*)message;
598
599 _checkError(response);
600 }
601
602
603 Array<CIMQualifierDecl> CIMOMHandle::enumerateQualifiers(
604 const String& nameSpace)
605 {
606 Message* request = new CIMEnumerateQualifiersRequestMessage(
607 XmlWriter::getNextMessageId(),
608 nameSpace,
609 _inputQueue->getQueueId());
610 mike 1.1
611 _outputQueue->enqueue(request);
612
613 Message* message = _inputQueue->dequeue();
614
615 CIMEnumerateQualifiersResponseMessage* response
616 = (CIMEnumerateQualifiersResponseMessage*)message;
617
618 _checkError(response);
619
620 return response->qualifierDeclarations;
621 }
622
623 CIMValue CIMOMHandle::invokeMethod(
624 const String& nameSpace,
625 const CIMReference& instanceName,
626 const String& methodName,
627 const Array<CIMValue>& inParameters,
628 Array<CIMValue>& outParameters)
629 {
630 Message* request = new CIMInvokeMethodRequestMessage(
631 mike 1.1 XmlWriter::getNextMessageId(),
632 nameSpace,
633 instanceName,
634 methodName,
635 inParameters,
636 _inputQueue->getQueueId());
637
638 _outputQueue->enqueue(request);
639
640 Message* message = _inputQueue->dequeue();
641
642 CIMInvokeMethodResponseMessage* response
643 = (CIMInvokeMethodResponseMessage*)message;
644
645 _checkError(response);
646
647 outParameters = response->outParameters;
648 return response->value;
649 }
650
651 void CIMOMHandle::_checkError(CIMResponseMessage* response)
652 mike 1.1 {
653 if (!response)
654 {
655 throw CIMException(
656 CIM_ERR_FAILED, __FILE__, __LINE__, "queue underflow");
657 }
658
659 if (response->errorCode != CIM_ERR_SUCCESS)
660 {
661 throw CIMException(response->errorCode, __FILE__, __LINE__,
662 response->errorDescription);
663 }
664 }
665
666 PEGASUS_NAMESPACE_END
|
Return to
CIMOMHandle.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Repository