1 r.kieninger 1.1 //%LICENSE////////////////////////////////////////////////////////////////
2 //
3 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 r.kieninger 1.1 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //////////////////////////////////////////////////////////////////////////
29 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include "CIMResponseData.h"
|
33 marek 1.2.2.5 #include <Pegasus/Common/Tracer.h>
34 #include <Pegasus/Common/XmlWriter.h>
35 #include <Pegasus/Common/SCMOXmlWriter.h>
36 #include <Pegasus/Common/XmlReader.h>
37 #include <Pegasus/Common/SCMOClassCache.h>
|
38 r.kieninger 1.1
39 PEGASUS_USING_STD;
40
41 PEGASUS_NAMESPACE_BEGIN
42
|
43 marek 1.2.2.5 // C++ objects interface handling
44
45 // Instance Names handling
46 Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
47 {
48 PEGASUS_DEBUG_ASSERT(
49 (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
50 _resolveToCIM();
51 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
52 return _instanceNames;
53 }
54
55 // Instance handling
56 CIMInstance& CIMResponseData::getInstance()
57 {
58 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
59 _resolveToCIM();
60 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
61 return _instances[0];
62 }
63
64 marek 1.2.2.5 // Instances handling
65 Array<CIMInstance>& CIMResponseData::getInstances()
66 {
67 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);
68 _resolveToCIM();
69 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
70 return _instances;
71 }
72
73 // Objects handling
74 Array<CIMObject>& CIMResponseData::getObjects()
75 {
76 PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
77 _resolveToCIM();
78 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
79 return _objects;
80 }
81
82 // SCMO representation, single instance stored as one element array
83 // object paths are represented as SCMOInstance
84 Array<SCMOInstance>& CIMResponseData::getSCMO()
85 marek 1.2.2.5 {
86 _resolveToSCMO();
87 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
88 return _scmoInstances;
89 }
90
|
91 marek 1.2.2.6 void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
92 {
93 // Just assignment bears danger of us being dependent on the original array
94 // content staying valid
|
95 marek 1.2.2.8 _scmoInstances=x;
96 /*
|
97 marek 1.2.2.6 for (Uint32 loop=0, max=x.size(); loop<max; loop++)
98 {
99 _scmoInstances.append(x[loop]);
100 }
|
101 marek 1.2.2.8 */
|
102 marek 1.2.2.6 // _scmoInstances.appendArray(x);
103 _encoding |= RESP_ENC_SCMO;
104 }
105
106
|
107 marek 1.2.2.5 // Binary data is just a data stream
108 Array<Uint8>& CIMResponseData::getBinary()
109 {
110 // TODO: Check if the following condition might come true
111 // One actually should resolve everything down to binary in here ...
112 return _binaryData;
113 }
114
115 bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)
|
116 r.kieninger 1.2.2.1 {
117 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
118 marek 1.2.2.5 "CIMResponseData::setBinary");
|
119 r.kieninger 1.2.2.1
120 if (hasLen)
121 {
122 if (!in.getUint8A(_binaryData))
123 {
124 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
125 "Failed to get binary object path data!");
126 PEG_METHOD_EXIT();
127 return false;
128 }
129 }
130 else
131 {
132 size_t remainingDataLength = in.capacity() - in.size();
133 _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
134 }
|
135 marek 1.2.2.5 _encoding |= RESP_ENC_BINARY;
|
136 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
137 return true;
|
138 marek 1.2.2.5 }
|
139 r.kieninger 1.2.2.1
|
140 marek 1.2.2.5 bool CIMResponseData::setXml(CIMBuffer& in)
|
141 r.kieninger 1.2.2.1 {
142 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
143 marek 1.2.2.5 "CIMResponseData::setXml");
|
144 r.kieninger 1.2.2.1
|
145 marek 1.2.2.5 if (_dataType == RESP_INSTNAMES)
|
146 r.kieninger 1.2.2.1 {
|
147 marek 1.2.2.5 Uint32 count;
|
148 marek 1.2.2.6
|
149 marek 1.2.2.5 if (!in.getUint32(count))
|
150 r.kieninger 1.2.2.1 {
151 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
|
152 marek 1.2.2.5 "Failed to get XML objectpath data (number of paths)!");
|
153 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
154 return false;
155 }
|
156 marek 1.2.2.6
|
157 marek 1.2.2.5 for (Uint32 i = 0; i < count; i++)
|
158 r.kieninger 1.2.2.1 {
|
159 marek 1.2.2.5 Array<Sint8> ref;
160 CIMNamespaceName ns;
161 String host;
|
162 marek 1.2.2.6
|
163 marek 1.2.2.5 if (!in.getSint8A(ref))
164 {
165 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
166 "Failed to get XML objectpath data (references)!");
167 PEG_METHOD_EXIT();
168 return false;
169 }
|
170 marek 1.2.2.6
|
171 marek 1.2.2.5 if (!in.getString(host))
172 {
173 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
174 "Failed to get XML instance data (host)!");
175 PEG_METHOD_EXIT();
176 return false;
177 }
|
178 marek 1.2.2.6
|
179 marek 1.2.2.5 if (!in.getNamespaceName(ns))
180 {
181 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
182 "Failed to get XML instance data (namespace)!");
183 PEG_METHOD_EXIT();
184 return false;
185 }
|
186 marek 1.2.2.6
|
187 marek 1.2.2.5 _referencesData.append(ref);
188 _hostsData.append(host);
189 _nameSpacesData.append(ns);
|
190 r.kieninger 1.2.2.1 }
191 }
|
192 marek 1.2.2.5 // TODO: Code the left out types
|
193 r.kieninger 1.2.2.1
|
194 marek 1.2.2.5 _encoding |= RESP_ENC_XML;
|
195 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
196 return true;
|
197 marek 1.2.2.5 }
198
199 // function used by OperationAggregator to aggregate response data in a
200 // single ResponseData object
201 void CIMResponseData::appendResponseData(const CIMResponseData & x)
202 {
203 // as the Messages set the data types, this should be impossible
204 PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
205 _encoding |= x._encoding;
206
207 // add all binary data
208 _binaryData.appendArray(x._binaryData);
|
209 r.kieninger 1.2.2.1
|
210 marek 1.2.2.5 // add all the C++ stuff
211 _instanceNames.appendArray(x._instanceNames);
212 _instances.appendArray(x._instances);
213 _objects.appendArray(x._objects);
|
214 r.kieninger 1.2.2.1
|
215 marek 1.2.2.5 // add the SCMO instances
216 _scmoInstances.appendArray(x._scmoInstances);
|
217 r.kieninger 1.2.2.1
|
218 marek 1.2.2.5 // add Xml encodings too
219 _referencesData.appendArray(x._referencesData);
220 _instanceData.appendArray(x._instanceData);
221 _hostsData.appendArray(x._hostsData);
222 _nameSpacesData.appendArray(x._nameSpacesData);
223 }
|
224 r.kieninger 1.2.2.1
|
225 marek 1.2.2.5 // Encoding responses into output format
226 void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)
|
227 r.kieninger 1.2.2.1 {
228 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
229 marek 1.2.2.5 "CIMResponseData::encodeBinaryResponse");
|
230 r.kieninger 1.2.2.1
|
231 marek 1.2.2.5 // Need to do a complete job here by transferring all contained data
232 // into binary format and handing it out in the CIMBuffer
233 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
234 r.kieninger 1.2.2.1 {
|
235 marek 1.2.2.5 // Binary does NOT need a marker as it consists of C++ and SCMO
|
236 r.kieninger 1.2.2.1 const Array<Uint8>& data = _binaryData;
237 out.putBytes(data.getData(), data.size());
238 }
|
239 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
240 r.kieninger 1.2.2.1 {
|
241 marek 1.2.2.6 // TODO: Set Marker for C++ data
|
242 marek 1.2.2.5 switch (_dataType)
|
243 r.kieninger 1.2.2.1 {
|
244 marek 1.2.2.5 case RESP_INSTNAMES:
245 {
246 out.putObjectPathA(_instanceNames, false);
247 break;
248 }
249 case RESP_INSTANCE:
250 {
251 if (0 != _instances.size())
252 {
253 out.putInstance(_instances[0], false, false);
254 }
255 break;
256 }
257 case RESP_INSTANCES:
258 {
259 out.putInstanceA(_instances, false);
260 break;
261 }
262 case RESP_OBJECTS:
263 {
264 out.putObjectA(_objects);
265 marek 1.2.2.5 break;
266 }
267 case RESP_OBJECTPATHS:
268 {
269 // TODO: Determine what to do here
270 break;
271 }
272 default:
273 {
|
274 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
275 marek 1.2.2.5 }
|
276 r.kieninger 1.2.2.1 }
277 }
|
278 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
279 r.kieninger 1.2.2.1 {
|
280 marek 1.2.2.5 // TODO: Set Marker for SCMO data
|
281 r.kieninger 1.2.2.1
|
282 marek 1.2.2.5 // Call magic here to transform a SCMO object into binary format
283 fprintf(stderr, "Watch wat ya do'n! SCMO to binary ? NO OOP yet.\n");
284 fflush(stderr);
285 }
286 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
287 r.kieninger 1.2.2.1 {
|
288 marek 1.2.2.5 // This actually should not happen following general code logic
|
289 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
290 r.kieninger 1.2.2.1 }
291
292 PEG_METHOD_EXIT();
293 }
294
|
295 marek 1.2.2.9 void CIMResponseData::completeHostNameAndNamespace(
296 const String & hn,
297 const CIMNamespaceName & ns)
298 {
299 // Internal XML always has host name and namespace
300 // binary data shhould not ever be present here
301 PEGASUS_DEBUG_ASSERT((RESP_ENC_BINARY != (_encoding & RESP_ENC_BINARY)));
302
303 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
304 {
305 switch (_dataType)
306 {
307 case RESP_OBJECTS:
308 {
309 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
310 {
311 const CIMObject& object = _objects[j];
312 CIMObjectPath& p =
313 const_cast<CIMObjectPath&>(object.getPath());
314 if (p.getHost().size()==0)
315 {
316 marek 1.2.2.9 p.setHost(hn);
317 }
318 if (p.getNameSpace().isNull())
319 {
320 p.setNameSpace(ns);
321 }
322 }
323 break;
324 }
325 case RESP_OBJECTPATHS:
326 {
327 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
328 {
329 CIMObjectPath& p = _instanceNames[j];
330 if (p.getHost().size() == 0)
331 p.setHost(hn);
332 if (p.getNameSpace().isNull())
333 p.setNameSpace(ns);
334 }
335 break;
336 }
337 marek 1.2.2.9 default:
338 {
339 PEGASUS_DEBUG_ASSERT(false);
340 }
341 }
342 }
343 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
344 {
345 CString hnCString=hn.getCString();
346 const char* hnChars = hnCString;
347 Uint32 hnLen = strlen(hnChars);
348 CString nsCString=ns.getString().getCString();
349 const char* nsChars=nsCString;
350 Uint32 nsLen = strlen(nsChars);
351 switch (_dataType)
352 {
353 case RESP_OBJECTS:
354 case RESP_OBJECTPATHS:
355 {
356 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
357 {
358 marek 1.2.2.9 SCMOInstance & scmoInst=_scmoInstances[j];
359 if (0 == scmoInst.getHostName())
360 {
361 scmoInst.setHostName_l(hnChars,hnLen);
362 }
363 if (0 == scmoInst.getNameSpace())
364 {
365 scmoInst.setNameSpace_l(nsChars,nsLen);
366 }
367 }
368 break;
369 }
370 default:
371 {
372 PEGASUS_DEBUG_ASSERT(false);
373 }
374 }
375 }
376 }
377
|
378 marek 1.2.2.5 void CIMResponseData::encodeXmlResponse(Buffer& out)
|
379 r.kieninger 1.2.2.1 {
380 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
381 marek 1.2.2.5 "CIMResponseData::encodeXmlResponse");
|
382 r.kieninger 1.2.2.1
|
383 marek 1.2.2.9 /* TODO: Transform into a trace statement
|
384 marek 1.2.2.5 fprintf(
385 stderr,
386 "encodeXmlResponse(encoding=%X,content=%X)\n",
387 _encoding,
388 _dataType);
389 fflush(stderr);
|
390 marek 1.2.2.9 */
|
391 r.kieninger 1.2.2.1
|
392 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
393 r.kieninger 1.2.2.1 {
|
394 marek 1.2.2.5 switch (_dataType)
|
395 r.kieninger 1.2.2.1 {
|
396 marek 1.2.2.5 case RESP_INSTNAMES:
397 {
398 const Array<ArraySint8>& a = _referencesData;
399 for (Uint32 i = 0, n = a.size(); i < n; i++)
400 {
401 out.append((char*)a[i].getData(), a[i].size() - 1);
402 }
403 break;
404 }
405 case RESP_INSTANCE:
406 {
407 out.append(
408 (char*)_instanceData.getData(),
409 _instanceData.size()-1);
410 break;
411 }
412 case RESP_INSTANCES:
413 {
414 const Array<ArraySint8>& a = _instanceData;
415 const Array<ArraySint8>& b = _referencesData;
|
416 r.kieninger 1.2.2.1
|
417 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
418 {
419 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
420 out.append((char*)b[i].getData(), b[i].size() - 1);
421 out.append((char*)a[i].getData(), a[i].size() - 1);
422 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
423 }
424 break;
425 }
426 case RESP_OBJECTS:
|
427 r.kieninger 1.2.2.1 {
|
428 marek 1.2.2.5 const Array<ArraySint8>& a = _instanceData;
429 const Array<ArraySint8>& b = _referencesData;
|
430 r.kieninger 1.2.2.1
|
431 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
432 {
433 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
434 out.append((char*)b[i].getData(), b[i].size() - 1);
435 out.append((char*)a[i].getData(), a[i].size() - 1);
436 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
437 }
438 break;
439 }
440 case RESP_OBJECTPATHS:
441 {
442 // TODO: Check what to do in this case
443 const Array<ArraySint8>& a = _instanceData;
444 const Array<ArraySint8>& b = _referencesData;
445
446 for (Uint32 i = 0, n = a.size(); i < n; i++)
447 {
448 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
449 out.append((char*)b[i].getData(), b[i].size() - 1);
450 out.append((char*)a[i].getData(), a[i].size() - 1);
451 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
452 marek 1.2.2.5 }
453 }
454 default:
455 {
|
456 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
457 r.kieninger 1.2.2.1 }
458 }
459 }
460
|
461 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
462 r.kieninger 1.2.2.1 {
|
463 marek 1.2.2.6 // TODO: Set Marker for C++ data
|
464 marek 1.2.2.5 switch (_dataType)
|
465 r.kieninger 1.2.2.1 {
|
466 marek 1.2.2.5 case RESP_INSTNAMES:
467 {
468 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
469 {
470 XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
471 }
472 break;
473 }
474 case RESP_INSTANCE:
475 {
476 if (_instances.size()>0)
477 {
478 XmlWriter::appendInstanceElement(out, _instances[0]);
479 }
480 break;
481 }
482 case RESP_INSTANCES:
483 {
484 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
485 {
486 XmlWriter::appendValueNamedInstanceElement(
487 marek 1.2.2.5 out, _instances[i]);
488 }
489 break;
490 }
491 case RESP_OBJECTS:
492 {
493 for (Uint32 i = 0; i < _objects.size(); i++)
494 {
495 XmlWriter::appendValueObjectWithPathElement(
496 out,
497 _objects[i]);
498 }
499 break;
500 }
501 case RESP_OBJECTPATHS:
502 {
503 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
504 {
505 out << "<OBJECTPATH>\n";
506 XmlWriter::appendValueReferenceElement(
507 out,
508 marek 1.2.2.5 _instanceNames[i],
509 false);
510 out << "</OBJECTPATH>\n";
511 }
512 break;
513 }
514 default:
515 {
|
516 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
517 marek 1.2.2.5 }
|
518 r.kieninger 1.2.2.1 }
519 }
|
520 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
521 r.kieninger 1.2.2.1 {
|
522 marek 1.2.2.5 /*SCMODump dmp;
523 dmp.dumpSCMOInstanceKeyBindings(_scmoInstances[i]);
524 dmp.dumpInstanceProperties(_scmoInstances[i]);*/
|
525 r.kieninger 1.1
|
526 marek 1.2.2.5 switch (_dataType)
|
527 r.kieninger 1.2 {
|
528 marek 1.2.2.5 case RESP_INSTNAMES:
529 {
530 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
531 {
532 SCMOXmlWriter::appendInstanceNameElement(
533 out,
534 _scmoInstances[i]);
535 }
536 break;
537 }
538 case RESP_INSTANCE:
539 {
540 if (_scmoInstances.size() > 0)
541 {
542 SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);
543 }
544 break;
545 }
546 case RESP_INSTANCES:
547 {
548 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
549 marek 1.2.2.5 {
550 SCMOXmlWriter::appendValueSCMOInstanceElement(
551 out,
552 _scmoInstances[i]);
553 }
554 break;
555 }
556 case RESP_OBJECTS:
557 {
558 for (Uint32 i = 0; i < _scmoInstances.size(); i++)
559 {
560 SCMOXmlWriter::appendValueObjectWithPathElement(
561 out,
562 _scmoInstances[i]);
563 }
564 break;
565 }
566 case RESP_OBJECTPATHS:
567 {
|
568 marek 1.2.2.7 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
569 {
570 out << "<OBJECTPATH>\n";
571 SCMOXmlWriter::appendValueReferenceElement(
572 out,
573 _scmoInstances[i],
574 false);
575 out << "</OBJECTPATH>\n";
576 }
|
577 marek 1.2.2.5 break;
578 }
579 default:
580 {
|
581 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
582 marek 1.2.2.5 }
|
583 r.kieninger 1.2 }
|
584 r.kieninger 1.1 }
|
585 marek 1.2.2.9 /* TODO: Transform into a trace statement
|
586 marek 1.2.2.6 fprintf(
587 stderr,
588 "After XmlWrite()\n%s",
589 out.getData());
590 fflush(stderr);
|
591 marek 1.2.2.9 */
|
592 marek 1.2.2.5 }
|
593 r.kieninger 1.1
|
594 marek 1.2.2.5 // contrary to encodeXmlResponse this function encodes the Xml in a format
595 // not usable by clients
596 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
597 {
598 // TODO: Implement
599 // Need the full switch here again
600 // Should use the internal data available SCMO, C++ and InternalXML
601 // to generate the InternalXML by CIMInternalEncoder and SCMOInternalEncoder
602 fprintf(stderr, "Watch wat ya do'n! SCMO to InternalXml ? NO OOP yet.\n");
603 fflush(stderr);
604 }
|
605 r.kieninger 1.1
|
606 marek 1.2.2.5 void CIMResponseData::_resolveToCIM()
|
607 r.kieninger 1.1 {
|
608 marek 1.2.2.9 /* TODO: Transform into warning trace statement
|
609 marek 1.2.2.5 fprintf(
610 stderr,
611 "_resolveToCIM(encoding=%X,content=%X)\n",
612 _encoding,
613 _dataType);
614 fflush(stderr);
|
615 marek 1.2.2.9 */
|
616 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
617 r.kieninger 1.1 {
|
618 marek 1.2.2.5 _resolveXmlToCIM();
|
619 r.kieninger 1.1 }
|
620 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
621 r.kieninger 1.1 {
|
622 marek 1.2.2.5 _resolveBinary();
|
623 r.kieninger 1.1 }
|
624 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
625 r.kieninger 1.1 {
|
626 marek 1.2.2.5 _resolveSCMOToCIM();
|
627 r.kieninger 1.1 }
|
628 marek 1.2.2.5 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
629 }
|
630 r.kieninger 1.1
|
631 marek 1.2.2.5 void CIMResponseData::_resolveToSCMO()
632 {
|
633 marek 1.2.2.9 /* TODO: Transform into warning trace statement
|
634 marek 1.2.2.5 fprintf(
635 stderr,
636 "_resolveToSCMO(encoding=%X,content=%X)\n",
637 _encoding,
638 _dataType);
639 fflush(stderr);
|
640 marek 1.2.2.9 */
|
641 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
642 r.kieninger 1.1 {
|
643 marek 1.2.2.5 _resolveXmlToSCMO();
|
644 r.kieninger 1.1 }
|
645 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
646 r.kieninger 1.1 {
|
647 marek 1.2.2.5 _resolveBinary();
|
648 r.kieninger 1.1 }
|
649 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
650 r.kieninger 1.1 {
|
651 marek 1.2.2.5 _resolveCIMToSCMO();
|
652 r.kieninger 1.1 }
|
653 marek 1.2.2.5 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
|
654 r.kieninger 1.1 }
655
|
656 marek 1.2.2.5 // helper functions to transform different formats into one-another
657 // functions work on the internal data and calling of them should be
658 // avoided whenever possible
659 void CIMResponseData::_resolveBinary()
|
660 r.kieninger 1.1 {
|
661 marek 1.2.2.5 // Call magic here to resolve binary format
662 fprintf(stderr, "Watch wat ya do'n! binary ? NO OOP yet.\n");
663 fflush(stderr);
|
664 r.kieninger 1.1
|
665 marek 1.2.2.5 switch (_dataType)
|
666 r.kieninger 1.1 {
|
667 marek 1.2.2.5 case RESP_INSTNAMES:
668 {
669 break;
670 }
671 case RESP_INSTANCE:
672 {
673 break;
674 }
675 case RESP_INSTANCES:
676 {
677 break;
678 }
679 case RESP_OBJECTS:
680 {
681 break;
682 }
683 case RESP_OBJECTPATHS:
684 {
685 break;
686 }
687 default:
688 marek 1.2.2.5 {
|
689 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
690 marek 1.2.2.5 }
|
691 r.kieninger 1.1 }
692 }
693
|
694 marek 1.2.2.5 void CIMResponseData::_resolveXmlToCIM()
|
695 r.kieninger 1.1 {
|
696 marek 1.2.2.5 switch (_dataType)
697 {
698 case RESP_INSTNAMES:
699 {
700 for (Uint32 i = 0; i < _referencesData.size(); i++)
701 {
702 CIMObjectPath cop;
703 // Deserialize path:
704 {
705 XmlParser parser((char*)_referencesData[i].getData());
706
707 if (XmlReader::getInstanceNameElement(parser, cop))
708 {
709 if (!_nameSpacesData[i].isNull())
710 cop.setNameSpace(_nameSpacesData[i]);
711
712 if (_hostsData[i].size())
713 cop.setHost(_hostsData[i]);
714 }
715 }
716 _instanceNames.append(cop);
717 marek 1.2.2.5 }
718 break;
719 }
720 case RESP_INSTANCE:
721 {
722 CIMInstance cimInstance;
723 // Deserialize instance:
724 {
725 XmlParser parser((char*)_instanceData[0].getData());
|
726 r.kieninger 1.1
|
727 marek 1.2.2.5 if (!XmlReader::getInstanceElement(parser, cimInstance))
728 {
729 cimInstance = CIMInstance();
730 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
731 "Failed to resolve XML instance, parser error!");
732 }
733 }
734 // Deserialize path:
735 {
736 XmlParser parser((char*)_referencesData[0].getData());
737 CIMObjectPath cimObjectPath;
|
738 r.kieninger 1.1
|
739 marek 1.2.2.5 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
740 {
741 if (_hostsData.size())
742 {
743 cimObjectPath.setHost(_hostsData[0]);
744 }
745 if (!_nameSpacesData[0].isNull())
746 {
747 cimObjectPath.setNameSpace(_nameSpacesData[0]);
748 }
749 cimInstance.setPath(cimObjectPath);
750 // only if everything works we add the CIMInstance to the
751 // array
752 _instances.append(cimInstance);
753 }
754 }
755 break;
756 }
757 case RESP_INSTANCES:
758 {
759 for (Uint32 i = 0; i < _instanceData.size(); i++)
760 marek 1.2.2.5 {
761 CIMInstance cimInstance;
762 // Deserialize instance:
763 {
764 XmlParser parser((char*)_instanceData[i].getData());
765
766 if (!XmlReader::getInstanceElement(parser, cimInstance))
767 {
768 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
769 "Failed to resolve XML instance."
770 " Creating empty instance!");
771 cimInstance = CIMInstance();
772 }
773 }
774
775 // Deserialize path:
776 {
777 XmlParser parser((char*)_referencesData[i].getData());
778 CIMObjectPath cimObjectPath;
779
780 if (XmlReader::getInstanceNameElement(parser,cimObjectPath))
781 marek 1.2.2.5 {
782 if (!_nameSpacesData[i].isNull())
783 cimObjectPath.setNameSpace(_nameSpacesData[i]);
784
785 if (_hostsData[i].size())
786 cimObjectPath.setHost(_hostsData[i]);
787
788 cimInstance.setPath(cimObjectPath);
789 }
790 }
|
791 r.kieninger 1.1
|
792 marek 1.2.2.5 _instances.append(cimInstance);
793 }
794 break;
795 }
796 case RESP_OBJECTS:
797 {
798 for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
799 {
800 CIMObject cimObject;
801
802 // Deserialize Objects:
803 {
804 XmlParser parser((char*)_instanceData[i].getData());
805
806 CIMInstance cimInstance;
807 CIMClass cimClass;
808
809 if (XmlReader::getInstanceElement(parser, cimInstance))
810 {
811 cimObject = CIMObject(cimInstance);
812 }
813 marek 1.2.2.5 else if (XmlReader::getClassElement(parser, cimClass))
814 {
815 cimObject = CIMObject(cimClass);
816 }
817 else
818 {
819 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
820 "Failed to get XML object data!");
821 }
822 }
823
824 // Deserialize paths:
825 {
826 XmlParser parser((char*)_referencesData[i].getData());
827 CIMObjectPath cimObjectPath;
828
829 if (XmlReader::getValueReferenceElement(
830 parser,
831 cimObjectPath))
832 {
833 if (!_nameSpacesData[i].isNull())
834 marek 1.2.2.5 cimObjectPath.setNameSpace(_nameSpacesData[i]);
835
836 if (_hostsData[i].size())
837 cimObjectPath.setHost(_hostsData[i]);
838
839 cimObject.setPath(cimObjectPath);
840 }
841 }
842 _objects.append(cimObject);
843 }
844 break;
845 }
846 case RESP_OBJECTPATHS:
847 {
848 // TODO: ????
849 }
850 default:
851 {
|
852 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
853 marek 1.2.2.5 }
854 }
855 // Xml was resolved, release Xml content now
856 _referencesData.clear();
857 _hostsData.clear();
858 _nameSpacesData.clear();
859 _instanceData.clear();
860 // remove Xml Encoding flag
|
861 marek 1.2.2.8 _encoding &=(~RESP_ENC_XML);
|
862 marek 1.2.2.5 // add CIM Encoding flag
863 _encoding |=RESP_ENC_CIM;
|
864 r.kieninger 1.1 }
865
|
866 marek 1.2.2.5 void CIMResponseData::_resolveXmlToSCMO()
|
867 r.kieninger 1.2.2.4 {
|
868 marek 1.2.2.5 // Not optimal, can probably be improved
869 // but on the other hand, since using the binary format this case should
870 // actually not ever happen.
871 _resolveXmlToCIM();
872 _resolveCIMToSCMO();
873 }
|
874 r.kieninger 1.2.2.4
|
875 marek 1.2.2.5 void CIMResponseData::_resolveSCMOToCIM()
876 {
877 switch(_dataType)
|
878 r.kieninger 1.2.2.4 {
|
879 marek 1.2.2.5 case RESP_INSTNAMES:
880 case RESP_OBJECTPATHS:
|
881 r.kieninger 1.1 {
|
882 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
883 {
884 CIMObjectPath newObjectPath;
885 _scmoInstances[x].getCIMObjectPath(newObjectPath);
886 _instanceNames.append(newObjectPath);
887 }
888 break;
|
889 r.kieninger 1.1 }
|
890 marek 1.2.2.5 case RESP_INSTANCE:
|
891 r.kieninger 1.1 {
|
892 marek 1.2.2.8 if (_scmoInstances.size() > 0)
893 {
894 CIMInstance newInstance;
895 _scmoInstances[0].getCIMInstance(newInstance);
896 _instances.append(newInstance);
897 }
|
898 marek 1.2.2.5 break;
|
899 marek 1.2.2.2 }
|
900 marek 1.2.2.5 case RESP_INSTANCES:
|
901 r.kieninger 1.2 {
|
902 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
903 r.kieninger 1.1 {
|
904 marek 1.2.2.5 CIMInstance newInstance;
905 _scmoInstances[x].getCIMInstance(newInstance);
906 _instances.append(newInstance);
|
907 r.kieninger 1.1 }
|
908 marek 1.2.2.5 break;
|
909 r.kieninger 1.1 }
|
910 marek 1.2.2.5 case RESP_OBJECTS:
|
911 r.kieninger 1.1 {
|
912 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
913 r.kieninger 1.1 {
|
914 marek 1.2.2.5 CIMInstance newInstance;
915 _scmoInstances[x].getCIMInstance(newInstance);
916 _objects.append(CIMObject(newInstance));
|
917 r.kieninger 1.1 }
|
918 marek 1.2.2.5 break;
|
919 r.kieninger 1.1 }
|
920 marek 1.2.2.5 default:
|
921 r.kieninger 1.2.2.1 {
|
922 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
923 r.kieninger 1.2.2.1 }
924 }
|
925 marek 1.2.2.5 _scmoInstances.clear();
926 // remove CIM Encoding flag
|
927 marek 1.2.2.8 _encoding &=(~RESP_ENC_SCMO);
|
928 marek 1.2.2.5 // add SCMO Encoding flag
929 _encoding |=RESP_ENC_CIM;
|
930 r.kieninger 1.2.2.1 }
931
|
932 marek 1.2.2.5 void CIMResponseData::_resolveCIMToSCMO()
|
933 r.kieninger 1.1 {
|
934 marek 1.2.2.5 switch (_dataType)
|
935 r.kieninger 1.2 {
|
936 marek 1.2.2.5 case RESP_INSTNAMES:
|
937 r.kieninger 1.2 {
|
938 marek 1.2.2.5 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
939 {
940 SCMOInstance addme =
941 _getSCMOFromCIMObjectPath(_instanceNames[i]);
942 _scmoInstances.append(addme);
943 }
|
944 marek 1.2.2.8 _instanceNames.clear();
|
945 marek 1.2.2.5 break;
|
946 r.kieninger 1.2 }
|
947 marek 1.2.2.5 case RESP_INSTANCE:
|
948 r.kieninger 1.1 {
|
949 marek 1.2.2.8 if (_instances.size() > 0)
950 {
951 SCMOInstance addme =
952 _getSCMOFromCIMInstance(_instances[0]);
953 _scmoInstances.append(addme);
954 _instances.clear();
955 }
|
956 marek 1.2.2.5 break;
|
957 r.kieninger 1.1 }
|
958 marek 1.2.2.5 case RESP_INSTANCES:
|
959 r.kieninger 1.1 {
|
960 marek 1.2.2.5 for (Uint32 i=0,n=_instances.size();i<n;i++)
961 {
|
962 marek 1.2.2.8 SCMOInstance addme = _getSCMOFromCIMInstance(_instances[i]);
|
963 marek 1.2.2.5 _scmoInstances.append(addme);
964 }
|
965 marek 1.2.2.8 _instances.clear();
|
966 marek 1.2.2.5 break;
|
967 r.kieninger 1.1 }
|
968 marek 1.2.2.5 case RESP_OBJECTS:
|
969 r.kieninger 1.1 {
|
970 marek 1.2.2.8 for (Uint32 i=0,n=_objects.size();i<n;i++)
971 {
|
972 marek 1.2.2.9 SCMOInstance addme= _getSCMOFromCIMObject(_objects[i]);
|
973 marek 1.2.2.8 _scmoInstances.append(addme);
974 }
975 _objects.clear();
|
976 marek 1.2.2.5 break;
|
977 r.kieninger 1.1 }
|
978 marek 1.2.2.9 case RESP_OBJECTPATHS:
979 {
980 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
981 {
982 SCMOInstance addme =
983 _getSCMOFromCIMObjectPath(_instanceNames[i]);
984 if (0 == _instanceNames[i].getKeyBindings().size())
985 {
986 // if there is no keybinding, this is a class
987 addme.setIsClassOnly(true);
988 }
989 _scmoInstances.append(addme);
990 }
991 _instanceNames.clear();
992 break;
993 }
|
994 marek 1.2.2.5 default:
|
995 r.kieninger 1.1 {
|
996 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
997 r.kieninger 1.1 }
998 }
999
|
1000 marek 1.2.2.5 // remove CIM Encoding flag
|
1001 marek 1.2.2.8 _encoding &=(~RESP_ENC_CIM);
|
1002 marek 1.2.2.5 // add SCMO Encoding flag
1003 _encoding |=RESP_ENC_SCMO;
|
1004 r.kieninger 1.1 }
1005
|
1006 marek 1.2.2.5
1007 // Function to convert a CIMInstance into an SCMOInstance
1008 SCMOInstance CIMResponseData::_getSCMOFromCIMInstance(
1009 const CIMInstance& cimInst)
|
1010 r.kieninger 1.1 {
|
1011 marek 1.2.2.5 const CIMObjectPath& cimPath = cimInst.getPath();
|
1012 r.kieninger 1.1
|
1013 marek 1.2.2.5 const CString nameSpace = cimPath.getNameSpace().getString().getCString();
1014 const CString className = cimPath.getClassName().getString().getCString();
1015 // TODO: What do when either or both are 0 ?
|
1016 r.kieninger 1.1
|
1017 marek 1.2.2.5 SCMOClass * scmoClass = _getSCMOClass(
1018 (const char*)nameSpace,
1019 (const char*)className);
1020 // TODO: What do when there is no such class ?
|
1021 r.kieninger 1.1
|
1022 marek 1.2.2.5 SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst);
|
1023 r.kieninger 1.1
|
1024 marek 1.2.2.5 return scmoInst;
|
1025 r.kieninger 1.1 }
1026
|
1027 marek 1.2.2.9 SCMOInstance CIMResponseData::_getSCMOFromCIMObject(
1028 const CIMObject& cimObj)
1029 {
1030 if (cimObj.isClass())
1031 {
1032 CIMClass retClass(cimObj);
1033 SCMOInstance theInstance(retClass);
1034 theInstance.setIsClassOnly(true);
1035 return theInstance;
1036 }
1037 return _getSCMOFromCIMInstance(CIMInstance(cimObj));
1038 }
1039
|
1040 marek 1.2.2.5 // Function to convert a CIMObjectPath into an SCMOInstance
1041 SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath(
1042 const CIMObjectPath& cimPath)
|
1043 r.kieninger 1.1 {
|
1044 marek 1.2.2.5 CString nameSpace = cimPath.getNameSpace().getString().getCString();
1045 CString className = cimPath.getClassName().getString().getCString();
|
1046 r.kieninger 1.1
|
1047 marek 1.2.2.5 // TODO: What do when either or both are 0 ?
|
1048 r.kieninger 1.1
|
1049 marek 1.2.2.5 SCMOClass * scmoClass = _getSCMOClass(
1050 (const char*)nameSpace,
1051 (const char*)className);
|
1052 r.kieninger 1.1
|
1053 marek 1.2.2.5 // TODO: What do when there is no such class ?
|
1054 r.kieninger 1.1
|
1055 marek 1.2.2.5 // TODO: Interrogate Thilo about need to call new
1056 SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);
|
1057 r.kieninger 1.1
|
1058 marek 1.2.2.5 return scmoRef;
|
1059 r.kieninger 1.1 }
1060
|
1061 marek 1.2.2.5 SCMOClass* CIMResponseData::_getSCMOClass(
1062 const char* nameSpace,
1063 const char* cls)
|
1064 r.kieninger 1.1 {
|
1065 marek 1.2.2.5 SCMOClassCache* local = SCMOClassCache::getInstance();
1066 return local->getSCMOClass(
1067 nameSpace,
1068 strlen(nameSpace),
1069 cls,
1070 strlen(cls));
|
1071 r.kieninger 1.1 }
1072
1073 PEGASUS_NAMESPACE_END
|
Return to
CIMResponseData.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common