示例#1
0
 def get_data_latest_timestamp(self, storage_id):
     archive_file_list = []
     try:
         tools = Tools()
         archive_name = self.navi_handler.create_archives(storage_id)
         LOG.info("Create archive_name: {}".format(archive_name))
         archive_file_list.append(archive_name)
         archive_name_infos = archive_name.split('.')
         file_path = '%s%s.csv' % (
             self.navi_handler.get_local_file_path(), archive_name_infos[0])
         resource_obj_name = ''
         collection_time = ''
         with open(file_path) as file:
             f_csv = csv.reader(file)
             next(f_csv)
             for row in f_csv:
                 if not resource_obj_name or resource_obj_name == row[0]:
                     resource_obj_name = row[0]
                     collection_time = row[1]
                 else:
                     break
             latest_time = tools.time_str_to_timestamp(collection_time,
                                                       consts.TIME_PATTERN)
     except Exception as err:
         err_msg = "Failed to get latest perf timestamp " \
                   "from VnxBlockStor: %s" % (six.text_type(err))
         LOG.error(err_msg)
         raise exception.InvalidResults(err_msg)
     finally:
         self._remove_archive_file(archive_file_list)
     return latest_time
示例#2
0
 def get_aggregate(self, storage_id):
     agg_list = []
     agg_info = self.ssh_pool.do_exec(
         constant.AGGREGATE_SHOW_DETAIL_COMMAND)
     agg_array = agg_info.split(constant.AGGREGATE_SPLIT_STR)
     agg_map = {}
     for agg in agg_array[1:]:
         Tools.split_value_map(agg, agg_map, split=':')
         status = constant.AGGREGATE_STATUS.get(agg_map['State'])
         pool_model = {
             'name':
             agg_map['e'],
             'storage_id':
             storage_id,
             'native_storage_pool_id':
             agg_map['UUIDString'],
             'description':
             '',
             'status':
             status,
             'storage_type':
             constants.StorageType.UNIFIED,
             'total_capacity':
             int(Tools.get_capacity_size(agg_map['Size'])),
             'used_capacity':
             int(Tools.get_capacity_size(agg_map['UsedSize'])),
             'free_capacity':
             int(Tools.get_capacity_size(agg_map['AvailableSize'])),
         }
         agg_list.append(pool_model)
     return agg_list
示例#3
0
 def get_pool(self, storage_id):
     pool_list = []
     pool_info = self.ssh_do_exec(constant.POOLS_SHOW_DETAIL_COMMAND)
     pool_map_list = []
     Tools.split_value_map_list(pool_info, pool_map_list, split=':')
     for pool_map in pool_map_list:
         if pool_map and 'StoragePoolName' in pool_map.keys():
             status = constants.StoragePoolStatus.ABNORMAL
             if pool_map['IsPoolHealthy?'] == 'true':
                 status = constants.StoragePoolStatus.NORMAL
             pool_model = {
                 'name':
                 pool_map['StoragePoolName'],
                 'storage_id':
                 storage_id,
                 'native_storage_pool_id':
                 pool_map['UUIDofStoragePool'],
                 'description':
                 None,
                 'status':
                 status,
                 'storage_type':
                 constants.StorageType.UNIFIED,
                 'total_capacity':
                 self.get_size(pool_map['StoragePoolTotalSize'], True),
                 'used_capacity':
                 self.get_size(pool_map['StoragePoolTotalSize'], True) -
                 self.get_size(pool_map['StoragePoolUsableSize'], True),
                 'free_capacity':
                 self.get_size(pool_map['StoragePoolUsableSize'], True)
             }
             pool_list.append(pool_model)
     return pool_list
示例#4
0
 def get_archive_file_name(self, storage_id):
     tools = Tools()
     create_time = tools.timestamp_to_time_str(
         time.time() * units.k, consts.ARCHIVE_FILE_NAME_TIME_PATTERN)
     archive_file_name = consts.ARCHIVE_FILE_NAME % (storage_id,
                                                     create_time)
     return archive_file_name
示例#5
0
 def _get_metric_model(self, metric_list, labels, metric_values, obj_cap,
                       resources_type):
     metric_model_list = []
     tools = Tools()
     for metric_name in (metric_list or []):
         values = {}
         obj_labels = copy.copy(labels)
         obj_labels['unit'] = obj_cap.get(metric_name).get('unit')
         for metric_value in metric_values:
             metric_value_infos = metric_value
             if not consts.METRIC_MAP.get(resources_type, {}).get(
                     metric_name):
                 continue
             value = metric_value_infos[
                 consts.METRIC_MAP.get(resources_type).get(metric_name)]
             if not value:
                 value = '0'
             collection_timestamp = tools.time_str_to_timestamp(
                 metric_value_infos[1], consts.TIME_PATTERN)
             collection_time_str = tools.timestamp_to_time_str(
                 collection_timestamp, consts.COLLECTION_TIME_PATTERN)
             collection_timestamp = tools.time_str_to_timestamp(
                 collection_time_str, consts.COLLECTION_TIME_PATTERN)
             if "iops" == obj_cap.get(metric_name).get('unit').lower():
                 value = int(float(value))
             else:
                 value = float('%.6f' % (float(value)))
             values[collection_timestamp] = value
         if values:
             metric_model = constants.metric_struct(name=metric_name,
                                                    labels=obj_labels,
                                                    values=values)
             metric_model_list.append(metric_model)
     return metric_model_list
