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

Source Code for Module pywbem.cim_provider2

   1  # 
   2  # (C) Copyright 2003-2007 Hewlett-Packard Development Company, L.P. 
   3  # 
   4  # This library is free software; you can redistribute it and/or 
   5  # modify it under the terms of the GNU Lesser General Public 
   6  # License as published by the Free Software Foundation; either 
   7  # version 2.1 of the License, or (at your option) any later version. 
   8  # 
   9  # This program is distributed in the hope that it will be useful, but 
  10  # WITHOUT ANY WARRANTY; without even the implied warranty of 
  11  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
  12  # Lesser General Public License for more details. 
  13  # 
  14  # You should have received a copy of the GNU Lesser General Public 
  15  # License along with this program; if not, write to the Free Software 
  16  # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
  17  # 
  18  # Author: Bart Whiteley 
  19  # Author: Jon Carey 
  20  # 
  21   
  22  """Python CIM Providers (aka "nirvana") 
  23   
  24  This module is an abstraction and utility layer between a CIMOM and 
  25  Python providers.  The CIMOM uses this module to load Python providers, 
  26  and route requests to those providers. 
  27   
  28  Python Provider Modules 
  29   
  30      Python Providers are implemented as Python modules.  By convention 
  31      these modules are installed into /usr/lib/pycim.  However, they can 
  32      be anywhere.  These modules are loaded on demand using load_module() 
  33      from the imp module.  The CIMOM's pycim interface stores the timestamp 
  34      of the provider modules.  If the modules change, the CIMOM reloads the 
  35      modules.  This is very useful while developing providers, since the 
  36      latest code will always be loaded and used. 
  37   
  38      A Python Provider Module will contain functions, attributes, and 
  39      instances that will be accessed and manipulated by this module. 
  40   
  41      Providers are often classified in the following catagories: 
  42          Instance -- Instrument the retrieval, creation, modification, 
  43              and deletion of CIM instances. 
  44          Association -- Instrument CIM associations (CIM classes with the 
  45              Association qualifier). 
  46          Method -- Instrument methods as defined on CIM instances or CIM 
  47              classes. 
  48          Indication -- Generates indications based on indication 
  49              subscriptions. 
  50          Indication Consumer -- "Consumes" (or "Handles") an indication, 
  51              possibly delivering it through some other means, such as email. 
  52          Polled -- A polled provider is allowed to run periodically (by 
  53              calling its poll function).  This allows a provider to do some 
  54              periodic work, without the need to create its own thread. 
  55   
  56      An Instance, Association, and/or Method provider is created by defining 
  57      one or more subclasses of CIMProvider2 within the provider module, and 
  58      registering instances of the subclass(es) with CIM class names by way 
  59      of the get_providers function (described below).  Refer to 
  60      the documentation for CIMProvider2 in this module. 
  61   
  62      Indication, Indication Consumer, and Polled providers are defined by 
  63      implementing some functions within the provider module. 
  64   
  65      Provider module functions: 
  66          init(env): 
  67              This module function is optional.  It is called immediately 
  68              after the provider module is imported. 
  69   
  70              Arguments: 
  71              env -- Provider Environment (pycimmb.ProviderEnvironment) 
  72   
  73          get_providers(env): 
  74              Return a dict that maps CIM class names to instances of 
  75              CIMProvider2 subclasses.  Note that multiple classes can be 
  76              instrumented by the same instance of a CIMProvider2 subclass. 
  77              The CIM class names are case-insensitive, since this dict is 
  78              converted to a NocaseDict. 
  79   
  80              Arguments: 
  81              env -- Provider Environment (pycimmb.ProviderEnvironment) 
  82   
  83              For example, a Python Provider Module may contain the following: 
  84   
  85                  class Py_FooBarProvider(CIMProvider2): 
  86                      ... 
  87   
  88                  def get_providers(env): 
  89                      _fbp = Py_FooBarProvider() 
  90                      return {'Py_Foo':_fbp, 'Py_Bar':_fbp} 
  91   
  92          can_unload(env): 
  93              Return True if the provider can be unloaded. 
  94   
  95              The CIMOM may try to unload a provider after a period of inactivity. 
  96              Before unloading a provider, the CIMOM asks the provider if it can 
  97              be unloaded. 
  98   
  99              Arguments: 
 100              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 101   
 102          shutdown(env): 
 103              Perform any cleanup tasks prior to being unloaded. 
 104   
 105              The provider will shortly be unloaded, and is given an opportunity 
 106              to perform any needed cleanup.  The provider may be unloaded after 
 107              a period of inactivity (see the documentation for can_unload), or 
 108              because the CIMOM is shutting down. 
 109   
 110              Arguments: 
 111              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 112   
 113          handle_indication(env, ns, handler_instance, indication_instance): 
 114              Process an indication. 
 115   
 116              Arguments: 
 117              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 118              ns -- The namespace where the event occurred 
 119              handler_instance -- 
 120              indication_instance -- The indication 
 121   
 122          authorize_filter (env, filter, ns, classes, 
 123                           owner): 
 124              Allow or disallow an indication subscription request. 
 125   
 126              Arguments: 
 127              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 128              filter -- The WQL select statement 
 129              namespace -- The namepace where the indication is registered for 
 130              classes -- The classpath of the indication registered for 
 131              owner -- The name of the principal (cimom user) 
 132   
 133          activate_filter (env, filter, ns, classes, 
 134                           first_activation): 
 135              Activate an indication subscription. 
 136   
 137              Arguments: 
 138              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 139              filter -- The WQL select statement 
 140              namespace -- The namepace where the indication is registered for 
 141              classes -- The classpath of the indication registered for 
 142              first_activation -- boolean - whether first activation 
 143   
 144          deactivate_filter(env, filter, ns, classes, 
 145                            last_activation): 
 146              Deactivate an indication subscription. 
 147   
 148              Arguments: 
 149              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 150              filter -- The WQL select statement 
 151              ns -- The namepace where the indication is registered for 
 152              classes -- The classpath of the indication registered for 
 153              last_activation -- boolean - whether last activation 
 154   
 155          enable_indications(env): 
 156              Enable indications. 
 157   
 158              Arguments: 
 159              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 160   
 161          disable_indications(env): 
 162              Disable indications. 
 163   
 164              Arguments: 
 165              env -- Provider Environment (pycimmb.ProviderEnvironment) 
 166   
 167  Provider Environment 
 168   
 169      A pycimmb.ProviderEnvironment is passed to many functions.  This is 
 170      a handle back into the CIMOM.  You can use it for logging and for 
 171      making "up-calls" to the CIMOM.  For example: 
 172   
 173          logger = env.get_logger() 
 174          logger.log_debug('Debug Info') 
 175   
 176          ch = env.get_cimom_handle() 
 177          other_inst = ch.GetInstance(inst_path, LocalOnly=False, 
 178                                      IncludeQualifiers=False, 
 179                                      IncludeClassOrigin=False) 
 180   
 181      The API of the pycimmb.CIMOMHandle resembles that of 
 182      pywbem.WBEMConnection. 
 183   
 184      For more information on the ProviderEnvironments, and other features 
 185      provided by pycimmb, refer to the pycimmb documentation. 
 186   
 187  CodeGen 
 188   
 189      The codegen function can be used to generate provider stub code for a 
 190      given CIM class.  This is a quick way to get started writing a provider. 
 191   
 192  """ 
 193   
 194  from os.path import dirname 
 195  from types import ModuleType 
 196  import os 
 197  import imp 
 198  import threading 
 199   
 200  import pywbem 
 201   
 202  g_mod_lock = threading.RLock() 
 203   
 204   
 205   
 206  __all__ = ['CIMProvider2', 'codegen'] 
 207   
 208   
