00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 import sys
00017
00018 try:
00019 from collections import OrderedDict
00020 except ImportError:
00021
00022 from ordereddict import OrderedDict
00023
00024 from datetime import datetime
00025
00026 from lsm import (size_bytes_2_size_human, LsmError, ErrorNumber,
00027 System, Pool, Disk, Volume, AccessGroup,
00028 FileSystem, FsSnapshot, NfsExport, TargetPort)
00029
00030 BIT_MAP_STRING_SPLITTER = ','
00031
00032
00033
00034
00035
00036
00037
00038 def out(msg):
00039 try:
00040 sys.stdout.write(str(msg))
00041 sys.stdout.write("\n")
00042 sys.stdout.flush()
00043 except IOError:
00044 sys.exit(1)
00045
00046
00047 def _bit_map_to_str(bit_map, conv_dict):
00048 rc = []
00049 bit_map = int(bit_map)
00050 for cur_enum in conv_dict.keys():
00051 if cur_enum & bit_map:
00052 rc.append(conv_dict[cur_enum])
00053
00054 if bit_map != 0 and len(rc) == 0:
00055 return 'Unknown(%s)' % hex(bit_map)
00056 return BIT_MAP_STRING_SPLITTER.join(rc)
00057
00058
00059 def _enum_type_to_str(int_type, conv_dict):
00060 rc = ''
00061 int_type = int(int_type)
00062
00063 if int_type in conv_dict.keys():
00064 return conv_dict[int_type]
00065 return 'Unknown(%d)' % int_type
00066
00067
00068 def _str_to_enum(type_str, conv_dict):
00069 keys = [k for k, v in conv_dict.items() if v.lower() == type_str.lower()]
00070 if len(keys) > 0:
00071 return keys[0]
00072 raise LsmError(ErrorNumber.INVALID_ARGUMENT,
00073 "Failed to convert %s to lsm type" % type_str)
00074
00075
00076 _SYSTEM_STATUS_CONV = {
00077 System.STATUS_UNKNOWN: 'Unknown',
00078 System.STATUS_OK: 'OK',
00079 System.STATUS_ERROR: 'Error',
00080 System.STATUS_DEGRADED: 'Degraded',
00081 System.STATUS_PREDICTIVE_FAILURE: 'Predictive failure',
00082 System.STATUS_OTHER: 'Other',
00083 }
00084
00085
00086 def system_status_to_str(system_status):
00087 return _bit_map_to_str(system_status, _SYSTEM_STATUS_CONV)
00088
00089
00090 _POOL_STATUS_CONV = {
00091 Pool.STATUS_UNKNOWN: 'Unknown',
00092 Pool.STATUS_OK: 'OK',
00093 Pool.STATUS_OTHER: 'Other',
00094 Pool.STATUS_DEGRADED: 'Degraded',
00095 Pool.STATUS_ERROR: 'Error',
00096 Pool.STATUS_STOPPED: 'Stopped',
00097 Pool.STATUS_RECONSTRUCTING: 'Reconstructing',
00098 Pool.STATUS_VERIFYING: 'Verifying',
00099 Pool.STATUS_INITIALIZING: 'Initializing',
00100 Pool.STATUS_GROWING: 'Growing',
00101 }
00102
00103
00104 def pool_status_to_str(pool_status):
00105 return _bit_map_to_str(pool_status, _POOL_STATUS_CONV)
00106
00107
00108 _POOL_ELEMENT_TYPE_CONV = {
00109 Pool.ELEMENT_TYPE_POOL: 'POOL',
00110 Pool.ELEMENT_TYPE_VOLUME: 'VOLUME',
00111 Pool.ELEMENT_TYPE_VOLUME_THIN: 'VOLUME_THIN',
00112 Pool.ELEMENT_TYPE_VOLUME_FULL: 'VOLUME_FULL',
00113 Pool.ELEMENT_TYPE_FS: 'FS',
00114 Pool.ELEMENT_TYPE_SYS_RESERVED: 'SYSTEM_RESERVED',
00115 Pool.ELEMENT_TYPE_DELTA: "DELTA",
00116 }
00117
00118 _POOL_UNSUPPORTED_ACTION_CONV = {
00119 Pool.UNSUPPORTED_VOLUME_GROW: "Volume Grow",
00120 Pool.UNSUPPORTED_VOLUME_SHRINK: "Volume Shrink"
00121 }
00122
00123
00124 def pool_element_type_to_str(element_type):
00125 return _bit_map_to_str(element_type, _POOL_ELEMENT_TYPE_CONV)
00126
00127
00128 def pool_unsupported_actions_to_str(unsupported_actions):
00129 return _bit_map_to_str(unsupported_actions, _POOL_UNSUPPORTED_ACTION_CONV)
00130
00131
00132 _VOL_PROVISION_CONV = {
00133 Volume.PROVISION_DEFAULT: 'DEFAULT',
00134 Volume.PROVISION_FULL: 'FULL',
00135 Volume.PROVISION_THIN: 'THIN',
00136 Volume.PROVISION_UNKNOWN: 'UNKNOWN',
00137 }
00138
00139
00140 def vol_provision_str_to_type(vol_provision_str):
00141 return _str_to_enum(vol_provision_str, _VOL_PROVISION_CONV)
00142
00143
00144 _VOL_ADMIN_STATE_CONV = {
00145 Volume.ADMIN_STATE_DISABLED: 'Yes',
00146 Volume.ADMIN_STATE_ENABLED: 'No',
00147 }
00148
00149
00150 def vol_admin_state_to_str(vol_admin_state):
00151 return _enum_type_to_str(vol_admin_state, _VOL_ADMIN_STATE_CONV)
00152
00153
00154 _VOL_REP_TYPE_CONV = {
00155 Volume.REPLICATE_CLONE: 'CLONE',
00156 Volume.REPLICATE_COPY: 'COPY',
00157 Volume.REPLICATE_MIRROR_SYNC: 'MIRROR_SYNC',
00158 Volume.REPLICATE_MIRROR_ASYNC: 'MIRROR_ASYNC',
00159 Volume.REPLICATE_UNKNOWN: 'UNKNOWN',
00160 }
00161
00162
00163 def vol_rep_type_str_to_type(vol_rep_type_str):
00164 return _str_to_enum(vol_rep_type_str, _VOL_REP_TYPE_CONV)
00165
00166
00167 _DISK_TYPE_CONV = {
00168 Disk.TYPE_UNKNOWN: 'UNKNOWN',
00169 Disk.TYPE_OTHER: 'Other',
00170 Disk.TYPE_ATA: 'ATA',
00171 Disk.TYPE_SATA: 'SATA',
00172 Disk.TYPE_SAS: 'SAS',
00173 Disk.TYPE_FC: 'FC',
00174 Disk.TYPE_SOP: 'SCSI Over PCI-E(SSD)',
00175 Disk.TYPE_SCSI: 'SCSI',
00176 Disk.TYPE_NL_SAS: 'NL_SAS',
00177 Disk.TYPE_HDD: 'HDD',
00178 Disk.TYPE_SSD: 'SSD',
00179 Disk.TYPE_HYBRID: 'Hybrid',
00180 Disk.TYPE_LUN: 'Remote LUN',
00181 }
00182
00183
00184 def disk_type_to_str(disk_type):
00185 return _enum_type_to_str(disk_type, _DISK_TYPE_CONV)
00186
00187
00188 _DISK_STATUS_CONV = {
00189 Disk.STATUS_UNKNOWN: 'Unknown',
00190 Disk.STATUS_OK: 'OK',
00191 Disk.STATUS_OTHER: 'Other',
00192 Disk.STATUS_PREDICTIVE_FAILURE: 'Predictive failure',
00193 Disk.STATUS_ERROR: 'Error',
00194 Disk.STATUS_REMOVED: 'Removed',
00195 Disk.STATUS_STARTING: 'Starting',
00196 Disk.STATUS_STOPPING: 'Stopping',
00197 Disk.STATUS_STOPPED: 'Stopped',
00198 Disk.STATUS_INITIALIZING: 'Initializing',
00199 Disk.STATUS_MAINTENANCE_MODE: 'Maintenance',
00200 Disk.STATUS_SPARE_DISK: 'Spare',
00201 Disk.STATUS_RECONSTRUCT: 'Reconstruct',
00202 Disk.STATUS_FREE: 'Free',
00203 }
00204
00205
00206 def disk_status_to_str(disk_status):
00207 return _bit_map_to_str(disk_status, _DISK_STATUS_CONV)
00208
00209
00210 _AG_INIT_TYPE_CONV = {
00211 AccessGroup.INIT_TYPE_UNKNOWN: 'Unknown',
00212 AccessGroup.INIT_TYPE_OTHER: 'Other',
00213 AccessGroup.INIT_TYPE_WWPN: 'WWPN',
00214 AccessGroup.INIT_TYPE_ISCSI_IQN: 'iSCSI',
00215 AccessGroup.INIT_TYPE_ISCSI_WWPN_MIXED: 'iSCSI/WWPN Mixed',
00216 }
00217
00218
00219 def ag_init_type_to_str(init_type):
00220 return _enum_type_to_str(init_type, _AG_INIT_TYPE_CONV)
00221
00222
00223 def ag_init_type_str_to_lsm(init_type_str):
00224 return _str_to_enum(init_type_str, _AG_INIT_TYPE_CONV)
00225
00226
00227 _TGT_PORT_TYPE_CONV = {
00228 TargetPort.TYPE_OTHER: 'Other',
00229 TargetPort.TYPE_FC: 'FC',
00230 TargetPort.TYPE_FCOE: 'FCoE',
00231 TargetPort.TYPE_ISCSI: 'iSCSI',
00232 }
00233
00234
00235 def tgt_port_type_to_str(port_type):
00236 return _enum_type_to_str(port_type, _TGT_PORT_TYPE_CONV)
00237
00238
00239 class PlugData(object):
00240 def __init__(self, description, plugin_version):
00241 self.desc = description
00242 self.version = plugin_version
00243
00244
00245 class VolumeRAIDInfo(object):
00246 _RAID_TYPE_MAP = {
00247 Volume.RAID_TYPE_RAID0: 'RAID0',
00248 Volume.RAID_TYPE_RAID1: 'RAID1',
00249 Volume.RAID_TYPE_RAID3: 'RAID3',
00250 Volume.RAID_TYPE_RAID4: 'RAID4',
00251 Volume.RAID_TYPE_RAID5: 'RAID5',
00252 Volume.RAID_TYPE_RAID6: 'RAID6',
00253 Volume.RAID_TYPE_RAID10: 'RAID10',
00254 Volume.RAID_TYPE_RAID15: 'RAID15',
00255 Volume.RAID_TYPE_RAID16: 'RAID16',
00256 Volume.RAID_TYPE_RAID50: 'RAID50',
00257 Volume.RAID_TYPE_RAID60: 'RAID60',
00258 Volume.RAID_TYPE_RAID51: 'RAID51',
00259 Volume.RAID_TYPE_RAID61: 'RAID61',
00260 Volume.RAID_TYPE_JBOD: 'JBOD',
00261 Volume.RAID_TYPE_MIXED: 'MIXED',
00262 Volume.RAID_TYPE_OTHER: 'OTHER',
00263 Volume.RAID_TYPE_UNKNOWN: 'UNKNOWN',
00264 }
00265
00266 VOL_CREATE_RAID_TYPES_STR = [
00267 'RAID0', 'RAID1', 'RAID5', 'RAID6', 'RAID10', 'RAID50', 'RAID60']
00268
00269 def __init__(self, vol_id, raid_type, strip_size, disk_count,
00270 min_io_size, opt_io_size):
00271 self.vol_id = vol_id
00272 self.raid_type = raid_type
00273 self.strip_size = strip_size
00274 self.disk_count = disk_count
00275 self.min_io_size = min_io_size
00276 self.opt_io_size = opt_io_size
00277
00278 @staticmethod
00279 def raid_type_to_str(raid_type):
00280 return _enum_type_to_str(raid_type, VolumeRAIDInfo._RAID_TYPE_MAP)
00281
00282 @staticmethod
00283 def raid_type_str_to_lsm(raid_type_str):
00284 return _str_to_enum(raid_type_str, VolumeRAIDInfo._RAID_TYPE_MAP)
00285
00286
00287 class PoolRAIDInfo(object):
00288 _MEMBER_TYPE_MAP = {
00289 Pool.MEMBER_TYPE_UNKNOWN: 'Unknown',
00290 Pool.MEMBER_TYPE_OTHER: 'Unknown',
00291 Pool.MEMBER_TYPE_POOL: 'Pool',
00292 Pool.MEMBER_TYPE_DISK: 'Disk',
00293 }
00294
00295 def __init__(self, pool_id, raid_type, member_type, member_ids):
00296 self.pool_id = pool_id
00297 self.raid_type = raid_type
00298 self.member_type = member_type
00299 self.member_ids = member_ids
00300
00301 @staticmethod
00302 def member_type_to_str(member_type):
00303 return _enum_type_to_str(
00304 member_type, PoolRAIDInfo._MEMBER_TYPE_MAP)
00305
00306
00307 class VcrCap(object):
00308 def __init__(self, system_id, raid_types, strip_sizes):
00309 self.system_id = system_id
00310 self.raid_types = raid_types
00311 self.strip_sizes = strip_sizes
00312
00313
00314 class DisplayData(object):
00315
00316 def __init__(self):
00317 pass
00318
00319 DISPLAY_WAY_COLUMN = 0
00320 DISPLAY_WAY_SCRIPT = 1
00321
00322 DISPLAY_WAY_DEFAULT = DISPLAY_WAY_COLUMN
00323
00324 DEFAULT_SPLITTER = ' | '
00325
00326 VALUE_CONVERT = {}
00327
00328
00329 SYSTEM_HEADER = OrderedDict()
00330 SYSTEM_HEADER['id'] = 'ID'
00331 SYSTEM_HEADER['name'] = 'Name'
00332 SYSTEM_HEADER['status'] = 'Status'
00333 SYSTEM_HEADER['status_info'] = 'Info'
00334
00335 SYSTEM_COLUMN_SKIP_KEYS = []
00336
00337
00338
00339 SYSTEM_VALUE_CONV_ENUM = {
00340 'status': system_status_to_str,
00341 }
00342
00343 SYSTEM_VALUE_CONV_HUMAN = []
00344
00345 VALUE_CONVERT[System] = {
00346 'headers': SYSTEM_HEADER,
00347 'column_skip_keys': SYSTEM_COLUMN_SKIP_KEYS,
00348 'value_conv_enum': SYSTEM_VALUE_CONV_ENUM,
00349 'value_conv_human': SYSTEM_VALUE_CONV_HUMAN,
00350 }
00351
00352 PLUG_DATA_HEADER = OrderedDict()
00353 PLUG_DATA_HEADER['desc'] = 'Description'
00354 PLUG_DATA_HEADER['version'] = 'Version'
00355
00356 PLUG_DATA_COLUMN_SKIP_KEYS = []
00357
00358 PLUG_DATA_VALUE_CONV_ENUM = {}
00359 PLUG_DATA_VALUE_CONV_HUMAN = []
00360
00361 VALUE_CONVERT[PlugData] = {
00362 'headers': PLUG_DATA_HEADER,
00363 'column_skip_keys': PLUG_DATA_COLUMN_SKIP_KEYS,
00364 'value_conv_enum': PLUG_DATA_VALUE_CONV_ENUM,
00365 'value_conv_human': PLUG_DATA_VALUE_CONV_HUMAN,
00366 }
00367
00368
00369 POOL_HEADER = OrderedDict()
00370 POOL_HEADER['id'] = 'ID'
00371 POOL_HEADER['name'] = 'Name'
00372 POOL_HEADER['element_type'] = 'Element Type'
00373 POOL_HEADER['unsupported_actions'] = 'Does not support'
00374 POOL_HEADER['total_space'] = 'Total Space'
00375 POOL_HEADER['free_space'] = 'Free Space'
00376 POOL_HEADER['status'] = 'Status'
00377 POOL_HEADER['status_info'] = 'Info'
00378 POOL_HEADER['system_id'] = 'System ID'
00379
00380 POOL_COLUMN_SKIP_KEYS = ['unsupported_actions']
00381
00382 POOL_VALUE_CONV_ENUM = {
00383 'status': pool_status_to_str,
00384 'element_type': pool_element_type_to_str,
00385 'unsupported_actions': pool_unsupported_actions_to_str
00386 }
00387
00388 POOL_VALUE_CONV_HUMAN = ['total_space', 'free_space']
00389
00390 VALUE_CONVERT[Pool] = {
00391 'headers': POOL_HEADER,
00392 'column_skip_keys': POOL_COLUMN_SKIP_KEYS,
00393 'value_conv_enum': POOL_VALUE_CONV_ENUM,
00394 'value_conv_human': POOL_VALUE_CONV_HUMAN,
00395 }
00396
00397
00398 VOL_HEADER = OrderedDict()
00399 VOL_HEADER['id'] = 'ID'
00400 VOL_HEADER['name'] = 'Name'
00401 VOL_HEADER['vpd83'] = 'SCSI VPD 0x83'
00402 VOL_HEADER['block_size'] = 'Block Size'
00403 VOL_HEADER['num_of_blocks'] = 'Block Count'
00404 VOL_HEADER['size_bytes'] = 'Size'
00405 VOL_HEADER['admin_state'] = 'Disabled'
00406 VOL_HEADER['pool_id'] = 'Pool ID'
00407 VOL_HEADER['system_id'] = 'System ID'
00408
00409 VOL_COLUMN_SKIP_KEYS = ['block_size', 'num_of_blocks']
00410
00411 VOL_VALUE_CONV_ENUM = {
00412 'admin_state': vol_admin_state_to_str
00413 }
00414
00415 VOL_VALUE_CONV_HUMAN = ['size_bytes', 'block_size']
00416
00417 VALUE_CONVERT[Volume] = {
00418 'headers': VOL_HEADER,
00419 'column_skip_keys': VOL_COLUMN_SKIP_KEYS,
00420 'value_conv_enum': VOL_VALUE_CONV_ENUM,
00421 'value_conv_human': VOL_VALUE_CONV_HUMAN,
00422 }
00423
00424
00425 DISK_HEADER = OrderedDict()
00426 DISK_HEADER['id'] = 'ID'
00427 DISK_HEADER['name'] = 'Name'
00428 DISK_HEADER['disk_type'] = 'Type'
00429 DISK_HEADER['block_size'] = 'Block Size'
00430 DISK_HEADER['num_of_blocks'] = 'Block Count'
00431 DISK_HEADER['size_bytes'] = 'Size'
00432 DISK_HEADER['status'] = 'Status'
00433 DISK_HEADER['system_id'] = 'System ID'
00434
00435 DISK_COLUMN_SKIP_KEYS = ['block_size', 'num_of_blocks']
00436
00437 DISK_VALUE_CONV_ENUM = {
00438 'status': disk_status_to_str,
00439 'disk_type': disk_type_to_str,
00440 }
00441
00442 DISK_VALUE_CONV_HUMAN = ['size_bytes', 'block_size']
00443
00444 VALUE_CONVERT[Disk] = {
00445 'headers': DISK_HEADER,
00446 'column_skip_keys': DISK_COLUMN_SKIP_KEYS,
00447 'value_conv_enum': DISK_VALUE_CONV_ENUM,
00448 'value_conv_human': DISK_VALUE_CONV_HUMAN,
00449 }
00450
00451
00452 AG_HEADER = OrderedDict()
00453 AG_HEADER['id'] = 'ID'
00454 AG_HEADER['name'] = 'Name'
00455 AG_HEADER['init_ids'] = 'Initiator IDs'
00456 AG_HEADER['init_type'] = 'Type'
00457 AG_HEADER['system_id'] = 'System ID'
00458
00459 AG_COLUMN_SKIP_KEYS = ['init_type']
00460
00461 AG_VALUE_CONV_ENUM = {
00462 'init_type': ag_init_type_to_str,
00463 }
00464
00465 AG_VALUE_CONV_HUMAN = []
00466
00467 VALUE_CONVERT[AccessGroup] = {
00468 'headers': AG_HEADER,
00469 'column_skip_keys': AG_COLUMN_SKIP_KEYS,
00470 'value_conv_enum': AG_VALUE_CONV_ENUM,
00471 'value_conv_human': AG_VALUE_CONV_HUMAN,
00472 }
00473
00474
00475 FS_HEADER = OrderedDict()
00476 FS_HEADER['id'] = 'ID'
00477 FS_HEADER['name'] = 'Name'
00478 FS_HEADER['total_space'] = 'Total Space'
00479 FS_HEADER['free_space'] = 'Free Space'
00480 FS_HEADER['pool_id'] = 'Pool ID'
00481 FS_HEADER['system_id'] = 'System ID'
00482
00483 FS_COLUMN_SKIP_KEYS = []
00484
00485 FS_VALUE_CONV_ENUM = {
00486 }
00487
00488 FS_VALUE_CONV_HUMAN = ['total_space', 'free_space']
00489
00490 VALUE_CONVERT[FileSystem] = {
00491 'headers': FS_HEADER,
00492 'column_skip_keys': FS_COLUMN_SKIP_KEYS,
00493 'value_conv_enum': FS_VALUE_CONV_ENUM,
00494 'value_conv_human': FS_VALUE_CONV_HUMAN,
00495 }
00496
00497
00498 FS_SNAP_HEADER = OrderedDict()
00499 FS_SNAP_HEADER['id'] = 'ID'
00500 FS_SNAP_HEADER['name'] = 'Name'
00501 FS_SNAP_HEADER['ts'] = 'Time Stamp'
00502
00503 FS_SNAP_COLUMN_SKIP_KEYS = []
00504
00505 FS_SNAP_VALUE_CONV_ENUM = {
00506 'ts': datetime.fromtimestamp
00507 }
00508
00509 FS_SNAP_VALUE_CONV_HUMAN = []
00510
00511 VALUE_CONVERT[FsSnapshot] = {
00512 'headers': FS_SNAP_HEADER,
00513 'column_skip_keys': FS_SNAP_COLUMN_SKIP_KEYS,
00514 'value_conv_enum': FS_SNAP_VALUE_CONV_ENUM,
00515 'value_conv_human': FS_SNAP_VALUE_CONV_HUMAN,
00516 }
00517
00518
00519 NFS_EXPORT_HEADER = OrderedDict()
00520 NFS_EXPORT_HEADER['id'] = 'ID'
00521 NFS_EXPORT_HEADER['fs_id'] = 'FileSystem ID'
00522 NFS_EXPORT_HEADER['export_path'] = 'Export Path'
00523 NFS_EXPORT_HEADER['auth'] = 'Auth Type'
00524 NFS_EXPORT_HEADER['root'] = 'Root Hosts'
00525 NFS_EXPORT_HEADER['rw'] = 'RW Hosts'
00526 NFS_EXPORT_HEADER['ro'] = 'RO Hosts'
00527 NFS_EXPORT_HEADER['anonuid'] = 'Anonymous UID'
00528 NFS_EXPORT_HEADER['anongid'] = 'Anonymous GID'
00529 NFS_EXPORT_HEADER['options'] = 'Options'
00530
00531 NFS_EXPORT_COLUMN_SKIP_KEYS = ['anonuid', 'anongid', 'auth']
00532
00533 NFS_EXPORT_VALUE_CONV_ENUM = {}
00534
00535 NFS_EXPORT_VALUE_CONV_HUMAN = []
00536
00537 VALUE_CONVERT[NfsExport] = {
00538 'headers': NFS_EXPORT_HEADER,
00539 'column_skip_keys': NFS_EXPORT_COLUMN_SKIP_KEYS,
00540 'value_conv_enum': NFS_EXPORT_VALUE_CONV_ENUM,
00541 'value_conv_human': NFS_EXPORT_VALUE_CONV_HUMAN,
00542 }
00543
00544
00545 TGT_PORT_HEADER = OrderedDict()
00546 TGT_PORT_HEADER['id'] = 'ID'
00547 TGT_PORT_HEADER['port_type'] = 'Type'
00548 TGT_PORT_HEADER['physical_name'] = 'Physical Name'
00549 TGT_PORT_HEADER['service_address'] = 'Address'
00550 TGT_PORT_HEADER['network_address'] = 'Network Address'
00551 TGT_PORT_HEADER['physical_address'] = 'Physical Address'
00552 TGT_PORT_HEADER['system_id'] = 'System ID'
00553
00554 TGT_PORT_COLUMN_SKIP_KEYS = ['physical_address', 'physical_name']
00555
00556 TGT_PORT_VALUE_CONV_ENUM = {
00557 'port_type': tgt_port_type_to_str,
00558 }
00559
00560 TGT_PORT_VALUE_CONV_HUMAN = []
00561
00562 VALUE_CONVERT[TargetPort] = {
00563 'headers': TGT_PORT_HEADER,
00564 'column_skip_keys': TGT_PORT_COLUMN_SKIP_KEYS,
00565 'value_conv_enum': TGT_PORT_VALUE_CONV_ENUM,
00566 'value_conv_human': TGT_PORT_VALUE_CONV_HUMAN,
00567 }
00568
00569 VOL_RAID_INFO_HEADER = OrderedDict()
00570 VOL_RAID_INFO_HEADER['vol_id'] = 'Volume ID'
00571 VOL_RAID_INFO_HEADER['raid_type'] = 'RAID Type'
00572 VOL_RAID_INFO_HEADER['strip_size'] = 'Strip Size'
00573 VOL_RAID_INFO_HEADER['disk_count'] = 'Disk Count'
00574 VOL_RAID_INFO_HEADER['min_io_size'] = 'Minimum I/O Size'
00575 VOL_RAID_INFO_HEADER['opt_io_size'] = 'Optimal I/O Size'
00576
00577 VOL_RAID_INFO_COLUMN_SKIP_KEYS = []
00578
00579 VOL_RAID_INFO_VALUE_CONV_ENUM = {
00580 'raid_type': VolumeRAIDInfo.raid_type_to_str,
00581 }
00582 VOL_RAID_INFO_VALUE_CONV_HUMAN = [
00583 'strip_size', 'min_io_size', 'opt_io_size']
00584
00585 VALUE_CONVERT[VolumeRAIDInfo] = {
00586 'headers': VOL_RAID_INFO_HEADER,
00587 'column_skip_keys': VOL_RAID_INFO_COLUMN_SKIP_KEYS,
00588 'value_conv_enum': VOL_RAID_INFO_VALUE_CONV_ENUM,
00589 'value_conv_human': VOL_RAID_INFO_VALUE_CONV_HUMAN,
00590 }
00591
00592 POOL_RAID_INFO_HEADER = OrderedDict()
00593 POOL_RAID_INFO_HEADER['pool_id'] = 'Pool ID'
00594 POOL_RAID_INFO_HEADER['raid_type'] = 'RAID Type'
00595 POOL_RAID_INFO_HEADER['member_type'] = 'Member Type'
00596 POOL_RAID_INFO_HEADER['member_ids'] = 'Member IDs'
00597
00598 POOL_RAID_INFO_COLUMN_SKIP_KEYS = []
00599
00600 POOL_RAID_INFO_VALUE_CONV_ENUM = {
00601 'raid_type': VolumeRAIDInfo.raid_type_to_str,
00602 'member_type': PoolRAIDInfo.member_type_to_str,
00603 }
00604 POOL_RAID_INFO_VALUE_CONV_HUMAN = []
00605
00606 VALUE_CONVERT[PoolRAIDInfo] = {
00607 'headers': POOL_RAID_INFO_HEADER,
00608 'column_skip_keys': POOL_RAID_INFO_COLUMN_SKIP_KEYS,
00609 'value_conv_enum': POOL_RAID_INFO_VALUE_CONV_ENUM,
00610 'value_conv_human': POOL_RAID_INFO_VALUE_CONV_HUMAN,
00611 }
00612
00613 VCR_CAP_HEADER = OrderedDict()
00614 VCR_CAP_HEADER['system_id'] = 'System ID'
00615 VCR_CAP_HEADER['raid_types'] = 'Supported RAID Types'
00616 VCR_CAP_HEADER['strip_sizes'] = 'Supported Strip Sizes'
00617
00618 VCR_CAP_COLUMN_SKIP_KEYS = []
00619
00620 VCR_CAP_VALUE_CONV_ENUM = {
00621 'raid_types': lambda i: [VolumeRAIDInfo.raid_type_to_str(x) for x in i]
00622 }
00623 VCR_CAP_VALUE_CONV_HUMAN = ['strip_sizes']
00624
00625 VALUE_CONVERT[VcrCap] = {
00626 'headers': VCR_CAP_HEADER,
00627 'column_skip_keys': VCR_CAP_COLUMN_SKIP_KEYS,
00628 'value_conv_enum': VCR_CAP_VALUE_CONV_ENUM,
00629 'value_conv_human': VCR_CAP_VALUE_CONV_HUMAN,
00630 }
00631
00632 @staticmethod
00633 def _get_man_pro_value(obj, key, value_conv_enum, value_conv_human,
00634 flag_human, flag_enum):
00635 value = getattr(obj, key)
00636 if not flag_enum:
00637 if key in value_conv_enum.keys():
00638 value = value_conv_enum[key](value)
00639 if flag_human:
00640 if key in value_conv_human:
00641 if type(value) is list:
00642 value = list(size_bytes_2_size_human(s) for s in value)
00643 else:
00644 value = size_bytes_2_size_human(value)
00645 return value
00646
00647 @staticmethod
00648 def _find_max_width(two_d_list, column_index):
00649 max_width = 1
00650 for row_index in range(0, len(two_d_list)):
00651 row_data = two_d_list[row_index]
00652 if len(row_data[column_index]) > max_width:
00653 max_width = len(row_data[column_index])
00654 return max_width
00655
00656 @staticmethod
00657 def _data_dict_gen(obj, flag_human, flag_enum, display_way,
00658 extra_properties=None, flag_dsp_all_data=False):
00659 data_dict = OrderedDict()
00660 value_convert = DisplayData.VALUE_CONVERT[type(obj)]
00661 headers = value_convert['headers']
00662 value_conv_enum = value_convert['value_conv_enum']
00663 value_conv_human = value_convert['value_conv_human']
00664
00665 if flag_dsp_all_data:
00666 display_way = DisplayData.DISPLAY_WAY_SCRIPT
00667
00668 display_keys = []
00669
00670 if display_way == DisplayData.DISPLAY_WAY_COLUMN:
00671 for key_name in headers.keys():
00672 if key_name not in value_convert['column_skip_keys']:
00673 display_keys.append(key_name)
00674 elif display_way == DisplayData.DISPLAY_WAY_SCRIPT:
00675 display_keys = headers.keys()
00676
00677 if extra_properties:
00678 for extra_key_name in extra_properties:
00679 if extra_key_name not in display_keys:
00680 display_keys.append(extra_key_name)
00681
00682 for key in display_keys:
00683 key_str = headers[key]
00684 value = DisplayData._get_man_pro_value(
00685 obj, key, value_conv_enum, value_conv_human, flag_human,
00686 flag_enum)
00687 data_dict[key_str] = value
00688
00689 return data_dict
00690
00691 @staticmethod
00692 def display_data(objs, display_way=None,
00693 flag_human=True, flag_enum=False,
00694 extra_properties=None,
00695 splitter=None,
00696 flag_with_header=True,
00697 flag_dsp_all_data=False):
00698 if len(objs) == 0:
00699 return None
00700
00701 if display_way is None:
00702 display_way = DisplayData.DISPLAY_WAY_DEFAULT
00703
00704 if splitter is None:
00705 splitter = DisplayData.DEFAULT_SPLITTER
00706
00707 data_dict_list = []
00708 if type(objs[0]) in DisplayData.VALUE_CONVERT.keys():
00709 for obj in objs:
00710 data_dict = DisplayData._data_dict_gen(
00711 obj, flag_human, flag_enum, display_way,
00712 extra_properties, flag_dsp_all_data)
00713 data_dict_list.extend([data_dict])
00714 else:
00715 return None
00716 if display_way == DisplayData.DISPLAY_WAY_SCRIPT:
00717 DisplayData.display_data_script_way(data_dict_list, splitter)
00718 elif display_way == DisplayData.DISPLAY_WAY_COLUMN:
00719 DisplayData._display_data_column_way(
00720 data_dict_list, splitter, flag_with_header)
00721 return True
00722
00723 @staticmethod
00724 def display_data_script_way(data_dict_list, splitter):
00725 key_column_width = 1
00726 value_column_width = 1
00727
00728 for data_dict in data_dict_list:
00729 for key_name in data_dict.keys():
00730
00731 cur_key_width = len(key_name)
00732 if cur_key_width > key_column_width:
00733 key_column_width = cur_key_width
00734
00735 cur_value = data_dict[key_name]
00736 cur_value_width = 0
00737 if isinstance(cur_value, list):
00738 if len(cur_value) == 0:
00739 continue
00740 cur_value_width = len(str(cur_value[0]))
00741 else:
00742 cur_value_width = len(str(cur_value))
00743 if cur_value_width > value_column_width:
00744 value_column_width = cur_value_width
00745
00746 row_format = '%%-%ds%s%%-%ds' % (key_column_width,
00747 splitter,
00748 value_column_width)
00749 sub_row_format = '%s%s%%-%ds' % (' ' * key_column_width,
00750 splitter,
00751 value_column_width)
00752 obj_splitter = '%s%s%s' % ('-' * key_column_width,
00753 '-' * len(splitter),
00754 '-' * value_column_width)
00755
00756 for data_dict in data_dict_list:
00757 out(obj_splitter)
00758 for key_name in data_dict:
00759 value = data_dict[key_name]
00760 if isinstance(value, list):
00761 flag_first_data = True
00762 for sub_value in value:
00763 if flag_first_data:
00764 out(row_format % (key_name, str(sub_value)))
00765 flag_first_data = False
00766 else:
00767 out(sub_row_format % str(sub_value))
00768 else:
00769 out(row_format % (key_name, str(value)))
00770 out(obj_splitter)
00771
00772 @staticmethod
00773 def _display_data_column_way(data_dict_list, splitter, flag_with_header):
00774 if len(data_dict_list) == 0:
00775 return
00776 two_d_list = []
00777
00778 item_count = len(data_dict_list[0].keys())
00779
00780
00781 row_width = 0
00782 for data_dict in data_dict_list:
00783 cur_max_wd = 0
00784 for key_name in data_dict.keys():
00785 if isinstance(data_dict[key_name], list):
00786 cur_row_width = len(data_dict[key_name])
00787 if cur_row_width > cur_max_wd:
00788 cur_max_wd = cur_row_width
00789 else:
00790 pass
00791 if cur_max_wd == 0:
00792 cur_max_wd = 1
00793 row_width += cur_max_wd
00794
00795 if flag_with_header:
00796
00797 row_width += 1
00798
00799
00800 for raw in range(0, row_width):
00801 new = []
00802 for column in range(0, item_count):
00803 new.append('')
00804 two_d_list.append(new)
00805
00806
00807 current_row_num = -1
00808 if flag_with_header:
00809 two_d_list[0] = data_dict_list[0].keys()
00810 current_row_num = 0
00811
00812
00813 for data_dict in data_dict_list:
00814 current_row_num += 1
00815 save_row_num = current_row_num
00816 values = data_dict.values()
00817 for index in range(0, len(values)):
00818 value = values[index]
00819 if isinstance(value, list):
00820 for sub_index in range(0, len(value)):
00821 tmp_row_num = save_row_num + sub_index
00822 two_d_list[tmp_row_num][index] = str(value[sub_index])
00823
00824 if save_row_num + len(value) > current_row_num:
00825 current_row_num = save_row_num + len(value) - 1
00826 else:
00827 two_d_list[save_row_num][index] = str(value)
00828
00829
00830 row_formats = []
00831 header_splitter = ''
00832 for column_index in range(0, len(two_d_list[0])):
00833 max_width = DisplayData._find_max_width(two_d_list, column_index)
00834 row_formats.extend(['%%-%ds' % max_width])
00835 header_splitter += '-' * max_width
00836 if column_index != (len(two_d_list[0]) - 1):
00837 header_splitter += '-' * len(splitter)
00838
00839 row_format = splitter.join(row_formats)
00840 for row_index in range(0, len(two_d_list)):
00841 out(row_format % tuple(two_d_list[row_index]))
00842 if row_index == 0 and flag_with_header:
00843 out(header_splitter)