示例#6
0
 def cli_log_to_list(self, resource_info):
     obj_list = []
     try:
         tools = Tools()
         # Filter log information for log codes 70-77
         pattern = re.compile(consts.LOG_FILTER_PATTERN)
         obj_infos = resource_info.split('\n')
         for obj_info in obj_infos:
             str_line = obj_info.strip()
             if str_line:
                 search_obj = pattern.search(str_line)
                 if search_obj:
                     str_line = str_line.replace(
                         'See alerts for details.', '')
                     str_infos = str_line.split(search_obj.group())
                     str_0 = str_infos[0].strip()
                     log_time = str_0[0:str_0.rindex(' ')]
                     event_code = search_obj.group() \
                         .replace('(', '').replace(')', '')
                     obj_model = {
                         'log_time': log_time,
                         'log_time_stamp': tools.time_str_to_timestamp(
                             log_time, consts.TIME_PATTERN),
                         'event_code': event_code,
                         'message': str_infos[1].strip()
                     }
                     obj_list.append(obj_model)
     except Exception as e:
         err_msg = "arrange log info error: %s", six.text_type(e)
         LOG.error(err_msg)
         raise exception.InvalidResults(err_msg)
     return obj_list
示例#7
0
 def list_filesystems(self, storage_id):
     try:
         fs_list = []
         fs_info = self.ssh_do_exec([constant.FS_INFO_COMMAND])
         fs_array = self.get_table_data(fs_info)
         status_info = self.ssh_do_exec([constant.FS_STATUS_COMMAND])
         status_array = self.get_table_data(status_info)
         status_map = {}
         for status in status_array:
             status_info = status.split()
             if len(status_info) > constant.FS_INDEX['status_len']:
                 status_map[status_info[constant.FS_INDEX['id_index']]] = \
                     [status_info[constant.FS_INDEX['pool_index']],
                      status_info[constant.FS_INDEX['status_index']]]
         for fs in fs_array:
             fs_info = list(filter(None, fs.split('  ')))
             if len(fs_info) > constant.FS_INDEX['detail_len']:
                 total_capacity = \
                     fs_info[constant.FS_INDEX['total_index']].replace(
                         ' ', '')
                 used_capacity = \
                     fs_info[constant.FS_INDEX['used_index']].replace(
                         ' ', '').split('(')[0]
                 free_capacity = \
                     fs_info[constant.FS_INDEX['free_index']].replace(
                         ' ', '').split('(')[0]
                 total_capacity = Tools.get_capacity_size(total_capacity)
                 used_capacity = Tools.get_capacity_size(used_capacity)
                 free_capacity = Tools.get_capacity_size(free_capacity)
                 volume_type = constants.VolumeType.THICK \
                     if fs_info[constant.FS_INDEX['type_index']] == 'No' \
                     else constants.VolumeType.THIN
                 pool_id = status_map.get(fs_info[0])[0] \
                     if status_map.get(fs_info[0]) else None
                 status = status_map.get(fs_info[0])[1] \
                     if status_map.get(fs_info[0]) else None
                 fs_model = {
                     'name': fs_info[1],
                     'storage_id': storage_id,
                     'native_filesystem_id': fs_info[1],
                     'native_pool_id': pool_id,
                     'status': constant.FS_STATUS_MAP[status],
                     'type': volume_type,
                     'total_capacity': total_capacity,
                     'used_capacity': used_capacity,
                     'free_capacity': free_capacity
                 }
                 fs_list.append(fs_model)
         return fs_list
     except exception.DelfinException as e:
         err_msg = "Failed to get filesystem from " \
                   "hitachi nas: %s" % (six.text_type(e.msg))
         LOG.error(err_msg)
         raise e
     except Exception as err:
         err_msg = "Failed to get filesystem from " \
                   "hitachi nas: %s" % (six.text_type(err))
         LOG.error(err_msg)
         raise exception.InvalidResults(err_msg)
