def checkForUpdates(self, ver=None, maxObjUpdatesWaitOp=None): ''' Used to check for any updated changes on ALL created filters. An optional version can be specified to check for a difference between the specified version and the current configuration. This method will return null if there are no differences between the the specified versions. Submitting a version of "None" will cause a full dump of the filters at the creation of the first checkForUpdates() call ''' try: lastVersion = ver waitOptions = Connection.vim25client.new('WaitOptions', maxWaitSeconds=0, maxObjectUpdates=maxObjUpdatesWaitOp) data = self.targetCollector.waitForUpdatesEx(version=ver, options=waitOptions) if data: lastVersion = getattr(data, 'version') # Version may have _ hence trim it if lastVersion.find('_') >= 0: lastVersion = lastVersion[0:lastVersion.find('_')] # When result set in chunks then we need to do this hack # If there is subversion, it always start with oldversion_subversion and last truncated # result data contains actual increased version so increasing version by 1 to have right # count for all object lastVersion = int(str(lastVersion)) + 1 yield lastVersion, data while hasattr(data, 'truncated'): version = data.version data = self.targetCollector.waitForUpdatesEx(version=version, options=waitOptions) # Version may have _, hence trim it, also increase by 1 as described above if version.find('_') >= 0: mainVer = version[0:version.find('_')] mainVer = int(str(mainVer)) + 1 else: mainVer = version yield mainVer, data except Exception as e: logger.error("[Inventory] checkForUpdates Failure") logger.exception(e)
def __init__(self): try: self.targetEventManager = self.eventManager self.eventSpec = None except Exception as e: logger.error("Error getting service instance EventManager") logger.exception(e)
def __init__(self, mor=None): try: CurrentViewManager.updateViewMgr() CurrentViewManager.updateViewList() if mor: if type(mor) != str: raise else: tempMOR = ManagedObjectReference(value=mor, _type="PropertyCollector") # tempMOR = Connection.vim25client.new('_this', value=mor, _type="PropertyCollector") self.targetCollector = Connection.vim25client.createExactManagedObject( mor=tempMOR) else: self.targetCollector = CurrentViewManager.propColl.createPropertyCollector( ) if not CurrentViewManager.cViewRef: CurrentViewManager.buildView(targetConfig.targetEntities) self.oSpec = None self.tSpec = CurrentViewManager.tSpec self.filterList = self.targetCollector.getFilter('filter') self.fSpecList = [] self.pSpecList = [] except Exception as e: logger.error( "Error, when specifying an mor, please pass just the mor value, not an object: %s", str(e)) logger.exception(e)
def __init__(self): try: self.targetTaskManager = self.taskManager self.taskSpec = None self.taskCollector = None except Exception as e: logger.error("Error getting service instance taskManager") logger.exception(e)
def CreateHierarchyCollector(managedObjectReference=None, targetConfigObject=None, updateType="update", version=None, oneTime=False, addlTargetConfig=None): ''' Primary method to create collecting inventory. managedObjectReference is to reference a propertyCollector that has already been created. You can pass the MOR value to this method, and it will create a reference to that existing property collector. You do not need to specify targetEntityType when using a MOR reference. For all new property collectors (like the first run), you should use targetEntityType. This will reference the entity out of the targetConfig class for what properties to collect. updateType is to be used in conjunction with an existing MOR, "update" will allow the user to submit a version for checking differences, while "recycle" will destroy the property collector and then create a new property collector. "addlTargetConfig" will include any additional properties that need to be collected, as specified in the conf file. It also create filterspec and filter as well before return property collector object Returns: version, property collector object, targetConfigObject (the returned configuration target for chaining to a formatter), mor (The returned MOR to the created / updated property collector, version ''' try: logger.debug("[Inventory] CollectInventory called with these options: managedObjectReference:{0}, targetConfigObject:{1}, updateType:{2}, version:{3}, oneTime:{4}, addlTargetConfig: {5}".format(managedObjectReference, targetConfigObject, updateType, version, oneTime, addlTargetConfig)) configObject = getattr(targetConfig, targetConfigObject) if addlTargetConfig: configObject['HostSystem'].extend(addlTargetConfig) logger.debug("[Inventory] CollectInventory: Addl properties added for 'HostSystem', configObject now contains:"+str(configObject)) if managedObjectReference: logger.debug("[Inventory] Received an MOR. Rebuilding old collector.") hierarchyCollector = PropCollector(mor=managedObjectReference) if updateType=="recycle": try: logger.debug("[Inventory] Old collector being recycled") hierarchyCollector.targetCollector.destroyPropertyCollector() except Exception as wf: if "Server raised fault:" in str(wf) and "has already been deleted or has not been completely created" in str(wf): logger.debug("[Inventory] Destroy Collector called with a non-existing collector, assuming deleted and creating new.") else: raise wf mor=None version=None hierarchyCollector = PropCollector() mor = str(hierarchyCollector.targetCollector.getMOR().value) logger.debug("[Inventory] Recycled collector MOR:{0}".format(mor)) hierarchyCollector.buildFilterSpecList(configObject) hierarchyCollector.buildFilter(hierarchyCollector.fSpecList, partUpdates=True) if oneTime == True: logger.debug("[Inventory] OneTime collection is set to true with existing MOR.") hierarchyCollector.buildFilterSpecList(configObject) mor = str(hierarchyCollector.targetCollector.getMOR().value) return version, hierarchyCollector, targetConfigObject, mor else: logger.debug("[Inventory] Creating new collector.") hierarchyCollector = PropCollector() mor = str(hierarchyCollector.targetCollector.getMOR().value) logger.debug("[Inventory] New collector MOR:{0}".format(mor)) hierarchyCollector.buildFilterSpecList(configObject) hierarchyCollector.buildFilter(hierarchyCollector.fSpecList, partUpdates=True) return version, hierarchyCollector, targetConfigObject, mor except Exception as e: logger.error("error in creating hierarchy collector") logger.exception(e) raise e
def DestroyHierarchyCollector(hierarchyCollector): ''' Destroy Property collector @param hierarchyCollector: PropertyCollector object ''' if hierarchyCollector is None or hierarchyCollector.targetCollector is None: logger.error("Hierarchy collector can not be destroy as it is passed as null value.") return hierarchyCollector.targetCollector.destroyPropertyCollector()
def dumpCollector(self): '''Preforms a full dump of the currently set fSpecList. ''' ro = Connection.vim25client.new('RetrieveOptions') try: props = self.targetCollector.retrievePropertiesEx(specSet=self.fSpecList, options=ro) return props except Exception as e: logger.error("dump collector took a dump: %s", str(e)) logger.exception(e)
def destroyFilter(self, filterListIndex): ''' Used to remove a filter that's been created. Specify the index list of the target filter to remove. Filters are accessed on PCollector.filterList ''' try: self.filterList[filterListIndex].destroyPropertyFilter() self.updateFilterList() except Exception as e: logger.error("Missing filter, or filter list out of range: %s", str(e)) logger.exception(e)
def destroyView(cls, viewListIndex): ''' Used to remove a view that's been created. Specify the index list of the target view to remove. Views are accessed on PCollector.cViewRefList ''' try: cls.cViewRefList[viewListIndex].destroyView() cls.updateViewList() except Exception as e: logger.error("Missing View, or view list index out of range: %s", str(e)) logger.exception(e)
def buildTaskCollector(self): try: if self.taskCollector: logger.error("Collector already exists") else: self.taskCollector = self.targetTaskManager.createCollectorForTasks( self.taskSpec) except Exception as e: logger.exception( "taskSpec does not exist, or there was an error during collector creation." ) logger.exception(e)
def CollectEvents(startTime=None, endTime=None): ''' Collects Events for the specified start and end times. returns a list of events in key order. ''' try: Collector = EventCollector() Collector.buildEventQuerySpec() Collector.buildTimeSpec(startTime, endTime) events = Collector.collectEvents(Collector.eventSpec) return events except Exception as e: logger.error("error in collect events") logger.exception(e) logger.exception(traceback.print_exc())
def CollectTasks(startTime=None, endTime=None): ''' Collects Tasks for the specified start and end times. returns a list of events in key order. ''' try: taskListCollector = TaskCollector() taskListCollector.buildTaskQuerySpec() taskListCollector.buildTimeSpec(startTime, endTime) taskList = taskListCollector.collectTasks() return taskList except Exception as e: logger.error("error in collect tasks") logger.exception(e) logger.exception(traceback.print_exc())
def collectPropertiesEx(self, specList): '''Preforms a full collection of the specList passed. Will not retain any information or update status. Any filter created during this process is destroyed after collection. this method will be most often used with buildFilterList. ''' ro = Connection.vim25client.new('RetrieveOptions') try: props = self.targetCollector.retrievePropertiesEx(specSet=specList, options=ro) yield props.objects while hasattr(props, 'token'): lastToken = str(props.token) props = self.targetCollector.continueRetrievePropertiesEx(token=lastToken) yield props.objects except Exception as e: logger.error("collect properties ex fail: %s", str(e)) logger.exception(e)
def is_service_instance_valid(cls): """ Check if the current service instance bound to the static class is valid """ try: logger.debug( "[Connection] Checking for current time on the service instance." ) cls.svcInstance.currentTime() logger.debug("[Connection] Time returned properly.") return True except Exception as e: logger.error( "[Connection] I can't check the time for domain %s. Exception below. Returning False on valid session. Killing all the rebel scum!" % (cls.domain)) logger.exception(e) logger.info("[Connection] Destroying bad session for domain %s" % (cls.domain)) cls._destroy_vim_service() return False
def Jsonify(target): try: return json.dumps(target) except Exception as e: logger.error("Error trying to jsonify object") logger.exception(e)
def _cache_and_populate_connection_properties(cls, new_domain): """ Check for a cached set of connection properties and cache the current ones. If cache is found use it to re-populate the convenience properties. RETURNS True if populated connection from cache """ #First cache what we have new_cache = {} new_cache["svcInstance"] = cls.svcInstance new_cache["vim25client"] = cls.vim25client new_cache["cookie"] = cls.cookie new_cache["session_key"] = cls.session_key new_cache["domain"] = cls.domain new_cache["propColl"] = cls.propColl new_cache["rootFolder"] = cls.rootFolder new_cache["viewMgrRef"] = cls.viewMgrRef new_cache["eventManager"] = cls.eventManager new_cache["taskManager"] = cls.taskManager new_cache["perfManager"] = cls.perfManager new_cache["tSpec"] = cls.tSpec new_cache["vc_uuid"] = cls.vc_uuid new_cache["vc_name"] = cls.vc_name new_cache["vc_version"] = cls.vc_version new_cache["target_type"] = cls.target_type if cls._domain_key is not None: cls.cached_connections[cls._domain_key] = new_cache else: logger.warning( "[Connection] could not cache connection due to lack of set _domain_key" ) #Check if we have a cache, if so populate from it cached_connection = cls.cached_connections.get(new_domain, None) if cached_connection is not None: logger.info( "[Connection] resetting connection from cache for domain=%s", new_domain) try: cls.svcInstance = cached_connection["svcInstance"] cls.vim25client = cached_connection["vim25client"] cls.cookie = cached_connection["cookie"] cls.session_key = cached_connection["session_key"] cls.domain = cached_connection["domain"] cls.propColl = cached_connection["propColl"] cls.rootFolder = cached_connection["rootFolder"] cls.viewMgrRef = cached_connection["viewMgrRef"] cls.eventManager = cached_connection["eventManager"] cls.taskManager = cached_connection["taskManager"] cls.perfManager = cached_connection["perfManager"] cls.tSpec = cached_connection["tSpec"] cls.vc_uuid = cached_connection["vc_uuid"] cls.vc_name = cached_connection["vc_name"] cls.vc_version = cached_connection["vc_version"] cls.target_type = cached_connection["target_type"] cls._domain_key = new_domain cls.svcInstance.getServerConnection().setSessionCookie( cls.cookie) cls.vim25client.setServerConnection( cls.svcInstance.getServerConnection()) return cls.is_service_instance_valid() except KeyError as e: logger.error( "[Connection] cache for domain=%s was missing a required property: %s", new_domain, e) cls._destroy_vim_service() return False else: logger.info( "[Connection] could not reset connection from cache for domain=%s because cache does not exist yet", new_domain) cls._destroy_vim_service() return False