From 449f766a2c81546369ebd6728210ff09a10d3791 Mon Sep 17 00:00:00 2001 From: "Joshua M. Boniface" Date: Sat, 7 Nov 2020 13:41:24 -0500 Subject: [PATCH] Lint: F821 undefined name 'zk_conn' Actually removes these entire sections of dead code; the daemon-common library does no formatting at all since it is no longer used by the CLI. --- daemon-common/ceph.py | 600 --------------------------------------- daemon-common/network.py | 318 --------------------- daemon-common/node.py | 212 -------------- daemon-common/vm.py | 266 ----------------- 4 files changed, 1396 deletions(-) diff --git a/daemon-common/ceph.py b/daemon-common/ceph.py index 6c7d0333..94db6d37 100644 --- a/daemon-common/ceph.py +++ b/daemon-common/ceph.py @@ -22,7 +22,6 @@ import os import re -import click import json import time import math @@ -169,10 +168,6 @@ def get_util(zk_conn): } return True, status_data -def format_raw_output(status_data): - click.echo('{bold}Ceph cluster {stype} (primary node {end}{blue}{primary}{end}{bold}){end}\n'.format(bold=ansiprint.bold(), end=ansiprint.end(), blue=ansiprint.blue(), stype=status_data['type'], primary=status_data['primary_node'])) - click.echo(status_data['ceph_data']) - click.echo('') # # OSD functions @@ -341,239 +336,6 @@ def get_list_osd(zk_conn, limit, is_fuzzy=True): return True, sorted(osd_list, key=lambda x: int(x['id'])) -def format_list_osd(osd_list): - osd_list_output = [] - - osd_id_length = 3 - osd_up_length = 4 - osd_in_length = 4 - osd_size_length = 5 - osd_weight_length = 3 - osd_reweight_length = 5 - osd_pgs_length = 4 - osd_node_length = 5 - osd_used_length = 5 - osd_free_length = 6 - osd_util_length = 6 - osd_var_length = 5 - osd_wrops_length = 4 - osd_wrdata_length = 5 - osd_rdops_length = 4 - osd_rddata_length = 5 - - for osd_information in osd_list: - try: - # If this happens, the node hasn't checked in fully yet, so just ignore it - if osd_information['stats']['node'] == '|': - continue - except KeyError: - continue - - # Deal with the size to human readable - osd_information['stats']['size'] = osd_information['stats']['kb'] * 1024 - for datatype in 'size', 'wr_data', 'rd_data': - databytes = osd_information['stats'][datatype] - databytes_formatted = format_bytes_tohuman(int(databytes)) - osd_information['stats'][datatype] = databytes_formatted - for datatype in 'wr_ops', 'rd_ops': - dataops = osd_information['stats'][datatype] - dataops_formatted = format_ops_tohuman(int(dataops)) - osd_information['stats'][datatype] = dataops_formatted - - # Set the OSD ID length - _osd_id_length = len(osd_information['id']) + 1 - if _osd_id_length > osd_id_length: - osd_id_length = _osd_id_length - - _osd_node_length = len(osd_information['stats']['node']) + 1 - if _osd_node_length > osd_node_length: - osd_node_length = _osd_node_length - - # Set the size and length - _osd_size_length = len(str(osd_information['stats']['size'])) + 1 - if _osd_size_length > osd_size_length: - osd_size_length = _osd_size_length - - # Set the weight and length - _osd_weight_length = len(str(osd_information['stats']['weight'])) + 1 - if _osd_weight_length > osd_weight_length: - osd_weight_length = _osd_weight_length - - # Set the reweight and length - _osd_reweight_length = len(str(osd_information['stats']['reweight'])) + 1 - if _osd_reweight_length > osd_reweight_length: - osd_reweight_length = _osd_reweight_length - - # Set the pgs and length - _osd_pgs_length = len(str(osd_information['stats']['pgs'])) + 1 - if _osd_pgs_length > osd_pgs_length: - osd_pgs_length = _osd_pgs_length - - # Set the used/available/utlization%/variance and lengths - _osd_used_length = len(osd_information['stats']['used']) + 1 - if _osd_used_length > osd_used_length: - osd_used_length = _osd_used_length - - _osd_free_length = len(osd_information['stats']['avail']) + 1 - if _osd_free_length > osd_free_length: - osd_free_length = _osd_free_length - - osd_util = round(osd_information['stats']['utilization'], 2) - _osd_util_length = len(str(osd_util)) + 1 - if _osd_util_length > osd_util_length: - osd_util_length = _osd_util_length - - osd_var = round(osd_information['stats']['var'], 2) - _osd_var_length = len(str(osd_var)) + 1 - if _osd_var_length > osd_var_length: - osd_var_length = _osd_var_length - - # Set the read/write IOPS/data and length - _osd_wrops_length = len(osd_information['stats']['wr_ops']) + 1 - if _osd_wrops_length > osd_wrops_length: - osd_wrops_length = _osd_wrops_length - - _osd_wrdata_length = len(osd_information['stats']['wr_data']) + 1 - if _osd_wrdata_length > osd_wrdata_length: - osd_wrdata_length = _osd_wrdata_length - - _osd_rdops_length = len(osd_information['stats']['rd_ops']) + 1 - if _osd_rdops_length > osd_rdops_length: - osd_rdops_length = _osd_rdops_length - - _osd_rddata_length = len(osd_information['stats']['rd_data']) + 1 - if _osd_rddata_length > osd_rddata_length: - osd_rddata_length = _osd_rddata_length - - # Format the output header - osd_list_output.append('{bold}\ -{osd_id: <{osd_id_length}} \ -{osd_node: <{osd_node_length}} \ -{osd_up: <{osd_up_length}} \ -{osd_in: <{osd_in_length}} \ -{osd_size: <{osd_size_length}} \ -{osd_pgs: <{osd_pgs_length}} \ -{osd_weight: <{osd_weight_length}} \ -{osd_reweight: <{osd_reweight_length}} \ -Sp: {osd_used: <{osd_used_length}} \ -{osd_free: <{osd_free_length}} \ -{osd_util: <{osd_util_length}} \ -{osd_var: <{osd_var_length}} \ -Rd: {osd_rdops: <{osd_rdops_length}} \ -{osd_rddata: <{osd_rddata_length}} \ -Wr: {osd_wrops: <{osd_wrops_length}} \ -{osd_wrdata: <{osd_wrdata_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - osd_id_length=osd_id_length, - osd_node_length=osd_node_length, - osd_up_length=osd_up_length, - osd_in_length=osd_in_length, - osd_size_length=osd_size_length, - osd_pgs_length=osd_pgs_length, - osd_weight_length=osd_weight_length, - osd_reweight_length=osd_reweight_length, - osd_used_length=osd_used_length, - osd_free_length=osd_free_length, - osd_util_length=osd_util_length, - osd_var_length=osd_var_length, - osd_wrops_length=osd_wrops_length, - osd_wrdata_length=osd_wrdata_length, - osd_rdops_length=osd_rdops_length, - osd_rddata_length=osd_rddata_length, - osd_id='ID', - osd_node='Node', - osd_up='Up', - osd_in='In', - osd_size='Size', - osd_pgs='PGs', - osd_weight='Wt', - osd_reweight='ReWt', - osd_used='Used', - osd_free='Free', - osd_util='Util%', - osd_var='Var', - osd_wrops='OPS', - osd_wrdata='Data', - osd_rdops='OPS', - osd_rddata='Data' - ) - ) - - for osd_information in osd_list: - try: - # If this happens, the node hasn't checked in fully yet, so just ignore it - if osd_information['stats']['node'] == '|': - continue - except KeyError: - continue - - osd_up_flag, osd_up_colour, osd_in_flag, osd_in_colour = getOutputColoursOSD(osd_information) - osd_util = round(osd_information['stats']['utilization'], 2) - osd_var = round(osd_information['stats']['var'], 2) - - # Format the output header - osd_list_output.append('{bold}\ -{osd_id: <{osd_id_length}} \ -{osd_node: <{osd_node_length}} \ -{osd_up_colour}{osd_up: <{osd_up_length}}{end_colour} \ -{osd_in_colour}{osd_in: <{osd_in_length}}{end_colour} \ -{osd_size: <{osd_size_length}} \ -{osd_pgs: <{osd_pgs_length}} \ -{osd_weight: <{osd_weight_length}} \ -{osd_reweight: <{osd_reweight_length}} \ - {osd_used: <{osd_used_length}} \ -{osd_free: <{osd_free_length}} \ -{osd_util: <{osd_util_length}} \ -{osd_var: <{osd_var_length}} \ - {osd_rdops: <{osd_rdops_length}} \ -{osd_rddata: <{osd_rddata_length}} \ - {osd_wrops: <{osd_wrops_length}} \ -{osd_wrdata: <{osd_wrdata_length}} \ -{end_bold}'.format( - bold='', - end_bold='', - end_colour=ansiprint.end(), - osd_id_length=osd_id_length, - osd_node_length=osd_node_length, - osd_up_length=osd_up_length, - osd_in_length=osd_in_length, - osd_size_length=osd_size_length, - osd_pgs_length=osd_pgs_length, - osd_weight_length=osd_weight_length, - osd_reweight_length=osd_reweight_length, - osd_used_length=osd_used_length, - osd_free_length=osd_free_length, - osd_util_length=osd_util_length, - osd_var_length=osd_var_length, - osd_wrops_length=osd_wrops_length, - osd_wrdata_length=osd_wrdata_length, - osd_rdops_length=osd_rdops_length, - osd_rddata_length=osd_rddata_length, - osd_id=osd_information['id'], - osd_node=osd_information['stats']['node'], - osd_up_colour=osd_up_colour, - osd_up=osd_up_flag, - osd_in_colour=osd_in_colour, - osd_in=osd_in_flag, - osd_size=osd_information['stats']['size'], - osd_pgs=osd_information['stats']['pgs'], - osd_weight=osd_information['stats']['weight'], - osd_reweight=osd_information['stats']['reweight'], - osd_used=osd_information['stats']['used'], - osd_free=osd_information['stats']['avail'], - osd_util=osd_util, - osd_var=osd_var, - osd_wrops=osd_information['stats']['wr_ops'], - osd_wrdata=osd_information['stats']['wr_data'], - osd_rdops=osd_information['stats']['rd_ops'], - osd_rddata=osd_information['stats']['rd_data'] - ) - ) - - click.echo('\n'.join(sorted(osd_list_output))) - # # Pool functions @@ -671,197 +433,6 @@ def get_list_pool(zk_conn, limit, is_fuzzy=True): return True, sorted(pool_list, key=lambda x: int(x['stats']['id'])) -def format_list_pool(pool_list): - pool_list_output = [] - - pool_name_length = 5 - pool_id_length = 3 - pool_used_length = 5 - pool_usedpct_length = 5 - pool_free_length = 5 - pool_num_objects_length = 6 - pool_num_clones_length = 7 - pool_num_copies_length = 7 - pool_num_degraded_length = 9 - pool_read_ops_length = 4 - pool_read_data_length = 5 - pool_write_ops_length = 4 - pool_write_data_length = 5 - - for pool_information in pool_list: - # Deal with the size to human readable - for datatype in ['free_bytes', 'used_bytes', 'write_bytes', 'read_bytes']: - databytes = pool_information['stats'][datatype] - databytes_formatted = format_bytes_tohuman(int(databytes)) - pool_information['stats'][datatype] = databytes_formatted - for datatype in ['write_ops', 'read_ops']: - dataops = pool_information['stats'][datatype] - dataops_formatted = format_ops_tohuman(int(dataops)) - pool_information['stats'][datatype] = dataops_formatted - for datatype in ['used_percent']: - datapct = pool_information['stats'][datatype] - datapct_formatted = format_pct_tohuman(float(datapct)) - pool_information['stats'][datatype] = datapct_formatted - - # Set the Pool name length - _pool_name_length = len(pool_information['name']) + 1 - if _pool_name_length > pool_name_length: - pool_name_length = _pool_name_length - - # Set the id and length - _pool_id_length = len(str(pool_information['stats']['id'])) + 1 - if _pool_id_length > pool_id_length: - pool_id_length = _pool_id_length - - # Set the used and length - _pool_used_length = len(str(pool_information['stats']['used_bytes'])) + 1 - if _pool_used_length > pool_used_length: - pool_used_length = _pool_used_length - - # Set the usedpct and length - _pool_usedpct_length = len(str(pool_information['stats']['used_percent'])) + 1 - if _pool_usedpct_length > pool_usedpct_length: - pool_usedpct_length = _pool_usedpct_length - - # Set the free and length - _pool_free_length = len(str(pool_information['stats']['free_bytes'])) + 1 - if _pool_free_length > pool_free_length: - pool_free_length = _pool_free_length - - # Set the num_objects and length - _pool_num_objects_length = len(str(pool_information['stats']['num_objects'])) + 1 - if _pool_num_objects_length > pool_num_objects_length: - pool_num_objects_length = _pool_num_objects_length - - # Set the num_clones and length - _pool_num_clones_length = len(str(pool_information['stats']['num_object_clones'])) + 1 - if _pool_num_clones_length > pool_num_clones_length: - pool_num_clones_length = _pool_num_clones_length - - # Set the num_copies and length - _pool_num_copies_length = len(str(pool_information['stats']['num_object_copies'])) + 1 - if _pool_num_copies_length > pool_num_copies_length: - pool_num_copies_length = _pool_num_copies_length - - # Set the num_degraded and length - _pool_num_degraded_length = len(str(pool_information['stats']['num_objects_degraded'])) + 1 - if _pool_num_degraded_length > pool_num_degraded_length: - pool_num_degraded_length = _pool_num_degraded_length - - # Set the read/write IOPS/data and length - _pool_write_ops_length = len(str(pool_information['stats']['write_ops'])) + 1 - if _pool_write_ops_length > pool_write_ops_length: - pool_write_ops_length = _pool_write_ops_length - - _pool_write_data_length = len(pool_information['stats']['write_bytes']) + 1 - if _pool_write_data_length > pool_write_data_length: - pool_write_data_length = _pool_write_data_length - - _pool_read_ops_length = len(str(pool_information['stats']['read_ops'])) + 1 - if _pool_read_ops_length > pool_read_ops_length: - pool_read_ops_length = _pool_read_ops_length - - _pool_read_data_length = len(pool_information['stats']['read_bytes']) + 1 - if _pool_read_data_length > pool_read_data_length: - pool_read_data_length = _pool_read_data_length - - # Format the output header - pool_list_output.append('{bold}\ -{pool_id: <{pool_id_length}} \ -{pool_name: <{pool_name_length}} \ -{pool_used: <{pool_used_length}} \ -{pool_usedpct: <{pool_usedpct_length}} \ -{pool_free: <{pool_free_length}} \ -Obj: {pool_objects: <{pool_objects_length}} \ -{pool_clones: <{pool_clones_length}} \ -{pool_copies: <{pool_copies_length}} \ -{pool_degraded: <{pool_degraded_length}} \ -Rd: {pool_read_ops: <{pool_read_ops_length}} \ -{pool_read_data: <{pool_read_data_length}} \ -Wr: {pool_write_ops: <{pool_write_ops_length}} \ -{pool_write_data: <{pool_write_data_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - pool_id_length=pool_id_length, - pool_name_length=pool_name_length, - pool_used_length=pool_used_length, - pool_usedpct_length=pool_usedpct_length, - pool_free_length=pool_free_length, - pool_objects_length=pool_num_objects_length, - pool_clones_length=pool_num_clones_length, - pool_copies_length=pool_num_copies_length, - pool_degraded_length=pool_num_degraded_length, - pool_write_ops_length=pool_write_ops_length, - pool_write_data_length=pool_write_data_length, - pool_read_ops_length=pool_read_ops_length, - pool_read_data_length=pool_read_data_length, - pool_id='ID', - pool_name='Name', - pool_used='Used', - pool_usedpct='%', - pool_free='Free', - pool_objects='Count', - pool_clones='Clones', - pool_copies='Copies', - pool_degraded='Degraded', - pool_write_ops='OPS', - pool_write_data='Data', - pool_read_ops='OPS', - pool_read_data='Data' - ) - ) - - for pool_information in pool_list: - # Format the output header - pool_list_output.append('{bold}\ -{pool_id: <{pool_id_length}} \ -{pool_name: <{pool_name_length}} \ -{pool_used: <{pool_used_length}} \ -{pool_usedpct: <{pool_usedpct_length}} \ -{pool_free: <{pool_free_length}} \ - {pool_objects: <{pool_objects_length}} \ -{pool_clones: <{pool_clones_length}} \ -{pool_copies: <{pool_copies_length}} \ -{pool_degraded: <{pool_degraded_length}} \ - {pool_read_ops: <{pool_read_ops_length}} \ -{pool_read_data: <{pool_read_data_length}} \ - {pool_write_ops: <{pool_write_ops_length}} \ -{pool_write_data: <{pool_write_data_length}} \ -{end_bold}'.format( - bold='', - end_bold='', - pool_id_length=pool_id_length, - pool_name_length=pool_name_length, - pool_used_length=pool_used_length, - pool_usedpct_length=pool_usedpct_length, - pool_free_length=pool_free_length, - pool_objects_length=pool_num_objects_length, - pool_clones_length=pool_num_clones_length, - pool_copies_length=pool_num_copies_length, - pool_degraded_length=pool_num_degraded_length, - pool_write_ops_length=pool_write_ops_length, - pool_write_data_length=pool_write_data_length, - pool_read_ops_length=pool_read_ops_length, - pool_read_data_length=pool_read_data_length, - pool_id=pool_information['stats']['id'], - pool_name=pool_information['name'], - pool_used=pool_information['stats']['used_bytes'], - pool_usedpct=pool_information['stats']['used_percent'], - pool_free=pool_information['stats']['free_bytes'], - pool_objects=pool_information['stats']['num_objects'], - pool_clones=pool_information['stats']['num_object_clones'], - pool_copies=pool_information['stats']['num_object_copies'], - pool_degraded=pool_information['stats']['num_objects_degraded'], - pool_write_ops=pool_information['stats']['write_ops'], - pool_write_data=pool_information['stats']['write_bytes'], - pool_read_ops=pool_information['stats']['read_ops'], - pool_read_data=pool_information['stats']['read_bytes'] - ) - ) - - click.echo('\n'.join(sorted(pool_list_output))) - # # Volume functions @@ -1090,113 +661,6 @@ def get_list_volume(zk_conn, pool, limit, is_fuzzy=True): return True, sorted(volume_list, key=lambda x: str(x['name'])) -def format_list_volume(volume_list): - volume_list_output = [] - - volume_name_length = 5 - volume_pool_length = 5 - volume_size_length = 5 - volume_objects_length = 8 - volume_order_length = 6 - volume_format_length = 7 - volume_features_length = 10 - - for volume_information in volume_list: - # Set the Volume name length - _volume_name_length = len(volume_information['name']) + 1 - if _volume_name_length > volume_name_length: - volume_name_length = _volume_name_length - - # Set the Volume pool length - _volume_pool_length = len(volume_information['pool']) + 1 - if _volume_pool_length > volume_pool_length: - volume_pool_length = _volume_pool_length - - # Set the size and length - _volume_size_length = len(str(volume_information['stats']['size'])) + 1 - if _volume_size_length > volume_size_length: - volume_size_length = _volume_size_length - - # Set the num_objects and length - _volume_objects_length = len(str(volume_information['stats']['objects'])) + 1 - if _volume_objects_length > volume_objects_length: - volume_objects_length = _volume_objects_length - - # Set the order and length - _volume_order_length = len(str(volume_information['stats']['order'])) + 1 - if _volume_order_length > volume_order_length: - volume_order_length = _volume_order_length - - # Set the format and length - _volume_format_length = len(str(volume_information['stats']['format'])) + 1 - if _volume_format_length > volume_format_length: - volume_format_length = _volume_format_length - - # Set the features and length - _volume_features_length = len(str(','.join(volume_information['stats']['features']))) + 1 - if _volume_features_length > volume_features_length: - volume_features_length = _volume_features_length - - # Format the output header - volume_list_output.append('{bold}\ -{volume_name: <{volume_name_length}} \ -{volume_pool: <{volume_pool_length}} \ -{volume_size: <{volume_size_length}} \ -{volume_objects: <{volume_objects_length}} \ -{volume_order: <{volume_order_length}} \ -{volume_format: <{volume_format_length}} \ -{volume_features: <{volume_features_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - volume_name_length=volume_name_length, - volume_pool_length=volume_pool_length, - volume_size_length=volume_size_length, - volume_objects_length=volume_objects_length, - volume_order_length=volume_order_length, - volume_format_length=volume_format_length, - volume_features_length=volume_features_length, - volume_name='Name', - volume_pool='Pool', - volume_size='Size', - volume_objects='Objects', - volume_order='Order', - volume_format='Format', - volume_features='Features', - ) - ) - - for volume_information in volume_list: - volume_list_output.append('{bold}\ -{volume_name: <{volume_name_length}} \ -{volume_pool: <{volume_pool_length}} \ -{volume_size: <{volume_size_length}} \ -{volume_objects: <{volume_objects_length}} \ -{volume_order: <{volume_order_length}} \ -{volume_format: <{volume_format_length}} \ -{volume_features: <{volume_features_length}} \ -{end_bold}'.format( - bold='', - end_bold='', - volume_name_length=volume_name_length, - volume_pool_length=volume_pool_length, - volume_size_length=volume_size_length, - volume_objects_length=volume_objects_length, - volume_order_length=volume_order_length, - volume_format_length=volume_format_length, - volume_features_length=volume_features_length, - volume_name=volume_information['name'], - volume_pool=volume_information['pool'], - volume_size=volume_information['stats']['size'], - volume_objects=volume_information['stats']['objects'], - volume_order=volume_information['stats']['order'], - volume_format=volume_information['stats']['format'], - volume_features=','.join(volume_information['stats']['features']), - ) - ) - - click.echo('\n'.join(sorted(volume_list_output))) - # # Snapshot functions @@ -1300,67 +764,3 @@ def get_list_snapshot(zk_conn, pool, volume, limit, is_fuzzy=True): snapshot_list.append({'pool': pool_name, 'volume': volume_name, 'snapshot': snapshot_name}) return True, sorted(snapshot_list, key=lambda x: int(x['id'])) - -def format_list_snapshot(snapshot_list): - snapshot_list_output = [] - - snapshot_name_length = 5 - snapshot_volume_length = 7 - snapshot_pool_length = 5 - - for snapshot in snapshot_list: - volume, snapshot_name = snapshot.split('@') - snapshot_pool, snapshot_volume = volume.split('/') - - # Set the Snapshot name length - _snapshot_name_length = len(snapshot_name) + 1 - if _snapshot_name_length > snapshot_name_length: - snapshot_name_length = _snapshot_name_length - - # Set the Snapshot volume length - _snapshot_volume_length = len(snapshot_volume) + 1 - if _snapshot_volume_length > snapshot_volume_length: - snapshot_volume_length = _snapshot_volume_length - - # Set the Snapshot pool length - _snapshot_pool_length = len(snapshot_pool) + 1 - if _snapshot_pool_length > snapshot_pool_length: - snapshot_pool_length = _snapshot_pool_length - - # Format the output header - snapshot_list_output.append('{bold}\ -{snapshot_name: <{snapshot_name_length}} \ -{snapshot_volume: <{snapshot_volume_length}} \ -{snapshot_pool: <{snapshot_pool_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - snapshot_name_length=snapshot_name_length, - snapshot_volume_length=snapshot_volume_length, - snapshot_pool_length=snapshot_pool_length, - snapshot_name='Name', - snapshot_volume='Volume', - snapshot_pool='Pool', - ) - ) - - for snapshot in snapshot_list: - volume, snapshot_name = snapshot.split('@') - snapshot_pool, snapshot_volume = volume.split('/') - snapshot_list_output.append('{bold}\ -{snapshot_name: <{snapshot_name_length}} \ -{snapshot_volume: <{snapshot_volume_length}} \ -{snapshot_pool: <{snapshot_pool_length}} \ -{end_bold}'.format( - bold='', - end_bold='', - snapshot_name_length=snapshot_name_length, - snapshot_volume_length=snapshot_volume_length, - snapshot_pool_length=snapshot_pool_length, - snapshot_name=snapshot_name, - snapshot_volume=snapshot_volume, - snapshot_pool=snapshot_pool, - ) - ) - - click.echo('\n'.join(sorted(snapshot_list_output))) diff --git a/daemon-common/network.py b/daemon-common/network.py index 3055de49..22f2695b 100644 --- a/daemon-common/network.py +++ b/daemon-common/network.py @@ -21,7 +21,6 @@ ############################################################################### import re -import click from kazoo.exceptions import NoNodeError @@ -618,320 +617,3 @@ def get_list_acl(zk_conn, network, limit, direction, is_fuzzy=True): acl_list.append(acl) return True, acl_list - -# CLI-only functions -def getOutputColours(network_information): - if network_information['ip6']['network'] != "None": - v6_flag_colour = ansiprint.green() - else: - v6_flag_colour = ansiprint.blue() - if network_information['ip4']['network'] != "None": - v4_flag_colour = ansiprint.green() - else: - v4_flag_colour = ansiprint.blue() - - if network_information['ip6']['dhcp_flag'] == "True": - dhcp6_flag_colour = ansiprint.green() - else: - dhcp6_flag_colour = ansiprint.blue() - if network_information['ip4']['dhcp_flag'] == "True": - dhcp4_flag_colour = ansiprint.green() - else: - dhcp4_flag_colour = ansiprint.blue() - - return v6_flag_colour, v4_flag_colour, dhcp6_flag_colour, dhcp4_flag_colour - -def format_info(network_information, long_output): - if not network_information: - click.echo("No network found") - return - - v6_flag_colour, v4_flag_colour, dhcp6_flag_colour, dhcp4_flag_colour = getOutputColours(network_information) - - # Format a nice output: do this line-by-line then concat the elements at the end - ainformation = [] - ainformation.append('{}Virtual network information:{}'.format(ansiprint.bold(), ansiprint.end())) - ainformation.append('') - # Basic information - ainformation.append('{}VNI:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['vni'])) - ainformation.append('{}Type:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['type'])) - ainformation.append('{}Description:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['description'])) - if network_information['type'] == 'managed': - ainformation.append('{}Domain:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['domain'])) - ainformation.append('{}DNS Servers:{} {}'.format(ansiprint.purple(), ansiprint.end(), ', '.join(network_information['name_servers']))) - if network_information['ip6']['network'] != "None": - ainformation.append('') - ainformation.append('{}IPv6 network:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['ip6']['network'])) - ainformation.append('{}IPv6 gateway:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['ip6']['gateway'])) - ainformation.append('{}DHCPv6 enabled:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), dhcp6_flag_colour, network_information['ip6']['dhcp_flag'], ansiprint.end())) - if network_information['ip4']['network'] != "None": - ainformation.append('') - ainformation.append('{}IPv4 network:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['ip4']['network'])) - ainformation.append('{}IPv4 gateway:{} {}'.format(ansiprint.purple(), ansiprint.end(), network_information['ip4']['gateway'])) - ainformation.append('{}DHCPv4 enabled:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), dhcp4_flag_colour, network_information['ip4']['dhcp_flag'], ansiprint.end())) - if network_information['ip4']['dhcp_flag'] == "True": - ainformation.append('{}DHCPv4 range:{} {} - {}'.format(ansiprint.purple(), ansiprint.end(), network_information['ip4']['dhcp_start'], network_information['ip4']['dhcp_end'])) - - if long_output: - dhcp4_reservations_list = getNetworkDHCPReservations(zk_conn, vni) - if dhcp4_reservations_list: - ainformation.append('') - ainformation.append('{}Client DHCPv4 reservations:{}'.format(ansiprint.bold(), ansiprint.end())) - ainformation.append('') - # Only show static reservations in the detailed information - dhcp4_reservations_string = formatDHCPLeaseList(zk_conn, vni, dhcp4_reservations_list, reservations=True) - for line in dhcp4_reservations_string.split('\n'): - ainformation.append(line) - - firewall_rules = zkhandler.listchildren(zk_conn, '/networks/{}/firewall_rules'.format(vni)) - if firewall_rules: - ainformation.append('') - ainformation.append('{}Network firewall rules:{}'.format(ansiprint.bold(), ansiprint.end())) - ainformation.append('') - formatted_firewall_rules = get_list_firewall_rules(zk_conn, vni) - for rule in formatted_firewall_rules: - ainformation.append(rule) - - # Join it all together - click.echo('\n'.join(ainformation)) - -def format_list(network_list): - if not network_list: - click.echo("No network found") - return - - network_list_output = [] - - # Determine optimal column widths - net_vni_length = 5 - net_description_length = 12 - net_nettype_length = 8 - net_domain_length = 6 - net_v6_flag_length = 6 - net_dhcp6_flag_length = 7 - net_v4_flag_length = 6 - net_dhcp4_flag_length = 7 - for network_information in network_list: - # vni column - _net_vni_length = len(str(network_information['vni'])) + 1 - if _net_vni_length > net_vni_length: - net_vni_length = _net_vni_length - # description column - _net_description_length = len(network_information['description']) + 1 - if _net_description_length > net_description_length: - net_description_length = _net_description_length - # domain column - _net_domain_length = len(network_information['domain']) + 1 - if _net_domain_length > net_domain_length: - net_domain_length = _net_domain_length - - # Format the string (header) - network_list_output.append('{bold}\ -{net_vni: <{net_vni_length}} \ -{net_description: <{net_description_length}} \ -{net_nettype: <{net_nettype_length}} \ -{net_domain: <{net_domain_length}} \ -{net_v6_flag: <{net_v6_flag_length}} \ -{net_dhcp6_flag: <{net_dhcp6_flag_length}} \ -{net_v4_flag: <{net_v4_flag_length}} \ -{net_dhcp4_flag: <{net_dhcp4_flag_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - net_vni_length=net_vni_length, - net_description_length=net_description_length, - net_nettype_length=net_nettype_length, - net_domain_length=net_domain_length, - net_v6_flag_length=net_v6_flag_length, - net_dhcp6_flag_length=net_dhcp6_flag_length, - net_v4_flag_length=net_v4_flag_length, - net_dhcp4_flag_length=net_dhcp4_flag_length, - net_vni='VNI', - net_description='Description', - net_nettype='Type', - net_domain='Domain', - net_v6_flag='IPv6', - net_dhcp6_flag='DHCPv6', - net_v4_flag='IPv4', - net_dhcp4_flag='DHCPv4', - ) - ) - - for network_information in network_list: - v6_flag_colour, v4_flag_colour, dhcp6_flag_colour, dhcp4_flag_colour = getOutputColours(network_information) - if network_information['ip4']['network'] != "None": - v4_flag = 'True' - else: - v4_flag = 'False' - - if network_information['ip6']['network'] != "None": - v6_flag = 'True' - else: - v6_flag = 'False' - - network_list_output.append( - '{bold}\ -{net_vni: <{net_vni_length}} \ -{net_description: <{net_description_length}} \ -{net_nettype: <{net_nettype_length}} \ -{net_domain: <{net_domain_length}} \ -{v6_flag_colour}{net_v6_flag: <{net_v6_flag_length}}{colour_off} \ -{dhcp6_flag_colour}{net_dhcp6_flag: <{net_dhcp6_flag_length}}{colour_off} \ -{v4_flag_colour}{net_v4_flag: <{net_v4_flag_length}}{colour_off} \ -{dhcp4_flag_colour}{net_dhcp4_flag: <{net_dhcp4_flag_length}}{colour_off} \ -{end_bold}'.format( - bold='', - end_bold='', - net_vni_length=net_vni_length, - net_description_length=net_description_length, - net_nettype_length=net_nettype_length, - net_domain_length=net_domain_length, - net_v6_flag_length=net_v6_flag_length, - net_dhcp6_flag_length=net_dhcp6_flag_length, - net_v4_flag_length=net_v4_flag_length, - net_dhcp4_flag_length=net_dhcp4_flag_length, - net_vni=network_information['vni'], - net_description=network_information['description'], - net_nettype=network_information['type'], - net_domain=network_information['domain'], - net_v6_flag=v6_flag, - v6_flag_colour=v6_flag_colour, - net_dhcp6_flag=network_information['ip6']['dhcp_flag'], - dhcp6_flag_colour=dhcp6_flag_colour, - net_v4_flag=v4_flag, - v4_flag_colour=v4_flag_colour, - net_dhcp4_flag=network_information['ip4']['dhcp_flag'], - dhcp4_flag_colour=dhcp4_flag_colour, - colour_off=ansiprint.end() - ) - ) - - click.echo('\n'.join(sorted(network_list_output))) - -def format_list_dhcp(dhcp_lease_list): - dhcp_lease_list_output = [] - - # Determine optimal column widths - lease_hostname_length = 9 - lease_ip4_address_length = 11 - lease_mac_address_length = 13 - lease_timestamp_length = 13 - for dhcp_lease_information in dhcp_lease_list: - # hostname column - _lease_hostname_length = len(dhcp_lease_information['hostname']) + 1 - if _lease_hostname_length > lease_hostname_length: - lease_hostname_length = _lease_hostname_length - # ip4_address column - _lease_ip4_address_length = len(dhcp_lease_information['ip4_address']) + 1 - if _lease_ip4_address_length > lease_ip4_address_length: - lease_ip4_address_length = _lease_ip4_address_length - # mac_address column - _lease_mac_address_length = len(dhcp_lease_information['mac_address']) + 1 - if _lease_mac_address_length > lease_mac_address_length: - lease_mac_address_length = _lease_mac_address_length - - # Format the string (header) - dhcp_lease_list_output.append('{bold}\ -{lease_hostname: <{lease_hostname_length}} \ -{lease_ip4_address: <{lease_ip4_address_length}} \ -{lease_mac_address: <{lease_mac_address_length}} \ -{lease_timestamp: <{lease_timestamp_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - lease_hostname_length=lease_hostname_length, - lease_ip4_address_length=lease_ip4_address_length, - lease_mac_address_length=lease_mac_address_length, - lease_timestamp_length=lease_timestamp_length, - lease_hostname='Hostname', - lease_ip4_address='IP Address', - lease_mac_address='MAC Address', - lease_timestamp='Timestamp' - ) - ) - - for dhcp_lease_information in dhcp_lease_list: - dhcp_lease_list_output.append('{bold}\ -{lease_hostname: <{lease_hostname_length}} \ -{lease_ip4_address: <{lease_ip4_address_length}} \ -{lease_mac_address: <{lease_mac_address_length}} \ -{lease_timestamp: <{lease_timestamp_length}} \ -{end_bold}'.format( - bold='', - end_bold='', - lease_hostname_length=lease_hostname_length, - lease_ip4_address_length=lease_ip4_address_length, - lease_mac_address_length=lease_mac_address_length, - lease_timestamp_length=12, - lease_hostname=dhcp_lease_information['hostname'], - lease_ip4_address=dhcp_lease_information['ip4_address'], - lease_mac_address=dhcp_lease_information['mac_address'], - lease_timestamp=dhcp_lease_information['timestamp'] - ) - ) - - click.echo('\n'.join(sorted(dhcp_lease_list_output))) - -def format_list_acl(acl_list): - acl_list_output = [] - - # Determine optimal column widths - acl_direction_length = 10 - acl_order_length = 6 - acl_description_length = 12 - acl_rule_length = 5 - for acl_information in acl_list: - # order column - _acl_order_length = len(str(acl_information['order'])) + 1 - if _acl_order_length > acl_order_length: - acl_order_length = _acl_order_length - # description column - _acl_description_length = len(acl_information['description']) + 1 - if _acl_description_length > acl_description_length: - acl_description_length = _acl_description_length - # rule column - _acl_rule_length = len(acl_information['rule']) + 1 - if _acl_rule_length > acl_rule_length: - acl_rule_length = _acl_rule_length - - # Format the string (header) - acl_list_output.append('{bold}\ -{acl_direction: <{acl_direction_length}} \ -{acl_order: <{acl_order_length}} \ -{acl_description: <{acl_description_length}} \ -{acl_rule: <{acl_rule_length}} \ -{end_bold}'.format( - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - acl_direction_length=acl_direction_length, - acl_order_length=acl_order_length, - acl_description_length=acl_description_length, - acl_rule_length=acl_rule_length, - acl_direction='Direction', - acl_order='Order', - acl_description='Description', - acl_rule='Rule', - ) - ) - - for acl_information in acl_list: - acl_list_output.append('{bold}\ -{acl_direction: <{acl_direction_length}} \ -{acl_order: <{acl_order_length}} \ -{acl_description: <{acl_description_length}} \ -{acl_rule: <{acl_rule_length}} \ -{end_bold}'.format( - bold='', - end_bold='', - acl_direction_length=acl_direction_length, - acl_order_length=acl_order_length, - acl_description_length=acl_description_length, - acl_rule_length=acl_rule_length, - acl_direction=acl_information['direction'], - acl_order=acl_information['order'], - acl_description=acl_information['description'], - acl_rule=acl_information['rule'], - ) - ) - - click.echo('\n'.join(sorted(acl_list_output))) diff --git a/daemon-common/node.py b/daemon-common/node.py index 857f9841..95bcb9df 100644 --- a/daemon-common/node.py +++ b/daemon-common/node.py @@ -22,7 +22,6 @@ import time import re -import click import daemon_lib.ansiprint as ansiprint import daemon_lib.zkhandler as zkhandler @@ -216,214 +215,3 @@ def get_list(zk_conn, limit, daemon_state=None, coordinator_state=None, domain_s node_list = limited_node_list return True, node_list - -# -# CLI-specific functions -# -def getOutputColours(node_information): - if node_information['daemon_state'] == 'run': - daemon_state_colour = ansiprint.green() - elif node_information['daemon_state'] == 'stop': - daemon_state_colour = ansiprint.red() - elif node_information['daemon_state'] == 'shutdown': - daemon_state_colour = ansiprint.yellow() - elif node_information['daemon_state'] == 'init': - daemon_state_colour = ansiprint.yellow() - elif node_information['daemon_state'] == 'dead': - daemon_state_colour = ansiprint.red() + ansiprint.bold() - else: - daemon_state_colour = ansiprint.blue() - - if node_information['coordinator_state'] == 'primary': - coordinator_state_colour = ansiprint.green() - elif node_information['coordinator_state'] == 'secondary': - coordinator_state_colour = ansiprint.blue() - else: - coordinator_state_colour = ansiprint.cyan() - - if node_information['domain_state'] == 'ready': - domain_state_colour = ansiprint.green() - else: - domain_state_colour = ansiprint.blue() - - return daemon_state_colour, coordinator_state_colour, domain_state_colour - -def format_info(node_information, long_output): - daemon_state_colour, coordinator_state_colour, domain_state_colour = getOutputColours(node_information) - - # Format a nice output; do this line-by-line then concat the elements at the end - ainformation = [] - # Basic information - ainformation.append('{}Name:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['name'])) - ainformation.append('{}Daemon State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), daemon_state_colour, node_information['daemon_state'], ansiprint.end())) - ainformation.append('{}Coordinator State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), coordinator_state_colour, node_information['coordinator_state'], ansiprint.end())) - ainformation.append('{}Domain State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), domain_state_colour, node_information['domain_state'], ansiprint.end())) - ainformation.append('{}Active VM Count:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['domains_count'])) - if long_output: - ainformation.append('') - ainformation.append('{}Architecture:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['arch'])) - ainformation.append('{}Operating System:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['os'])) - ainformation.append('{}Kernel Version:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['kernel'])) - ainformation.append('') - ainformation.append('{}Host CPUs:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['vcpu']['total'])) - ainformation.append('{}vCPUs:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['vcpu']['allocated'])) - ainformation.append('{}Load:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['load'])) - ainformation.append('{}Total RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['memory']['total'])) - ainformation.append('{}Used RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['memory']['used'])) - ainformation.append('{}Free RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['memory']['free'])) - ainformation.append('{}Allocated RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['memory']['allocated'])) - ainformation.append('{}Provisioned RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['memory']['provisioned'])) - - # Join it all together - information = '\n'.join(ainformation) - click.echo(information) - - click.echo('') - -def format_list(node_list): - node_list_output = [] - - # Determine optimal column widths - node_name_length = 5 - daemon_state_length = 7 - coordinator_state_length = 12 - domain_state_length = 8 - domains_count_length = 4 - cpu_count_length = 6 - load_length = 5 - mem_total_length = 6 - mem_used_length = 5 - mem_free_length = 5 - mem_alloc_length = 4 - mem_prov_length = 4 - for node_information in node_list: - # node_name column - _node_name_length = len(node_information['name']) + 1 - if _node_name_length > node_name_length: - node_name_length = _node_name_length - # daemon_state column - _daemon_state_length = len(node_information['daemon_state']) + 1 - if _daemon_state_length > daemon_state_length: - daemon_state_length = _daemon_state_length - # coordinator_state column - _coordinator_state_length = len(node_information['coordinator_state']) + 1 - if _coordinator_state_length > coordinator_state_length: - coordinator_state_length = _coordinator_state_length - # domain_state column - _domain_state_length = len(node_information['domain_state']) + 1 - if _domain_state_length > domain_state_length: - domain_state_length = _domain_state_length - # domains_count column - _domains_count_length = len(str(node_information['domains_count'])) + 1 - if _domains_count_length > domains_count_length: - domains_count_length = _domains_count_length - # cpu_count column - _cpu_count_length = len(str(node_information['cpu_count'])) + 1 - if _cpu_count_length > cpu_count_length: - cpu_count_length = _cpu_count_length - # load column - _load_length = len(str(node_information['load'])) + 1 - if _load_length > load_length: - load_length = _load_length - # mem_total column - _mem_total_length = len(str(node_information['memory']['total'])) + 1 - if _mem_total_length > mem_total_length: - mem_total_length = _mem_total_length - # mem_used column - _mem_used_length = len(str(node_information['memory']['used'])) + 1 - if _mem_used_length > mem_used_length: - mem_used_length = _mem_used_length - # mem_free column - _mem_free_length = len(str(node_information['memory']['free'])) + 1 - if _mem_free_length > mem_free_length: - mem_free_length = _mem_free_length - # mem_alloc column - _mem_alloc_length = len(str(node_information['memory']['allocated'])) + 1 - if _mem_alloc_length > mem_alloc_length: - mem_alloc_length = _mem_alloc_length - # mem_prov column - _mem_prov_length = len(str(node_information['memory']['provisioned'])) + 1 - if _mem_prov_length > mem_prov_length: - mem_prov_length = _mem_prov_length - - # Format the string (header) - node_list_output.append( - '{bold}{node_name: <{node_name_length}} \ -St: {daemon_state_colour}{node_daemon_state: <{daemon_state_length}}{end_colour} {coordinator_state_colour}{node_coordinator_state: <{coordinator_state_length}}{end_colour} {domain_state_colour}{node_domain_state: <{domain_state_length}}{end_colour} \ -Res: {node_domains_count: <{domains_count_length}} {node_cpu_count: <{cpu_count_length}} {node_load: <{load_length}} \ -Mem (M): {node_mem_total: <{mem_total_length}} {node_mem_used: <{mem_used_length}} {node_mem_free: <{mem_free_length}} {node_mem_allocated: <{mem_alloc_length}} {node_mem_provisioned: <{mem_prov_length}}{end_bold}'.format( - node_name_length=node_name_length, - daemon_state_length=daemon_state_length, - coordinator_state_length=coordinator_state_length, - domain_state_length=domain_state_length, - domains_count_length=domains_count_length, - cpu_count_length=cpu_count_length, - load_length=load_length, - mem_total_length=mem_total_length, - mem_used_length=mem_used_length, - mem_free_length=mem_free_length, - mem_alloc_length=mem_alloc_length, - mem_prov_length=mem_prov_length, - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - daemon_state_colour='', - coordinator_state_colour='', - domain_state_colour='', - end_colour='', - node_name='Name', - node_daemon_state='Daemon', - node_coordinator_state='Coordinator', - node_domain_state='Domain', - node_domains_count='VMs', - node_cpu_count='vCPUs', - node_load='Load', - node_mem_total='Total', - node_mem_used='Used', - node_mem_free='Free', - node_mem_allocated='VMs Run', - node_mem_provisioned='VMs Total' - ) - ) - - # Format the string (elements) - for node_information in node_list: - daemon_state_colour, coordinator_state_colour, domain_state_colour = getOutputColours(node_information) - node_list_output.append( - '{bold}{node_name: <{node_name_length}} \ - {daemon_state_colour}{node_daemon_state: <{daemon_state_length}}{end_colour} {coordinator_state_colour}{node_coordinator_state: <{coordinator_state_length}}{end_colour} {domain_state_colour}{node_domain_state: <{domain_state_length}}{end_colour} \ - {node_domains_count: <{domains_count_length}} {node_cpu_count: <{cpu_count_length}} {node_load: <{load_length}} \ - {node_mem_total: <{mem_total_length}} {node_mem_used: <{mem_used_length}} {node_mem_free: <{mem_free_length}} {node_mem_allocated: <{mem_alloc_length}} {node_mem_provisioned: <{mem_prov_length}}{end_bold}'.format( - node_name_length=node_name_length, - daemon_state_length=daemon_state_length, - coordinator_state_length=coordinator_state_length, - domain_state_length=domain_state_length, - domains_count_length=domains_count_length, - cpu_count_length=cpu_count_length, - load_length=load_length, - mem_total_length=mem_total_length, - mem_used_length=mem_used_length, - mem_free_length=mem_free_length, - mem_alloc_length=mem_alloc_length, - mem_prov_length=mem_prov_length, - bold='', - end_bold='', - daemon_state_colour=daemon_state_colour, - coordinator_state_colour=coordinator_state_colour, - domain_state_colour=domain_state_colour, - end_colour=ansiprint.end(), - node_name=node_information['name'], - node_daemon_state=node_information['daemon_state'], - node_coordinator_state=node_information['coordinator_state'], - node_domain_state=node_information['domain_state'], - node_domains_count=node_information['domains_count'], - node_cpu_count=node_information['vcpu']['allocated'], - node_load=node_information['load'], - node_mem_total=node_information['memory']['total'], - node_mem_used=node_information['memory']['used'], - node_mem_free=node_information['memory']['free'], - node_mem_allocated=node_information['memory']['allocated'], - node_mem_provisioned=node_information['memory']['provisioned'] - ) - ) - - click.echo('\n'.join(sorted(node_list_output))) diff --git a/daemon-common/vm.py b/daemon-common/vm.py index e5bf28a1..6e9fa1aa 100644 --- a/daemon-common/vm.py +++ b/daemon-common/vm.py @@ -22,7 +22,6 @@ import time import re -import click import lxml.objectify import daemon_lib.ansiprint as ansiprint @@ -709,268 +708,3 @@ def get_list(zk_conn, node, state, limit, is_fuzzy=True): vm_list.append(common.getInformationFromXML(zk_conn, vm)) return True, vm_list - -# -# CLI-specific functions -# -def format_info(zk_conn, domain_information, long_output): - # Format a nice output; do this line-by-line then concat the elements at the end - ainformation = [] - ainformation.append('{}Virtual machine information:{}'.format(ansiprint.bold(), ansiprint.end())) - ainformation.append('') - # Basic information - ainformation.append('{}UUID:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['uuid'])) - ainformation.append('{}Name:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['name'])) - ainformation.append('{}Description:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['description'])) - ainformation.append('{}Profile:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['profile'])) - ainformation.append('{}Memory (M):{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['memory'])) - ainformation.append('{}vCPUs:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['vcpu'])) - ainformation.append('{}Topology (S/C/T):{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['vcpu_topology'])) - - if long_output is True: - # Virtualization information - ainformation.append('') - ainformation.append('{}Emulator:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['emulator'])) - ainformation.append('{}Type:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['type'])) - ainformation.append('{}Arch:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['arch'])) - ainformation.append('{}Machine:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['machine'])) - ainformation.append('{}Features:{} {}'.format(ansiprint.purple(), ansiprint.end(), ' '.join(domain_information['features']))) - - # PVC cluster information - ainformation.append('') - dstate_colour = { - 'start': ansiprint.green(), - 'restart': ansiprint.yellow(), - 'shutdown': ansiprint.yellow(), - 'stop': ansiprint.red(), - 'disable': ansiprint.blue(), - 'fail': ansiprint.red(), - 'migrate': ansiprint.blue(), - 'unmigrate': ansiprint.blue() - } - ainformation.append('{}State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), dstate_colour[domain_information['state']], domain_information['state'], ansiprint.end())) - ainformation.append('{}Current Node:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['node'])) - if not domain_information['last_node']: - domain_information['last_node'] = "N/A" - ainformation.append('{}Previous Node:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['last_node'])) - - # Get a failure reason if applicable - if domain_information['failed_reason']: - ainformation.append('') - ainformation.append('{}Failure reason:{} {}'.format(ansiprint.purple(), ansiprint.end(), domain_information['failed_reason'])) - - if not domain_information['node_selector']: - formatted_node_selector = "False" - else: - formatted_node_selector = domain_information['node_selector'] - - if not domain_information['node_limit']: - formatted_node_limit = "False" - else: - formatted_node_limit = ', '.join(domain_information['node_limit']) - - if not domain_information['node_autostart']: - formatted_node_autostart = "False" - else: - formatted_node_autostart = domain_information['node_autostart'] - - if not domain_information['migration_method']: - formatted_migration_method = "False" - else: - formatted_migration_method = domain_information['migration_method'] - - ainformation.append('{}Migration selector:{} {}'.format(ansiprint.purple(), ansiprint.end(), formatted_node_selector)) - ainformation.append('{}Node limit:{} {}'.format(ansiprint.purple(), ansiprint.end(), formatted_node_limit)) - ainformation.append('{}Autostart:{} {}'.format(ansiprint.purple(), ansiprint.end(), formatted_node_autostart)) - ainformation.append('{}Migration Method:{} {}'.format(ansiprint.purple(), ansiprint.end(), formatted_migration_method)) - - # Network list - net_list = [] - for net in domain_information['networks']: - # Split out just the numerical (VNI) part of the brXXXX name - net_vnis = re.findall(r'\d+', net['source']) - if net_vnis: - net_vni = net_vnis[0] - else: - net_vni = re.sub('br', '', net['source']) - net_exists = zkhandler.exists(zk_conn, '/networks/{}'.format(net_vni)) - if not net_exists and net_vni != 'cluster': - net_list.append(ansiprint.red() + net_vni + ansiprint.end() + ' [invalid]') - else: - net_list.append(net_vni) - ainformation.append('') - ainformation.append('{}Networks:{} {}'.format(ansiprint.purple(), ansiprint.end(), ', '.join(net_list))) - - if long_output is True: - # Disk list - ainformation.append('') - name_length = 0 - for disk in domain_information['disks']: - _name_length = len(disk['name']) + 1 - if _name_length > name_length: - name_length = _name_length - ainformation.append('{0}Disks:{1} {2}ID Type {3: <{width}} Dev Bus{4}'.format(ansiprint.purple(), ansiprint.end(), ansiprint.bold(), 'Name', ansiprint.end(), width=name_length)) - for disk in domain_information['disks']: - ainformation.append(' {0: <3} {1: <5} {2: <{width}} {3: <4} {4: <5}'.format(domain_information['disks'].index(disk), disk['type'], disk['name'], disk['dev'], disk['bus'], width=name_length)) - ainformation.append('') - ainformation.append('{}Interfaces:{} {}ID Type Source Model MAC{}'.format(ansiprint.purple(), ansiprint.end(), ansiprint.bold(), ansiprint.end())) - for net in domain_information['networks']: - ainformation.append(' {0: <3} {1: <8} {2: <10} {3: <8} {4}'.format(domain_information['networks'].index(net), net['type'], net['source'], net['model'], net['mac'])) - # Controller list - ainformation.append('') - ainformation.append('{}Controllers:{} {}ID Type Model{}'.format(ansiprint.purple(), ansiprint.end(), ansiprint.bold(), ansiprint.end())) - for controller in domain_information['controllers']: - ainformation.append(' {0: <3} {1: <14} {2: <8}'.format(domain_information['controllers'].index(controller), controller['type'], controller['model'])) - - # Join it all together - information = '\n'.join(ainformation) - click.echo(information) - - click.echo('') - -def format_list(zk_conn, vm_list, raw): - # Function to strip the "br" off of nets and return a nicer list - def getNiceNetID(domain_information): - # Network list - net_list = [] - for net in domain_information['networks']: - # Split out just the numerical (VNI) part of the brXXXX name - net_vnis = re.findall(r'\d+', net['source']) - if net_vnis: - net_vni = net_vnis[0] - else: - net_vni = re.sub('br', '', net['source']) - net_list.append(net_vni) - return net_list - - # Handle raw mode since it just lists the names - if raw: - for vm in sorted(item['name'] for item in vm_list): - click.echo(vm) - return True, '' - - vm_list_output = [] - - # Determine optimal column widths - # Dynamic columns: node_name, node, migrated - vm_name_length = 5 - vm_uuid_length = 37 - vm_state_length = 6 - vm_nets_length = 9 - vm_ram_length = 8 - vm_vcpu_length = 6 - vm_node_length = 8 - vm_migrated_length = 10 - for domain_information in vm_list: - net_list = getNiceNetID(domain_information) - # vm_name column - _vm_name_length = len(domain_information['name']) + 1 - if _vm_name_length > vm_name_length: - vm_name_length = _vm_name_length - # vm_state column - _vm_state_length = len(domain_information['state']) + 1 - if _vm_state_length > vm_state_length: - vm_state_length = _vm_state_length - # vm_nets column - _vm_nets_length = len(','.join(net_list)) + 1 - if _vm_nets_length > vm_nets_length: - vm_nets_length = _vm_nets_length - # vm_node column - _vm_node_length = len(domain_information['node']) + 1 - if _vm_node_length > vm_node_length: - vm_node_length = _vm_node_length - # vm_migrated column - _vm_migrated_length = len(domain_information['migrated']) + 1 - if _vm_migrated_length > vm_migrated_length: - vm_migrated_length = _vm_migrated_length - - # Format the string (header) - vm_list_output.append( - '{bold}{vm_name: <{vm_name_length}} {vm_uuid: <{vm_uuid_length}} \ -{vm_state_colour}{vm_state: <{vm_state_length}}{end_colour} \ -{vm_networks: <{vm_nets_length}} \ -{vm_memory: <{vm_ram_length}} {vm_vcpu: <{vm_vcpu_length}} \ -{vm_node: <{vm_node_length}} \ -{vm_migrated: <{vm_migrated_length}}{end_bold}'.format( - vm_name_length=vm_name_length, - vm_uuid_length=vm_uuid_length, - vm_state_length=vm_state_length, - vm_nets_length=vm_nets_length, - vm_ram_length=vm_ram_length, - vm_vcpu_length=vm_vcpu_length, - vm_node_length=vm_node_length, - vm_migrated_length=vm_migrated_length, - bold=ansiprint.bold(), - end_bold=ansiprint.end(), - vm_state_colour='', - end_colour='', - vm_name='Name', - vm_uuid='UUID', - vm_state='State', - vm_networks='Networks', - vm_memory='RAM (M)', - vm_vcpu='vCPUs', - vm_node='Node', - vm_migrated='Migrated' - ) - ) - - # Format the string (elements) - for domain_information in vm_list: - if domain_information['state'] == 'start': - vm_state_colour = ansiprint.green() - elif domain_information['state'] == 'restart': - vm_state_colour = ansiprint.yellow() - elif domain_information['state'] == 'shutdown': - vm_state_colour = ansiprint.yellow() - elif domain_information['state'] == 'stop': - vm_state_colour = ansiprint.red() - elif domain_information['state'] == 'fail': - vm_state_colour = ansiprint.red() - else: - vm_state_colour = ansiprint.blue() - - # Handle colouring for an invalid network config - raw_net_list = getNiceNetID(domain_information) - net_list = [] - vm_net_colour = '' - for net_vni in raw_net_list: - net_exists = zkhandler.exists(zk_conn, '/networks/{}'.format(net_vni)) - if not net_exists and net_vni != 'cluster': - vm_net_colour = ansiprint.red() - net_list.append(net_vni) - - vm_list_output.append( - '{bold}{vm_name: <{vm_name_length}} {vm_uuid: <{vm_uuid_length}} \ -{vm_state_colour}{vm_state: <{vm_state_length}}{end_colour} \ -{vm_net_colour}{vm_networks: <{vm_nets_length}}{end_colour} \ -{vm_memory: <{vm_ram_length}} {vm_vcpu: <{vm_vcpu_length}} \ -{vm_node: <{vm_node_length}} \ -{vm_migrated: <{vm_migrated_length}}{end_bold}'.format( - vm_name_length=vm_name_length, - vm_uuid_length=vm_uuid_length, - vm_state_length=vm_state_length, - vm_nets_length=vm_nets_length, - vm_ram_length=vm_ram_length, - vm_vcpu_length=vm_vcpu_length, - vm_node_length=vm_node_length, - vm_migrated_length=vm_migrated_length, - bold='', - end_bold='', - vm_state_colour=vm_state_colour, - end_colour=ansiprint.end(), - vm_name=domain_information['name'], - vm_uuid=domain_information['uuid'], - vm_state=domain_information['state'], - vm_net_colour=vm_net_colour, - vm_networks=','.join(net_list), - vm_memory=domain_information['memory'], - vm_vcpu=domain_information['vcpu'], - vm_node=domain_information['node'], - vm_migrated=domain_information['migrated'] - ) - ) - - click.echo('\n'.join(sorted(vm_list_output))) - - return True, ''