示例#8
0
 def list_volumes(self, storage_id):
     try:
         volume_list = []
         volume_info = self.ssh_do_exec(constant.LUN_SHOW_DETAIL_COMMAND)
         fs_list = self.get_filesystems(storage_id)
         volume_map_list = []
         Tools.split_value_map_list(volume_info, volume_map_list, split=':')
         for volume_map in volume_map_list:
             if volume_map and 'LUNName' in volume_map.keys():
                 pool_id = None
                 status = 'normal' if volume_map['State'] == 'online' \
                     else 'offline'
                 for fs in fs_list:
                     if fs['name'] == volume_map['VolumeName']:
                         pool_id = fs['native_pool_id']
                 type = constants.VolumeType.THIN \
                     if volume_map['SpaceAllocation'] == 'enabled' \
                     else constants.VolumeType.THICK
                 volume_model = {
                     'name':
                     volume_map['LUNName'],
                     'storage_id':
                     storage_id,
                     'description':
                     None,
                     'status':
                     status,
                     'native_volume_id':
                     volume_map['SerialNumber'],
                     'native_storage_pool_id':
                     pool_id,
                     'wwn':
                     None,
                     'compressed':
                     None,
                     'deduplicated':
                     None,
                     'type':
                     type,
                     'total_capacity':
                     self.get_size(volume_map['LUNSize'], True),
                     'used_capacity':
                     self.get_size(volume_map['UsedSize'], True),
                     'free_capacity':
                     self.get_size(volume_map['LUNSize'], True) -
                     self.get_size(volume_map['UsedSize'], True)
                 }
                 volume_list.append(volume_model)
         return volume_list
     except exception.DelfinException as e:
         err_msg = "Failed to get storage volume from " \
                   "netapp cmode: %s" % (six.text_type(e))
         LOG.error(err_msg)
         raise e
     except Exception as err:
         err_msg = "Failed to get storage volume from " \
                   "netapp cmode: %s" % (six.text_type(err))
         LOG.error(err_msg)
         raise exception.InvalidResults(err_msg)
示例#9
0
 def get_storage(self):
     try:
         raw_capacity = total_capacity = used_capacity = free_capacity = 0
         controller_map_list = []
         system_info = self.ssh_do_exec(constant.CLUSTER_SHOW_COMMAND)
         version_info = self.ssh_do_exec(constant.VERSION_SHOW_COMMAND)
         status_info = self.ssh_do_exec(constant.STORAGE_STATUS_COMMAND)
         controller_info = self.ssh_do_exec(
             constant.CONTROLLER_SHOW_DETAIL_COMMAND)
         Tools.split_value_map_list(controller_info, controller_map_list,
                                    ":")
         version_array = version_info.split("\r\n")
         storage_version = ''
         for version in version_array:
             if 'NetApp' in version:
                 storage_version = version.split(":")
                 break
         status = self.get_table_data(status_info)
         status = constant.STORAGE_STATUS.get(status[0].split()[0])
         disk_list = self.get_disks(None)
         pool_list = self.list_storage_pools(None)
         storage_map_list = []
         Tools.split_value_map_list(system_info,
                                    storage_map_list,
                                    split=':')
         if len(storage_map_list) > 0:
             storage_map = storage_map_list[len(storage_map_list) - 1]
             controller_map = \
                 controller_map_list[len(controller_map_list) - 1]
             for disk in disk_list:
                 raw_capacity += disk['capacity']
             for pool in pool_list:
                 total_capacity += pool['total_capacity']
                 free_capacity += pool['free_capacity']
                 used_capacity += pool['used_capacity']
             storage_model = {
                 "name": storage_map['ClusterName'],
                 "vendor": constant.STORAGE_VENDOR,
                 "model": controller_map['Model'],
                 "status": status,
                 "serial_number": storage_map['ClusterSerialNumber'],
                 "firmware_version": storage_version[0],
                 "location": controller_map['Location'],
                 "total_capacity": total_capacity,
                 "raw_capacity": raw_capacity,
                 "used_capacity": used_capacity,
                 "free_capacity": free_capacity
             }
             return storage_model
     except exception.DelfinException as e:
         err_msg = "Failed to get storage from " \
                   "netapp cmode: %s" % (six.text_type(e.msg))
         LOG.error(err_msg)
         raise e
     except Exception as err:
         err_msg = "Failed to get storage from " \
                   "netapp cmode: %s" % (six.text_type(err))
         LOG.error(err_msg)
         raise exception.InvalidResults(err_msg)
示例#10
0
 def log_query_time_to_list(self, begin_timestamp, end_timestamp):
     tools = Tools()
     begin_time = tools.timestamp_to_time_str(begin_timestamp,
                                              consts.DATE_PATTERN)
     end_time = tools.timestamp_to_time_str(end_timestamp,
                                            consts.DATE_PATTERN)
     query_time_map = {'begin_time': begin_time, 'end_time': end_time}
     return query_time_map
示例#11
0
 def get_pool_metrics(self, start_time, end_time):
     start_time_str = Tools.timestamp_to_utc_time_str(
         start_time, consts.REST_COLLEC_TTIME_PATTERN)
     end_time_str = Tools.timestamp_to_utc_time_str(
         end_time, consts.REST_COLLEC_TTIME_PATTERN)
     url = RestHandler.REST_CPGSTATISTICS_URL % (
         start_time_str, end_time_str)
     rejson = self.get_resinfo_call(url, method='GET')
     return rejson
示例#12
0
 def handle_stats_filename(file_name, file_map):
     name_arr = file_name.split('_')
     file_type = '%s_%s_%s' % (name_arr[0], name_arr[1], name_arr[2])
     file_time = '20%s%s' % (name_arr[3], name_arr[4])
     time_pattern = '%Y%m%d%H%M%S'
     tools = Tools()
     occur_time = tools.time_str_to_timestamp(file_time, time_pattern)
     if file_map.get(file_type):
         file_map[file_type][occur_time] = file_name
     else:
         file_map[file_type] = {occur_time: file_name}
