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())
}