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 // _scmoInstances=x;
96 for (Uint32 loop=0, max=x.size(); loop<max; loop++)
97 {
98 _scmoInstances.append(x[loop]);
99 }
100 // _scmoInstances.appendArray(x);
101 _encoding |= RESP_ENC_SCMO;
102 }
103
104
|
105 marek 1.2.2.5 // Binary data is just a data stream
106 Array<Uint8>& CIMResponseData::getBinary()
107 {
108 // TODO: Check if the following condition might come true
109 // One actually should resolve everything down to binary in here ...
110 return _binaryData;
111 }
112
113 bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)
|
114 r.kieninger 1.2.2.1 {
115 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
116 marek 1.2.2.5 "CIMResponseData::setBinary");
|
117 r.kieninger 1.2.2.1
118 if (hasLen)
119 {
120 if (!in.getUint8A(_binaryData))
121 {
122 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
123 "Failed to get binary object path data!");
124 PEG_METHOD_EXIT();
125 return false;
126 }
127 }
128 else
129 {
130 size_t remainingDataLength = in.capacity() - in.size();
131 _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
132 }
|
133 marek 1.2.2.5 _encoding |= RESP_ENC_BINARY;
|
134 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
135 return true;
|
136 marek 1.2.2.5 }
|
137 r.kieninger 1.2.2.1
|
138 marek 1.2.2.5 bool CIMResponseData::setXml(CIMBuffer& in)
|
139 r.kieninger 1.2.2.1 {
140 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
141 marek 1.2.2.5 "CIMResponseData::setXml");
|
142 r.kieninger 1.2.2.1
|
143 marek 1.2.2.5 if (_dataType == RESP_INSTNAMES)
|
144 r.kieninger 1.2.2.1 {
|
145 marek 1.2.2.5 Uint32 count;
|
146 marek 1.2.2.6
|
147 marek 1.2.2.5 if (!in.getUint32(count))
|
148 r.kieninger 1.2.2.1 {
149 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
|
150 marek 1.2.2.5 "Failed to get XML objectpath data (number of paths)!");
|
151 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
152 return false;
153 }
|
154 marek 1.2.2.6
|
155 marek 1.2.2.5 for (Uint32 i = 0; i < count; i++)
|
156 r.kieninger 1.2.2.1 {
|
157 marek 1.2.2.5 Array<Sint8> ref;
158 CIMNamespaceName ns;
159 String host;
|
160 marek 1.2.2.6
|
161 marek 1.2.2.5 if (!in.getSint8A(ref))
162 {
163 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
164 "Failed to get XML objectpath data (references)!");
165 PEG_METHOD_EXIT();
166 return false;
167 }
|
168 marek 1.2.2.6
|
169 marek 1.2.2.5 if (!in.getString(host))
170 {
171 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
172 "Failed to get XML instance data (host)!");
173 PEG_METHOD_EXIT();
174 return false;
175 }
|
176 marek 1.2.2.6
|
177 marek 1.2.2.5 if (!in.getNamespaceName(ns))
178 {
179 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
180 "Failed to get XML instance data (namespace)!");
181 PEG_METHOD_EXIT();
182 return false;
183 }
|
184 marek 1.2.2.6
|
185 marek 1.2.2.5 _referencesData.append(ref);
186 _hostsData.append(host);
187 _nameSpacesData.append(ns);
|
188 r.kieninger 1.2.2.1 }
189 }
|
190 marek 1.2.2.5 // TODO: Code the left out types
|
191 r.kieninger 1.2.2.1
|
192 marek 1.2.2.5 _encoding |= RESP_ENC_XML;
|
193 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
194 return true;
|
195 marek 1.2.2.5 }
196
197 // function used by OperationAggregator to aggregate response data in a
198 // single ResponseData object
199 void CIMResponseData::appendResponseData(const CIMResponseData & x)
200 {
201 // as the Messages set the data types, this should be impossible
202 PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
203 _encoding |= x._encoding;
204
205 // add all binary data
206 _binaryData.appendArray(x._binaryData);
|
207 r.kieninger 1.2.2.1
|
208 marek 1.2.2.5 // add all the C++ stuff
209 _instanceNames.appendArray(x._instanceNames);
210 _instances.appendArray(x._instances);
211 _objects.appendArray(x._objects);
|
212 r.kieninger 1.2.2.1
|
213 marek 1.2.2.5 // add the SCMO instances
214 _scmoInstances.appendArray(x._scmoInstances);
|
215 r.kieninger 1.2.2.1
|
216 marek 1.2.2.5 // add Xml encodings too
217 _referencesData.appendArray(x._referencesData);
218 _instanceData.appendArray(x._instanceData);
219 _hostsData.appendArray(x._hostsData);
220 _nameSpacesData.appendArray(x._nameSpacesData);
221 }
|
222 r.kieninger 1.2.2.1
|
223 marek 1.2.2.5 // Encoding responses into output format
224 void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)
|
225 r.kieninger 1.2.2.1 {
226 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
227 marek 1.2.2.5 "CIMResponseData::encodeBinaryResponse");
|
228 r.kieninger 1.2.2.1
|
229 marek 1.2.2.5 // Need to do a complete job here by transferring all contained data
230 // into binary format and handing it out in the CIMBuffer
231 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
232 r.kieninger 1.2.2.1 {
|
233 marek 1.2.2.5 // Binary does NOT need a marker as it consists of C++ and SCMO
|
234 r.kieninger 1.2.2.1 const Array<Uint8>& data = _binaryData;
235 out.putBytes(data.getData(), data.size());
236 }
|
237 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
238 r.kieninger 1.2.2.1 {
|
239 marek 1.2.2.6 // TODO: Set Marker for C++ data
|
240 marek 1.2.2.5 switch (_dataType)
|
241 r.kieninger 1.2.2.1 {
|
242 marek 1.2.2.5 case RESP_INSTNAMES:
243 {
244 out.putObjectPathA(_instanceNames, false);
245 break;
246 }
247 case RESP_INSTANCE:
248 {
249 if (0 != _instances.size())
250 {
251 out.putInstance(_instances[0], false, false);
252 }
253 break;
254 }
255 case RESP_INSTANCES:
256 {
257 out.putInstanceA(_instances, false);
258 break;
259 }
260 case RESP_OBJECTS:
261 {
262 out.putObjectA(_objects);
263 marek 1.2.2.5 break;
264 }
265 case RESP_OBJECTPATHS:
266 {
267 // TODO: Determine what to do here
268 break;
269 }
270 default:
271 {
272 // TODO:
273 // Argl, not nice, but not a problem yet, ignore this
274 }
|
275 r.kieninger 1.2.2.1 }
276 }
|
277 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
278 r.kieninger 1.2.2.1 {
|
279 marek 1.2.2.5 // TODO: Set Marker for SCMO data
|
280 r.kieninger 1.2.2.1
|
281 marek 1.2.2.5 // Call magic here to transform a SCMO object into binary format
282 fprintf(stderr, "Watch wat ya do'n! SCMO to binary ? NO OOP yet.\n");
283 fflush(stderr);
284 }
285 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
286 r.kieninger 1.2.2.1 {
|
287 marek 1.2.2.5 // This actually should not happen following general code logic
288 PEGASUS_DEBUG_ASSERT(true);
|
289 r.kieninger 1.2.2.1 }
290
291 PEG_METHOD_EXIT();
292 }
293
|
294 marek 1.2.2.5 void CIMResponseData::encodeXmlResponse(Buffer& out)
|
295 r.kieninger 1.2.2.1 {
296 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
297 marek 1.2.2.5 "CIMResponseData::encodeXmlResponse");
|
298 r.kieninger 1.2.2.1
|
299 marek 1.2.2.5 fprintf(
300 stderr,
301 "encodeXmlResponse(encoding=%X,content=%X)\n",
302 _encoding,
303 _dataType);
304 fflush(stderr);
|
305 r.kieninger 1.2.2.1
|
306 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
307 r.kieninger 1.2.2.1 {
|
308 marek 1.2.2.5 switch (_dataType)
|
309 r.kieninger 1.2.2.1 {
|
310 marek 1.2.2.5 case RESP_INSTNAMES:
311 {
312 const Array<ArraySint8>& a = _referencesData;
313 for (Uint32 i = 0, n = a.size(); i < n; i++)
314 {
315 out.append((char*)a[i].getData(), a[i].size() - 1);
316 }
317 break;
318 }
319 case RESP_INSTANCE:
320 {
321 out.append(
322 (char*)_instanceData.getData(),
323 _instanceData.size()-1);
324 break;
325 }
326 case RESP_INSTANCES:
327 {
328 const Array<ArraySint8>& a = _instanceData;
329 const Array<ArraySint8>& b = _referencesData;
|
330 r.kieninger 1.2.2.1
|
331 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
332 {
333 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
334 out.append((char*)b[i].getData(), b[i].size() - 1);
335 out.append((char*)a[i].getData(), a[i].size() - 1);
336 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
337 }
338 break;
339 }
340 case RESP_OBJECTS:
|
341 r.kieninger 1.2.2.1 {
|
342 marek 1.2.2.5 const Array<ArraySint8>& a = _instanceData;
343 const Array<ArraySint8>& b = _referencesData;
|
344 r.kieninger 1.2.2.1
|
345 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
346 {
347 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
348 out.append((char*)b[i].getData(), b[i].size() - 1);
349 out.append((char*)a[i].getData(), a[i].size() - 1);
350 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
351 }
352 break;
353 }
354 case RESP_OBJECTPATHS:
355 {
356 // TODO: Check what to do in this case
357 const Array<ArraySint8>& a = _instanceData;
358 const Array<ArraySint8>& b = _referencesData;
359
360 for (Uint32 i = 0, n = a.size(); i < n; i++)
361 {
362 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
363 out.append((char*)b[i].getData(), b[i].size() - 1);
364 out.append((char*)a[i].getData(), a[i].size() - 1);
365 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
366 marek 1.2.2.5 }
367 }
368 default:
369 {
370 // TODO:
371 // Argl, not nice, but not a problem yet, ignore this
|
372 r.kieninger 1.2.2.1 }
373 }
374 }
375
|
376 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
377 r.kieninger 1.2.2.1 {
|
378 marek 1.2.2.5 fprintf(stderr,"Got CIM data...\n");
379 fflush(stderr);
|
380 marek 1.2.2.6 // TODO: Set Marker for C++ data
|
381 marek 1.2.2.5 switch (_dataType)
|
382 r.kieninger 1.2.2.1 {
|
383 marek 1.2.2.5 case RESP_INSTNAMES:
384 {
385 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
386 {
387 XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
388 }
389 break;
390 }
391 case RESP_INSTANCE:
392 {
393 if (_instances.size()>0)
394 {
395 XmlWriter::appendInstanceElement(out, _instances[0]);
396 }
397 break;
398 }
399 case RESP_INSTANCES:
400 {
401 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
402 {
403 XmlWriter::appendValueNamedInstanceElement(
404 marek 1.2.2.5 out, _instances[i]);
405 }
406 break;
407 }
408 case RESP_OBJECTS:
409 {
410 for (Uint32 i = 0; i < _objects.size(); i++)
411 {
412 XmlWriter::appendValueObjectWithPathElement(
413 out,
414 _objects[i]);
415 }
416 break;
417 }
418 case RESP_OBJECTPATHS:
419 {
420 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
421 {
422 out << "<OBJECTPATH>\n";
423 XmlWriter::appendValueReferenceElement(
424 out,
425 marek 1.2.2.5 _instanceNames[i],
426 false);
427 out << "</OBJECTPATH>\n";
428 }
429 break;
430 }
431 default:
432 {
433 // TODO:
434 // Argl, not nice, but not a problem yet, ignore this
435 }
|
436 r.kieninger 1.2.2.1 }
437 }
|
438 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
439 r.kieninger 1.2.2.1 {
|
440 marek 1.2.2.5 /*SCMODump dmp;
441 dmp.dumpSCMOInstanceKeyBindings(_scmoInstances[i]);
442 dmp.dumpInstanceProperties(_scmoInstances[i]);*/
|
443 marek 1.2.2.7 fprintf(
444 stderr,"encodeXmlResponse(SCMO)=%d instances...\n",
445 _scmoInstances.size());
446 fflush(stderr);
|
447 r.kieninger 1.1
|
448 marek 1.2.2.5 switch (_dataType)
|
449 r.kieninger 1.2 {
|
450 marek 1.2.2.5 case RESP_INSTNAMES:
451 {
452 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
453 {
454 SCMOXmlWriter::appendInstanceNameElement(
455 out,
456 _scmoInstances[i]);
457 }
458 break;
459 }
460 case RESP_INSTANCE:
461 {
462 if (_scmoInstances.size() > 0)
463 {
464 SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);
465 }
466 break;
467 }
468 case RESP_INSTANCES:
469 {
470 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
471 marek 1.2.2.5 {
472 SCMOXmlWriter::appendValueSCMOInstanceElement(
473 out,
474 _scmoInstances[i]);
475 }
476 break;
477 }
478 case RESP_OBJECTS:
479 {
480 for (Uint32 i = 0; i < _scmoInstances.size(); i++)
481 {
482 SCMOXmlWriter::appendValueObjectWithPathElement(
483 out,
484 _scmoInstances[i]);
485 }
486 break;
487 }
488 case RESP_OBJECTPATHS:
489 {
|
490 marek 1.2.2.7 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
491 {
492 out << "<OBJECTPATH>\n";
493 SCMOXmlWriter::appendValueReferenceElement(
494 out,
495 _scmoInstances[i],
496 false);
497 out << "</OBJECTPATH>\n";
498 }
|
499 marek 1.2.2.5 break;
500 }
501 default:
502 {
503 // TODO:
504 // Argl, not nice, but not a problem yet, ignore this
505 }
|
506 r.kieninger 1.2 }
|
507 r.kieninger 1.1 }
|
508 marek 1.2.2.6 fprintf(
509 stderr,
510 "After XmlWrite()\n%s",
511 out.getData());
512 fflush(stderr);
|
513 marek 1.2.2.5 }
|
514 r.kieninger 1.1
|
515 marek 1.2.2.5 // contrary to encodeXmlResponse this function encodes the Xml in a format
516 // not usable by clients
517 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
518 {
519 // TODO: Implement
520 // Need the full switch here again
521 // Should use the internal data available SCMO, C++ and InternalXML
522 // to generate the InternalXML by CIMInternalEncoder and SCMOInternalEncoder
523 fprintf(stderr, "Watch wat ya do'n! SCMO to InternalXml ? NO OOP yet.\n");
524 fflush(stderr);
525 }
|
526 r.kieninger 1.1
|
527 marek 1.2.2.5 void CIMResponseData::_resolveToCIM()
|
528 r.kieninger 1.1 {
|
529 marek 1.2.2.5 fprintf(
530 stderr,
531 "_resolveToCIM(encoding=%X,content=%X)\n",
532 _encoding,
533 _dataType);
534 fflush(stderr);
|
535 r.kieninger 1.1
|
536 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
537 r.kieninger 1.1 {
|
538 marek 1.2.2.5 _resolveXmlToCIM();
|
539 r.kieninger 1.1 }
|
540 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
541 r.kieninger 1.1 {
|
542 marek 1.2.2.5 _resolveBinary();
|
543 r.kieninger 1.1 }
|
544 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
545 r.kieninger 1.1 {
|
546 marek 1.2.2.5 _resolveSCMOToCIM();
|
547 r.kieninger 1.1 }
|
548 marek 1.2.2.5 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
549 }
|
550 r.kieninger 1.1
|
551 marek 1.2.2.5 void CIMResponseData::_resolveToSCMO()
552 {
553 fprintf(
554 stderr,
555 "_resolveToSCMO(encoding=%X,content=%X)\n",
556 _encoding,
557 _dataType);
558 fflush(stderr);
|
559 marek 1.2.2.6
|
560 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
561 r.kieninger 1.1 {
|
562 marek 1.2.2.5 _resolveXmlToSCMO();
|
563 r.kieninger 1.1 }
|
564 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
565 r.kieninger 1.1 {
|
566 marek 1.2.2.5 _resolveBinary();
|
567 r.kieninger 1.1 }
|
568 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
569 r.kieninger 1.1 {
|
570 marek 1.2.2.5 _resolveCIMToSCMO();
|
571 r.kieninger 1.1 }
|
572 marek 1.2.2.5 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
|
573 r.kieninger 1.1 }
574
|
575 marek 1.2.2.5 // helper functions to transform different formats into one-another
576 // functions work on the internal data and calling of them should be
577 // avoided whenever possible
578 void CIMResponseData::_resolveBinary()
|
579 r.kieninger 1.1 {
|
580 marek 1.2.2.5 // Call magic here to resolve binary format
581 fprintf(stderr, "Watch wat ya do'n! binary ? NO OOP yet.\n");
582 fflush(stderr);
|
583 r.kieninger 1.1
|
584 marek 1.2.2.5 switch (_dataType)
|
585 r.kieninger 1.1 {
|
586 marek 1.2.2.5 case RESP_INSTNAMES:
587 {
588 break;
589 }
590 case RESP_INSTANCE:
591 {
592 break;
593 }
594 case RESP_INSTANCES:
595 {
596 break;
597 }
598 case RESP_OBJECTS:
599 {
600 break;
601 }
602 case RESP_OBJECTPATHS:
603 {
604 break;
605 }
606 default:
607 marek 1.2.2.5 {
608 // TODO:
609 // Argl, not nice, but not a problem yet, ignore this
610 }
|
611 r.kieninger 1.1 }
612 }
613
|
614 marek 1.2.2.5 void CIMResponseData::_resolveXmlToCIM()
|
615 r.kieninger 1.1 {
|
616 marek 1.2.2.5 switch (_dataType)
617 {
618 case RESP_INSTNAMES:
619 {
620 for (Uint32 i = 0; i < _referencesData.size(); i++)
621 {
622 CIMObjectPath cop;
623 // Deserialize path:
624 {
625 XmlParser parser((char*)_referencesData[i].getData());
626
627 if (XmlReader::getInstanceNameElement(parser, cop))
628 {
629 if (!_nameSpacesData[i].isNull())
630 cop.setNameSpace(_nameSpacesData[i]);
631
632 if (_hostsData[i].size())
633 cop.setHost(_hostsData[i]);
634 }
635 }
636 _instanceNames.append(cop);
637 marek 1.2.2.5 }
638 break;
639 }
640 case RESP_INSTANCE:
641 {
642 CIMInstance cimInstance;
643 // Deserialize instance:
644 {
645 XmlParser parser((char*)_instanceData[0].getData());
|
646 r.kieninger 1.1
|
647 marek 1.2.2.5 if (!XmlReader::getInstanceElement(parser, cimInstance))
648 {
649 cimInstance = CIMInstance();
650 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
651 "Failed to resolve XML instance, parser error!");
652 }
653 }
654 // Deserialize path:
655 {
656 XmlParser parser((char*)_referencesData[0].getData());
657 CIMObjectPath cimObjectPath;
|
658 r.kieninger 1.1
|
659 marek 1.2.2.5 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
660 {
661 if (_hostsData.size())
662 {
663 cimObjectPath.setHost(_hostsData[0]);
664 }
665 if (!_nameSpacesData[0].isNull())
666 {
667 cimObjectPath.setNameSpace(_nameSpacesData[0]);
668 }
669 cimInstance.setPath(cimObjectPath);
670 // only if everything works we add the CIMInstance to the
671 // array
672 _instances.append(cimInstance);
673 }
674 }
675 break;
676 }
677 case RESP_INSTANCES:
678 {
679 for (Uint32 i = 0; i < _instanceData.size(); i++)
680 marek 1.2.2.5 {
681 CIMInstance cimInstance;
682 // Deserialize instance:
683 {
684 XmlParser parser((char*)_instanceData[i].getData());
685
686 if (!XmlReader::getInstanceElement(parser, cimInstance))
687 {
688 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
689 "Failed to resolve XML instance."
690 " Creating empty instance!");
691 cimInstance = CIMInstance();
692 }
693 }
694
695 // Deserialize path:
696 {
697 XmlParser parser((char*)_referencesData[i].getData());
698 CIMObjectPath cimObjectPath;
699
700 if (XmlReader::getInstanceNameElement(parser,cimObjectPath))
701 marek 1.2.2.5 {
702 if (!_nameSpacesData[i].isNull())
703 cimObjectPath.setNameSpace(_nameSpacesData[i]);
704
705 if (_hostsData[i].size())
706 cimObjectPath.setHost(_hostsData[i]);
707
708 cimInstance.setPath(cimObjectPath);
709 }
710 }
|
711 r.kieninger 1.1
|
712 marek 1.2.2.5 _instances.append(cimInstance);
713 }
714 break;
715 }
716 case RESP_OBJECTS:
717 {
718 for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
719 {
720 CIMObject cimObject;
721
722 // Deserialize Objects:
723 {
724 XmlParser parser((char*)_instanceData[i].getData());
725
726 CIMInstance cimInstance;
727 CIMClass cimClass;
728
729 if (XmlReader::getInstanceElement(parser, cimInstance))
730 {
731 cimObject = CIMObject(cimInstance);
732 }
733 marek 1.2.2.5 else if (XmlReader::getClassElement(parser, cimClass))
734 {
735 cimObject = CIMObject(cimClass);
736 }
737 else
738 {
739 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
740 "Failed to get XML object data!");
741 }
742 }
743
744 // Deserialize paths:
745 {
746 XmlParser parser((char*)_referencesData[i].getData());
747 CIMObjectPath cimObjectPath;
748
749 if (XmlReader::getValueReferenceElement(
750 parser,
751 cimObjectPath))
752 {
753 if (!_nameSpacesData[i].isNull())
754 marek 1.2.2.5 cimObjectPath.setNameSpace(_nameSpacesData[i]);
755
756 if (_hostsData[i].size())
757 cimObjectPath.setHost(_hostsData[i]);
758
759 cimObject.setPath(cimObjectPath);
760 }
761 }
762 _objects.append(cimObject);
763 }
764 break;
765 }
766 case RESP_OBJECTPATHS:
767 {
768 // TODO: ????
769 }
770 default:
771 {
772 // TODO:
773 // Argl, not nice, but not a problem yet, ignore this
774 }
775 marek 1.2.2.5 }
776 // Xml was resolved, release Xml content now
777 _referencesData.clear();
778 _hostsData.clear();
779 _nameSpacesData.clear();
780 _instanceData.clear();
781 // remove Xml Encoding flag
782 _encoding &=(!RESP_ENC_XML);
783 // add CIM Encoding flag
784 _encoding |=RESP_ENC_CIM;
|
785 r.kieninger 1.1 }
786
|
787 marek 1.2.2.5 void CIMResponseData::_resolveXmlToSCMO()
|
788 r.kieninger 1.2.2.4 {
|
789 marek 1.2.2.5 // Not optimal, can probably be improved
790 // but on the other hand, since using the binary format this case should
791 // actually not ever happen.
792 _resolveXmlToCIM();
793 _resolveCIMToSCMO();
794 }
|
795 r.kieninger 1.2.2.4
|
796 marek 1.2.2.5 void CIMResponseData::_resolveSCMOToCIM()
797 {
798 switch(_dataType)
|
799 r.kieninger 1.2.2.4 {
|
800 marek 1.2.2.5 case RESP_INSTNAMES:
801 case RESP_OBJECTPATHS:
|
802 r.kieninger 1.1 {
|
803 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
804 {
805 CIMObjectPath newObjectPath;
806 _scmoInstances[x].getCIMObjectPath(newObjectPath);
807 _instanceNames.append(newObjectPath);
808 }
809 break;
|
810 r.kieninger 1.1 }
|
811 marek 1.2.2.5 case RESP_INSTANCE:
|
812 r.kieninger 1.1 {
|
813 marek 1.2.2.5 CIMInstance newInstance;
814 _scmoInstances[0].getCIMInstance(newInstance);
815 _instances.append(newInstance);
816 break;
|
817 marek 1.2.2.2 }
|
818 marek 1.2.2.5 case RESP_INSTANCES:
|
819 r.kieninger 1.2 {
|
820 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
821 r.kieninger 1.1 {
|
822 marek 1.2.2.5 CIMInstance newInstance;
823 _scmoInstances[x].getCIMInstance(newInstance);
824 _instances.append(newInstance);
|
825 r.kieninger 1.1 }
|
826 marek 1.2.2.5 break;
|
827 r.kieninger 1.1 }
|
828 marek 1.2.2.5 case RESP_OBJECTS:
|
829 r.kieninger 1.1 {
|
830 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
831 r.kieninger 1.1 {
|
832 marek 1.2.2.5 CIMInstance newInstance;
833 _scmoInstances[x].getCIMInstance(newInstance);
834 _objects.append(CIMObject(newInstance));
|
835 r.kieninger 1.1 }
|
836 marek 1.2.2.5 break;
|
837 r.kieninger 1.1 }
|
838 marek 1.2.2.5 default:
|
839 r.kieninger 1.2.2.1 {
|
840 marek 1.2.2.5 // TODO:
841 // Argl, not nice, but not a problem yet, ignore this
|
842 r.kieninger 1.2.2.1 }
843 }
844
|
845 marek 1.2.2.5 _scmoInstances.clear();
846 // remove CIM Encoding flag
847 _encoding &=(!RESP_ENC_SCMO);
848 // add SCMO Encoding flag
849 _encoding |=RESP_ENC_CIM;
|
850 r.kieninger 1.2.2.1 }
851
|
852 marek 1.2.2.5 void CIMResponseData::_resolveCIMToSCMO()
|
853 r.kieninger 1.1 {
|
854 marek 1.2.2.5 switch (_dataType)
|
855 r.kieninger 1.2 {
|
856 marek 1.2.2.5 case RESP_INSTNAMES:
857 case RESP_OBJECTPATHS:
|
858 r.kieninger 1.2 {
|
859 marek 1.2.2.5 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
860 {
861 SCMOInstance addme =
862 _getSCMOFromCIMObjectPath(_instanceNames[i]);
863 _scmoInstances.append(addme);
864 }
865 break;
|
866 r.kieninger 1.2 }
|
867 marek 1.2.2.5 case RESP_INSTANCE:
|
868 r.kieninger 1.1 {
|
869 marek 1.2.2.5 SCMOInstance addme =
870 _getSCMOFromCIMInstance(_instances[0]);
871 _scmoInstances.append(addme);
872 break;
|
873 r.kieninger 1.1 }
|
874 marek 1.2.2.5 case RESP_INSTANCES:
|
875 r.kieninger 1.1 {
|
876 marek 1.2.2.5 for (Uint32 i=0,n=_instances.size();i<n;i++)
877 {
878 SCMOInstance addme =
879 _getSCMOFromCIMInstance(_instances[i]);
880 _scmoInstances.append(addme);
881 }
882 break;
|
883 r.kieninger 1.1 }
|
884 marek 1.2.2.5 case RESP_OBJECTS:
|
885 r.kieninger 1.1 {
|
886 marek 1.2.2.5 // TODO: Implement, but how ???
887 break;
|
888 r.kieninger 1.1 }
|
889 marek 1.2.2.5 default:
|
890 r.kieninger 1.1 {
|
891 marek 1.2.2.5 // TODO:
892 // Argl, not nice, but not a problem yet, ignore this
893 break;
|
894 r.kieninger 1.1 }
895 }
896
|
897 marek 1.2.2.5 // remove CIM Encoding flag
898 _encoding &=(!RESP_ENC_CIM);
899 // add SCMO Encoding flag
900 _encoding |=RESP_ENC_SCMO;
|
901 r.kieninger 1.1 }
902
|
903 marek 1.2.2.5
904 // Function to convert a CIMInstance into an SCMOInstance
905 SCMOInstance CIMResponseData::_getSCMOFromCIMInstance(
906 const CIMInstance& cimInst)
|
907 r.kieninger 1.1 {
|
908 marek 1.2.2.5 const CIMObjectPath& cimPath = cimInst.getPath();
|
909 r.kieninger 1.1
|
910 marek 1.2.2.5 const CString nameSpace = cimPath.getNameSpace().getString().getCString();
911 const CString className = cimPath.getClassName().getString().getCString();
912 // TODO: What do when either or both are 0 ?
|
913 r.kieninger 1.1
|
914 marek 1.2.2.5 SCMOClass * scmoClass = _getSCMOClass(
915 (const char*)nameSpace,
916 (const char*)className);
917 // TODO: What do when there is no such class ?
|
918 r.kieninger 1.1
|
919 marek 1.2.2.5 // TODO: Interrogate Thilo about need to call new
920 SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst);
|
921 r.kieninger 1.1
|
922 marek 1.2.2.5 return scmoInst;
|
923 r.kieninger 1.1 }
924
|
925 marek 1.2.2.5 // Function to convert a CIMObjectPath into an SCMOInstance
926 SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath(
927 const CIMObjectPath& cimPath)
|
928 r.kieninger 1.1 {
|
929 marek 1.2.2.5 CString nameSpace = cimPath.getNameSpace().getString().getCString();
930 CString className = cimPath.getClassName().getString().getCString();
|
931 r.kieninger 1.1
|
932 marek 1.2.2.5 // TODO: What do when either or both are 0 ?
|
933 r.kieninger 1.1
|
934 marek 1.2.2.5 SCMOClass * scmoClass = _getSCMOClass(
935 (const char*)nameSpace,
936 (const char*)className);
|
937 r.kieninger 1.1
|
938 marek 1.2.2.5 // TODO: What do when there is no such class ?
|
939 r.kieninger 1.1
|
940 marek 1.2.2.5 // TODO: Interrogate Thilo about need to call new
941 SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);
|
942 r.kieninger 1.1
|
943 marek 1.2.2.5 return scmoRef;
|
944 r.kieninger 1.1 }
945
|
946 marek 1.2.2.5 SCMOClass* CIMResponseData::_getSCMOClass(
947 const char* nameSpace,
948 const char* cls)
|
949 r.kieninger 1.1 {
|
950 marek 1.2.2.5 SCMOClassCache* local = SCMOClassCache::getInstance();
951 return local->getSCMOClass(
952 nameSpace,
953 strlen(nameSpace),
954 cls,
955 strlen(cls));
|
956 r.kieninger 1.1 }
957
958 PEGASUS_NAMESPACE_END
|
Return to
CIMResponseData.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common