示例#13
0
 def get_pools_volumes(self, storage_id):
     volumes_list = []
     pool_list = cli_handler((constant.POOL_INFO_COMMAND % {
         'unit_name': self.storage_name
     }))
     pools_array = pool_list.split("\r\n")
     if len(pools_array) > 2:
         for pool in pools_array[2:]:
             pool_array = pool.split()
             pool_info = cli_handler(constant.POOL_DETAIL_INFO_COMMAND % {
                 'unit_name': self.storage_name,
                 'pool_no': pool_array[0]
             })
             volumes = pool_info.split("Logical Unit")
             if len(volumes) > 1:
                 volume_array = volumes[1].split('\r\n')
                 for volume_info in volume_array[3:]:
                     volume = volume_info.split()
                     if len(volume) > 9:
                         volume_model = {
                             'name':
                             volume[0],
                             'storage_id':
                             storage_id,
                             'description':
                             '',
                             'status':
                             constants.StoragePoolStatus.NORMAL
                             if volume[9] == 'normal' else
                             constants.StoragePoolStatus.ABNORMAL,
                             'native_volume_id':
                             volume[0],
                             'native_storage_pool_id':
                             pool_array[0],
                             'wwn':
                             '',
                             'compressed':
                             '',
                             'deduplicated':
                             '',
                             'type':
                             constants.VolumeType.THIN,
                             'total_capacity':
                             int(Tools.get_capacity_size(volume[1] + 'GB')),
                             'used_capacity':
                             int(Tools.get_capacity_size(volume[3] + 'GB')),
                             'free_capacity':
                             int(Tools.get_capacity_size(volume[1] + 'GB'))
                             -
                             int(Tools.get_capacity_size(volume[3] + 'GB'))
                         }
                         volumes_list.append(volume_model)
                 return volumes_list
示例#14
0
 def _get__archive_file(self, start_time, end_time):
     archive_file_list = []
     archives = self.navi_handler.get_archives()
     tools = Tools()
     for archive_info in (archives or []):
         collection_timestamp = tools.time_str_to_timestamp(
             archive_info.get('collection_time'), consts.TIME_PATTERN)
         if collection_timestamp > start_time:
             archive_file_list.append(archive_info.get('archive_name'))
         if collection_timestamp > end_time:
             break
     return archive_file_list
示例#15
0
 def get_disks(self, storage_id):
     disks_list = []
     physicals_list = []
     disks_info = self.ssh_do_exec(constant.DISK_SHOW_DETAIL_COMMAND)
     physicals_info = self.ssh_do_exec(constant.DISK_SHOW_PHYSICAL_COMMAND)
     error_disk = self.ssh_do_exec(constant.DISK_ERROR_COMMAND)
     error_disk_list = []
     error_disk_array = self.get_table_data(error_disk)
     for error_disk in error_disk_array:
         error_array = error_disk.split()
         if len(error_array) > 2:
             error_disk_list.append(error_array[0])
     disks_map_list = []
     physical_array = self.get_table_data(physicals_info)
     for physical in physical_array:
         physicals_list.append(physical.split())
     Tools.split_value_map_list(disks_info, disks_map_list, split=':')
     for disks_map in disks_map_list:
         if disks_map and 'Disk' in disks_map.keys():
             speed = physical_type = firmware = None
             logical_type = constant.DISK_LOGICAL. \
                 get(disks_map['ContainerType'])
             """Map disk physical information"""
             for physical_info in physicals_list:
                 if len(physical_info) > 6 and \
                         physical_info[0] == disks_map['Disk']:
                     physical_type = \
                         constant.DISK_TYPE.get(physical_info[1])
                     speed = physical_info[5] \
                         if physical_info[5] != '-' else 0
                     firmware = physical_info[4]
             status = constants.DiskStatus.NORMAL
             if disks_map['Disk'] in error_disk_list:
                 status = constants.DiskStatus.ABNORMAL
             disk_model = {
                 'name': disks_map['Disk'],
                 'storage_id': storage_id,
                 'native_disk_id': disks_map['Disk'],
                 'serial_number': disks_map['SerialNumber'],
                 'manufacturer': disks_map['Vendor'],
                 'model': disks_map['Model'],
                 'firmware': firmware,
                 'speed': speed,
                 'capacity': self.get_size(disks_map['PhysicalSize'], True),
                 'status': status,
                 'physical_type': physical_type,
                 'logical_type': logical_type,
                 'native_disk_group_id': disks_map['Aggregate'],
                 'location': None,
             }
             disks_list.append(disk_model)
     return disks_list
