Very beautiful and elegant list functions

This commit is contained in:
Joshua Boniface 2018-06-12 01:26:06 -04:00
parent de68519153
commit dd2560c2f8
1 changed files with 187 additions and 61 deletions

248
pvc.py
View File

@ -158,56 +158,112 @@ def node_list():
List all hypervisor nodes in the cluster. List all hypervisor nodes in the cluster.
""" """
node_list_header = ansiiprint.bold() + 'Name State: Daemon Nodes Resources: VMs CPUs RAM [MiB]: Total Used Free Allocated' + ansiiprint.end() # Open a Zookeeper connection
node_list = []
zk = pvcf.startZKConnection(zk_host) zk = pvcf.startZKConnection(zk_host)
for node_name in zk.get_children('/nodes'):
node_daemon_state = zk.get('/nodes/{}/daemonstate'.format(node_name))[0].decode('ascii') node_list = zk.get_children('/nodes')
node_domain_state = zk.get('/nodes/{}/domainstate'.format(node_name))[0].decode('ascii') node_list_output = []
node_cpu_count = zk.get('/nodes/{}/cpucount'.format(node_name))[0].decode('ascii') node_daemon_state = {}
node_mem_used = zk.get('/nodes/{}/memused'.format(node_name))[0].decode('ascii') node_daemon_state = {}
node_mem_free = zk.get('/nodes/{}/memfree'.format(node_name))[0].decode('ascii') node_domain_state = {}
node_mem_total = int(node_mem_used) + int(node_mem_free) node_cpu_count = {}
node_domains_count = zk.get('/nodes/{}/domainscount'.format(node_name))[0].decode('ascii') node_mem_used = {}
node_running_domains = zk.get('/nodes/{}/runningdomains'.format(node_name))[0].decode('ascii').split() node_mem_free = {}
node_mem_allocated = 0 node_mem_total = {}
for domain in node_running_domains: node_domains_count = {}
node_running_domains = {}
node_mem_allocated = {}
# Gather information for printing
for node_name in node_list:
node_daemon_state[node_name] = zk.get('/nodes/{}/daemonstate'.format(node_name))[0].decode('ascii')
node_domain_state[node_name] = zk.get('/nodes/{}/domainstate'.format(node_name))[0].decode('ascii')
node_cpu_count[node_name] = zk.get('/nodes/{}/cpucount'.format(node_name))[0].decode('ascii')
node_mem_used[node_name] = zk.get('/nodes/{}/memused'.format(node_name))[0].decode('ascii')
node_mem_free[node_name] = zk.get('/nodes/{}/memfree'.format(node_name))[0].decode('ascii')
node_mem_total[node_name] = int(node_mem_used[node_name]) + int(node_mem_free[node_name])
node_domains_count[node_name] = zk.get('/nodes/{}/domainscount'.format(node_name))[0].decode('ascii')
node_running_domains[node_name] = zk.get('/nodes/{}/runningdomains'.format(node_name))[0].decode('ascii').split()
node_mem_allocated[node_name] = 0
for domain in node_running_domains[node_name]:
parsed_xml = pvcf.getDomainXML(zk, domain) parsed_xml = pvcf.getDomainXML(zk, domain)
duuid, dname, dmemory, dvcpu, dvcputopo = pvcf.getDomainMainDetails(parsed_xml) duuid, dname, dmemory, dvcpu, dvcputopo = pvcf.getDomainMainDetails(parsed_xml)
node_mem_allocated += int(dmemory) node_mem_allocated[node_name] += int(dmemory)
if node_daemon_state == 'start': # Determine optimal column widths
# Dynamic columns: node_name, hypervisor, migrated
node_name_length = 0
for node_name in node_list:
# node_name column
_node_name_length = len(node_name) + 1
if _node_name_length > node_name_length:
node_name_length = _node_name_length
# Format the string (header)
node_list_output.append(
'{bold}{node_name: <{node_name_length}} \
State: {daemon_state_colour}{node_daemon_state: <8}{end_colour} {domain_state_colour}{node_domain_state: <8}{end_colour} \
Resources: {node_domains_count: <4} {node_cpu_count: <5} \
RAM (MiB): {node_mem_total: <6} {node_mem_used: <6} {node_mem_free: <6} {node_mem_allocated: <6}{end_bold}'.format(
node_name_length=node_name_length,
bold=ansiiprint.bold(),
end_bold=ansiiprint.end(),
daemon_state_colour='',
domain_state_colour='',
end_colour='',
node_name='Name',
node_daemon_state='Daemon',
node_domain_state='Domain',
node_domains_count='VMs',
node_cpu_count='CPUs',
node_mem_total='Total',
node_mem_used='Used',
node_mem_free='Free',
node_mem_allocated='VMs'
)
)
# Format the string (elements)
for node_name in node_list:
if node_daemon_state[node_name] == 'start':
daemon_state_colour = ansiiprint.green() daemon_state_colour = ansiiprint.green()
elif node_daemon_state == 'stop': elif node_daemon_state[node_name] == 'stop':
daemon_state_colour = ansiiprint.red() daemon_state_colour = ansiiprint.red()
else: else:
daemon_state_colour = ansiiprint.yellow() daemon_state_colour = ansiiprint.yellow()
if node_domain_state == 'ready': if node_domain_state[node_name] == 'ready':
domain_state_colour = ansiiprint.green() domain_state_colour = ansiiprint.green()
else: else:
domain_state_colour = ansiiprint.blue() domain_state_colour = ansiiprint.blue()
node_output_string = '{3: <28} {0}{4: <7}{2} {1}{5: <8}{2} {6: <4} {7: <4} {8: <6} {9: <6} {10: <6} {11: <6}'.format( node_list_output.append(
daemon_state_colour, '{bold}{node_name: <{node_name_length}} \
domain_state_colour, {daemon_state_colour}{node_daemon_state: <8}{end_colour} {domain_state_colour}{node_domain_state: <8}{end_colour} \
ansiiprint.end(), {node_domains_count: <4} {node_cpu_count: <5} \
node_name, {node_mem_total: <6} {node_mem_used: <6} {node_mem_free: <6} {node_mem_allocated: <6}{end_bold}'.format(
node_daemon_state, node_name_length=node_name_length,
node_domain_state, bold='',
node_domains_count, end_bold='',
node_cpu_count, daemon_state_colour=daemon_state_colour,
node_mem_total, domain_state_colour=domain_state_colour,
node_mem_used, end_colour=ansiiprint.end(),
node_mem_free, node_name=node_name,
node_mem_allocated node_daemon_state=node_daemon_state[node_name],
node_domain_state=node_domain_state[node_name],
node_domains_count=node_domains_count[node_name],
node_cpu_count=node_cpu_count[node_name],
node_mem_total=node_mem_total[node_name],
node_mem_used=node_mem_used[node_name],
node_mem_free=node_mem_free[node_name],
node_mem_allocated=node_mem_allocated[node_name]
)
) )
node_list.append(node_output_string)
click.echo(node_list_header) click.echo('\n'.join(sorted(node_list_output)))
click.echo('\n'.join(sorted(node_list)))
# Close the Zookeeper connection
pvcf.stopZKConnection(zk)
############################################################################### ###############################################################################
@ -780,47 +836,117 @@ def vm_list(hypervisor):
List all virtual machines in the cluster. List all virtual machines in the cluster.
""" """
vm_list_header = ansiiprint.bold() + 'Name UUID State RAM [MiB] vCPUs Hypervisor Migrated?' + ansiiprint.end() # Open a Zookeeper connection
vm_list = []
zk = pvcf.startZKConnection(zk_host) zk = pvcf.startZKConnection(zk_host)
for vm in zk.get_children('/domains'):
vm_list = zk.get_children('/domains')
vm_list_output = []
vm_hypervisor = {}
vm_state = {}
vm_migrated = {}
vm_uuid = {}
vm_name = {}
vm_memory = {}
vm_vcpu = {}
# Gather information for printing
for vm in vm_list:
# Check hypervisor to avoid unneeded ZK calls # Check hypervisor to avoid unneeded ZK calls
vm_hypervisor = zk.get('/domains/{}/hypervisor'.format(vm))[0].decode('ascii') vm_hypervisor[vm] = zk.get('/domains/{}/hypervisor'.format(vm))[0].decode('ascii')
if hypervisor != None and vm_hypervisor != hypervisor: if hypervisor != None and vm_hypervisor[vm] != hypervisor:
continue continue
vm_state = zk.get('/domains/{}/state'.format(vm))[0].decode('ascii') vm_state[vm] = zk.get('/domains/{}/state'.format(vm))[0].decode('ascii')
vm_lasthypervisor = zk.get('/domains/{}/lasthypervisor'.format(vm))[0].decode('ascii') vm_lasthypervisor = zk.get('/domains/{}/lasthypervisor'.format(vm))[0].decode('ascii')
if vm_lasthypervisor != '': if vm_lasthypervisor != '':
vm_migrated = 'from {}'.format(vm_lasthypervisor) vm_migrated[vm] = 'from {}'.format(vm_lasthypervisor)
else: else:
vm_migrated = 'no' vm_migrated[vm] = 'no'
vm_xml = pvcf.getDomainXML(zk, vm) vm_xml = pvcf.getDomainXML(zk, vm)
vm_uuid, vm_name, vm_memory, vm_vcpu, vm_vcputopo = pvcf.getDomainMainDetails(vm_xml) vm_uuid[vm], vm_name[vm], vm_memory[vm], vm_vcpu[vm], vm_vcputopo = pvcf.getDomainMainDetails(vm_xml)
if vm_state == 'start': # Determine optimal column widths
state_colour = ansiiprint.green() # Dynamic columns: node_name, hypervisor, migrated
elif vm_state == 'stop' or vm_state == 'shutdown': vm_name_length = 0
state_colour = ansiiprint.red() vm_hypervisor_length = 0
else: vm_migrated_length = 0
state_colour = ansiiprint.yellow() for vm in vm_list:
# vm_name column
_vm_name_length = len(vm_name[vm]) + 1
if _vm_name_length > vm_name_length:
vm_name_length = _vm_name_length
# vm_hypervisor column
_vm_hypervisor_length = len(vm_hypervisor[vm]) + 1
if _vm_hypervisor_length > vm_hypervisor_length:
vm_hypervisor_length = _vm_hypervisor_length
# vm_migrated column
_vm_migrated_length = len(vm_migrated[vm]) + 1
if _vm_migrated_length > vm_migrated_length:
vm_migrated_length = _vm_migrated_length
vm_output_string = '{2: <16} {3: <32} {0}{4: <8}{1} {5: <6} {6: <5} {7: <20} {8: <25}'.format( # Format the string (header)
state_colour, vm_list_header = ansiiprint.bold() + 'Name UUID State RAM [MiB] vCPUs Hypervisor Migrated?' + ansiiprint.end()
ansiiprint.end(), vm_list_output.append(
vm_name, '{bold}{vm_name: <{vm_name_length}} {vm_uuid: <37} \
vm_uuid, {vm_state_colour}{vm_state: <8}{end_colour} \
vm_state, {vm_memory: <10} {vm_vcpu: <6} \
vm_memory, {vm_hypervisor: <{vm_hypervisor_length}} \
vm_vcpu, {vm_migrated: <{vm_migrated_length}}{end_bold}'.format(
vm_hypervisor, vm_name_length=vm_name_length,
vm_migrated vm_hypervisor_length=vm_hypervisor_length,
vm_migrated_length=vm_migrated_length,
bold=ansiiprint.bold(),
end_bold=ansiiprint.end(),
vm_state_colour='',
end_colour='',
vm_name='Name',
vm_uuid='UUID',
vm_state='State',
vm_memory='RAM (MiB)',
vm_vcpu='vCPUs',
vm_hypervisor='Hypervisor',
vm_migrated='Migrated'
)
) )
vm_list.append(vm_output_string)
click.echo(vm_list_header) # Format the string (elements)
click.echo('\n'.join(sorted(vm_list))) for vm in vm_list:
if vm_state[vm] == 'start':
vm_state_colour = ansiiprint.green()
elif vm_state[vm] == 'stop':
vm_state_colour = ansiiprint.red()
else:
vm_state_colour = ansiiprint.blue()
vm_list_output.append(
'{bold}{vm_name: <{vm_name_length}} {vm_uuid: <37} \
{vm_state_colour}{vm_state: <8}{end_colour} \
{vm_memory: <10} {vm_vcpu: <6} \
{vm_hypervisor: <{vm_hypervisor_length}} \
{vm_migrated: <{vm_migrated_length}}{end_bold}'.format(
vm_name_length=vm_name_length,
vm_hypervisor_length=vm_hypervisor_length,
vm_migrated_length=vm_migrated_length,
bold='',
end_bold='',
vm_state_colour=vm_state_colour,
end_colour=ansiiprint.end(),
vm_name=vm_name[vm],
vm_uuid=vm_uuid[vm],
vm_state=vm_state[vm],
vm_memory=vm_memory[vm],
vm_vcpu=vm_vcpu[vm],
vm_hypervisor=vm_hypervisor[vm],
vm_migrated=vm_migrated[vm]
)
)
click.echo('\n'.join(sorted(vm_list_output)))
# Close the Zookeeper connection
pvcf.stopZKConnection(zk)
############################################################################### ###############################################################################