Update node.py to allow API use

Addresses #33

client-cli/pvc.py

@@ -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)
+    retcode, retdata = pvc_node.get_info(zk_conn, node)
-    cleanup(retcode, retmsg, zk_conn)
+    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)
+    retcode, retdata = pvc_node.get_list(zk_conn, limit)
-    cleanup(retcode, retmsg, zk_conn)
+    if retcode:
+        pvc_node.format_list(retdata)
+        retdata = ''
+    cleanup(retcode, retdata, zk_conn)
 
 ###############################################################################
 # pvc vm

client-common/node.py

@@ -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':
+    # Construct a data structure to represent the data
-        daemon_state_colour = ansiprint.green()
+    node_information = {
-    elif node_daemon_state == 'stop':
+        'name': node_name,
-        daemon_state_colour = ansiprint.red()
+        'daemon_state': node_daemon_state,
-    elif node_daemon_state == 'init':
+        'coordinator_state': node_coordinator_state,
-        daemon_state_colour = ansiprint.yellow()
+        'domain_state': node_domain_state,
-    elif node_daemon_state == 'dead':
+        'cpu_count': node_cpu_count,
-        daemon_state_colour = ansiprint.red() + ansiprint.bold()
+        'kernel': node_kernel,
-    else:
+        'os': node_os,
-        daemon_state_colour = ansiprint.blue()
+        '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':
+    return node_information
-        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
 
 #
 # 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)
+    node_information = getInformationFromNode(zk_conn, node)
-
+    if node_information == None:
-    if information == None:
         return False, 'ERROR: Could not find a node matching that name.'
 
-    click.echo(information)
+    return True, node_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, ''
 
 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:
+    for node_information in node_list:
-        if node_daemon_state[node_name] == 'run':
+        daemon_state_colour, coordinator_state_colour, domain_state_colour = getOutputColours(node_information)
-            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()
-
         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_name=node_information['name'],
-                node_daemon_state=node_daemon_state[node_name],
+                node_daemon_state=node_information['daemon_state'],
-                node_coordinator_state=node_coordinator_state[node_name],
+                node_coordinator_state=node_information['coordinator_state'],
-                node_domain_state=node_domain_state[node_name],
+                node_domain_state=node_information['domain_state'],
-                node_domains_count=node_domains_count[node_name],
+                node_domains_count=node_information['domains_count'],
-                node_cpu_count=node_cpu_count[node_name],
+                node_cpu_count=node_information['cpu_count'],
-                node_load=node_load[node_name],
+                node_load=node_information['load'],
-                node_mem_total=node_mem_total[node_name],
+                node_mem_total=node_information['memory']['total'],
-                node_mem_used=node_mem_used[node_name],
+                node_mem_used=node_information['memory']['used'],
-                node_mem_free=node_mem_free[node_name],
+                node_mem_free=node_information['memory']['free'],
-                node_mem_allocated=node_mem_allocated[node_name]
+                node_mem_allocated=node_information['memory']['allocated']
             )
         )
 
     click.echo('\n'.join(sorted(node_list_output)))
-
-    return True, ''