示例#16
0
    def list_qtrees(self, storage_id):
        try:
            qt_list = []
            qt_info = self.ssh_do_exec(constant.QTREE_SHOW_DETAIL_COMMAND)
            fs_info = self.ssh_do_exec(constant.FS_SHOW_DETAIL_COMMAND)
            fs_map_list = []
            qt_map_list = []
            Tools.split_value_map_list(fs_info, fs_map_list, split=':')
            Tools.split_value_map_list(qt_info, qt_map_list, split=':')
            for qt_map in qt_map_list:
                if qt_map and 'QtreeName' in qt_map.keys():
                    fs_id = self.get_fs_id(qt_map['VserverName'],
                                           qt_map['VolumeName'])
                    qtree_path = None
                    for fs_map in fs_map_list:
                        if fs_map and 'VserverName' in fs_map.keys() \
                                and fs_id == self.get_fs_id(
                                fs_map['VserverName'],
                                fs_map['VolumeName']) \
                                and fs_map['JunctionPath'] != '-':
                            qtree_path = fs_map['JunctionPath']
                            break
                    qt_id = self.get_qt_id(qt_map['VserverName'],
                                           qt_map['VolumeName'],
                                           qt_map['QtreeName'])
                    qtree_name = qt_map['QtreeName']
                    if qt_map['QtreeName'] and qtree_path:
                        qtree_path += '/' + qt_map['QtreeName']
                        qtree_path = qtree_path.replace('//', '/')
                    else:
                        qtree_name = qt_id
                    qt_model = {
                        'name': qtree_name,
                        'storage_id': storage_id,
                        'native_qtree_id': qt_id,
                        'path': qtree_path,
                        'native_filesystem_id': fs_id,
                        'security_mode': qt_map['SecurityStyle'],
                    }
                    qt_list.append(qt_model)
            return qt_list
        except exception.DelfinException as err:
            err_msg = "Failed to get storage qtrees from " \
                      "netapp cmode: %s" % (six.text_type(err))
            LOG.error(err_msg)
            raise err

        except Exception as err:
            err_msg = "Failed to get storage qtrees from " \
                      "netapp cmode: %s" % (six.text_type(err))
            LOG.error(err_msg)
            raise exception.InvalidResults(err_msg)
示例#17
0
 def get_raid_groups(self, storage_id):
     pool_list = []
     raid_group_map = {}
     raid_group_info = cli_handler((constant.RAIDGROUP_INFO_COMMAND % {
         'unit_name': self.storage_name
     }))
     raid_group_array = raid_group_info.split("\r\n")
     if len(raid_group_array) > 2:
         for raid_array in raid_group_array[2:]:
             raid_group = raid_array.split()
             if len(raid_group) > 2:
                 raid_detail = cli_handler(
                     constant.RAIDGROUP_DETAIL_INFO_COMMAND % {
                         'unit_name': self.storage_name,
                         'raidgroup_no': raid_group[0]
                     })
                 self.get_detail(raid_detail, raid_group_map, ":", True)
                 raid_group_model = {
                     'name':
                     raid_group_map['RAIDGroup'],
                     'storage_id':
                     storage_id,
                     'native_storage_pool_id':
                     raid_group_map['RAIDGroup'],
                     'description':
                     '',
                     'status':
                     constants.StoragePoolStatus.NORMAL
                     if raid_group_map['Status'] == 'Normal' else
                     constants.StoragePoolStatus.OFFLINE,
                     'storage_type':
                     constants.StorageType.BLOCK,
                     'subscribed_capacity':
                     '',
                     'total_capacity':
                     int(
                         Tools.get_capacity_size(
                             raid_group_map['TotalCapacity'])),
                     'used_capacity':
                     int(
                         Tools.get_capacity_size(
                             raid_group_map['TotalCapacity'])) - int(
                                 Tools.get_capacity_size(
                                     raid_group_map['FreeCapacity'])),
                     'free_capacity':
                     int(
                         Tools.get_capacity_size(
                             raid_group_map['FreeCapacity']))
                 }
                 pool_list.append(raid_group_model)
         return pool_list
示例#18
0
 def get_event(events_error_str, query_para):
     events_error_dict = dict()
     events_error_arr = events_error_str.split('\n')
     for events_error_row_str in events_error_arr:
         events_error_row_str = events_error_row_str.strip()
         reg = re.compile(r"(\d{4}-\d{1,2}-\d{1,2})")
         if not re.match(reg, events_error_row_str):
             continue
         error_description_dict = dict()
         time_stamp = Tools().time_str_to_timestamp(
             events_error_row_str[:consts.OCCUR_TIME_RANGE].strip(),
             consts.TIME_PATTERN)
         if query_para is not None:
             try:
                 if time_stamp is None or time_stamp \
                         < int(query_para.get('begin_time')) or \
                         time_stamp > int(query_para.get('end_time')):
                     continue
             except Exception as e:
                 LOG.error(e)
         severity = events_error_row_str[consts.SEVERITY_RANGE_BEGIN:consts.
                                         SEVERITY_RANGE_END].strip()
         code = events_error_row_str[consts.CODE_RANGE_BEGIN:consts.
                                     CODE_RANGE_END].strip()
         description = events_error_row_str[consts.DESCRIPTION_RANGE:] \
             .strip()
         key = '{}{}{}'.format(severity, code, description)
         if events_error_dict.get(key):
             continue
         error_description_dict['severity'] = severity
         error_description_dict['code'] = code
         error_description_dict['description'] = description
         error_description_dict['occur_time'] = time_stamp
         events_error_dict[key] = error_description_dict
     return events_error_dict
