Package pywbem :: Module cim_xml
[frames] | no frames]

Source Code for Module pywbem.cim_xml

   1  # 
   2  # (C) Copyright 2003-2006 Hewlett-Packard Development Company, L.P. 
   3  # (C) Copyright 2006-2007 Novell, Inc. 
   4  # 
   5  # This library is free software; you can redistribute it and/or 
   6  # modify it under the terms of the GNU Lesser General Public 
   7  # License as published by the Free Software Foundation; either 
   8  # version 2.1 of the License, or (at your option) any later version. 
   9  # 
  10  # This program is distributed in the hope that it will be useful, but 
  11  # WITHOUT ANY WARRANTY; without even the implied warranty of 
  12  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
  13  # Lesser General Public License for more details. 
  14  # 
  15  # You should have received a copy of the GNU Lesser General Public 
  16  # License along with this program; if not, write to the Free Software 
  17  # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
  18  # 
  19  # Author: Tim Potter <tpot@hp.com> 
  20  # Author: Bart Whiteley <bwhiteley@suse.de> 
  21  # 
  22   
  23  """ 
  24   
  25  Functions to create XML documens and elements conforming to the DMTF 
  26  standard DSP0201, Representation of CIM in XML, v2.2. 
  27   
  28    http://www.dmtf.org/standards/wbem/DSP201.html 
  29    http://www.dmtf.org/standards/published_documents/DSP201.pdf 
  30   
  31  Elements generated by this module should conform to version 2.2 of the 
  32  DTD: 
  33   
  34    http://www.dmtf.org/standards/wbem/CIM_DTD_V22.dtd 
  35   
  36  There should be one class for each element described in the DTD.  The 
  37  constructors take builtin Python types, or other cim_xml classes where 
  38  child elements are required. 
  39   
  40  Every class is a subclass of the Element class and so shares the same 
  41  attributes and methods, and can be used with the built-in Python XML 
  42  handling routines.  In particular you can call the toxml() and 
  43  toprettyxml() methods to generate XML. 
  44   
  45  Note that converting using toprettyxml() inserts whitespace which may 
  46  corrupt the data in the XML (!!) so you should only do this when 
  47  displaying to humans who can ignore it, and never for computers.  XML 
  48  always passes through all non-markup whitespace. 
  49   
  50  """ 
  51   
  52  import sys 
  53  import xml.dom.minidom 
  54  from xml.dom.minidom import Element 
  55   
  56  __all__ = ['CIMElement', 'CIM', 'DECLARATION', 'DECLGROUP', 
  57             'DECLGROUP_WITHNAME', 'DECLGROUP_WITHPATH', 'QUALIFIER_DECLARATION', 
  58             'SCOPE', 'VALUE', 'VALUE_ARRAY', 'VALUE_REFERENCE', 
  59             'VALUE_REFARRAY', 'VALUE_OBJECT', 'VALUE_NAMEDINSTANCE', 
  60             'VALUE_NAMEDOBJECT', 'VALUE_OBJECTWITHLOCALPATH', 
  61             'VALUE_OBJECTWITHPATH', 'VALUE_NULL', 'NAMESPACEPATH', 
  62             'LOCALNAMESPACEPATH', 'HOST', 'NAMESPACE', 'CLASSPATH', 
  63             'LOCALCLASSPATH', 'CLASSNAME', 'INSTANCEPATH', 'LOCALINSTANCEPATH', 
  64             'INSTANCENAME', 'OBJECTPATH', 'KEYBINDING', 'KEYVALUE', 'CLASS', 
  65             'INSTANCE', 'QUALIFIER', 'PROPERTY', 'PROPERTY_ARRAY', 
  66             'PROPERTY_REFERENCE', 'METHOD', 'PARAMETER', 'PARAMETER_REFERENCE', 
  67             'PARAMETER_ARRAY', 'PARAMETER_REFARRAY', 
  68             'TABLECELL_DECLARATION', 'TABLECELL_REFERENCE', 
  69             'TABLEROW_DECLARATION', 'TABLE','TABLEROW', 
  70             'MESSAGE', 'MULTIREQ', 'MULTIEXPREQ', 'SIMPLEREQ', 'SIMPLEEXPREQ', 
  71             'IMETHODCALL', 'METHODCALL', 'EXPMETHODCALL', 'PARAMVALUE', 
  72             'IPARAMVALUE', 'EXPPARAMVALUE', 'MULTIRSP', 'MULTIEXPRSP', 
  73             'SIMPLERSP', 'SIMPLEEXPRSP', 'METHODRESPONSE', 'EXPMETHODRESPONSE', 
  74             'IMETHODRESPONSE', 'ERROR', 'RETURNVALUE', 'IRETURNVALUE', 
  75             'RESPONSEDESTINATION', 'SIMPLEREQACK'] 
  76   
