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

Source Code for Module pywbem.cim_operations

   1  # 
   2  # (C) Copyright 2003-2007 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: Martin Pool <mbp@hp.com> 
  21  # Author: Bart Whiteley <bwhiteley@suse.de> 
  22  # 
  23   
  24  """CIM operations over HTTP. 
  25   
  26  The `WBEMConnection` class in this module opens a connection to a remote 
  27  WBEM server. Across this connection you can run various CIM operations. 
  28  Each method of this class corresponds fairly directly to a single CIM 
  29  operation. 
  30  """ 
  31   
  32  # This module is meant to be safe for 'import *'. 
  33   
  34  import string 
  35  import re 
  36  from types import StringTypes 
  37  from xml.dom import minidom 
  38  from datetime import datetime, timedelta 
  39  from xml.parsers.expat import ExpatError 
  40   
  41  from pywbem import cim_obj, cim_xml, cim_http, cim_types, tupletree, tupleparse 
  42  from pywbem.cim_obj import CIMInstance, CIMInstanceName, CIMClass, \ 
  43                             CIMClassName, NocaseDict 
  44  from pywbem.tupleparse import ParseError 
  45   
  46  __all__ = ['DEFAULT_NAMESPACE', 'check_utf8_xml_chars', 
  47             'CIMError', 'WBEMConnection', 'is_subclass', 
  48             'PegasusUDSConnection', 'SFCBUDSConnection', 
  49             'OpenWBEMUDSConnection'] 
  50   
  51  DEFAULT_NAMESPACE = 'root/cimv2' 
  52   
  53  if len(u'\U00010122') == 2: 
  54      # This is a "narrow" Unicode build of Python (the normal case). 
  55      _ILLEGAL_XML_CHARS_RE = re.compile( 
  56          u'([\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE\uFFFF])') 
  57  else: 
  58      # This is a "wide" Unicode build of Python. 
  59      _ILLEGAL_XML_CHARS_RE = re.compile( 
  60          u'([\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE\uFFFF])') 
  61   
  62  _ILL_FORMED_UTF8_RE = re.compile( 
  63      '(\xED[\xA0-\xBF][\x80-\xBF])')    # U+D800...U+DFFF 
  64   
  65   