示例#19
0
 def analysis_sp_time(self, resource_info):
     system_time = 0
     try:
         tools = Tools()
         obj_infos = resource_info.split('\n')
         for obj_info in obj_infos:
             str_line = obj_info.strip()
             if "Time on SP A:" in str_line:
                 time_str = str_line.replace("Time on SP A:", "").strip()
                 system_time = tools.time_str_to_timestamp(
                     time_str, consts.GET_SP_TIME_PATTERN)
     except Exception as e:
         err_msg = "analysis sp time error: %s", six.text_type(e)
         LOG.error(err_msg)
         raise exception.InvalidResults(err_msg)
     return system_time
示例#20
0
 def _filter_performance_data(self, archive_file_list, resources_map,
                              start_time, end_time):
     performance_lines_map = {}
     try:
         tools = Tools()
         for archive_file in archive_file_list:
             self.navi_handler.download_archives(archive_file)
             archive_name_infos = archive_file.split('.')
             file_path = '%s%s.csv' % (
                 self.navi_handler.get_local_file_path(),
                 archive_name_infos[0])
             with open(file_path) as file:
                 f_csv = csv.reader(file)
                 next(f_csv)
                 for row in f_csv:
                     self._package_performance_data(row, resources_map,
                                                    start_time, end_time,
                                                    tools,
                                                    performance_lines_map)
     except Exception as err:
         err_msg = "Failed to filter performance data: %s" % \
                   (six.text_type(err))
         LOG.error(err_msg)
         raise exception.StorageBackendException(err_msg)
     return performance_lines_map
示例#21
0
 def list_controllers(self, context):
     controllers = self.cli_handler.get_controllers()
     controllers_status = self.cli_handler.common_data_encapsulation(
         consts.GET_STORAGE_CONTROLLER_STATUS)
     controller_list = []
     for controller in (controllers or []):
         name = controller.get('name')
         status = constants.ControllerStatus.FAULT
         if controllers_status and controllers_status.get(name):
             status_value = controllers_status.get(name)
             if status_value and \
                     consts.CONTROLLER_STATUS_NORMAL_KEY in status_value:
                 status = constants.ControllerStatus.NORMAL
         controller_model = {
             'name': controller.get('name'),
             'storage_id': self.storage_id,
             'native_controller_id': controller.get('Serial Number'),
             'status': status,
             'location': controller.get('name'),
             'soft_version': controller.get('Hard Revision'),
             'cpu_info': controller.get('CPU Clock'),
             'memory_size': str(int(
                 Tools.get_capacity_size(controller.get('Memory Size'))))
         }
         controller_list.append(controller_model)
     return controller_list
示例#22
0
 def get_disks(self, storage_id):
     disks_list = []
     physicals_list = []
     disks_info = self.ssh_pool.do_exec(constant.DISK_SHOW_DETAIL_COMMAND)
     disks_array = disks_info.split(constant.DISK_SPLIT_STR)
     physicals_info = self.ssh_pool.do_exec(
         constant.DISK_SHOW_PHYSICAL_COMMAND)
     disks_map = {}
     physical_array = physicals_info.split('\r\n')
     for i in range(2, len(physical_array), 2):
         physicals_list.append(physical_array[i].split())
     for disk_str in disks_array[1:]:
         speed = physical_type = firmware = None
         Tools.split_value_map(disk_str, disks_map, split=':')
         logical_type = constant.DISK_LOGICAL. \
             get(disks_map['ContainerType'])
         """Map disk physical information"""
         for physical_info in physicals_list:
             if len(physical_info) > 6 \
                     and physical_info[0] == disks_map['k']:
                 physical_type = constant.DISK_TYPE.get(physical_info[1])
                 speed = physical_info[5]
                 firmware = physical_info[4]
                 break
         status = constants.DiskStatus.ABNORMAL
         if disks_map['Errors:'] is None or disks_map['Errors:'] == "":
             status = constants.DiskStatus.NORMAL
         disk_model = {
             'name': disks_map['k'],
             'storage_id': storage_id,
             'native_disk_id': disks_map['k'],
             'serial_number': disks_map['SerialNumber'],
             'manufacturer': disks_map['Vendor'],
             'model': disks_map['Model'],
             'firmware': firmware,
             'speed': speed,
             'capacity':
             int(Tools.get_capacity_size(disks_map['PhysicalSize'])),
             'status': status,
             'physical_type': physical_type,
             'logical_type': logical_type,
             'health_score': '',
             'native_disk_group_id': disks_map['Aggregate'],
             'location': '',
         }
         disks_list.append(disk_model)
     return disks_list
