def ModifyInstance(self, *args, **kwargs): """This method is used by the MOF compiler only in the course of handling CIM_ERR_ALREADY_EXISTS after trying to create an instance. NOTE: It does NOT support the propertylist attribute that is part of the CIM/XML defintion of ModifyInstance and it requires that each created instance include the instance path which means that the MOF must include the instance alias on each created instance. """ mod_inst = args[0] if args else kwargs['ModifiedInstance'] if self.default_namespace not in self.instances: raise CIMError( CIM_ERR_INVALID_NAMESPACE, _format( 'ModifyInstance failed. No instance repo exists. ' 'Use compiler instance alias to set path on ' 'instance declaration. inst: {0!A}', mod_inst)) if mod_inst.path not in self.instances[self.default_namespace]: raise CIMError( CIM_ERR_NOT_FOUND, _format( 'ModifyInstance failed. No instance exists. ' 'Use compiler instance alias to set path on ' 'instance declaration. inst: {0!A}', mod_inst)) orig_instance = self.instances[self.default_namespace][mod_inst.path] orig_instance.update(mod_inst.properties) self.instances[self.default_namespace][mod_inst.path] = orig_instance
def parseErrorAndResponse(self, data): """Parse returned XML for errors, then convert into appropriate Python objects.""" try: xml = fromstring(data) except Exception: self.deferred.errback( CIMError( 0, 'Incorrect XML response for {0}'.format(self.classname))) return error = xml.find('.//ERROR') if error is not None: msg = error.get('DESCRIPTION') if msg and "context cannot be found" in msg: error.set( "DESCRIPTION", "Response is not complete for {} classname. " "Please check zWBEMOperationTimeout and " "zWBEMMaxObjectCount properties".format(self.classname)) else: self.deferred.callback(self.parseResponse(xml)) return try: code = int(error.attrib['CODE']) except ValueError: code = 0 self.deferred.errback(CIMError(code, error.attrib['DESCRIPTION']))
def _validate_qualifiers(qualifier_list, qual_repo, new_class, scope): """ Validate a list of qualifiers against the Qualifier decl in the repository. 1. Whether it is declared (can be obtained from the declContext). 2. Whether it has the same type as the declaration. 3. Whether the qualifier is valid for the given scope. 4. Whether the qualifier can be overridden. 5. Whether the qualifier should be propagated to the subclass. """ for qname, qvalue in qualifier_list.items(): if qname not in qual_repo: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier {0!A} in new_class {1!A} in " "CreateClass not in repository.", qname, new_class.classname)) q_decl = qual_repo[qname] if qvalue.type != q_decl.type: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier {0!A} in new_class {1!A} override type " "mismatch {2!A} with qualifier declaration {3!A}.", qname, new_class.classname, qvalue.type, q_decl.type)) if scope not in q_decl.scopes: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier {0!A} in new class {1!A} scope {2!A} " "invalid. Not in qualifier decl scopes {3}", qname, new_class.classname, scope, q_decl.scopes))
def CreateInstance(self, *args, **kwargs): """ Create a CIM instance in the local repository of this class. This method is derived from the the same method in the pywbem mof compiler but modified to: 1. Use a dictionary as the container for instances where the key is the path. This means that all instances must have a path component to be inserted into the repository. Normally the path component is built within the compiler by using the instance alias. 2. Fail with a CIMError exception if the instance already exists in the repository. For a description of the parameters, see :meth:`pywbem.WBEMConnection.CreateInstance`. """ namespace = self.default_namespace inst = args[0] if args else kwargs['NewInstance'] # Get list of properties in class defined for this instance cln = inst.classname cls = self.GetClass(cln, IncludeQualifiers=True, LocalOnly=False) cls_key_properties = [ p for p, v in cls.properties.items() if 'key' in v.qualifiers ] # Validate all key properties are in instance for pname in cls_key_properties: if pname not in inst.properties: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( 'CreateInstance failed. Key property {0!A} in ' 'class {1!A} but not in new_instance: {2!A}', pname, cln, str(inst))) # Build path from instance and class if inst.path is None or not inst.path.keybindings: inst.path = CIMInstanceName.from_instance( cls, inst, namespace=self.default_namespace) # Exception if duplicate. NOTE: compiler overrides this with # modify instance. instance_store = self.repo.get_instance_store(namespace) if instance_store.exists(inst.path): raise CIMError( CIM_ERR_ALREADY_EXISTS, _format( 'CreateInstance failed. Instance with path {0!A} ' 'already exists in mock repository', inst.path)) try: # TODO: This should go through self.conn.CreateInstance instance_store.create(inst.path, inst) except KeyError: raise return inst.path
def remove_namespace(self, namespace, verbose=False): """ Remove a CIM namespace from the CIM repository. The namespace must exist in the CIM repository and must be empty. The Interop namespace cannot be removed from the CIM repository. Parameters: namespace (:term:`string`): The name of the CIM namespace in the CIM repository (case insensitive). Must not be `None`. Leading or trailing slash characters are ignored. verbose (:class:`py:bool`): Verbose mode: Print a message about the namespace deletion. Raises: ValueError: Namespace argument must not be None. :exc:`~pywbem.CIMError`: CIM_ERR_NOT_FOUND if the namespace does not exist in the CIM repository. :exc:`~pywbem.CIMError`: CIM_ERR_INVALID_NAMESPACE if the Interop namespace was specified. :exc:`~pywbem.CIMError`: CIM_ERR_NAMESPACE_NOT_EMPTY if the namespace icontains objects. :exc:`~pywbem.CIMError`: CIM_ERR_NAMESPACE_NOT_EMPTY if attempting to delete the default connection namespace. This namespace cannot be deleted from the CIM repository """ if namespace is None: raise ValueError("Namespace argument must not be None") namespace = namespace.strip('/') if namespace not in self.cimrepository.namespaces: raise CIMError( CIM_ERR_NOT_FOUND, _format( "Namespace {0!A} does not exist in the CIM repository ", namespace)) if self.is_interop_namespace(namespace): raise CIMError( CIM_ERR_INVALID_NAMESPACE, _format( "The Interop namespace {0!A} cannot be removed from " "the CIM repository.", namespace)) if verbose: print("Deleting namespace {} (in mock support)".format(namespace)) try: self.cimrepository.remove_namespace(namespace) # KeyError cannot happen because existence was already verified except ValueError: raise CIMError( CIM_ERR_NAMESPACE_NOT_EMPTY, _format("Namespace {0!A} contains objects.", namespace))
def add_namespace(self, namespace, verbose=False): """ Add a CIM namespace to the CIM repository. The namespace must not yet exist in the CIM repository and the repository can contain only one Interop namespace. An Interop namespace can be added with this method, if an Interop namespace does not yet exist in the CIM repository. Parameters: namespace (:term:`string`): The name of the CIM namespace in the CIM repository. Must not be `None`. Any leading or trailing slash characters are removed before the string is used to define the namespace name. verbose (:class:`py:bool`): Verbose mode: Print a message about the namespace creation. Raises: ValueError: Namespace argument must not be None. :exc:`~pywbem.CIMError`: CIM_ERR_ALREADY_EXISTS if the namespace already exists in the CIM repository. :exc:`~pywbem.CIMError`: CIM_ERR_ALREADY_EXISTS if the namespace is one of the possible Interop namespace names and an interop namespace already exists in the CIM repository. """ if namespace is None: raise ValueError("Namespace argument must not be None") namespace = namespace.strip('/') # Just for appearance in exc messages # Cannot add more than one of the possible Interop namespace names if self.is_interop_namespace(namespace): if self.find_interop_namespace(): raise CIMError( CIM_ERR_ALREADY_EXISTS, _format( "An Interop namespace {0!A} already exists in the " "CIM repository. {1!A} cannot be added. ", self.find_interop_namespace(), namespace)) if verbose: print("Creating namespace {} (in mock support)".format(namespace)) try: self.cimrepository.add_namespace(namespace) except ValueError: raise CIMError( CIM_ERR_ALREADY_EXISTS, _format( "Namespace {0!A} already exists in the CIM repository ", namespace))
def _validate_qualifiers(qualifiers, qualifier_store, new_class, scope): """ Validate a list of qualifiers against the Qualifier decl in the repository. 1. Whether it is declared (can be obtained from the declContext). 2. Whether it has the same type as the declaration. 3. Whether the qualifier is valid for the given scope. 4. Whether the qualifier can be overridden. 5. Whether the qualifier should be propagated to the subclass. Parameters: qualifiers: (:class:`py:dict` or `NocaseDict`_): Qualifiers to validate qualifier_store (): new_class (:class:`~pywbem.CIMClass`): The class being validated scope (:term:`string`): The scope defined for the object containing the qualifiers. May be 'CLASS', 'PROPERTY', 'METHOD', 'PARAMETER' """ for qname, qual in qualifiers.items(): if not qualifier_store.object_exists(qname): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format("Qualifier {0!A} used in new class {1!A} " "has no qualifier declaration in repository.", qname, new_class.classname)) q_decl = qualifier_store.get(qname) if qual.type != q_decl.type: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format("Qualifier {0!A} used in new class {1!A} has " "invalid type {2!A} (Qualifier declaration type: " "{3!A}).", qname, new_class.classname, qual.type, q_decl.type)) # Test for valid scope for this object type ot qualdecl ANY if not q_decl.scopes[scope] and not q_decl.scopes['ANY']: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format("Qualifier {0!A} in new class {1!A} is used in " "invalid scope: {2!A}. (QualifierDeclaration " "scopes: ({3})", qname, new_class.classname, scope, ", ".join( [s for s, v in q_decl.scopes.items() if v])))
def DeleteInstance(self, InstanceName): # pylint: disable=invalid-name """ Dispatcher for the DeleteInstance provider method. This method performs validations and if successful, routes the provider method call either to a registered provider, or to the default provider. """ # Verify the input parameter types (type errors have already been # raised during checks in the WBEMConnection operation). assert isinstance(InstanceName, CIMInstanceName) # Verify that the namespace exists in the CIM repository. namespace = InstanceName.namespace self.validate_namespace(namespace) class_store = self.cimrepository.get_class_store(namespace) instance_store = self.cimrepository.get_instance_store(namespace) # Verify that the creation class of the instance to be deleted exists # in the CIM repository. if not class_store.object_exists(InstanceName.classname): raise CIMError( CIM_ERR_INVALID_CLASS, _format( "Creation class {0!A} of instance to be deleted does " "not exist in namespace {1!A} of the CIM repository.", InstanceName.classname, namespace)) # Verify that the instance to be deleted exists in the CIM repository. if not instance_store.object_exists(InstanceName): raise CIMError( CIM_ERR_NOT_FOUND, _format( "Instance to be deleted does not exist in the CIM " "repository: {0!A}", InstanceName)) # Determine the provider to be used. Note that a registered provider # always has all provider methods for the provider type, either # implemented or inherited. provider = self.provider_registry.get_registered_provider( namespace, 'instance-write', InstanceName.classname) if not provider: provider = self.default_instance_write_provider # Call the provider method. result = provider.DeleteInstance(InstanceName) # Verify provider method result. assert result is None
def CreateInstance(self, *args, **kwargs): """ Create a CIM instance in the local repository of this class. This method is derived from the the same method in the pywbem mof compiler but modified to: 1. Use a dictionary as the container for instances where the key is the path. This means that all instances must have a path component to be inserted into the repository. Normally the path component is built within the compiler by using the instance alias. 2. Fail with a CIMError exception if the instance already exists in the repository. TODO: Determine if the logic should be to fail or replace. See pywbem issue #1890 For a description of the parameters, see :meth:`pywbem.WBEMConnection.CreateInstance`. """ inst = args[0] if args else kwargs['NewInstance'] # TODO build path if does not exist. For now simply abort # NOTE: compiler does not build path unless the instance alias is # defined for the instance if inst.path is None or not inst.path.keybindings: raise CIMError( CIM_ERR_FAILED, _format( 'CreateInstance failed. No path in new_instance or ' 'keybindings in path. ', 'Use compiler instance alias to set path on ' 'instance declaration. inst: {0!A}', inst)) if self.default_namespace not in self.instances: self.instances[self.default_namespace] = {} if inst.path in self.instances[self.default_namespace]: raise CIMError( CIM_ERR_ALREADY_EXISTS, _format( 'CreateInstance failed. Instance with path {0!A} ' 'already exists in mock repository', inst.path)) try: self.instances[self.default_namespace][inst.path] = inst except KeyError: self.instances[self.default_namespace] = {} self.instances[self.default_namespace][inst.path] = inst return inst.path
def validate_no_subscription(self, instance_name): """ Validate that no subscriptions exist containing reference to this instance. Parameters: instance_name (:class:`~pywbem.CIMInstanceName`) Instance name of the target instance. The class must be either the filter class or the listener destination class Returns: Returns if there are no corresponding subscriptions. """ # If a subscription exists containing this ListenerDestination, # reject delete if self.conn.ReferenceNames(instance_name, ResultClass=SUBSCRIPTION_CLASSNAME): # DSP1054 1.2 defines CIM error is raised by the server # in that case; we simulate it. raise CIMError(CIM_ERR_FAILED, _format( "The instance {0} is referenced by " "subscriptions.", instance_name), conn_id=self.conn.conn_id)
def test_cimerror_2(status_tuple, conn_info): # pylint: disable=redefined-outer-name """ Test CIMError exception class with status_code and description as input. """ status_code, status_code_name = status_tuple conn_id_kwarg, exp_conn_str = conn_info invalid_code_name = 'Invalid status code %s' % status_code input_desc = 'foo' exc = CIMError(status_code, input_desc, **conn_id_kwarg) assert exc.status_code == status_code assert exc.status_description == input_desc if status_code_name is None: assert exc.status_code_name == invalid_code_name else: assert exc.status_code_name == status_code_name assert exc.args[0] == exc.status_code assert exc.args[1] == input_desc assert exc.args[2] is None assert len(exc.args) == 3 _assert_connection(exc, conn_id_kwarg, exp_conn_str) _assert_subscription(exc)
def _getResultParams(result): """Common processing for pull results to separate end-of-sequence, enum-context, and entities in IRETURNVALUE. Returns tuple of entities in IRETURNVALUE, end_of_sequence, and enumeration_context) """ end_of_sequence = False enumeration_context = None sequence = result.get('EndOfSequence') if sequence and isinstance(sequence, six.string_types) and \ sequence.lower() in ['true', 'false']: # noqa: E125 end_of_sequence = sequence.lower() == 'true' context = result.get('EnumerationContext') if context and isinstance(context, six.string_types): # noqa: E125 enumeration_context = context rtn_objects = result.get('IRETURNVALUE') or [] if not sequence or not context: raise CIMError(CIM_ERR_INVALID_PARAMETER, "EndOfSequence or EnumerationContext required") # convert enum context if eos is True # Otherwise, returns tuple of enumeration context and namespace rtn_ctxt = None if end_of_sequence else enumeration_context if rtn_ctxt: return (rtn_objects, end_of_sequence, rtn_ctxt) else: return rtn_objects
def validate_namespace(self, namespace): """ Validates that a namespace is defined in the CIM repository. Returns only if namespace is valid. Otherwise it generates an exception. Parameters: namespace (:term:`string`): The name of the CIM namespace in the CIM repository (case insensitive). Must not be `None`. Any leading or trailing slash characters are ignored. Raises: :exc:`~pywbem.CIMError`: (CIM_ERR_INVALID_NAMESPACE) Namespace does not exist. """ try: self.cimrepository.validate_namespace(namespace) except KeyError: raise CIMError( CIM_ERR_INVALID_NAMESPACE, _format("Namespace does not exist in CIM repository: {0!A}", namespace))
def DeleteQualifier(self, *args, **kwargs): """This method is only invoked by :meth:`rollback` (on the underlying repository), and never by the MOF compiler, and is therefore not implemented.""" raise CIMError(CIM_ERR_FAILED, 'This should not happen!', conn_id=self.conn_id)
def handleEndHeaders(self): """Check whether the status was OK and raise an error if not using previously saved header information.""" if self.status != '200': if not hasattr(self, 'cimerror') or \ not hasattr(self, 'errordetail'): self.factory.deferred.errback( CIMError(0, 'HTTP error %s: %s' % (self.status, self.message))) else: self.factory.deferred.errback( CIMError(0, '%s: %s' % (cimerror, errordetail)))
def ModifyInstance(self, modified_instance, IncludeQualifiers=None): """ Modification of CIM_Namespace instance not allowed """ raise CIMError( CIM_ERR_NOT_SUPPORTED, _format("Modification of {0} instances is not allowed: " "{1!A}", NAMESPACE_CLASSNAME, modified_instance.path))
def EnumerateInstanceNames(self, *args, **kwargs): """This method is used by the MOF compiler only when it creates a namespace in the course of handling CIM_ERR_NAMESPACE_NOT_FOUND. Because the operations of this class silently create every namespace that is needed and never return that error, this method is never called, and is therefore not implemented. """ raise CIMError(CIM_ERR_FAILED, 'This should not happen!', conn_id=self.conn_id)
def parameter_is_interop(self, ns, classname): # pylint: disable=no-self-use """ Test if the parameter provided in ns is the interop namespace """ if not self.is_interop_namespace(ns): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Cannot create instance of class {0!A} in namespace {1!A}: " "The namespace is not an Interop namespace. " "Valid Interop namespaces are: {2!A}", classname, ns, ", ".join(self.interop_namespace_names)))
def _test_qualifier_decl(qualifier, qualifier_store, namespace): """ Test that qualifier is in repo and valid. """ if qualifier_store is None: return if not qualifier_store.exists(qualifier.name): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier declaration {0!A} required by CreateClass " "not found in namespace {1!A}.", qualifier.name, namespace))
def DeleteInstance(self, InstanceName): """ Delete an instance of the CIM_Namespace class in an Interop namespace of the CIM repository, and in addition delete the namespace represented by it in the CIM repository. See `~pywbem_mock.InstanceWriteProvider.CreateInstance` for documentation of validation and description of input parameters, noting extra conditions for this provider as described below: The namespace to be deleted must be empty and must not be the Interop namespace. Parameters: InstanceName: (:class:`~pywbem.CIMInstanceName`): The keybinding `Name` must exist; it defines the namespace to be deleted. Raises: :exc:`~pywbem.CIMError`: (CIM_ERR_INVALID_PARAMETER) :exc:`~pywbem.CIMError`: (CIM_ERR_NAMESPACE_NOT_EMPTY) """ # The provider dispatcher ensures that provider methods are only called # for the registered classes. # And this provider sets only a single class, not a list. assert InstanceName.classname.lower() == \ CIMNamespaceProvider.provider_classnames.lower() remove_namespace = InstanceName.keybindings['Name'] if self.is_interop_namespace(remove_namespace): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Cannot delete instance {0!A} from the CIM repository: " "This instance represents the Interop namespace {1!A} " "which must not be deleted.", InstanceName, remove_namespace)) # Delete the namespace from the CIM repository. # This call verifies that the namespace is empty and raises # CIMError(CIM_ERR_NAMESPACE_NOT_EMPTY) if not empty. self.remove_namespace(remove_namespace) # Delete the instance from the CIM repository instance_store = self.cimrepository.get_instance_store( InstanceName.namespace) instance_store.delete(InstanceName)
def _test_qualifier_decl(qualifier, qualifier_repo, namespace): """ Test that qualifier is in repo and valid. For for conn_lite, ignore this test """ if qualifier_repo is None: return if qualifier.name not in qualifier_repo: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier declaration {0!A} required by CreateClass " "not found in namespace {1!A}.", qualifier.name, namespace))
def _validate_qualifiers(qualifier_list, qualifier_store, new_class, scope): """ Validate a list of qualifiers against the Qualifier decl in the repository. 1. Whether it is declared (can be obtained from the declContext). 2. Whether it has the same type as the declaration. 3. Whether the qualifier is valid for the given scope. 4. Whether the qualifier can be overridden. 5. Whether the qualifier should be propagated to the subclass. """ for qname, qvalue in qualifier_list.items(): if not qualifier_store.exists(qname): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier {0!A} used in new class {1!A} " "has no qualifier declaration in repository.", qname, new_class.classname)) q_decl = qualifier_store.get(qname) if qvalue.type != q_decl.type: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier {0!A} used in new class {1!A} has " "invalid type {2!A} (Qualifier declaration type: " "{3!A}).", qname, new_class.classname, qvalue.type, q_decl.type)) if scope not in q_decl.scopes and 'ANY' not in q_decl.scopes: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Qualifier {0!A} in new class {1!A} is used in " "invalid scope {2!A} (Qualifier declaration " "scopes: {3})", qname, new_class.classname, scope, q_decl.scopes))
def CreateInstance(self, *args, **kwargs): """ Create a CIM instance in the connected client. This method: 1. Validates properties and the class 2. Sets the instance path to None to assuming that the conn.CreateInstance creates a complete path. 3. Passes the NewInstance to conn.CreateInstance (the client that is connected to a repository) For a description of the parameters, see :meth:`pywbem.WBEMConnection.CreateInstance`. """ inst = args[0] if args else kwargs['NewInstance'] ns = kwargs.get('namespace', self.default_namespace) # Get list of properties in class defined for this instance cln = inst.classname cls = self.GetClass(cln, namespace=ns, IncludeQualifiers=True, LocalOnly=False) cls_key_properties = [p for p, v in cls.properties.items() if 'key' in v.qualifiers] # Validate all key properties are in instance for pname in cls_key_properties: if pname not in inst.properties: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format('CreateInstance failed. Key property {0!A} in ' 'class {1!A} but not in new_instance: {2!A}', pname, cln, str(inst))) # Insure inst.path is empty before calling CreateInstance so that # the path is built by CreateInstance. This is logical because # the mock environment always requires a complete path to insert # an instance into the repository. inst.path = None try: path = self.conn.CreateInstance(inst, namespace=ns) except KeyError: # pylint: disable=try-except-raise raise return path
def validate_required_properties_exist(self, new_instance, namespace, required_properties): # pylint: disable=no-self-use """ Validate that the properties in required_properties list do exist in the new_instance """ for pn in required_properties: if pn not in new_instance: raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Cannot create instance of class {0!A} in " "namespace {1!A}: " "Missing required property {2!A} in new_instance", new_instance.classname, namespace, pn))
def parseErrorAndResponse(self, data): """Parse returned XML for errors, then convert into appropriate Python objects.""" xml = fromstring(data) error = xml.find('.//ERROR') if error is None: self.deferred.callback(self.parseResponse(xml)) return try: code = int(error.attrib['CODE']) except ValueError: code = 0 self.deferred.errback(CIMError(code, error.attrib['DESCRIPTION']))
def __init__(self, cimrepository): """ Parameters: cimrepository (:class:`~pywbem_mock.BaseRepository` or subclass): Defines the CIM repository to be used by the provider. """ super(CIMNamespaceProvider, self).__init__(cimrepository) if not self.find_interop_namespace(): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Cannot create namespace provider (for class {0}): " "No Interop namespace exists in the CIM repository. " "Valid Interop namespaces are: {1}", NAMESPACE_CLASSNAME, ", ".join(self.interop_namespace_names))) self.installed = False # test if provider previously installed.
def test_cimerror_3(status_tuple, error_instances, conn_info): # pylint: disable=redefined-outer-name """ Test CIMError exception class with status_code and instances as input. """ status_code, status_code_name = status_tuple conn_id_kwarg, exp_conn_str = conn_info exc = CIMError(status_code, instances=error_instances, **conn_id_kwarg) assert exc.status_code == status_code if status_code_name is not None: assert exc.status_code_name == status_code_name assert exc.args[2] == error_instances assert len(exc.args) == 3 _assert_connection(exc, conn_id_kwarg, exp_conn_str) _assert_subscription(exc)
def __init__(self, cimrepository): """ Parameters: cimrepository (:class:`~pywbem_mock.BaseRepository` or subclass): Defines the CIM repository to be used by the provider. """ super(CIMIndicationSubscriptionProvider, self).__init__(cimrepository) if not self.find_interop_namespace(): raise CIMError( CIM_ERR_INVALID_PARAMETER, _format( "Cannot create indication subscription provider for " "class: {0}. " "No Interop namespace exists in the CIM repository. " "Valid Interop namespaces are: {1}", FILTER_CLASSNAME, ", ".join(self.interop_namespace_names))) self.installed = False # test if provider previously installed. self.conn = None
def test_cimerror_1(status_tuple): # pylint: disable=redefined-outer-name """Test cimerror""" status_code = status_tuple[0] status_code_name = status_tuple[1] invalid_code_name = 'Invalid status code %s' % status_code invalid_code_desc = 'Invalid status code %s' % status_code exc = CIMError(status_code) assert exc.status_code == status_code if status_code_name is None: assert exc.status_description == invalid_code_desc assert exc.status_code_name == invalid_code_name else: assert isinstance(exc.status_description, six.string_types) assert exc.status_code_name == status_code_name assert exc.args[0] == exc.status_code assert exc.args[1] is None assert len(exc.args) == 2 _assert_subscription(exc)
def GetClass(self, *args, **kwargs): """Retrieve a CIM class from the local repository of this class. For a description of the parameters, see :meth:`pywbem.WBEMConnection.GetClass`. """ cname = args[0] if args else kwargs['ClassName'] try: cc = self.classes[self.default_namespace][cname] except KeyError: if self.conn is None: ce = CIMError(CIM_ERR_NOT_FOUND, cname) raise ce cc = self.conn.GetClass(*args, **kwargs) try: self.classes[self.default_namespace][cc.classname] = cc except KeyError: self.classes[self.default_namespace] = \ NocaseDict({cc.classname: cc}) if 'LocalOnly' in kwargs and not kwargs['LocalOnly']: if cc.superclass: try: del kwargs['ClassName'] except KeyError: pass if args: args = args[1:] super_ = self.GetClass(cc.superclass, *args, **kwargs) for prop in super_.properties.values(): if prop.name not in cc.properties: cc.properties[prop.name] = prop for meth in super_.methods.values(): if meth.name not in cc.methods: cc.methods[meth.name] = meth return cc