parent
2151566b74
commit
045ad131af
|
|
@ -30,6 +30,7 @@ import re
|
|||
import colorama
|
||||
import yaml
|
||||
|
||||
import client_lib.ansiprint as ansiprint
|
||||
import client_lib.common as pvc_common
|
||||
import client_lib.node as pvc_node
|
||||
import client_lib.vm as pvc_vm
|
||||
|
|
@ -162,8 +163,16 @@ def node_info(node, long_output):
|
|||
"""
|
||||
|
||||
zk_conn = pvc_common.startZKConnection(zk_host)
|
||||
retcode, retmsg = pvc_node.get_info(zk_conn, node, long_output)
|
||||
cleanup(retcode, retmsg, zk_conn)
|
||||
retcode, retdata = pvc_node.get_info(zk_conn, node)
|
||||
if retcode:
|
||||
pvc_node.format_info(zk_conn, retdata, long_output)
|
||||
if long_output:
|
||||
click.echo('{}Virtual machines on node:{}'.format(ansiprint.bold(), ansiprint.end()))
|
||||
click.echo('')
|
||||
pvc_vm.get_list(zk_conn, node, None, None, None)
|
||||
click.echo('')
|
||||
retdata = ''
|
||||
cleanup(retcode, retdata, zk_conn)
|
||||
|
||||
###############################################################################
|
||||
# pvc node list
|
||||
|
|
@ -178,8 +187,11 @@ def node_list(limit):
|
|||
"""
|
||||
|
||||
zk_conn = pvc_common.startZKConnection(zk_host)
|
||||
retcode, retmsg = pvc_node.get_list(zk_conn, limit)
|
||||
cleanup(retcode, retmsg, zk_conn)
|
||||
retcode, retdata = pvc_node.get_list(zk_conn, limit)
|
||||
if retcode:
|
||||
pvc_node.format_list(retdata)
|
||||
retdata = ''
|
||||
cleanup(retcode, retdata, zk_conn)
|
||||
|
||||
###############################################################################
|
||||
# pvc vm
|
||||
|
|
|
|||
|
|
@ -39,7 +39,10 @@ import client_lib.zkhandler as zkhandler
|
|||
import client_lib.common as common
|
||||
import client_lib.vm as pvc_vm
|
||||
|
||||
def getInformationFromNode(zk_conn, node_name, long_output):
|
||||
def getInformationFromNode(zk_conn, node_name):
|
||||
"""
|
||||
Gather information about a node from the Zookeeper database and return a dict() containing it.
|
||||
"""
|
||||
node_daemon_state = zkhandler.readdata(zk_conn, '/nodes/{}/daemonstate'.format(node_name))
|
||||
node_coordinator_state = zkhandler.readdata(zk_conn, '/nodes/{}/routerstate'.format(node_name))
|
||||
node_domain_state = zkhandler.readdata(zk_conn, '/nodes/{}/domainstate'.format(node_name))
|
||||
|
|
@ -48,63 +51,36 @@ def getInformationFromNode(zk_conn, node_name, long_output):
|
|||
node_kernel = node_static_data[1]
|
||||
node_os = node_static_data[2]
|
||||
node_arch = node_static_data[3]
|
||||
node_mem_total = int(zkhandler.readdata(zk_conn, '/nodes/{}/memtotal'.format(node_name)))
|
||||
node_mem_allocated = int(zkhandler.readdata(zk_conn, '/nodes/{}/memalloc'.format(node_name)))
|
||||
node_mem_used = int(zkhandler.readdata(zk_conn, '/nodes/{}/memused'.format(node_name)))
|
||||
node_mem_free = int(zkhandler.readdata(zk_conn, '/nodes/{}/memfree'.format(node_name)))
|
||||
node_mem_total = node_mem_used + node_mem_free
|
||||
node_load = zkhandler.readdata(zk_conn, '/nodes/{}/cpuload'.format(node_name))
|
||||
node_domains_count = zkhandler.readdata(zk_conn, '/nodes/{}/domainscount'.format(node_name))
|
||||
node_running_domains = zkhandler.readdata(zk_conn, '/nodes/{}/runningdomains'.format(node_name)).split()
|
||||
|
||||
if node_daemon_state == 'run':
|
||||
daemon_state_colour = ansiprint.green()
|
||||
elif node_daemon_state == 'stop':
|
||||
daemon_state_colour = ansiprint.red()
|
||||
elif node_daemon_state == 'init':
|
||||
daemon_state_colour = ansiprint.yellow()
|
||||
elif node_daemon_state == 'dead':
|
||||
daemon_state_colour = ansiprint.red() + ansiprint.bold()
|
||||
else:
|
||||
daemon_state_colour = ansiprint.blue()
|
||||
# Construct a data structure to represent the data
|
||||
node_information = {
|
||||
'name': node_name,
|
||||
'daemon_state': node_daemon_state,
|
||||
'coordinator_state': node_coordinator_state,
|
||||
'domain_state': node_domain_state,
|
||||
'cpu_count': node_cpu_count,
|
||||
'kernel': node_kernel,
|
||||
'os': node_os,
|
||||
'arch': node_arch,
|
||||
'load': node_load,
|
||||
'domains_count': node_domains_count,
|
||||
'running_domains': node_running_domains,
|
||||
'memory': {
|
||||
'total': node_mem_total,
|
||||
'allocated': node_mem_allocated,
|
||||
'used': node_mem_used,
|
||||
'free': node_mem_free
|
||||
}
|
||||
}
|
||||
|
||||
if node_coordinator_state == 'primary':
|
||||
coordinator_state_colour = ansiprint.green()
|
||||
elif node_coordinator_state == 'secondary':
|
||||
coordinator_state_colour = ansiprint.blue()
|
||||
else:
|
||||
coordinator_state_colour = ansiprint.purple()
|
||||
|
||||
if node_domain_state == 'ready':
|
||||
domain_state_colour = ansiprint.green()
|
||||
else:
|
||||
domain_state_colour = ansiprint.blue()
|
||||
|
||||
# Format a nice output; do this line-by-line then concat the elements at the end
|
||||
ainformation = []
|
||||
ainformation.append('{}Node information:{}'.format(ansiprint.bold(), ansiprint.end()))
|
||||
ainformation.append('')
|
||||
# Basic information
|
||||
ainformation.append('{}Name:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_name))
|
||||
ainformation.append('{}Daemon State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), daemon_state_colour, node_daemon_state, ansiprint.end()))
|
||||
ainformation.append('{}Coordinator State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), coordinator_state_colour, node_coordinator_state, ansiprint.end()))
|
||||
ainformation.append('{}Domain State:{} {}{}{}'.format(ansiprint.purple(), ansiprint.end(), domain_state_colour, node_domain_state, ansiprint.end()))
|
||||
ainformation.append('{}Active VM Count:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_domains_count))
|
||||
if long_output == True:
|
||||
ainformation.append('')
|
||||
ainformation.append('{}Architecture:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_arch))
|
||||
ainformation.append('{}Operating System:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_os))
|
||||
ainformation.append('{}Kernel Version:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_kernel))
|
||||
ainformation.append('')
|
||||
ainformation.append('{}CPUs:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_cpu_count))
|
||||
ainformation.append('{}Load:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_load))
|
||||
ainformation.append('{}Total RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_mem_total))
|
||||
ainformation.append('{}Used RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_mem_used))
|
||||
ainformation.append('{}Free RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_mem_free))
|
||||
ainformation.append('{}Allocated RAM (MiB):{} {}'.format(ansiprint.purple(), ansiprint.end(), node_mem_allocated))
|
||||
|
||||
# Join it all together
|
||||
information = '\n'.join(ainformation)
|
||||
return information
|
||||
return node_information
|
||||
|
||||
#
|
||||
# Direct Functions
|
||||
|
|
@ -193,29 +169,17 @@ def ready_node(zk_conn, node):
|
|||
|
||||
return True, retmsg
|
||||
|
||||
def get_info(zk_conn, node, long_output):
|
||||
def get_info(zk_conn, node):
|
||||
# Verify node is valid
|
||||
if not common.verifyNode(zk_conn, node):
|
||||
return False, 'ERROR: No node named "{}" is present in the cluster.'.format(node)
|
||||
|
||||
# Get information about node in a pretty format
|
||||
information = getInformationFromNode(zk_conn, node, long_output)
|
||||
|
||||
if information == None:
|
||||
node_information = getInformationFromNode(zk_conn, node)
|
||||
if node_information == None:
|
||||
return False, 'ERROR: Could not find a node matching that name.'
|
||||
|
||||
click.echo(information)
|
||||
|
||||
if long_output == True:
|
||||
click.echo('')
|
||||
click.echo('{}Virtual machines on node:{}'.format(ansiprint.bold(), ansiprint.end()))
|
||||
click.echo('')
|
||||
# List all VMs on this node
|
||||
pvc_vm.get_list(zk_conn, node, None)
|
||||
|
||||
click.echo('')
|
||||
|
||||
return True, ''
|
||||
return True, node_information
|
||||
|
||||
def get_list(zk_conn, limit):
|
||||
# Match our limit
|
||||
|
|
@ -231,41 +195,77 @@ def get_list(zk_conn, limit):
|
|||
limit = limit + '.*'
|
||||
|
||||
if re.match(limit, node) != None:
|
||||
node_list.append(node)
|
||||
node_list.append(getInformationFromNode(zk_conn, node))
|
||||
except Exception as e:
|
||||
return False, 'Regex Error: {}'.format(e)
|
||||
else:
|
||||
node_list.append(node)
|
||||
node_list.append(getInformationFromNode(zk_conn, node))
|
||||
|
||||
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'] == '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.purple()
|
||||
|
||||
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(zk_conn, 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('{}CPUs:{} {}'.format(ansiprint.purple(), ansiprint.end(), node_information['cpu_count']))
|
||||
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']))
|
||||
|
||||
# Join it all together
|
||||
information = '\n'.join(ainformation)
|
||||
click.echo(information)
|
||||
|
||||
click.echo('')
|
||||
|
||||
def format_list(node_list):
|
||||
node_list_output = []
|
||||
node_daemon_state = {}
|
||||
node_coordinator_state = {}
|
||||
node_domain_state = {}
|
||||
node_cpu_count = {}
|
||||
node_mem_used = {}
|
||||
node_mem_free = {}
|
||||
node_mem_total = {}
|
||||
node_mem_allocated = {}
|
||||
node_domains_count = {}
|
||||
node_running_domains = {}
|
||||
node_load = {}
|
||||
|
||||
# Gather information for printing
|
||||
for node_name in node_list:
|
||||
node_daemon_state[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/daemonstate'.format(node_name))
|
||||
node_coordinator_state[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/routerstate'.format(node_name))
|
||||
node_domain_state[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/domainstate'.format(node_name))
|
||||
node_cpu_count[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/staticdata'.format(node_name)).split()[0]
|
||||
node_mem_allocated[node_name] = int(zkhandler.readdata(zk_conn, '/nodes/{}/memalloc'.format(node_name)))
|
||||
node_mem_used[node_name] = int(zkhandler.readdata(zk_conn, '/nodes/{}/memused'.format(node_name)))
|
||||
node_mem_free[node_name] = int(zkhandler.readdata(zk_conn, '/nodes/{}/memfree'.format(node_name)))
|
||||
node_mem_total[node_name] = node_mem_used[node_name] + node_mem_free[node_name]
|
||||
node_load[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/cpuload'.format(node_name))
|
||||
node_domains_count[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/domainscount'.format(node_name))
|
||||
node_running_domains[node_name] = zkhandler.readdata(zk_conn, '/nodes/{}/runningdomains'.format(node_name)).split()
|
||||
|
||||
# Determine optimal column widths
|
||||
# Dynamic columns: node_name, daemon_state, network_state, domain_state, load
|
||||
node_name_length = 5
|
||||
daemon_state_length = 7
|
||||
coordinator_state_length = 12
|
||||
|
|
@ -277,49 +277,49 @@ def get_list(zk_conn, limit):
|
|||
mem_used_length = 5
|
||||
mem_free_length = 5
|
||||
mem_alloc_length = 4
|
||||
for node_name in node_list:
|
||||
for node_information in node_list:
|
||||
# node_name column
|
||||
_node_name_length = len(node_name) + 1
|
||||
_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_daemon_state[node_name]) + 1
|
||||
_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_coordinator_state[node_name]) + 1
|
||||
_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_domain_state[node_name]) + 1
|
||||
_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(node_domains_count[node_name]) + 1
|
||||
_domains_count_length = len(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(node_cpu_count[node_name]) + 1
|
||||
_cpu_count_length = len(node_information['cpu_count']) + 1
|
||||
if _cpu_count_length > cpu_count_length:
|
||||
cpu_count_length = _cpu_count_length
|
||||
# load column
|
||||
_load_length = len(node_load[node_name]) + 1
|
||||
_load_length = len(node_information['load']) + 1
|
||||
if _load_length > load_length:
|
||||
load_length = _load_length
|
||||
# mem_total column
|
||||
_mem_total_length = len(str(node_mem_total[node_name])) + 1
|
||||
_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_mem_used[node_name])) + 1
|
||||
_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_mem_free[node_name])) + 1
|
||||
_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_mem_allocated[node_name])) + 1
|
||||
_mem_alloc_length = len(str(node_information['memory']['allocated'])) + 1
|
||||
if _mem_alloc_length > mem_alloc_length:
|
||||
mem_alloc_length = _mem_alloc_length
|
||||
|
||||
|
|
@ -361,33 +361,8 @@ Mem (M): {node_mem_total: <{mem_total_length}} {node_mem_used: <{mem_used_length
|
|||
)
|
||||
|
||||
# Format the string (elements)
|
||||
for node_name in node_list:
|
||||
if node_daemon_state[node_name] == 'run':
|
||||
daemon_state_colour = ansiprint.green()
|
||||
elif node_daemon_state[node_name] == 'stop':
|
||||
daemon_state_colour = ansiprint.red()
|
||||
elif node_daemon_state[node_name] == 'init':
|
||||
daemon_state_colour = ansiprint.yellow()
|
||||
elif node_daemon_state[node_name] == 'dead':
|
||||
daemon_state_colour = ansiprint.red() + ansiprint.bold()
|
||||
else:
|
||||
daemon_state_colour = ansiprint.blue()
|
||||
|
||||
if node_coordinator_state[node_name] == 'primary':
|
||||
coordinator_state_colour = ansiprint.green()
|
||||
elif node_coordinator_state[node_name] == 'secondary':
|
||||
coordinator_state_colour = ansiprint.blue()
|
||||
else:
|
||||
coordinator_state_colour = ansiprint.purple()
|
||||
|
||||
if node_mem_allocated[node_name] != 0 and node_mem_allocated[node_name] >= node_mem_total[node_name]:
|
||||
node_domain_state[node_name] = 'overprov'
|
||||
domain_state_colour = ansiprint.yellow()
|
||||
elif node_domain_state[node_name] == 'ready':
|
||||
domain_state_colour = ansiprint.green()
|
||||
else:
|
||||
domain_state_colour = ansiprint.blue()
|
||||
|
||||
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} \
|
||||
|
|
@ -410,20 +385,18 @@ Mem (M): {node_mem_total: <{mem_total_length}} {node_mem_used: <{mem_used_length
|
|||
coordinator_state_colour=coordinator_state_colour,
|
||||
domain_state_colour=domain_state_colour,
|
||||
end_colour=ansiprint.end(),
|
||||
node_name=node_name,
|
||||
node_daemon_state=node_daemon_state[node_name],
|
||||
node_coordinator_state=node_coordinator_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_load=node_load[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_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['cpu_count'],
|
||||
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']
|
||||
)
|
||||
)
|
||||
|
||||
click.echo('\n'.join(sorted(node_list_output)))
|
||||
|
||||
return True, ''
|
||||
|
|
|
|||
Loading…
Reference in New Issue