def check_ovs_packages(result_handler): """ Checks the availability of packages for Open vStorage :param result_handler: logging object :type result_handler: ovs.extensions.healthcheck.result.HCResults :return: None :rtype: NoneType """ result_handler.info('Checking OVS packages: ', add_to_result=False) client = SSHClient(OpenvStorageHealthCheck.LOCAL_SR) package_manager = PackageFactory.get_manager() # Get all base packages base_packages = set() for names in package_manager.package_info['names'].itervalues(): base_packages = base_packages.union(names) base_packages = list(base_packages) extra_packages = Helper.packages installed = package_manager.get_installed_versions(client=client, package_names=base_packages) installed.update(package_manager.get_installed_versions(client=client, package_names=Helper.packages)) for package in base_packages + extra_packages: version = installed.get(package) if version: version = str(version) result_handler.success('Package {0} is installed with version {1}'.format(package, version), code=ErrorCodes.package_required) else: if package in package_manager.package_info['mutually_exclusive']: # Mutually exclusive package, so ignore continue if package in base_packages: result_handler.warning('Package {0} is not installed.'.format(package), code=ErrorCodes.package_required) elif package in extra_packages: result_handler.skip('Package {0} is not installed.'.format(package))
def __init__(self): """ Initializes the client """ # Safe calls self._node_id = System.get_my_machine_id().replace(r"'", r"'\''") # Alba is currently always installed but the Alba version/package info is located in the SDM section self._package_manager = PackageFactory.get_manager() self._service_manager = ServiceFactory.get_manager() self._service_type = ServiceFactory.get_service_type() if self._service_type != 'systemd': raise NotImplementedError('Only Systemd is supported') # Potential failing calls self._cluster_id = self.get_config_key( self.LOCATION_CLUSTER_ID, fallback=[CONFIG_STORE_LOCATION, 'cluster_id']) self.interval = self.get_config_key( self.LOCATION_INTERVAL, fallback=[self.FALLBACK_CONFIG, self.KEY_INTERVAL], default=self.DEFAULT_INTERVAL) self._openvpn_service_name = 'openvpn@ovs_{0}-{1}'.format( self._cluster_id, self._node_id) # Calls to look out for. These could still be None when using them self._storagerouter = None self._client = None self._set_storagerouter() self._set_client() # Safe call, start caching self.caching = SupportAgentCache(self)
def check_ovs_packages(result_handler): """ Checks the availability of packages for Open vStorage :param result_handler: logging object :type result_handler: ovs.extensions.healthcheck.result.HCResults :return: None :rtype: NoneType """ result_handler.info('Checking OVS packages: ', add_to_result=False) client = SSHClient(OpenvStorageHealthCheck.LOCAL_SR) # PackageManager.SDM_PACKAGE_NAMES for sdm package_manager = PackageFactory.get_manager() all_packages = list(package_manager.package_names) extra_packages = list(Helper.packages) ee_relation = { 'alba': 'alba-ee', 'arakoon': 'arakoon', 'volumedriver-no-dedup-server': 'volumedriver-ee-server' } # Key = non-ee, value = ee if OpenvStorageHealthCheck.LOCAL_SR.features['alba'][ 'edition'] == 'community': required_packages = [ package_name for package_name in all_packages if package_name in ee_relation.keys() ] else: required_packages = [ package_name for package_name in all_packages if package_name in ee_relation.values() ] installed = package_manager.get_installed_versions( client=client, package_names=list(required_packages + extra_packages)) while len(required_packages) > 0: package = required_packages.pop() version = installed.get(package) if version: version = str(version) result_handler.success( 'Package {0} is installed with version {1}'.format( package, version.replace('\n', ''))) else: result_handler.warning( 'Package {0} is not installed.'.format(package)) while len(extra_packages) > 0: package = extra_packages.pop() version = installed.get(package) if version: version = str(version) result_handler.success( 'Package {0} is installed with version {1}'.format( package, version.replace('\n', ''))) else: result_handler.skip( 'Package {0} is not installed.'.format(package))
def get_healthcheck_version(): """ Gets the installed healthcheck version :return: version number of the installed healthcheck :rtype: str """ client = SSHClient(System.get_my_storagerouter()) package_name = 'openvstorage-health-check' package_manager = PackageFactory.get_manager() packages = package_manager.get_installed_versions(client=client, package_names=[package_name]) return packages.get(package_name, 'unknown')
def get_healthcheck_version(): """ Gets the installed healthcheck version :return: version number of the installed healthcheck :rtype: str """ client = SSHClient(System.get_my_storagerouter()) package_name = 'openvstorage-health-check' package_manager = PackageFactory.get_manager() packages = package_manager.get_installed_versions( client=client, package_names=[package_name]) return packages.get(package_name, 'unknown')
def get_heartbeat_data(self): """ Returns heartbeat data """ data = {'cid': Configuration.get('/ovs/framework/cluster_id'), 'nid': System.get_my_machine_id(), 'metadata': {}, 'errors': []} try: # Versions manager = PackageFactory.get_manager() data['metadata']['versions'] = manager.get_installed_versions() # Fallback to check_output except Exception, ex: data['errors'].append(str(ex))
def get_release_name(cls, client=None): """ Retrieve the release name :param client: Client on which to retrieve the release name :type client: ovs_extensions.generic.sshclient.SSHClient :return: The name of the release :rtype: str """ try: if client is not None: return client.run(['cat', cls.RELEASE_NAME_FILE]).strip() with open(cls.RELEASE_NAME_FILE, 'r') as the_file: return the_file.read().strip() except: manager = PackageFactory.get_manager() return manager.get_release_name()
def get_version_info(storagerouter_guid): """ Returns version information regarding a given StorageRouter :param storagerouter_guid: StorageRouter guid to get version information for :type storagerouter_guid: str :return: Version information :rtype: dict """ package_manager = PackageFactory.get_manager() client = SSHClient(StorageRouter(storagerouter_guid)) return { 'storagerouter_guid': storagerouter_guid, 'versions': dict((pkg_name, str(version)) for pkg_name, version in package_manager.get_installed_versions(client).iteritems()) }