77 -def _text(data):
78 """Return a minidom text node with the specified data string. 79 80 When converting that node to an XML string using ``toxml()``, XML-escaping 81 will be applied if needed (for example, ``_text('&').toxml() = '&amp;'``). 82 83 Note: The API for the minidom text node function has changed in 84 Python 2.3. The code for older Python versions has been removed from this 85 function in PyWBEM 0.8.0; the Python version check is now done in 86 __init__.py. 87 """ 88 89 # The following initialization approach requires Python 2.3 or higher. 90 t = xml.dom.minidom.Text() 91 t.data = data 92 93 return t
94 95 # Switch controlling whether the escaping of special XML characters in any 96 # request messages sent to the WBEM server will be done using CDATA 97 # sections (if True), or using XML entity references (e.g. &amp;) (if 98 # False). 99 # Using XML-based escaping generates a simpler CIM-XML payload. 100 # Standards-conforming WBEM servers need to support both ways. 101 # You only need to set this to True if the WBEM server has no support for 102 # XML-based escaping, but does have support for CDATA-based escaping. 103 _CDATA_ESCAPING = False 104
105 -def _pcdata_nodes(pcdata):
106 """Return a list of minidom nodes with the properly escaped ``pcdata`` 107 inside. 108 109 The following special XML characters are escaped: 110 * left angle bracket (<) 111 * Right angle bracket (>) 112 * Ampersand (&) 113 114 By default, XML-based escaping is used for these characters. XML-based 115 escaping will cause the corresponding XML entity references to be used 116 (for example, the ampersand character ``&`` will be represented as 117 ``&amp;``, and the returned list contains one text node with the escaped 118 pcdata string. 119 120 Nesting of escaped pcdata is naturally supported with XML-based escaping. 121 For example, if the pcdata string is ``a&amp;b``, the XML-escaped string 122 will be ``a&amp;amp;b``. 123 124 If the ``cim_xml._CDATA_ESCAPING`` switch is set to True, CDATA-based 125 escaping is used instead. CDATA-based escaping will cause a CDATA section 126 to be used for the entire string, or consecutive CDATA sequences (see 127 discussion of nesting, below). The returned node list contains only CDATA 128 section nodes. Example: The pcdata string ``a<b>c`` will become 129 ``<![CDATA[a<b>]]>``, allowing the special XML characters to be used 130 unchanged inside of the CDATA section. 131 132 Nesting of escaped pcdata is supported with CDATA-based escaping, by using 133 the following approach: If the input pcdata string already contains CDATA 134 sections, they are split into separate strings, splitting the CDATA end 135 token string in the middle, and these part strings are CDATA-escaped 136 separately. See http://en.wikipedia.org/wiki/CDATA#Nesting for details. 137 138 Escaping of already escaped pcdata is needed in support of nested embedded 139 instances. That requires that each level of escaping can lateron be 140 unescaped, one at a time. 141 """ 142 143 nodelist = [] 144 145 if _CDATA_ESCAPING and type(pcdata) in (str,unicode) and \ 146 (pcdata.find("<") >= 0 or \ 147 pcdata.find(">") >= 0 or \ 148 pcdata.find("&") >= 0): 149 150 # In order to support nesting of CDATA sections, we represent pcdata 151 # that already contains CDATA sections by multiple new CDATA sections 152 # whose boundaries split the end marker of the already existing CDATA 153 # sections. 154 155 pcdata_part_list = pcdata.split("]]>") 156 # ']]>' is the complete CDATA section end marker 157 158 i = 0 159 for pcdata_part in pcdata_part_list: 160 i += 1 161 162 left = "" if i == 1 else "]>" 163 # ']>' is right part of CDATA section end marker 164 165 right = "" if i == len(pcdata_part_list) else "]" 166 # "]" is left part of CDATA section end marker 167 168 # The following initialization approach requires Python 2.3 or 169 # higher. 170 node = xml.dom.minidom.CDATASection() 171 node.data = left + pcdata_part + right 172 173 nodelist.append(node) 174 175 else: 176 177 # The following automatically uses XML entity references for escaping. 178 node = _text(pcdata) 179 180 nodelist.append(node) 181 182 return nodelist
183
184 -class CIMElement(Element):
185 """A base class that has a few bonus helper methods.""" 186
187 - def setName(self, name):
188 """Set the NAME attribute of the element.""" 189 self.setAttribute('NAME', name)
190
191 - def setOptionalAttribute(self, name, value):
192 """Set an attribute if the value parameter is not None.""" 193 if value is not None: 194 self.setAttribute(name, value)
195
196 - def appendOptionalChild(self, child):
197 """Append a child element which can be None.""" 198 if child is not None: 199 self.appendChild(child)
200
201 - def appendChildren(self, children):
202 """Append a list or tuple of children.""" 203 [self.appendChild(child) for child in children]
204 205 # Root element 206
207 -class CIM(CIMElement):
208 """ 209 The CIM element is the root element of every XML Document that is 210 valid with respect to this schema. 211 212 Each document takes one of two forms; it either contains a single 213 MESSAGE element defining a CIM message (to be used in the HTTP 214 mapping), or it contains a DECLARATION element used to declare a 215 set of CIM objects. 216 217 <!ELEMENT CIM (MESSAGE | DECLARATION)> 218 <!ATTLIST CIM 219 CIMVERSION CDATA #REQUIRED 220 DTDVERSION CDATA #REQUIRED> 221 """ 222
223 - def __init__(self, data, cim_version, dtd_version):
224 Element.__init__(self, 'CIM') 225 self.setAttribute('CIMVERSION', cim_version) 226 self.setAttribute('DTDVERSION', dtd_version) 227 self.appendChild(data)
228 229 # Object declaration elements 230
231 -class DECLARATION(CIMElement):
232 """ 233 The DECLARATION element defines a set of one or more declarations 234 of CIM objects. These are partitioned into logical declaration 235 subsets. 236 237 <!ELEMENT DECLARATION (DECLGROUP | DECLGROUP.WITHNAME | 238 DECLGROUP.WITHPATH)+> 239 """ 240
241 - def __init__(self, data):
242 Element.__init__(self, 'DECLARATION') 243 self.appendChildren(data)
244
245 -class DECLGROUP(CIMElement):
246 """ 247 The DECLGROUP element defines a logical set of CIM Class, Instance 248 and Qualifier declarations. It MAY optionally include a 249 NAMESPACEPATH or LOCALNAMESPACEPATH element which, if present, 250 defines the common namespace in which all objects within the group 251 are declared. 252 253 <!ELEMENT DECLGROUP ((LOCALNAMESPACEPATH | NAMESPACEPATH)?, 254 QUALIFIER.DECLARATION*, VALUE.OBJECT*)> 255 """ 256
257 - def __init__(self, data):
258 Element.__init__(self, 'DECLGROUP') 259 self.appendChildren(data)
260
261 -class DECLGROUP_WITHNAME(CIMElement):
262 # pylint: disable=invalid-name 263 """ 264 The DECLGROUP.WITHNAME element defines a logical set of CIM Class, 265 Instance and Qualifier declarations. It MAY optionally include a 266 NAMESPACEPATH or LOCALNAMESPACEPATH element which, if present, 267 defines the common namespace in which all objects within the group 268 are declared. 269 270 <!ELEMENT DECLGROUP.WITHNAME ((LOCALNAMESPACEPATH | NAMESPACEPATH)?, 271 QUALIFIER.DECLARATION*, VALUE.NAMEDOBJECT*)> 272 """ 273
274 - def __init__(self, data):
275 Element.__init__(self, 'DECLGROUP.WITHNAME') 276 self.appendChildren(data)
277
278 -class DECLGROUP_WITHPATH(CIMElement):
279 # pylint: disable=invalid-name 280 """ 281 The DECLGROUP.WITHPATH element defines a logical set of CIM Class 282 and Instance declarations. Each object is declared with its own 283 independent naming and location information. 284 285 <!ELEMENT DECLGROUP.WITHPATH (VALUE.OBJECTWITHPATH | 286 VALUE.OBJECTWITHLOCALPATH)*> 287 """ 288
289 - def __init__(self, data):
290 Element.__init__(self, 'DECLGROUP.WITHPATH') 291 self.appendChildren(data)
292
293 -class QUALIFIER_DECLARATION(CIMElement):
294 # pylint: disable=invalid-name 295 """ 296 The QUALIFIER.DECLARATION element defines a single CIM Qualifier 297 declaration. 298 299 <!ELEMENT QUALIFIER.DECLARATION (SCOPE?, (VALUE | VALUE.ARRAY)?)> 300 <!ATTLIST QUALIFIER.DECLARATION 301 %CIMName; 302 %CIMType; #REQUIRED 303 ISARRAY (true|false) #IMPLIED 304 %ArraySize; 305 %QualifierFlavor;> 306 """ 307
308 - def __init__(self, name, type, value, is_array=None, 309 array_size=None, qualifier_scopes={}, 310 overridable=None, tosubclass=None, 311 toinstance=None, translatable=None):
312 313 Element.__init__(self, 'QUALIFIER.DECLARATION') 314 self.setName(name) 315 self.setAttribute('TYPE', type) 316 if is_array is not None: 317 self.setOptionalAttribute('ISARRAY', str(is_array).lower()) 318 if array_size is not None: 319 self.setAttribute('ARRAYSIZE', str(array_size)) 320 if overridable is not None: 321 self.setAttribute('OVERRIDABLE', str(overridable).lower()) 322 if tosubclass is not None: 323 self.setAttribute('TOSUBCLASS', str(tosubclass).lower()) 324 if toinstance is not None: 325 self.setAttribute('TOINSTANCE', str(toinstance).lower()) 326 if translatable is not None: 327 self.setAttribute('TRANSLATABLE', str(translatable).lower()) 328 329 if qualifier_scopes: 330 scope = SCOPE(qualifier_scopes) 331 self.appendOptionalChild(scope) 332 if value is not None: 333 if is_array: 334 xval = VALUE_ARRAY(value) 335 else: 336 xval = VALUE(value) 337 self.appendOptionalChild(xval)
338
339 -class SCOPE(CIMElement):
340 """ 341 The SCOPE element defines the scope of a QUALIFIER.DECLARATION in 342 the case that there are restrictions on the scope of the Qualifier 343 declaration. 344 345 <!ELEMENT SCOPE EMPTY> 346 <!ATTLIST SCOPE 347 CLASS (true|false) 'false' 348 ASSOCIATION (true|false) 'false' 349 REFERENCE (true|false) 'false' 350 PROPERTY (true|false) 'false' 351 METHOD (true|false) 'false' 352 PARAMETER (true|false) 'false' 353 INDICATION (true|false) 'false'> 354 """ 355
356 - def __init__(self, scopes={}):
357 Element.__init__(self, 'SCOPE') 358 if 'any' in scopes and scopes['any']: 359 scopes = {'CLASS': True, 360 'ASSOCIATION': True, 361 'REFERENCE': True, 362 'PROPERTY': True, 363 'METHOD': True, 364 'PARAMETER': True, 365 'INDICATION': True} 366 for k, v in scopes.items(): 367 self.setOptionalAttribute(k, str(v).lower())
368 369 # Object value elements 370
371 -class VALUE(CIMElement):
372 """ 373 The VALUE element is used to define a single (non-array and 374 non-reference) CIM Property value, CIM Qualifier value, or a CIM 375 Method Parameter value. 376 377 <!ELEMENT VALUE (#PCDATA)> 378 """ 379
380 - def __init__(self, pcdata):
381 Element.__init__(self, 'VALUE') 382 if pcdata is not None: 383 self.appendChildren(_pcdata_nodes(pcdata))
384
385 -class VALUE_ARRAY(CIMElement):
386 # pylint: disable=invalid-name 387 """ 388 The VALUE.ARRAY element is used to represent the value of a CIM 389 Property or Qualifier that has an array type. 390 391 <!ELEMENT VALUE.ARRAY (VALUE*)> 392 """ 393
394 - def __init__(self, values):
395 Element.__init__(self, 'VALUE.ARRAY') 396 self.appendChildren(values)
397
398 -class VALUE_REFERENCE(CIMElement):
399 # pylint: disable=invalid-name 400 """ 401 The VALUE.REFERENCE element is used to define a single CIM 402 reference Property value. 403 404 <!ELEMENT VALUE.REFERENCE (CLASSPATH | LOCALCLASSPATH | CLASSNAME | 405 INSTANCEPATH | LOCALINSTANCEPATH | 406 INSTANCENAME)> 407 """ 408
409 - def __init__(self, data):
410 Element.__init__(self, 'VALUE.REFERENCE') 411 self.appendChild(data)
412
413 -class VALUE_REFARRAY(CIMElement):
414 # pylint: disable=invalid-name 415 """ 416 The VALUE.REFARRAY element is used to represent the value of an 417 array of CIM references. 418 419 <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)> 420 """ 421
422 - def __init__(self, data):
423 Element.__init__(self, 'VALUE.REFARRAY') 424 self.appendChildren(data)
425
426 -class VALUE_OBJECT(CIMElement):
427 # pylint: disable=invalid-name 428 """ 429 The VALUE.OBJECT element is used to define a value which is 430 comprised of a single CIM Class or Instance definition. 431 432 <!ELEMENT VALUE.OBJECT (CLASS | INSTANCE)> 433 """ 434
435 - def __init__(self, data):
436 Element.__init__(self, 'VALUE.OBJECT') 437 self.appendChild(data)
438
439 -class VALUE_NAMEDINSTANCE(CIMElement):
440 # pylint: disable=invalid-name 441 """ 442 The VALUE.NAMEDINSTANCE element is used to define a value which 443 is comprised of a single named CIM Instance definition. 444 445 <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME, INSTANCE)> 446 """ 447
448 - def __init__(self, instancename, instance):
449 Element.__init__(self, 'VALUE.NAMEDINSTANCE') 450 self.appendChild(instancename) 451 self.appendChild(instance)
452
453 -class VALUE_NAMEDOBJECT(CIMElement):
454 # pylint: disable=invalid-name 455 """ 456 The VALUE.NAMEDOBJECT element is used to define a value which 457 is comprised of a single named CIM Class or Instance definition. 458 459 <!ELEMENT VALUE.NAMEDOBJECT (CLASS | (INSTANCENAME, INSTANCE))> 460 """ 461
462 - def __init__(self, data):
463 Element.__init__(self, 'VALUE.NAMEDOBJECT') 464 if type(data) == tuple or type(data) == list: 465 self.appendChildren(data) 466 else: 467 self.appendChild(data)
468
469 -class VALUE_OBJECTWITHLOCALPATH(CIMElement):
470 # pylint: disable=invalid-name 471 """ 472 The VALUE.OBJECTWITHLOCALPATH element is used to define a value 473 which is comprised of a single CIM Object (Class or Instance) 474 definition with additional information that defines the local path 475 to that Object. 476 477 <!ELEMENT VALUE.OBJECTWITHLOCALPATH ((LOCALCLASSPATH, CLASS) | 478 (LOCALINSTANCEPATH, INSTANCE))> 479 """ 480
481 - def __init__(self, data1, data2):
482 Element.__init__(self, 'VALUE.OBJECTWITHLOCALPATH') 483 self.appendChild(data1) 484 self.appendChild(data2)
485
486 -class VALUE_OBJECTWITHPATH(CIMElement):
487 # pylint: disable=invalid-name 488 """ 489 The VALUE.OBJECTWITHPATH element is used to define a value 490 which is comprised of a single CIM Object (Class or Instance) 491 definition with additional information that defines the absolute 492 path to that Object. 493 494 <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH, CLASS) | 495 (INSTANCEPATH, INSTANCE))> 496 """ 497
498 - def __init__(self, data1, data2):
499 Element.__init__(self, 'VALUE.OBJECTWITHPATH') 500 self.appendChild(data1) 501 self.appendChild(data2)
502
503 -class VALUE_NULL(CIMElement):
504 # pylint: disable=invalid-name 505 """ 506 The VALUE.NULL element is used to represent a TABLECELL that has 507 no assigned value. 508 509 <!ELEMENT VALUE.NULL EMPTY> 510 """ 511
512 - def __init__(self):
513 Element.__init__(self, 'VALUE.NULL')
514 515 # Object naming and location elements 516
517 -class NAMESPACEPATH(CIMElement):
518 # pylint: disable=invalid-name 519 """ 520 The NAMESPACEPATH element is used to define a Namespace Path. It 521 consists of a HOST element and a LOCALNAMESPACE element. 522 523 <!ELEMENT NAMESPACEPATH (HOST, LOCALNAMESPACEPATH)> 524 """ 525
526 - def __init__(self, host, localnamespacepath):
527 Element.__init__(self, 'NAMESPACEPATH') 528 self.appendChild(host) 529 self.appendChild(localnamespacepath)
530
531 -class LOCALNAMESPACEPATH(CIMElement):
532 # pylint: disable=invalid-name 533 """ 534 The LOCALNAMESPACEPATH element is used to define a local Namespace 535 path (one without a Host component). It consists of one or more 536 NAMESPACE elements (one for each namespace in the path). 537 538 <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)> 539 """ 540
541 - def __init__(self, namespaces):
542 Element.__init__(self, 'LOCALNAMESPACEPATH') 543 self.appendChildren(namespaces)
544
545 -class HOST(CIMElement):
546 # pylint: disable=invalid-name 547 """ 548 The HOST element is used to define a single Host. The element 549 content MUST specify a legal value for a hostname in accordance 550 with the CIM specification. 551 552 <!ELEMENT HOST (#PCDATA)> 553 """ 554
555 - def __init__(self, pcdata):
556 Element.__init__(self, 'HOST') 557 self.appendChild(_text(pcdata))
558
559 -class NAMESPACE(CIMElement):
560 # pylint: disable=invalid-name 561 """ 562 The NAMESPACE element is used to define a single Namespace 563 component of a Namespace path. 564 565 <!ELEMENT NAMESPACE EMPTY> 566 <!ATTLIST NAMESPACE 567 %CIMName;> 568 """ 569
570 - def __init__(self, name):
571 Element.__init__(self, 'NAMESPACE') 572 self.setName(name)
573
574 -class CLASSPATH(CIMElement):
575 # pylint: disable=invalid-name 576 """ 577 The CLASSPATH element defines the absolute path to a CIM Class. It 578 is formed from a namespace path and Class name. 579 580 <!ELEMENT CLASSPATH (NAMESPACEPATH, CLASSNAME)> 581 """ 582
583 - def __init__(self, namespacepath, classname):
584 Element.__init__(self, 'CLASSPATH') 585 self.appendChild(namespacepath) 586 self.appendChild(classname)
587 588
589 -class LOCALCLASSPATH(CIMElement):
590 # pylint: disable=invalid-name 591 """ 592 The LOCALCLASSPATH element defines the a local path to a CIM 593 Class. It is formed from a local namespace path and Class name. 594 595 <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)> 596 """ 597
598 - def __init__(self, localnamespacepath, classname):
599 Element.__init__(self, 'LOCALCLASSPATH') 600 self.appendChild(localnamespacepath) 601 self.appendChild(classname)
602
603 -class CLASSNAME(CIMElement):
604 # pylint: disable=invalid-name 605 """ 606 The CLASSNAME element defines the qualifying name of a CIM Class. 607 608 <!ELEMENT CLASSNAME EMPTY> 609 <!ATTLIST CLASSNAME 610 %CIMName;> 611 """ 612
613 - def __init__(self, classname):
614 Element.__init__(self, 'CLASSNAME') 615 self.setName(classname)
616
617 -class INSTANCEPATH(CIMElement):
618 # pylint: disable=invalid-name 619 """ 620 The INSTANCEPATH element defines the absolute path to a CIM 621 Instance. It is comprised of a Namespace path and an Instance Name 622 (model path). 623 624 <!ELEMENT INSTANCEPATH (NAMESPACEPATH, INSTANCENAME)> 625 """ 626
627 - def __init__(self, namespacepath, instancename):
628 Element.__init__(self, 'INSTANCEPATH') 629 self.appendChild(namespacepath) 630 self.appendChild(instancename)
631
632 -class LOCALINSTANCEPATH(CIMElement):
633 # pylint: disable=invalid-name 634 """ 635 The LOCALINSTANCEPATH element defines the local path to a CIM 636 Instance. It is comprised of a local Namespace path and an 637 Instance Name (model path). 638 639 <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)> 640 """ 641
642 - def __init__(self, localpath, instancename):
643 Element.__init__(self, 'LOCALINSTANCEPATH') 644 self.appendChild(localpath) 645 self.appendChild(instancename)
646
647 -class INSTANCENAME(CIMElement):
648 # pylint: disable=invalid-name 649 """ 650 The INSTANCENAME element defines the location of a CIM Instance 651 within a Namespace (it is referred to in the CIM Specification 652 as a Model Path). It is comprised of a class name and a key 653 binding information. 654 655 If the Class has a single key property, then a single KEYVALUE or 656 VALUE.REFERENCE subelement may be used to describe the 657 (necessarily) unique key value without a key name. Alternatively a 658 single KEYBINDING subelement may be used instead. 659 660 If the Class has more than one key property, then a KEYBINDING 661 subelement MUST appear for each key. 662 663 If there are no key-bindings specified, the instance is assumed to 664 be a singleton instance of a keyless Class. 665 666 <!ELEMENT INSTANCENAME (KEYBINDING* | KEYVALUE? | VALUE.REFERENCE?)> 667 <!ATTLIST INSTANCENAME 668 %ClassName;> 669 """ 670
671 - def __init__(self, classname, data):
672 Element.__init__(self, 'INSTANCENAME') 673 self.setAttribute('CLASSNAME', classname) 674 if data is not None: 675 if type(data) == list: 676 self.appendChildren(data) 677 else: 678 self.appendChild(data)
679
680 -class OBJECTPATH(CIMElement):
681 # pylint: disable=invalid-name 682 """ 683 The OBJECTPATH element is used to define a full path to a single 684 CIM Object (Class or Instance). 685 686 <!ELEMENT OBJECTPATH (INSTANCEPATH | CLASSPATH)> 687 """ 688
689 - def __init__(self, data):
690 Element.__init__(self, 'OBJECTPATH') 691 self.appendChild(data)
692
693 -class KEYBINDING(CIMElement):
694 # pylint: disable=invalid-name 695 """ 696 The KEYBINDING element defines a single key property value binding. 697 698 <!ELEMENT KEYBINDING (KEYVALUE | VALUE.REFERENCE)> 699 <!ATTLIST KEYBINDING 700 %CIMName;> 701 """ 702
703 - def __init__(self, name, data):
704 Element.__init__(self, 'KEYBINDING') 705 self.setName(name) 706 self.appendChild(data)
707
708 -class KEYVALUE(CIMElement):
709 # pylint: disable=invalid-name 710 """ 711 The KEYVALUE element defines a single property key value when the 712 key property is a non-reference type. 713 714 <!ELEMENT KEYVALUE (#PCDATA)> 715 <!ATTLIST KEYVALUE 716 VALUETYPE (string|boolean|numeric) 'string' 717 %CIMType; #IMPLIED> 718 """ 719
720 - def __init__(self, data, value_type=None, cim_type=None):
721 722 Element.__init__(self, 'KEYVALUE') 723 724 if value_type is None: 725 self.setAttribute('VALUETYPE', 'string') 726 else: 727 self.setAttribute('VALUETYPE', value_type) 728 729 self.setOptionalAttribute('TYPE', cim_type) 730 731 if data != None: 732 self.appendChild(_text(data))
733 734 # Object definition elements 735
736 -class CLASS(CIMElement):
737 # pylint: disable=invalid-name 738 """ 739 The CLASS element defines a single CIM Class. 740 741 <!ELEMENT CLASS (QUALIFIER*, (PROPERTY | PROPERTY.ARRAY | 742 PROPERTY.REFERENCE)*, METHOD*)> 743 <!ATTLIST CLASS 744 %CIMName; 745 %SuperClass;> 746 """ 747
748 - def __init__(self, classname, properties=[], methods=[], 749 qualifiers=[], superclass=None):
750 Element.__init__(self, 'CLASS') 751 self.setName(classname) 752 self.setOptionalAttribute('SUPERCLASS', superclass) 753 self.appendChildren(qualifiers + properties + methods)
754
755 -class INSTANCE(CIMElement):
756 # pylint: disable=invalid-name 757 """ 758 The INSTANCE element defines a single CIM Instance of a CIM Class. 759 760 <!ELEMENT INSTANCE (QUALIFIER*, (PROPERTY | PROPERTY.ARRAY | 761 PROPERTY.REFERENCE)*)> 762 <!ATTLIST INSTANCE 763 %ClassName; 764 xml:lang NMTOKEN #IMPLIED> 765 """
766 - def __init__(self, classname, properties=[], qualifiers=[], 767 xml_lang=None):
768 Element.__init__(self, 'INSTANCE') 769 self.setAttribute('CLASSNAME', classname) 770 self.setOptionalAttribute('xml:lang', xml_lang) 771 self.appendChildren(qualifiers + properties)
772
773 -class QUALIFIER(CIMElement):
774 # pylint: disable=invalid-name 775 """ 776 The QUALIFIER element defines a single CIM Qualifier. If the 777 Qualifier has a non-array type, it contains a single VALUE element 778 representing the value of the Qualifier. If the Qualifier has an 779 array type, it contains a single VALUE.ARRAY element to represent 780 the value. 781 782 If the Qualifier has no assigned value then the VALUE element MUST 783 be absent. 784 785 <!ELEMENT QUALIFIER ((VALUE | VALUE.ARRAY)?)> 786 <!ATTLIST QUALIFIER 787 %CIMName; 788 %CIMType; #REQUIRED 789 %Propagated; 790 %QualifierFlavor; 791 xml:lang NMTOKEN #IMPLIED> 792 """ 793
794 - def __init__(self, name, type, value=None, propagated=None, 795 overridable=None, tosubclass=None, toinstance=None, 796 translatable=None, xml_lang=None):
797 798 Element.__init__(self, 'QUALIFIER') 799 800 self.setName(name) 801 self.setAttribute('TYPE', type) 802 803 if propagated is not None: 804 self.setAttribute('PROPAGATED', str(propagated).lower()) 805 806 if overridable is not None: 807 self.setAttribute('OVERRIDABLE', str(overridable).lower()) 808 if tosubclass is not None: 809 self.setAttribute('TOSUBCLASS', str(tosubclass).lower()) 810 if toinstance is not None: 811 self.setAttribute('TOINSTANCE', str(toinstance).lower()) 812 if translatable is not None: 813 self.setAttribute('TRANSLATABLE', str(translatable).lower()) 814 815 self.setOptionalAttribute('xml:lang', xml_lang) 816 817 self.appendOptionalChild(value)
818
819 -class PROPERTY(CIMElement):
820 # pylint: disable=invalid-name 821 """ 822 The PROPERTY element defines a single (non-array) CIM Property 823 that is not a reference. It contains a single VALUE element 824 representing the value of the Property. 825 826 If the Property has no assigned value then the VALUE element MUST be 827 absent. 828 829 CIM Reference Properties are described using the 830 PROPERTY.REFERENCE element. 831 832 <!ELEMENT PROPERTY (QUALIFIER*, VALUE?)> 833 <!ATTLIST PROPERTY 834 %CIMName; 835 %ClassOrigin; 836 %Propagated; 837 %CIMType; #REQUIRED 838 xml:lang NMTOKEN #IMPLIED> 839 """ 840
841 - def __init__(self, name, type, value=None, class_origin=None, 842 propagated=None, qualifiers=[], xml_lang=None, 843 embedded_object=None):
844 845 Element.__init__(self, 'PROPERTY') 846 847 self.setName(name) 848 self.setAttribute('TYPE', type) 849 850 self.setOptionalAttribute('CLASSORIGIN', class_origin) 851 852 if propagated is not None: 853 self.setAttribute('PROPAGATED', str(propagated).lower()) 854 855 self.setOptionalAttribute('xml:lang', xml_lang) 856 857 self.setOptionalAttribute('EmbeddedObject', embedded_object) 858 # Note on EmbeddedObject: 859 # The CIM-XML standard requires the mixed case form, 'EmbeddedObject'. 860 # Given that all other attributes are in upper case, this is an 861 # inconsistency in the standard that cannot be fixed for backwards 862 # compatibility reasons. 863 # OpenPegasus 2.6 supported only the upper case form 'EMBEDDEDOBJECT'. 864 # Later OpenPegasus versions fixed that by using 'EmbeddedObject' in 865 # any responses and by accepting both 'EMBEDDEDOBJECT' and 866 # 'EmbeddedObject' in any requests. 867 # Adding the 'EMBEDDEDOBJECT' attribute to any requests (that is, in 868 # this code here) in order to support the old OpenPegasus 2.6 does not 869 # work unfortunately, because SFCB supports either form but not both 870 # attributes in the same request. 871 # As a result, the best choice is to use only the standards-conforming 872 # mixed case form in any requests sent by PyWBEM. 873 874 self.appendChildren(qualifiers) 875 self.appendOptionalChild(value)
876
877 -class PROPERTY_ARRAY(CIMElement):
878 # pylint: disable=invalid-name 879 """ 880 The PROPERTY.ARRAY element defines a single CIM Property with an 881 array type. It contains a single VALUE.ARRAY element representing 882 the value of the Property. 883 884 If the Property has no assigned value then the VALUE.ARRAY element 885 MUST be absent. 886 887 There is no element to model a Property that contains an array of 888 references as this is not a valid Property type according to CIM. 889 890 <!ELEMENT PROPERTY.ARRAY (QUALIFIER*, VALUE.ARRAY?)> 891 <!ATTLIST PROPERTY.ARRAY 892 %CIMName; 893 %CIMType; #REQUIRED 894 %ArraySize; 895 %ClassOrigin; 896 %Propagated; 897 xml:lang NMTOKEN #IMPLIED> 898 """ 899
900 - def __init__(self, name, type, value_array=None, array_size=None, 901 class_origin=None, propagated=None, qualifiers=[], 902 xml_lang=None, embedded_object=None):
903 904 Element.__init__(self, 'PROPERTY.ARRAY') 905 906 self.setName(name) 907 self.setAttribute('TYPE', type) 908 909 if array_size is not None: 910 self.setAttribute('ARRAYSIZE', str(array_size)) 911 self.setOptionalAttribute('CLASSORIGIN', class_origin) 912 self.setOptionalAttribute('EmbeddedObject', embedded_object) 913 # See the note on EmbeddedObject in PROPERTY(). 914 915 if propagated is not None: 916 self.setAttribute('PROPAGATED', str(propagated).lower()) 917 918 self.setOptionalAttribute('xml:lang', xml_lang) 919 920 self.appendChildren(qualifiers) 921 self.appendOptionalChild(value_array)
922
923 -class PROPERTY_REFERENCE(CIMElement):
924 # pylint: disable=invalid-name 925 """ 926 The PROPERTY.REFERENCE element models a single CIM Property with 927 reference semantics. In future the features of XML Linking may 928 be used to identify linking elements within the XML Document; as 929 XML Linking is currently only at Working Draft status no explicit 930 dependencies have been made at this point. 931 932 <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*, VALUE.REFERENCE?)> 933 <!ATTLIST PROPERTY.REFERENCE 934 %CIMName; 935 %ReferenceClass; 936 %ClassOrigin; 937 %Propagated;> 938 """ 939
940 - def __init__(self, name, value_reference=None, reference_class=None, 941 class_origin=None, propagated=None, qualifiers=[]):
942 943 Element.__init__(self, 'PROPERTY.REFERENCE') 944 945 self.setName(name) 946 947 self.setOptionalAttribute('REFERENCECLASS', reference_class) 948 self.setOptionalAttribute('CLASSORIGIN', class_origin) 949 950 if propagated is not None: 951 self.setAttribute('PROPAGATED', str(propagated).lower()); 952 953 self.appendChildren(qualifiers) 954 self.appendOptionalChild(value_reference)
955
956 -class METHOD(CIMElement):
957 # pylint: disable=invalid-name 958 """ 959 The METHOD element defines a single CIM Method. It may have 960 Qualifiers, and zero or more parameters. 961 962 The order of the PARAMETER, PARAMETER.REFERENCE, PARAMETER.ARRAY 963 and PARAMETER.REFARRAY subelements is not significant. 964 965 <!ELEMENT METHOD (QUALIFIER*, (PARAMETER | PARAMETER.REFERENCE | 966 PARAMETER.ARRAY | PARAMETER.REFARRAY)*)> 967 <!ATTLIST METHOD 968 %CIMName; 969 %CIMType; #IMPLIED 970 %ClassOrigin; 971 %Propagated;> 972 """ 973
974 - def __init__(self, name, parameters=[], return_type=None, 975 class_origin=None, propagated=None, qualifiers=[]):
976 977 Element.__init__(self, 'METHOD') 978 979 self.setName(name) 980 981 self.setOptionalAttribute('TYPE', return_type) 982 self.setOptionalAttribute('CLASSORIGIN', class_origin) 983 984 if propagated is not None: 985 self.setAttribute('PROPAGATED', str(propagated).lower()) 986 987 self.appendChildren(qualifiers + parameters)
988
989 -class PARAMETER(CIMElement):
990 # pylint: disable=invalid-name 991 """ 992 The PARAMETER element defines a single (non-array, non-reference) 993 Parameter to a CIM Method. The parameter MAY have zero or more 994 Qualifiers. 995 996 <!ELEMENT PARAMETER (QUALIFIER*)> 997 <!ATTLIST PARAMETER 998 %CIMName; 999 %CIMType; #REQUIRED> 1000 """ 1001
1002 - def __init__(self, name, type, qualifiers=[]):
1003 Element.__init__(self, 'PARAMETER') 1004 self.setName(name) 1005 self.setAttribute('TYPE', type) 1006 self.appendChildren(qualifiers)
1007
1008 -class PARAMETER_REFERENCE(CIMElement):
1009 # pylint: disable=invalid-name 1010 """ 1011 The PARAMETER.REFERENCE element defines a single reference 1012 Parameter to a CIM Method. The parameter MAY have zero or more 1013 Qualifiers. 1014 1015 <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)> 1016 <!ATTLIST PARAMETER.REFERENCE 1017 %CIMName; 1018 %ReferenceClass;> 1019 """ 1020
1021 - def __init__(self, name, reference_class=None, qualifiers=[]):
1022 Element.__init__(self, 'PARAMETER.REFERENCE') 1023 self.setName(name) 1024 self.setOptionalAttribute('REFERENCECLASS', reference_class) 1025 self.appendChildren(qualifiers)
1026
1027 -class PARAMETER_ARRAY(CIMElement):
1028 # pylint: disable=invalid-name 1029 """ 1030 The PARAMETER.ARRAY element defines a single Parameter to a CIM 1031 Method that has an array type. The parameter MAY have zero or more 1032 Qualifiers. 1033 1034 <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)> 1035 <!ATTLIST PARAMETER.ARRAY 1036 %CIMName; 1037 %CIMType; #REQUIRED 1038 %ArraySize;> 1039 """ 1040
1041 - def __init__(self, name, type, array_size=None, qualifiers=[]):
1042 Element.__init__(self, 'PARAMETER.ARRAY') 1043 self.setName(name) 1044 self.setAttribute('TYPE', type) 1045 if array_size is not None: 1046 self.setAttribute('ARRAYSIZE', str(array_size)) 1047 self.appendChildren(qualifiers)
1048
1049 -class PARAMETER_REFARRAY(CIMElement):
1050 # pylint: disable=invalid-name 1051 """ 1052 The PARAMETER.REFARRAY element defines a single Parameter to a CIM 1053 Method that has an array of references type. The parameter MAY 1054 have zero or more Qualifiers. 1055 1056 <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)> 1057 <!ATTLIST PARAMETER.REFARRAY 1058 %CIMName; 1059 %ReferenceClass; 1060 %ArraySize;> 1061 """ 1062
1063 - def __init__(self, name, reference_class=None, array_size=None, 1064 qualifiers=[]):
1065 Element.__init__(self, 'PARAMETER.REFARRAY') 1066 self.setName(name) 1067 self.setOptionalAttribute('REFERENCECLASS', reference_class) 1068 if array_size is not None: 1069 self.setAttribute('ARRAYSIZE', str(array_size)) 1070 self.appendChildren(qualifiers)
1071
1072 -class TABLECELL_DECLARATION(CIMElement):
1073 # pylint: disable=invalid-name 1074 """ 1075 The TABLECELL.DECLARATION element describes a TABLECELL that is 1076 not a reference or an array of references. 1077 1078 1079 <!ELEMENT TABLECELL.DECLARATION EMPTY> 1080 <!ATTLIST TABLECELL.DECLARATION 1081 %CIMName; 1082 %CIMType; #REQUIRED 1083 ISARRAY (true|false) "false" 1084 %ARRAYSIZE; 1085 CELLPOS CDATA #REQUIRED 1086 SORTPOS CDATA #IMPLIED 1087 SORTDIR (ASC|DESC) #IMPLIED> 1088 """
1089
1090 -class TABLECELL_REFERENCE(CIMElement):
1091 # pylint: disable=invalid-name 1092 """ 1093 1094 The TABLECELL.REFERENCE element defines a TABLECELL that contains 1095 reference or reference array values. 1096 1097 <!ELEMENT TABLECELL.REFERENCE EMPTY> 1098 <!ATTLIST TABLECELL.REFERENCE 1099 %CIMName; 1100 %ReferenceClass; #REQUIRED 1101 ISARRAY (true|false) "false" 1102 %ARRAYSIZE; 1103 CELLPOS CDATA #REQUIRED 1104 SORTPOS CDATA #IMPLIED 1105 SORTDIR (ASC|DESC) #IMPLIED> 1106 """
1107
1108 -class TABLEROW_DECLARATION(CIMElement):
1109 # pylint: disable=invalid-name 1110 """ 1111 1112 The TABLEROW.DECLARATION element contains a definition for each 1113 TABLECELL in the TABLEROW. 1114 1115 <!ELEMENT TABLEROW.DECLARATION (TABLECELL.DECLARATION 1116 | TABLECELL.REFERENCE)*> 1117 """
1118
1119 -class TABLE(CIMElement):
1120 # pylint: disable=invalid-name 1121 """ 1122 The TABLE element defines the result of a CIM Query. A TABLE 1123 element consists of a TABLEROW.DECLARATION followed by 0 or more 1124 rows. 1125 1126 <!ELEMENT TABLE(TABLEROW.DECLARATION,(TABLEROW)*)> 1127 """
1128
1129 -class TABLEROW(CIMElement):
1130 # pylint: disable=invalid-name 1131 """ 1132 1133 The TABLEROW element defines the values for a single row of a 1134 table. A value for each cell of the row MUST be specified. If a 1135 value has no assigned value, the VALUE.NULL element MUST be used. 1136 1137 <!ELEMENT TABLEROW (VALUE | VALUE.ARRAY | VALUE.REFERENCE | 1138 VALUE.REFARRAY | VALUE.NULL)*> 1139 """
1140 1141 # Message elements 1142
1143 -class MESSAGE(CIMElement):
1144 # pylint: disable=invalid-name 1145 """ 1146 The MESSAGE element models a single CIM message. This element is 1147 used as the basis for CIM Operation Messages and CIM Export 1148 Messages. 1149 1150 <!ELEMENT MESSAGE (SIMPLEREQ | MULTIREQ | SIMPLERSP | MULTIRSP | 1151 SIMPLEEXPREQ | MULTIEXPREQ | SIMPLEEXPRSP | 1152 MULTIEXPRSP)> 1153 <!ATTLIST MESSAGE 1154 ID CDATA #REQUIRED 1155 PROTOCOLVERSION CDATA #REQUIRED> 1156 """ 1157
1158 - def __init__(self, data, message_id, protocol_version):
1159 Element.__init__(self, 'MESSAGE') 1160 self.setAttribute('ID', message_id) 1161 self.setAttribute('PROTOCOLVERSION', protocol_version) 1162 self.appendChild(data)
1163
1164 -class MULTIREQ(CIMElement):
1165 # pylint: disable=invalid-name 1166 """ 1167 The MULTIREQ element defines a Multiple CIM Operation request. It 1168 contains two or more subelements defining the SIMPLEREQ elements 1169 that make up this multiple request. 1170 1171 <!ELEMENT MULTIREQ (SIMPLEREQ, SIMPLEREQ+)> 1172 """ 1173
1174 - def __init__(self, data):
1175 Element.__init__(self, 'MULTIREQ') 1176 self.appendChildren(data)
1177
1178 -class MULTIEXPREQ(CIMElement):
1179 # pylint: disable=invalid-name 1180 """ 1181 The MULTIEXPREQ element defines a Multiple CIM Export request. It 1182 contains two or more subelements defining the SIMPLEEXPREQ 1183 elements that make up this multiple request. 1184 1185 <!ELEMENT MULTIEXPREQ (SIMPLEEXPREQ, SIMPLEEXPREQ+)> 1186 """ 1187
1188 - def __init__(self, data):
1189 Element.__init__(self, 'MULTIEXPREQ') 1190 self.appendChildren(data)
1191
1192 -class SIMPLEREQ(CIMElement):
1193 # pylint: disable=invalid-name 1194 """ 1195 The SIMPLEREQ element defines a Simple CIM Operation request. It 1196 contains either a METHODCALL (extrinsic method) element or an 1197 IMETHODCALL (intrinsic method) element. 1198 1199 <!ELEMENT SIMPLEREQ (IMETHODCALL | METHODCALL)> 1200 """ 1201
1202 - def __init__(self, data):
1203 Element.__init__(self, 'SIMPLEREQ') 1204 self.appendChild(data)
1205
1206 -class SIMPLEEXPREQ(CIMElement):
1207 # pylint: disable=invalid-name 1208 """ 1209 The SIMPLEEXPREQ element defines a Simple CIM Export request. It 1210 contains an EXPMETHODCALL (export method). 1211 1212 <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)> 1213 """ 1214
1215 - def __init__(self, data):
1216 Element.__init__(self, 'SIMPLEEXPREQ') 1217 self.appendChild(data)
1218
1219 -class IMETHODCALL(CIMElement):
1220 # pylint: disable=invalid-name 1221 """ 1222 The IMETHODCALL element defines a single intrinsic method 1223 invocation. It specifies the target local namespace, followed by 1224 zero or more IPARAMVALUE subelements as the parameter values to be 1225 passed to the method. If the RESPONSEDESTINATION element is 1226 specified, the intrinsic method call MUST be interpreted as an 1227 asynchronous method call. 1228 1229 <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH, IPARAMVALUE*, 1230 RESPONSEDESTINATION?)> 1231 <!ATTLIST IMETHODCALL 1232 %CIMName;> 1233 """ 1234
1235 - def __init__(self, name, localnamespacepath, iparamvalues=[], 1236 responsedestination=None):
1237 Element.__init__(self, 'IMETHODCALL') 1238 self.setName(name) 1239 self.appendChild(localnamespacepath) 1240 self.appendChildren(iparamvalues) 1241 self.appendOptionalChild(responsedestination)
1242
1243 -class METHODCALL(CIMElement):
1244 # pylint: disable=invalid-name 1245 """ 1246 The METHODCALL element defines a single method invocation on a 1247 Class or Instance. It specifies the local path of the target 1248 Class or Instance, followed by zero or more PARAMVALUE subelements 1249 as the parameter values to be passed to the method. If the 1250 RESPONSEDESTINATION element is specified, the method call MUST be 1251 interpreted as an asynchronous method call. 1252 1253 <!ELEMENT METHODCALL ((LOCALINSTANCEPATH | LOCALCLASSPATH), PARAMVALUE*, 1254 RESPONSEDESTINATION?)> 1255 <!ATTLIST METHODCALL 1256 %CIMName;> 1257 """ 1258
1259 - def __init__(self, name, localpath, paramvalues=[], 1260 responsedestination=None):
1261 Element.__init__(self, 'METHODCALL') 1262 self.setName(name) 1263 self.appendChild(localpath) 1264 self.appendChildren(paramvalues) 1265 self.appendOptionalChild(responsedestination)
1266
1267 -class EXPMETHODCALL(CIMElement):
1268 # pylint: disable=invalid-name 1269 """ 1270 The EXPMETHODCALL element defines a single export method 1271 invocation. It specifies zero or more <EXPPARAMVALUE> 1272 subelements as the parameter values to be passed to the method. 1273 1274 <!ELEMENT EXPMETHODCALL (EXPPARAMVALUE*)> 1275 <!ATTLIST EXPMETHODCALL 1276 %CIMName;> 1277 """ 1278
1279 - def __init__(self, name, params=[]):
1280 Element.__init__(self, 'EXPMETHODCALL') 1281 self.setName(name) 1282 self.appendChildren(params)
1283
1284 -class PARAMVALUE(CIMElement):
1285 # pylint: disable=invalid-name 1286 """ 1287 The PARAMVALUE element defines a single extrinsic method named 1288 parameter value. If no subelement is present this indicates that 1289 no value has been supplied for this parameter. 1290 1291 <!ELEMENT PARAMVALUE (VALUE | VALUE.REFERENCE | VALUE.ARRAY | 1292 VALUE.REFARRAY)?> 1293 <!ATTLIST PARAMVALUE 1294 %CIMName; 1295 %ParamType; #IMPLIED> 1296 """ 1297
1298 - def __init__(self, name, data=None, paramtype=None, 1299 embedded_object=None):
1300 Element.__init__(self, 'PARAMVALUE') 1301 self.setName(name) 1302 self.setOptionalAttribute('PARAMTYPE', paramtype) 1303 self.setOptionalAttribute('EmbeddedObject', embedded_object) 1304 # See the note on EmbeddedObject in PROPERTY(). 1305 self.appendOptionalChild(data)
1306
1307 -class IPARAMVALUE(CIMElement):
1308 # pylint: disable=invalid-name 1309 """ 1310 The IPARAMVALUE element defines a single intrinsic method named 1311 parameter value. If no subelement is present this indicates that 1312 no value has been supplied for this parameter. 1313 1314 <!ELEMENT IPARAMVALUE (VALUE | VALUE.ARRAY | VALUE.REFERENCE | 1315 INSTANCENAME | CLASSNAME | QUALIFIER.DECLARATION | 1316 CLASS | INSTANCE | VALUE.NAMEDINSTANCE)?> 1317 <!ATTLIST IPARAMVALUE 1318 %CIMName;> 1319 """ 1320
1321 - def __init__(self, name, data=None):
1322 Element.__init__(self, 'IPARAMVALUE') 1323 self.setName(name) 1324 self.appendOptionalChild(data)
1325
1326 -class EXPPARAMVALUE(CIMElement):
1327 # pylint: disable=invalid-name 1328 """ 1329 The EXPPARAMVALUE element defines a single export method named 1330 parameter value. If no subelement is present this indicates that 1331 no value has been supplied for this parameter. 1332 1333 <!ELEMENT EXPPARAMVALUE (INSTANCE? | VALUE? | METHODRESPONSE? | 1334 IMETHODRESPONSE?)> 1335 <!ATTLIST EXPPARAMVALUE 1336 %CIMName; 1337 %ParamType; #IMPLIED> 1338 """ 1339
1340 - def __init__(self, name, data=None, param_type=None):
1341 Element.__init__(self, 'EXPPARAMVALUE') 1342 self.setName(name) 1343 self.setOptionalAttribute('PARAMTYPE', param_type) 1344 self.appendOptionalChild(data)
1345
1346 -class MULTIRSP(CIMElement):
1347 # pylint: disable=invalid-name 1348 """ 1349 The MULTIRSP element defines a Multiple CIM Operation response. 1350 It contains two or more subelements defining the SIMPLERSP 1351 elements that make up this multiple response. 1352 1353 <!ELEMENT MULTIRSP (SIMPLERSP, SIMPLERSP+)> 1354 """ 1355
1356 - def __init__(self, data):
1357 Element.__init__(self, 'MULTIRSP') 1358 self.appendChildren(data)
1359
1360 -class MULTIEXPRSP(CIMElement):
1361 # pylint: disable=invalid-name 1362 """ 1363 The MULTIEXPRSP element defines a Multiple CIM Export response. 1364 It contains two or more subelements defining the SIMPLEEXPRSP 1365 elements that make up this multiple response. 1366 1367 <!ELEMENT MULTIEXPRSP (SIMPLEEXPRSP, SIMPLEEXPRSP+)> 1368 """ 1369
1370 - def __init__(self, data):
1371 Element.__init__(self, 'MULTIEXPRSP') 1372 self.appendChildren(data)
1373
1374 -class SIMPLERSP(CIMElement):
1375 # pylint: disable=invalid-name 1376 """ 1377 The SIMPLERSP element defines a Simple CIM Operation response. It 1378 contains either a METHODRESPONSE (for extrinsic methods), 1379 IMETHODRESPONSE (for intrinsic methods) or a SIMPLEREQACK 1380 subelement. 1381 1382 <!ELEMENT SIMPLERSP (METHODRESPONSE | IMETHODRESPONSE | SIMPLEREQACK)> 1383 """ 1384
1385 - def __init__(self, data):
1386 Element.__init__(self, 'SIMPLERSP') 1387 self.appendChild(data)
1388
1389 -class SIMPLEEXPRSP(CIMElement):
1390 # pylint: disable=invalid-name 1391 """ 1392 The SIMPLEEXPRSP element defines a Simple CIM Export response. It 1393 contains either a EXPMETHODRESPONSE (for export methods) 1394 subelement. 1395 1396 <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)> 1397 """ 1398
1399 - def __init__(self, data):
1400 Element.__init__(self, 'SIMPLEEXPRSP') 1401 self.appendChild(data)
1402
1403 -class METHODRESPONSE(CIMElement):
1404 # pylint: disable=invalid-name 1405 """ 1406 The METHODRESPONSE defines the response to a single CIM extrinsic 1407 method invocation. It contains either an ERROR subelement (to 1408 report a fundamental error which prevented the method from 1409 executing), or a combination of an optional return value and zero 1410 or more out parameter values. 1411 1412 <!ELEMENT METHODRESPONSE (ERROR | (RETURNVALUE?, PARAMVALUE*))> 1413 <!ATTLIST METHODRESPONSE 1414 %CIMName;> 1415 """ 1416
1417 - def __init__(self, name, data=None):
1418 Element.__init__(self, 'METHODRESPONSE') 1419 self.setName(name) 1420 if data is not None: 1421 if type(data) == tuple or type(data) == list: 1422 self.appendChildren(data) 1423 else: 1424 self.appendChild(data)
1425
1426 -class EXPMETHODRESPONSE(CIMElement):
1427 # pylint: disable=invalid-name 1428 """ 1429 The EXPMETHODRESPONSE defines the response to a single export 1430 method invocation. It contains either an ERROR subelement (to 1431 report a fundamental error which prevented the method from 1432 executing), or an optional return value. 1433 1434 <!ELEMENT EXPMETHODRESPONSE (ERROR | IRETURNVALUE?)> 1435 <!ATTLIST EXPMETHODRESPONSE 1436 %CIMName;> 1437 """ 1438
1439 - def __init__(self, name, data=None):
1440 Element.__init__(self, 'EXPMETHODRESPONSE') 1441 self.setName(name) 1442 self.appendOptionalChild(data)
1443
1444 -class IMETHODRESPONSE(CIMElement):
1445 # pylint: disable=invalid-name 1446 """ 1447 The IMETHODRESPONSE defines the response to a single intrinsic CIM 1448 method invocation. It contains either an ERROR subelement (to 1449 report a fundamental error which prevented the method from 1450 executing), or an optional return value. 1451 1452 <!ELEMENT IMETHODRESPONSE (ERROR | IRETURNVALUE?)> 1453 <!ATTLIST IMETHODRESPONSE 1454 %CIMName;> 1455 """ 1456
1457 - def __init__(self, name, data=None):
1458 Element.__init__(self, 'IMETHODRESPONSE') 1459 self.setName(name) 1460 self.appendOptionalChild(data)
1461
1462 -class ERROR(CIMElement):
1463 # pylint: disable=invalid-name 1464 """ 1465 The ERROR element is used to define a fundamental error which 1466 prevented a method from executing normally. It consists of a 1467 status code, an optional description and zero or more instances 1468 containing detailed information about the error. 1469 1470 <!ELEMENT ERROR (INSTANCE*)> 1471 <!ATTLIST ERROR 1472 CODE CDATA #REQUIRED 1473 DESCRIPTION CDATA #IMPLIED> 1474 """ 1475
1476 - def __init__(self, code, description=None, instances=[]):
1477 Element.__init__(self, 'ERROR') 1478 self.setAttribute('CODE', code) 1479 self.setOptionalAttribute('DESCRIPTION', description) 1480 self.appendChildren(instances)
1481
1482 -class RETURNVALUE(CIMElement):
1483 # pylint: disable=invalid-name 1484 """ 1485 The RETURNVALUE element specifies the value returned from an 1486 extrinsic method call. 1487 1488 <!ELEMENT RETURNVALUE (VALUE | VALUE.REFERENCE)> 1489 <!ATTLIST RETURNVALUE 1490 %ParamType; #IMPLIED> 1491 """ 1492
1493 - def __init__(self, data, param_type=None):
1494 Element.__init__(self, 'RETURNVALUE') 1495 self.setOptionalAttribute('PARAMTYPE', param_type) 1496 self.appendChild(data)
1497
1498 -class IRETURNVALUE(CIMElement):
1499 # pylint: disable=invalid-name 1500 """ 1501 The IRETURNVALUE element specifies the value returned from an 1502 intrinsic method call. 1503 1504 <!ELEMENT IRETURNVALUE (CLASSNAME* | INSTANCENAME* | VALUE* | 1505 VALUE.OBJECTWITHPATH* | 1506 VALUE.OBJECTWITHLOCALPATH* | VALUE.OBJECT* | 1507 OBJECTPATH* | QUALIFIER.DECLARATION* | 1508 VALUE.ARRAY? | VALUE.REFERENCE? | CLASS* | 1509 INSTANCE* | VALUE.NAMEDINSTANCE*)> 1510 """ 1511
1512 - def __init__(self, data):
1513 Element.__init__(self, 'IRETURNVALUE') 1514 self.appendOptionalChild(data)
1515
1516 -class RESPONSEDESTINATION(CIMElement):
1517 # pylint: disable=invalid-name 1518 """ 1519 The RESPONSEDESTINATION element contains an instance that 1520 describes the desired destination for the response. 1521 1522 <!ELEMENT RESPONSEDESTINATON (INSTANCE)> 1523 """ 1524
1525 - def __init__(self, data):
1526 Element.__init__(self, 'RESPONSEDESTINATON') 1527 self.appendChild(data);
1528
1529 -class SIMPLEREQACK(CIMElement):
1530 # pylint: disable=invalid-name 1531 """ 1532 The SIMPLEREQACK defines the acknowledgement response to a Simple 1533 CIM Operation asynchronous request. The ERROR subelement is used 1534 to report a fundamental error which prevented the asynchronous 1535 request from being initiated. 1536 1537 <!ELEMENT SIMPLEREQACK (ERROR?)> 1538 <!ATTLIST SIMPLEREQACK 1539 INSTANCEID CDATA #REQUIRED> 1540 """ 1541
1542 - def __init__(self, instanceid, data):
1543 Element.__init__(self, 'SIMPLEREQACK') 1544 self.setOptionalAttribute('INSTANCEID', instanceid) 1545 self.appendOptionalChild(data)
1546