示例#23
0
    def list_controllers(self, storage_id):
        try:
            controller_list = []
            controller_info = self.ssh_do_exec(
                constant.CONTROLLER_SHOW_DETAIL_COMMAND)
            controller_ips = self.ssh_do_exec(constant.CONTROLLER_IP_COMMAND)
            ips_array = self.get_table_data(controller_ips)
            ip_map = {}
            for ips in ips_array:
                ip_array = ips.split()
                if len(ip_array) == 4:
                    ip_map[ip_array[2]] = ip_array[3]
            controller_map_list = []
            Tools.split_value_map_list(controller_info,
                                       controller_map_list,
                                       split=':')
            for controller_map in controller_map_list:
                if controller_map and 'Node' in controller_map.keys():
                    status = constants.ControllerStatus.NORMAL \
                        if controller_map['Health'] == 'true' \
                        else constants.ControllerStatus.OFFLINE
                    controller_model = {
                        'name': controller_map['Node'],
                        'storage_id': storage_id,
                        'native_controller_id': controller_map['SystemID'],
                        'status': status,
                        'location': controller_map['Location'],
                        'soft_version': None,
                        'cpu_info': None,
                        'memory_size': None,
                        'mgmt_ip': ip_map.get(controller_map['Node'])
                    }
                    controller_list.append(controller_model)
            return controller_list
        except exception.DelfinException as e:
            err_msg = "Failed to get storage controllers from " \
                      "netapp cmode: %s" % (six.text_type(e))
            LOG.error(err_msg)
            raise e

        except Exception as err:
            err_msg = "Failed to get storage controllers from " \
                      "netapp cmode: %s" % (six.text_type(err))
            LOG.error(err_msg)
            raise exception.InvalidResults(err_msg)
示例#24
0
    def format_port_group(port_set_info, lif_info, storage_id):
        port_map_list, port_group_list = [], []
        lif_map_list, port_group_relation_list = [], []
        Tools.split_value_map_list(port_set_info, port_map_list, split=':')
        Tools.split_value_map_list(lif_info, lif_map_list, split=':')
        for port_map in port_map_list:
            if 'PortsetName' in port_map:
                port_group_id = "%s-%s-%s" % \
                                (port_map.get('VserverName'),
                                 port_map.get('PortsetName'),
                                 port_map.get('Protocol'))
                ports = \
                    port_map.get('LIFOrTPGName').replace(' ', '').split(',')
                ports_str = ''
                for lif_map in lif_map_list:
                    if 'LogicalInterfaceName' in lif_map:
                        if lif_map.get('LogicalInterfaceName') in ports:
                            port_id = "%s_%s" % \
                                      (lif_map['CurrentNode'],
                                       lif_map['CurrentPort'])
                            port_group_relation = {
                                'storage_id': storage_id,
                                'native_port_group_id': port_group_id,
                                'native_port_id': port_id
                            }
                            port_group_relation_list.append(
                                port_group_relation)
                            if ports_str:
                                ports_str = \
                                    "{0},{1}".format(ports_str, port_id)
                            else:
                                ports_str = "{0}".format(port_id)

                port_group_model = {
                    'native_port_group_id': port_group_id,
                    'name': port_map.get('PortsetName'),
                    'ports': ports_str,
                    'storage_id': storage_id,
                }
                port_group_list.append(port_group_model)
        result = {
            'port_groups': port_group_list,
            'port_grp_port_rels': port_group_relation_list
        }
        return result
示例#25
0
 def get_alerts(self, query_para):
     alert_list = []
     alert_info = self.ssh_do_exec(constant.ALTER_SHOW_DETAIL_COMMAND)
     alert_map_list = []
     Tools.split_value_map_list(alert_info, alert_map_list, True, split=':')
     for alert_map in alert_map_list:
         if alert_map and 'AlertID' in alert_map.keys():
             occur_time = int(
                 time.mktime(
                     time.strptime(alert_map['IndicationTime'],
                                   constant.ALTER_TIME_TYPE)))
             if not query_para or \
                     (int(query_para['begin_time'])
                      <= occur_time
                      <= int(query_para['end_time'])):
                 alert_model = {
                     'alert_id':
                     alert_map['AlertID'],
                     'alert_name':
                     alert_map['AlertID'],
                     'severity':
                     constant.ALERT_SEVERITY[
                         alert_map['PerceivedSeverity']],
                     'category':
                     constants.Category.FAULT,
                     'type':
                     constants.EventType.EQUIPMENT_ALARM,
                     'occur_time':
                     occur_time * 1000,
                     'description':
                     alert_map['Description'],
                     'sequence_number':
                     alert_map['AlertID'],
                     'match_key':
                     hashlib.md5((alert_map['AlertID'] + alert_map['Node'] +
                                  alert_map['AlertingResource']
                                  ).encode()).hexdigest(),
                     'resource_type':
                     constants.DEFAULT_RESOURCE_TYPE,
                     'location':
                     alert_map['ProbableCause'] + ':' +
                     alert_map['PossibleEffect']
                 }
                 alert_list.append(alert_model)
     return alert_list
