def remove(license_guid): """ Removes a license """ clients = {} storagerouters = StorageRouterList.get_storagerouters() try: for storagerouter in storagerouters: clients[storagerouter] = SSHClient(storagerouter.ip) except UnableToConnectException: raise RuntimeError('Not all StorageRouters are reachable') lic = License(license_guid) if lic.can_remove is True: remove_functions = Toolbox.fetch_hooks( 'license', '{0}.remove'.format(lic.component)) result = remove_functions[0](component=lic.component, data=lic.data, valid_until=lic.valid_until, signature=lic.signature) if result is True: lic.delete() license_contents = [] for lic in LicenseList.get_licenses(): license_contents.append(lic.hash) for storagerouter in storagerouters: client = clients[storagerouter] client.file_write( '/opt/OpenvStorage/config/licenses', '{0}\n'.format('\n'.join(license_contents))) return result return None
def _configure_arakoon_to_volumedriver(offline_node_ips=None): print 'Update existing vPools' logger.info('Update existing vPools') if offline_node_ips is None: offline_node_ips = [] for storagerouter in StorageRouterList.get_storagerouters(): config = ArakoonClusterConfig('voldrv') config.load_config() arakoon_nodes = [] for node in config.nodes: arakoon_nodes.append({'host': node.ip, 'port': node.client_port, 'node_id': node.name}) with Remote(storagerouter.ip, [os, RawConfigParser, EtcdConfiguration, StorageDriverConfiguration], 'ovs') as remote: configuration_dir = '{0}/storagedriver/storagedriver'.format(EtcdConfiguration.get('/ovs/framework/paths|cfgdir')) if not remote.os.path.exists(configuration_dir): remote.os.makedirs(configuration_dir) for json_file in remote.os.listdir(configuration_dir): vpool_name = json_file.replace('.json', '') if json_file.endswith('.json'): if remote.os.path.exists('{0}/{1}.cfg'.format(configuration_dir, vpool_name)): continue # There's also a .cfg file, so this is an alba_proxy configuration file storagedriver_config = remote.StorageDriverConfiguration('storagedriver', vpool_name) storagedriver_config.load() storagedriver_config.configure_volume_registry(vregistry_arakoon_cluster_id='voldrv', vregistry_arakoon_cluster_nodes=arakoon_nodes) storagedriver_config.configure_distributed_lock_store(dls_type='Arakoon', dls_arakoon_cluster_id='voldrv', dls_arakoon_cluster_nodes=arakoon_nodes) storagedriver_config.save(reload_config=True)
def remove(license_guid): """ Removes a license """ clients = {} storagerouters = StorageRouterList.get_storagerouters() try: for storagerouter in storagerouters: clients[storagerouter] = SSHClient(storagerouter.ip) except UnableToConnectException: raise RuntimeError('Not all StorageRouters are reachable') lic = License(license_guid) if lic.can_remove is True: remove_functions = Toolbox.fetch_hooks('license', '{0}.remove'.format(lic.component)) result = remove_functions[0](component=lic.component, data=lic.data, valid_until=lic.valid_until, signature=lic.signature) if result is True: lic.delete() license_contents = [] for lic in LicenseList.get_licenses(): license_contents.append(lic.hash) for storagerouter in storagerouters: client = clients[storagerouter] client.file_write('/opt/OpenvStorage/config/licenses', '{0}\n'.format('\n'.join(license_contents))) return result return None
def getVPoolByIPandPort(ip, port): for storagerouter in StorageRouterList.get_storagerouters(): for storagedriver in storagerouter.storagedrivers: if storagedriver.ports[ "edge"] == port and storagedriver.storage_ip == ip: return storagedriver.vpool raise RuntimeError("Could not find vpool for {}:{}".format(ip, port))
def print_current_mds_layout(): """ Prints the current MDS layout """ output = ['', 'Open vStorage - MDS debug information', '=====================================', 'timestamp: {0}'.format(time.time()), ''] for storagerouter in StorageRouterList.get_storagerouters(): output.append('+ {0} ({1})'.format(storagerouter.name, storagerouter.ip)) vpools = set(sd.vpool for sd in storagerouter.storagedrivers) for vpool in vpools: output.append(' + {0}'.format(vpool.name)) for mds_service in vpool.mds_services: if mds_service.service.storagerouter_guid == storagerouter.guid: masters, slaves = 0, 0 for junction in mds_service.vdisks: if junction.is_master: masters += 1 else: slaves += 1 capacity = mds_service.capacity if capacity == -1: capacity = 'infinite' load, _ = MDSServiceController.get_mds_load(mds_service) if load == float('inf'): load = 'infinite' else: load = '{0}%'.format(round(load, 2)) output.append(' + {0} - port {1} - {2} master(s), {3} slave(s) - capacity: {4}, load: {5}'.format( mds_service.number, mds_service.service.ports[0], masters, slaves, capacity, load )) print '\n'.join(output)
def list(self): """ Overview of all StorageRouters :return: List of StorageRouters :rtype: list[ovs.dal.hybrids.storagerouter.StorageRouter] """ return StorageRouterList.get_storagerouters()
def _run_and_validate_dtl_checkup(self, vdisk, validations): """ Execute the DTL checkup for a vDisk and validate the settings afterwards """ single_node = len(StorageRouterList.get_storagerouters()) == 1 VDiskController.dtl_checkup(vdisk_guid=vdisk.guid) config = vdisk.storagedriver_client.get_dtl_config(vdisk.volume_id) config_mode = vdisk.storagedriver_client.get_dtl_config_mode(vdisk.volume_id) msg = '{0} node - {{0}} - Actual: {{1}} - Expected: {{2}}'.format('Single' if single_node is True else 'Multi') validations.append({'key': 'config_mode', 'value': DTLConfigMode.MANUAL}) for validation in validations: key = validation['key'] value = validation['value'] if key == 'config': actual_value = config elif key == 'host': actual_value = config.host elif key == 'port': actual_value = config.port elif key == 'mode': actual_value = config.mode else: actual_value = config_mode if isinstance(value, list): self.assertTrue(expr=actual_value in value, msg=msg.format(key.capitalize(), actual_value, ', '.join(value))) else: self.assertEqual(first=actual_value, second=value, msg=msg.format(key.capitalize(), actual_value, value)) return config
def pulse(): """ Update the heartbeats for the Current Routers :return: None """ logger = Logger('extensions-generic') machine_id = System.get_my_machine_id() current_time = int(time.time()) routers = StorageRouterList.get_storagerouters() for node in routers: if node.machine_id == machine_id: with volatile_mutex('storagerouter_heartbeat_{0}'.format( node.guid)): node_save = StorageRouter(node.guid) node_save.heartbeats['process'] = current_time node_save.save() StorageRouterController.ping.s( node.guid, current_time).apply_async( routing_key='sr.{0}'.format(machine_id)) else: try: # check timeout of other nodes and clear arp cache if node.heartbeats and 'process' in node.heartbeats: if current_time - node.heartbeats[ 'process'] >= HeartBeat.ARP_TIMEOUT: check_output("/usr/sbin/arp -d '{0}'".format( node.name.replace(r"'", r"'\''")), shell=True) except CalledProcessError: logger.exception('Error clearing ARP cache')
def pulse(): """ Update the heartbeats for the Current Routers :return: None """ logger = LogHandler.get('extensions', name='heartbeat') machine_id = System.get_my_machine_id() current_time = int(time.time()) routers = StorageRouterList.get_storagerouters() for node in routers: if node.machine_id == machine_id: with volatile_mutex('storagerouter_heartbeat_{0}'.format(node.guid)): node_save = StorageRouter(node.guid) node_save.heartbeats['process'] = current_time node_save.save() StorageRouterController.ping.s(node.guid, current_time).apply_async(routing_key='sr.{0}'.format(machine_id)) else: try: # check timeout of other nodes and clear arp cache if node.heartbeats and 'process' in node.heartbeats: if current_time - node.heartbeats['process'] >= HeartBeat.ARP_TIMEOUT: check_output("/usr/sbin/arp -d '{0}'".format(node.name.replace(r"'", r"'\''")), shell=True) except CalledProcessError: logger.exception('Error clearing ARP cache')
def _configure_arakoon_to_volumedriver(): print 'Update existing vPools' logger.info('Update existing vPools') for storagerouter in StorageRouterList.get_storagerouters(): with Remote(storagerouter.ip, [os, RawConfigParser, Configuration, StorageDriverConfiguration, ArakoonManagementEx], 'ovs') as remote: arakoon_cluster_config = remote.ArakoonManagementEx().getCluster('voldrv').getClientConfig() arakoon_nodes = [] for node_id, node_config in arakoon_cluster_config.iteritems(): arakoon_nodes.append({'host': node_config[0][0], 'port': node_config[1], 'node_id': node_id}) configuration_dir = '{0}/storagedriver/storagedriver'.format( remote.Configuration.get('ovs.core.cfgdir')) if not remote.os.path.exists(configuration_dir): remote.os.makedirs(configuration_dir) for json_file in remote.os.listdir(configuration_dir): vpool_name = json_file.replace('.json', '') if json_file.endswith('.json'): if remote.os.path.exists('{0}/{1}.cfg'.format(configuration_dir, vpool_name)): continue # There's also a .cfg file, so this is an alba_proxy configuration file storagedriver_config = remote.StorageDriverConfiguration('storagedriver', vpool_name) storagedriver_config.load() storagedriver_config.configure_volume_registry(vregistry_arakoon_cluster_id='voldrv', vregistry_arakoon_cluster_nodes=arakoon_nodes) storagedriver_config.configure_distributed_lock_store(dls_type='Arakoon', dls_arakoon_cluster_id='voldrv', dls_arakoon_cluster_nodes=arakoon_nodes) storagedriver_config.save()
def _dtl_status(self): """ Retrieve the DTL status for a vDisk """ sd_status = self.info.get('failover_mode', 'UNKNOWN').lower() if sd_status == '': sd_status = 'unknown' if sd_status != 'ok_standalone': return sd_status # Verify whether 'ok_standalone' is the correct status for this vDisk vpool_dtl = self.vpool.configuration['dtl_enabled'] if self.has_manual_dtl is True or vpool_dtl is False: return sd_status domains = [] possible_dtl_targets = set() for sr in StorageRouterList.get_storagerouters(): if sr.guid == self.storagerouter_guid: domains = [junction.domain for junction in sr.domains] elif len(sr.storagedrivers) > 0: possible_dtl_targets.add(sr) if len(domains) > 0: possible_dtl_targets = set() for domain in domains: possible_dtl_targets.update( StorageRouterList.get_primary_storagerouters_for_domain( domain)) if len(possible_dtl_targets) == 0: return sd_status return 'checkup_required'
def _configure_arakoon_to_volumedriver(): print "Update existing vPools" logger.info("Update existing vPools") for storagerouter in StorageRouterList.get_storagerouters(): config = ArakoonClusterConfig("voldrv") config.load_config() arakoon_nodes = [] for node in config.nodes: arakoon_nodes.append({"host": node.ip, "port": node.client_port, "node_id": node.name}) with Remote( storagerouter.ip, [os, RawConfigParser, EtcdConfiguration, StorageDriverConfiguration], "ovs" ) as remote: configuration_dir = "{0}/storagedriver/storagedriver".format( EtcdConfiguration.get("/ovs/framework/paths|cfgdir") ) if not remote.os.path.exists(configuration_dir): remote.os.makedirs(configuration_dir) for json_file in remote.os.listdir(configuration_dir): vpool_name = json_file.replace(".json", "") if json_file.endswith(".json"): if remote.os.path.exists("{0}/{1}.cfg".format(configuration_dir, vpool_name)): continue # There's also a .cfg file, so this is an alba_proxy configuration file storagedriver_config = remote.StorageDriverConfiguration("storagedriver", vpool_name) storagedriver_config.load() storagedriver_config.configure_volume_registry( vregistry_arakoon_cluster_id="voldrv", vregistry_arakoon_cluster_nodes=arakoon_nodes ) storagedriver_config.configure_distributed_lock_store( dls_type="Arakoon", dls_arakoon_cluster_id="voldrv", dls_arakoon_cluster_nodes=arakoon_nodes ) storagedriver_config.save(reload_config=True)
def on_demote(cluster_ip, master_ip): """ Handles the demote for the StorageDrivers :param cluster_ip: IP of the node to demote :param master_ip: IP of the master node """ client = SSHClient(cluster_ip, username='******') servicetype = ServiceTypeList.get_by_name('Arakoon') current_service = None remaining_ips = [] for service in servicetype.services: if service.name == 'arakoon-voldrv': if service.storagerouter.ip == cluster_ip: current_service = service else: remaining_ips.append(service.storagerouter.ip) if current_service is not None: print '* Shrink StorageDriver cluster' ArakoonInstaller.shrink_cluster(master_ip, cluster_ip, 'voldrv') if ServiceManager.has_service(current_service.name, client=client) is True: ServiceManager.stop_service(current_service.name, client=client) ServiceManager.remove_service(current_service.name, client=client) ArakoonInstaller.restart_cluster_remove('voldrv', remaining_ips) current_service.delete() for storagerouter in StorageRouterList.get_storagerouters(): ArakoonInstaller.deploy_to_slave(master_ip, storagerouter.ip, 'voldrv') StorageDriverController._configure_arakoon_to_volumedriver()
def _dtl_status(self): """ Retrieve the DTL status for a vDisk """ sd_status = self.info.get('failover_mode', 'UNKNOWN').lower() if sd_status == '': sd_status = 'unknown' if sd_status != 'ok_standalone': return sd_status # Verify whether 'ok_standalone' is the correct status for this vDisk vpool_dtl = self.vpool.configuration['dtl_enabled'] if self.has_manual_dtl is True or vpool_dtl is False: return sd_status domains = [] possible_dtl_targets = set() for sr in StorageRouterList.get_storagerouters(): if sr.guid == self.storagerouter_guid: domains = [junction.domain for junction in sr.domains] elif len(sr.storagedrivers) > 0: possible_dtl_targets.add(sr) if len(domains) > 0: possible_dtl_targets = set() for domain in domains: possible_dtl_targets.update(StorageRouterList.get_primary_storagerouters_for_domain(domain)) if len(possible_dtl_targets) == 0: return sd_status return 'checkup_required'
def pulse(): """ Update the heartbeats for all Storage Routers :return: None """ logger = LogHandler.get('extensions', name='heartbeat') current_time = int(time.time()) machine_id = System.get_my_machine_id() amqp = '{0}://{1}:{2}@{3}//'.format(EtcdConfiguration.get('/ovs/framework/messagequeue|protocol'), EtcdConfiguration.get('/ovs/framework/messagequeue|user'), EtcdConfiguration.get('/ovs/framework/messagequeue|password'), EtcdConfiguration.get('/ovs/framework/hosts/{0}/ip'.format(machine_id))) celery_path = OSManager.get_path('celery') worker_states = check_output("{0} inspect ping -b {1} --timeout=5 2> /dev/null | grep OK | perl -pe 's/\x1b\[[0-9;]*m//g' || true".format(celery_path, amqp), shell=True) routers = StorageRouterList.get_storagerouters() for node in routers: if node.heartbeats is None: node.heartbeats = {} if 'celery@{0}: OK'.format(node.name) in worker_states: node.heartbeats['celery'] = current_time if node.machine_id == machine_id: node.heartbeats['process'] = current_time else: try: # check timeout of other nodes and clear arp cache if node.heartbeats and 'process' in node.heartbeats: if current_time - node.heartbeats['process'] >= HeartBeat.ARP_TIMEOUT: check_output("/usr/sbin/arp -d {0}".format(node.name), shell=True) except CalledProcessError: logger.exception('Error clearing ARP cache') node.save()
def get_stats_storagerouters(cls): """ Retrieve amount of vDisks and some read/write statistics for all StorageRouters """ if cls._config is None: cls.validate_and_retrieve_config() stats = [] errors = False environment = cls._config['environment'] for storagerouter in StorageRouterList.get_storagerouters(): if len(storagerouter.storagedrivers) == 0: cls._logger.debug('StorageRouter {0} does not have any StorageDrivers linked to it, skipping'.format(storagerouter.name)) continue try: statistics = storagerouter.statistics stats.append({'tags': {'environment': environment, 'storagerouter_name': storagerouter.name}, 'fields': {'read_byte': statistics['data_read'], 'write_byte': statistics['data_written'], 'operations': statistics['4k_operations'], 'amount_vdisks': len(storagerouter.vdisks_guids), 'read_operations': statistics['4k_read_operations'], 'write_operations': statistics['4k_write_operations']}, 'measurement': 'storagerouter'}) except Exception: errors = True cls._logger.exception('Retrieving statistics for StorageRouter {0} failed'.format(storagerouter.name)) return errors, stats
def process_response(self, request, response): """ Processes responses """ _ = self # Timings if isinstance(response, OVSResponse): if hasattr(request, '_entry_time'): # noinspection PyProtectedMember response.timings['total'] = [ time.time() - request._entry_time, 'Total' ] response.build_timings() # Process CORS responses if 'HTTP_ORIGIN' in request.META: path = request.path storagerouters = StorageRouterList.get_storagerouters() allowed_origins = [ 'https://{0}'.format(storagerouter.ip) for storagerouter in storagerouters ] if request.META[ 'HTTP_ORIGIN'] in allowed_origins or '/swagger.json' in path: response['Access-Control-Allow-Origin'] = request.META[ 'HTTP_ORIGIN'] response[ 'Access-Control-Allow-Headers'] = 'x-requested-with, content-type, accept, origin, authorization' response[ 'Access-Control-Allow-Methods'] = 'GET, POST, PUT, PATCH, DELETE, OPTIONS' return response
def test_ssh_connectivity(): """ Validates whether all nodes can SSH into eachother """ MonitoringController._logger.info('Starting SSH connectivity test...') ips = [sr.ip for sr in StorageRouterList.get_storagerouters()] for ip in ips: for primary_username in ['root', 'ovs']: try: with remote(ip, [SSHClient], username=primary_username) as rem: for local_ip in ips: for username in ['root', 'ovs']: message = '* Connection from {0}@{1} to {2}@{3}... {{0}}'.format( primary_username, ip, username, local_ip) try: c = rem.SSHClient(local_ip, username=username) assert c.run(['whoami' ]).strip() == username message = message.format('OK') logger = MonitoringController._logger.info except Exception as ex: message = message.format(ex.message) logger = MonitoringController._logger.error logger(message) except Exception as ex: MonitoringController._logger.error( '* Could not connect to {0}@{1}: {2}'.format( primary_username, ip, ex.message)) MonitoringController._logger.info('Finished')
def get_storagerouters(): """ Fetch the storagerouters :return: list with storagerouters :rtype: list """ return StorageRouterList.get_storagerouters()
def get_available_actions(self): """ Gets a list of all available actions """ actions = [] storagerouters = StorageRouterList.get_storagerouters() if len(storagerouters) > 1: actions.append('MOVE_AWAY') return Response(actions, status=status.HTTP_200_OK)
def get_available_actions(self): """ Gets a list of all available actions """ actions = [] storagerouters = StorageRouterList.get_storagerouters() if len(storagerouters) > 1: actions.append('MOVE_AWAY') return actions
def apply(license_string): """ Applies a license. It will apply as much licenses as possible, however, it won't fail on invalid licenses as it will simply skip them. """ try: clients = {} storagerouters = StorageRouterList.get_storagerouters() try: for storagerouter in storagerouters: clients[storagerouter] = SSHClient(storagerouter.ip) except UnableToConnectException: raise RuntimeError('Not all StorageRouters are reachable') data = LicenseController._decode(license_string) for component in data: cdata = data[component] name = cdata['name'] data = cdata['data'] token = cdata['token'] valid_until = float( cdata['valid_until']) if 'valid_until' in cdata else None if valid_until is not None and valid_until <= time.time(): continue signature = cdata['signature'] if 'signature' in cdata else None validate_functions = Toolbox.fetch_hooks( 'license', '{0}.validate'.format(component)) apply_functions = Toolbox.fetch_hooks( 'license', '{0}.apply'.format(component)) if len(validate_functions) == 1 and len(apply_functions) == 1: valid, metadata = validate_functions[0]( component=component, data=data, signature=signature) if valid is True: success = apply_functions[0](component=component, data=data, signature=signature) if success is True: license_object = LicenseList.get_by_component( component) if license_object is None: license_object = License() license_object.component = component license_object.name = name license_object.token = token license_object.data = data license_object.valid_until = valid_until license_object.signature = signature license_object.save() license_contents = [] for lic in LicenseList.get_licenses(): license_contents.append(lic.hash) for storagerouter in storagerouters: client = clients[storagerouter] client.file_write('/opt/OpenvStorage/config/licenses', '{0}\n'.format('\n'.join(license_contents))) except Exception, ex: logger.exception('Error applying license: {0}'.format(ex)) return None
def list(self, query=None): """ Overview of all Storage Routers """ if query is None: return StorageRouterList.get_storagerouters() else: query = json.loads(query) return DataList(StorageRouter, query)
def list(self, query=None): """ Overview of all Storage Routers """ if query is None: return StorageRouterList.get_storagerouters() else: query = json.loads(query) query_result = DataList({"object": StorageRouter, "data": DataList.select.GUIDS, "query": query}).data return DataObjectList(query_result, StorageRouter)
def list(self, query=None): """ Overview of all Storage Routers :param query: A query to filter the StorageRouters :type query: DataQuery """ if query is None: return StorageRouterList.get_storagerouters() else: return DataList(StorageRouter, query)
def collapse_arakoon(): """ Collapse Arakoon's Tlogs :return: None """ from ovs_extensions.generic.toolbox import ExtensionsToolbox GenericController._logger.info('Arakoon collapse started') cluster_info = [] storagerouters = StorageRouterList.get_storagerouters() if os.environ.get('RUNNING_UNITTESTS') != 'True': cluster_info = [('cacc', storagerouters[0])] cluster_names = [] for service in ServiceList.get_services(): if service.is_internal is True and service.type.name in (ServiceType.SERVICE_TYPES.ARAKOON, ServiceType.SERVICE_TYPES.NS_MGR, ServiceType.SERVICE_TYPES.ALBA_MGR): cluster = ExtensionsToolbox.remove_prefix(service.name, 'arakoon-') if cluster in cluster_names and cluster not in [ARAKOON_NAME, ARAKOON_NAME_UNITTEST]: continue cluster_names.append(cluster) cluster_info.append((cluster, service.storagerouter)) workload = {} cluster_config_map = {} for cluster, storagerouter in cluster_info: GenericController._logger.debug(' Collecting info for cluster {0}'.format(cluster)) ip = storagerouter.ip if cluster in [ARAKOON_NAME, ARAKOON_NAME_UNITTEST] else None try: config = ArakoonClusterConfig(cluster_id=cluster, source_ip=ip) cluster_config_map[cluster] = config except: GenericController._logger.exception(' Retrieving cluster information on {0} for {1} failed'.format(storagerouter.ip, cluster)) continue for node in config.nodes: if node.ip not in workload: workload[node.ip] = {'node_id': node.name, 'clusters': []} workload[node.ip]['clusters'].append((cluster, ip)) for storagerouter in storagerouters: try: if storagerouter.ip not in workload: continue node_workload = workload[storagerouter.ip] client = SSHClient(storagerouter) for cluster, ip in node_workload['clusters']: try: GenericController._logger.debug(' Collapsing cluster {0} on {1}'.format(cluster, storagerouter.ip)) client.run(['arakoon', '--collapse-local', node_workload['node_id'], '2', '-config', cluster_config_map[cluster].external_config_path]) GenericController._logger.debug(' Collapsing cluster {0} on {1} completed'.format(cluster, storagerouter.ip)) except: GenericController._logger.exception(' Collapsing cluster {0} on {1} failed'.format(cluster, storagerouter.ip)) except UnableToConnectException: GenericController._logger.error(' Could not collapse any cluster on {0} (not reachable)'.format(storagerouter.name)) GenericController._logger.info('Arakoon collapse finished')
def get(self, request, *args, **kwargs): """ Fetches metadata """ _ = args, kwargs data = {'authenticated': False, 'authentication_state': None, 'username': None, 'userguid': None, 'roles': [], 'storagerouter_ips': [sr.ip for sr in StorageRouterList.get_storagerouters()], 'versions': list(settings.VERSION), 'plugins': {}} try: # Gather plugin metadata plugins = {} # - Backends. BackendType plugins must set the has_plugin flag on True for backend_type in BackendTypeList.get_backend_types(): if backend_type.has_plugin is True: if backend_type.code not in plugins: plugins[backend_type.code] = [] plugins[backend_type.code] += ['backend', 'gui'] data['plugins'] = plugins # Gather authorization metadata if 'HTTP_AUTHORIZATION' not in request.META: return HttpResponse, dict(data.items() + {'authentication_state': 'unauthenticated'}.items()) authorization_type, access_token = request.META['HTTP_AUTHORIZATION'].split(' ') if authorization_type != 'Bearer': return HttpResponse, dict(data.items() + {'authentication_state': 'invalid_authorization_type'}.items()) tokens = BearerTokenList.get_by_access_token(access_token) if len(tokens) != 1: return HttpResponse, dict(data.items() + {'authentication_state': 'invalid_token'}.items()) token = tokens[0] if token.expiration < time.time(): for junction in token.roles.itersafe(): junction.delete() token.delete() return HttpResponse, dict(data.items() + {'authentication_state': 'token_expired'}.items()) # Gather user metadata user = token.client.user if not user.is_active: return HttpResponse, dict(data.items() + {'authentication_state': 'inactive_user'}.items()) roles = [j.role.code for j in token.roles] return HttpResponse, dict(data.items() + {'authenticated': True, 'authentication_state': 'authenticated', 'username': user.username, 'userguid': user.guid, 'roles': roles, 'plugins': plugins}.items()) except Exception as ex: logger.exception('Unexpected exception: {0}'.format(ex)) return HttpResponse, dict(data.items() + {'authentication_state': 'unexpected_exception'}.items())
def get_storagerouter_ips(): """ Fetch all the ip addresses in this cluster :return: list with storagerouter ips :rtype: list """ return [ storagerouter.ip for storagerouter in StorageRouterList.get_storagerouters() ]
def monitor_mds_layout(): """ Prints the current MDS layout :return: None :rtype: NoneType """ try: while True: output = [ '', 'Open vStorage - MDS debug information', '=====================================', 'timestamp: {0}'.format(datetime.datetime.now()), '' ] vpools_deployed = False for storagerouter in sorted( StorageRouterList.get_storagerouters(), key=lambda k: k.name): vpools = set(sd.vpool for sd in storagerouter.storagedrivers) if len(vpools) > 0: vpools_deployed = True output.append('+ {0} ({1})'.format( storagerouter.name, storagerouter.ip)) for vpool in sorted(vpools, key=lambda k: k.name): output.append(' + {0}'.format(vpool.name)) for mds_service in sorted(vpool.mds_services, key=lambda k: k.number): if mds_service.service.storagerouter_guid == storagerouter.guid: masters, slaves = 0, 0 for junction in mds_service.vdisks: if junction.is_master: masters += 1 else: slaves += 1 capacity = mds_service.capacity if capacity == -1: capacity = 'infinite' load, _ = MDSServiceController.get_mds_load( mds_service) if load == float('inf'): load = 'infinite' else: load = '{0}%'.format(round(load, 2)) output.append( ' + {0} - port {1} - {2} master(s), {3} slave(s) - capacity: {4}, load: {5}' .format(mds_service.number, mds_service.service.ports[0], masters, slaves, capacity, load)) if vpools_deployed is False: output.append('No vPools deployed') print '\x1b[2J\x1b[H' + '\n'.join(output) time.sleep(1) except KeyboardInterrupt: pass
def get_scrub_storagerouters(self): """ Loads a list of suitable StorageRouters for scrubbing the given vDisk """ storagerouters = [] for storagerouter in StorageRouterList.get_storagerouters(): scrub_partitions = storagerouter.partition_config.get(DiskPartition.ROLES.SCRUB, []) if len(scrub_partitions) == 0: continue storagerouters.append(storagerouter) return storagerouters
def _remote_stack(self): """ Live list of information about remote linked OSDs of type ALBA BACKEND :return: Information about all linked OSDs :rtype: dict """ # Import here to prevent from circular references from ovs.dal.hybrids.albaosd import AlbaOSD def _load_backend_info(_connection_info, _alba_backend_guid): client = OVSClient(ip=_connection_info['host'], port=_connection_info['port'], credentials=(_connection_info['username'], _connection_info['password']), version=3) try: info = client.get('/alba/backends/{0}/'.format(_alba_backend_guid), params={'contents': 'local_summary'}) with lock: return_value[_alba_backend_guid].update(info['local_summary']) except NotFoundException: return_value[_alba_backend_guid]['error'] = 'backend_deleted' except ForbiddenException: return_value[_alba_backend_guid]['error'] = 'not_allowed' except Exception as ex: return_value[_alba_backend_guid]['error'] = 'unknown' AlbaBackend._logger.exception('Collecting remote ALBA backend information failed with error: {0}'.format(ex)) # Retrieve local summaries of all related OSDs of type ALBA_BACKEND lock = Lock() threads = [] return_value = {} cluster_ips = [sr.ip for sr in StorageRouterList.get_storagerouters()] for osd in self.osds: if osd.osd_type == AlbaOSD.OSD_TYPES.ALBA_BACKEND and osd.metadata is not None: backend_info = osd.metadata['backend_info'] connection_info = osd.metadata['backend_connection_info'] connection_host = connection_info['host'] alba_backend_guid = backend_info['linked_guid'] return_value[alba_backend_guid] = {'name': backend_info['linked_name'], 'error': '', 'domain': None if osd.domain is None else {'guid': osd.domain_guid, 'name': osd.domain.name}, 'preset': backend_info['linked_preset'], 'osd_id': backend_info['linked_alba_id'], 'local_ip': connection_host in cluster_ips, 'remote_host': connection_host} thread = Thread(target=_load_backend_info, args=(connection_info, alba_backend_guid)) thread.start() threads.append(thread) for thread in threads: thread.join() return return_value
def check_scrub_partition_present(): """ Checks whether at least 1 scrub partition is present on any StorageRouter :return: True if at least 1 SCRUB role present in the cluster else False :rtype: bool """ for storage_router in StorageRouterList.get_storagerouters(): for disk in storage_router.disks: for partition in disk.partitions: if DiskPartition.ROLES.SCRUB in partition.roles: return True return False
def list(self, query=None): """ Overview of all Storage Routers """ if query is None: return StorageRouterList.get_storagerouters() else: query = json.loads(query) query_result = DataList({'object': StorageRouter, 'data': DataList.select.GUIDS, 'query': query}).data return DataObjectList(query_result, StorageRouter)
def refresh_package_information(): """ Retrieve and store the package information of all StorageRouters :return: None """ GenericController._logger.info('Updating package information') threads = [] information = {} all_storagerouters = StorageRouterList.get_storagerouters() for storagerouter in all_storagerouters: information[storagerouter.ip] = {} for fct in Toolbox.fetch_hooks('update', 'get_package_info_multi'): try: # We make use of these clients in Threads --> cached = False client = SSHClient(endpoint=storagerouter, username='******', cached=False) except UnableToConnectException: information[storagerouter.ip]['errors'] = [ 'StorageRouter {0} is inaccessible'.format( storagerouter.name) ] break thread = Thread(target=fct, args=(client, information)) thread.start() threads.append(thread) for fct in Toolbox.fetch_hooks('update', 'get_package_info_single'): thread = Thread(target=fct, args=(information, )) thread.start() threads.append(thread) for thread in threads: thread.join() errors = [] copy_information = copy.deepcopy(information) for ip, info in information.iteritems(): if len(info.get('errors', [])) > 0: errors.extend( ['{0}: {1}'.format(ip, error) for error in info['errors']]) copy_information.pop(ip) for storagerouter in all_storagerouters: info = copy_information.get(storagerouter.ip, {}) if 'errors' in info: info.pop('errors') storagerouter.package_information = info storagerouter.save() if len(errors) > 0: errors = [str(error) for error in set(errors)] raise Exception(' - {0}'.format('\n - '.join(errors)))
def get_scrub_storagerouters(self): """ Loads a list of suitable StorageRouters for scrubbing the given vDisk """ storagerouters = [] for storagerouter in StorageRouterList.get_storagerouters(): scrub_partitions = storagerouter.partition_config.get( DiskPartition.ROLES.SCRUB, []) if len(scrub_partitions) == 0: continue storagerouters.append(storagerouter) return storagerouters
def install_plugins(): """ (Re)load plugins """ if ServiceManager.has_service('ovs-watcher-framework', SSHClient('127.0.0.1', username='******')): # If the watcher is running, 'ovs setup' was executed and we need to restart everything to load # the plugin. In the other case, the plugin will be loaded once 'ovs setup' is executed from ovs.dal.lists.storagerouterlist import StorageRouterList clients = [] try: for storagerouter in StorageRouterList.get_storagerouters(): clients.append(SSHClient(storagerouter, username='******')) except UnableToConnectException: raise RuntimeError('Not all StorageRouters are reachable') for client in clients: for service_name in ['watcher-framework', 'memcached']: ServiceManager.stop_service(service_name, client=client) wait = 30 while wait > 0: if ServiceManager.get_service_status( service_name, client=client) is False: break time.sleep(1) wait -= 1 if wait == 0: raise RuntimeError( 'Could not stop service: {0}'.format(service_name)) for client in clients: for service_name in ['memcached', 'watcher-framework']: ServiceManager.start_service(service_name, client=client) wait = 30 while wait > 0: if ServiceManager.get_service_status( service_name, client=client) is True: break time.sleep(1) wait -= 1 if wait == 0: raise RuntimeError( 'Could not start service: {0}'.format( service_name)) from ovs.dal.helpers import Migration Migration.migrate() from ovs.lib.helpers.toolbox import Toolbox ip = System.get_my_storagerouter().ip functions = Toolbox.fetch_hooks('plugin', 'postinstall') for function in functions: function(ip=ip)
def build_clients(self): # type: () -> Dict[StorageRouter, SSHClient] """ Builds SSHClients towards all StorageRouters :return: SSHClient mapped by storagerouter :rtype: dict((storagerouter, sshclient)) """ clients = {} for storagerouter in StorageRouterList.get_storagerouters(): client = self.build_ssh_client(storagerouter) if client is not None: clients[storagerouter] = client return clients
def get_scrub_storagerouters(self): """ Loads a list of suitable StorageRouters for scrubbing the given vDisk :return: A list of StorageRouters which have the SCRUB role :rtype: list[ovs.dal.hybrids.storagerouter.StorageRouter] """ storagerouters = [] for storagerouter in StorageRouterList.get_storagerouters(): scrub_partitions = storagerouter.partition_config.get(DiskPartition.ROLES.SCRUB, []) if len(scrub_partitions) == 0: continue storagerouters.append(storagerouter) return storagerouters
def get_my_storagerouter(): """ Returns unique machine storagerouter id """ from ovs.dal.hybrids.storagerouter import StorageRouter from ovs.dal.lists.storagerouterlist import StorageRouterList if not System.my_storagerouter_guid: for storagerouter in StorageRouterList.get_storagerouters(): if storagerouter.machine_id == System.get_my_machine_id(): System.my_storagerouter_guid = storagerouter.guid return StorageRouter(System.my_storagerouter_guid)
def listEdgeclients(): edgeclients = [] protocol = getEdgeProtocol() for storagerouter in StorageRouterList.get_storagerouters(): if storagerouter.status == 'FAILURE': continue for storagedriver in storagerouter.storagedrivers: edgeclient = {'vpool': storagedriver.vpool.name, 'protocol': protocol, 'ip': storagerouter.ip, 'port': storagedriver.ports['edge']} edgeclients.append(edgeclient) return edgeclients
def process_response(self, request, response): """ Processes responses """ _ = self # Process CORS responses if 'HTTP_ORIGIN' in request.META: storagerouters = StorageRouterList.get_storagerouters() allowed_origins = ['https://{0}'.format(storagerouter.ip) for storagerouter in storagerouters] if request.META['HTTP_ORIGIN'] in allowed_origins: response['Access-Control-Allow-Origin'] = request.META['HTTP_ORIGIN'] response['Access-Control-Allow-Headers'] = 'x-requested-with, content-type, accept, origin, authorization' response['Access-Control-Allow-Methods'] = 'GET, POST, PUT, PATCH, DELETE, OPTIONS' return response
def collapse_arakoon(): """ Collapse Arakoon's Tlogs :return: None """ ScheduledTaskController._logger.info('Starting arakoon collapse') storagerouters = StorageRouterList.get_storagerouters() cluster_info = [('cacc', storagerouters[0], True)] cluster_names = [] for service in ServiceList.get_services(): if service.is_internal is True and service.type.name in (ServiceType.SERVICE_TYPES.ARAKOON, ServiceType.SERVICE_TYPES.NS_MGR, ServiceType.SERVICE_TYPES.ALBA_MGR): cluster = service.name.replace('arakoon-', '') if cluster in cluster_names: continue cluster_names.append(cluster) cluster_info.append((cluster, service.storagerouter, False)) workload = {} for cluster, storagerouter, filesystem in cluster_info: ScheduledTaskController._logger.debug(' Collecting info for cluster {0}'.format(cluster)) config = ArakoonClusterConfig(cluster, filesystem=filesystem) config.load_config(storagerouter.ip) for node in config.nodes: if node.ip not in workload: workload[node.ip] = {'node_id': node.name, 'clusters': []} workload[node.ip]['clusters'].append((cluster, filesystem)) for storagerouter in storagerouters: try: if storagerouter.ip not in workload: continue node_workload = workload[storagerouter.ip] client = SSHClient(storagerouter) for cluster, filesystem in node_workload['clusters']: try: ScheduledTaskController._logger.debug(' Collapsing cluster {0} on {1}'.format(cluster, storagerouter.ip)) if filesystem is True: config_path = ArakoonClusterConfig.CONFIG_FILE.format(cluster) else: config_path = Configuration.get_configuration_path(ArakoonClusterConfig.CONFIG_KEY.format(cluster)) client.run(['arakoon', '--collapse-local', node_workload['node_id'], '2', '-config', config_path]) ScheduledTaskController._logger.info(' Collapsing cluster {0} on {1} completed'.format(cluster, storagerouter.ip)) except: ScheduledTaskController._logger.exception(' Collapsing cluster {0} on {1} failed'.format(cluster, storagerouter.ip)) except UnableToConnectException: ScheduledTaskController._logger.error(' Could not collapse any cluster on {0} (not reachable)'.format(storagerouter.name)) ScheduledTaskController._logger.info('Arakoon collapse finished')
def apply(license_string): """ Applies a license. It will apply as much licenses as possible, however, it won't fail on invalid licenses as it will simply skip them. """ try: clients = {} storagerouters = StorageRouterList.get_storagerouters() try: for storagerouter in storagerouters: clients[storagerouter] = SSHClient(storagerouter.ip) except UnableToConnectException: raise RuntimeError('Not all StorageRouters are reachable') data = LicenseController._decode(license_string) for component in data: cdata = data[component] name = cdata['name'] data = cdata['data'] token = cdata['token'] valid_until = float(cdata['valid_until']) if 'valid_until' in cdata else None if valid_until is not None and valid_until <= time.time(): continue signature = cdata['signature'] if 'signature' in cdata else None validate_functions = Toolbox.fetch_hooks('license', '{0}.validate'.format(component)) apply_functions = Toolbox.fetch_hooks('license', '{0}.apply'.format(component)) if len(validate_functions) == 1 and len(apply_functions) == 1: valid, metadata = validate_functions[0](component=component, data=data, signature=signature) if valid is True: success = apply_functions[0](component=component, data=data, signature=signature) if success is True: license_object = LicenseList.get_by_component(component) if license_object is None: license_object = License() license_object.component = component license_object.name = name license_object.token = token license_object.data = data license_object.valid_until = valid_until license_object.signature = signature license_object.save() license_contents = [] for lic in LicenseList.get_licenses(): license_contents.append(lic.hash) for storagerouter in storagerouters: client = clients[storagerouter] client.file_write('/opt/OpenvStorage/config/licenses', '{0}\n'.format('\n'.join(license_contents))) except Exception, ex: LicenseController._logger.exception('Error applying license: {0}'.format(ex)) return None
def refresh_package_information(): """ Retrieve and store the package information of all StorageRouters :return: None """ GenericController._logger.info('Updating package information') threads = [] information = {} all_storagerouters = StorageRouterList.get_storagerouters() for storagerouter in all_storagerouters: information[storagerouter.ip] = {} for function in Toolbox.fetch_hooks('update', 'get_package_info_multi'): try: # We make use of these clients in Threads --> cached = False client = SSHClient(endpoint=storagerouter, username='******', cached=False) except UnableToConnectException: information[storagerouter.ip]['errors'] = ['StorageRouter {0} is inaccessible'.format(storagerouter.name)] break thread = Thread(target=function, args=(client, information)) thread.start() threads.append(thread) for function in Toolbox.fetch_hooks('update', 'get_package_info_single'): thread = Thread(target=function, args=(information,)) thread.start() threads.append(thread) for thread in threads: thread.join() errors = [] copy_information = copy.deepcopy(information) for ip, info in information.iteritems(): if len(info.get('errors', [])) > 0: errors.extend(['{0}: {1}'.format(ip, error) for error in info['errors']]) copy_information.pop(ip) for storagerouter in all_storagerouters: info = copy_information.get(storagerouter.ip, {}) if 'errors' in info: info.pop('errors') storagerouter.package_information = info storagerouter.save() if len(errors) > 0: errors = [str(error) for error in set(errors)] raise Exception(' - {0}'.format('\n - '.join(errors)))
def _default_starting_values(since=None, until=None, search_locations=None, hosts=None): if until and since is not None and isinstance( since, str) and isinstance(until, str): # Test for times to be properly formatted, allow hh:mm or hh:mm:ss pattern = re.compile( r'(^[2][0-3]|[0-1][0-9]):[0-5][0-9](:[0-5][0-9])?$') # If only hours are supplied, match them to a day if pattern.match(since) or pattern.match(until): # Determine Time Range yesterday = date.fromordinal(date.today().toordinal() - 1).strftime('%Y-%m-%d') today = datetime.now().strftime('%Y-%m-%d') now = datetime.now().strftime('%R') if since > now or since > until: search_start = yesterday else: search_start = today if until > since > now: search_end = yesterday else: search_end = today since = LogFileTimeParser._parse_date(search_start + ' ' + since) until = LogFileTimeParser._parse_date(search_end + ' ' + until) else: # Set dates since = LogFileTimeParser._parse_date(since) until = LogFileTimeParser._parse_date(until) # Setup default times if since is None: since = (datetime.today() - timedelta(hours=1)) if until is None: until = datetime.today() if search_locations is None: execution_mode = LogFileTimeParser._get_execution_mode() search_locations = LogFileTimeParser.STANDARD_SEARCH_LOCATIONS for service, info in LogFileTimeParser.INTERNAL_MAPPING.iteritems( ): search_locations.append(info.get(execution_mode)) if not hosts: hosts = [sr.ip for sr in StorageRouterList.get_storagerouters()] return since, until, search_locations, hosts
def listEdgeclients(): edgeclients = [] protocol = getEdgeProtocol() for storagerouter in StorageRouterList.get_storagerouters(): if storagerouter.status == "FAILURE": continue for storagedriver in storagerouter.storagedrivers: edgeclient = { "vpool": storagedriver.vpool.name, "protocol": protocol, "ip": storagerouter.ip, "port": storagedriver.ports["edge"], } edgeclients.append(edgeclient) return edgeclients
def _storage_router_layout(self): """ Creates a dictionary with information about which Storage Routers use this domain as its normal and recovery domain :return: Information about Storage Routers using this domain :rtype: dict """ layout = {'regular': [], 'recovery': []} for sr in StorageRouterList.get_storagerouters(): for junction in sr.domains: if junction.domain_guid == self.guid: if junction.backup is True: layout['recovery'].append(sr.guid) else: layout['regular'].append(sr.guid) return layout
def install_plugins(): """ (Re)load plugins """ if ServiceManager.has_service('ovs-watcher-framework', SSHClient('127.0.0.1', username='******')): # If the watcher is running, 'ovs setup' was executed and we need to restart everything to load # the plugin. In the other case, the plugin will be loaded once 'ovs setup' is executed from ovs.dal.lists.storagerouterlist import StorageRouterList clients = [] try: for storagerouter in StorageRouterList.get_storagerouters(): clients.append(SSHClient(storagerouter, username='******')) except UnableToConnectException: raise RuntimeError('Not all StorageRouters are reachable') for client in clients: for service_name in ['watcher-framework', 'memcached']: ServiceManager.stop_service(service_name, client=client) wait = 30 while wait > 0: if ServiceManager.get_service_status(service_name, client=client) is False: break time.sleep(1) wait -= 1 if wait == 0: raise RuntimeError('Could not stop service: {0}'.format(service_name)) for client in clients: for service_name in ['memcached', 'watcher-framework']: ServiceManager.start_service(service_name, client=client) wait = 30 while wait > 0: if ServiceManager.get_service_status(service_name, client=client) is True: break time.sleep(1) wait -= 1 if wait == 0: raise RuntimeError('Could not start service: {0}'.format(service_name)) from ovs.dal.helpers import Migration Migration.migrate() from ovs.lib.helpers.toolbox import Toolbox ip = System.get_my_storagerouter().ip functions = Toolbox.fetch_hooks('plugin', 'postinstall') for function in functions: function(ip=ip)
def register(name, email, company, phone, newsletter): """ Registers the environment """ SupportAgent().run() # Execute a single heartbeat run client = OVSClient('monitoring.openvstorage.com', 443, credentials=None, verify=True, version=1) task_id = client.post('/support/register/', data={'cluster_id': Configuration.get('ovs.support.cid'), 'name': name, 'email': email, 'company': company, 'phone': phone, 'newsletter': newsletter, 'register_only': True}) if task_id: client.wait_for_task(task_id, timeout=120) for storagerouter in StorageRouterList.get_storagerouters(): client = SSHClient(storagerouter) client.config_set('ovs.core.registered', True)
def _default_starting_values(since=None, until=None, search_locations=None, hosts=None): if until and since is not None and isinstance(since, str) and isinstance(until, str): # Test for times to be properly formatted, allow hh:mm or hh:mm:ss pattern = re.compile(r'(^[2][0-3]|[0-1][0-9]):[0-5][0-9](:[0-5][0-9])?$') # If only hours are supplied, match them to a day if pattern.match(since) or pattern.match(until): # Determine Time Range yesterday = date.fromordinal(date.today().toordinal() - 1).strftime('%Y-%m-%d') today = datetime.now().strftime('%Y-%m-%d') now = datetime.now().strftime('%R') if since > now or since > until: search_start = yesterday else: search_start = today if until > since > now: search_end = yesterday else: search_end = today since = LogFileTimeParser._parse_date(search_start + ' ' + since) until = LogFileTimeParser._parse_date(search_end + ' ' + until) else: # Set dates since = LogFileTimeParser._parse_date(since) until = LogFileTimeParser._parse_date(until) # Setup default times if since is None: since = (datetime.today() - timedelta(hours=1)) if until is None: until = datetime.today() if search_locations is None: execution_mode = LogFileTimeParser._get_execution_mode() search_locations = LogFileTimeParser.STANDARD_SEARCH_LOCATIONS for service, info in LogFileTimeParser.INTERNAL_MAPPING.iteritems(): search_locations.append(info.get(execution_mode)) if not hosts: hosts = [sr.ip for sr in StorageRouterList.get_storagerouters()] return since, until, search_locations, hosts
def sync_with_reality(storagerouter_guid=None): """ Syncs the Disks from all StorageRouters with the reality. :param storagerouter_guid: Guid of the Storage Router to synchronize """ storagerouters = [] if storagerouter_guid is not None: storagerouters.append(StorageRouter(storagerouter_guid)) else: storagerouters = StorageRouterList.get_storagerouters() for storagerouter in storagerouters: try: client = SSHClient(storagerouter, username='******') except UnableToConnectException: DiskController._logger.info('Could not connect to StorageRouter {0}, skipping'.format(storagerouter.ip)) continue configuration = {} # Gather mount data mount_mapping = {} mount_data = client.run('mount') for mount in mount_data.splitlines(): mount = mount.strip() match = re.search('(/dev/(.+?)) on (/.*?) type.*', mount) if match is not None: dev_name = match.groups()[0] uuid = client.run('blkid -o value -s UUID {0}'.format(dev_name)) if uuid: mount_mapping[uuid] = match.groups()[2] else: mount_mapping[match.groups()[1]] = match.groups()[2] # Gather raid information try: md_information = client.run('mdadm --detail /dev/md*', suppress_logging=True) except CalledProcessError: md_information = '' raid_members = [] for member in re.findall('(?: +[0-9]+){4} +[^/]+/dev/([a-z0-9]+)', md_information): raid_members.append(member) # Gather disk information with remote(storagerouter.ip, [Context, os]) as rem: context = rem.Context() devices = [device for device in context.list_devices(subsystem='block') if ('ID_TYPE' in device and device['ID_TYPE'] == 'disk') or ('DEVNAME' in device and ('loop' in device['DEVNAME'] or 'nvme' in device['DEVNAME'] or 'md' in device['DEVNAME']))] for device in devices: is_partition = device['DEVTYPE'] == 'partition' device_path = device['DEVNAME'] device_name = device_path.split('/')[-1] partition_id = None partition_name = None extended_partition_info = None if is_partition is True: partition_name = device['ID_FS_UUID'] if 'ID_FS_UUID' in device else device_name if 'ID_PART_ENTRY_NUMBER' in device: extended_partition_info = True partition_id = device['ID_PART_ENTRY_NUMBER'] if device_name.startswith('nvme') or device_name.startswith('loop'): device_name = device_name[:0 - int(len(partition_id)) - 1] elif device_name.startswith('md'): device_name = device_name[:device_name.index('p')] else: device_name = device_name[:0 - int(len(partition_id))] else: DiskController._logger.debug('Partition {0} has no partition metadata'.format(device_path)) extended_partition_info = False match = re.match('^(\D+?)(\d+)$', device_name) if match is None: DiskController._logger.debug('Could not handle disk/partition {0}'.format(device_path)) continue # Unable to handle this disk/partition partition_id = match.groups()[1] device_name = match.groups()[0] sectors = int(client.run('cat /sys/block/{0}/size'.format(device_name))) sector_size = int(client.run('cat /sys/block/{0}/queue/hw_sector_size'.format(device_name))) rotational = int(client.run('cat /sys/block/{0}/queue/rotational'.format(device_name))) if sectors == 0: continue if device_name in raid_members: continue if device_name not in configuration: configuration[device_name] = {'partitions': {}} path = None for path_type in ['by-id', 'by-uuid']: if path is not None: break if 'DEVLINKS' in device: for item in device['DEVLINKS'].split(' '): if path_type in item: path = item if path is None: path = device_path if is_partition is True: if 'ID_PART_ENTRY_TYPE' in device and device['ID_PART_ENTRY_TYPE'] == '0x5': continue # This is an extended partition, let's skip that one if extended_partition_info is True: offset = int(device['ID_PART_ENTRY_OFFSET']) * sector_size size = int(device['ID_PART_ENTRY_SIZE']) * sector_size else: match = re.match('^(\D+?)(\d+)$', device_path) if match is None: DiskController._logger.debug('Could not handle disk/partition {0}'.format(device_path)) continue # Unable to handle this disk/partition partitions_info = DiskTools.get_partitions_info(match.groups()[0]) if device_path in partitions_info: partition_info = partitions_info[device_path] offset = int(partition_info['start']) size = int(partition_info['size']) else: DiskController._logger.warning('Could not retrieve partition info for disk/partition {0}'.format(device_path)) continue configuration[device_name]['partitions'][partition_id] = {'offset': offset, 'size': size, 'path': path, 'state': 'OK'} partition_data = configuration[device_name]['partitions'][partition_id] if partition_name in mount_mapping: mountpoint = mount_mapping[partition_name] partition_data['mountpoint'] = mountpoint partition_data['inode'] = rem.os.stat(mountpoint).st_dev del mount_mapping[partition_name] try: client.run('touch {0}/{1}; rm {0}/{1}'.format(mountpoint, str(time.time()))) except CalledProcessError: partition_data['state'] = 'FAILURE' pass if 'ID_FS_TYPE' in device: partition_data['filesystem'] = device['ID_FS_TYPE'] else: configuration[device_name].update({'name': device_name, 'path': path, 'vendor': device['ID_VENDOR'] if 'ID_VENDOR' in device else None, 'model': device['ID_MODEL'] if 'ID_MODEL' in device else None, 'size': sector_size * sectors, 'is_ssd': rotational == 0, 'state': 'OK'}) for partition_name in mount_mapping: device_name = partition_name.split('/')[-1] match = re.search('^(\D+?)(\d+)$', device_name) if match is not None: device_name = match.groups()[0] partition_id = match.groups()[1] if device_name not in configuration: configuration[device_name] = {'partitions': {}, 'state': 'MISSING'} configuration[device_name]['partitions'][partition_id] = {'mountpoint': mount_mapping[partition_name], 'state': 'MISSING'} # Sync the model disk_names = [] for disk in storagerouter.disks: if disk.name not in configuration: for partition in disk.partitions: partition.delete() disk.delete() else: disk_names.append(disk.name) DiskController._update_disk(disk, configuration[disk.name]) partitions = [] partition_info = configuration[disk.name]['partitions'] for partition in disk.partitions: if partition.id not in partition_info: partition.delete() else: partitions.append(partition.id) DiskController._update_partition(partition, partition_info[partition.id]) for partition_id in partition_info: if partition_id not in partitions: DiskController._create_partition(partition_id, partition_info[partition_id], disk) for disk_name in configuration: if disk_name not in disk_names and configuration[disk_name]['state'] not in ['MISSING']: disk = Disk() disk.storagerouter = storagerouter disk.name = disk_name DiskController._update_disk(disk, configuration[disk_name]) partition_info = configuration[disk_name]['partitions'] for partition_id in partition_info: if partition_info[partition_id]['state'] not in ['MISSING']: DiskController._create_partition(partition_id, partition_info[partition_id], disk)
def _bootstrap_dal_models(self): """ Load/hook dal models as snmp oids """ _guids = set() enabled_key = "{0}_config_dal_enabled".format(STORAGE_PREFIX) self.instance_oid = 0 try: enabled = self.persistent.get(enabled_key) except KeyNotFoundException: enabled = True # Enabled by default, can be disabled by setting the key if enabled: from ovs.dal.lists.vdisklist import VDiskList from ovs.dal.lists.storagerouterlist import StorageRouterList from ovs.dal.lists.pmachinelist import PMachineList from ovs.dal.lists.vmachinelist import VMachineList from ovs.dal.lists.vpoollist import VPoolList from ovs.dal.lists.storagedriverlist import StorageDriverList for storagerouter in StorageRouterList.get_storagerouters(): _guids.add(storagerouter.guid) if not self._check_added(storagerouter): self._register_dal_model(10, storagerouter, 'guid', "0") self._register_dal_model(10, storagerouter, 'name', "1") self._register_dal_model(10, storagerouter, 'pmachine', "3", key = 'host_status') self._register_dal_model(10, storagerouter, 'description', "4") self._register_dal_model(10, storagerouter, 'devicename', "5") self._register_dal_model(10, storagerouter, 'dtl_mode', "6") self._register_dal_model(10, storagerouter, 'ip', "8") self._register_dal_model(10, storagerouter, 'machineid', "9") self._register_dal_model(10, storagerouter, 'status', "10") self._register_dal_model(10, storagerouter, '#vdisks', "11", func = lambda storagerouter: len([vdisk for vpool_vdisks in [storagedriver.vpool.vdisks for storagedriver in storagerouter.storagedrivers] for vdisk in vpool_vdisks if vdisk.storagedriver_id == storagedriver.storagedriver_id]), atype = int) self._register_dal_model(10, storagerouter, '#vmachines', "12", func = lambda storagerouter: len(set([vdisk.vmachine.guid for vpool_vdisks in [storagedriver.vpool.vdisks for storagedriver in storagerouter.storagedrivers] for vdisk in vpool_vdisks if vdisk.storagedriver_id == storagedriver.storagedriver_id])), atype = int) self._register_dal_model(10, storagerouter, '#stored_data', "13", func = lambda storagerouter: sum([vdisk.vmachine.stored_data for vpool_vdisks in [storagedriver.vpool.vdisks for storagedriver in storagerouter.storagedrivers] for vdisk in vpool_vdisks if vdisk.storagedriver_id == storagedriver.storagedriver_id]), atype = int) self.instance_oid += 1 for vm in VMachineList.get_vmachines(): _guids.add(vm.guid) if not self._check_added(vm): if vm.is_vtemplate: self._register_dal_model(11, vm, 'guid', "0") self._register_dal_model(11, vm, 'name', "1") def _children(vmt): children = 0 disks = [vd.guid for vd in vmt.vdisks] for vdisk in [vdisk.parent_vdisk_guid for item in [vm.vdisks for vm in VMachineList.get_vmachines() if not vm.is_vtemplate] for vdisk in item]: for disk in disks: if vdisk == disk: children += 1 return children self._register_dal_model(11, vm, '#children', 2, func = _children, atype = int) self.instance_oid += 1 for vm in VMachineList.get_vmachines(): _guids.add(vm.guid) if not self._check_added(vm): if not vm.is_vtemplate: self._register_dal_model(0, vm, 'guid', "0") self._register_dal_model(0, vm, 'name', "1") self._register_dal_model(0, vm, 'statistics', "2.0", key = "operations", atype = int) self._register_dal_model(0, vm, 'statistics', "2.1", key = "cluster_cache_misses_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.2", key = "data_read", atype = int) self._register_dal_model(0, vm, 'statistics', "2.3", key = "sco_cache_misses", atype = int) self._register_dal_model(0, vm, 'statistics', "2.4", key = "sco_cache_hits_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.5", key = "sco_cache_hits", atype = int) self._register_dal_model(0, vm, 'statistics', "2.6", key = "write_operations", atype = int) self._register_dal_model(0, vm, 'statistics', "2.7", key = "cluster_cache_misses", atype = int) self._register_dal_model(0, vm, 'statistics', "2.8", key = "read_operations_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.9", key = "sco_cache_misses_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.10", key = "backend_write_operations", atype = int) self._register_dal_model(0, vm, 'statistics', "2.11", key = "backend_data_read", atype = int) self._register_dal_model(0, vm, 'statistics', "2.12", key = "cache_hits", atype = int) self._register_dal_model(0, vm, 'statistics', "2.13", key = "backend_write_operations_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.14", key = "metadata_store_hits_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.15", key = "metadata_store_misses", atype = int) self._register_dal_model(0, vm, 'statistics', "2.16", key = "backend_data_written", atype = int) self._register_dal_model(0, vm, 'statistics', "2.17", key = "data_read_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.18", key = "read_operations", atype = int) self._register_dal_model(0, vm, 'statistics', "2.19", key = "cluster_cache_hits", atype = int) self._register_dal_model(0, vm, 'statistics', "2.20", key = "data_written_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.21", key = "cluster_cache_hits_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.22", key = "cache_hits_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.23", key = "timestamp", atype = int) self._register_dal_model(0, vm, 'statistics', "2.24", key = "metadata_store_misses_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.25", key = "backend_data_written_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.26", key = "backend_read_operations", atype = int) self._register_dal_model(0, vm, 'statistics', "2.27", key = "data_written", atype = int) self._register_dal_model(0, vm, 'statistics', "2.28", key = "metadata_store_hits", atype = int) self._register_dal_model(0, vm, 'statistics', "2.29", key = "backend_data_read_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.30", key = "operations_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.31", key = "backend_read_operations_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.32", key = "data_transferred_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.33", key = "write_operations_ps", atype = int) self._register_dal_model(0, vm, 'statistics', "2.34", key = "data_transferred", atype = int) self._register_dal_model(0, vm, 'stored_data', "3", atype = int) self._register_dal_model(0, vm, 'description', "4") self._register_dal_model(0, vm, 'devicename', "5") self._register_dal_model(0, vm, 'dtl_mode', "6") self._register_dal_model(0, vm, 'hypervisorid', "7") self._register_dal_model(0, vm, 'ip', "8") self._register_dal_model(0, vm, 'status', "10") self._register_dal_model(0, vm, 'stored_data', "10", atype = int) self._register_dal_model(0, vm, 'snapshots', "11", atype = int) self._register_dal_model(0, vm, 'vdisks', "12", atype = int) self._register_dal_model(0, vm, 'DTL', '13', func = lambda vm: 'DEGRADED' if all(item == 'DEGRADED' for item in [vd.info['failover_mode'] for vd in vm.vdisks]) else 'OK') self.instance_oid += 1 for vd in VDiskList.get_vdisks(): _guids.add(vd.guid) if not self._check_added(vd): self._register_dal_model(1, vd, 'guid', "0") self._register_dal_model(1, vd, 'name', "1") self._register_dal_model(1, vd, 'statistics', "2.0", key = "operations", atype = int) self._register_dal_model(1, vd, 'statistics', "2.1", key = "data_written_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.2", key = "data_read", atype = int) self._register_dal_model(1, vd, 'statistics', "2.3", key = "sco_cache_misses", atype = int) self._register_dal_model(1, vd, 'statistics', "2.4", key = "sco_cache_hits_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.5", key = "sco_cache_hits", atype = int) self._register_dal_model(1, vd, 'statistics', "2.6", key = "write_operations", atype = int) self._register_dal_model(1, vd, 'statistics', "2.7", key = "cluster_cache_misses", atype = int) self._register_dal_model(1, vd, 'statistics', "2.8", key = "read_operations_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.9", key = "sco_cache_misses_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.10", key = "backend_write_operations", atype = int) self._register_dal_model(1, vd, 'statistics', "2.11", key = "backend_data_read", atype = int) self._register_dal_model(1, vd, 'statistics', "2.12", key = "cache_hits", atype = int) self._register_dal_model(1, vd, 'statistics', "2.13", key = "backend_write_operations_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.14", key = "metadata_store_hits_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.15", key = "metadata_store_misses", atype = int) self._register_dal_model(1, vd, 'statistics', "2.16", key = "backend_data_written", atype = int) self._register_dal_model(1, vd, 'statistics', "2.17", key = "data_read_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.18", key = "read_operations", atype = int) self._register_dal_model(1, vd, 'statistics', "2.19", key = "cluster_cache_hits", atype = int) self._register_dal_model(1, vd, 'statistics', "2.20", key = "cluster_cache_misses_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.21", key = "cluster_cache_hits_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.22", key = "cache_hits_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.23", key = "timestamp", atype = int) self._register_dal_model(1, vd, 'statistics', "2.24", key = "metadata_store_misses_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.25", key = "backend_data_written_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.26", key = "backend_read_operations", atype = int) self._register_dal_model(1, vd, 'statistics', "2.27", key = "data_written", atype = int) self._register_dal_model(1, vd, 'statistics', "2.28", key = "metadata_store_hits", atype = int) self._register_dal_model(1, vd, 'statistics', "2.29", key = "backend_data_read_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.30", key = "operations_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.31", key = "backend_read_operations_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.32", key = "data_transferred_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.33", key = "write_operations_ps", atype = int) self._register_dal_model(1, vd, 'statistics', "2.34", key = "data_transferred", atype = int) self._register_dal_model(1, vd, 'info', "3", key = 'stored', atype = int) self._register_dal_model(1, vd, 'info', "4", key = 'failover_mode', atype = int) self._register_dal_model(1, vd, 'snapshots', "5", atype = int) self.instance_oid += 1 for pm in PMachineList.get_pmachines(): _guids.add(pm.guid) if not self._check_added(pm): self._register_dal_model(2, pm, 'guid', "0") self._register_dal_model(2, pm, 'name', "1") self._register_dal_model(2, pm, 'host_status', "2") self.instance_oid += 1 for vp in VPoolList.get_vpools(): _guids.add(vp.guid) if not self._check_added(vp): self._register_dal_model(3, vp, 'guid', "0") self._register_dal_model(3, vp, 'name', "1") self._register_dal_model(3, vp, 'statistics', "2.0", key = "operations", atype = int) self._register_dal_model(3, vp, 'statistics', "2.1", key = "cluster_cache_misses_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.2", key = "data_read", atype = int) self._register_dal_model(3, vp, 'statistics', "2.3", key = "sco_cache_misses", atype = int) self._register_dal_model(3, vp, 'statistics', "2.4", key = "sco_cache_hits_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.5", key = "sco_cache_hits", atype = int) self._register_dal_model(3, vp, 'statistics', "2.6", key = "write_operations", atype = int) self._register_dal_model(3, vp, 'statistics', "2.7", key = "cluster_cache_misses", atype = int) self._register_dal_model(3, vp, 'statistics', "2.8", key = "read_operations_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.9", key = "sco_cache_misses_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.10", key = "backend_write_operations", atype = int) self._register_dal_model(3, vp, 'statistics', "2.11", key = "backend_data_read", atype = int) self._register_dal_model(3, vp, 'statistics', "2.12", key = "cache_hits", atype = int) self._register_dal_model(3, vp, 'statistics', "2.13", key = "backend_write_operations_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.14", key = "metadata_store_hits_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.15", key = "metadata_store_misses", atype = int) self._register_dal_model(3, vp, 'statistics', "2.16", key = "backend_data_written", atype = int) self._register_dal_model(3, vp, 'statistics', "2.17", key = "data_read_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.18", key = "read_operations", atype = int) self._register_dal_model(3, vp, 'statistics', "2.19", key = "cluster_cache_hits", atype = int) self._register_dal_model(3, vp, 'statistics', "2.20", key = "data_written_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.21", key = "cluster_cache_hits_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.22", key = "cache_hits_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.23", key = "timestamp", atype = int) self._register_dal_model(3, vp, 'statistics', "2.24", key = "metadata_store_misses_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.25", key = "backend_data_written_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.26", key = "backend_read_operations", atype = int) self._register_dal_model(3, vp, 'statistics', "2.27", key = "data_written", atype = int) self._register_dal_model(3, vp, 'statistics', "2.28", key = "metadata_store_hits", atype = int) self._register_dal_model(3, vp, 'statistics', "2.29", key = "backend_data_read_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.30", key = "operations_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.31", key = "backend_read_operations_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.32", key = "data_transferred_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.33", key = "write_operations_ps", atype = int) self._register_dal_model(3, vp, 'statistics', "2.34", key = "data_transferred", atype = int) self._register_dal_model(3, vp, 'status', "3") self._register_dal_model(3, vp, 'description', "4") self._register_dal_model(3, vp, 'vdisks', "5", atype = int) self._register_dal_model(3, vp, '#vmachines', "6", func = lambda vp: len(set([vd.vmachine.guid for vd in vp.vdisks])), atype = int) self.instance_oid += 1 for storagedriver in StorageDriverList.get_storagedrivers(): _guids.add(storagedriver.guid) if not self._check_added(storagedriver): self._register_dal_model(4, storagedriver, 'guid', "0") self._register_dal_model(4, storagedriver, 'name', "1") self._register_dal_model(4, storagedriver, 'stored_data', "2", atype = int) self.instance_oid += 1 try: # try to load OVS Backends from ovs.dal.lists.albabackendlist import AlbaBackendList for backend in AlbaBackendList.get_albabackends(): _guids.add(backend.guid) if not self._check_added(backend): self._register_dal_model(5, backend, 'guid', 0) self._register_dal_model(5, backend, 'name', 1) for disk_id in range(len((backend.all_disks))): self._register_dal_model(5, backend, 'all_disks', '2.{0}.0'.format(disk_id), key = "name", index=disk_id) self._register_dal_model(5, backend, 'all_disks', '2.{0}.1'.format(disk_id), key = "usage.size", atype = long, index=disk_id) self._register_dal_model(5, backend, 'all_disks', '2.{0}.2'.format(disk_id), key = "usage.used", atype = long, index=disk_id) self._register_dal_model(5, backend, 'all_disks', '2.{0}.3'.format(disk_id), key = "usage.available", atype = long, index=disk_id) self._register_dal_model(5, backend, 'all_disks', '2.{0}.4'.format(disk_id), key = "state.state", index=disk_id) self._register_dal_model(5, backend, 'all_disks', '2.{0}.5'.format(disk_id), key = "node_id", index=disk_id) self.instance_oid += 1 except ImportError: print('OVS Backend not present') pass reload = False for object_guid in list(self.model_oids): if object_guid not in _guids: self.model_oids.remove(object_guid) reload = True if reload: self._reload_snmp()
def sync_with_reality(storagerouter_guid=None): """ Syncs the Disks from all StorageRouters with the reality. """ storagerouters = [] if storagerouter_guid is not None: storagerouters.append(StorageRouter(storagerouter_guid)) else: storagerouters = StorageRouterList.get_storagerouters() for storagerouter in storagerouters: try: client = SSHClient(storagerouter, username='******') except UnableToConnectException: logger.info('Could not connect to StorageRouter {0}, skipping'.format(storagerouter.ip)) continue configuration = {} # Gather mount data mount_mapping = {} mount_data = client.run('mount') for mount in mount_data.splitlines(): mount = mount.strip() match = re.search('/dev/(.+?) on (/.*?) type.*', mount) if match is not None: mount_mapping[match.groups()[0]] = match.groups()[1] # Gather disk information with Remote(storagerouter.ip, [Context, os]) as remote: context = remote.Context() devices = [device for device in context.list_devices(subsystem='block') if 'ID_TYPE' in device and device['ID_TYPE'] == 'disk'] for device in devices: is_partition = device['DEVTYPE'] == 'partition' device_path = device['DEVNAME'] device_name = device_path.split('/')[-1] partition_id = None partition_name = None extended_parition_info = None if is_partition is True: if 'ID_PART_ENTRY_NUMBER' in device: extended_parition_info = True partition_id = device['ID_PART_ENTRY_NUMBER'] partition_name = device_name device_name = device_name[:0 - int(len(partition_id))] else: logger.debug('Partition {0} has no partition metadata'.format(device_path)) extended_parition_info = False match = re.match('^(\D+?)(\d+)$', device_name) if match is None: logger.debug('Could not handle disk/partition {0}'.format(device_path)) continue # Unable to handle this disk/partition partition_name = device_name partition_id = match.groups()[1] device_name = match.groups()[0] if device_name not in configuration: configuration[device_name] = {'partitions': {}} path = None for path_type in ['by-id', 'by-uuid']: if path is not None: break for item in device['DEVLINKS'].split(' '): if path_type in item: path = item if path is None: path = device_path sectors = int(client.run('cat /sys/block/{0}/size'.format(device_name))) sector_size = int(client.run('cat /sys/block/{0}/queue/hw_sector_size'.format(device_name))) rotational = int(client.run('cat /sys/block/{0}/queue/rotational'.format(device_name))) if is_partition is True: if 'ID_PART_ENTRY_TYPE' in device and device['ID_PART_ENTRY_TYPE'] == '0x5': continue # This is an extended partition, let's skip that one if extended_parition_info is True: offset = int(device['ID_PART_ENTRY_OFFSET']) * sector_size size = int(device['ID_PART_ENTRY_SIZE']) * sector_size else: match = re.match('^(\D+?)(\d+)$', device_path) if match is None: logger.debug('Could not handle disk/partition {0}'.format(device_path)) continue # Unable to handle this disk/partition fdisk_info = client.run('fdisk -l {0} | grep {1}'.format(match.groups()[0], device_path)).strip() fdisk_data = filter(None, fdisk_info.split(' ')) offset = int(fdisk_data[1]) * sector_size size = (int(fdisk_data[2]) - int(fdisk_data[1])) * sector_size configuration[device_name]['partitions'][partition_id] = {'offset': offset, 'size': size, 'path': path, 'state': 'OK'} partition_data = configuration[device_name]['partitions'][partition_id] if partition_name in mount_mapping: mountpoint = mount_mapping[partition_name] partition_data['mountpoint'] = mountpoint partition_data['inode'] = remote.os.stat(mountpoint).st_dev del mount_mapping[partition_name] try: client.run('touch {0}/{1}; rm {0}/{1}'.format(mountpoint, str(time.time()))) except CalledProcessError: partition_data['state'] = 'FAILURE' pass if 'ID_FS_TYPE' in device: partition_data['filesystem'] = device['ID_FS_TYPE'] else: configuration[device_name].update({'name': device_name, 'path': path, 'vendor': device['ID_VENDOR'] if 'ID_VENDOR' in device else None, 'model': device['ID_MODEL'] if 'ID_MODEL' in device else None, 'size': sector_size * sectors, 'is_ssd': rotational == 0, 'state': 'OK'}) for partition_name in mount_mapping: device_name = partition_name.split('/')[-1] match = re.search('^(\D+?)(\d+)$', device_name) if match is not None: device_name = match.groups()[0] partition_id = match.groups()[1] if device_name not in configuration: configuration[device_name] = {'partitions': {}, 'state': 'MISSING'} configuration[device_name]['partitions'][partition_id] = {'mountpoint': mount_mapping[partition_name], 'state': 'MISSING'} # Sync the model disk_names = [] for disk in storagerouter.disks: if disk.name not in configuration: for partition in disk.partitions: partition.delete() disk.delete() else: disk_names.append(disk.name) DiskController._update_disk(disk, configuration[disk.name]) partitions = [] partition_info = configuration[disk.name]['partitions'] for partition in disk.partitions: if partition.id not in partition_info: partition.delete() else: partitions.append(partition.id) DiskController._update_partition(partition, partition_info[partition.id]) for partition_id in partition_info: if partition_id not in partitions: DiskController._create_partition(partition_id, partition_info[partition_id], disk) for disk_name in configuration: if disk_name not in disk_names and configuration[disk_name]['state'] not in ['MISSING']: disk = Disk() disk.storagerouter = storagerouter disk.name = disk_name DiskController._update_disk(disk, configuration[disk_name]) partition_info = configuration[disk_name]['partitions'] for partition_id in partition_info: if partition_info[partition_id]['state'] not in ['MISSING']: DiskController._create_partition(partition_id, partition_info[partition_id], disk)