Module cim_provider2
source code
Python CIM Providers (aka "nirvana")
This module is an abstraction and utility layer between a CIMOM and
Python providers. The CIMOM uses this module to load Python providers,
and route requests to those providers.
Python Provider Modules
Python Providers are implemented as Python modules. By convention
these modules are installed into /usr/lib/pycim. However, they can
be anywhere. These modules are loaded on demand using load_module()
from the imp module. The CIMOM's pycim interface stores the timestamp
of the provider modules. If the modules change, the CIMOM reloads the
modules. This is very useful while developing providers, since the
latest code will always be loaded and used.
A Python Provider Module will contain functions, attributes, and
instances that will be accessed and manipulated by this module.
Providers are often classified in the following catagories:
Instance -- Instrument the retrieval, creation, modification,
and deletion of CIM instances.
Association -- Instrument CIM associations (CIM classes with the
Association qualifier).
Method -- Instrument methods as defined on CIM instances or CIM
classes.
Indication -- Generates indications based on indication
subscriptions.
Indication Consumer -- "Consumes" (or "Handles") an indication,
possibly delivering it through some other means, such as email.
Polled -- A polled provider is allowed to run periodically (by
calling its poll function). This allows a provider to do some
periodic work, without the need to create its own thread.
An Instance, Association, and/or Method provider is created by defining
one or more subclasses of CIMProvider2 within the provider module, and
registering instances of the subclass(es) with CIM class names by way
of the get_providers function (described below). Refer to
the documentation for CIMProvider2 in this module.
Indication, Indication Consumer, and Polled providers are defined by
implementing some functions within the provider module.
Provider module functions:
init(env):
This module function is optional. It is called immediately
after the provider module is imported.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
get_providers(env):
Return a dict that maps CIM class names to instances of
CIMProvider2 subclasses. Note that multiple classes can be
instrumented by the same instance of a CIMProvider2 subclass.
The CIM class names are case-insensitive, since this dict is
converted to a NocaseDict.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
For example, a Python Provider Module may contain the following:
class Py_FooBarProvider(CIMProvider2):
...
def get_providers(env):
_fbp = Py_FooBarProvider()
return {'Py_Foo':_fbp, 'Py_Bar':_fbp}
can_unload(env):
Return True if the provider can be unloaded.
The CIMOM may try to unload a provider after a period of inactivity.
Before unloading a provider, the CIMOM asks the provider if it can
be unloaded.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
shutdown(env):
Perform any cleanup tasks prior to being unloaded.
The provider will shortly be unloaded, and is given an opportunity
to perform any needed cleanup. The provider may be unloaded after
a period of inactivity (see the documentation for can_unload), or
because the CIMOM is shutting down.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
handle_indication(env, ns, handler_instance, indication_instance):
Process an indication.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
ns -- The namespace where the event occurred
handler_instance --
indication_instance -- The indication
authorize_filter (env, filter, ns, classes,
owner):
Allow or disallow an indication subscription request.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
filter -- The WQL select statement
namespace -- The namepace where the indication is registered for
classes -- The classpath of the indication registered for
owner -- The name of the principal (cimom user)
activate_filter (env, filter, ns, classes,
first_activation):
Activate an indication subscription.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
filter -- The WQL select statement
namespace -- The namepace where the indication is registered for
classes -- The classpath of the indication registered for
first_activation -- boolean - whether first activation
deactivate_filter(env, filter, ns, classes,
last_activation):
Deactivate an indication subscription.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
filter -- The WQL select statement
ns -- The namepace where the indication is registered for
classes -- The classpath of the indication registered for
last_activation -- boolean - whether last activation
enable_indications(env):
Enable indications.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
disable_indications(env):
Disable indications.
Arguments:
env -- Provider Environment (pycimmb.ProviderEnvironment)
Provider Environment
A pycimmb.ProviderEnvironment is passed to many functions. This is
a handle back into the CIMOM. You can use it for logging and for
making "up-calls" to the CIMOM. For example:
logger = env.get_logger()
logger.log_debug('Debug Info')
ch = env.get_cimom_handle()
other_inst = ch.GetInstance(inst_path, LocalOnly=False,
IncludeQualifiers=False,
IncludeClassOrigin=False)
The API of the pycimmb.CIMOMHandle resembles that of
pywbem.WBEMConnection.
For more information on the ProviderEnvironments, and other features
provided by pycimmb, refer to the pycimmb documentation.
CodeGen
The codegen function can be used to generate provider stub code for a
given CIM class. This is a quick way to get started writing a provider.
Generate a Python Provider template.
Parameters:
cc - A CIMClass to generate code for.
- Returns a two-tuple containing the Python provider code stubs, and
- the provider registration MOF.
|