class ProviderRegistry(object):
"""
This class defines the provider registry with methods to register
a provider and to get the registered provider for a particular classname
namespace, and provider_type.
"""
#: Allowed provider types
PROVIDER_TYPES = ["instance-write", "method"]
def __init__(self):
# Dictionary of registered providers.
# Hierarchy of dictionaries is [namespace][classname][type]
# value is provider object.
self._registry = NocaseDict()
def __repr__(self):
return _format(
"ProviderRegistry("
"registry={s._registry}, ",
s=self)
def display_registered_providers(self, dest=None):
"""
Generate display of registry in readable form and return the string
Output format is:
<namespace>:
<classname>: CIM_Namespace provider: NamespaceProvider type: instance
For example:
Registered Providers:
namespace: root/cimv2
CIM_Foo instance UserInstanceTestProvider
CIM_Foo method UserMethodTestProvider
namespace: root/cimv3
CIM_Foo instance UserInstanceTestProvider
CIM_Foo method UserMethodTestProvider
Parameters:
dest (:term:`string`):
File path of an output file. If `None`, the output is written to
stdout.
"""
def print_ljust(rows):
"""
Print left justified and column aligned row of rows where each item
is either a string or list of strings
"""
widths = [max(map(len, col)) for col in zip(*rows)]
for row in rows:
_uprint(dest, u" {0}".format(
u" ".join((val.ljust(width) for
(val, width) in zip(row, widths)))))
_uprint(dest, "Registered Providers:")
for ns in self.provider_namespaces():
rows = []
_uprint(dest, _format(u'namespace: {0}', ns))
for class_name in sorted(self.provider_classes(ns)):
for type_ in sorted(self.provider_types(ns, class_name)):
provider = self.provider_obj(ns, class_name, type_)
provider_cn = provider.__class__.__name__
rows.append([class_name, type_, provider_cn])
print_ljust(rows)
def register_provider(self, conn, provider, namespaces=None,
schema_pragma_files=None, verbose=None):
# pylint: disable=line-too-long
"""
Register the provider object for specific namespaces and CIM classes.
Registering a provider tells the FakedWBEMConnection that the provider
implementation provided with this call as the `provider` parameter is
to be executed as the request response method for the namespaces
defined in the `namespaces` parameter, the provider type defined in the
provider 'provider_type` attribute of the `provider` and the classes
defined in the provider `provider_classnames` attribute of the
`provider`.
The provider registration process includes:
1. Validation that the namespaces defined for the provider exist.
2. Validation that the superclass of the provider is consistent with
the `provider_type` attribute defined in the provider.
3. Installation of any CIM classes defined by the provider
(`provider_classnames` attribute) including installation of
dependencies for these classes using the `schema_pragma_files` to
locate the search directories for dependencies.
4. Adding the provider to the registry of user_providers so that any
of the request methods defined for the `provider_type` are
passed to this provider in place of the default request processors.
5. Execute post_register_setup() call to the provider to allow the
provider to perform any special setup functionality.
Providers can only be registered for the following request response
methods:
1. provider_type = 'instance-write': defines methods for CreateInstance,
ModifyInstance, and DeleteInstance requests within a subclass of
the `InstanceWriteProvider` class.
2. provider_type = 'method': defines a InvokeMethod method within
a subclass of the `MethodProvider` class.
Each classname in a particular namespace may have at most one provider
registered
Parameters:
conn (:class:`~pywbem_mock.FakedWBEMConnection`):
Defines the attributes of the connection. Used to issue requests to
create instances in the Interop namespace for all existing
namespaces that do not have instances of CIM_Namespace defined
provider (instance of subclass of :class:`pywbem_mock.InstanceWriteProvider` or :class:`pywbem_mock.MethodProvider`):
The methods in this subclass override the corresponding methods in
the superclass. The method call parameters must be the same
as the default method in the superclass and it must return
data in the same format if the default method returns data.
This
class must contain variables `provider_type` and
`provider_classnames` that define the type of provider and the CIM
classes that the provider serves.
namespaces (:term:`string` or list of :term:`string`):
Namespace or namespaces for which the provider is being registered.
If `None`, the default namespace of the connection will be set to
the built-in default namespace
schema_pragma_files (:term:`py:iterable` of :term:`string` or :term:`string`):
Path names of schema pragma files for the set of CIM
classes that make up a schema such as the DMTF schema. These files
must contain include pragams defining the file location of the
classes to be compiled for the defined provider and for any
dependencies required to compile those classes. The directory
containing each schema pragma file is passed to the MOF compiler as
the search path for compile dependencies.
see :class:`pywbem.MOFCompiler` for more information on the
`search_paths` parameter.
verbose (:class:`py:bool`):
Display details on actions
Raises:
TypeError: Invalid provider_type retrieved from provider or
provider_type does not match superlclass. or the
namespace parameter is invalid.
ValueError: provider_type retrieved from provider is not a
valid type string.
ValueError: classnames parameter not a valid string or iterable or
namespace does not exist in repository.
""" # noqa: E501
# pylint: enable=line-too-long
if schema_pragma_files:
if isinstance(schema_pragma_files, six.string_types):
schema_pragma_files = [schema_pragma_files]
try:
provider_type = provider.provider_type
provider_classnames = provider.provider_classnames
except AttributeError as ae:
raise TypeError(
_format("Attributes provider_type and provider_classnames "
"required in provider. exception {}",
ae))
if provider_type == 'instance-write':
if not isinstance(provider, InstanceWriteProvider):
raise TypeError(
_format("Provider argument {0!A} is not a "
"valid subclass of InstanceWriteProvider. ",
provider))
elif provider_type == 'method':
if not isinstance(provider, MethodProvider):
raise TypeError(
_format("Provider argument {0!A} is not a "
"valid subclass of MethodProvider. ",
provider))
else:
raise ValueError(
_format("Provider_type argument {0!A} is not a valid provider "
"type. Valid provider types are {1!A}.",
provider_type, self.PROVIDER_TYPES))
if provider_classnames is None:
raise ValueError(
_format('Classnames argument must be string '
'or list of strings. None not allowed.'))
if namespaces is None:
namespaces = [conn.default_namespace]
if isinstance(namespaces, six.string_types):
namespaces = [namespaces]
if not isinstance(namespaces, (list, tuple)):
raise TypeError(
_format('Namespace argument {0|A} must be a string or '
'list/tuple but is {1}',
namespaces, type(namespaces)))
for namespace in namespaces:
if not isinstance(namespace, six.string_types):
raise TypeError(
_format('Namespace "{0!A}" in namespaces argument not '
'a string. ', namespace))
if namespace not in conn.namespaces:
raise ValueError(
_format('Namespace "{0!A}" in namespaces argument not '
'in CIM repository. '
'Existing namespaces are: {1!A}. ',
namespace, conn.namespaces))
if isinstance(provider_classnames, six.string_types):
provider_classnames = [provider_classnames]
assert isinstance(provider_classnames, (list, tuple))
for classname in provider_classnames:
assert isinstance(classname, six.string_types)
# For each namespace in which the provider is to be registered,
# if the class is not in that namespace, either compile it in if
# pragmas exist or generate an exception if no pragmas exist
for namespace in namespaces:
for classname in provider_classnames:
# pylint: disable=protected-access
if not conn._mainprovider.class_exists(namespace, classname):
if schema_pragma_files:
conn.compile_schema_classes(
provider_classnames,
schema_pragma_files,
namespace=namespace,
verbose=verbose)
else:
raise ValueError(
_format('Class "{0!A}" does not exist in '
'namespace {1!A} of the CIM repository '
'and no schema pragma files were specified',
classname, namespace))
if namespace not in self._registry:
self._registry[namespace] = NocaseDict()
# Add classnames for the namespace
for classname in provider_classnames:
if classname not in self._registry[namespace]:
self._registry[namespace][classname] = {}
self._registry[namespace][classname][provider_type] = provider
if verbose:
_format("Provider {0!A} registered: classes:[{1!A}], "
"type: {1!A} namespaces:{2!A}",
provider.__class__.__name__,
", ".join(provider_classnames),
provider_type, ", ".join(namespaces))
# Call post_register_setup. Since this method is defined in the
# default provider methods (MethodProvider, etc.) any exception is
# caught as an error.
provider.post_register_setup(conn)
def get_registered_provider(self, namespace, provider_type, classname):
"""
Get the user-defined provider registered for this namespace,
provider_type, and classname.
If no provider is registered, return `None`.
Parameters:
namespace (:term:`string`):
The namespace in which the request will be executed.
provider_type (:term:`string`):
String containing keyword ('instance-write' or 'method') defining
the type of provider.
classname (:term:`string`):
Name of the class defined for the operation
Returns:
Instance of :class:`~pywbem_mock.BaseProvider`: The registered
provider.
None if the registry is empty, the classname is not in the registry
or the namespace is not in the registry or the entry for the
classname, namespace and provider type is not defined.
"""
if not self._registry or namespace not in self._registry:
return None
if classname not in self._registry[namespace]:
return None
# Return None if requested type is not registered type
if provider_type not in self.provider_types(namespace, classname):
return None
return self.provider_obj(namespace, classname, provider_type)
def provider_namespaces(self):
"""
Get list of namespaces for registered providers. The returned
list is case sensitive.
Returns:
list of :term:`string`: namespaces
for which providers are registered.
"""
return list(self._registry.keys())
def provider_classes(self, namespace):
"""
Get case insensitive iterable of the classes for providers registered
for a namespace. The returned list is case sensitive.
Parameters:
namespace (:term:`string`):
The namespace in which the request will be executed.
Returns:
list of :term:`string`:
Names of classes registered for namespace
Raises:
KeyError: if namespace invalid
"""
return list(self._registry[namespace].keys())
def provider_types(self, namespace, classname):
"""
Get provider types for a namespace and classname. This is
a case-sensitive list.
Parameters:
namespace (:term:`string`):
The namespace in which the request will be executed.
classname (:term:`string`):
Name of the class defined for the operation.
Returns:
list of :term:`string`: Strings defining provider
types for the defined namespace and classname
Raises:
KeyError: if namespace invalid
"""
return list(self._registry[namespace][classname].keys())
def provider_obj(self, namespace, classname, provider_type):
"""
Get the registered provider object (instance of the registered
provider) for namespace, provider classname, and provider_type.
Parameters:
namespace (:term:`string`):
The namespace in which the request will be executed.
classname (:term:`string`):
Name of the class defined for the operation.
provider_type (:term:`string`):
String containing keyword ('instance-write' or 'method') defining
the type of provider.
Returns:
The registered object
Raises:
KeyError: if namespace or classname invalid
"""
return self._registry[namespace][classname][provider_type]
def iteritems(self):
"""
Return an iterator through the registered provider items. Each item
is a tuple(namespace, classname, provider_type, provider_obj),
with:
namespace (:term:`string`):
The namespace in which the request will be executed.
classname (:term:`string`):
Name of the class defined for the operation.
provider_type (:term:`string`):
String containing keyword ('instance-write' or 'method') defining
the type of provider.
provider_obj (:class:`~pywbem_mock.BaseProvider`):
The registered provider.
"""
ns_dict = self._registry
for ns in ns_dict:
cln_dict = ns_dict[ns]
for cln in cln_dict:
pt_dict = cln_dict[cln]
for pt in pt_dict:
pobj = pt_dict[pt]
yield (ns, cln, pt, pobj)
def load(self, other):
"""
Replace the data in this object with the data from the other object.
This is used to restore the object from a serialized state, without
changing its identity.
"""
# pylint: disable=protected-access
self._registry = other._registry
class InMemoryRepository(BaseRepository):
"""
A CIM repository that maintains the data in memory using the
methods defined in its superclass (~pywbem_mock:`BaseObjectStore`).
*New in pywbem 1.0 as experimental and finalized in 1.2.*
This implementation creates the repository as multi-level dictionary
elements to define the namespaces and within each
namespace the CIM classes, CIM instances, and CIM qualifiers in the
repository.
"""
# Documentation for the methods and properties isinherited from
# ~pywbem_mock:`BaseObjectStore` by sphinx when building documentaton.
# Therefore the methods in this class have no documentation
# string unless they add or modify documentation in the parent class or
# are not defined in the parent class. Any method that needs to modifyu
# the base method documentation must copy the base class documentation.
def __init__(self, initial_namespace=None):
"""
Initialize an empty in-memory CIM repository and optionally add a
namespace in the repository..
Parameters:
initial_namespace (:term:`string` or None):
Optional initial namespace that will be added to
the CIM repository.
"""
# Defines the top level NocaseDict() which defines the
# namespaces in the repository. The keys of this dictionary
# are namespace names and the values are dictionaries
# defining the CIM classes, CIM instances, and CIM qualifier
# declarations where the keys are "classes", "instances", and
# "qualifiers" and the value for each is an instance of the
# class InMemoryObjectStore that containe the CIM objects.
self._repository = NocaseDict()
# If an initial namespace is defined, add it to the repository
if initial_namespace:
self.add_namespace(initial_namespace)
def __repr__(self):
"""Display summary of the repository"""
return _format("InMemoryRepository(data={s._repository})", s=self)
def print_repository(self, dest=None):
"""
Print the CIM repository to a destination. This displays information on
the items in the data base and is only a diagnostic tool.
Parameters:
dest (:term:`string`):
File path of an output file. If `None`, the output is written to
stdout.
"""
def objstore_info(objstore_name):
"""
Display the data for the object store
"""
for ns in self._repository:
if objstore_name == 'class':
store = self.get_class_store(ns)
elif objstore_name == 'qualifier':
store = self.get_qualifier_store(ns)
else:
assert objstore_name == 'instance'
store = self.get_instance_store(ns)
rtn_str = u'Namespace: {} Repo: {} len:{}\n'.format(
ns, objstore_name, store.len())
for val in store.iter_values():
rtn_str += (u'{}\n'.format(val))
return rtn_str
namespaces = ",".join(self._repository.keys())
_uprint(dest, _format(u'NAMESPACES: {0}', namespaces))
_uprint(dest, _format(u'QUALIFIERS: {0}', objstore_info('qualifier')))
_uprint(dest, _format(u'CLASSES: {0}', objstore_info('class')))
_uprint(dest, _format(u'INSTANCES: {0}', objstore_info('instance')))
def validate_namespace(self, namespace):
if namespace is None:
raise ValueError("Namespace argument must not be None")
namespace = namespace.strip('/')
try:
self._repository[namespace]
except KeyError:
raise KeyError(
'Namespace "{}" does not exist in repository'.format(
namespace))
def add_namespace(self, namespace):
if namespace is None:
raise ValueError("Namespace argument must not be None")
namespace = namespace.strip('/')
if namespace in self._repository:
raise ValueError(
'Namespace "{}" already in repository'.format(namespace))
self._repository[namespace] = {}
# Create the data store for each of the object types.
self._repository[namespace]['classes'] = InMemoryObjectStore(CIMClass)
self._repository[namespace]['instances'] = InMemoryObjectStore(
CIMInstance)
self._repository[namespace]['qualifiers'] = InMemoryObjectStore(
CIMQualifierDeclaration)
def remove_namespace(self, namespace):
self.validate_namespace(namespace)
namespace = namespace.strip('/')
if self.get_class_store(namespace).len() != 0 or \
self.get_qualifier_store(namespace).len() != 0 or \
self.get_instance_store(namespace).len() != 0:
raise ValueError('Namespace {} removal invalid. Namespace not '
'empty'.format(namespace))
del self._repository[namespace]
@property
def namespaces(self):
# pylint: disable=invalid-overridden-method
# This puts just the dict keys (i.e. namespaces) into the list
return NocaseList(self._repository)
def get_class_store(self, namespace):
if namespace is None:
raise ValueError("Namespace None not permitted.")
namespace = namespace.strip('/')
self.validate_namespace(namespace)
return self._repository[namespace]['classes']
def get_instance_store(self, namespace):
if namespace is None:
raise ValueError("Namespace None not permitted.")
namespace = namespace.strip('/')
self.validate_namespace(namespace)
return self._repository[namespace]['instances']
def get_qualifier_store(self, namespace):
if namespace is None:
raise ValueError("Namespace None not permitted.")
namespace = namespace.strip('/')
self.validate_namespace(namespace)
return self._repository[namespace]['qualifiers']
def load(self, other):
"""
Replace the data in this object with the data from the other object.
This is used to restore the object from a serialized state, without
changing its identity.
"""
# pylint: disable=protected-access
self._repository = other._repository
class InMemoryRepository(BaseRepository):
"""
A CIM repository that maintains its data in memory.
"""
# Documentation for the methods and properties inherited from
# ~pywbem_mock:`BaseObjectStore` is also inherited in the pywbem
# documentation. Therefore the methods in this class have no documentation
# string.
def __init__(self, initial_namespace=None):
"""
Parameters:
initial_namespace:(:term:`string` or None):
Optional initial namespace that will be added to
the CIM repository.
"""
# Defines the top level NocaseDict() which defines the
# namespaces in the repository. The keys of this dictionary
# are namespace names and the values are dictionaries
# defining the CIM classes, CIM instances, and CIM qualifier
# declarations where the keys are "classes", "instance", and
# "qualifiers" and the value for each is an instance of the
# class InMemoryObjectStore that containe the CIM objects.
self._repository = NocaseDict()
# If an initial namespace is defined, add it to the repository
if initial_namespace:
self.add_namespace(initial_namespace)
def print_repository(self, dest=None, ):
"""
Print the CIM repository to a destination. This displays information on
the items in the data base and is only a diagnostic tool.
Parameters:
dest (:term:`string`):
File path of an output file. If `None`, the output is written to
stdout.
"""
def objstore_info(objstore_name):
"""
Display the data for the object store
"""
for ns in self._repository:
if objstore_name == 'class':
store = self.get_class_store(ns)
elif objstore_name == 'qualifier':
store = self.get_qualifier_store(ns)
else:
assert objstore_name == 'instance'
store = self.get_instance_store(ns)
rtn_str = u'Namespace: {} Repo: {} len:{}\n'.format(
ns, objstore_name, store.len())
for val in store.iter_values():
rtn_str += (u'{}\n'.format(val))
return rtn_str
namespaces = ",".join(self._repository.keys())
_uprint(dest, _format(u'NAMESPACES: {0}', namespaces))
_uprint(dest, _format(u'QUALIFIERS: {0}', objstore_info('qualifier')))
_uprint(dest, _format(u'CLASSES: {0}', objstore_info('class')))
_uprint(dest, _format(u'INSTANCES: {0}', objstore_info('instance')))
def validate_namespace(self, namespace):
if namespace is None:
raise ValueError("Namespace argument must not be None")
namespace = namespace.strip('/')
try:
self._repository[namespace]
except KeyError:
raise KeyError('Namespace "{}" does not exist in repository'.
format(namespace))
def add_namespace(self, namespace):
if namespace is None:
raise ValueError("Namespace argument must not be None")
namespace = namespace.strip('/')
if namespace in self._repository:
raise ValueError('Namespace "{}" already in repository'.
format(namespace))
self._repository[namespace] = {}
# Create the data store for each of the object types.
self._repository[namespace]['classes'] = InMemoryObjectStore(CIMClass)
self._repository[namespace]['instances'] = InMemoryObjectStore(
CIMInstance)
self._repository[namespace]['qualifiers'] = InMemoryObjectStore(
CIMQualifierDeclaration)
def remove_namespace(self, namespace):
self.validate_namespace(namespace)
namespace = namespace.strip('/')
if self.get_class_store(namespace).len() != 0 or \
self.get_qualifier_store(namespace).len() != 0 or \
self.get_instance_store(namespace).len() != 0:
raise ValueError('Namespace {} removal invalid. Namespace not '
'empty'.format(namespace))
del self._repository[namespace]
@property
def namespaces(self):
return list(self._repository)
def get_class_store(self, namespace):
if namespace is None:
raise ValueError("Namespace None not permitted.")
namespace = namespace.strip('/')
self.validate_namespace(namespace)
return self._repository[namespace]['classes']
def get_instance_store(self, namespace):
if namespace is None:
raise ValueError("Namespace None not permitted.")
namespace = namespace.strip('/')
self.validate_namespace(namespace)
return self._repository[namespace]['instances']
def get_qualifier_store(self, namespace):
if namespace is None:
raise ValueError("Namespace None not permitted.")
namespace = namespace.strip('/')
self.validate_namespace(namespace)
return self._repository[namespace]['qualifiers']