示例#26
0
 def get_cifs_shares(self, storage_id, vserver_name, qtree_list,
                     protocol_map):
     shares_list = []
     share_info = self.ssh_do_exec(
         (constant.CIFS_SHARE_SHOW_DETAIL_COMMAND % {
             'vserver_name': vserver_name
         }))
     share_map_list = []
     Tools.split_value_map_list(share_info, share_map_list, split=':')
     for share_map in share_map_list:
         if share_map and 'VolumeName' in share_map.keys() and \
                 share_map['VolumeName'] != '-':
             protocol_str = protocol_map.get(share_map['Vserver'])
             fs_id = self.get_fs_id(share_map['Vserver'],
                                    share_map['VolumeName'])
             share_id = fs_id + '_' + share_map['Share'] + '_'
             qtree_id = None
             for qtree in qtree_list:
                 name_array = share_map['Path'].split('/')
                 if len(name_array) > 0:
                     qtree_name = name_array[len(name_array) - 1]
                     if qtree_name == share_map['VolumeName']:
                         qtree_name = ''
                     qt_id = self.get_qt_id(share_map['Vserver'],
                                            share_map['VolumeName'],
                                            qtree_name)
                 else:
                     break
                 if qtree['native_qtree_id'] == qt_id:
                     qtree_id = qt_id
                     break
             if constants.ShareProtocol.CIFS in protocol_str:
                 share = {
                     'name': share_map['Share'],
                     'storage_id': storage_id,
                     'native_share_id':
                     share_id + constants.ShareProtocol.CIFS,
                     'native_qtree_id': qtree_id,
                     'native_filesystem_id': fs_id,
                     'path': share_map['Path'],
                     'protocol': constants.ShareProtocol.CIFS
                 }
                 shares_list.append(share)
     return shares_list
 def get_unit_size(value, unit):
     if value is None:
         return None
     if value == '0' or value == 0:
         return 0
     unit_array = unit.split('/')
     capacity = Tools.change_capacity_to_bytes(unit_array[0])
     if capacity == 1:
         return value
     return round(int(value) / capacity, 3)
示例#28
0
 def get_latest_perf_timestamp(self):
     latest_time = 0
     stats_file_command = 'lsdumps -prefix /dumps/iostats'
     file_list = self.exec_ssh_command(stats_file_command)
     file_line = file_list.split('\n')
     for file in islice(file_line, 1, None):
         if file:
             file_arr = ' '.join(file.split()).split(' ')
             if len(file_arr) > 1:
                 file_name = file_arr[1]
                 name_arr = file_name.split('_')
                 file_time = '20%s%s' % (name_arr[3], name_arr[4])
                 time_pattern = '%Y%m%d%H%M%S'
                 tools = Tools()
                 occur_time = tools.time_str_to_timestamp(
                     file_time, time_pattern)
                 if latest_time < occur_time:
                     latest_time = occur_time
     return latest_time
示例#29
0
 def get_raid_group_volumes(self, storage_id):
     volumes_list = []
     volumes_info = cli_handler((constant.VOLUMES_INFO_COMMAND % {
         'unit_name': self.storage_name
     }))
     volumes_array = volumes_info.split("\r\n")
     if len(volumes_array) > 2:
         for volume_info in volumes_array[2:]:
             volume_array = volume_info.split()
             if len(volume_array) > 4 and volume_array[4] != 'N/A':
                 volume_model = {
                     'name':
                     volume_array[0],
                     'storage_id':
                     storage_id,
                     'description':
                     '',
                     'status':
                     constants.VolumeStatus.AVAILABLE if volume_array[13]
                     == 'normal' else constants.VolumeStatus.ERROR,
                     'native_volume_id':
                     volume_array[0],
                     'native_storage_pool_id':
                     volume_array[4],
                     'wwn':
                     '',
                     'compressed':
                     '',
                     'deduplicated':
                     '',
                     'type':
                     constants.VolumeType.THICK,
                     'total_capacity':
                     int(Tools.get_capacity_size(volume_array[1] + 'GB')),
                     'used_capacity':
                     int(Tools.get_capacity_size(volume_array[1] + 'GB')),
                     'free_capacity':
                     0
                 }
                 volumes_list.append(volume_model)
         return volumes_list
示例#30
0
    def get_events(self, query_para):
        event_list = []
        event_info = self.ssh_pool.do_exec(constant.EVENT_SHOW_DETAIL_COMMAND)
        event_array = event_info.split(constant.ALTER_SPLIT_STR)
        event_map = {}

        for event_str in event_array[1:]:
            Tools.split_value_map(event_str, event_map, split=':')
            occur_time = int(
                time.mktime(
                    time.strptime(event_map['Time'],
                                  constant.EVENT_TIME_TYPE)))
            if query_para is None or \
                    (query_para['begin_time']
                     <= occur_time
                     <= query_para['end_time']):
                alert_model = {
                    'alert_id':
                    event_map['Sequence#'],
                    'alert_name':
                    event_map['MessageName'],
                    'severity':
                    constants.Severity.CRITICAL,
                    'category':
                    constants.Category.EVENT,
                    'type':
                    constants.EventType.EQUIPMENT_ALARM,
                    'occur_time':
                    occur_time,
                    'description':
                    event_map['Event'],
                    'match_key':
                    hashlib.md5((event_map['Sequence#'] +
                                 str(occur_time)).encode()).hexdigest(),
                    'resource_type':
                    constants.DEFAULT_RESOURCE_TYPE,
                    'location':
                    event_map['Source']
                }
                event_list.append(alert_model)
        return event_list