66 -def _check_classname(val):
67 """ 68 Validate a classname. 69 70 At this point, only the type is validated to be a string. 71 """ 72 if not isinstance(val, StringTypes): 73 raise ValueError("string expected for classname, not %s" % `val`)
74
75 -def check_utf8_xml_chars(utf8_xml, meaning):
76 """ 77 Examine a UTF-8 encoded XML string and raise a `pywbem.ParseError` 78 exception if the response contains Bytes that are invalid UTF-8 79 sequences (incorrectly encoded or ill-formed) or that are invalid XML 80 characters. 81 82 This function works in both "wide" and "narrow" Unicode builds of Python 83 and supports the full range of Unicode characters from U+0000 to U+10FFFF. 84 85 This function is just a workaround for the bad error handling of Python's 86 `xml.dom.minidom` package. It replaces the not very informative 87 `ExpatError` "not well-formed (invalid token): line: x, column: y" with a 88 `pywbem.ParseError` providing more useful information. 89 90 :Parameters: 91 92 utf8_xml : string 93 The UTF-8 encoded XML string to be examined. 94 95 meaning : string 96 Short text with meaning of the XML string, for messages in exceptions. 97 98 :Exceptions: 99 100 `TypeError`, if invoked with incorrect Python object type for `utf8_xml`. 101 102 `pywbem.ParseError`, if `utf8_xml` contains Bytes that are invalid UTF-8 103 sequences (incorrectly encoded or ill-formed) or invalid XML characters. 104 105 Notes on Unicode support in Python: 106 107 (1) For internally representing Unicode characters in the unicode type, a 108 "wide" Unicode build of Python uses UTF-32, while a "narrow" Unicode 109 build uses UTF-16. The difference is visible to Python programs for 110 Unicode characters assigned to code points above U+FFFF: The "narrow" 111 build uses 2 characters (a surrogate pair) for them, while the "wide" 112 build uses just 1 character. This affects all position- and 113 length-oriented functions, such as `len()` or string slicing. 114 115 (2) In a "wide" Unicode build of Python, the Unicode characters assigned to 116 code points U+10000 to U+10FFFF are represented directly (using code 117 points U+10000 to U+10FFFF) and the surrogate code points 118 U+D800...U+DFFF are never used; in a "narrow" Unicode build of Python, 119 the Unicode characters assigned to code points U+10000 to U+10FFFF are 120 represented using pairs of the surrogate code points U+D800...U+DFFF. 121 122 Notes on the Unicode code points U+D800...U+DFFF ("surrogate code points"): 123 124 (1) These code points have no corresponding Unicode characters assigned, 125 because they are reserved for surrogates in the UTF-16 encoding. 126 127 (2) The UTF-8 encoding can technically represent the surrogate code points. 128 ISO/IEC 10646 defines that a UTF-8 sequence containing the surrogate 129 code points is ill-formed, but it is technically possible that such a 130 sequence is in a UTF-8 encoded XML string. 131 132 (3) The Python escapes ``\\u`` and ``\\U`` used in literal strings can 133 represent the surrogate code points (as well as all other code points, 134 regardless of whether they are assigned to Unicode characters). 135 136 (4) The Python `str.encode()` and `str.decode()` functions successfully 137 translate the surrogate code points back and forth for encoding UTF-8. 138 139 For example, ``'\\xed\\xb0\\x80'.decode("utf-8") = u'\\udc00'``. 140 141 (5) Because Python supports the encoding and decoding of UTF-8 sequences 142 also for the surrogate code points, the "narrow" Unicode build of 143 Python can be (mis-)used to transport each surrogate unit separately 144 encoded in (ill-formed) UTF-8. 145 146 For example, code point U+10122 can be (illegally) created from a 147 sequence of code points U+D800,U+DD22 represented in UTF-8: 148 149 ``'\\xED\\xA0\\x80\\xED\\xB4\\xA2'.decode("utf-8") = u'\\U00010122'`` 150 151 while the correct UTF-8 sequence for this code point is: 152 153 ``u'\\U00010122'.encode("utf-8") = '\\xf0\\x90\\x84\\xa2'`` 154 155 Notes on XML characters: 156 157 (1) The legal XML characters are defined in W3C XML 1.0 (Fith Edition): 158 159 :: 160 161 Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | 162 [#x10000-#x10FFFF] 163 164 These are the code points of Unicode characters using a non-surrogate 165 representation. 166 """ 167 168 context_before = 16 # number of chars to print before any bad chars 169 context_after = 16 # number of chars to print after any bad chars 170 171 if not isinstance(utf8_xml, str): 172 raise TypeError("utf8_xml argument does not have str type, but %s" % \ 173 type(utf8_xml)) 174 175 # Check for ill-formed UTF-8 sequences. This needs to be done 176 # before the str type gets decoded to unicode, because afterwards 177 # surrogates produced from ill-formed UTF-8 cannot be distinguished from 178 # legally produced surrogates (for code points above U+FFFF). 179 ic_list = list() 180 for m in _ILL_FORMED_UTF8_RE.finditer(utf8_xml): 181 ic_pos = m.start(1) 182 ic_seq = m.group(1) 183 ic_list.append((ic_pos,ic_seq)) 184 if len(ic_list) > 0: 185 exc_txt = "Ill-formed (surrogate) UTF-8 Byte sequences found in %s:" %\ 186 meaning 187 for (ic_pos,ic_seq) in ic_list: 188 exc_txt += "\n At offset %d:" % ic_pos 189 for c in ic_seq: 190 exc_txt += " 0x%02X" % ord(c) 191 cpos1 = max(ic_pos-context_before,0) 192 cpos2 = min(ic_pos+context_after,len(utf8_xml)) 193 exc_txt += ", CIM-XML snippet: %r" % utf8_xml[cpos1:cpos2] 194 raise ParseError(exc_txt) 195 196 # Check for incorrectly encoded UTF-8 sequences. 197 # @ibm.13@ Simplified logic (removed loop). 198 try: 199 utf8_xml_u = utf8_xml.decode("utf-8") 200 except UnicodeDecodeError as exc: 201 # Only raised for incorrectly encoded UTF-8 sequences; technically 202 # correct sequences that are ill-formed (e.g. representing surrogates) 203 # do not cause this exception to be raised. 204 # If more than one incorrectly encoded sequence is present, only 205 # information about the first one is returned in the exception object. 206 # Also, the stated reason (in _msg) is not always correct. 207 _codec, _str, _p1, _p2, _msg = exc.args 208 exc_txt = "Incorrectly encoded UTF-8 Byte sequences found in %s" %\ 209 meaning 210 exc_txt += "\n At offset %d:" % _p1 211 for c in utf8_xml[_p1:_p2+1]: 212 exc_txt += " 0x%02X" % ord(c) 213 cpos1 = max(_p1-context_before,0) 214 cpos2 = min(_p2+context_after,len(utf8_xml)) 215 exc_txt += ", CIM-XML snippet: %r" % utf8_xml[cpos1:cpos2] 216 raise ParseError(exc_txt) 217 218 # Now we know the Unicode characters are valid. 219 # Check for Unicode characters that cannot legally be represented as XML 220 # characters. 221 ic_list = list() 222 last_ic_pos = -2 223 for m in _ILLEGAL_XML_CHARS_RE.finditer(utf8_xml_u): 224 ic_pos = m.start(1) 225 ic_char = m.group(1) 226 if ic_pos > last_ic_pos + 1: 227 ic_list.append((ic_pos,ic_char)) 228 last_ic_pos = ic_pos 229 if len(ic_list) > 0: 230 exc_txt = "Invalid XML characters found in %s:" % meaning 231 for (ic_pos,ic_char) in ic_list: 232 cpos1 = max(ic_pos-context_before,0) 233 cpos2 = min(ic_pos+context_after,len(utf8_xml_u)) 234 exc_txt += "\n At offset %d: U+%04X, CIM-XML snippet: %r" % \ 235 (ic_pos, ord(ic_char), utf8_xml_u[cpos1:cpos2]) 236 raise ParseError(exc_txt) 237 238 return utf8_xml
239 240
241 -class CIMError(cim_http.Error):
242 """ 243 Exception indicating that the WBEM server has returned an error response 244 with a CIM status code. 245 246 The exception value is a tuple of 247 ``(error_code, description, exception_obj)``, where: 248 249 * ``error_code``: the numeric CIM status code. See `cim_constants` for 250 constants defining CIM status code values. 251 252 * ``description``: a string (`unicode` or UTF-8 encoded `str`) 253 that is the CIM status description text returned by the server, 254 representing a human readable message describing the error. 255 256 * ``exception_obj``: the underlying exception object that caused this 257 exception to be raised, or ``None``. Will always be ``None``. 258 """ 259 pass
260
261 -class WBEMConnection(object):
262 """ 263 A client's connection to a WBEM server. This is the main class of the 264 PyWBEM client. 265 266 The connection object knows a default CIM namespace, which is used when no 267 namespace is specified on subsequent CIM operations (that support 268 specifying namespaces). Thus, the connection object can be used as a 269 connection to multiple CIM namespaces on a WBEM server (when the namespace 270 is specified on subsequent operations), or as a connection to only the 271 default namespace (this allows omitting the namespace on subsequent 272 operations). 273 274 As usual in HTTP, there is no persistent TCP connection; the connectedness 275 provided by this class is only conceptual. That is, the creation of the 276 connection object does not cause any interaction with the WBEM server, and 277 each subsequent CIM operation performs an independent, state-less 278 HTTP/HTTPS request. 279 280 After creating a `WBEMConnection` object, various methods may be called on 281 the object, which cause CIM operations to be invoked on the WBEM server. 282 All these methods take regular Python objects or objects defined in 283 `cim_types` as arguments, and return the same. 284 The caller does not need to know about the CIM-XML encoding that is used 285 underneath (It should be possible to use a different transport below this 286 layer without disturbing any callers). 287 288 The connection remembers the XML of the last request and last reply if 289 debugging is turned on via the `debug` instance variable of the connection 290 object. 291 This may be useful in debugging: If a problem occurs, you can examine the 292 `last_request` and `last_reply` instance variables of the connection 293 object. These are the prettified XML of request and response, respectively. 294 The real request and response that are sent and received are available in 295 the `last_raw_request` and `last_raw_reply` instance variables of the 296 connection object. 297 298 The methods of this class may raise the following exceptions: 299 300 * Exceptions indicating processing errors: 301 302 - `pywbem.ConnectionError` - A connection with the WBEM server could not 303 be established or broke down. 304 305 - `pywbem.AuthError` - Authentication failed with the WBEM server. 306 307 - `pywbem.ParseError` - The response from the WBEM server cannot be 308 parsed (for example, invalid characters or UTF-8 sequences, ill-formed 309 XML, or invalid CIM-XML). 310 311 - `pywbem.CIMError` - The WBEM server returned an error response with a 312 CIM status code. 313 314 - `pywbem.TimeoutError` - The WBEM server did not respond in time and the 315 client timed out. 316 317 * Exceptions indicating programming errors: 318 319 - `TypeError` 320 - `KeyError` 321 - `ValueError` 322 - ... possibly others ... 323 324 Exceptions indicating programming errors should not happen and should be 325 reported as bugs, unless caused by the code using this class. 326 327 :Ivariables: 328 329 ... 330 All parameters of `__init__` are set as instance variables. 331 332 debug : `bool` 333 A boolean indicating whether logging of the last request and last reply 334 is enabled. 335 336 The initial value of this instance variable is `False`. 337 Debug logging can be enabled for future operations by setting this 338 instance variable to `True`. 339 340 last_request : `unicode` 341 CIM-XML data of the last request sent to the WBEM server 342 on this connection, formatted as prettified XML. Prior to sending the 343 very first request on this connection object, it is `None`. 344 345 last_raw_request : `unicode` 346 CIM-XML data of the last request sent to the WBEM server 347 on this connection, formatted as it was sent. Prior to sending the 348 very first request on this connection object, it is `None`. 349 350 last_reply : `unicode` 351 CIM-XML data of the last response received from the WBEM server 352 on this connection, formatted as prettified XML. Prior to sending the 353 very first request on this connection object, while waiting for any 354 response, it is `None`. 355 356 last_raw_reply : `unicode` 357 CIM-XML data of the last response received from the WBEM server 358 on this connection, formatted as it was received. Prior to sending the 359 very first request on this connection object, while waiting for any 360 response, it is `None`. 361 """ 362
363 - def __init__(self, url, creds=None, default_namespace=DEFAULT_NAMESPACE, 364 x509=None, verify_callback=None, ca_certs=None, 365 no_verification=False, timeout=None):
366 """ 367 Initialize the `WBEMConnection` object. 368 369 :Parameters: 370 371 url : string 372 URL of the WBEM server (e.g. ``"https://10.11.12.13:6988"``). 373 374 TODO: Describe supported formats. 375 376 creds 377 Credentials for authenticating with the WBEM server. Currently, 378 that is always a tuple of ``(userid, password)``, where: 379 380 * ``userid`` is a string that is the userid to be used for 381 authenticating with the WBEM server. 382 383 * ``password`` is a string that is the password for that userid. 384 385 default_namespace : string 386 Optional: Name of the CIM namespace to be used by default (if no 387 namespace is specified for an operation). 388 389 Default: See method definition. 390 391 x509 : dictionary 392 Optional: X.509 certificates for HTTPS to be used instead of the 393 credentials provided in the `creds` parameter. This parameter is 394 used only when the `url` parameter specifies a scheme of ``https``. 395 396 If `None`, certificates are not used (and credentials are used 397 instead). 398 399 Otherwise, certificates are used instead of the credentials, and 400 this parameter must be a dictionary containing the following 401 key/value pairs: 402 403 * ``'cert_file'`` : The file path of a file containing an X.509 404 certificate. 405 406 * ``'key_file'`` : The file path of a file containing the private 407 key belonging to the public key that is part of the X.509 408 certificate file. 409 410 Default: `None`. 411 412 verify_callback : function 413 Optional: Registers a callback function that will be called to 414 verify the certificate returned by the WBEM server during the SSL 415 handshake, in addition to the verification alreay performed by 416 `M2Crypto`. 417 418 If `None`, no such callback function will be registered. 419 420 The specified function will be called for the returned certificate, 421 and for each of the certificates in its chain of trust. 422 423 See `M2Crypto.SSL.Context.set_verify` for details, as well as 424 http://blog.san-ss.com.ar/2012/05/validating-ssl-certificate-in-python.html): 425 426 The callback function must take five parameters: 427 428 * the `M2Crypto.SSL.Connection` object that triggered the 429 verification. 430 431 * an `OpenSSL.crypto.X509` object representing the certificate 432 to be validated (the returned certificate or one of the 433 certificates in its chain of trust). 434 435 * an integer containing the error number (0 in case no error) of 436 any validation error detected by `M2Crypto`. 437 You can find their meaning in the OpenSSL documentation. 438 439 * an integer indicating the depth (=position) of the certificate to 440 be validated (the one in the second parameter) in the chain of 441 trust of the returned certificate. A value of 0 indicates 442 that the returned is currently validated; any other value 443 indicates the distance of the currently validated certificate to 444 the returned certificate in its chain of trust. 445 446 * an integer that indicates whether the validation of the 447 certificate specified in the second argument passed or did not 448 pass the validation by `M2Crypto`. A value of 1 indicates a 449 successful validation and 0 an unsuccessful one. 450 451 The callback function must return `True` if the verification 452 passes and `False` otherwise. 453 454 Default: `None`. 455 456 ca_certs : string 457 Optional: Location of CA certificates (trusted certificates) for 458 verification purposes. 459 460 The parameter value is either the directory path of a directory 461 prepared using the ``c_rehash`` tool included with OpenSSL, or the 462 file path of a file in PEM format. 463 464 If `None`, the default system path will be used. 465 466 Default: `None`. 467 468 no_verification : `bool` 469 Optional: Indicates that verification of the certificate returned 470 by the WBEM server is disabled (both by `M2Crypto` and by the 471 callback function specified in `verify_callback`). 472 473 Disabling the verification is insecure and should be avoided. 474 475 If `True`, verification is disabled; otherwise, it is enabled. 476 477 Default: `False`. 478 479 timeout : number 480 Timeout in seconds, for requests sent to the server. If the server 481 did not respond within the timeout duration, the socket for the 482 connection will be closed, causing a `TimeoutError` to be raised. 483 484 A value of ``None`` means there is no timeout. 485 486 A value of ``0`` means the timeout is very short, and does not 487 really make any sense. 488 489 Note that not all situations can be handled within this timeout, so 490 for some issues, operations may take longer before raising an 491 exception. 492 493 :Exceptions: 494 495 See the list of exceptions described in `WBEMConnection`. 496 """ 497 498 self.url = url 499 self.creds = creds 500 self.x509 = x509 501 self.verify_callback = verify_callback 502 self.ca_certs = ca_certs 503 self.no_verification = no_verification 504 self.default_namespace = default_namespace 505 self.timeout = timeout 506 507 self.debug = False 508 self.last_raw_request = None 509 self.last_raw_reply = None 510 self.last_request = None 511 self.last_reply = None
512
513 - def __repr__(self):
514 """ 515 Return a representation of the connection object with the major 516 instance variables, except for the password in the credentials. 517 518 TODO: Change to show all instance variables. 519 """ 520 if self.creds is None: 521 user = 'anonymous' 522 else: 523 user = 'user=%s' % `self.creds[0]` 524 return "%s(%s, %s, namespace=%s)" % \ 525 (self.__class__.__name__, `self.url`, user, 526 `self.default_namespace`)
527
528 - def imethodcall(self, methodname, namespace, **params):
529 """ 530 Perform an intrinsic method call (= CIM operation). 531 532 This is a low-level function that is used by the operation-specific 533 methods of this class (e.g. `EnumerateInstanceNames`). In general, 534 clients should call these operation-specific methods instead of this 535 function. 536 537 The parameters are automatically converted to the right CIM-XML 538 elements. 539 540 :Returns: 541 542 A tupletree (see `tupletree` module) with an ``IRETURNVALUE`` 543 element at the root. 544 545 :Exceptions: 546 547 See the list of exceptions described in `WBEMConnection`. 548 """ 549 550 # Create HTTP headers 551 552 headers = ['CIMOperation: MethodCall', 553 'CIMMethod: %s' % methodname, 554 cim_http.get_object_header(namespace)] 555 556 # Create parameter list 557 558 plist = map(lambda x: 559 cim_xml.IPARAMVALUE(x[0], cim_obj.tocimxml(x[1])), 560 params.items()) 561 562 # Build XML request 563 564 req_xml = cim_xml.CIM( 565 cim_xml.MESSAGE( 566 cim_xml.SIMPLEREQ( 567 cim_xml.IMETHODCALL( 568 methodname, 569 cim_xml.LOCALNAMESPACEPATH( 570 [cim_xml.NAMESPACE(ns) 571 for ns in string.split(namespace, '/')]), 572 plist)), 573 '1001', '1.0'), 574 '2.0', '2.0') 575 576 if self.debug: 577 self.last_raw_request = req_xml.toxml() 578 self.last_request = req_xml.toprettyxml(indent=' ') 579 # Reset replies in case we fail before they are set 580 self.last_raw_reply = None 581 self.last_reply = None 582 583 # Send request and receive response 584 585 try: 586 reply_xml = cim_http.wbem_request( 587 self.url, req_xml.toxml(), self.creds, headers, 588 x509=self.x509, 589 verify_callback=self.verify_callback, 590 ca_certs=self.ca_certs, 591 no_verification=self.no_verification, 592 timeout=self.timeout) 593 except (cim_http.AuthError, cim_http.ConnectionError, 594 cim_http.TimeoutError, cim_http.Error): 595 raise 596 597 # Set the raw response before parsing (which can fail) 598 if self.debug: 599 self.last_raw_reply = reply_xml 600 601 try: 602 reply_dom = minidom.parseString(reply_xml) 603 except ParseError as exc: 604 msg = str(exc) 605 parsing_error = True 606 except ExpatError as exc: 607 # This is raised e.g. when XML numeric entity references of invalid 608 # XML characters are used (e.g. '&#0;'). 609 # str(exc) is: "{message}, line {X}, offset {Y}" 610 parsed_line = str(reply_xml).splitlines()[exc.lineno-1] 611 msg = "ExpatError %s: %s: %r" % (str(exc.code), str(exc), 612 parsed_line) 613 parsing_error = True 614 else: 615 parsing_error = False 616 617 if parsing_error or self.debug: 618 # Here we just improve the quality of the exception information, 619 # so we do this only if it already has failed. Because the check 620 # function we invoke catches more errors than minidom.parseString, 621 # we call it also when debug is turned on. 622 try: 623 check_utf8_xml_chars(reply_xml, "CIM-XML response") 624 except ParseError: 625 raise 626 else: 627 if parsing_error: 628 # We did not catch it in the check function, but 629 # minidom.parseString() failed. 630 raise ParseError(msg) # data from previous exception 631 632 if self.debug: 633 pretty_reply = reply_dom.toprettyxml(indent=' ') 634 self.last_reply = re.sub(r'>( *[\r\n]+)+( *)<', r'>\n\2<', 635 pretty_reply) # remove extra empty lines 636 637 # Parse response 638 639 tt = tupleparse.parse_cim(tupletree.dom_to_tupletree(reply_dom)) 640 641 if tt[0] != 'CIM': 642 raise ParseError('Expecting CIM element, got %s' % tt[0]) 643 tt = tt[2] 644 645 if tt[0] != 'MESSAGE': 646 raise ParseError('Expecting MESSAGE element, got %s' % tt[0]) 647 tt = tt[2] 648 649 if len(tt) != 1 or tt[0][0] != 'SIMPLERSP': 650 raise ParseError('Expecting one SIMPLERSP element') 651 tt = tt[0][2] 652 653 if tt[0] != 'IMETHODRESPONSE': 654 raise ParseError('Expecting IMETHODRESPONSE element, got %s' %\ 655 tt[0]) 656 657 if tt[1]['NAME'] != methodname: 658 raise ParseError('Expecting attribute NAME=%s, got %s' %\ 659 (methodname, tt[1]['NAME'])) 660 tt = tt[2] 661 662 # At this point we either have a IRETURNVALUE, ERROR element 663 # or None if there was no child nodes of the IMETHODRESPONSE 664 # element. 665 666 if tt is None: 667 return None 668 669 if tt[0] == 'ERROR': 670 code = int(tt[1]['CODE']) 671 if tt[1].has_key('DESCRIPTION'): 672 raise CIMError(code, tt[1]['DESCRIPTION']) 673 raise CIMError(code, 'Error code %s' % tt[1]['CODE']) 674 675 if tt[0] != 'IRETURNVALUE': 676 raise ParseError('Expecting IRETURNVALUE element, got %s' % tt[0]) 677 678 return tt
679
680 - def methodcall(self, methodname, localobject, Params=None, **params):
681 """ 682 Perform an extrinsic method call (= CIM method invocation). 683 684 This is a low-level function that is used by the 'InvokeMethod' 685 method of this class. In general, clients should use 'InvokeMethod' 686 instead of this function. 687 688 The Python method parameters are automatically converted to the right 689 CIM-XML elements. See `InvokeMethod` for details. 690 691 :Returns: 692 693 A tupletree (see `tupletree` module) with a ``RETURNVALUE`` 694 element at the root. 695 696 :Exceptions: 697 698 See the list of exceptions described in `WBEMConnection`. 699 """ 700 701 # METHODCALL only takes a LOCALCLASSPATH or LOCALINSTANCEPATH 702 if hasattr(localobject, 'host') and localobject.host is not None: 703 localobject = localobject.copy() 704 localobject.host = None 705 706 # Create HTTP headers 707 708 headers = ['CIMOperation: MethodCall', 709 'CIMMethod: %s' % methodname, 710 cim_http.get_object_header(localobject)] 711 712 # Create parameter list 713 714 def paramtype(obj): 715 """Return a string to be used as the CIMTYPE for a parameter.""" 716 if isinstance(obj, cim_types.CIMType): 717 return obj.cimtype 718 elif type(obj) == bool: 719 return 'boolean' 720 elif isinstance(obj, StringTypes): 721 return 'string' 722 elif isinstance(obj, (datetime, timedelta)): 723 return 'datetime' 724 elif isinstance(obj, (CIMClassName, CIMInstanceName)): 725 return 'reference' 726 elif isinstance(obj, (CIMClass, CIMInstance)): 727 return 'string' 728 elif isinstance(obj, list): 729 if obj: 730 return paramtype(obj[0]) 731 else: 732 return None 733 raise TypeError('Unsupported parameter type "%s"' % type(obj))
734 735 def paramvalue(obj): 736 """Return a cim_xml node to be used as the value for a 737 parameter.""" 738 if isinstance(obj, (datetime, timedelta)): 739 obj = cim_types.CIMDateTime(obj) 740 if isinstance(obj, (cim_types.CIMType, bool, StringTypes)): 741 return cim_xml.VALUE(cim_types.atomic_to_cim_xml(obj)) 742 if isinstance(obj, (CIMClassName, CIMInstanceName)): 743 return cim_xml.VALUE_REFERENCE(obj.tocimxml()) 744 if isinstance(obj, (CIMClass, CIMInstance)): 745 return cim_xml.VALUE(obj.tocimxml().toxml()) 746 if isinstance(obj, list): 747 if obj and isinstance(obj[0], (CIMClassName, CIMInstanceName)): 748 return cim_xml.VALUE_REFARRAY([paramvalue(x) for x in obj]) 749 return cim_xml.VALUE_ARRAY([paramvalue(x) for x in obj]) 750 raise TypeError('Unsupported parameter type "%s"' % type(obj))
751 752 def is_embedded(obj): 753 """Determine if an object requires an EmbeddedObject attribute""" 754 if isinstance(obj, list) and obj: 755 return is_embedded(obj[0]) 756 elif isinstance(obj, CIMClass): 757 return 'object' 758 elif isinstance(obj, CIMInstance): 759 return 'instance' 760 return None 761 762 if Params is None: 763 Params = [] 764 plist = [cim_xml.PARAMVALUE(x[0], 765 paramvalue(x[1]), 766 paramtype(x[1]), 767 embedded_object=is_embedded(x[1])) 768 for x in Params] 769 plist += [cim_xml.PARAMVALUE(x[0], 770 paramvalue(x[1]), 771 paramtype(x[1]), 772 embedded_object=is_embedded(x[1])) 773 for x in params.items()] 774 775 # Build XML request 776 777 req_xml = cim_xml.CIM( 778 cim_xml.MESSAGE( 779 cim_xml.SIMPLEREQ( 780 cim_xml.METHODCALL( 781 methodname, 782 localobject.tocimxml(), 783 plist)), 784 '1001', '1.0'), 785 '2.0', '2.0') 786 787 if self.debug: 788 self.last_raw_request = req_xml.toxml() 789 self.last_request = req_xml.toprettyxml(indent=' ') 790 # Reset replies in case we fail before they are set 791 self.last_raw_reply = None 792 self.last_reply = None 793 794 # Send request and receive response 795 796 try: 797 reply_xml = cim_http.wbem_request( 798 self.url, req_xml.toxml(), self.creds, headers, 799 x509=self.x509, 800 verify_callback=self.verify_callback, 801 ca_certs=self.ca_certs, 802 no_verification=self.no_verification, 803 timeout=self.timeout) 804 except (cim_http.AuthError, cim_http.ConnectionError, 805 cim_http.TimeoutError, cim_http.Error): 806 raise 807 808 # Set the raw response before parsing and checking (which can fail) 809 if self.debug: 810 self.last_raw_reply = reply_xml 811 812 try: 813 reply_dom = minidom.parseString(reply_xml) 814 except ParseError as exc: 815 msg = str(exc) 816 parsing_error = True 817 except ExpatError as exc: 818 # This is raised e.g. when XML numeric entity references of invalid 819 # XML characters are used (e.g. '&#0;'). 820 # str(exc) is: "{message}, line {X}, offset {Y}" 821 parsed_line = str(reply_xml).splitlines()[exc.lineno-1] 822 msg = "ExpatError %s: %s: %r" % (str(exc.code), str(exc), 823 parsed_line) 824 parsing_error = True 825 else: 826 parsing_error = False 827 828 if parsing_error or self.debug: 829 # Here we just improve the quality of the exception information, 830 # so we do this only if it already has failed. Because the check 831 # function we invoke catches more errors than minidom.parseString, 832 # we call it also when debug is turned on. 833 try: 834 check_utf8_xml_chars(reply_xml, "CIM-XML response") 835 except ParseError: 836 raise 837 else: 838 if parsing_error: 839 # We did not catch it in the check function, but 840 # minidom.parseString() failed. 841 raise ParseError(msg) # data from previous exception 842 843 if self.debug: 844 pretty_reply = reply_dom.toprettyxml(indent=' ') 845 self.last_reply = re.sub(r'>( *[\r\n]+)+( *)<', r'>\n\2<', 846 pretty_reply) # remove extra empty lines 847 848 # Parse response 849 850 tt = tupleparse.parse_cim(tupletree.dom_to_tupletree(reply_dom)) 851 852 if tt[0] != 'CIM': 853 raise ParseError('Expecting CIM element, got %s' % tt[0]) 854 tt = tt[2] 855 856 if tt[0] != 'MESSAGE': 857 raise ParseError('Expecting MESSAGE element, got %s' % tt[0]) 858 tt = tt[2] 859 860 if len(tt) != 1 or tt[0][0] != 'SIMPLERSP': 861 raise ParseError('Expecting one SIMPLERSP element') 862 tt = tt[0][2] 863 864 if tt[0] != 'METHODRESPONSE': 865 raise ParseError('Expecting METHODRESPONSE element, got %s' %\ 866 tt[0]) 867 868 if tt[1]['NAME'] != methodname: 869 raise ParseError('Expecting attribute NAME=%s, got %s' %\ 870 (methodname, tt[1]['NAME'])) 871 tt = tt[2] 872 873 # At this point we have an optional RETURNVALUE and zero or 874 # more PARAMVALUE elements representing output parameters. 875 876 if len(tt) > 0 and tt[0][0] == 'ERROR': 877 code = int(tt[0][1]['CODE']) 878 if tt[0][1].has_key('DESCRIPTION'): 879 raise CIMError(code, tt[0][1]['DESCRIPTION']) 880 raise CIMError(code, 'Error code %s' % tt[0][1]['CODE']) 881 882 return tt 883 884 # 885 # Instance provider API 886 # 887
888 - def EnumerateInstanceNames(self, ClassName, namespace=None, **params):
889 # pylint: disable=invalid-name 890 """ 891 Enumerate the instance paths of instances of a class (including 892 instances of its subclasses). 893 894 This method performs the EnumerateInstanceNames CIM-XML operation. 895 If the operation succeeds, this method returns. 896 Otherwise, this method raises an exception. 897 898 :Parameters: 899 900 ClassName : string 901 Name of the class to be enumerated. 902 903 namespace : string 904 Optional: Name of the CIM namespace to be used. The value `None` 905 causes the default namespace of the connection object to be used. 906 907 Default: `None`. 908 909 :Returns: 910 911 A list of `CIMInstanceName` objects that are the enumerated 912 instance paths. 913 914 :Exceptions: 915 916 See the list of exceptions described in `WBEMConnection`. 917 """ 918 919 if namespace is None: 920 namespace = self.default_namespace 921 922 result = self.imethodcall( 923 'EnumerateInstanceNames', 924 namespace, 925 ClassName=CIMClassName(ClassName), 926 **params) 927 928 names = [] 929 930 if result is not None: 931 names = result[2] 932 933 [setattr(n, 'namespace', namespace) for n in names] 934 935 return names
936
937 - def EnumerateInstances(self, ClassName, namespace=None, **params):
938 # pylint: disable=invalid-name 939 """ 940 Enumerate the instances of a class (including instances of its 941 subclasses). 942 943 This method performs the EnumerateInstances CIM-XML operation. 944 If the operation succeeds, this method returns. 945 Otherwise, this method raises an exception. 946 947 :Parameters: 948 949 ClassName : string 950 Name of the class to be enumerated. 951 952 namespace : string 953 Optional: Name of the CIM namespace to be used. The value `None` 954 causes the default namespace of the connection object to be used. 955 956 Default: `None`. 957 958 LocalOnly : `bool` 959 Optional: Controls the exclusion of inherited properties from the 960 returned instances, as follows: 961 962 * If `False`, inherited properties are not excluded. 963 * If `True`, the behavior is WBEM server specific. 964 965 Default: `True`. 966 967 This parameter has been deprecated in CIM-XML and should be set to 968 `False` by the caller. 969 970 DeepInheritance : `bool` 971 Optional: Indicates that properties added by subclasses of the 972 specified class are to be included in the returned instances. 973 Note, the semantics of this parameter differs between instance and 974 class level operations. 975 976 Default: `True`. 977 978 IncludeQualifiers : `bool` 979 Optional: Indicates that qualifiers are to be included in the 980 returned instance. 981 982 Default: `False`. 983 984 This parameter has been deprecated in CIM-XML. Clients cannot rely 985 on it being implemented by WBEM servers. 986 987 IncludeClassOrigin : `bool` 988 Optional: Indicates that class origin information is to be included 989 on each property in the returned instances. 990 991 Default: `False`. 992 993 PropertyList : iterable of string 994 Optional: An iterable specifying the names of the properties to be 995 included in the returned instances. An empty iterable indicates to 996 include no properties. A value of `None` for this parameter 997 indicates to include all properties. 998 999 Default: `None`. 1000 1001 :Returns: 1002 1003 A list of `CIMInstance` objects that are representations of 1004 the enumerated instances. 1005 1006 :Exceptions: 1007 1008 See the list of exceptions described in `WBEMConnection`. 1009 """ 1010 1011 if namespace is None: 1012 namespace = self.default_namespace 1013 1014 result = self.imethodcall( 1015 'EnumerateInstances', 1016 namespace, 1017 ClassName=CIMClassName(ClassName), 1018 **params) 1019 1020 instances = [] 1021 1022 if result is not None: 1023 instances = result[2] 1024 1025 [setattr(i.path, 'namespace', namespace) for i in instances] 1026 1027 return instances
1028
1029 - def GetInstance(self, InstanceName, **params):
1030 # pylint: disable=invalid-name 1031 """ 1032 Retrieve an instance. 1033 1034 This method performs the GetInstance CIM-XML operation. 1035 If the operation succeeds, this method returns. 1036 Otherwise, this method raises an exception. 1037 1038 :Parameters: 1039 1040 InstanceName : `CIMInstanceName` 1041 Instance path of the instance to be retrieved. 1042 1043 LocalOnly : `bool` 1044 Optional: Controls the exclusion of inherited properties from the 1045 returned instance, as follows: 1046 1047 * If `False`, inherited properties are not excluded. 1048 * If `True`, the behavior is WBEM server specific. 1049 1050 Default: `True`. 1051 1052 This parameter has been deprecated in CIM-XML and should be set to 1053 `False` by the caller. 1054 1055 IncludeQualifiers : `bool` 1056 Optional: Indicates that qualifiers are to be included in the 1057 returned instance. 1058 1059 Default: `False`. 1060 1061 This parameter has been deprecated in CIM-XML. Clients cannot rely 1062 on it being implemented by WBEM servers. 1063 1064 IncludeClassOrigin : `bool` 1065 Optional: Indicates that class origin information is to be included 1066 on each property in the returned instance. 1067 1068 Default: `False`. 1069 1070 PropertyList : iterable of string 1071 Optional: An iterable specifying the names of the properties to be 1072 included in the returned instances. An empty iterable indicates to 1073 include no properties. A value of `None` for this parameter 1074 indicates to include all properties. 1075 1076 Default: `None`. 1077 1078 :Returns: 1079 1080 A `CIMInstance` object that is a representation of the 1081 retrieved instance. 1082 1083 :Exceptions: 1084 1085 See the list of exceptions described in `WBEMConnection`. 1086 """ 1087 1088 # Strip off host and namespace to make this a "local" object 1089 1090 iname = InstanceName.copy() 1091 iname.host = None 1092 iname.namespace = None 1093 1094 if InstanceName.namespace is None: 1095 namespace = self.default_namespace 1096 else: 1097 namespace = InstanceName.namespace 1098 1099 result = self.imethodcall( 1100 'GetInstance', 1101 namespace, 1102 InstanceName=iname, 1103 **params) 1104 1105 instance = result[2][0] 1106 instance.path = InstanceName 1107 instance.path.namespace = namespace 1108 1109 return instance
1110
1111 - def DeleteInstance(self, InstanceName, **params):
1112 # pylint: disable=invalid-name 1113 """ 1114 Delete an instance. 1115 1116 This method performs the DeleteInstance CIM-XML operation. 1117 If the operation succeeds, this method returns. 1118 Otherwise, this method raises an exception. 1119 1120 :Parameters: 1121 1122 InstanceName : `CIMInstanceName` 1123 Instance path of the instance to be deleted. 1124 1125 :Exceptions: 1126 1127 See the list of exceptions described in `WBEMConnection`. 1128 """ 1129 1130 # Strip off host and namespace to make this a "local" object 1131 1132 iname = InstanceName.copy() 1133 iname.host = None 1134 iname.namespace = None 1135 1136 if InstanceName.namespace is None: 1137 namespace = self.default_namespace 1138 else: 1139 namespace = InstanceName.namespace 1140 1141 self.imethodcall( 1142 'DeleteInstance', 1143 namespace, 1144 InstanceName=iname, 1145 **params)
1146
1147 - def CreateInstance(self, NewInstance, **params):
1148 # pylint: disable=invalid-name 1149 """ 1150 Create an instance. 1151 1152 This method performs the CreateInstance CIM-XML operation. 1153 If the operation succeeds, this method returns. 1154 Otherwise, this method raises an exception. 1155 1156 :Parameters: 1157 1158 NewInstance : `CIMInstance` 1159 A representation of the instance to be created. 1160 1161 The `namespace` and `classname` instance variables of this object 1162 specify CIM namespace and creation class for the new instance, 1163 respectively. 1164 An instance path specified using the `path` instance variable of 1165 this object will be ignored. 1166 1167 The `properties` instance variable of this object specifies initial 1168 property values for the new instance. 1169 1170 Instance-level qualifiers have been deprecated in CIM, so any 1171 qualifier values specified using the `qualifiers` instance variable 1172 of this object will be ignored. 1173 1174 :Returns: 1175 1176 `CIMInstanceName` object that is the instance path of the new 1177 instance. 1178 1179 :Exceptions: 1180 1181 See the list of exceptions described in `WBEMConnection`. 1182 """ 1183 1184 # Take namespace path from object parameter 1185 1186 if NewInstance.path is not None and \ 1187 NewInstance.path.namespace is not None: 1188 namespace = NewInstance.path.namespace 1189 else: 1190 namespace = self.default_namespace 1191 1192 # Strip off path to avoid producing a VALUE.NAMEDINSTANCE 1193 # element instead of an INSTANCE element. 1194 1195 instance = NewInstance.copy() 1196 instance.path = None 1197 1198 result = self.imethodcall( 1199 'CreateInstance', 1200 namespace, 1201 NewInstance=instance, 1202 **params) 1203 1204 name = result[2][0] 1205 name.namespace = namespace 1206 1207 return name
1208
1209 - def ModifyInstance(self, ModifiedInstance, **params):
1210 # pylint: disable=invalid-name 1211 """ 1212 Modify the property values of an instance. 1213 1214 This method performs the ModifyInstance CIM-XML operation. 1215 If the operation succeeds, this method returns. 1216 Otherwise, this method raises an exception. 1217 1218 :Parameters: 1219 1220 ModifiedInstance : `CIMInstance` 1221 A representation of the modified instance. This object needs to 1222 contain any new property values and the instance path of the 1223 instance to be modified. Missing properties (relative to the class 1224 declaration) and properties provided with a value of `None` will be 1225 set to NULL. Typically, this object has been retrieved by other 1226 operations, such as GetInstance. 1227 1228 IncludeQualifiers : `bool` 1229 Optional: Indicates that qualifiers are to be modified as specified 1230 in the `ModifiedInstance` parameter. 1231 1232 Default: `True`. 1233 1234 This parameter has been deprecated in CIM-XML. Clients cannot rely 1235 on it being implemented by WBEM servers. 1236 1237 PropertyList : iterable of string 1238 Optional: An iterable specifying the names of the properties to be 1239 modified. An empty iterable indicates to modify no properties. A 1240 value of `None` for this parameter indicates to modify all 1241 properties. 1242 1243 Default: `None`. 1244 1245 :Exceptions: 1246 1247 See the list of exceptions described in `WBEMConnection`. 1248 """ 1249 1250 # Must pass a named CIMInstance here (i.e path attribute set) 1251 1252 if ModifiedInstance.path is None: 1253 raise ValueError( 1254 'ModifiedInstance parameter must have path attribute set') 1255 1256 # Take namespace path from object parameter 1257 1258 if ModifiedInstance.path.namespace is None: 1259 namespace = self.default_namespace 1260 else: 1261 namespace = ModifiedInstance.path.namespace 1262 1263 instance = ModifiedInstance.copy() 1264 instance.path.namespace = None 1265 1266 self.imethodcall( 1267 'ModifyInstance', 1268 namespace, 1269 ModifiedInstance=instance, 1270 **params)
1271
1272 - def ExecQuery(self, QueryLanguage, Query, namespace=None):
1273 # pylint: disable=invalid-name 1274 """ 1275 Execute a query in a namespace. 1276 1277 This method performs the ExecQuery CIM-XML operation. 1278 If the operation succeeds, this method returns. 1279 Otherwise, this method raises an exception. 1280 1281 :Parameters: 1282 1283 QueryLanguage : string 1284 Name of the query language used in the `Query` parameter. 1285 1286 Query : string 1287 Query string in the query language specified in the `QueryLanguage` 1288 parameter. 1289 1290 namespace : string 1291 Optional: Name of the CIM namespace to be used. The value `None` 1292 causes the default namespace of the connection object to be used. 1293 1294 Default: `None`. 1295 1296 :Returns: 1297 1298 A list of `CIMInstance` objects that represents the query 1299 result. 1300 These instances have their `path` instance variable set to identify 1301 their creation class and the target namespace of the query, but 1302 they are not addressable instances. 1303 1304 :Exceptions: 1305 1306 See the list of exceptions described in `WBEMConnection`. 1307 """ 1308 1309 if namespace is None: 1310 namespace = self.default_namespace 1311 1312 result = self.imethodcall( 1313 'ExecQuery', 1314 namespace, 1315 QueryLanguage=QueryLanguage, 1316 Query=Query) 1317 1318 instances = [] 1319 1320 if result is not None: 1321 instances = [tt[2] for tt in result[2]] 1322 1323 [setattr(i.path, 'namespace', namespace) for i in instances] 1324 1325 return instances
1326 1327 # 1328 # Schema management API 1329 # 1330
1331 - def _map_classname_param(self, params):
1332 """Convert string ClassName parameter to a CIMClassName.""" 1333 1334 if params.has_key('ClassName') and \ 1335 isinstance(params['ClassName'], StringTypes): 1336 params['ClassName'] = CIMClassName(params['ClassName']) 1337 1338 return params
1339
1340 - def EnumerateClassNames(self, namespace=None, **params):
1341 # pylint: disable=invalid-name 1342 """ 1343 Enumerate the names of subclasses of a class, or of the top-level 1344 classes in a namespace. 1345 1346 This method performs the EnumerateClassNames CIM-XML operation. 1347 If the operation succeeds, this method returns. 1348 Otherwise, this method raises an exception. 1349 1350 :Parameters: 1351 1352 namespace : string 1353 Optional: Name of the namespace of the class, as a string. 1354 The value `None` causes the default namespace of the connection to 1355 be used. 1356 1357 Default: `None` 1358 1359 ClassName : string 1360 Optional: Name of the class whose subclasses are to be retrieved. 1361 The value `None` causes the top-level classes in the namespace to 1362 be retrieved. 1363 1364 Default: `None` 1365 1366 DeepInheritance : `bool` 1367 Optional: Indicates that all (direct and indirect) subclasses of 1368 the specified class or of the top-level classes are to be included 1369 in the result. 1370 `False` indicates that only direct subclasses of the specified 1371 class or ony top-level classes are to be included in the result. 1372 1373 Note, the semantics of this parameter differs between instance and 1374 class level operations. 1375 1376 Default: `False`. 1377 1378 :Returns: 1379 1380 A list of strings that are the class names of the enumerated 1381 classes. 1382 1383 :Exceptions: 1384 1385 See the list of exceptions described in `WBEMConnection`. 1386 """ 1387 1388 params = self._map_classname_param(params) 1389 1390 if namespace is None: 1391 namespace = self.default_namespace 1392 1393 result = self.imethodcall( 1394 'EnumerateClassNames', 1395 namespace, 1396 **params) 1397 1398 if result is None: 1399 return [] 1400 else: 1401 return map(lambda x: x.classname, result[2])
1402
1403 - def EnumerateClasses(self, namespace=None, **params):
1404 # pylint: disable=invalid-name 1405 """ 1406 Enumerate the subclasses of a class, or the top-level classes in a 1407 namespace. 1408 1409 This method performs the EnumerateClasses CIM-XML operation. 1410 If the operation succeeds, this method returns. 1411 Otherwise, this method raises an exception. 1412 1413 :Parameters: 1414 1415 namespace : string 1416 Optional: Name of the namespace of the class, as a string. 1417 The value `None` causes the default namespace of the connection to 1418 be used. 1419 1420 Default: `None` 1421 1422 ClassName : string 1423 Optional: Name of the class whose subclasses are to be retrieved. 1424 The value `None` causes the top-level classes in the namespace to 1425 be retrieved. 1426 1427 Default: `None` 1428 1429 DeepInheritance : `bool` 1430 Optional: Indicates that all (direct and indirect) subclasses of 1431 the specified class or of the top-level classes are to be included 1432 in the result. 1433 `False` indicates that only direct subclasses of the specified 1434 class or ony top-level classes are to be included in the result. 1435 1436 Note, the semantics of this parameter differs between instance and 1437 class level operations. 1438 1439 Default: `False`. 1440 1441 LocalOnly : `bool` 1442 Optional: Indicates that inherited properties, methods, and 1443 qualifiers are to be excluded from the returned classes. 1444 1445 Default: `True`. 1446 1447 IncludeQualifiers : `bool` 1448 Optional: Indicates that qualifiers are to be included in the 1449 returned classes. 1450 1451 Default: `False`. 1452 1453 IncludeClassOrigin : `bool` 1454 Optional: Indicates that class origin information is to be included 1455 on each property and method in the returned classes. 1456 1457 Default: `False`. 1458 1459 :Returns: 1460 1461 A list of `CIMClass` objects that are representations of the 1462 enumerated classes. 1463 1464 :Exceptions: 1465 1466 See the list of exceptions described in `WBEMConnection`. 1467 """ 1468 1469 params = self._map_classname_param(params) 1470 1471 if namespace is None: 1472 namespace = self.default_namespace 1473 1474 result = self.imethodcall( 1475 'EnumerateClasses', 1476 namespace, 1477 **params) 1478 1479 if result is None: 1480 return [] 1481 1482 return result[2]
1483
1484 - def GetClass(self, ClassName, namespace=None, **params):
1485 # pylint: disable=invalid-name 1486 """ 1487 Retrieve a class. 1488 1489 This method performs the GetClass CIM-XML operation. 1490 If the operation succeeds, this method returns. 1491 Otherwise, this method raises an exception. 1492 1493 :Parameters: 1494 1495 ClassName : string 1496 Name of the class to be retrieved. 1497 1498 namespace : string 1499 Optional: Name of the namespace of the class, as a string. 1500 The value `None` causes the default namespace of the connection to 1501 be used. 1502 1503 Default: `None` 1504 1505 LocalOnly : `bool` 1506 Optional: Indicates that inherited properties, methods, and 1507 qualifiers are to be excluded from the returned class. 1508 1509 Default: `True`. 1510 1511 IncludeQualifiers : `bool` 1512 Optional: Indicates that qualifiers are to be included in the 1513 returned class. 1514 1515 Default: `False`. 1516 1517 IncludeClassOrigin : `bool` 1518 Optional: Indicates that class origin information is to be included 1519 on each property and method in the returned class. 1520 1521 Default: `False`. 1522 1523 PropertyList : iterable of string 1524 Optional: An iterable specifying the names of the properties to be 1525 included in the returned class. An empty iterable indicates to 1526 include no properties. A value of `None` for this parameter 1527 indicates to include all properties. 1528 1529 Default: `None`. 1530 1531 :Returns: 1532 1533 A `CIMClass` object that is a representation of the 1534 retrieved class. 1535 1536 :Exceptions: 1537 1538 See the list of exceptions described in `WBEMConnection`. 1539 """ 1540 1541 params = self._map_classname_param(params) 1542 1543 if namespace is None: 1544 namespace = self.default_namespace 1545 1546 result = self.imethodcall( 1547 'GetClass', 1548 namespace, 1549 ClassName=CIMClassName(ClassName), 1550 **params) 1551 1552 return result[2][0]
1553
1554 - def DeleteClass(self, ClassName, namespace=None, **params):
1555 # pylint: disable=invalid-name 1556 """ 1557 Delete a class. 1558 1559 This method performs the DeleteClass CIM-XML operation. 1560 If the operation succeeds, this method returns. 1561 Otherwise, this method raises an exception. 1562 1563 TODO This method is UNSUPPORTED right now. Test and verify description. 1564 1565 :Parameters: 1566 1567 ClassName : string 1568 Name of the class to be deleted. 1569 1570 namespace : string 1571 Optional: Name of the namespace of the class, as a string. 1572 The value `None` causes the default namespace of the connection to 1573 be used. 1574 1575 Default: `None` 1576 1577 :Exceptions: 1578 1579 See the list of exceptions described in `WBEMConnection`. 1580 """ 1581 1582 params = self._map_classname_param(params) 1583 1584 if namespace is None: 1585 namespace = self.default_namespace 1586 1587 self.imethodcall( 1588 'DeleteClass', 1589 namespace, 1590 ClassName=CIMClassName(ClassName), 1591 **params)
1592
1593 - def ModifyClass(self, ModifiedClass, namespace=None, **params):
1594 # pylint: disable=invalid-name 1595 """ 1596 Modify a class. 1597 1598 This method performs the ModifyClass CIM-XML operation. 1599 If the operation succeeds, this method returns. 1600 Otherwise, this method raises an exception. 1601 1602 TODO This method is UNSUPPORTED right now. Test and verify description. 1603 1604 :Parameters: 1605 1606 ModifiedClass : `CIMClass` 1607 A representation of the modified class. This object needs to 1608 contain any modified properties, methods and qualifiers and the 1609 class path of the class to be modified. 1610 Typically, this object has been retrieved by other operations, such 1611 as GetClass. 1612 1613 :Exceptions: 1614 1615 See the list of exceptions described in `WBEMConnection`. 1616 """ 1617 1618 if namespace is None: 1619 namespace = self.default_namespace 1620 1621 self.imethodcall( 1622 'ModifyClass', 1623 namespace, 1624 ModifiedClass=ModifiedClass, 1625 **params)
1626
1627 - def CreateClass(self, NewClass, namespace=None, **params):
1628 # pylint: disable=invalid-name 1629 """ 1630 Create a class. 1631 1632 This method performs the ModifyClass CIM-XML operation. 1633 If the operation succeeds, this method returns. 1634 Otherwise, this method raises an exception. 1635 1636 TODO This method is UNSUPPORTED right now. Test and verify description. 1637 1638 :Parameters: 1639 1640 NewClass : `CIMClass` 1641 A representation of the class to be created. This object needs to 1642 contain any properties, methods, qualifiers, superclass name, and 1643 the class name of the class to be created. 1644 The class path in this object (`path` instance variable) will be 1645 ignored. 1646 1647 namespace : string 1648 Optional: Name of the namespace in which the class is to be 1649 created. The value `None` causes the default namespace of the 1650 connection to be used. 1651 1652 Default: `None` 1653 1654 :Exceptions: 1655 1656 See the list of exceptions described in `WBEMConnection`. 1657 """ 1658 1659 if namespace is None: 1660 namespace = self.default_namespace 1661 1662 self.imethodcall( 1663 'CreateClass', 1664 namespace, 1665 NewClass=NewClass, 1666 **params)
1667 1668 # 1669 # Association provider API 1670 # 1671
1672 - def _add_objectname_param(self, params, object):
1673 """Add an object name (either a class name or an instance 1674 name) to a dictionary of parameter names.""" 1675 1676 if isinstance(object, (CIMClassName, CIMInstanceName)): 1677 params['ObjectName'] = object.copy() 1678 params['ObjectName'].namespace = None 1679 elif isinstance(object, StringTypes): 1680 params['ObjectName'] = CIMClassName(object) 1681 else: 1682 raise ValueError('Expecting a classname, CIMClassName or ' 1683 'CIMInstanceName object') 1684 1685 return params
1686
1687 - def _map_association_params(self, params):
1688 """Convert various convenience parameters and types into their 1689 correct form for passing to the imethodcall() function.""" 1690 1691 # ResultClass and Role parameters that are strings should be 1692 # mapped to CIMClassName objects. 1693 1694 if params.has_key('ResultClass') and \ 1695 isinstance(params['ResultClass'], StringTypes): 1696 params['ResultClass'] = CIMClassName(params['ResultClass']) 1697 1698 if params.has_key('AssocClass') and \ 1699 isinstance(params['AssocClass'], StringTypes): 1700 params['AssocClass'] = CIMClassName(params['AssocClass']) 1701 1702 return params
1703
1704 - def Associators(self, ObjectName, **params):
1705 # pylint: disable=invalid-name 1706 """ 1707 Retrieve the instances (or classes) associated to a source instance 1708 (or source class). 1709 1710 This method performs the Associators CIM-XML operation. 1711 If the operation succeeds, this method returns. 1712 Otherwise, this method raises an exception. 1713 1714 :Parameters: 1715 1716 ObjectName 1717 For instance level usage: The instance path of the source instance, 1718 as a `CIMInstanceName` object. If that object does not 1719 specify a namespace, the default namespace of the connection is 1720 used. 1721 1722 For class level usage: The class path of the source class, as a 1723 string or as a `CIMClassName` object. 1724 If specified as a string, the string is interpreted as a class name 1725 in the default namespace of the connection. 1726 If specified as a `CIMClassName` object that does not 1727 specify a namespace, the default namespace of the connection is 1728 used. 1729 1730 AssocClass : string or `CIMClassName` 1731 Optional: Class name of an association class, to filter the result 1732 to include only traversals of that association class (or 1733 subclasses). 1734 1735 Default: `None` (no filtering). 1736 1737 ResultClass : string or `CIMClassName` 1738 Optional: Class name of an associated class, to filter the result 1739 to include only traversals to that associated class (or 1740 subclasses). 1741 1742 Default: `None` (no filtering). 1743 1744 Role : string 1745 Optional: Role name (= property name) of the source end, to filter 1746 the result to include only traversals from that source role. 1747 1748 Default: `None` (no filtering). 1749 1750 ResultRole 1751 Optional: Role name (= property name) of the far end, to filter 1752 the result to include only traversals to that far role. 1753 1754 Default: `None` (no filtering). 1755 1756 IncludeQualifiers : `bool` 1757 Optional: Indicates that qualifiers are to be included in the 1758 returned instances (or classes). 1759 1760 Default: `False`. 1761 1762 This parameter has been deprecated in CIM-XML. Clients cannot rely 1763 on it being implemented by WBEM servers. 1764 1765 IncludeClassOrigin : `bool` 1766 Optional: Indicates that class origin information is to be included 1767 on each property or method in the returned instances (or classes). 1768 1769 Default: `False`. 1770 1771 PropertyList : iterable of string 1772 Optional: An iterable specifying the names of the properties to be 1773 included in the returned instances (or classes). An empty iterable 1774 indicates to include no properties. A value of `None` for this 1775 parameter indicates to include all properties. 1776 1777 Default: `None`. 1778 1779 :Returns: 1780 1781 For instance level usage, a list of `CIMInstance` objects 1782 that are representations of the associated instances. 1783 1784 For class level usage, a list of `CIMClass` objects 1785 that are representations the associated classes. 1786 1787 :Exceptions: 1788 1789 See the list of exceptions described in `WBEMConnection`. 1790 """ 1791 1792 params = self._map_association_params(params) 1793 params = self._add_objectname_param(params, ObjectName) 1794 1795 namespace = self.default_namespace 1796 1797 if isinstance(ObjectName, CIMInstanceName) and \ 1798 ObjectName.namespace is not None: 1799 namespace = ObjectName.namespace 1800 1801 result = self.imethodcall( 1802 'Associators', 1803 namespace, 1804 **params) 1805 1806 if result is None: 1807 return [] 1808 1809 return map(lambda x: x[2], result[2])
1810
1811 - def AssociatorNames(self, ObjectName, **params):
1812 # pylint: disable=invalid-name 1813 """ 1814 Retrieve the instance paths of the instances (or class paths of the 1815 classes) associated to a source instance (or source class). 1816 1817 This method performs the AssociatorNames CIM-XML operation. 1818 If the operation succeeds, this method returns. 1819 Otherwise, this method raises an exception. 1820 1821 :Parameters: 1822 1823 ObjectName 1824 For instance level usage: The instance path of the source instance, 1825 as a `CIMInstanceName` object. If that object does not 1826 specify a namespace, the default namespace of the connection is 1827 used. 1828 1829 For class level usage: The class path of the source class, as a 1830 string or as a `CIMClassName` object. 1831 If specified as a string, the string is interpreted as a class name 1832 in the default namespace of the connection. 1833 If specified as a `CIMClassName` object that does not 1834 specify a namespace, the default namespace of the connection is 1835 used. 1836 1837 AssocClass : string or `CIMClassName` 1838 Optional: Class name of an association class, to filter the result 1839 to include only traversals of that association class (or 1840 subclasses). 1841 1842 Default: `None` (no filtering). 1843 1844 ResultClass : string or `CIMClassName` 1845 Optional: Class name of an associated class, to filter the result 1846 to include only traversals to that associated class (or 1847 subclasses). 1848 1849 Default: `None` (no filtering). 1850 1851 Role : string 1852 Optional: Role name (= property name) of the source end, to filter 1853 the result to include only traversals from that source role. 1854 1855 Default: `None` (no filtering). 1856 1857 ResultRole 1858 Optional: Role name (= property name) of the far end, to filter 1859 the result to include only traversals to that far role. 1860 1861 Default: `None` (no filtering). 1862 1863 :Returns: 1864 1865 For instance level usage, a list of `CIMInstanceName` 1866 objects that are the instance paths of the associated instances. 1867 1868 For class level usage, a list of `CIMClassName` objects 1869 that are the class paths of the associated classes. 1870 1871 :Exceptions: 1872 1873 See the list of exceptions described in `WBEMConnection`. 1874 """ 1875 1876 params = self._map_association_params(params) 1877 params = self._add_objectname_param(params, ObjectName) 1878 1879 namespace = self.default_namespace 1880 1881 if isinstance(ObjectName, CIMInstanceName) and \ 1882 ObjectName.namespace is not None: 1883 namespace = ObjectName.namespace 1884 1885 result = self.imethodcall( 1886 'AssociatorNames', 1887 namespace, 1888 **params) 1889 1890 if result is None: 1891 return [] 1892 1893 return map(lambda x: x[2], result[2])
1894
1895 - def References(self, ObjectName, **params):
1896 # pylint: disable=invalid-name 1897 """ 1898 Retrieve the association instances (or association classes) that 1899 reference a source instance (or source class). 1900 1901 This method performs the References CIM-XML operation. 1902 If the operation succeeds, this method returns. 1903 Otherwise, this method raises an exception. 1904 1905 :Parameters: 1906 1907 ObjectName 1908 For instance level usage: The instance path of the source instance, 1909 as a `CIMInstanceName` object. If that object does not 1910 specify a namespace, the default namespace of the connection is 1911 used. 1912 1913 For class level usage: The class path of the source class, as a 1914 string or as a `CIMClassName` object. 1915 If specified as a string, the string is interpreted as a class name 1916 in the default namespace of the connection. 1917 If specified as a `CIMClassName` object that does not 1918 specify a namespace, the default namespace of the connection is 1919 used. 1920 1921 ResultClass : string or `CIMClassName` 1922 Optional: Class name of an association class, to filter the result 1923 to include only traversals of that association class (or 1924 subclasses). 1925 1926 Default: `None` (no filtering). 1927 1928 Role : string 1929 Optional: Role name (= property name) of the source end, to filter 1930 the result to include only traversals from that source role. 1931 1932 Default: `None` (no filtering). 1933 1934 IncludeQualifiers : `bool` 1935 Optional: Indicates that qualifiers are to be included in the 1936 returned instances (or classes). 1937 1938 Default: `False`. 1939 1940 This parameter has been deprecated in CIM-XML. Clients cannot rely 1941 on it being implemented by WBEM servers. 1942 1943 IncludeClassOrigin : `bool` 1944 Optional: Indicates that class origin information is to be included 1945 on each property or method in the returned instances (or classes). 1946 1947 Default: `False`. 1948 1949 PropertyList : iterable of string 1950 Optional: An iterable specifying the names of the properties to be 1951 included in the returned instances (or classes). An empty iterable 1952 indicates to include no properties. A value of `None` for this 1953 parameter indicates to include all properties. 1954 1955 Default: `None`. 1956 1957 :Returns: 1958 1959 For instance level usage, a list of `CIMInstance` objects 1960 that are representations of the referencing association instances. 1961 1962 For class level usage, a list of `CIMClass` objects 1963 that are representations the referencing association classes. 1964 1965 :Exceptions: 1966 1967 See the list of exceptions described in `WBEMConnection`. 1968 """ 1969 1970 params = self._map_association_params(params) 1971 params = self._add_objectname_param(params, ObjectName) 1972 1973 namespace = self.default_namespace 1974 1975 if isinstance(ObjectName, CIMInstanceName) and \ 1976 ObjectName.namespace is not None: 1977 namespace = ObjectName.namespace 1978 1979 result = self.imethodcall( 1980 'References', 1981 namespace, 1982 **params) 1983 1984 if result is None: 1985 return [] 1986 1987 return map(lambda x: x[2], result[2])
1988
1989 - def ReferenceNames(self, ObjectName, **params):
1990 # pylint: disable=invalid-name 1991 """ 1992 Retrieve the instance paths of the association instances (or class 1993 paths of the association classes) that reference a source instance 1994 (or source class). 1995 1996 This method performs the ReferenceNames CIM-XML operation. 1997 If the operation succeeds, this method returns. 1998 Otherwise, this method raises an exception. 1999 2000 :Parameters: 2001 2002 ObjectName 2003 For instance level usage: The instance path of the source instance, 2004 as a `CIMInstanceName` object. If that object does not 2005 specify a namespace, the default namespace of the connection is 2006 used. 2007 2008 For class level usage: The class path of the source class, as a 2009 string or as a `CIMClassName` object. 2010 If specified as a string, the string is interpreted as a class name 2011 in the default namespace of the connection. 2012 If specified as a `CIMClassName` object that does not 2013 specify a namespace, the default namespace of the connection is 2014 used. 2015 2016 ResultClass : string or `CIMClassName` 2017 Optional: Class name of an association class, to filter the result 2018 to include only traversals of that association class (or 2019 subclasses). 2020 2021 Default: `None` (no filtering). 2022 2023 Role : string 2024 Optional: Role name (= property name) of the source end, to filter 2025 the result to include only traversals from that source role. 2026 2027 Default: `None` (no filtering). 2028 2029 :Returns: 2030 2031 For instance level usage, a list of `CIMInstanceName` 2032 objects that are the instance paths of the referencing association 2033 instances. 2034 2035 For class level usage, a list of `CIMClassName` objects 2036 that are the class paths of the referencing association classes. 2037 2038 :Exceptions: 2039 2040 See the list of exceptions described in `WBEMConnection`. 2041 """ 2042 2043 params = self._map_association_params(params) 2044 params = self._add_objectname_param(params, ObjectName) 2045 2046 namespace = self.default_namespace 2047 2048 if isinstance(ObjectName, CIMInstanceName) and \ 2049 ObjectName.namespace is not None: 2050 namespace = ObjectName.namespace 2051 2052 result = self.imethodcall( 2053 'ReferenceNames', 2054 namespace, 2055 **params) 2056 2057 if result is None: 2058 return [] 2059 2060 return map(lambda x: x[2], result[2])
2061 2062 # 2063 # Method provider API 2064 # 2065
2066 - def InvokeMethod(self, MethodName, ObjectName, Params=None, **params):
2067 # pylint: disable=invalid-name 2068 """ 2069 Invoke a method on a target instance or on a target class. 2070 2071 The methods that can be invoked are static and non-static methods 2072 defined in a class (also known as *extrinsic* methods). 2073 Static methods can be invoked on instances and on classes. 2074 Non-static methods can be invoked only on instances. 2075 2076 This method performs the InvokeMethod CIM-XML operation. 2077 If the operation succeeds, this method returns. 2078 Otherwise, this method raises an exception. 2079 2080 Input parameters for the CIM method can be specified in a 2081 order-preserving way using the ``Params`` parameter, and in a 2082 order-agnostic way using the ``**params`` keyword parameters. 2083 2084 :Parameters: 2085 2086 MethodName : string 2087 Name of the method to be invoked (without parenthesis or any 2088 parameter signature). 2089 2090 ObjectName 2091 For instance level usage: The instance path of the target instance, 2092 as a `CIMInstanceName` object. If that object does not 2093 specify a namespace, the default namespace of the connection is 2094 used. 2095 2096 For class level usage: The class path of the target class, as a 2097 string or as a `CIMClassName` object. 2098 If specified as a string, the string is interpreted as a class name 2099 in the default namespace of the connection. 2100 If specified as a `CIMClassName` object that does not 2101 specify a namespace, the default namespace of the connection is 2102 used. 2103 2104 Params 2105 A list of input parameters for the CIM method. 2106 2107 Each list item represents a single input parameter for the CIM 2108 method and must be a ``tuple(name,value)``, where ``name`` is the 2109 parameter name in any lexical case, and ``value`` is the parameter 2110 value as a CIM typed value as described in `cim_types`. 2111 2112 **params 2113 Keyword parameters for the input parameters for the CIM method. 2114 2115 Each keyword parameter represents a single input parameter for the 2116 CIM method, where the key is the parameter name in any lexical 2117 case, and the value is the parameter value as a CIM typed value as 2118 described in `cim_types`. 2119 2120 The overall list of input parameters represented in the CIM-XML 2121 request message that is sent to the WBEM server is formed from 2122 the list of parameters specified in ``Params`` preserving its 2123 order, followed by the set of parameters specified in ``**params`` 2124 in any order. There is no checking for duplicate parameter names 2125 in the PyWBEM client. 2126 2127 2128 :Returns: 2129 2130 A tuple of ``(returnvalue, outparams)``, where: 2131 2132 - ``returnvalue`` : Return value of the CIM method, as a CIM typed 2133 value as described in `cim_types`. 2134 - ``outparams`` : Output parameters of the CIM method, as a 2135 `NocaseDict` dictionary containing all CIM method output 2136 parameters, where the dictionary items have: 2137 2138 * a key that is the CIM parameter name, as a string. 2139 * a value that is the CIM parameter value, as a CIM typed value 2140 as described in `cim_types`. 2141 2142 :Exceptions: 2143 2144 See the list of exceptions described in `WBEMConnection`. 2145 """ 2146 2147 # Convert string to CIMClassName 2148 2149 obj = ObjectName 2150 2151 if isinstance(obj, StringTypes): 2152 obj = CIMClassName(obj, namespace=self.default_namespace) 2153 2154 if isinstance(obj, CIMInstanceName) and obj.namespace is None: 2155 obj = ObjectName.copy() 2156 obj.namespace = self.default_namespace 2157 2158 # Make the method call 2159 2160 result = self.methodcall(MethodName, obj, Params, **params) 2161 2162 # Convert optional RETURNVALUE into a Python object 2163 2164 returnvalue = None 2165 2166 if len(result) > 0 and result[0][0] == 'RETURNVALUE': 2167 2168 returnvalue = cim_obj.tocimobj(result[0][1]['PARAMTYPE'], 2169 result[0][2]) 2170 result = result[1:] 2171 2172 # Convert zero or more PARAMVALUE elements into dictionary 2173 2174 output_params = NocaseDict() 2175 2176 for p in result: 2177 if p[1] == 'reference': 2178 output_params[p[0]] = p[2] 2179 else: 2180 output_params[p[0]] = cim_obj.tocimobj(p[1], p[2]) 2181 2182 return returnvalue, output_params
2183 2184 # 2185 # Qualifiers API 2186 # 2187
2188 - def EnumerateQualifiers(self, namespace=None, **params):
2189 # pylint: disable=invalid-name 2190 """ 2191 Enumerate qualifier types. 2192 2193 Returns a list of `CIMQualifier` objects. 2194 2195 TODO Complete this description. 2196 """ 2197 2198 if namespace is None: 2199 namespace = self.default_namespace 2200 2201 result = self.imethodcall( 2202 'EnumerateQualifiers', 2203 namespace, 2204 **params) 2205 2206 qualifiers = [] 2207 2208 if result is not None: 2209 names = result[2] 2210 else: 2211 names = [] 2212 2213 return names
2214
2215 - def GetQualifier(self, QualifierName, namespace=None, **params):
2216 # pylint: disable=invalid-name 2217 """ 2218 Retrieve a qualifier type. 2219 2220 Returns a `CIMQualifier` object. 2221 2222 TODO Complete this description. 2223 """ 2224 2225 if namespace is None: 2226 namespace = self.default_namespace 2227 2228 result = self.imethodcall( 2229 'GetQualifier', 2230 namespace, 2231 QualifierName=QualifierName, 2232 **params) 2233 2234 if result is not None: 2235 names = result[2][0] 2236 2237 return names
2238
2239 - def SetQualifier(self, QualifierDeclaration, namespace=None, **params):
2240 # pylint: disable=invalid-name 2241 """ 2242 Create or modify a qualifier type. 2243 2244 TODO Complete this description. 2245 """ 2246 2247 if namespace is None: 2248 namespace = self.default_namespace 2249 2250 result = self.imethodcall( 2251 'SetQualifier', 2252 namespace, 2253 QualifierDeclaration=QualifierDeclaration, 2254 **params)
2255
2256 - def DeleteQualifier(self, QualifierName, namespace=None, **params):
2257 # pylint: disable=invalid-name 2258 """ 2259 Delete a qualifier type. 2260 2261 TODO Complete this description. 2262 """ 2263 2264 if namespace is None: 2265 namespace = self.default_namespace 2266 2267 result = self.imethodcall( 2268 'DeleteQualifier', 2269 namespace, 2270 QualifierName=QualifierName, 2271 **params)
2272
2273 -def is_subclass(ch, ns, super, sub):
2274 """Determine if one class is a subclass of another 2275 2276 Keyword Arguments: 2277 ch -- A CIMOMHandle. Either a pycimmb.CIMOMHandle or a 2278 pywbem.WBEMConnection. 2279 ns -- Namespace. 2280 super -- A string containing the super class name. 2281 sub -- The subclass. This can either be a string or a pywbem.CIMClass. 2282 2283 """ 2284 2285 lsuper = super.lower() 2286 if isinstance(sub, CIMClass): 2287 subname = sub.classname 2288 subclass = sub 2289 else: 2290 subname = sub 2291 subclass = None 2292 if subname.lower() == lsuper: 2293 return True 2294 if subclass is None: 2295 subclass = ch.GetClass(subname, 2296 ns, 2297 LocalOnly=True, 2298 IncludeQualifiers=False, 2299 PropertyList=[], 2300 IncludeClassOrigin=False) 2301 while subclass.superclass is not None: 2302 if subclass.superclass.lower() == lsuper: 2303 return True 2304 subclass = ch.GetClass(subclass.superclass, 2305 ns, 2306 LocalOnly=True, 2307 IncludeQualifiers=False, 2308 PropertyList=[], 2309 IncludeClassOrigin=False) 2310 return False
2311
2312 -def PegasusUDSConnection(creds=None, **kwargs):
2313 # pylint: disable=invalid-name 2314 return WBEMConnection('/var/run/tog-pegasus/cimxml.socket', creds, **kwargs)
2315
2316 -def SFCBUDSConnection(creds=None, **kwargs):
2317 # pylint: disable=invalid-name 2318 return WBEMConnection('/tmp/sfcbHttpSocket', creds, **kwargs)
2319
2320 -def OpenWBEMUDSConnection(creds=None, **kwargs):
2321 # pylint: disable=invalid-name 2322 return WBEMConnection('/tmp/OW@LCL@APIIPC_72859_Xq47Bf_P9r761-5_J-7_Q', 2323 creds, **kwargs)
2324