Source code for lmi.shell.LMICIMXMLClient

# Copyright (C) 2012-2014 Peter Hatina <phatina@redhat.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.

import os
import sys
import urlparse

from lmi.shell.compat import *

from lmi.shell.LMIReturnValue import LMIReturnValue
from lmi.shell.LMIUtil import lmi_parse_uri
from lmi.shell.LMIUtil import lmi_raise_or_dump_exception
from lmi.shell.LMIUtil import lmi_get_use_exceptions
from lmi.shell.LMIUtil import lmi_set_use_exceptions
from lmi.shell.LMIUtil import lmi_instance_to_path
from lmi.shell.LMIUtil import lmi_is_localhost

from lmi.shell.LMIDecorators import lmi_wrap_cim_exceptions
from lmi.shell.LMIDecorators import lmi_wrap_cim_exceptions_rval

from lmi.shell.LMIExceptions import CIMError
from lmi.shell.LMIExceptions import ConnectionError
from lmi.shell.LMIExceptions import LMIFilterError


def filter_kwargs(**kwargs):
    return {k: v for k, v in kwargs.iteritems() if v is not None}


[docs]class LMICIMXMLClient(object): """ CIM-XML client. :param string uri: URI of the CIMOM :param string username: account, under which, the CIM calls will be performed :param string password: user's password :param bool verify_server_cert: indicates, whether a server side certificate needs to be verified, if SSL used; default value is True :param string key_file: path to x509 key file; default value is None :param string cert_file: path to x509 cert file; default value is None """ QUERY_LANG_CQL = "DMTF:CQL" QUERY_LANG_WQL = "WQL" # Unix sockets used by TOG-Pegasus, SFCB or OpenWBEM. PEGASUS_SOCKET = "/var/run/tog-pegasus/cimxml.socket" def __init__(self, uri, username="", password="", verify_server_cert=True, key_file=None, cert_file=None): self._uri = uri if not self._uri.startswith("http://") and \ not self._uri.startswith("https://"): self._uri = "https://" + uri # Parse CIMOM URI _, hostname, _, path, username_, password_ = lmi_parse_uri(self._uri) if username_ is not None: username = username_ password = password_ creds = (username, password) x509 = { "cert_file": cert_file, "key_file": key_file } # If we are connecting to localhost without username or certificate # set, we will use the local UNIX socket for higher performance (and # skip authentication). connect_locally = lmi_is_localhost(uri) and \ path != "/wsman" and \ not username and not password and \ not cert_file and not key_file if HAVE_LMIWBEM: # LMIWBEM self._cliconn = wbem.WBEMConnection( self._uri, creds=creds, x509=x509, no_verification=not verify_server_cert, connect_locally=connect_locally) else: # PyWBEM if connect_locally: self._cliconn = wbem.PegasusUDSConnection() else: self._cliconn = wbem.WBEMConnection( self._uri, creds=creds, x509=x509, no_verification=not verify_server_cert) # LMIWBEM defines hostname attribute, so we define it here, # as well. self._cliconn.hostname = hostname def __del__(self): """ Disconnects and frees :py:class:`WBEMConnection` object. **NOTE:** Applicable only wbem :py:mod:`lmiwbem` is used. """ if HAVE_LMIWBEM: self.disconnect() del self._cliconn @lmi_wrap_cim_exceptions(False)
[docs] def connect(self): """ Connects to CIMOM. **NOTE:** Applicable only wbem :py:mod:`lmiwbem` is used. """ if HAVE_LMIWBEM: self._cliconn.connect() return LMIReturnValue(rval=True)
[docs] def disconnect(self): """ Disconnects from CIMOM. **NOTE:** Applicable only wbem :py:mod:`lmiwbem` is used. """ if HAVE_LMIWBEM: self._cliconn.disconnect()
[docs] def dummy(self): """ Sends a "dummy" request to verify credentials. :returns: :py:class:`.LMIReturnValue` with rval set to True, if provided credentials are OK; False otherwise. If LMIShell uses exceptions, :py:exc:`.CIMError` or :py:exc:`.ConnectionError` will be raised. :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ try: use_exceptions = lmi_get_use_exceptions() lmi_set_use_exceptions(True) try: # Perform a dummy request self.get_class("SomeNonExistingClass") except: raise finally: lmi_set_use_exceptions(use_exceptions) except CIMError, e: if e.args[0] == wbem.CIM_ERR_NOT_FOUND: return LMIReturnValue(rval=True) lmi_raise_or_dump_exception(e) errorstr = e.args[1] except ConnectionError, e: lmi_raise_or_dump_exception(e) errorstr = e.args[1] return LMIReturnValue(rval=False, errorstr=errorstr) # NOTE: usage with Key=something, Value=something is deprecated # NOTE: inst_filter is either None or dict
[docs] def get_instance_names(self, classname, namespace=None, inst_filter=None, limit=-1, **kwargs): """ Returns a list of :py:class:`wbem.CIMInstanceName` objects. :param string classname: class name :param string namespace: namespace name, where the instance names live :param dictionary inst_filter: dictionary containing filter values. The key corresponds to the primary key of the :py:class:`wbem.CIMInstanceName`; value contains the filtering value. :param int limit: unused :param dictionary kwargs: supported keyword arguments (these are **deprecated**) * **Key** or **key** (*string*) -- filtering key, see above * **Value** or **value** (*string*) -- filtering value, see above :returns: :py:class:`.LMIReturnValue` object with ``rval`` contains a list of :py:class:`wbem.CIMInstanceName` objects, if no error occurs; otherwise ``rval`` is set to None and ``errorstr`` contains appropriate error string :raises: :py:exc:`.LMIFilterError`, :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ @lmi_wrap_cim_exceptions(prefix="EnumerateInstanceNames " + classname) def get_instance_names_core(classname, namespace): return LMIReturnValue( rval=self._cliconn.EnumerateInstanceNames( classname, namespace)) filter_value = "" filter_key = "Name" if inst_filter is None: inst_filter = {} if "key" in kwargs: filter_key = kwargs["key"] kwargs.pop("key") elif "Key" in kwargs: filter_key = kwargs["Key"] kwargs.pop("Key") if "value" in kwargs: filter_value = kwargs["value"] kwargs.pop("value") if "Value" in kwargs: filter_value = kwargs["Value"] kwargs.pop("Value") if filter_value: inst_filter[filter_key] = filter_value try: inst_name_list, _, errorstr = get_instance_names_core( classname, namespace) if inst_filter: inst_name_list_filtered = [] for inst_name in inst_name_list: append = True for filter_key, filter_value in inst_filter.iteritems(): if inst_name[filter_key] != filter_value: append = False break if append: inst_name_list_filtered.append(inst_name) inst_name_list = inst_name_list_filtered except KeyError, e: errorstr = "Can not filter by '%s'" % filter_key lmi_raise_or_dump_exception(LMIFilterError(errorstr)) return LMIReturnValue(rval=None, errorstr=errorstr) return LMIReturnValue(rval=inst_name_list, errorstr=errorstr)
[docs] def get_instance(self, instance, LocalOnly=True, IncludeQualifiers=False, IncludeClassOrigin=False, PropertyList=None): """ Returns a :py:class:`wbem.CIMInstance` object. :param path: path of the object, which is about to be retrieved. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstanceName` * :py:class:`wbem.CIMInstance` * :py:class:`.LMIInstanceName` * :py:class:`.LMIInstance` :param bool LocalOnly: indicates if to include the only elements (properties, methods, references) overridden or defined in the class :param bool IncludeQualifiers: indicates, if all Qualifiers for the class and its elements shall be included in the response :param bool IncludeClassOrigin: indicates, if the ``CLASSORIGIN`` attribute shall be present on all appropriate elements in the returned class :param list PropertyList: if present and not None, the members of the list define one or more property names. The returned class shall not include elements for properties missing from this list. Note that if LocalOnly is specified as True, it acts as an additional filter on the set of properties returned. For example, if property A is included in the PropertyList but LocalOnly is set to True and A is not local to the requested class, it is not included in the response. If the PropertyList input parameter is an empty list, no properties are included in the response. If the PropertyList input parameter is None, no additional filtering is defined. :returns: :py:class:`.LMIReturnValue` object, where ``rval`` is set to :py:class:`wbem.CIMInstance` object, if no error occurs; otherwise ``rval`` is set to None and ``errorstr`` is set to corresponding error string. :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ @lmi_wrap_cim_exceptions(prefix="GetInstance " + instance.classname) def get_instance_core(path, **kwargs): return LMIReturnValue( rval=self._cliconn.GetInstance(path, **kwargs)) return get_instance_core( lmi_instance_to_path(instance), **filter_kwargs( LocalOnly=LocalOnly, IncludeQualifiers=IncludeQualifiers, IncludeClassOrigin=IncludeClassOrigin, PropertyList=PropertyList)) # NOTE: usage with Key=something, Value=something is deprecated # NOTE: inst_filter is either None or dict
[docs] def get_instances(self, classname, namespace=None, inst_filter=None, client_filtering=False, limit=-1, **kwargs): """ Returns a list of :py:class:`wbem.CIMInstance` objects. :param string classname: class name :param string namespace: namespace, where the instances live :param dictionary inst_filter: dictionary containing filter values. The key corresponds to the primary key of the :py:class:`wbem.CIMInstanceName`; value contains the filtering value. :param bool client_filtering: if True, client-side filtering will be performed, otherwise the filtering will be done by a CIMOM. Default value is False. :param int limit: unused :param dictionary kwargs: supported keyword arguments (these are **deprecated**) * **Key** or **key** (*string*) -- filtering key, see above * **Value** or **value** (*string*) -- filtering value, see above :returns: :py:class:`.LMIReturnValue` object with ``rval`` set to a list of :py:class:`wbem.CIMIntance` objects, if no error occurs; otherwise ``rval`` is set to None and ``errorstr`` is set to corresponding error string. :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ @lmi_wrap_cim_exceptions([], prefix="EnumerateInstances " + classname) def get_instances_core(classname, namespace, **kwargs): return LMIReturnValue( rval=self._cliconn.EnumerateInstances( classname, namespace, **kwargs)) filter_value = "" filter_key = "Name" if inst_filter is None: inst_filter = {} if "key" in kwargs: filter_key = kwargs["key"] kwargs.pop("key") elif "Key" in kwargs: filter_key = kwargs["Key"] kwargs.pop("Key") if "value" in kwargs: filter_value = kwargs["value"] kwargs.pop("value") if "Value" in kwargs: filter_value = kwargs["Value"] kwargs.pop("Value") if filter_value: inst_filter[filter_key] = filter_value if not client_filtering: query = "select * from %s" % classname if inst_filter: more = False query += " where" for filter_key, filter_value in inst_filter.iteritems(): if more: query += " and" quotes = isinstance(filter_value, basestring) query += " %s =" % filter_key if quotes: query += " \"%s\"" % filter_value else: query += " %s" % filter_value more = True return self.exec_query( LMICIMXMLClient.QUERY_LANG_WQL, query, namespace) # Client-side filtering - this is not a pretty solution, but it needs # to be present due to TOG-Pegasus, which does not raise an exception, # if an error occurs while performing CQL/WQL query. inst_list, _, errorstr = get_instances_core( classname, namespace, LocalOnly=False, DeepInheritance=True, IncludeQualifiers=False) if inst_list and inst_filter: inst_list_filtered = [] for inst in inst_list: for filter_key, filter_value in inst_filter.iteritems(): if filter_key not in inst.properties or \ inst.properties[filter_key].value != filter_value: break else: inst_list_filtered.append(inst) inst_list = inst_list_filtered return LMIReturnValue(rval=inst_list, errorstr=errorstr)
@lmi_wrap_cim_exceptions(prefix="EnumerateClassNames")
[docs] def get_class_names(self, namespace=None, ClassName=None, DeepInheritance=False): """ Returns a list of class names. :param string namespace: namespace, from which the class names list should be retrieved; if None, default namespace will be used (**NOTE:** see :py:mod:`wbem`) :param string ClassName: defines the class that is the basis for the enumeration. If the ClassName input parameter is absent, this implies that the names of all classes. :param bool DeepInheritance: if not present, of False, only the names of immediate child subclasses are returned, otherwise the names of all subclasses of the specified class should be returned. :returns: :py:class:`.LMIReturnValue` object with ``rval`` set to a list of strings containing class names, if no error occurs; otherwise ``rval`` is set to None and ``errorstr`` contains an appropriate error string :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ return LMIReturnValue( rval=self._cliconn.EnumerateClassNames( namespace, **filter_kwargs( ClassName=ClassName, DeepInheritance=DeepInheritance)))
@lmi_wrap_cim_exceptions(prefix="GetClass")
[docs] def get_class(self, classname, namespace=None, LocalOnly=True, IncludeQualifiers=True, IncludeClassOrigin=False, PropertyList=None): """ Returns a :py:class:`wbem.CIMClass` object. :param string classname: class name :param string namespace: -- namespace name, from which the :py:class:`wbem.CIMClass` should be retrieved; if None, default namespace will be used (**NOTE:** see :py:mod:`wbem`) :param bool LocalOnly: indicates, if only local members should be present in the returned :py:class:`wbem.CIMClass`; any CIM elements (properties, methods, and qualifiers), except those added or overridden in the class as specified in the classname input parameter, shall not be included in the returned class. :param bool IncludeQualifiers: indicates, if qualifiers for the class (including qualifiers on the class and on any returned properties, methods, or method parameters) shall be included in the response. :param bool IncludeClassOrigin: indicates, if the ``CLASSORIGIN`` attribute shall be present on all appropriate elements in the returned class. :param list PropertyList: if present and not None, the members of the list define one or more property names. The returned class shall not include elements for properties missing from this list. Note that if LocalOnly is specified as True, it acts as an additional filter on the set of properties returned. For example, if property A is included in the PropertyList but LocalOnly is set to True and A is not local to the requested class, it is not included in the response. If the PropertyList input parameter is an empty list, no properties are included in the response. If the PropertyList input parameter is None, no additional filtering is defined. :returns: :py:class:`.LMIReturnValue` object with rval set to :py:class:`wbem.CIMClass`, if no error occurs; otherwise rval is set to None and errorstr to appropriate error string :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ return LMIReturnValue( rval=self._cliconn.GetClass( classname, namespace, **filter_kwargs(LocalOnly=LocalOnly, IncludeQualifiers=IncludeQualifiers, IncludeClassOrigin=IncludeClassOrigin, PropertyList=PropertyList)))
[docs] def get_superclass(self, classname, namespace=None): """ Returns a superclass to given class. :param string classname: class name :param string namespace: namespace name :returns: superclass to given class, if such superclass exists, None otherwise :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ minimal_class, rparams, errorstr = LMICIMXMLClient.get_class( self, classname, namespace, LocalOnly=True, IncludeQualifiers=False, PropertyList=[]) if not minimal_class: return LMIReturnValue( rval=None, rparams=rparams, errorstr=errorstr) return LMIReturnValue(rval=minimal_class.superclass)
[docs] def call_method(self, instance, method, **params): """ Executes a method within a given instance. :param instance: object, on which the method will be executed. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstance` * :py:class:`wbem.CIMInstanceName` * :py:class:`.LMIInstance` * :py:class:`.LMIInstanceName` :param string method: string containing a method name :param dictionary params: parameters passed to the method call :returns: :py:class:`.LMIReturnValue` object with rval set to return value of the method call, rparams set to returned parameters from the method call, if no error occurs; otherwise rval is set to -1 and errorstr to appropriate error string :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ @lmi_wrap_cim_exceptions(-1, prefix="InvokeMethod " + method) def call_method_core(path, method, **params): rval, rparams = self._cliconn.InvokeMethod(method, path, **params) return LMIReturnValue(rval=rval, rparams=rparams) path = lmi_instance_to_path(instance) return call_method_core(path, method, **params)
@lmi_wrap_cim_exceptions_rval([], prefix="AssociatorNames")
[docs] def get_associator_names(self, instance, AssocClass=None, ResultClass=None, Role=None, ResultRole=None, limit=-1): """ Returns a list of associated :py:class:`wbem.CIMInstanceName` objects with an input instance. :param instance: for this object the list of associated :py:class:`wbem.CIMInstanceName` will be returned. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstance` * :py:class:`wbem.CIMInstanceName` * :py:class:`.LMIInstance` * :py:class:`.LMIInstanceName` :param string AssocClass: valid CIM association class name. It acts as a filter on the returned set of names by mandating that each returned name identify an object that shall be associated to the source object through an instance of this class or one of its subclasses. :param string ResultClass: valid CIM class name. It acts as a filter on the returned set of names by mandating that each returned name identify an object that shall be either an instance of this class (or one of its subclasses) or be this class (or one of its subclasses). :param string Role: valid property name. It acts as a filter on the returned set of names by mandating that each returned name identify an object that shall be associated to the source object through an association in which the source object plays the specified role. That is, the name of the property in the association class that refers to the source object shall match the value of this parameter. :param string ResultRole: valid property name. It acts as a filter on the returned set of names by mandating that each returned name identify an object that shall be associated to the source object through an association in which the named returned object plays the specified role. That is, the name of the property in the association class that refers to the returned object shall match the value of this parameter. :param int limit: unused :returns: list of associated :py:class:`wbem.CIMInstanceName` objects with an input instance, if no error occurs; otherwise an empty list is returned :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ return self._cliconn.AssociatorNames( lmi_instance_to_path(instance), **filter_kwargs( AssocClass=AssocClass, ResultClass=ResultClass, Role=Role, ResultRole=ResultRole))
@lmi_wrap_cim_exceptions_rval([], prefix="Associators")
[docs] def get_associators(self, instance, AssocClass=None, ResultClass=None, Role=None, ResultRole=None, IncludeQualifiers=False, IncludeClassOrigin=False, PropertyList=None, limit=-1): """ Returns a list of associated :py:class:`wbem.CIMInstance` objects with an input instance. :param instance: for this object the list of associated :py:class:`wbem.CIMInstance` objects will be returned. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstance` * :py:class:`wbem.CIMInstanceName` * :py:class:`.LMIInstance` * :py:class:`.LMIInstanceName` :param string AssocClass: valid CIM association class name. It acts as a filter on the returned set of objects by mandating that each returned object shall be associated to the source object through an instance of this class or one of its subclasses. :param string ResultClass: valid CIM class name. It acts as a filter on the returned set of objects by mandating that each returned object shall be either an instance of this class (or one of its subclasses) or be this class (or one of its subclasses). :param string Role: valid property name. It acts as a filter on the returned set of objects by mandating that each returned object shall be associated with the source object through an association in which the source object plays the specified role. That is, the name of the property in the association class that refers to the source object shall match the value of this parameter. :param string ResultRole: valid property name. It acts as a filter on the returned set of objects by mandating that each returned object shall be associated to the source object through an association in which the returned object plays the specified role. That is, the name of the property in the association class that refers to the returned object shall match the value of this parameter. :param bool IncludeQualifiers: indicates, if all qualifiers for each object (including qualifiers on the object and on any returned properties) shall be included as ``<QUALIFIER>`` elements in the response. :param bool IncludeClassOrigin: indicates, if the ``CLASSORIGIN`` attribute shall be present on all appropriate elements in each returned object. :param list PropertyList: if not None, the members of the array define one or more property names. Each returned object shall not include elements for any properties missing from this list. If PropertyList is an empty list, no properties are included in each returned object. If it is None, no additional filtering is defined. :param int limit: unused :returns: list of associated :py:class:`wbem.CIMInstance` objects with an input instance, if no error occurs; otherwise an empty list is returned :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ return self._cliconn.Associators( lmi_instance_to_path(instance), **filter_kwargs( AssocClass=AssocClass, ResultClass=ResultClass, Role=Role, ResultRole=ResultRole, IncludeQualifiers=IncludeQualifiers, IncludeClassOrigin=IncludeClassOrigin, PropertyList=PropertyList))
@lmi_wrap_cim_exceptions_rval([], prefix="ReferenceNames")
[docs] def get_reference_names(self, instance, ResultClass=None, Role=None, limit=-1): """ Returns a list of association :py:class:`wbem.CIMInstanceName` objects with an input instance. :param instance: for this object the association :py:class:`wbem.CIMInstanceName` objects will be returned. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstance` * :py:class:`wbem.CIMInstanceName` * :py:class:`.LMIInstance` * :py:class:`.LMIInstanceName` :param string ResultClass: valid CIM class name. It acts as a filter on the returned set of object names by mandating that each returned Object Name identify an instance of this class (or one of its subclasses) or this class (or one of its subclasses). :param string Role: valid property name. It acts as a filter on the returned set of object names by mandating that each returned object name shall identify an object that refers to the target instance through a property with a name that matches the value of this parameter. :param int limit: unused :returns: list of association :py:class:`wbem.CIMInstanceName` objects with an input instance, if no error occurs; otherwise an empty list is returned :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ return self._cliconn.ReferenceNames( lmi_instance_to_path(instance), **filter_kwargs( ResultClass=ResultClass, Role=Role))
@lmi_wrap_cim_exceptions_rval([], prefix="References")
[docs] def get_references(self, instance, ResultClass=None, Role=None, IncludeQualifiers=False, IncludeClassOrigin=False, PropertyList=None, limit=-1): """ Returns a list of association :py:class:`wbem.CIMInstance` objects with an input instance. :param instance: for this object the list of association :py:class:`wbem.CIMInstance` objects will be returned. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstance` * :py:class:`wbem.CIMInstanceName` * :py:class:`.LMIInstance` * :py:class:`.LMIInstanceName` :param string ResultClass: valid CIM class name. It acts as a filter on the returned set of objects by mandating that each returned object shall be an instance of this class (or one of its subclasses) or this class (or one of its subclasses). :param string Role: valid property name. It acts as a filter on the returned set of objects by mandating that each returned object shall refer to the target object through a property with a name that matches the value of this parameter. :param bool IncludeQualifiers: bool flag indicating, if all qualifiers for each object (including qualifiers on the object and on any returned properties) shall be included as ``<QUALIFIER>`` elements in the response. :param bool IncludeClassOrigin: bool flag indicating, if the ``CLASSORIGIN`` attribute shall be present on all appropriate elements in each returned object. :param list PropertyList: if not None, the members of the list define one or more property names. Each returned object shall not include elements for any properties missing from this list. If PropertyList is an empty list, no properties are included in each returned object. If PropertyList is None, no additional filtering is defined. :param int limit: unused :returns: list of association :py:class:`wbem.CIMInstance` objects with an input instance, if no error occurs; otherwise an empty list is returned :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ return self._cliconn.References( lmi_instance_to_path(instance), **filter_kwargs( ResultClass=ResultClass, Role=Role, IncludeQualifiers=IncludeQualifiers, IncludeClassOrigin=IncludeClassOrigin, PropertyList=PropertyList))
@lmi_wrap_cim_exceptions(None, prefix="CreateInstance")
[docs] def create_instance(self, classname, namespace=None, host=None, properties=None, qualifiers=None, property_list=None): """ Creates a new :py:class:`wbem.CIMInstance` object. :param string classname: class name of a new instance :param string namespace: namespace, of the new instance :param dictionary properties: property names and values :param dictionary qualifiers: qualifier names and values :param list property_list: list for property filtering; see :py:class:`wbem.CIMInstance` :returns: new :class:`wbem.CIMInstance`, if no error occurs; otherwise None is returned :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ # Create a new dictionaries from the input ones, we do not want to # modify user's input variables. properties = dict(properties) if properties is not None else {} qualifiers = dict(qualifiers) if qualifiers is not None else {} cim_instance = wbem.CIMInstance( classname, properties, qualifiers, wbem.CIMInstanceName( classname, namespace=namespace, host=host), property_list) cim_path = self._cliconn.CreateInstance(NewInstance=cim_instance) return self.get_instance(cim_path, LocalOnly=False)
@lmi_wrap_cim_exceptions(-1, prefix="ModifyInstance")
[docs] def modify_instance(self, instance, IncludeQualifiers=True, PropertyList=None): """ Modifies a :py:class:`wbem.CIMInstance` object at CIMOM side. :param wbem.CIMInstance instance: object to be modified :param bool IncludeQualifiers: indicates, if the qualifiers are modified as specified in `ModifiedInstance`. :param list PropertyList: if not None, the members of the list define one or more property names. Only properties specified in the PropertyList are modified. Properties of the *ModifiedInstance* that are missing from the PropertyList are ignored. If the PropertyList is an empty list, no properties are modified. If the PropertyList is None, the set of properties to be modified consists of those of *ModifiedInstance* with values different from the current values in the instance to be modified. :returns: :py:class:`.LMIReturnValue` object with ``rval`` set to 0, if no error occurs; otherwise ``rval`` is set to -1 and ``errorstr`` is set to corresponding error string. :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ self._cliconn.ModifyInstance( instance, **filter_kwargs( IncludeQualifiers=IncludeQualifiers, PropertyList=PropertyList)) return LMIReturnValue(rval=0)
@lmi_wrap_cim_exceptions(False, prefix="DeleteInstance")
[docs] def delete_instance(self, instance): """ Deletes a :py:class:`wbem.CIMInstance` from the CIMOM side. :param instance: object to be deleted. The object needs to be instance of following classes: * :py:class:`wbem.CIMInstance` * :py:class:`wbem.CIMInstanceName` * :py:class:`.LMIInstance` * :py:class:`.LMIInstanceName` :returns: :py:class:`.LMIReturnValue` object with ``rval`` set to True, if no error occurs; otherwise ``rval`` is set to False and ``errorstr`` is set to corresponding error string :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError`, :py:exc:`TypeError` """ self._cliconn.DeleteInstance(lmi_instance_to_path(instance)) return LMIReturnValue(rval=True)
@lmi_wrap_cim_exceptions(prefix="ExecQuery")
[docs] def exec_query(self, query_lang, query, namespace=None): """ Executes a query and returns a list of :py:class:`wbem.CIMInstance` objects. :param string query_lang: query language :param string query: query to execute :param string namespace: target namespace for the query :returns: :py:class:`.LMIReturnValue` object with ``rval`` set to list of :py:class:`wbem.CIMInstance` objects, if no error occurs; otherwise ``rval`` is set to None and ``errorstr`` is set to corresponding error string :raises: :py:exc:`.CIMError`, :py:exc:`.ConnectionError` """ inst_list = self._cliconn.ExecQuery(query_lang, query, namespace) return LMIReturnValue(rval=inst_list)
@property
[docs] def username(self): """ :returns: user name as a part of provided credentials :rtype: string """ return self._cliconn.creds[0]
@property
[docs] def uri(self): """ :returns: URI of the CIMOM :rtype: string """ return self._uri
@property
[docs] def hostname(self): """ :returns: hostname of CIMOM :rtype: string """ return self._cliconn.hostname