1 karl 1.26 //%2006////////////////////////////////////////////////////////////////////////
|
2 kumpf 1.1 //
|
3 karl 1.16 // 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 kumpf 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.16 // 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.20 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.26 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 kumpf 1.1 //
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 //
21 // 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: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
33 //
|
34 se.gupta 1.10 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135
|
35 david.dillard 1.18 // David Dillard, VERITAS Software Corp.
36 // (david.dillard@veritas.com)
|
37 jenny.yu 1.19 // Jenny Yu, Hewlett-Packard Company (jenny.yu@hp.com)
|
38 carolann.graves 1.21 // Carol Ann Krug Graves, Hewlett-Packard Company
39 // (carolann_graves@hp.com)
|
40 kumpf 1.1 //
41 //%/////////////////////////////////////////////////////////////////////////////
42
|
43 kumpf 1.9 #include <Pegasus/Common/XmlWriter.h>
44 #include <Pegasus/Common/OperationContextInternal.h>
45
|
46 kumpf 1.1 #include "CIMMessageSerializer.h"
47
48 PEGASUS_NAMESPACE_BEGIN
49
|
50 mike 1.22 void CIMMessageSerializer::serialize(Buffer& out, CIMMessage* cimMessage)
|
51 kumpf 1.1 {
52 if (cimMessage == 0)
53 {
54 // No message to serialize
55 return;
56 }
57
58 // ATTN: Need to serialize the Message class members?
59
60 XmlWriter::append(out, "<PGMESSAGE ID=\"");
61 XmlWriter::append(out, cimMessage->messageId);
62 XmlWriter::append(out, "\" TYPE=\"");
63 XmlWriter::append(out, cimMessage->getType());
64 XmlWriter::append(out, "\">");
65
|
66 kumpf 1.23 #ifndef PEGASUS_DISABLE_PERFINST
67 // Serialize the statistics data
68
69 XmlWriter::appendValueElement(
|
70 kumpf 1.34 out, cimMessage->getServerStartTime());
|
71 kumpf 1.23 XmlWriter::appendValueElement(
|
72 kumpf 1.34 out, cimMessage->getProviderTime());
|
73 kumpf 1.23 #endif
74
|
75 kumpf 1.29 XmlWriter::appendValueElement(out, cimMessage->isComplete());
|
76 kumpf 1.30 XmlWriter::appendValueElement(out, cimMessage->getIndex());
|
77 kumpf 1.29
|
78 kumpf 1.11 _serializeOperationContext(out, cimMessage->operationContext);
|
79 kumpf 1.1
80 CIMRequestMessage* cimReqMessage;
81 cimReqMessage = dynamic_cast<CIMRequestMessage*>(cimMessage);
82
83 CIMResponseMessage* cimRespMessage;
84 cimRespMessage = dynamic_cast<CIMResponseMessage*>(cimMessage);
85
86 if (cimReqMessage)
87 {
88 _serializeCIMRequestMessage(out, cimReqMessage);
89 }
|
90 kumpf 1.27 else
|
91 kumpf 1.1 {
|
92 kumpf 1.27 PEGASUS_ASSERT(cimRespMessage != 0);
|
93 kumpf 1.1 _serializeCIMResponseMessage(out, cimRespMessage);
94 }
95
96 XmlWriter::append(out, "</PGMESSAGE>");
97 }
98
99 //
100 // _serializeCIMRequestMessage
101 //
102 void CIMMessageSerializer::_serializeCIMRequestMessage(
|
103 mike 1.22 Buffer& out,
|
104 kumpf 1.1 CIMRequestMessage* cimMessage)
105 {
106 PEGASUS_ASSERT(cimMessage != 0);
107
108 XmlWriter::append(out, "<PGREQ>");
109
110 _serializeQueueIdStack(out, cimMessage->queueIds);
111
112 CIMOperationRequestMessage* cimOpReqMessage;
113 cimOpReqMessage = dynamic_cast<CIMOperationRequestMessage*>(cimMessage);
114
115 CIMIndicationRequestMessage* cimIndReqMessage;
116 cimIndReqMessage = dynamic_cast<CIMIndicationRequestMessage*>(cimMessage);
117
118 if (cimOpReqMessage)
119 {
120 XmlWriter::append(out, "<PGOPREQ>\n");
121
|
122 kumpf 1.32 _serializeUserInfo(
123 out, cimOpReqMessage->authType, cimOpReqMessage->userName);
|
124 kumpf 1.1 _serializeCIMNamespaceName(out, cimOpReqMessage->nameSpace);
125 _serializeCIMName(out, cimOpReqMessage->className);
126
127 // Encode cimOpReqMessage->providerType as an integer
128 XmlWriter::appendValueElement(out, cimOpReqMessage->providerType);
129
130 switch (cimMessage->getType())
131 {
|
132 kumpf 1.27 // A provider cannot implement these operation types, so the
133 // serialization of these messages is not implemented.
134 //case CIM_GET_CLASS_REQUEST_MESSAGE:
135 //case CIM_DELETE_CLASS_REQUEST_MESSAGE:
136 //case CIM_CREATE_CLASS_REQUEST_MESSAGE:
137 //case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
138 //case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
139 //case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
140 //case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
141 //case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
142 //case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
143 //case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
|
144 kumpf 1.1
145 // Instance operations
146 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
147 _serializeCIMGetInstanceRequestMessage(
148 out, (CIMGetInstanceRequestMessage*)cimMessage);
149 break;
150 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
151 _serializeCIMDeleteInstanceRequestMessage(
152 out, (CIMDeleteInstanceRequestMessage*)cimMessage);
153 break;
154 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
155 _serializeCIMCreateInstanceRequestMessage(
156 out, (CIMCreateInstanceRequestMessage*)cimMessage);
157 break;
158 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
159 _serializeCIMModifyInstanceRequestMessage(
160 out, (CIMModifyInstanceRequestMessage*)cimMessage);
161 break;
162 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
163 _serializeCIMEnumerateInstancesRequestMessage(
164 out, (CIMEnumerateInstancesRequestMessage*)cimMessage);
165 kumpf 1.1 break;
166 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
167 _serializeCIMEnumerateInstanceNamesRequestMessage(
168 out, (CIMEnumerateInstanceNamesRequestMessage*)cimMessage);
169 break;
170 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
171 _serializeCIMExecQueryRequestMessage(
172 out, (CIMExecQueryRequestMessage*)cimMessage);
173 break;
174
175 // Property operations
176 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
177 _serializeCIMGetPropertyRequestMessage(
178 out, (CIMGetPropertyRequestMessage*)cimMessage);
179 break;
180 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
181 _serializeCIMSetPropertyRequestMessage(
182 out, (CIMSetPropertyRequestMessage*)cimMessage);
183 break;
184
185 // Association operations
186 kumpf 1.1 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
187 _serializeCIMAssociatorsRequestMessage(
188 out, (CIMAssociatorsRequestMessage*)cimMessage);
189 break;
190 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
191 _serializeCIMAssociatorNamesRequestMessage(
192 out, (CIMAssociatorNamesRequestMessage*)cimMessage);
193 break;
194 case CIM_REFERENCES_REQUEST_MESSAGE:
195 _serializeCIMReferencesRequestMessage(
196 out, (CIMReferencesRequestMessage*)cimMessage);
197 break;
198 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
199 _serializeCIMReferenceNamesRequestMessage(
200 out, (CIMReferenceNamesRequestMessage*)cimMessage);
201 break;
202
203 // Method operations
204 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
205 _serializeCIMInvokeMethodRequestMessage(
206 out, (CIMInvokeMethodRequestMessage*)cimMessage);
207 kumpf 1.1 break;
208
209 default:
210 PEGASUS_ASSERT(0);
211 }
212
213 XmlWriter::append(out, "</PGOPREQ>");
214 }
215 else if (cimIndReqMessage)
216 {
217 XmlWriter::append(out, "<PGINDREQ>");
218
|
219 kumpf 1.32 _serializeUserInfo(
220 out, cimIndReqMessage->authType, cimIndReqMessage->userName);
221
|
222 kumpf 1.1 switch (cimMessage->getType())
223 {
224 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
225 _serializeCIMCreateSubscriptionRequestMessage(
226 out, (CIMCreateSubscriptionRequestMessage*)cimMessage);
227 break;
228 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
229 _serializeCIMModifySubscriptionRequestMessage(
230 out, (CIMModifySubscriptionRequestMessage*)cimMessage);
231 break;
232 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
233 _serializeCIMDeleteSubscriptionRequestMessage(
234 out, (CIMDeleteSubscriptionRequestMessage*)cimMessage);
235 break;
236 default:
237 PEGASUS_ASSERT(0);
238 }
239
240 XmlWriter::append(out, "</PGINDREQ>");
241 }
242 else // Other message types
243 kumpf 1.1 {
244 XmlWriter::append(out, "<PGOTHERREQ>");
245
246 switch (cimMessage->getType())
247 {
248 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
249 _serializeCIMExportIndicationRequestMessage(
250 out, (CIMExportIndicationRequestMessage*)cimMessage);
251 break;
252 case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
253 _serializeCIMProcessIndicationRequestMessage(
254 out, (CIMProcessIndicationRequestMessage*)cimMessage);
255 break;
|
256 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
|
257 kumpf 1.1 // ATTN: No need to serialize this yet
258 //_serializeCIMNotifyProviderRegistrationRequestMessage(
259 // out, (CIMNotifyProviderRegistrationRequestMessage*)cimMessage);
260 break;
|
261 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
|
262 kumpf 1.1 // ATTN: No need to serialize this yet
263 //_serializeCIMNotifyProviderTerminationRequestMessage(
264 // out, (CIMNotifyProviderTerminationRequestMessage*)cimMessage);
265 break;
|
266 kumpf 1.27 //case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
|
267 kumpf 1.1 // ATTN: No need to serialize this yet
268 //_serializeCIMHandleIndicationRequestMessage(
269 // out, (CIMHandleIndicationRequestMessage*)cimMessage);
270 break;
271 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
272 _serializeCIMDisableModuleRequestMessage(
273 out, (CIMDisableModuleRequestMessage*)cimMessage);
274 break;
275 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
276 _serializeCIMEnableModuleRequestMessage(
277 out, (CIMEnableModuleRequestMessage*)cimMessage);
278 break;
|
279 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
|
280 kumpf 1.1 // ATTN: No need to serialize this yet
281 //_serializeCIMNotifyProviderEnableRequestMessage(
282 // out, (CIMNotifyProviderEnableRequestMessage*)cimMessage);
283 break;
|
284 carolann.graves 1.31 //case CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE:
285 // ATTN: No need to serialize this yet
286 //_serializeCIMNotifyProviderFailRequestMessage(
287 // out, (CIMNotifyProviderFailRequestMessage*)cimMessage);
288 //break;
|
289 kumpf 1.1 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
290 _serializeCIMStopAllProvidersRequestMessage(
291 out, (CIMStopAllProvidersRequestMessage*)cimMessage);
292 break;
|
293 kumpf 1.2 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
294 _serializeCIMInitializeProviderRequestMessage(
295 out, (CIMInitializeProviderRequestMessage*)cimMessage);
296 break;
|
297 kumpf 1.7 case CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE:
298 _serializeCIMInitializeProviderAgentRequestMessage(
299 out, (CIMInitializeProviderAgentRequestMessage*)cimMessage);
300 break;
|
301 kumpf 1.2
|
302 kumpf 1.8 case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:
303 _serializeCIMNotifyConfigChangeRequestMessage(
304 out, (CIMNotifyConfigChangeRequestMessage*)cimMessage);
305 break;
306
|
307 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
308 _serializeCIMSubscriptionInitCompleteRequestMessage(
309 out,
310 (CIMSubscriptionInitCompleteRequestMessage *)
311 cimMessage);
312 break;
313
|
314 kumpf 1.1 default:
315 PEGASUS_ASSERT(0);
316 }
317
318 XmlWriter::append(out, "</PGOTHERREQ>");
319 }
320
321 XmlWriter::append(out, "</PGREQ>");
322 }
323
324 //
325 // _serializeCIMResponseMessage
326 //
327 void CIMMessageSerializer::_serializeCIMResponseMessage(
|
328 mike 1.22 Buffer& out,
|
329 kumpf 1.1 CIMResponseMessage* cimMessage)
330 {
331 PEGASUS_ASSERT(cimMessage != 0);
332
333 XmlWriter::append(out, "<PGRESP>\n");
334
335 _serializeQueueIdStack(out, cimMessage->queueIds);
336 _serializeCIMException(out, cimMessage->cimException);
337
338 switch (cimMessage->getType())
339 {
340 //
341 // CIM Operation Response Messages
342 //
343
|
344 kumpf 1.27 // A provider cannot implement these operation types, so the
345 // serialization of these messages is not implemented.
346 //case CIM_GET_CLASS_RESPONSE_MESSAGE:
347 //case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
348 //case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
349 //case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
350 //case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
351 //case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
352 //case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
353 //case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
354 //case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
355 //case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
|
356 kumpf 1.1
357 // Instance operations
358 case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
359 _serializeCIMGetInstanceResponseMessage(
360 out, (CIMGetInstanceResponseMessage*)cimMessage);
361 break;
362 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
363 _serializeCIMDeleteInstanceResponseMessage(
364 out, (CIMDeleteInstanceResponseMessage*)cimMessage);
365 break;
366 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
367 _serializeCIMCreateInstanceResponseMessage(
368 out, (CIMCreateInstanceResponseMessage*)cimMessage);
369 break;
370 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
371 _serializeCIMModifyInstanceResponseMessage(
372 out, (CIMModifyInstanceResponseMessage*)cimMessage);
373 break;
374 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
375 _serializeCIMEnumerateInstancesResponseMessage(
376 out, (CIMEnumerateInstancesResponseMessage*)cimMessage);
377 kumpf 1.1 break;
378 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
379 _serializeCIMEnumerateInstanceNamesResponseMessage(
380 out, (CIMEnumerateInstanceNamesResponseMessage*)cimMessage);
381 break;
382 case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
383 _serializeCIMExecQueryResponseMessage(
384 out, (CIMExecQueryResponseMessage*)cimMessage);
385 break;
386
387 // Property operations
388 case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
389 _serializeCIMGetPropertyResponseMessage(
390 out, (CIMGetPropertyResponseMessage*)cimMessage);
391 break;
392 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
393 _serializeCIMSetPropertyResponseMessage(
394 out, (CIMSetPropertyResponseMessage*)cimMessage);
395 break;
396
397 // Association operations
398 kumpf 1.1 case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
399 _serializeCIMAssociatorsResponseMessage(
400 out, (CIMAssociatorsResponseMessage*)cimMessage);
401 break;
402 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
403 _serializeCIMAssociatorNamesResponseMessage(
404 out, (CIMAssociatorNamesResponseMessage*)cimMessage);
405 break;
406 case CIM_REFERENCES_RESPONSE_MESSAGE:
407 _serializeCIMReferencesResponseMessage(
408 out, (CIMReferencesResponseMessage*)cimMessage);
409 break;
410 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
411 _serializeCIMReferenceNamesResponseMessage(
412 out, (CIMReferenceNamesResponseMessage*)cimMessage);
413 break;
414
415 // Method operations
416 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
417 _serializeCIMInvokeMethodResponseMessage(
418 out, (CIMInvokeMethodResponseMessage*)cimMessage);
419 kumpf 1.1 break;
420
421 //
422 // CIM Indication Response Messages
423 //
424
425 case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE:
426 _serializeCIMCreateSubscriptionResponseMessage(
427 out, (CIMCreateSubscriptionResponseMessage*)cimMessage);
428 break;
429 case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE:
430 _serializeCIMModifySubscriptionResponseMessage(
431 out, (CIMModifySubscriptionResponseMessage*)cimMessage);
432 break;
433 case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE:
434 _serializeCIMDeleteSubscriptionResponseMessage(
435 out, (CIMDeleteSubscriptionResponseMessage*)cimMessage);
436 break;
437
438 //
439 // Other CIM Response Messages
440 kumpf 1.1 //
441
442 case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE:
443 _serializeCIMExportIndicationResponseMessage(
444 out, (CIMExportIndicationResponseMessage*)cimMessage);
445 break;
446 case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE:
447 _serializeCIMProcessIndicationResponseMessage(
448 out, (CIMProcessIndicationResponseMessage*)cimMessage);
449 break;
|
450 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE:
|
451 kumpf 1.1 // ATTN: No need to serialize this yet
452 //_serializeCIMNotifyProviderRegistrationResponseMessage(
453 // out, (CIMNotifyProviderRegistrationResponseMessage*)cimMessage);
454 break;
|
455 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE:
|
456 kumpf 1.1 // ATTN: No need to serialize this yet
457 //_serializeCIMNotifyProviderTerminationResponseMessage(
458 // out, (CIMNotifyProviderTerminationResponseMessage*)cimMessage);
459 break;
|
460 kumpf 1.27 //case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE:
|
461 kumpf 1.1 // ATTN: No need to serialize this yet
462 //_serializeCIMHandleIndicationResponseMessage(
463 // out, (CIMHandleIndicationResponseMessage*)cimMessage);
464 break;
465 case CIM_DISABLE_MODULE_RESPONSE_MESSAGE:
466 _serializeCIMDisableModuleResponseMessage(
467 out, (CIMDisableModuleResponseMessage*)cimMessage);
468 break;
469 case CIM_ENABLE_MODULE_RESPONSE_MESSAGE:
470 _serializeCIMEnableModuleResponseMessage(
471 out, (CIMEnableModuleResponseMessage*)cimMessage);
472 break;
|
473 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE:
|
474 kumpf 1.1 // ATTN: No need to serialize this yet
475 //_serializeCIMNotifyProviderEnableResponseMessage(
476 // out, (CIMNotifyProviderEnableResponseMessage*)cimMessage);
477 break;
|
478 carolann.graves 1.31 //case CIM_NOTIFY_PROVIDER_FAIL_RESPONSE_MESSAGE:
479 // ATTN: No need to serialize this yet
480 //_serializeCIMNotifyProviderFailResponseMessage(
481 // out, (CIMNotifyProviderFailResponseMessage*)cimMessage);
482 //break;
|
483 kumpf 1.1 case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE:
484 _serializeCIMStopAllProvidersResponseMessage(
485 out, (CIMStopAllProvidersResponseMessage*)cimMessage);
486 break;
|
487 kumpf 1.2 case CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE:
488 _serializeCIMInitializeProviderResponseMessage(
489 out, (CIMInitializeProviderResponseMessage*)cimMessage);
490 break;
|
491 kumpf 1.7 case CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE:
492 _serializeCIMInitializeProviderAgentResponseMessage(
493 out, (CIMInitializeProviderAgentResponseMessage*)cimMessage);
494 break;
|
495 kumpf 1.8 case CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE:
496 _serializeCIMNotifyConfigChangeResponseMessage(
497 out, (CIMNotifyConfigChangeResponseMessage*)cimMessage);
498 break;
|
499 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE:
500 _serializeCIMSubscriptionInitCompleteResponseMessage(
501 out,
502 (CIMSubscriptionInitCompleteResponseMessage *)
503 cimMessage);
504 break;
|
505 kumpf 1.2
|
506 kumpf 1.1 default:
507 PEGASUS_ASSERT(0);
508 }
509
510 XmlWriter::append(out, "</PGRESP>");
511 }
512
513
514 //
515 // Utility Methods
516 //
517
518 //
519 // _serializeUserInfo consolidates encoding of these common message attributes
520 //
521 void CIMMessageSerializer::_serializeUserInfo(
|
522 mike 1.22 Buffer& out,
|
523 kumpf 1.1 const String& authType,
524 const String& userName)
525 {
526 XmlWriter::appendValueElement(out, authType);
527 XmlWriter::appendValueElement(out, userName);
528 }
529
530 //
531 // _serializeQueueIdStack
532 //
533 void CIMMessageSerializer::_serializeQueueIdStack(
|
534 mike 1.22 Buffer& out,
|
535 kumpf 1.1 const QueueIdStack& queueIdStack)
536 {
537 QueueIdStack stackCopy = queueIdStack;
538
539 // Use a PGQIDSTACK element to encapsulate the QueueIdStack encoding
540 XmlWriter::append(out, "<PGQIDSTACK>\n");
541 while (!stackCopy.isEmpty())
542 {
543 Uint32 item = stackCopy.top();
544 stackCopy.pop();
545 XmlWriter::appendValueElement(out, item);
546 }
547 XmlWriter::append(out, "</PGQIDSTACK>\n");
548 }
549
550 //
551 // _serializeOperationContext
552 //
553 void CIMMessageSerializer::_serializeOperationContext(
|
554 mike 1.22 Buffer& out,
|
555 kumpf 1.1 const OperationContext& operationContext)
556 {
|
557 kumpf 1.13 // Use a PGOP element to encapsulate the OperationContext encoding
|
558 kumpf 1.1 XmlWriter::append(out, "<PGOC>\n");
559
560 // Note: OperationContext class does not allow iteration through Containers
561
|
562 a.dunfey 1.33 if(operationContext.contains(IdentityContainer::NAME))
|
563 kumpf 1.1 {
564 const IdentityContainer container =
565 operationContext.get(IdentityContainer::NAME);
566
567 XmlWriter::append(out, "<PGOCID>\n");
568 XmlWriter::appendValueElement(out, container.getUserName());
569 XmlWriter::append(out, "</PGOCID>\n");
570 }
571
|
572 a.dunfey 1.33 if(operationContext.contains(SubscriptionInstanceContainer::NAME))
|
573 kumpf 1.1 {
574 const SubscriptionInstanceContainer container =
575 operationContext.get(SubscriptionInstanceContainer::NAME);
576
577 XmlWriter::append(out, "<PGOCSI>\n");
578 _serializeCIMInstance(out, container.getInstance());
579 XmlWriter::append(out, "</PGOCSI>\n");
580 }
581
|
582 a.dunfey 1.33 if(operationContext.contains(SubscriptionFilterConditionContainer::NAME))
|
583 kumpf 1.1 {
584 const SubscriptionFilterConditionContainer container =
585 operationContext.get(SubscriptionFilterConditionContainer::NAME);
586
587 XmlWriter::append(out, "<PGOCSFC>\n");
588 XmlWriter::appendValueElement(out, container.getFilterCondition());
589 XmlWriter::appendValueElement(out, container.getQueryLanguage());
590 XmlWriter::append(out, "</PGOCSFC>\n");
591 }
592
|
593 a.dunfey 1.33 if(operationContext.contains(SubscriptionFilterQueryContainer::NAME))
|
594 kumpf 1.1 {
|
595 chuck 1.17 const SubscriptionFilterQueryContainer container =
596 operationContext.get(SubscriptionFilterQueryContainer::NAME);
597
598 XmlWriter::append(out, "<PGOCSFQ>\n");
599 XmlWriter::appendValueElement(out, container.getFilterQuery());
600 XmlWriter::appendValueElement(out, container.getQueryLanguage());
601 _serializeCIMNamespaceName(out, container.getSourceNameSpace());
602 XmlWriter::append(out, "</PGOCSFQ>\n");
603 }
604
|
605 a.dunfey 1.33 if(operationContext.contains(SubscriptionInstanceNamesContainer::NAME))
|
606 chuck 1.17 {
|
607 kumpf 1.1 const SubscriptionInstanceNamesContainer container =
608 operationContext.get(SubscriptionInstanceNamesContainer::NAME);
609
610 XmlWriter::append(out, "<PGOCSIN>\n");
611
612 Array<CIMObjectPath> cimObjectPaths = container.getInstanceNames();
613 for (Uint32 i=0; i < cimObjectPaths.size(); i++)
614 {
615 _serializeCIMObjectPath(out, cimObjectPaths[i]);
616 }
617
618 XmlWriter::append(out, "</PGOCSIN>\n");
619 }
620
|
621 a.dunfey 1.33 if(operationContext.contains(TimeoutContainer::NAME))
|
622 kumpf 1.1 {
623 const TimeoutContainer container =
624 operationContext.get(TimeoutContainer::NAME);
625
626 XmlWriter::append(out, "<PGOCTO>\n");
627 XmlWriter::appendValueElement(out, container.getTimeOut());
628 XmlWriter::append(out, "</PGOCTO>\n");
629 }
630
|
631 a.dunfey 1.33 if(operationContext.contains(AcceptLanguageListContainer::NAME))
|
632 kumpf 1.1 {
633 const AcceptLanguageListContainer container =
634 operationContext.get(AcceptLanguageListContainer::NAME);
635
636 XmlWriter::append(out, "<PGOCALL>\n");
|
637 kumpf 1.25 _serializeAcceptLanguageList(out, container.getLanguages());
|
638 kumpf 1.1 XmlWriter::append(out, "</PGOCALL>\n");
639 }
640
|
641 a.dunfey 1.33 if(operationContext.contains(ContentLanguageListContainer::NAME))
|
642 kumpf 1.1 {
643 const ContentLanguageListContainer container =
644 operationContext.get(ContentLanguageListContainer::NAME);
645
646 XmlWriter::append(out, "<PGOCCLL>\n");
|
647 kumpf 1.25 _serializeContentLanguageList(out, container.getLanguages());
|
648 kumpf 1.1 XmlWriter::append(out, "</PGOCCLL>\n");
649 }
650
|
651 a.dunfey 1.33 if(operationContext.contains(SnmpTrapOidContainer::NAME))
|
652 kumpf 1.1 {
653 const SnmpTrapOidContainer container =
654 operationContext.get(SnmpTrapOidContainer::NAME);
655
656 XmlWriter::append(out, "<PGOCSTO>\n");
657 XmlWriter::appendValueElement(out, container.getSnmpTrapOid());
658 XmlWriter::append(out, "</PGOCSTO>\n");
659 }
660
|
661 a.dunfey 1.33 if(operationContext.contains(LocaleContainer::NAME))
|
662 kumpf 1.1 {
663 const LocaleContainer container =
664 operationContext.get(LocaleContainer::NAME);
665
666 XmlWriter::append(out, "<PGOCL>\n");
667 XmlWriter::appendValueElement(out, container.getLanguageId());
668 XmlWriter::append(out, "</PGOCL>\n");
669 }
670
|
671 a.dunfey 1.33 if(operationContext.contains(ProviderIdContainer::NAME))
|
672 kumpf 1.1 {
673 const ProviderIdContainer container =
674 operationContext.get(ProviderIdContainer::NAME);
675
676 XmlWriter::append(out, "<PGOCPI>\n");
677 _serializeCIMInstance(out, container.getModule());
678 _serializeCIMInstance(out, container.getProvider());
|
679 kumpf 1.11 XmlWriter::appendValueElement(out, container.isRemoteNameSpace());
680 XmlWriter::appendValueElement(out, container.getRemoteInfo());
|
681 kumpf 1.1 XmlWriter::append(out, "</PGOCPI>\n");
682 }
683
684 XmlWriter::append(out, "</PGOC>\n");
685 }
686
687 //
|
688 kumpf 1.25 // _serializeContentLanguageList
|
689 kumpf 1.1 //
|
690 kumpf 1.25 void CIMMessageSerializer::_serializeContentLanguageList(
|
691 mike 1.22 Buffer& out,
|
692 kumpf 1.25 const ContentLanguageList& contentLanguages)
|
693 kumpf 1.1 {
|
694 kumpf 1.25 // Use a PGCONTLANGS element to encapsulate the ContentLanguageList
695 // encoding
|
696 kumpf 1.1 XmlWriter::append(out, "<PGCONTLANGS>\n");
|
697 kumpf 1.24 for (Uint32 i=0; i < contentLanguages.size(); i++)
|
698 kumpf 1.1 {
|
699 kumpf 1.24 XmlWriter::appendValueElement(
700 out, contentLanguages.getLanguageTag(i).toString());
|
701 kumpf 1.1 }
702 XmlWriter::append(out, "</PGCONTLANGS>\n");
703 }
704
705 //
|
706 kumpf 1.25 // _serializeAcceptLanguageList
|
707 kumpf 1.1 //
|
708 kumpf 1.25 void CIMMessageSerializer::_serializeAcceptLanguageList(
|
709 mike 1.22 Buffer& out,
|
710 kumpf 1.25 const AcceptLanguageList& acceptLanguages)
|
711 kumpf 1.1 {
|
712 kumpf 1.25 // Use a PGACCLANGS element to encapsulate the AcceptLanguageList encoding
|
713 kumpf 1.1 XmlWriter::append(out, "<PGACCLANGS>\n");
|
714 kumpf 1.24 for (Uint32 i=0; i < acceptLanguages.size(); i++)
|
715 kumpf 1.1 {
|
716 kumpf 1.24 XmlWriter::appendValueElement(
717 out, acceptLanguages.getLanguageTag(i).toString());
718 XmlWriter::appendValueElement(out, acceptLanguages.getQualityValue(i));
|
719 kumpf 1.1 }
720 XmlWriter::append(out, "</PGACCLANGS>\n");
721 }
722
723 //
724 // _serializeCIMException
725 //
726 void CIMMessageSerializer::_serializeCIMException(
|
727 mike 1.22 Buffer& out,
|
728 kumpf 1.1 const CIMException& cimException)
729 {
|
730 kumpf 1.9 TraceableCIMException e(cimException);
|
731 kumpf 1.1
732 // Use a PGCIMEXC element to encapsulate the CIMException encoding
|
733 kumpf 1.9 // (Note: This is not truly necessary and could be removed.)
|
734 kumpf 1.1 XmlWriter::append(out, "<PGCIMEXC>\n");
|
735 kumpf 1.9
736 XmlWriter::appendValueElement(out, Uint32(e.getCode()));
737 XmlWriter::appendValueElement(out, e.getMessage());
738 XmlWriter::appendValueElement(out, e.getCIMMessage());
739 XmlWriter::appendValueElement(out, e.getFile());
740 XmlWriter::appendValueElement(out, e.getLine());
|
741 kumpf 1.25 _serializeContentLanguageList(out, e.getContentLanguages());
|
742 kumpf 1.9
|
743 kumpf 1.1 XmlWriter::append(out, "</PGCIMEXC>\n");
744 }
745
746 //
|
747 jenny.yu 1.19 // _serializeCIMPropertyList
|
748 kumpf 1.1 //
749 void CIMMessageSerializer::_serializeCIMPropertyList(
|
750 mike 1.22 Buffer& out,
|
751 kumpf 1.1 const CIMPropertyList& cimPropertyList)
752 {
753 // Need IPARAMVALUE wrapper because the value can be null.
754 XmlWriter::appendPropertyListIParameter(out, cimPropertyList);
755 }
756
757 //
758 // _serializeCIMObjectPath
759 //
760 void CIMMessageSerializer::_serializeCIMObjectPath(
|
761 mike 1.22 Buffer& out,
|
762 kumpf 1.1 const CIMObjectPath& cimObjectPath)
763 {
764 // Use a PGPATH element to encapsulate the CIMObjectPath encoding
765 // to account for uninitialized objects
766 XmlWriter::append(out, "<PGPATH>\n");
767 if (!cimObjectPath.getClassName().isNull())
768 {
769 XmlWriter::appendValueReferenceElement(out, cimObjectPath, true);
770 }
771 XmlWriter::append(out, "</PGPATH>\n");
772 }
773
774 //
775 // _serializeCIMInstance
776 //
777 void CIMMessageSerializer::_serializeCIMInstance(
|
778 mike 1.22 Buffer& out,
|
779 kumpf 1.1 const CIMInstance& cimInstance)
780 {
781 // Use a PGINST element to encapsulate the CIMInstance encoding
782 // to account for uninitialized objects
783 XmlWriter::append(out, "<PGINST>\n");
784 if (!cimInstance.isUninitialized())
785 {
|
786 jenny.yu 1.19 XmlWriter::appendInstanceElement(out, cimInstance);
787 _serializeCIMObjectPath(out, cimInstance.getPath());
|
788 kumpf 1.1 }
789 XmlWriter::append(out, "</PGINST>\n");
790 }
791
792 //
793 // _serializeCIMNamespaceName
794 //
795 void CIMMessageSerializer::_serializeCIMNamespaceName(
|
796 mike 1.22 Buffer& out,
|
797 kumpf 1.1 const CIMNamespaceName& cimNamespaceName)
798 {
799 // Encode CIMNamespaceName as a String for efficiency and so that null
800 // values can be handled
801 XmlWriter::appendValueElement(out, cimNamespaceName.getString());
802 }
803
804 //
805 // _serializeCIMName
806 //
807 void CIMMessageSerializer::_serializeCIMName(
|
808 mike 1.22 Buffer& out,
|
809 kumpf 1.1 const CIMName& cimName)
810 {
811 // Encode CIMName as a String so that null values can be handled
812 XmlWriter::appendValueElement(out, cimName.getString());
813 }
814
|
815 jenny.yu 1.19 //
816 // _serializeCIMObject
817 //
818 void CIMMessageSerializer::_serializeCIMObject(
|
819 mike 1.22 Buffer& out,
|
820 jenny.yu 1.19 const CIMObject& object)
821 {
822 // Use a PGOBJ element to encapsulate the CIMObject encoding
823 // to account for uninitialized objects
824 XmlWriter::append(out, "<PGOBJ>\n");
825 if (!object.isUninitialized())
826 {
827 XmlWriter::appendObjectElement(out, object);
828 _serializeCIMObjectPath(out, object.getPath());
829 }
830 XmlWriter::append(out, "</PGOBJ>\n");
831 }
|
832 kumpf 1.1
833 //
834 //
835 // Request Messages
836 //
837 //
838
839 //
840 //
841 // CIMOperationRequestMessages
842 //
843 //
844
845 //
846 // _serializeCIMGetInstanceRequestMessage
847 //
848 void CIMMessageSerializer::_serializeCIMGetInstanceRequestMessage(
|
849 mike 1.22 Buffer& out,
|
850 kumpf 1.1 CIMGetInstanceRequestMessage* message)
851 {
852 _serializeCIMObjectPath(out, message->instanceName);
853 XmlWriter::appendValueElement(out, message->localOnly);
854 XmlWriter::appendValueElement(out, message->includeQualifiers);
855 XmlWriter::appendValueElement(out, message->includeClassOrigin);
856 _serializeCIMPropertyList(out, message->propertyList);
857 }
858
859 //
860 // _serializeCIMDeleteInstanceRequestMessage
861 //
862 void CIMMessageSerializer::_serializeCIMDeleteInstanceRequestMessage(
|
863 mike 1.22 Buffer& out,
|
864 kumpf 1.1 CIMDeleteInstanceRequestMessage* message)
865 {
866 _serializeCIMObjectPath(out, message->instanceName);
867 }
868
869 //
870 // _serializeCIMCreateInstanceRequestMessage
871 //
872 void CIMMessageSerializer::_serializeCIMCreateInstanceRequestMessage(
|
873 mike 1.22 Buffer& out,
|
874 kumpf 1.1 CIMCreateInstanceRequestMessage* message)
875 {
876 _serializeCIMInstance(out, message->newInstance);
877 }
878
879 //
880 // _serializeCIMModifyInstanceRequestMessage
881 //
882 void CIMMessageSerializer::_serializeCIMModifyInstanceRequestMessage(
|
883 mike 1.22 Buffer& out,
|
884 kumpf 1.1 CIMModifyInstanceRequestMessage* message)
885 {
886 _serializeCIMInstance(out, message->modifiedInstance);
887 XmlWriter::appendValueElement(out, message->includeQualifiers);
888 _serializeCIMPropertyList(out, message->propertyList);
889 }
890
891 //
892 // _serializeCIMEnumerateInstancesRequestMessage
893 //
894 void CIMMessageSerializer::_serializeCIMEnumerateInstancesRequestMessage(
|
895 mike 1.22 Buffer& out,
|
896 kumpf 1.1 CIMEnumerateInstancesRequestMessage* message)
897 {
898 XmlWriter::appendValueElement(out, message->deepInheritance);
899 XmlWriter::appendValueElement(out, message->localOnly);
900 XmlWriter::appendValueElement(out, message->includeQualifiers);
901 XmlWriter::appendValueElement(out, message->includeClassOrigin);
902 _serializeCIMPropertyList(out, message->propertyList);
903 }
904
905 //
906 // _serializeCIMEnumerateInstanceNamesRequestMessage
907 //
908 void CIMMessageSerializer::_serializeCIMEnumerateInstanceNamesRequestMessage(
|
909 mike 1.22 Buffer& out,
|
910 kumpf 1.1 CIMEnumerateInstanceNamesRequestMessage* message)
911 {
912 // No additional attributes to serialize!
913 }
914
915 //
916 // _serializeCIMExecQueryRequestMessage
917 //
918 void CIMMessageSerializer::_serializeCIMExecQueryRequestMessage(
|
919 mike 1.22 Buffer& out,
|
920 kumpf 1.1 CIMExecQueryRequestMessage* message)
921 {
922 XmlWriter::appendValueElement(out, message->queryLanguage);
923 XmlWriter::appendValueElement(out, message->query);
924 }
925
926 //
927 // _serializeCIMAssociatorsRequestMessage
928 //
929 void CIMMessageSerializer::_serializeCIMAssociatorsRequestMessage(
|
930 mike 1.22 Buffer& out,
|
931 kumpf 1.1 CIMAssociatorsRequestMessage* message)
932 {
933 _serializeCIMObjectPath(out, message->objectName);
934 _serializeCIMName(out, message->assocClass);
935 _serializeCIMName(out, message->resultClass);
936 XmlWriter::appendValueElement(out, message->role);
937 XmlWriter::appendValueElement(out, message->resultRole);
938 XmlWriter::appendValueElement(out, message->includeQualifiers);
939 XmlWriter::appendValueElement(out, message->includeClassOrigin);
940 _serializeCIMPropertyList(out, message->propertyList);
941 }
942
943 //
944 // _serializeCIMAssociatorNamesRequestMessage
945 //
946 void CIMMessageSerializer::_serializeCIMAssociatorNamesRequestMessage(
|
947 mike 1.22 Buffer& out,
|
948 kumpf 1.1 CIMAssociatorNamesRequestMessage* message)
949 {
950 _serializeCIMObjectPath(out, message->objectName);
951 _serializeCIMName(out, message->assocClass);
952 _serializeCIMName(out, message->resultClass);
953 XmlWriter::appendValueElement(out, message->role);
954 XmlWriter::appendValueElement(out, message->resultRole);
955 }
956
957 //
958 // _serializeCIMReferencesRequestMessage
959 //
960 void CIMMessageSerializer::_serializeCIMReferencesRequestMessage(
|
961 mike 1.22 Buffer& out,
|
962 kumpf 1.1 CIMReferencesRequestMessage* message)
963 {
964 _serializeCIMObjectPath(out, message->objectName);
965 _serializeCIMName(out, message->resultClass);
966 XmlWriter::appendValueElement(out, message->role);
967 XmlWriter::appendValueElement(out, message->includeQualifiers);
968 XmlWriter::appendValueElement(out, message->includeClassOrigin);
969 _serializeCIMPropertyList(out, message->propertyList);
970 }
971
972 //
973 // _serializeCIMReferenceNamesRequestMessage
974 //
975 void CIMMessageSerializer::_serializeCIMReferenceNamesRequestMessage(
|
976 mike 1.22 Buffer& out,
|
977 kumpf 1.1 CIMReferenceNamesRequestMessage* message)
978 {
979 _serializeCIMObjectPath(out, message->objectName);
980 _serializeCIMName(out, message->resultClass);
981 XmlWriter::appendValueElement(out, message->role);
982 }
983
984 //
985 // _serializeCIMGetPropertyRequestMessage
986 //
987 void CIMMessageSerializer::_serializeCIMGetPropertyRequestMessage(
|
988 mike 1.22 Buffer& out,
|
989 kumpf 1.1 CIMGetPropertyRequestMessage* message)
990 {
991 _serializeCIMObjectPath(out, message->instanceName);
992 _serializeCIMName(out, message->propertyName);
993 }
994
995 //
996 // _serializeCIMSetPropertyRequestMessage
997 //
998 void CIMMessageSerializer::_serializeCIMSetPropertyRequestMessage(
|
999 mike 1.22 Buffer& out,
|
1000 kumpf 1.1 CIMSetPropertyRequestMessage* message)
1001 {
1002 _serializeCIMObjectPath(out, message->instanceName);
1003
1004 // Use PARAMVALUE element so we can preserve the CIMType information
1005 XmlWriter::appendParamValueElement(
1006 out,
1007 CIMParamValue(
1008 message->propertyName.getString(), message->newValue, true));
1009 }
1010
1011 //
1012 // _serializeCIMInvokeMethodRequestMessage
1013 //
1014 void CIMMessageSerializer::_serializeCIMInvokeMethodRequestMessage(
|
1015 mike 1.22 Buffer& out,
|
1016 kumpf 1.1 CIMInvokeMethodRequestMessage* message)
1017 {
1018 _serializeCIMObjectPath(out, message->instanceName);
1019 _serializeCIMName(out, message->methodName);
1020
1021 // Use PGPARAMS element so we can find the end of the PARAMVALUE elements
1022 XmlWriter::append(out, "<PGPARAMS>\n");
1023 for (Uint32 i=0; i < message->inParameters.size(); i++)
1024 {
1025 XmlWriter::appendParamValueElement(out, message->inParameters[i]);
1026 }
1027 XmlWriter::append(out, "</PGPARAMS>\n");
1028 }
1029
1030
1031 //
1032 //
1033 // CIMIndicationRequestMessages
1034 //
1035 //
1036
1037 kumpf 1.1 //
1038 // _serializeCIMCreateSubscriptionRequestMessage
1039 //
1040 void CIMMessageSerializer::_serializeCIMCreateSubscriptionRequestMessage(
|
1041 mike 1.22 Buffer& out,
|
1042 kumpf 1.1 CIMCreateSubscriptionRequestMessage* message)
1043 {
1044 _serializeCIMNamespaceName(out, message->nameSpace);
1045
1046 _serializeCIMInstance(out, message->subscriptionInstance);
1047
1048 // Use PGNAMEARRAY element to encapsulate the CIMName elements
1049 XmlWriter::append(out, "<PGNAMEARRAY>\n");
1050 for (Uint32 i=0; i < message->classNames.size(); i++)
1051 {
1052 _serializeCIMName(out, message->classNames[i]);
1053 }
1054 XmlWriter::append(out, "</PGNAMEARRAY>\n");
1055
1056 _serializeCIMPropertyList(out, message->propertyList);
1057
1058 // Encode message->repeatNotificationPolicy as an integer
1059 XmlWriter::appendValueElement(out, message->repeatNotificationPolicy);
1060
|
1061 kumpf 1.3 XmlWriter::appendValueElement(out, message->query);
|
1062 kumpf 1.13 }
|
1063 kumpf 1.1
1064 //
1065 // _serializeCIMModifySubscriptionRequestMessage
1066 //
1067 void CIMMessageSerializer::_serializeCIMModifySubscriptionRequestMessage(
|
1068 mike 1.22 Buffer& out,
|
1069 kumpf 1.1 CIMModifySubscriptionRequestMessage* message)
1070 {
1071 _serializeCIMNamespaceName(out, message->nameSpace);
1072
1073 _serializeCIMInstance(out, message->subscriptionInstance);
1074
1075 // Use PGNAMEARRAY element to encapsulate the CIMName elements
1076 XmlWriter::append(out, "<PGNAMEARRAY>\n");
1077 for (Uint32 i=0; i < message->classNames.size(); i++)
1078 {
1079 _serializeCIMName(out, message->classNames[i]);
1080 }
1081 XmlWriter::append(out, "</PGNAMEARRAY>\n");
1082
1083 _serializeCIMPropertyList(out, message->propertyList);
1084
1085 // Encode message->repeatNotificationPolicy as an integer
1086 XmlWriter::appendValueElement(out, message->repeatNotificationPolicy);
1087
|
1088 kumpf 1.3 XmlWriter::appendValueElement(out, message->query);
|
1089 kumpf 1.1 }
1090
1091 //
1092 // _serializeCIMDeleteSubscriptionRequestMessage
1093 //
1094 void CIMMessageSerializer::_serializeCIMDeleteSubscriptionRequestMessage(
|
1095 mike 1.22 Buffer& out,
|
1096 kumpf 1.1 CIMDeleteSubscriptionRequestMessage* message)
1097 {
1098 _serializeCIMNamespaceName(out, message->nameSpace);
1099
1100 _serializeCIMInstance(out, message->subscriptionInstance);
1101
1102 // Use PGNAMEARRAY element to encapsulate the CIMName elements
1103 XmlWriter::append(out, "<PGNAMEARRAY>\n");
1104 for (Uint32 i=0; i < message->classNames.size(); i++)
1105 {
1106 _serializeCIMName(out, message->classNames[i]);
1107 }
1108 XmlWriter::append(out, "</PGNAMEARRAY>\n");
1109 }
1110
1111
1112 //
1113 //
1114 // Other CIMRequestMessages
1115 //
1116 //
1117 kumpf 1.1
1118 //
1119 // _serializeCIMExportIndicationRequestMessage
1120 //
1121 void CIMMessageSerializer::_serializeCIMExportIndicationRequestMessage(
|
1122 mike 1.22 Buffer& out,
|
1123 kumpf 1.1 CIMExportIndicationRequestMessage* message)
1124 {
1125 _serializeUserInfo(out, message->authType, message->userName);
1126
1127 XmlWriter::appendValueElement(out, message->destinationPath);
1128 _serializeCIMInstance(out, message->indicationInstance);
1129 }
1130
1131 //
1132 // _serializeCIMProcessIndicationRequestMessage
1133 //
1134 void CIMMessageSerializer::_serializeCIMProcessIndicationRequestMessage(
|
1135 mike 1.22 Buffer& out,
|
1136 kumpf 1.1 CIMProcessIndicationRequestMessage* message)
1137 {
1138 _serializeCIMNamespaceName(out, message->nameSpace);
1139
1140 _serializeCIMInstance(out, message->indicationInstance);
1141
1142 // Use PGPATHARRAY element to encapsulate the object path elements
1143 XmlWriter::append(out, "<PGPATHARRAY>\n");
1144 for (Uint32 i=0; i < message->subscriptionInstanceNames.size(); i++)
1145 {
1146 _serializeCIMObjectPath(out, message->subscriptionInstanceNames[i]);
1147 }
1148 XmlWriter::append(out, "</PGPATHARRAY>\n");
1149
1150 _serializeCIMInstance(out, message->provider);
1151 }
1152
1153 //
1154 // _serializeCIMDisableModuleRequestMessage
1155 //
1156 void CIMMessageSerializer::_serializeCIMDisableModuleRequestMessage(
|
1157 mike 1.22 Buffer& out,
|
1158 kumpf 1.1 CIMDisableModuleRequestMessage* message)
1159 {
1160 _serializeUserInfo(out, message->authType, message->userName);
1161
1162 _serializeCIMInstance(out, message->providerModule);
1163
1164 // Use PGINSTARRAY element to encapsulate the CIMInstance elements
1165 XmlWriter::append(out, "<PGINSTARRAY>\n");
1166 for (Uint32 i=0; i < message->providers.size(); i++)
1167 {
1168 _serializeCIMInstance(out, message->providers[i]);
1169 }
1170 XmlWriter::append(out, "</PGINSTARRAY>\n");
1171
1172 XmlWriter::appendValueElement(out, message->disableProviderOnly);
1173
1174 // Use PGBOOLARRAY element to encapsulate the Boolean elements
1175 XmlWriter::append(out, "<PGBOOLARRAY>\n");
1176 for (Uint32 i=0; i < message->indicationProviders.size(); i++)
1177 {
1178 XmlWriter::appendValueElement(out, message->indicationProviders[i]);
1179 kumpf 1.1 }
1180 XmlWriter::append(out, "</PGBOOLARRAY>\n");
1181 }
1182
1183 //
1184 // _serializeCIMEnableModuleRequestMessage
1185 //
1186 void CIMMessageSerializer::_serializeCIMEnableModuleRequestMessage(
|
1187 mike 1.22 Buffer& out,
|
1188 kumpf 1.1 CIMEnableModuleRequestMessage* message)
1189 {
1190 _serializeUserInfo(out, message->authType, message->userName);
1191
1192 _serializeCIMInstance(out, message->providerModule);
1193 }
1194
1195 //
1196 // _serializeCIMStopAllProvidersRequestMessage
1197 //
1198 void CIMMessageSerializer::_serializeCIMStopAllProvidersRequestMessage(
|
1199 mike 1.22 Buffer& out,
|
1200 kumpf 1.1 CIMStopAllProvidersRequestMessage* message)
1201 {
1202 // No additional attributes to serialize!
1203 }
1204
|
1205 kumpf 1.2 //
1206 // _serializeCIMInitializeProviderRequestMessage
1207 //
1208 void CIMMessageSerializer::_serializeCIMInitializeProviderRequestMessage(
|
1209 mike 1.22 Buffer& out,
|
1210 kumpf 1.2 CIMInitializeProviderRequestMessage* message)
1211 {
|
1212 kumpf 1.4 // No additional attributes to serialize!
|
1213 kumpf 1.2 }
1214
|
1215 kumpf 1.7 //
1216 // _serializeCIMInitializeProviderAgentRequestMessage
1217 //
1218 void CIMMessageSerializer::_serializeCIMInitializeProviderAgentRequestMessage(
|
1219 mike 1.22 Buffer& out,
|
1220 kumpf 1.7 CIMInitializeProviderAgentRequestMessage* message)
1221 {
1222 XmlWriter::appendValueElement(out, message->pegasusHome);
1223
1224 // Use PGCONFARRAY element to encapsulate the config property elements
1225 XmlWriter::append(out, "<PGCONFARRAY>\n");
1226 for (Uint32 i=0; i < message->configProperties.size(); i++)
1227 {
1228 XmlWriter::appendValueElement(out, message->configProperties[i].first);
1229 XmlWriter::appendValueElement(out, message->configProperties[i].second);
1230 }
1231 XmlWriter::append(out, "</PGCONFARRAY>\n");
1232
1233 XmlWriter::appendValueElement(out, message->bindVerbose);
|
1234 carolann.graves 1.21
1235 XmlWriter::appendValueElement(out, message->subscriptionInitComplete);
|
1236 kumpf 1.7 }
1237
|
1238 kumpf 1.8 //
1239 // _serializeCIMNotifyConfigChangeRequestMessage
1240 //
1241 void CIMMessageSerializer::_serializeCIMNotifyConfigChangeRequestMessage(
|
1242 mike 1.22 Buffer& out,
|
1243 kumpf 1.8 CIMNotifyConfigChangeRequestMessage* message)
1244 {
1245 XmlWriter::appendValueElement(out, message->propertyName);
1246 XmlWriter::appendValueElement(out, message->newPropertyValue);
1247 XmlWriter::appendValueElement(out, message->currentValueModified);
1248 }
|
1249 kumpf 1.1
1250 //
|
1251 carolann.graves 1.21 // _serializeCIMSubscriptionInitCompleteRequestMessage
1252 //
1253 void
1254 CIMMessageSerializer::_serializeCIMSubscriptionInitCompleteRequestMessage(
|
1255 mike 1.22 Buffer& out,
|
1256 carolann.graves 1.21 CIMSubscriptionInitCompleteRequestMessage* message)
1257 {
1258 // No additional attributes to serialize!
1259 }
1260
1261 //
|
1262 kumpf 1.1 //
1263 // Response Messages
1264 //
1265 //
1266
1267 //
1268 //
1269 // CIM Operation Response Messages
1270 //
1271 //
1272
1273 //
1274 // _serializeCIMGetInstanceResponseMessage
1275 //
1276 void CIMMessageSerializer::_serializeCIMGetInstanceResponseMessage(
|
1277 mike 1.22 Buffer& out,
|
1278 kumpf 1.1 CIMGetInstanceResponseMessage* message)
1279 {
1280 _serializeCIMInstance(out, message->cimInstance);
1281 }
1282
1283 //
1284 // _serializeCIMDeleteInstanceResponseMessage
1285 //
1286 void CIMMessageSerializer::_serializeCIMDeleteInstanceResponseMessage(
|
1287 mike 1.22 Buffer& out,
|
1288 kumpf 1.1 CIMDeleteInstanceResponseMessage* message)
1289 {
1290 // No additional attributes to serialize!
1291 }
1292
1293 //
1294 // _serializeCIMCreateInstanceResponseMessage
1295 //
1296 void CIMMessageSerializer::_serializeCIMCreateInstanceResponseMessage(
|
1297 mike 1.22 Buffer& out,
|
1298 kumpf 1.1 CIMCreateInstanceResponseMessage* message)
1299 {
1300 _serializeCIMObjectPath(out, message->instanceName);
1301 }
1302
1303 //
1304 // _serializeCIMModifyInstanceResponseMessage
1305 //
1306 void CIMMessageSerializer::_serializeCIMModifyInstanceResponseMessage(
|
1307 mike 1.22 Buffer& out,
|
1308 kumpf 1.1 CIMModifyInstanceResponseMessage* message)
1309 {
1310 // No additional attributes to serialize!
1311 }
1312
1313 //
1314 // _serializeCIMEnumerateInstancesResponseMessage
1315 //
1316 void CIMMessageSerializer::_serializeCIMEnumerateInstancesResponseMessage(
|
1317 mike 1.22 Buffer& out,
|
1318 kumpf 1.1 CIMEnumerateInstancesResponseMessage* message)
1319 {
1320 // Use PGINSTARRAY element to encapsulate the CIMInstance elements
1321 XmlWriter::append(out, "<PGINSTARRAY>\n");
1322 for (Uint32 i=0; i < message->cimNamedInstances.size(); i++)
1323 {
1324 _serializeCIMInstance(out, message->cimNamedInstances[i]);
1325 }
1326 XmlWriter::append(out, "</PGINSTARRAY>\n");
1327 }
1328
1329 //
1330 // _serializeCIMEnumerateInstanceNamesResponseMessage
1331 //
1332 void CIMMessageSerializer::_serializeCIMEnumerateInstanceNamesResponseMessage(
|
1333 mike 1.22 Buffer& out,
|
1334 kumpf 1.1 CIMEnumerateInstanceNamesResponseMessage* message)
1335 {
1336 // Use PGPATHARRAY element to encapsulate the object path elements
1337 XmlWriter::append(out, "<PGPATHARRAY>\n");
1338 for (Uint32 i=0; i < message->instanceNames.size(); i++)
1339 {
1340 _serializeCIMObjectPath(out, message->instanceNames[i]);
1341 }
1342 XmlWriter::append(out, "</PGPATHARRAY>\n");
1343 }
1344
1345 //
1346 // _serializeCIMExecQueryResponseMessage
1347 //
1348 void CIMMessageSerializer::_serializeCIMExecQueryResponseMessage(
|
1349 mike 1.22 Buffer& out,
|
1350 kumpf 1.1 CIMExecQueryResponseMessage* message)
1351 {
|
1352 jenny.yu 1.19 // Use PGOBJARRAY element to encapsulate the CIMObject elements
|
1353 kumpf 1.1 XmlWriter::append(out, "<PGOBJARRAY>\n");
1354 for (Uint32 i=0; i < message->cimObjects.size(); i++)
1355 {
|
1356 jenny.yu 1.19 _serializeCIMObject(out, message->cimObjects[i]);
|
1357 kumpf 1.1 }
1358 XmlWriter::append(out, "</PGOBJARRAY>\n");
1359 }
1360
1361 //
1362 // _serializeCIMAssociatorsResponseMessage
1363 //
1364 void CIMMessageSerializer::_serializeCIMAssociatorsResponseMessage(
|
1365 mike 1.22 Buffer& out,
|
1366 kumpf 1.1 CIMAssociatorsResponseMessage* message)
1367 {
|
1368 jenny.yu 1.19 // Use PGOBJARRAY element to encapsulate the CIMObject elements
|
1369 kumpf 1.1 XmlWriter::append(out, "<PGOBJARRAY>\n");
1370 for (Uint32 i=0; i < message->cimObjects.size(); i++)
1371 {
|
1372 jenny.yu 1.19 _serializeCIMObject(out, message->cimObjects[i]);
|
1373 kumpf 1.1 }
1374 XmlWriter::append(out, "</PGOBJARRAY>\n");
1375 }
1376
1377 //
1378 // _serializeCIMAssociatorNamesResponseMessage
1379 //
1380 void CIMMessageSerializer::_serializeCIMAssociatorNamesResponseMessage(
|
1381 mike 1.22 Buffer& out,
|
1382 kumpf 1.1 CIMAssociatorNamesResponseMessage* message)
1383 {
1384 // Use PGPATHARRAY element to encapsulate the object path elements
1385 XmlWriter::append(out, "<PGPATHARRAY>\n");
1386 for (Uint32 i=0; i < message->objectNames.size(); i++)
1387 {
1388 _serializeCIMObjectPath(out, message->objectNames[i]);
1389 }
1390 XmlWriter::append(out, "</PGPATHARRAY>\n");
1391 }
1392
1393 //
1394 // _serializeCIMReferencesResponseMessage
1395 //
1396 void CIMMessageSerializer::_serializeCIMReferencesResponseMessage(
|
1397 mike 1.22 Buffer& out,
|
1398 kumpf 1.1 CIMReferencesResponseMessage* message)
1399 {
|
1400 jenny.yu 1.19 // Use PGOBJARRAY element to encapsulate the CIMObject elements
|
1401 kumpf 1.1 XmlWriter::append(out, "<PGOBJARRAY>\n");
1402 for (Uint32 i=0; i < message->cimObjects.size(); i++)
1403 {
|
1404 jenny.yu 1.19 _serializeCIMObject(out, message->cimObjects[i]);
|
1405 kumpf 1.1 }
1406 XmlWriter::append(out, "</PGOBJARRAY>\n");
1407 }
1408
1409 //
1410 // _serializeCIMReferenceNamesResponseMessage
1411 //
1412 void CIMMessageSerializer::_serializeCIMReferenceNamesResponseMessage(
|
1413 mike 1.22 Buffer& out,
|
1414 kumpf 1.1 CIMReferenceNamesResponseMessage* message)
1415 {
1416 // Use PGPATHARRAY element to encapsulate the object path elements
1417 XmlWriter::append(out, "<PGPATHARRAY>\n");
1418 for (Uint32 i=0; i < message->objectNames.size(); i++)
1419 {
1420 _serializeCIMObjectPath(out, message->objectNames[i]);
1421 }
1422 XmlWriter::append(out, "</PGPATHARRAY>\n");
1423 }
1424
1425 //
1426 // _serializeCIMGetPropertyResponseMessage
1427 //
1428 void CIMMessageSerializer::_serializeCIMGetPropertyResponseMessage(
|
1429 mike 1.22 Buffer& out,
|
1430 kumpf 1.1 CIMGetPropertyResponseMessage* message)
1431 {
1432 // Use PARAMVALUE element so we can preserve the CIMType information
1433 XmlWriter::appendParamValueElement(
1434 out,
1435 CIMParamValue(String("ignore"), message->value, true));
1436 }
1437
1438 //
1439 // _serializeCIMSetPropertyResponseMessage
1440 //
1441 void CIMMessageSerializer::_serializeCIMSetPropertyResponseMessage(
|
1442 mike 1.22 Buffer& out,
|
1443 kumpf 1.1 CIMSetPropertyResponseMessage* message)
1444 {
1445 // No additional attributes to serialize!
1446 }
1447
1448 //
1449 // _serializeCIMInvokeMethodResponseMessage
1450 //
1451 void CIMMessageSerializer::_serializeCIMInvokeMethodResponseMessage(
|
1452 mike 1.22 Buffer& out,
|
1453 kumpf 1.1 CIMInvokeMethodResponseMessage* message)
1454 {
1455 // Use PARAMVALUE element so we can preserve the CIMType information
1456 XmlWriter::appendParamValueElement(
1457 out,
1458 CIMParamValue(String("ignore"), message->retValue, true));
1459
1460 // Use PGPARAMS element so we can find the end of the PARAMVALUE elements
1461 XmlWriter::append(out, "<PGPARAMS>\n");
1462 for (Uint32 i=0; i < message->outParameters.size(); i++)
1463 {
1464 XmlWriter::appendParamValueElement(out, message->outParameters[i]);
1465 }
1466 XmlWriter::append(out, "</PGPARAMS>\n");
1467
1468 _serializeCIMName(out, message->methodName);
1469 }
1470
1471
1472 //
1473 //
1474 kumpf 1.1 // CIM Indication Response Messages
1475 //
1476 //
1477
1478 //
1479 // _serializeCIMCreateSubscriptionResponseMessage
1480 //
1481 void CIMMessageSerializer::_serializeCIMCreateSubscriptionResponseMessage(
|
1482 mike 1.22 Buffer& out,
|
1483 kumpf 1.1 CIMCreateSubscriptionResponseMessage* message)
1484 {
1485 // No additional attributes to serialize!
1486 }
1487
1488 //
1489 // _serializeCIMModifySubscriptionResponseMessage
1490 //
1491 void CIMMessageSerializer::_serializeCIMModifySubscriptionResponseMessage(
|
1492 mike 1.22 Buffer& out,
|
1493 kumpf 1.1 CIMModifySubscriptionResponseMessage* message)
1494 {
1495 // No additional attributes to serialize!
1496 }
1497
1498 //
1499 // _serializeCIMDeleteSubscriptionResponseMessage
1500 //
1501 void CIMMessageSerializer::_serializeCIMDeleteSubscriptionResponseMessage(
|
1502 mike 1.22 Buffer& out,
|
1503 kumpf 1.1 CIMDeleteSubscriptionResponseMessage* message)
1504 {
1505 // No additional attributes to serialize!
1506 }
1507
1508
1509 //
1510 //
1511 // Other CIMResponseMessages
1512 //
1513 //
1514
1515 //
1516 // _serializeCIMExportIndicationResponseMessage
1517 //
1518 void CIMMessageSerializer::_serializeCIMExportIndicationResponseMessage(
|
1519 mike 1.22 Buffer& out,
|
1520 kumpf 1.1 CIMExportIndicationResponseMessage* message)
1521 {
1522 // No additional attributes to serialize!
1523 }
1524
1525 //
1526 // _serializeCIMProcessIndicationResponseMessage
1527 //
1528 void CIMMessageSerializer::_serializeCIMProcessIndicationResponseMessage(
|
1529 mike 1.22 Buffer& out,
|
1530 kumpf 1.1 CIMProcessIndicationResponseMessage* message)
1531 {
1532 // No additional attributes to serialize!
1533 }
1534
1535 //
1536 // _serializeCIMDisableModuleResponseMessage
1537 //
1538 void CIMMessageSerializer::_serializeCIMDisableModuleResponseMessage(
|
1539 mike 1.22 Buffer& out,
|
1540 kumpf 1.1 CIMDisableModuleResponseMessage* message)
1541 {
1542 // Use PGUINT16ARRAY element to encapsulate the Uint16 elements
1543 XmlWriter::append(out, "<PGUINT16ARRAY>\n");
1544 for (Uint32 i=0; i < message->operationalStatus.size(); i++)
1545 {
1546 XmlWriter::appendValueElement(out, message->operationalStatus[i]);
1547 }
1548 XmlWriter::append(out, "</PGUINT16ARRAY>\n");
1549 }
1550
1551 //
1552 // _serializeCIMEnableModuleResponseMessage
1553 //
1554 void CIMMessageSerializer::_serializeCIMEnableModuleResponseMessage(
|
1555 mike 1.22 Buffer& out,
|
1556 kumpf 1.1 CIMEnableModuleResponseMessage* message)
1557 {
1558 // Use PGUINT16ARRAY element to encapsulate the Uint16 elements
1559 XmlWriter::append(out, "<PGUINT16ARRAY>\n");
1560 for (Uint32 i=0; i < message->operationalStatus.size(); i++)
1561 {
1562 XmlWriter::appendValueElement(out, message->operationalStatus[i]);
1563 }
1564 XmlWriter::append(out, "</PGUINT16ARRAY>\n");
1565 }
1566
1567 //
1568 // _serializeCIMStopAllProvidersResponseMessage
1569 //
1570 void CIMMessageSerializer::_serializeCIMStopAllProvidersResponseMessage(
|
1571 mike 1.22 Buffer& out,
|
1572 kumpf 1.1 CIMStopAllProvidersResponseMessage* message)
1573 {
1574 // No additional attributes to serialize!
1575 }
1576
|
1577 kumpf 1.2 //
1578 // _serializeCIMInitializeProviderResponseMessage
1579 //
1580 void CIMMessageSerializer::_serializeCIMInitializeProviderResponseMessage(
|
1581 mike 1.22 Buffer& out,
|
1582 kumpf 1.2 CIMInitializeProviderResponseMessage* message)
1583 {
1584 // No additional attributes to serialize!
1585 }
1586
|
1587 kumpf 1.7 //
1588 // _serializeCIMInitializeProviderAgentResponseMessage
1589 //
1590 void CIMMessageSerializer::_serializeCIMInitializeProviderAgentResponseMessage(
|
1591 mike 1.22 Buffer& out,
|
1592 kumpf 1.7 CIMInitializeProviderAgentResponseMessage* message)
1593 {
1594 // No additional attributes to serialize!
1595 }
1596
|
1597 kumpf 1.8 //
1598 // _serializeCIMNotifyConfigChangeResponseMessage
1599 //
1600 void CIMMessageSerializer::_serializeCIMNotifyConfigChangeResponseMessage(
|
1601 mike 1.22 Buffer& out,
|
1602 kumpf 1.8 CIMNotifyConfigChangeResponseMessage* message)
1603 {
1604 // No additional attributes to serialize!
1605 }
1606
|
1607 carolann.graves 1.21 //
1608 // _serializeCIMSubscriptionInitCompleteResponseMessage
1609 //
1610 void
1611 CIMMessageSerializer::_serializeCIMSubscriptionInitCompleteResponseMessage
|
1612 mike 1.22 (Buffer& out,
|
1613 carolann.graves 1.21 CIMSubscriptionInitCompleteResponseMessage* message)
1614 {
1615 // No additional attributes to serialize!
1616 }
1617
|
1618 kumpf 1.1 PEGASUS_NAMESPACE_END
|
Return to
CIMMessageSerializer.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common