def process(workbook: Any, contents: list) -> None:
"""Process Virtual Disks worksheet
:param workbook:
:param contents:
"""
worksheet_name = 'Virtual Disks'
worksheet = workbook.get_sheet_by_name(worksheet_name)
family_excel_header = ['FamilyName', 'OperationalState', 'TotalSnapshots']
host_excel_header = [
'FamilyName', 'AllocatedCapacity', 'HostName', 'HostOSMode'
]
FamilyTuple = namedtuple('FamilyTuple', family_excel_header)
HostTuple = namedtuple('HostTuple', host_excel_header)
build_header(worksheet, family_excel_header)
build_header(worksheet, host_excel_header, 'E')
family_header = ['familyname', 'operationalstate', 'totalsnapshots']
host_header = [
'familyname', 'allocatedcapacity', 'presentation/hostname',
'presentation/hostosmode'
]
family_data, host_data = [], [] # type: list, list
for content in contents:
doc = xmltodict.parse(content)
family_data += list(
ordered_jsons(search_tag_value(doc, 'object'), family_header))
raw_host_data = [
flatten_dict(det_dict)
for det_dict in search_tag_value(doc, 'object')
]
host_data += ordered_jsons(raw_host_data, host_header)
final_col, final_row = write_excel(family_data, worksheet, FamilyTuple,
'A')
sheet_process_output(worksheet, 'FamilyTable', 'Virtual Disks', final_col,
final_row)
final_col, final_row = write_excel(host_data, worksheet, HostTuple, 'E')
sheet_process_output(worksheet,
'HostTable',
'Virtual Disks',
final_col,
final_row,
start_col=ord('E'))
def process(workbook: Any, contents: list) -> None:
"""Process Disk Group worksheet
:param workbook:
:param contents:
"""
worksheet_name = 'Disk Group'
worksheet = workbook.get_sheet_by_name(worksheet_name)
disk_excel_header = [
'DiskGroupName', 'TotalDisks', 'DiskDriveType', 'RequestedSparePolicy',
'CurrentSparePolicy', 'TotalStorageSpaceGB', 'UsedStorageSpaceGB'
]
object_excel_header = [
'ObjectName', 'TotalUngroupedDisks', 'XMLCapacityGB'
]
DiskTuple = namedtuple('DiskTuple', disk_excel_header)
ObjectTuple = namedtuple('ObjectTuple', object_excel_header)
build_header(worksheet, disk_excel_header)
build_header(worksheet, object_excel_header, 'I')
disk_header = [
'diskgroupname', 'totaldisks', 'diskdrivetype', 'requestedsparepolicy',
'currentsparepolicy', 'totalstoragespacegb', 'usedstoragespacegb'
]
object_header = ['objectname', 'totalungroupeddisks', 'xmlcapacitygb']
disk_data, object_data = [], [] # type: list, list
for content in contents:
doc = xmltodict.parse(content)
disk_data += list(
ordered_jsons(search_tag_value(doc, 'object'), disk_header))
object_data += list(
ordered_jsons(search_tag_value(doc, 'object'), object_header))
final_col, final_row = write_excel(disk_data, worksheet, DiskTuple, 'A')
sheet_process_output(worksheet, 'DiskTable', 'Disk Group', final_col,
final_row)
final_col, final_row = write_excel(object_data, worksheet, ObjectTuple,
'I')
sheet_process_output(worksheet,
'ObjectTable',
'Disk Group',
final_col,
final_row,
start_col=ord('I'))
def process(workbook: Any, contents: list) -> None:
"""Process Hosts worksheet
:param workbook:
:param contents:
"""
worksheet_name = 'Hosts'
worksheet = workbook.get_sheet_by_name(worksheet_name)
host_excel_header = [
'HostName', 'OperationalState', 'OSMode', 'HostType', 'VirtualDiskName'
]
HostTuple = namedtuple('HostTuple', host_excel_header)
build_header(worksheet, host_excel_header)
host_header = [
'hostname', 'operationalstate', 'osmode', 'hosttype',
'presentation/virtualdiskname'
]
disk_data = [] # type: list
for content in contents:
doc = xmltodict.parse(content)
raw_disk_data = [
flatten_dict(det_dict)
for det_dict in search_tag_value(doc, 'object')
]
disk_data += ordered_jsons(raw_disk_data, host_header)
final_col, final_row = write_excel(disk_data, worksheet, HostTuple, 'A')
sheet_process_output(worksheet, 'HostsTable', 'Hosts', final_col,
final_row)
def process(workbook: Any, contents: list) -> None:
"""Process Storage Inventory worksheet
:param workbook:
:param contents:
"""
worksheet_name = 'Storage Inventory'
worksheet = workbook.get_sheet_by_name(worksheet_name)
system_excel_header = [
'SystemObjectName', 'SystemType', 'FirmwareVersion',
'TotalStorageSpace', 'AvailableStorageSpace', 'UsedStorageSpace'
]
SystemTuple = namedtuple('SystemTuple', system_excel_header)
build_header(worksheet, system_excel_header)
system_header = [
'objectname', 'systemtype', 'firmwareversion', 'totalstoragespace',
'availablestoragespace', 'usedstoragespace'
]
system_data = [] # type: list
for content in contents:
doc = xmltodict.parse(content)
system_data += list(
ordered_jsons(search_tag_value(doc, 'object'), system_header))
final_col, final_row = write_excel(system_data, worksheet, SystemTuple,
'A')
sheet_process_output(worksheet, 'SystemTable', 'Storage Inventory',
final_col, final_row)
def process(workbook: Any, contents: list) -> None:
"""Process Controller worksheet
:param workbook:
:param contents:
"""
worksheet_name = 'Disk Enclosure'
worksheet = workbook.get_sheet_by_name(worksheet_name)
excel_header = [
'Name', 'Type', 'DiskSlotType', 'Transport', 'ProductId',
'ProductNumber', 'DiskSlot'
]
RowTuple = namedtuple('RowTuple', excel_header)
build_header(worksheet, excel_header)
header = [
'objectname', 'objecttype', 'diskslottype', 'transport', 'productid',
'productnum', 'diskslot/name'
]
disk_data = [] # type: list
for content in contents:
doc = xmltodict.parse(content)
raw_disk_data = [
flatten_dict(det_dict)
for det_dict in search_tag_value(doc, 'object')
]
for main_dict in raw_disk_data:
entry = list(ordered_jsons([main_dict], ['diskslot']))
if entry:
main_dict['diskslot'] = merge_dicts(main_dict['diskslot'])
main_dict = flatten_dict(main_dict)
disk_data += ordered_jsons([main_dict], header)
final_col, final_row = write_excel(disk_data, worksheet, RowTuple, 'A')
sheet_process_output(worksheet, 'DiskEnclosureTable', 'DiskEnclosure',
final_col, final_row)
def process(workbook: Any, contents: list) -> None:
"""Process Disks worksheet
:param workbook:
:param contents:
"""
worksheet_name = 'Disks'
worksheet = workbook.get_sheet_by_name(worksheet_name)
disks_excel_header = [
'DiskName', 'OperationalState', 'EnclosureDiskBays', 'DiskBayNumber',
'ShelfNumber', 'DiskGroupName', 'DiskType', 'ModelNumber',
'FormattedCapacity', 'Occupancy'
]
HostTuple = namedtuple('HostTuple', disks_excel_header)
build_header(worksheet, disks_excel_header)
disks_header = [
'diskname', 'operationalstate', 'EnclosureDiskBays', 'diskbaynumber',
'shelfnumber', 'diskgroupname', 'disktype', 'modelnumber',
'formattedcapacity', 'occupancy'
]
disk_data = [] # type: list
for content in contents:
doc = xmltodict.parse(content)
raw_disk_data = [flatten_dict(det_dict)
for det_dict in search_tag_value(doc, 'object')]
disk_data += ordered_jsons(raw_disk_data, disks_header)
final_col, final_row = write_excel(disk_data, worksheet, HostTuple, 'A')
sheet_process_output(
worksheet,
'DisksTable',
'Disks',
final_col,
final_row)
def process(workbook: Workbook, content: tuple) -> None:
"""Process StorageArrayPivot worksheet
:param workbook:
:param content:
"""
worksheet_name = 'StorageArrayPivot'
worksheet = workbook.get_sheet_by_name(worksheet_name)
speed_header = [
'ArrayName', 'SumRegisteredInitiators',
'SumLoggedInInitiators', 'SumNotLoggedInInitiators'
]
model_header = ['ArrayModel', 'Count']
revision_header = ['Revision', 'Count']
SpeedTuple = namedtuple(
'RowTuple', speed_header) # pylint: disable=invalid-name
ModelTuple = namedtuple(
'RowTuple', model_header) # pylint: disable=invalid-name
RevisionTuple = namedtuple(
'RowTuple', model_header) # pylint: disable=invalid-name
build_header(worksheet, speed_header)
build_header(worksheet, model_header, 'F')
build_header(worksheet, revision_header, 'I')
speed_array_groups = groupby(itemgetter(6, 0), content[0])
speed_groups = groupby(itemgetter(0), speed_array_groups)
speed_rows, grand_total = [], [0, 0, 0] # type: list, list
for speed in speed_groups:
total_initiators = [0, 0, 0]
array_rows = []
for array in speed_groups[speed]:
array_initiators = list(zip(*speed_array_groups[array]))
row = [
array[1], sum(map(int, array_initiators[3])),
sum(map(int, array_initiators[4])),
sum(map(int, array_initiators[5]))
]
total_initiators = [x + y
for x, y in zip(total_initiators, row[1:])]
array_rows.append(map(str, row))
grand_total = [x + y for x, y in zip(grand_total, total_initiators)]
speed_rows += [[speed] + list(map(str, total_initiators)), *array_rows]
speed_rows += [['Grand Total'] + grand_total]
final_col, final_row = 0, 0
for row_n, row_tuple in enumerate(map(SpeedTuple._make, speed_rows), 2):
for col_n, col_value in \
enumerate(row_tuple._asdict().values(), ord('A')):
cell = worksheet['{}{}'.format(chr(col_n), row_n)]
col_value = str(col_value) \
if not isinstance(col_value, str) else col_value
cell.value = col_value
style_value_cell(cell)
if row_tuple.ArrayName \
in [sg for sg in speed_groups.keys()] + ['Grand Total']:
cell.font = Font(bold=True, size=11)
set_cell_to_number(cell)
final_col = col_n
final_row = row_n
sheet_process_output(
worksheet,
'StorageArrayPivotTable',
'StorageArrayPivot',
final_col,
final_row)
model_rows = [(key, len(val)) for key, val in content[1].items()]
model_rows.append(('Total', sum([row[1] for row in model_rows])))
final_col, final_row = write_excel(model_rows, worksheet, ModelTuple, 'F')
sheet_process_output(
worksheet,
'ModelTable',
'StorageArrayPivot',
final_col,
final_row,
start_col=ord('F'))
revision_rows = [(key, len(val)) for key, val in content[2].items()]
revision_rows.append(('Total', sum([row[1] for row in revision_rows])))
final_col, final_row = write_excel(
revision_rows, worksheet, RevisionTuple, 'I')
sheet_process_output(
worksheet,
'RevisionTable',
'StorageArrayPivot',
final_col,
final_row,
start_col=ord('I'))