dashboard: display minion status in node list view

circle/dashboard/tables.py

@@ -19,7 +19,8 @@ from __future__ import absolute_import
 
 
 from django.contrib.auth.models import Group, User
 from django.contrib.auth.models import Group, User
 from django_tables2 import Table, A
 from django_tables2 import Table, A
-from django_tables2.columns import TemplateColumn, Column, LinkColumn
+from django_tables2.columns import (TemplateColumn, Column, LinkColumn,
+                                    BooleanColumn)
 
 
 from vm.models import Node, InstanceTemplate, Lease
 from vm.models import Node, InstanceTemplate, Lease
 from django.utils.translation import ugettext_lazy as _
 from django.utils.translation import ugettext_lazy as _
@@ -67,12 +68,18 @@ class NodeListTable(Table):
         orderable=False,
         orderable=False,
     )
     )
 
 
+    minion_online = BooleanColumn(
+        verbose_name=_("Minion online"),
+        attrs={'th': {'class': 'node-list-table-thin'}},
+        orderable=False,
+    )
+
     class Meta:
     class Meta:
         model = Node
         model = Node
         attrs = {'class': ('table table-bordered table-striped table-hover '
         attrs = {'class': ('table table-bordered table-striped table-hover '
                            'node-list-table')}
                            'node-list-table')}
         fields = ('pk', 'name', 'host', 'get_status_display', 'priority',
         fields = ('pk', 'name', 'host', 'get_status_display', 'priority',
-                  'overcommit', 'number_of_VMs', )
+                  'minion_online', 'overcommit', 'number_of_VMs', )
 
 
 
 
 class GroupListTable(Table):
 class GroupListTable(Table):

circle/dashboard/templates/dashboard/node-detail/resources.html

@@ -7,8 +7,9 @@
     <dt>{% trans "RAM size" %}:</dt> <dd>{% widthratio node.info.ram_size 1048576 1 %} MiB</dd>
     <dt>{% trans "RAM size" %}:</dt> <dd>{% widthratio node.info.ram_size 1048576 1 %} MiB</dd>
     <dt>{% trans "Architecture" %}:</dt><dd>{{ node.info.architecture }}</dd>
     <dt>{% trans "Architecture" %}:</dt><dd>{{ node.info.architecture }}</dd>
     <dt>{% trans "Host IP" %}:</dt><dd>{{ node.host.ipv4 }}</dd>
     <dt>{% trans "Host IP" %}:</dt><dd>{{ node.host.ipv4 }}</dd>
-    <dt>{% trans "Enabled" %}:</dt><dd>{{ node.enabled }}</dd>
-    <dt>{% trans "Host online" %}:</dt><dd> {{ node.online }}</dd>
+    <dt>{% trans "Enabled" %}:</dt><dd>{{ node.enabled|yesno }}</dd>
+    <dt>{% trans "Host online" %}:</dt><dd> {{ node.online|yesno }}</dd>
+    <dt>{% trans "Minion online" %}:</dt><dd> {{ node.minion_online|yesno }}</dd>
     <dt>{% trans "Priority" %}:</dt><dd>{{ node.priority }}</dd>
     <dt>{% trans "Priority" %}:</dt><dd>{{ node.priority }}</dd>
     <dt>{% trans "Driver Version:" %}</dt>
     <dt>{% trans "Driver Version:" %}</dt>
     <dd>
     <dd>

circle/vm/models/node.py

@@ -17,9 +17,14 @@
 
 
 from __future__ import absolute_import, unicode_literals
 from __future__ import absolute_import, unicode_literals
 from functools import update_wrapper
 from functools import update_wrapper
+from glob import glob
 from logging import getLogger
 from logging import getLogger
+import os.path
 from warnings import warn
 from warnings import warn
 import requests
 import requests
+from salt.client import LocalClient
+import salt.utils
+from time import time, sleep
 
 
 from django.conf import settings
 from django.conf import settings
 from django.db.models import (
 from django.db.models import (
@@ -44,6 +49,56 @@ from .common import Trait
 logger = getLogger(__name__)
 logger = getLogger(__name__)
 
 
 
 
+class MyLocalClient(LocalClient):
+    def get_returns(self, jid, minions, timeout=None):
+        '''
+        Get the returns for the command line interface via the event system
+        '''
+        minions = set(minions)
+        if timeout is None:
+            timeout = self.opts['timeout']
+        jid_dir = salt.utils.jid_dir(jid,
+                                     self.opts['cachedir'],
+                                     self.opts['hash_type'])
+        start = time()
+        timeout_at = start + timeout
+
+        found = set()
+        ret = {}
+        wtag = os.path.join(jid_dir, 'wtag*')
+        # Check to see if the jid is real, if not return the empty dict
+        if not os.path.isdir(jid_dir):
+            logger.warning("jid_dir (%s) does not exist", jid_dir)
+            return ret
+        # Wait for the hosts to check in
+        while True:
+            time_left = timeout_at - time()
+            raw = self.event.get_event(time_left, jid)
+            if raw is not None and 'return' in raw:
+                found.add(raw['id'])
+                ret[raw['id']] = raw['return']
+                if len(found.intersection(minions)) >= len(minions):
+                    # All minions have returned, break out of the loop
+                    logger.debug("jid %s found all minions", jid)
+                    break
+                continue
+            # Then event system timeout was reached and nothing was returned
+            if len(found.intersection(minions)) >= len(minions):
+                # All minions have returned, break out of the loop
+                logger.debug("jid %s found all minions", jid)
+                break
+            if glob(wtag) and time() <= timeout_at + 1:
+                # The timeout +1 has not been reached and there is still a
+                # write tag for the syndic
+                continue
+            if time() > timeout_at:
+                logger.info('jid %s minions %s did not return in time',
+                            jid, (minions - found))
+                break
+            sleep(0.01)
+        return ret
+
+
 def node_available(function):
 def node_available(function):
     """Decorate methods to ignore disabled Nodes.
     """Decorate methods to ignore disabled Nodes.
     """
     """
@@ -111,6 +166,18 @@ class Node(OperatedMixin, TimeStampedModel):
 
 
     online = property(get_online)
     online = property(get_online)
 
 
+    @method_cache(20)
+    def get_minion_online(self):
+        name = self.host.hostname
+        client = MyLocalClient()
+        client.opts['timeout'] = 0.2
+        try:
+            return bool(client.cmd(name, 'test.ping')[name])
+        except KeyError:
+            return False
+
+    minion_online = property(get_minion_online)
+
     @node_available
     @node_available
     @method_cache(300)
     @method_cache(300)
     def get_info(self):
     def get_info(self):