209 -def _paths_equal(lhs, rhs):
210 """If one object path doesn't inlcude a host, don't include the hosts 211 in the comparison 212 213 """ 214 215 if lhs is rhs: 216 return True 217 if lhs.host is not None and rhs.host is not None and lhs.host != rhs.host: 218 return False 219 # need to make sure this stays in sync with CIMInstanceName.__cmp__() 220 return not (pywbem.cmpname(rhs.classname, lhs.classname) or 221 cmp(rhs.keybindings, lhs.keybindings) or 222 pywbem.cmpname(rhs.namespace, lhs.namespace))
223 224
225 -class CIMProvider2(object):
226 """Base class for CIM Providers. 227 228 A derived class might normally override the following: 229 - enum_instances 230 - get_instance 231 - set_instance 232 - delete_instance 233 - references 234 235 If the provider is a "read-only" instance provider, set_instance and 236 delete_instance need not be overridden. 237 238 Only association providers need to override references. 239 240 A method provider should implement a method of the form: 241 def cim_method_<method_name>(self, env, object_name, method, 242 param_<input_param_1>, 243 param_<input_param_2>, 244 ...): 245 Where <method_name> is the name of the method from the CIM schema. 246 <method_name> needs to be all lowercase, regardless of the case of 247 the method name in the CIM schema (CIM method names are case 248 insensitive). 249 250 Keyword arguments: 251 env -- Provider Environment (pycimmb.ProviderEnvironment) 252 object_name -- A pywbem.CIMInstanceName or pywbem.CIMClassname 253 specifying the object on which the method is to be invoked. 254 method -- A pywbem.CIMMethod, representing the method to execute. 255 param_<param_name> -- Corresponds to the input parameter <param_name> 256 from the CIM schema. <param_name> needs to be all lowercase, 257 regardless of the case of the parameter name in the CIM schema 258 (CIM parameter names are case insensitive). 259 260 The method returns a two-tuple containing the return value of the 261 method, and a dictionary containing the output parameters. 262 263 Example: 264 def cim_method_requeststatechange(self, env, object_name, method, 265 param_requestedstate, 266 param_timeoutperiod): 267 # do stuff. 268 out_params = {'job': pywbem.CIMInstanceName(...)} 269 rval = pywbem.Uint32(0) 270 return (rval, out_params) 271 272 The methods prefixed with "MI_" correspond to the WBEM operations 273 from http://www.dmtf.org/standards/published_documents/DSP200.html 274 The default implementations of these methods call the methods 275 described above. These will not normally be overridden or extended 276 by a subclass. 277 278 """ 279
280 - def get_instance(self, env, model):
281 """Return an instance. 282 283 Keyword arguments: 284 env -- Provider Environment (pycimmb.ProviderEnvironment) 285 model -- A template of the pywbem.CIMInstance to be returned. The 286 key properties are set on this instance to correspond to the 287 instanceName that was requested. The properties of the model 288 are already filtered according to the PropertyList from the 289 request. Only properties present in the model need to be 290 given values. If you prefer, you can set all of the 291 values, and the instance will be filtered for you. 292 293 Possible Errors: 294 CIM_ERR_ACCESS_DENIED 295 CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized 296 or otherwise incorrect parameters) 297 CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM 298 Instance does not exist in the specified namespace) 299 CIM_ERR_FAILED (some other unspecified error occurred) 300 301 """ 302 return None
303
304 - def enum_instances(self, env, model, keys_only):
305 """Enumerate instances. 306 307 The WBEM operations EnumerateInstances and EnumerateInstanceNames 308 are both mapped to this method. 309 This method is a python generator 310 311 Keyword arguments: 312 env -- Provider Environment (pycimmb.ProviderEnvironment) 313 model -- A template of the pywbem.CIMInstances to be generated. 314 The properties of the model are already filtered according to 315 the PropertyList from the request. Only properties present in 316 the model need to be given values. If you prefer, you can 317 always set all of the values, and the instance will be filtered 318 for you. 319 keys_only -- A boolean. True if only the key properties should be 320 set on the generated instances. 321 322 Possible Errors: 323 CIM_ERR_FAILED (some other unspecified error occurred) 324 325 """ 326 pass
327
328 - def set_instance(self, env, instance, modify_existing):
329 """Return a newly created or modified instance. 330 331 Keyword arguments: 332 env -- Provider Environment (pycimmb.ProviderEnvironment) 333 instance -- The new pywbem.CIMInstance. If modifying an existing 334 instance, the properties on this instance have been filtered by 335 the PropertyList from the request. 336 modify_existing -- True if ModifyInstance, False if CreateInstance 337 338 Return the new instance. The keys must be set on the new instance. 339 340 Possible Errors: 341 CIM_ERR_ACCESS_DENIED 342 CIM_ERR_NOT_SUPPORTED 343 CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized 344 or otherwise incorrect parameters) 345 CIM_ERR_ALREADY_EXISTS (the CIM Instance already exists -- only 346 valid if modify_existing is False, indicating that the operation 347 was CreateInstance) 348 CIM_ERR_NOT_FOUND (the CIM Instance does not exist -- only valid 349 if modify_existing is True, indicating that the operation 350 was ModifyInstance) 351 CIM_ERR_FAILED (some other unspecified error occurred) 352 353 """ 354 raise pywbem.CIMError(pywbem.CIM_ERR_NOT_SUPPORTED, "")
355
356 - def delete_instance(self, env, instance_name):
357 """Delete an instance. 358 359 Keyword arguments: 360 env -- Provider Environment (pycimmb.ProviderEnvironment) 361 instance_name -- A pywbem.CIMInstanceName specifying the instance 362 to delete. 363 364 Possible Errors: 365 CIM_ERR_ACCESS_DENIED 366 CIM_ERR_NOT_SUPPORTED 367 CIM_ERR_INVALID_NAMESPACE 368 CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized 369 or otherwise incorrect parameters) 370 CIM_ERR_INVALID_CLASS (the CIM Class does not exist in the specified 371 namespace) 372 CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM 373 Instance does not exist in the specified namespace) 374 CIM_ERR_FAILED (some other unspecified error occurred) 375 376 """ 377 raise pywbem.CIMError(pywbem.CIM_ERR_NOT_SUPPORTED, "")
378
379 - def references(self, env, object_name, model, 380 result_class_name, role, result_role, keys_only):
381 """Instrument Associations. 382 383 All four association-related operations (Associators, AssociatorNames, 384 References, ReferenceNames) are mapped to this method. 385 This method is a python generator 386 387 Keyword arguments: 388 env -- Provider Environment (pycimmb.ProviderEnvironment) 389 object_name -- A pywbem.CIMInstanceName that defines the source 390 CIM Object whose associated Objects are to be returned. 391 model -- A template pywbem.CIMInstance to serve as a model 392 of the objects to be returned. Only properties present on this 393 model need to be set. 394 result_class_name -- If not empty, this string acts as a filter on 395 the returned set of Instances by mandating that each returned 396 Instances MUST represent an association between object_name 397 and an Instance of a Class whose name matches this parameter 398 or a subclass. 399 role -- If not empty, MUST be a valid Property name. It acts as a 400 filter on the returned set of Instances by mandating that each 401 returned Instance MUST refer to object_name via a Property 402 whose name matches the value of this parameter. 403 result_role -- If not empty, MUST be a valid Property name. It acts 404 as a filter on the returned set of Instances by mandating that 405 each returned Instance MUST represent associations of 406 object_name to other Instances, where the other Instances play 407 the specified result_role in the association (i.e. the 408 name of the Property in the Association Class that refers to 409 the Object related to object_name MUST match the value of this 410 parameter). 411 keys_only -- A boolean. True if only the key properties should be 412 set on the generated instances. 413 414 The following diagram may be helpful in understanding the role, 415 result_role, and result_class_name parameters. 416 +------------------------+ +-------------------+ 417 | object_name.classname | | result_class_name | 418 | ~~~~~~~~~~~~~~~~~~~~~ | | ~~~~~~~~~~~~~~~~~ | 419 +------------------------+ +-------------------+ 420 | +-----------------------------------+ | 421 | | [Association] model.classname | | 422 | object_name | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | | 423 +--------------+ object_name.classname REF role | | 424 (CIMInstanceName) | result_class_name REF result_role +------+ 425 | |(CIMInstanceName) 426 +-----------------------------------+ 427 428 Possible Errors: 429 CIM_ERR_ACCESS_DENIED 430 CIM_ERR_NOT_SUPPORTED 431 CIM_ERR_INVALID_NAMESPACE 432 CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized 433 or otherwise incorrect parameters) 434 CIM_ERR_FAILED (some other unspecified error occurred) 435 436 """ 437 # Don't change this return value. If affects the behavior 438 # of the MI_* methods. 439 return None
440
441 - def simple_refs(self, env, object_name, model, 442 result_class_name, role, result_role, keys_only):
443 444 gen = self.enum_instances(env, model, keys_only) 445 if role: 446 role = role.lower() 447 for inst in gen: 448 for prop in inst.properties.values(): 449 if prop.type != 'reference': 450 continue 451 if role and prop.name.lower() != role: 452 continue 453 if self.paths_equal(object_name, prop.value): 454 yield inst
455 456
457 - def paths_equal(self, lhs, rhs):
458 """If one object path doesn't inlcude a host, don't include the hosts 459 in the comparison 460 461 """ 462 463 if lhs is rhs: 464 return True 465 if lhs.host is not None and rhs.host is not None and\ 466 lhs.host != rhs.host: 467 return False 468 # need to make sure this stays in sync with CIMInstanceName.__cmp__() 469 return not (pywbem.cmpname(rhs.classname, lhs.classname) or 470 cmp(rhs.keybindings, lhs.keybindings) or 471 pywbem.cmpname(rhs.namespace, lhs.namespace))
472 473
474 - def MI_enumInstanceNames(self, 475 env, 476 objPath):
477 # pylint: disable=invalid-name 478 """Return instance names of a given CIM class 479 480 Implements the WBEM operation EnumerateInstanceNames in terms 481 of the enum_instances method. A derived class will not normally 482 override this method. 483 484 """ 485 486 logger = env.get_logger() 487 logger.log_debug('CIMProvider2 MI_enumInstanceNames called...') 488 model = pywbem.CIMInstance(classname=objPath.classname, 489 path=objPath) 490 gen = self.enum_instances(env=env, 491 model=model, 492 keys_only=True) 493 try: 494 iter(gen) 495 except TypeError: 496 logger.log_debug('CIMProvider2 MI_enumInstanceNames returning') 497 return 498 499 for inst in gen: 500 yield inst.path 501 logger.log_debug('CIMProvider2 MI_enumInstanceNames returning')
502
503 - def MI_enumInstances(self, 504 env, 505 objPath, 506 propertyList):
507 # pylint: disable=invalid-name 508 """Return instances of a given CIM class 509 510 Implements the WBEM operation EnumerateInstances in terms 511 of the enum_instances method. A derived class will not normally 512 override this method. 513 514 """ 515 logger = env.get_logger() 516 logger.log_debug('CIMProvider2 MI_enumInstances called...') 517 518 model = pywbem.CIMInstance(classname=objPath.classname, 519 path=objPath) 520 gen = self.enum_instances(env=env, 521 model=model, 522 keys_only=False) 523 try: 524 iter(gen) 525 except TypeError: 526 logger.log_debug('CIMProvider2 MI_enumInstances returning') 527 return 528 return gen
529
530 - def MI_getInstance(self, 531 env, 532 instanceName, 533 propertyList):
534 # pylint: disable=invalid-name 535 """Return a specific CIM instance 536 537 Implements the WBEM operation GetInstance in terms 538 of the get_instance method. A derived class will not normally 539 override this method. 540 541 """ 542 543 logger = env.get_logger() 544 logger.log_debug('CIMProvider2 MI_getInstance called...') 545 plist = None 546 if propertyList is not None: 547 plist = [s.lower() for s in propertyList] 548 plist += [s.lower() for s in instanceName.keybindings.keys()] 549 model = pywbem.CIMInstance(classname=instanceName.classname, 550 path=instanceName, property_list=plist) 551 model.update(model.path.keybindings) 552 553 rval = self.get_instance(env=env, model=model) 554 logger.log_debug('CIMProvider2 MI_getInstance returning') 555 if rval is None: 556 raise pywbem.CIMError(pywbem.CIM_ERR_NOT_FOUND, "") 557 return rval
558
559 - def MI_createInstance(self, 560 env, 561 instance):
562 # pylint: disable=invalid-name 563 """Create a CIM instance, and return its instance name 564 565 Implements the WBEM operation CreateInstance in terms 566 of the set_instance method. A derived class will not normally 567 override this method. 568 569 """ 570 571 logger = env.get_logger() 572 logger.log_debug('CIMProvider2 MI_createInstance called...') 573 rval = None 574 ''' 575 ch = env.get_cimom_handle() 576 cimClass = ch.GetClass(instance.classname, 577 instance.path.namespace, 578 LocalOnly=False, 579 IncludeQualifiers=True) 580 ''' 581 # CIMOM has already filled in default property values for 582 # props with default values, if values not supplied by client. 583 rval = self.set_instance(env=env, 584 instance=instance, 585 modify_existing=False) 586 logger.log_debug('CIMProvider2 MI_createInstance returning') 587 return rval.path
588
589 - def MI_modifyInstance(self, 590 env, 591 modifiedInstance, 592 propertyList):
593 # pylint: disable=invalid-name 594 """Modify a CIM instance 595 596 Implements the WBEM operation ModifyInstance in terms 597 of the set_instance method. A derived class will not normally 598 override this method. 599 600 """ 601 602 logger = env.get_logger() 603 logger.log_debug('CIMProvider2 MI_modifyInstance called...') 604 plist = None 605 if propertyList is not None: 606 plist = [s.lower() for s in propertyList] 607 plist += [s.lower() 608 for s in modifiedInstance.path.keybindings.keys()] 609 self.filter_instance(modifiedInstance, plist) 610 modifiedInstance.property_list = plist 611 modifiedInstance.update(modifiedInstance.path) 612 self.set_instance(env=env, 613 instance=modifiedInstance, 614 modify_existing=True) 615 logger.log_debug('CIMProvider2 MI_modifyInstance returning')
616
617 - def MI_deleteInstance(self, 618 env, 619 instanceName):
620 # pylint: disable=invalid-name 621 """Delete a CIM instance 622 623 Implements the WBEM operation DeleteInstance in terms 624 of the delete_instance method. A derived class will not normally 625 override this method. 626 627 """ 628 629 logger = env.get_logger() 630 logger.log_debug('CIMProvider2 MI_deleteInstance called...') 631 self.delete_instance(env=env, instance_name=instanceName) 632 logger.log_debug('CIMProvider2 MI_deleteInstance returning')
633 634
635 - def MI_associators(self, 636 env, 637 objectName, 638 assocClassName, 639 resultClassName, 640 role, 641 resultRole, 642 propertyList):
643 # pylint: disable=invalid-name 644 """Return instances associated to a given object. 645 646 Implements the WBEM operation Associators in terms 647 of the references method. A derived class will not normally 648 override this method. 649 650 """ 651 652 # NOTE: This should honor the parameters resultClassName, role, 653 # resultRole, and propertyList 654 logger = env.get_logger() 655 logger.log_debug('CIMProvider2 MI_associators called. ' \ 656 'assocClass: %s' % (assocClassName)) 657 if not assocClassName: 658 raise pywbem.CIMError(pywbem.CIM_ERR_FAILED, 659 "Empty assocClassName passed to Associators") 660 ch = env.get_cimom_handle() 661 model = pywbem.CIMInstance(classname=assocClassName) 662 model.path = pywbem.CIMInstanceName(classname=assocClassName, 663 namespace=objectName.namespace) 664 gen = self.references(env=env, 665 object_name=objectName, 666 model=model, 667 result_class_name=resultClassName, 668 role=role, 669 result_role=None, 670 keys_only=False) 671 if gen is None: 672 logger.log_debug('references() returned None instead of ' \ 673 'generator object') 674 return 675 for inst in gen: 676 for prop in inst.properties.values(): 677 lpname = prop.name.lower() 678 if prop.type != 'reference': 679 continue 680 if role and role.lower() == lpname: 681 continue 682 if resultRole and resultRole.lower() != lpname: 683 continue 684 if self.paths_equal(prop.value, objectName): 685 continue 686 if resultClassName and \ 687 resultClassName.lower() != prop.value.classname.lower(): 688 continue 689 try: 690 if prop.value.namespace is None: 691 prop.value.namespace = objectName.namespace 692 inst = ch.GetInstance(prop.value, propertyList) 693 except pywbem.CIMError, (num, msg): 694 if num == pywbem.CIM_ERR_NOT_FOUND: 695 continue 696 else: 697 raise 698 if inst.path is None: 699 inst.path = prop.value 700 yield inst 701 logger.log_debug('CIMProvider2 MI_associators returning')
702
703 - def MI_associatorNames(self, 704 env, 705 objectName, 706 assocClassName, 707 resultClassName, 708 role, 709 resultRole):
710 # pylint: disable=invalid-name 711 """Return instances names associated to a given object. 712 713 Implements the WBEM operation AssociatorNames in terms 714 of the references method. A derived class will not normally 715 override this method. 716 717 """ 718 719 logger = env.get_logger() 720 logger.log_debug('CIMProvider2 MI_associatorNames called. ' \ 721 'assocClass: %s' % (assocClassName)) 722 if not assocClassName: 723 raise pywbem.CIMError( 724 pywbem.CIM_ERR_FAILED, 725 "Empty assocClassName passed to AssociatorNames") 726 model = pywbem.CIMInstance(classname=assocClassName) 727 model.path = pywbem.CIMInstanceName(classname=assocClassName, 728 namespace=objectName.namespace) 729 gen = self.references(env=env, 730 object_name=objectName, 731 model=model, 732 result_class_name=resultClassName, 733 role=role, 734 result_role=None, 735 keys_only=False) 736 if gen is None: 737 logger.log_debug('references() returned None instead of ' \ 738 'generator object') 739 return 740 for inst in gen: 741 for prop in inst.properties.values(): 742 lpname = prop.name.lower() 743 if prop.type != 'reference': 744 continue 745 if role and role.lower() == lpname: 746 continue 747 if resultRole and resultRole.lower() != lpname: 748 continue 749 if self.paths_equal(prop.value, objectName): 750 continue 751 if resultClassName and \ 752 resultClassName.lower() != prop.value.classname.lower(): 753 continue 754 if prop.value.namespace is None: 755 prop.value.namespace = objectName.namespace 756 yield prop.value 757 logger.log_debug('CIMProvider2 MI_associatorNames returning')
758
759 - def MI_references(self, 760 env, 761 objectName, 762 resultClassName, 763 role, 764 propertyList):
765 # pylint: disable=invalid-name 766 """Return instances of an association class. 767 768 Implements the WBEM operation References in terms 769 of the references method. A derived class will not normally 770 override this method. 771 772 """ 773 774 logger = env.get_logger() 775 logger.log_debug('CIMProvider2 MI_references called. ' \ 776 'resultClass: %s' % (resultClassName)) 777 if not resultClassName: 778 raise pywbem.CIMError( 779 pywbem.CIM_ERR_FAILED, 780 "Empty resultClassName passed to References") 781 plist = None 782 if propertyList is not None: 783 plist = [s.lower() for s in propertyList] 784 model = pywbem.CIMInstance(classname=resultClassName, 785 property_list=plist) 786 model.path = pywbem.CIMInstanceName(classname=resultClassName, 787 namespace=objectName.namespace) 788 if role: 789 if role in model.properties: 790 model[role] = objectName 791 792 gen = self.references(env=env, 793 object_name=objectName, 794 model=model, 795 result_class_name='', 796 role=role, 797 result_role=None, 798 keys_only=False) 799 if gen is None: 800 logger.log_debug('references() returned None instead of ' \ 801 'generator object') 802 return 803 for inst in gen: 804 for prop in inst.properties.values(): 805 if hasattr(prop.value, 'namespace') and \ 806 prop.value.namespace is None: 807 prop.value.namespace = objectName.namespace 808 yield inst 809 logger.log_debug('CIMProvider2 MI_references returning')
810
811 - def MI_referenceNames(self, 812 env, 813 objectName, 814 resultClassName, 815 role):
816 # pylint: disable=invalid-name 817 """Return instance names of an association class. 818 819 Implements the WBEM operation ReferenceNames in terms 820 of the references method. A derived class will not normally 821 override this method. 822 823 """ 824 825 logger = env.get_logger() 826 logger.log_debug('CIMProvider2 MI_referenceNames <2> called. ' \ 827 'resultClass: %s' % (resultClassName)) 828 if not resultClassName: 829 raise pywbem.CIMError( 830 pywbem.CIM_ERR_FAILED, 831 "Empty resultClassName passed to ReferenceNames") 832 833 model = pywbem.CIMInstance(classname=resultClassName) 834 model.path = pywbem.CIMInstanceName(classname=resultClassName, 835 namespace=objectName.namespace) 836 if role: 837 if role in model.properties: 838 model[role] = objectName 839 gen = self.references(env=env, 840 object_name=objectName, 841 model=model, 842 result_class_name='', 843 role=role, 844 result_role=None, 845 keys_only=True) 846 if gen is None: 847 logger.log_debug('references() returned None instead of ' \ 848 'generator object') 849 return 850 for inst in gen: 851 for prop in inst.properties.values(): 852 if hasattr(prop.value, 'namespace') and \ 853 prop.value.namespace is None: 854 prop.value.namespace = objectName.namespace 855 yield inst.path 856 logger.log_debug('CIMProvider2 MI_referenceNames returning')
857
858 - def MI_invokeMethod(self, env, objectName, methodName, inputParams):
859 # pylint: disable=invalid-name 860 """Invoke an extrinsic method. 861 862 Implements the InvokeMethod WBEM operation by calling the 863 method on a derived class called cim_method_<method_name>, 864 where <method_name> is the name of the CIM method, in all 865 lower case. 866 867 Arguments: 868 env -- Provider Environment (pycimmb.ProviderEnvironment) 869 objectName -- The InstanceName or ClassName of the object on 870 which the method is invoked. 871 methodName -- The name of the method to be invoked. 872 inputParams -- A Dictionary where the key is the parameter name 873 and the value is the parameter value. 874 875 The return value for invokeMethod must be a tuple of size 2 876 where: 877 element 0 is a tuple of size 2 where element 0 is the return 878 data type name and element 1 is the actual data value. 879 element 1 is a dictionary where the key is the output 880 parameter name and the value is a tuple of size 2 where 881 element 0 is the data type name for the output parameter 882 and element 1 is the actual value of the output parameter. 883 884 A derived class will not normally override this method. 885 886 """ 887 888 logger = env.get_logger() 889 logger.log_debug('CIMProvider2 MI_invokeMethod called. ' \ 890 'method: %s:%s' % (objectName.classname, methodName)) 891 lmethName = "cim_method_%s" % methodName.lower() 892 if hasattr(self, lmethName): 893 method = getattr(self, lmethName) 894 new_inputs = dict([('param_%s' % k.lower(), v) \ 895 for k, v in inputParams.items()]) 896 try: 897 (rval, outs) = method(env=env, object_name=objectName, 898 **new_inputs) 899 except TypeError, e: 900 raise pywbem.CIMError(pywbem.CIM_ERR_INVALID_PARAMETER, str(e)) 901 902 def add_type(v): 903 if isinstance(v, pywbem.CIMParameter): 904 return (v.type, v.value) 905 lv = v 906 if type(v) == list and len(v) > 0: 907 lv = v[0] 908 if isinstance(lv, pywbem.CIMClass): 909 tp = 'class' 910 elif isinstance(lv, pywbem.CIMInstance): 911 tp = 'instance' 912 elif isinstance(lv, pywbem.CIMInstanceName): 913 tp = 'reference' 914 elif v is None or (type(v) == list and len(v) == 0): 915 assert(None == 'This should not happen') 916 else: 917 tp = pywbem.cimtype(v) 918 return (tp, v)
919 920 louts = {} 921 for op in outs: 922 louts[op.name] = (op.type, op.value) 923 rval = add_type(rval) 924 rval = (rval, louts) 925 else: 926 raise pywbem.CIMError( 927 pywbem.CIM_ERR_METHOD_NOT_FOUND, 928 "%s:%s"%(objectName.classname, methodName)) 929 logger.log_debug('CIMProvider2 MI_invokeMethod returning') 930 return rval
931
932 - def filter_instance(self, inst, plist):
933 """Remove properties from an instance that aren't in the PropertyList 934 935 inst -- The CIMInstance 936 plist -- The property List, or None. The list items must be all 937 lowercase. 938 939 """ 940 941 if plist is not None: 942 for pname in inst.properties.keys(): 943 if pname.lower() not in plist and pname: 944 if inst.path is not None and pname in inst.path.keybindings: 945 continue 946 del inst.properties[pname]
947
948 - def authorize_filter(env, filter, ns, classes, owner):
949 """Allow or disallow an indication subscription request. 950 951 Arguments: 952 env -- Provider Environment (pycimmb.ProviderEnvironment) 953 filter -- The WQL select statement 954 namespace -- The namepace where the indication is registered for 955 classes -- The classpath of the indication registered for 956 owner -- The name of the principal (cimom user) 957 """ 958 pass
959
960 - def activate_filter(env, filter, ns, classes, first_activation):
961 """Activate an indication subscription. 962 963 Arguments: 964 env -- Provider Environment (pycimmb.ProviderEnvironment) 965 filter -- The WQL select statement 966 namespace -- The namepace where the indication is registered for 967 classes -- The classpath of the indication registered for 968 first_activation -- boolean - whether first activation 969 """ 970 pass
971
972 - def deactivate_filter(env, filter, ns, classes, last_activation):
973 """Deactivate an indication subscription. 974 975 Arguments: 976 env -- Provider Environment (pycimmb.ProviderEnvironment) 977 filter -- The WQL select statement 978 ns -- The namepace where the indication is registered for 979 classes -- The classpath of the indication registered for 980 last_activation -- boolean - whether last activation 981 """ 982 pass
983
984 - def enable_indications(env):
985 """Enable indications. 986 987 Arguments: 988 env -- Provider Environment (pycimmb.ProviderEnvironment) 989 """ 990 pass
991
992 - def disable_indications(env):
993 """Disable indications. 994 995 Arguments: 996 env -- Provider Environment (pycimmb.ProviderEnvironment) 997 """ 998 pass
999 1000
1001 -def codegen(cc):
1002 """Generate a Python Provider template. 1003 1004 Parameters: 1005 cc - A CIMClass to generate code for. 1006 1007 Returns a two-tuple containing the Python provider code stubs, and 1008 the provider registration MOF. 1009 1010 """ 1011 1012 import inspect 1013 1014 def format_desc(obj, indent): 1015 linelen = 75 - indent 1016 if isinstance(obj, basestring): 1017 raw = obj 1018 else: 1019 try: 1020 raw = obj.qualifiers['description'].value 1021 except KeyError: 1022 return '' 1023 txt = '' 1024 beg = 0 1025 end = 0 1026 while beg < len(raw): 1027 beg = end 1028 end += linelen 1029 while beg < len(raw) and raw[beg].isspace(): 1030 beg = beg+1 1031 while end < len(raw) and end > beg and not raw[end].isspace(): 1032 end = end-1 1033 if beg == end: # a long URL 1034 while end < len(raw) and not raw[end].isspace(): 1035 end += 1 1036 line = raw[beg:end] 1037 line = line.replace('\n', ' ') 1038 line = line.replace('\r', '') 1039 txt += '\n%s%s'% (''.ljust(indent), line) 1040 return txt
1041 1042 ################# 1043 def map_value(obj, val): 1044 rv = str(val) 1045 if 'ValueMap' not in obj.qualifiers: 1046 return rv 1047 if 'Values' not in obj.qualifiers: 1048 return rv 1049 vals = [str(x) for x in obj.qualifiers['Values'].value] 1050 maps = [str(x) for x in obj.qualifiers['ValueMap'].value] 1051 d = dict(zip(maps, vals)) 1052 try: 1053 tmp = d[str(val)] 1054 rv = '' 1055 for ch in tmp: 1056 rv += ch.isalnum() and ch or '_' 1057 except KeyError: 1058 pass 1059 return rv 1060 1061 ################# 1062 def type_hint(obj, method_name=None): 1063 if hasattr(obj, 'type'): 1064 tx = obj.type 1065 if 'embeddedinstance' in obj.qualifiers: 1066 tx = "pywbem.CIMInstance(classname='%s', ...)" % \ 1067 obj.qualifiers['embeddedinstance'].value 1068 elif tx == 'reference': 1069 tx = "pywbem.CIMInstanceName(classname='%s', ...)" % \ 1070 obj.reference_class 1071 else: 1072 tx = obj.return_type 1073 if hasattr(obj, 'value') and obj.value is not None: 1074 defval = str(obj.value) 1075 else: 1076 defval = '' 1077 if not tx.startswith('pywbem.'): 1078 if tx == 'boolean': 1079 tx = 'bool(%s)' % defval 1080 elif tx == 'datetime': 1081 tx = 'pywbem.CIMDateTime()' 1082 elif tx == 'string': 1083 tx = "''" 1084 else: 1085 tx = 'pywbem.%s(%s)' % (tx.capitalize(), defval) 1086 if 'valuemap' in obj.qualifiers: 1087 if defval: 1088 defval = map_value(obj, defval) 1089 else: 1090 defval = '<VAL>' 1091 tx = 'self.Values.%s%s.%s' % \ 1092 (method_name and '%s.'%method_name or '', 1093 obj.name, defval) 1094 if hasattr(obj, 'is_array') and obj.is_array: 1095 tx = '[%s,]' % tx 1096 return tx 1097 ################# 1098 def type_str(obj, method_name=None): 1099 if hasattr(obj, 'type'): 1100 tx = obj.type 1101 if 'embeddedinstance' in obj.qualifiers: 1102 return "pywbem.CIMInstance(classname='%s', ...)" % \ 1103 obj.qualifiers['embeddedinstance'].value 1104 elif tx == 'reference': 1105 return "REF (pywbem.CIMInstanceName(classname='%s', ...)" % \ 1106 obj.reference_class 1107 else: 1108 tx = obj.return_type 1109 if tx == 'boolean': 1110 tx = 'bool' 1111 elif tx == 'datetime': 1112 tx = 'pywbem.CIMDateTime' 1113 elif tx == 'string': 1114 tx = 'unicode' 1115 else: 1116 tx = 'pywbem.%s' % tx.capitalize() 1117 if hasattr(obj, 'is_array') and obj.is_array: 1118 tx = '[%s,]' % tx 1119 if 'valuemap' in obj.qualifiers: 1120 tx += ' self.Values.%s%s' % \ 1121 (method_name and '%s.'%method_name or '', obj.name) 1122 return tx 1123 ################# 1124 def is_required(obj): 1125 if 'required' in obj.qualifiers and obj.qualifiers['required'].value: 1126 return '(Required)' 1127 return '' 1128 ################# 1129 def build_reverse_val_map(obj): 1130 vm = obj.qualifiers['valuemap'].value 1131 if 'values' in obj.qualifiers: 1132 vals = obj.qualifiers['values'].value 1133 else: 1134 vals = vm 1135 tmap = zip(vals, vm) 1136 rv = {} 1137 for val, vm in tmap: 1138 try: 1139 vmi = int(vm) 1140 except ValueError: 1141 continue 1142 rv[vmi] = str(val) # we want normal strings, not unicode 1143 return rv 1144 ################# 1145 def build_val_map(obj): 1146 vm = obj.qualifiers['valuemap'].value 1147 if 'values' in obj.qualifiers: 1148 vals = obj.qualifiers['values'].value 1149 else: 1150 vals = vm 1151 tmap = zip(vals, vm) 1152 map = [] 1153 for t in tmap: 1154 nname = '' 1155 for ch in t[0]: 1156 if ch.isalnum(): 1157 nname += ch 1158 else: 1159 nname += '_' 1160 if hasattr(obj, 'return_type'): 1161 tp = obj.return_type 1162 else: 1163 tp = obj.type 1164 if tp == 'string': 1165 val = "'%s'" % t[1] 1166 else: 1167 try: 1168 int(t[1]) 1169 val = 'pywbem.%s(%s)' % (tp.capitalize(), t[1]) 1170 except ValueError: 1171 val = t[1] 1172 nname = "# "+nname 1173 map.append((nname, val)) 1174 return map 1175 1176 valuemaps = {} 1177 rvaluemaps = pywbem.NocaseDict() 1178 1179 for prop in cc.properties.values(): 1180 if 'valuemap' in prop.qualifiers and 'values' in prop.qualifiers: 1181 rvaluemaps[prop.name] = build_reverse_val_map(prop) 1182 1183 for obj in cc.properties.values() + cc.methods.values(): 1184 if 'valuemap' in obj.qualifiers: 1185 valuemaps[obj.name] = {'<vms>':build_val_map(obj)} 1186 1187 for meth in cc.methods.values(): 1188 for parm in meth.parameters.values(): 1189 if 'valuemap' in parm.qualifiers: 1190 if meth.name not in valuemaps: 1191 valuemaps[meth.name] = {} 1192 valuemaps[meth.name][parm.name] = build_val_map(parm) 1193 1194 mappings = {'classname':cc.classname, 1195 'classname_l':cc.classname.lower()} 1196 isAssoc = 'association' in cc.qualifiers 1197 isIndication = 'indication' in cc.qualifiers 1198 1199 code = '''"""Python Provider for %(classname)s 1200 1201 Instruments the CIM class %(classname)s 1202 1203 """ 1204 1205 import pywbem 1206 from pywbem.cim_provider2 import CIMProvider2 1207 1208 class %(classname)s(CIMProvider2): 1209 """Instrument the CIM class %(classname)s \n''' % mappings 1210 code += format_desc(cc, 4) 1211 code += ''' 1212 """''' 1213 1214 1215 args = inspect.getargspec(CIMProvider2.get_instance)[0] 1216 args = ', '.join(args) 1217 code += ''' 1218 1219 def __init__ (self, env): 1220 logger = env.get_logger() 1221 logger.log_debug('Initializing provider %%s from %%s' \\ 1222 %% (self.__class__.__name__, __file__)) 1223 1224 def get_instance(%s): 1225 """%s""" 1226 1227 logger = env.get_logger() 1228 logger.log_debug('Entering %%s.get_instance()' \\ 1229 %% self.__class__.__name__) 1230 ''' % (args, CIMProvider2.get_instance.__doc__) 1231 keyProps = [p for p in cc.properties.values() \ 1232 if 'key' in p.qualifiers] 1233 if not keyProps and 'association' in cc.qualifiers: 1234 # SFCB has problems with qualifiers on REF properties. 1235 # http://sourceforge.net/tracker/index.php?func=detail&aid=2104565&group_id=128809&atid=712784 1236 keyProps = [p for p in cc.properties.values() \ 1237 if p.type == 'reference'] 1238 for prop in keyProps: 1239 prop.qualifiers['KEY'] = True 1240 code += ''' 1241 1242 # TODO fetch system resource matching the following keys:''' 1243 for kp in keyProps: 1244 code += ''' 1245 # model['%s']''' % kp.name 1246 code += '\n' 1247 props = cc.properties.values() 1248 props.sort() 1249 for prop in props: 1250 if 'key' in prop.qualifiers: 1251 continue 1252 line = "#model['%s'] = %s # TODO %s" % \ 1253 (prop.name, type_hint(prop), is_required(prop)) 1254 code += ''' 1255 %s''' % line 1256 1257 args = inspect.getargspec(CIMProvider2.enum_instances)[0] 1258 args = ', '.join(args) 1259 code += ''' 1260 return model 1261 1262 def enum_instances(%s): 1263 """%s""" 1264 1265 logger = env.get_logger() 1266 logger.log_debug('Entering %%s.enum_instances()' \\ 1267 %% self.__class__.__name__) 1268 ''' % (args, CIMProvider2.enum_instances.__doc__) 1269 keydict = dict([(str(kp.name), None) for kp in keyProps]) 1270 code += ''' 1271 # Prime model.path with knowledge of the keys, so key values on 1272 # the CIMInstanceName (model.path) will automatically be set when 1273 # we set property values on the model. 1274 model.pa%s 1275 ''' % format_desc('th.update('+str(keydict)+')', 12).strip() 1276 1277 code += ''' 1278 while False: # TODO more instances? 1279 # TODO fetch system resource 1280 # Key properties''' 1281 for kp in keyProps: 1282 if kp.name == 'CreationClassName': 1283 line = "model['%s'] = '%s'" % (kp.name, cc.classname) 1284 else: 1285 line = "#model['%s'] = %s # TODO (type = %s)" % \ 1286 (kp.name, type_hint(kp), type_str(kp)) 1287 code += ''' 1288 %s''' % line 1289 code += ''' 1290 if keys_only: 1291 yield model 1292 else: 1293 try: 1294 yield self.get_instance(env, model) 1295 except pywbem.CIMError, (num, msg): 1296 if num not in (pywbem.CIM_ERR_NOT_FOUND, 1297 pywbem.CIM_ERR_ACCESS_DENIED): 1298 raise\n''' 1299 1300 args = inspect.getargspec(CIMProvider2.set_instance)[0] 1301 args = ', '.join(args) 1302 code += ''' 1303 def set_instance(%s): 1304 """%s""" 1305 1306 logger = env.get_logger() 1307 logger.log_debug('Entering %%s.set_instance()' \\ 1308 %% self.__class__.__name__) 1309 # TODO create or modify the instance 1310 raise pywbem.CIMError(pywbem.CIM_ERR_NOT_SUPPORTED) # Remove to implement 1311 return instance''' % (args, CIMProvider2.set_instance.__doc__) 1312 1313 args = inspect.getargspec(CIMProvider2.delete_instance)[0] 1314 args = ', '.join(args) 1315 code += ''' 1316 1317 def delete_instance(%s): 1318 """%s""" 1319 1320 logger = env.get_logger() 1321 logger.log_debug('Entering %%s.delete_instance()' \\ 1322 %% self.__class__.__name__) 1323 1324 # TODO delete the resource 1325 raise pywbem.CIMError(pywbem.CIM_ERR_NOT_SUPPORTED) # Remove to implement 1326 ''' % (args, CIMProvider2.delete_instance.__doc__) 1327 1328 for method in cc.methods.values(): 1329 inParms = [p for p in method.parameters.values() if \ 1330 'in' in p.qualifiers and p.qualifiers['in'].value] 1331 outParms = [p for p in method.parameters.values() if \ 1332 'out' in p.qualifiers and p.qualifiers['out'].value] 1333 code += ''' 1334 def cim_method_%s(self, env, object_name''' % method.name.lower() 1335 for p in inParms: 1336 if 'required' in p.qualifiers and p.qualifiers['required']: 1337 code += ''',\n%sparam_%s''' % (''.rjust(len(method.name)+20), 1338 p.name.lower()) 1339 for p in inParms: 1340 if 'required' not in p.qualifiers or not p.qualifiers['required']: 1341 code += ''',\n%sparam_%s=None''' % \ 1342 (''.rjust(len(method.name)+20), 1343 p.name.lower()) 1344 code += '''): 1345 """Implements %s.%s()\n''' % (cc.classname, method.name) 1346 code += format_desc(method, 8) 1347 1348 code += ''' 1349 Keyword arguments: 1350 env -- Provider Environment (pycimmb.ProviderEnvironment) 1351 object_name -- A pywbem.CIMInstanceName or pywbem.CIMCLassName 1352 specifying the object on which the method %s() 1353 should be invoked.'''\ 1354 % method.name 1355 1356 for p in inParms: 1357 code += ''' 1358 param_%s -- The input parameter %s (type %s) %s''' \ 1359 % (p.name.lower(), p.name, type_str(p, method.name), 1360 is_required(p)) 1361 code += format_desc(p, 12) 1362 1363 code += ''' 1364 1365 Returns a two-tuple containing the return value (type %s) 1366 and a list of CIMParameter objects representing the output parameters 1367 1368 Output parameters:''' % type_str(method) 1369 1370 if not outParms: 1371 code += ' none' 1372 else: 1373 for p in outParms: 1374 code += ''' 1375 %s -- (type %s) %s''' % (p.name, type_str(p, method.name), 1376 is_required(p)) 1377 code += format_desc(p, 12) 1378 1379 code += ''' 1380 1381 Possible Errors: 1382 CIM_ERR_ACCESS_DENIED 1383 CIM_ERR_INVALID_PARAMETER (including missing, duplicate, 1384 unrecognized or otherwise incorrect parameters) 1385 CIM_ERR_NOT_FOUND (the target CIM Class or instance does not 1386 exist in the specified namespace) 1387 CIM_ERR_METHOD_NOT_AVAILABLE (the CIM Server is unable to honor 1388 the invocation request) 1389 CIM_ERR_FAILED (some other unspecified error occurred) 1390 1391 """ 1392 1393 logger = env.get_logger() 1394 logger.log_debug('Entering %%s.cim_method_%s()' \\ 1395 %% self.__class__.__name__) 1396 1397 # TODO do something 1398 raise pywbem.CIMError(pywbem.CIM_ERR_METHOD_NOT_AVAILABLE) # Remove to implemented 1399 out_params = []''' % method.name.lower() 1400 1401 for p in outParms: 1402 code += ''' 1403 #out_params+= [pywbem.CIMParameter('%s', type='%s', 1404 # value=%s)] # TODO''' % \ 1405 (p.name.lower(), p.type, type_hint(p, method.name)) 1406 1407 code += ''' 1408 #rval = # TODO (type %s) 1409 return (rval, out_params) 1410 ''' % type_str(method) 1411 1412 if isAssoc: 1413 args = inspect.getargspec(CIMProvider2.references)[0] 1414 args = format_desc(', '.join(args), 19).strip() 1415 code += ''' 1416 def references(%s): 1417 """%s""" 1418 1419 logger = env.get_logger() 1420 logger.log_debug('Entering %%s.references()' \\ 1421 %% self.__class__.__name__) 1422 ch = env.get_cimom_handle()''' % \ 1423 (args, CIMProvider2.references.__doc__) 1424 1425 refprops = [] 1426 for prop in cc.properties.values(): 1427 if prop.reference_class is not None: 1428 refprops.append((prop.name, prop.reference_class)) 1429 1430 code += '''\n 1431 # If you want to get references for free, implemented in terms 1432 # of enum_instances, just leave the code below unaltered.''' 1433 1434 for i, refprop in enumerate(refprops): 1435 if i == 0: 1436 code += ''' 1437 if ch.is_subclass(object_name.namespace, 1438 sub=object_name.classname, 1439 super='%s')''' % refprop[1] 1440 1441 else: 1442 code += ''' or \\ 1443 ch.is_subclass(object_name.namespace, 1444 sub=object_name.classname, 1445 super='%s')''' % refprop[1] 1446 code += ''': 1447 return self.simple_refs(env, object_name, model, 1448 result_class_name, role, result_role, keys_only) 1449 ''' 1450 1451 1452 code += ''' 1453 # If you are doing simple refs with the code above, remove the 1454 # remainder of this method. Or, remove the stuff above and 1455 # implement references below. You need to pick either the 1456 # above approach or the below, and delete the other. Otherwise 1457 # you'll get a SyntaxError on the first yield below. 1458 1459 # Prime model.path with knowledge of the keys, so key values on 1460 # the CIMInstanceName (model.path) will automatically be set when 1461 # we set property values on the model. 1462 model.pa%s 1463 1464 # This is a common pattern. YMMV''' % \ 1465 format_desc('th.update('+str(keydict)+')', 12).strip() 1466 1467 for refprop in refprops: 1468 code += ''' 1469 if (not role or role.lower() == '%(refpropnamel)s') and \\ 1470 ch.is_subclass(object_name.namespace, 1471 sub=object_name.classname, 1472 super='%(rolecname)s'): 1473 model['%(refpropname)s'] = object_name 1474 yield model # TODO: Add other REF properties. 1475 # Yield association instances where 1476 # object_name is %(refpropnamel)s. 1477 # Only appropriate if object_name.classname 1478 # is '%(rolecname)s' or a subclass.\n''' \ 1479 % {'refpropname':refprop[0], 1480 'refpropnamel':refprop[0].lower(), 1481 'rolecname':refprop[1]} 1482 1483 if valuemaps: 1484 code += ''' 1485 class Values(object):''' 1486 for group, maps in valuemaps.items(): 1487 code += ''' 1488 class %s(object):''' % group 1489 if '<vms>' in maps: 1490 for value, vm in maps['<vms>']: 1491 if value in maps: 1492 value = value+'_' 1493 code += ''' 1494 %s = %s''' % (value, vm) 1495 if group in rvaluemaps: 1496 code += ''' 1497 _reverse_map = %s''' % repr(rvaluemaps[group]) 1498 for pname, vms in maps.items(): 1499 if pname == '<vms>': 1500 continue 1501 code += ''' 1502 class %s(object):''' % pname 1503 for value, vm in vms: 1504 code += ''' 1505 %s = %s''' % (value, vm) 1506 code += '\n' 1507 1508 code += ''' 1509 ## end of class %(classname)sProvider 1510 1511 ## get_providers() for associating CIM Class Name to python provider class name 1512 1513 def get_providers(env): 1514 %(classname_l)s_prov = %(classname)s(env) 1515 return {'%(classname)s': %(classname_l)s_prov} 1516 ''' % mappings 1517 1518 if isIndication: 1519 code += ''' 1520 1521 ## Indication support methods... 1522 ## Use these methods if this class will deliver indications. 1523 ## Remove these methods if this class will not deliver indications.''' 1524 args = inspect.getargspec(CIMProvider2.authorize_filter)[0] 1525 args = format_desc(', '.join(args), 19).strip() 1526 code += ''' 1527 1528 1529 def authorize_filter(%s): 1530 """%s""" 1531 1532 logger = env.get_logger() 1533 logger.log_debug('Entering %%s.authorize_filter()' \\ 1534 %% self.__class__.__name__) 1535 ch = env.get_cimom_handle() 1536 #raise pywbem.CIMError(pywbem.CIM_ERR_***) to indicate failure 1537 #otherwise just fall through for success''' % \ 1538 (args, CIMProvider2.authorize_filter.__doc__ or "Doc Goes Here") 1539 1540 args = inspect.getargspec(CIMProvider2.enable_indications)[0] 1541 args = format_desc(', '.join(args), 19).strip() 1542 code += ''' 1543 1544 1545 def enable_indications(%s): 1546 """%s""" 1547 1548 logger = env.get_logger() 1549 logger.log_debug('Entering %%s.enable_indications()' \\ 1550 %% self.__class__.__name__) 1551 ch = env.get_cimom_handle() 1552 #raise pywbem.CIMError(pywbem.CIM_ERR_***) to indicate failure 1553 #otherwise just fall through for success''' % \ 1554 (args, CIMProvider2.enable_indications.__doc__ or "Doc Goes Here") 1555 1556 args = inspect.getargspec(CIMProvider2.disable_indications)[0] 1557 args = format_desc(', '.join(args), 19).strip() 1558 code += ''' 1559 1560 1561 def disable_indications(%s): 1562 """%s""" 1563 1564 logger = env.get_logger() 1565 logger.log_debug('Entering %%s.disable_indications()' \\ 1566 %% self.__class__.__name__) 1567 ch = env.get_cimom_handle() 1568 #raise pywbem.CIMError(pywbem.CIM_ERR_***) to indicate failure 1569 #otherwise just fall through for success''' % \ 1570 (args, CIMProvider2.disable_indications.__doc__ or "Doc Goes Here") 1571 1572 args = inspect.getargspec(CIMProvider2.activate_filter)[0] 1573 args = format_desc(', '.join(args), 19).strip() 1574 code += ''' 1575 1576 1577 def activate_filter(%s): 1578 """%s""" 1579 1580 logger = env.get_logger() 1581 logger.log_debug('Entering %%s.activate_filter()' \\ 1582 %% self.__class__.__name__) 1583 ch = env.get_cimom_handle() 1584 #raise pywbem.CIMError(pywbem.CIM_ERR_***) to indicate failure 1585 #otherwise just fall through for success''' % \ 1586 (args, CIMProvider2.activate_filter.__doc__ or "Doc Goes Here") 1587 1588 1589 args = inspect.getargspec(CIMProvider2.deactivate_filter)[0] 1590 args = format_desc(', '.join(args), 19).strip() 1591 code += ''' 1592 1593 1594 def deactivate_filter(%s): 1595 """%s""" 1596 1597 logger = env.get_logger() 1598 logger.log_debug('Entering %%s.deactivate_filter()' \\ 1599 %% self.__class__.__name__) 1600 ch = env.get_cimom_handle() 1601 #raise pywbem.CIMError(pywbem.CIM_ERR_***) to indicate failure 1602 #otherwise just fall through for success''' % \ 1603 (args, CIMProvider2.deactivate_filter.__doc__ or "Doc Goes Here") 1604 1605 code += ''' 1606 1607 ## End of Indication Support Methods''' 1608 1609 owtypes = ['1', 'Instance'] 1610 pegtypes = ['2', 'Instance'] 1611 sfcbtypes = 'instance' 1612 if isAssoc: 1613 owtypes[0] += ',3' 1614 owtypes[1] += ', Associator' 1615 pegtypes[0] += ',3' 1616 pegtypes[1] += ', Associator' 1617 sfcbtypes += ' association' 1618 if cc.methods: 1619 owtypes[0] += ',6' 1620 owtypes[1] += ', Method' 1621 pegtypes[0] += ',5' 1622 pegtypes[1] += ', Method' 1623 sfcbtypes += ' method' 1624 omitted = ''' 1625 // OpenWBEM Provider registration for %(classname)s 1626 instance of OpenWBEM_PyProviderRegistration 1627 { 1628 InstanceID = "<org:product:%(classname)s:unique_id>"; // TODO 1629 NamespaceNames = {"root/cimv2"}; // TODO 1630 ClassName = "%(classname)s"; 1631 ProviderTypes = {%(owtypeNums)s}; // %(owtypeStrs)s 1632 ModulePath = "/usr/lib/pycim/%(classname)sProvider.py"; // TODO 1633 }; 1634 ''' 1635 1636 mof = ''' 1637 // SFCB Provider registration for %(classname)s 1638 [%(classname)s] 1639 provider: %(classname)s 1640 location: pyCmpiProvider 1641 type: %(sfcbtypes)s 1642 namespace: root/cimv2 // TODO 1643 1644 // Pegasus Provider registration for %(classname)s 1645 instance of PG_ProviderModule 1646 { 1647 Name = "pyCmpiProvider_%(classname)s"; 1648 InterfaceType = "CMPI"; 1649 InterfaceVersion = "2.0.0"; 1650 Location = "pyCmpiProvider"; 1651 UserContext = 2; // Requestor 1652 Vendor = "TODO"; // TODO 1653 Version = "1.0"; 1654 }; 1655 instance of PG_Provider 1656 { 1657 Name = "%(classname)s"; 1658 ProviderModuleName = "pyCmpiProvider_%(classname)s"; 1659 }; 1660 instance of PG_ProviderCapabilities 1661 { 1662 CapabilityID = "%(classname)s"; 1663 ProviderModuleName = "pyCmpiProvider_%(classname)s"; 1664 ProviderName = "%(classname)s"; 1665 ClassName = "%(classname)s"; 1666 Namespaces = {"root/cimv2"}; // TODO 1667 ProviderType = {%(pegtypeNum)s}; // %(pegtypeStr)s 1668 };\n''' % {'classname': cc.classname, 1669 'owtypeNums': owtypes[0], 1670 'owtypeStrs': owtypes[1], 1671 'pegtypeNum': pegtypes[0], 1672 'pegtypeStr': pegtypes[1], 1673 'sfcbtypes' : sfcbtypes} 1674 1675 1676 return code, mof 1677
1678 -class ProviderProxy(object):
1679 """Wraps a provider module, and routes requests into the module """ 1680
1681 - def __init__(self, env, provid):
1682 self.env = env 1683 if isinstance(provid, ModuleType): 1684 self.provmod = provid 1685 self.provid = provid.__name__ 1686 self.filename = provid.__file__ 1687 else: 1688 logger = env.get_logger() 1689 logger.log_debug('Loading python provider at %s' %provid) 1690 self.provid = provid 1691 self._load_provider_source(logger) 1692 self._init_provider(env)
1693
1694 - def _init_provider(self, env):
1695 self.provregs = {} 1696 if hasattr(self.provmod, 'init'): 1697 self.provmod.init(env) 1698 if hasattr(self.provmod, 'get_providers'): 1699 self.provregs = pywbem.NocaseDict(self.provmod.get_providers(env))
1700
1701 - def _load_provider_source(self, logger):
1702 self.provider_module_name = os.path.basename(self.provid)[:-3] 1703 # let providers import other providers in the same directory 1704 provdir = dirname(self.provid) 1705 if provdir not in sys.path: 1706 sys.path.append(provdir) 1707 try: 1708 self.provmod = sys.modules[self.provider_module_name] 1709 logger.log_debug('Provider %s already loaded, found in ' \ 1710 'sys.modules' % self.provmod) 1711 except KeyError: 1712 try: 1713 # use full path in module name for uniqueness. 1714 logger.log_debug('Loading provider %s from source' % \ 1715 self.provid) 1716 fn = imp.find_module(self.provider_module_name, [provdir]) 1717 try: 1718 g_mod_lock.acquire() 1719 imp.acquire_lock() 1720 self.provmod = imp.load_module( 1721 self.provider_module_name, *fn) 1722 self.provmod.provmod_timestamp = \ 1723 os.path.getmtime(self.provid) 1724 finally: 1725 imp.release_lock() 1726 g_mod_lock.release() 1727 fn[0].close() 1728 except IOError, arg: 1729 raise pywbem.CIMError( 1730 pywbem.CIM_ERR_FAILED, 1731 "Error loading provider %s: %s" % (self.provid, arg)) 1732 self.filename = self.provmod.__file__
1733
1734 - def _get_callable(self, classname, cname):
1735 """Return a function or method object appropriate to fulfill a request 1736 1737 classname -- The CIM class name associated with the request. 1738 cname -- The function or method name to look for. 1739 1740 """ 1741 1742 callable = None 1743 if classname in self.provregs: 1744 provClass = self.provregs[classname] 1745 if hasattr(provClass, cname): 1746 callable = getattr(provClass, cname) 1747 elif hasattr(self.provmod, cname): 1748 callable = getattr(self.provmod, cname) 1749 if callable is None: 1750 raise pywbem.CIMError( 1751 pywbem.CIM_ERR_FAILED, 1752 "No provider registered for %s or no callable for %s:%s on " \ 1753 "provider %s" % (classname, classname, cname, self.provid)) 1754 return callable
1755
1756 - def _reload_if_necessary(self, env):
1757 """Check timestamp of loaded python provider module, and if it has 1758 changed since load, then reload the provider module. 1759 """ 1760 try: 1761 mod = sys.modules[self.provider_module_name] 1762 except KeyError: 1763 mod = None 1764 if (mod is None or \ 1765 mod.provmod_timestamp != os.path.getmtime(self.provid)): 1766 logger = env.get_logger() 1767 logger.log_debug("Need to reload provider at %s" % self.provid) 1768 1769 #first unload the module 1770 if self.provmod and hasattr(self.provmod, "shutdown"): 1771 self.provmod.shutdown(env) 1772 #now reload and reinit module 1773 try: 1774 del sys.modules[self.provider_module_name] 1775 except KeyError: 1776 pass 1777 try: 1778 self._load_provider_source(logger) 1779 self._init_provider(env) 1780 except IOError, arg: 1781 raise pywbem.CIMError( 1782 pywbem.CIM_ERR_FAILED, 1783 "Error loading provider %s: %s" % (provid, arg))
1784 1785 1786 ############################################################################## 1787 # enumInstanceNames 1788 ##############################################################################
1789 - def MI_enumInstanceNames(self, 1790 env, 1791 objPath):
1792 # pylint: disable=invalid-name 1793 logger = env.get_logger() 1794 logger.log_debug('ProviderProxy MI_enumInstanceNames called...') 1795 self._reload_if_necessary(env) 1796 return self._get_callable(objPath.classname, 1797 'MI_enumInstanceNames')(env, objPath)
1798 1799 ############################################################################## 1800 # enumInstances 1801 ##############################################################################
1802 - def MI_enumInstances(self, 1803 env, 1804 objPath, 1805 propertyList):
1806 # pylint: disable=invalid-name 1807 logger = env.get_logger() 1808 logger.log_debug('CIMProvider2 MI_enumInstances called...') 1809 self._reload_if_necessary(env) 1810 return self._get_callable(objPath.classname, 'MI_enumInstances') \ 1811 (env, 1812 objPath, 1813 propertyList)
1814 1815 ############################################################################## 1816 # getInstance 1817 ##############################################################################
1818 - def MI_getInstance(self, 1819 env, 1820 instanceName, 1821 propertyList):
1822 # pylint: disable=invalid-name 1823 logger = env.get_logger() 1824 logger.log_debug('CIMProvider2 MI_getInstance called...') 1825 self._reload_if_necessary(env) 1826 rval = self._get_callable(instanceName.classname, 'MI_getInstance') \ 1827 (env, 1828 instanceName, 1829 propertyList) 1830 logger.log_debug('CIMProvider2 MI_getInstance returning') 1831 return rval
1832 1833 ############################################################################## 1834 # createInstance 1835 ##############################################################################
1836 - def MI_createInstance(self, 1837 env, 1838 instance):
1839 # pylint: disable=invalid-name 1840 logger = env.get_logger() 1841 logger.log_debug('CIMProvider2 MI_createInstance called...') 1842 self._reload_if_necessary(env) 1843 rval = self._get_callable(instance.classname, 'MI_createInstance') \ 1844 (env, instance) 1845 logger.log_debug('CIMProvider2 MI_createInstance returning') 1846 return rval
1847 1848 ############################################################################## 1849 # modifyInstance 1850 ##############################################################################
1851 - def MI_modifyInstance(self, 1852 env, 1853 modifiedInstance, 1854 propertyList):
1855 # pylint: disable=invalid-name 1856 logger = env.get_logger() 1857 logger.log_debug('CIMProvider2 MI_modifyInstance called...') 1858 self._reload_if_necessary(env) 1859 self._get_callable(modifiedInstance.classname, 'MI_modifyInstance') \ 1860 (env, modifiedInstance, propertyList) 1861 logger.log_debug('CIMProvider2 MI_modifyInstance returning')
1862 1863 ############################################################################## 1864 # deleteInstance 1865 ##############################################################################
1866 - def MI_deleteInstance(self, 1867 env, 1868 instanceName):
1869 # pylint: disable=invalid-name 1870 logger = env.get_logger() 1871 logger.log_debug('CIMProvider2 MI_deleteInstance called...') 1872 self._reload_if_necessary(env) 1873 self._get_callable(instanceName.classname, 'MI_deleteInstance') \ 1874 (env, instanceName) 1875 logger.log_debug('CIMProvider2 MI_deleteInstance returning')
1876 1877 1878 ############################################################################## 1879 # associators 1880 ##############################################################################
1881 - def MI_associators(self, 1882 env, 1883 objectName, 1884 assocClassName, 1885 resultClassName, 1886 role, 1887 resultRole, 1888 propertyList):
1889 # pylint: disable=invalid-name 1890 # NOTE: This should honor the parameters resultClassName, role, 1891 # resultRole, and propertyList 1892 logger = env.get_logger() 1893 logger.log_debug('CIMProvider2 MI_associators called. ' \ 1894 'assocClass: %s' % (assocClassName)) 1895 self._reload_if_necessary(env) 1896 1897 cname = assocClassName 1898 if not cname and hasattr(self.provmod, 'MI_associators'): 1899 for i in self.provmod.MI_associators(env, 1900 objectName, 1901 assocClassName, 1902 resultClassName, 1903 role, 1904 resultRole, 1905 propertyList): 1906 yield i 1907 return 1908 1909 lcnames = [] 1910 if cname: 1911 lcnames = [cname] 1912 else: 1913 lcnames = self.provregs.keys() 1914 1915 for lcname in lcnames: 1916 fn = self._get_callable(lcname, 'MI_associators') 1917 for i in fn(env, 1918 objectName, 1919 lcname, 1920 resultClassName, 1921 role, 1922 resultRole, 1923 propertyList): 1924 yield i 1925 logger.log_debug('CIMProvider2 MI_associators returning')
1926 1927 ############################################################################## 1928 # associatorNames 1929 ##############################################################################
1930 - def MI_associatorNames(self, 1931 env, 1932 objectName, 1933 assocClassName, 1934 resultClassName, 1935 role, 1936 resultRole):
1937 # pylint: disable=invalid-name 1938 logger = env.get_logger() 1939 logger.log_debug('CIMProvider2 MI_associatorNames called. ' \ 1940 'assocClass: %s' % (assocClassName)) 1941 self._reload_if_necessary(env) 1942 cname = assocClassName 1943 if not cname and hasattr(self.provmod, 'MI_associatorNames'): 1944 for i in self.provmod.MI_associatorNames(env, 1945 objectName, 1946 assocClassName, 1947 resultClassName, 1948 role, 1949 resultRole): 1950 yield i 1951 return 1952 1953 lcnames = [] 1954 if cname: 1955 lcnames = [cname] 1956 else: 1957 lcnames = self.provregs.keys() 1958 1959 for lcname in lcnames: 1960 fn = self._get_callable(lcname, 'MI_associatorNames') 1961 for i in fn(env, 1962 objectName, 1963 lcname, 1964 resultClassName, 1965 role, 1966 resultRole): 1967 yield i 1968 1969 logger.log_debug('CIMProvider2 MI_associatorNames returning')
1970 1971 ############################################################################## 1972 # references 1973 ##############################################################################
1974 - def MI_references(self, 1975 env, 1976 objectName, 1977 resultClassName, 1978 role, 1979 propertyList):
1980 # pylint: disable=invalid-name 1981 logger = env.get_logger() 1982 logger.log_debug('CIMProvider2 MI_references called. ' \ 1983 'resultClass: %s' % (resultClassName)) 1984 self._reload_if_necessary(env) 1985 cname = resultClassName 1986 if not cname and hasattr(self.provmod, 'MI_references'): 1987 for i in self.provmod.MI_references(env, objectName, 1988 resultClassName, role, 1989 propertyList): 1990 yield i 1991 return 1992 1993 lcnames = [] 1994 if cname: 1995 lcnames = [cname] 1996 else: 1997 lcnames = self.provregs.keys() 1998 1999 for lcname in lcnames: 2000 fn = self._get_callable(lcname, 'MI_references') 2001 for i in fn(env, 2002 objectName, 2003 lcname, 2004 role, 2005 propertyList): 2006 yield i 2007 2008 logger.log_debug('CIMProvider2 MI_references returning')
2009 2010 ############################################################################## 2011 # referenceNames 2012 ##############################################################################
2013 - def MI_referenceNames(self, 2014 env, 2015 objectName, 2016 resultClassName, 2017 role):
2018 # pylint: disable=invalid-name 2019 logger = env.get_logger() 2020 logger.log_debug('CIMProvider2 MI_referenceNames <1> called. ' \ 2021 'resultClass: %s' % (resultClassName)) 2022 self._reload_if_necessary(env) 2023 2024 cname = resultClassName 2025 if not cname and hasattr(self.provmod, 'MI_referenceNames'): 2026 for i in self.provmod.MI_referenceNames(env, objectName, 2027 resultClassName, role): 2028 yield i 2029 return 2030 2031 lcnames = [] 2032 if cname: 2033 lcnames = [cname] 2034 else: 2035 lcnames = self.provregs.keys() 2036 2037 for lcname in lcnames: 2038 fn = self._get_callable(lcname, 'MI_referenceNames') 2039 for i in fn(env, 2040 objectName, 2041 lcname, 2042 role): 2043 yield i 2044 2045 logger.log_debug('CIMProvider2 MI_referenceNames returning')
2046 2047 ############################################################################## 2048 # invokeMethod 2049 # inputParam is a Dictionary where the key is the parameter name 2050 # and the value is the parameter value 2051 # The return value for invokeMethod must be a tuple of size 2 where 2052 # element 0 is a tuple of size 2 where element 0 is the return data type name 2053 # and element 1 is the actual data value 2054 # element 1 is a dictionary where the key is the output parameter name 2055 # and the value is a tuple of size 2 where element 0 is the data type name 2056 # for the output parameter and element 1 is the actual value of the 2057 # output parameter. 2058 ##############################################################################
2059 - def MI_invokeMethod(self, env, objectName, methodName, inputParams):
2060 # pylint: disable=invalid-name 2061 logger = env.get_logger() 2062 logger.log_debug('CIMProvider2 MI_invokeMethod called. ' \ 2063 'method: %s:%s' % (objectName.classname, methodName)) 2064 self._reload_if_necessary(env) 2065 rval = self._get_callable(objectName.classname, 'MI_invokeMethod') \ 2066 (env, objectName, methodName, inputParams) 2067 logger.log_debug('CIMProvider2 MI_invokeMethod returning') 2068 return rval
2069 2070 ##############################################################################
2071 - def MI_authorizeFilter(self, 2072 env, 2073 filter, 2074 classname, 2075 classPath, 2076 owner):
2077 # pylint: disable=invalid-name 2078 logger = env.get_logger() 2079 logger.log_debug('CIMProvider2 MI_authorizeFilter called') 2080 self._reload_if_necessary(env) 2081 if hasattr(self.provmod, 'authorize_filter'): 2082 self.provmod.authorize_filter(env, filter, classname, 2083 classPath, owner) 2084 elif hasattr(self.provmod, 'MI_authorizeFilter'): 2085 self.provmod.MI_authorizeFilter(env, filter, classname, 2086 classPath, owner) 2087 else: 2088 # if not instrumented in provider, assume success 2089 logger.log_debug("Provider %s has no support for authorize " \ 2090 "filter" % self.provid) 2091 logger.log_debug('CIMProvider2 MI_authorizeFilter returning') 2092 return
2093 2094 2095 ##############################################################################
2096 - def MI_activateFilter(self, 2097 env, 2098 filter, 2099 namespace, 2100 classes, 2101 firstActivation):
2102 # pylint: disable=invalid-name 2103 logger = env.get_logger() 2104 logger.log_debug('CIMProvider2 MI_activateFilter called') 2105 self._reload_if_necessary(env) 2106 if hasattr(self.provmod, 'activate_filter'): 2107 self.provmod.activate_filter(env, filter, namespace, 2108 classes, firstActivation) 2109 elif hasattr(self.provmod, 'MI_activateFilter'): 2110 self.provmod.MI_activateFilter(env, filter, namespace, 2111 classes, firstActivation) 2112 else: 2113 # if not instrumented in provider, assume success 2114 logger.log_debug("Provider %s has no support for activate " \ 2115 "filter" % self.provid) 2116 logger.log_debug('CIMProvider2 MI_activateFilter returning') 2117 return
2118 2119 2120 ##############################################################################
2121 - def MI_deActivateFilter(self, 2122 env, 2123 filter, 2124 namespace, 2125 classes, 2126 lastActivation):
2127 # pylint: disable=invalid-name 2128 logger = env.get_logger() 2129 logger.log_debug('CIMProvider2 MI_deActivateFilter called') 2130 self._reload_if_necessary(env) 2131 if hasattr(self.provmod, 'deactivate_filter'): 2132 self.provmod.deactivate_filter(env, filter, namespace, classes, 2133 lastActivation) 2134 elif hasattr(self.provmod, 'MI_deActivateFilter'): 2135 self.provmod.MI_deActivateFilter(env, filter, namespace, classes, 2136 lastActivation) 2137 else: 2138 # if not instrumented in provider, assume success 2139 logger.log_debug("Provider %s has no support for deactivate " \ 2140 "filter" % self.provid) 2141 logger.log_debug('CIMProvider2 MI_deActivateFilter returning') 2142 return
2143 2144 2145 ##############################################################################
2146 - def MI_enableIndications(self, env):
2147 # pylint: disable=invalid-name 2148 logger = env.get_logger() 2149 logger.log_debug('CIMProvider2 MI_enableIndications called') 2150 self._reload_if_necessary(env) 2151 if hasattr(self.provmod, 'enable_indications'): 2152 self.provmod.enable_indications(env) 2153 elif hasattr(self.provmod, 'MI_enableIndications'): 2154 self.provmod.MI_enableIndications(env) 2155 else: 2156 # if not instrumented in provider, assume success 2157 logger.log_debug("Provider %s has no support for enable " \ 2158 "indications" % self.provid) 2159 logger.log_debug('CIMProvider2 MI_enableIndications returning') 2160 return
2161 2162 2163 ##############################################################################
2164 - def MI_disableIndications(self, 2165 env):
2166 # pylint: disable=invalid-name 2167 logger = env.get_logger() 2168 logger.log_debug('CIMProvider2 MI_disableIndications called') 2169 self._reload_if_necessary(env) 2170 if hasattr(self.provmod, 'disable_indications'): 2171 self.provmod.disable_indications(env) 2172 elif hasattr(self.provmod, 'MI_disableIndications'): 2173 self.provmod.MI_disableIndications(env) 2174 else: 2175 # if not instrumented in provider, assume success 2176 logger.log_debug("Provider %s has no support for disable " \ 2177 "indications" % self.provid) 2178 logger.log_debug('CIMProvider2 MI_disableIndications returning') 2179 return
2180 2181 2182 ##############################################################################
2183 - def MI_shutdown(self, env):
2184 # pylint: disable=invalid-name 2185 # shutdown may be called multiple times -- once per MI type 2186 # (instance/method/association/...) We'll only do stuff on 2187 # the first time. 2188 if self.provmod is None: 2189 return 2190 modname = self.provmod.__name__ 2191 if hasattr(self.provmod, "shutdown"): 2192 self.provmod.shutdown(env) 2193 self.provmod = None 2194 del sys.modules[modname]
2195 #TODO concurrency problems here?? 2196 2197 2198 ##############################################################################
2199 - def MI_canunload(self, env):
2200 # pylint: disable=invalid-name 2201 if hasattr(self.provmod, "can_unload"): 2202 return self.provmod.can_unload(env) 2203 else: 2204 return True
2205 2206 ##############################################################################
2207 - def MI_consumeIndication(self, env, destinationPath, indicationInstance):
2208 # pylint: disable=invalid-name 2209 2210 logger = env.get_logger() 2211 logger.log_debug('ProviderProxy MI_consumeIndication called') 2212 self._reload_if_necessary(env) 2213 if hasattr(self.provmod, 'consume_indication'): 2214 self.provmod.consume_indication(env, destinationPath, 2215 indicationInstance) 2216 elif hasattr(self.provmod, 'MI_consumeIndication'): 2217 self.provmod.MI_consumeIndication(env, destinationPath, 2218 indicationInstance) 2219 else: 2220 raise pywbem.CIMError( 2221 pywbem.CIM_ERR_FAILED, 2222 "Provider %s has no support for consume indication" % \ 2223 self.provid) 2224 logger.log_debug('ProviderProxy MI_consumeIndication returning')
2225 2226 2227 ##############################################################################
2228 - def MI_handleIndication(self, 2229 env, 2230 ns, 2231 handlerInstance, 2232 indicationInstance):
2233 # pylint: disable=invalid-name 2234 2235 logger = env.get_logger() 2236 logger.log_debug('ProviderProxy MI_handleIndication called') 2237 self._reload_if_necessary(env) 2238 if hasattr(self.provmod, 'handle_indication'): 2239 self.provmod.handle_indication(env, ns, handlerInstance, 2240 indicationInstance) 2241 elif hasattr(self.provmod, 'MI_handleIndication'): 2242 self.provmod.MI_handleIndication(env, ns, handlerInstance, 2243 indicationInstance) 2244 else: 2245 raise pywbem.CIMError( 2246 pywbem.CIM_ERR_FAILED, 2247 "Provider %s has no support for handle indication" % \ 2248 self.provid) 2249 logger.log_debug('ProviderProxy MI_handleIndication returning')
2250