Introduce (un)mounting hosts via sshfs on client

Author: DavidPL1

hyperion/lib/networking/clientInterface.py

@@ -2,13 +2,17 @@
 import socket
 import time
 import logging
+import os
 import sys
 import struct
 import threading
+import hyperion.lib.util.config as config
 import hyperion.lib.util.actionSerializer as actionSerializer
 import hyperion.lib.util.exception as exceptions
 from hyperion.manager import AbstractController
-from hyperion.lib.util.events import ServerDisconnectEvent
+from hyperion.lib.util.events import ServerDisconnectEvent, DisconnectEvent, ReconnectEvent
+from signal import *
+from subprocess import Popen, PIPE
 
 is_py2 = sys.version[0] == '2'
 if is_py2:
@@ -51,6 +55,9 @@ def __init__(self, host, port):
         self.mysel = selectors.DefaultSelector()
         self.keep_running = True
         self.ui_event_queue = None
+        self.mounted_hosts = []
+
+        signal(SIGINT, self._handle_sigint)
 
         self.function_mapping = {
             'get_conf_response': self._set_config,
@@ -84,6 +91,10 @@ def __init__(self, host, port):
             self.logger.debug("Waiting for config")
             time.sleep(0.5)
 
+        for host in self.host_list:
+            if not self.is_localhost(host):
+                self._mount_host(host)
+
     def request_config(self):
         action = 'get_conf'
         payload = []
@@ -94,14 +105,21 @@ def request_config(self):
         message = actionSerializer.serialize_request(action, payload)
         self.send_queue.put(message)
 
-    def cleanup(self, full=False):
+    def cleanup(self, full=False, exit_code=0):
         if full:
             action = 'quit'
             message = actionSerializer.serialize_request(action, [full])
+            self.logger.debug("Sending quit to server")
         else:
             action = 'unsubscribe'
             message = actionSerializer.serialize_request(action, [])
+            self.logger.debug("Sending unsubscribe to server")
         self.send_queue.put(message)
+
+        for host in self.mounted_hosts:
+            self.logger.debug("Unmounting host %s" % host)
+            self._unmount_host(host)
+
         self.keep_running = False
 
     def get_component_by_id(self, comp_id):
@@ -170,6 +188,14 @@ def _forward_event(self, event):
         if self.ui_event_queue:
             self.ui_event_queue.put(event)
 
+        # Special events handling
+        if isinstance(event, DisconnectEvent):
+            self.host_list[event.host_name] = None
+            self._unmount_host(event.host_name)
+        elif isinstance(event, ReconnectEvent):
+            self.host_list[event.host_name] = True
+            self._mount_host(event.host_name)
+
     def loop(self):
         # Keep alive until shutdown is requested and no messages are left to send
         while self.keep_running or not self.send_queue.empty():
@@ -209,3 +235,116 @@ def add_subscriber(self, subscriber_queue):
         :return: None
         """
         self.ui_event_queue = subscriber_queue
+
+    ###################
+    # Host related
+    ###################
+    def _mount_host(self, hostname):
+        """Mount remote host log directory via sshfs.
+
+        :param hostname: Remote host name
+        :type hostname: str
+        :return: None
+        """
+        directory = "%s/%s" % (config.TMP_LOG_PATH, hostname)
+        # First unmount to prevent unknown permissions issue on disconnected mountpoint
+        self._unmount_host(hostname)
+
+        if not self.host_list[hostname]:
+            self.logger.error("'%s' seems not to be connected. Aborting mount! Logs will not be available" % hostname)
+            return
+        try:
+            os.makedirs(directory)
+        except OSError as err:
+            if err.errno == 17:
+                # Dir already exists
+                pass
+            else:
+                self.logger.error("Error while trying to create directory '%s'" % directory)
+
+        cmd = 'sshfs %s:%s %s -F %s' % (hostname,
+                                        config.TMP_LOG_PATH,
+                                        directory,
+                                        config.SSH_CONFIG_PATH
+                                        )
+        self.logger.debug("running command: %s" % cmd)
+        p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+
+        while p.poll() is None:
+            time.sleep(.5)
+
+        if p.returncode == 0:
+            self.logger.debug("Successfully mounted remote '%s' with sshfs" % hostname)
+            self.mounted_hosts.append(hostname)
+        else:
+            self.logger.error("Could not mount remote '%s' with sshfs - logs will not be accessible!" % hostname)
+            self.logger.debug("sshfs exited with error: %s (code: %s)" % (p.stderr.readlines(), p.returncode))
+
+        self.logger.debug("mounted hosts: %s" % self.mounted_hosts)
+
+    def _unmount_host(self, hostname):
+        """Unmount fuse mounted remote log directory.
+
+        :param hostname: Remote host name.
+        :type hostname: str
+        :return: None
+        """
+        directory = "%s/%s" % (config.TMP_LOG_PATH, hostname)
+
+        cmd = 'fusermount -u %s' % directory
+        self.logger.debug("running command: %s" % cmd)
+        p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+
+        if hostname in self.mounted_hosts:
+            self.mounted_hosts.remove(hostname)
+
+        while p.poll() is None:
+            time.sleep(.5)
+
+        self.logger.debug("mounted hosts: %s" % self.mounted_hosts)
+
+    def reconnect_with_host(self, hostname):
+        action = 'reconnect_with_host'
+        payload = [hostname]
+
+        message = actionSerializer.serialize_request(action, payload)
+        self.send_queue.put(message)
+
+    def is_localhost(self, hostname):
+        """Check if 'hostname' resolves to localhost.
+
+        :param hostname: Name of host to check
+        :type hostname: str
+        :return: Whether 'host' resolves to localhost or not
+        :rtype: bool
+        """
+
+        if hostname == 'localhost':
+            hostname = self.host
+
+        try:
+            hn_out = socket.gethostbyname('%s' % hostname)
+            if hn_out == '127.0.0.1' or hn_out == '127.0.1.1' or hn_out == '::1':
+                self.logger.debug("Host '%s' is localhost" % hostname)
+                return True
+            else:
+                self.logger.debug("Host '%s' is not localhost" % hostname)
+                return False
+        except socket.gaierror:
+            raise exceptions.HostUnknownException("Host '%s' is unknown! Update your /etc/hosts file!" % hostname)
+
+    def run_on_localhost(self, comp):
+        """Check if component 'comp' is run on localhost or not.
+
+        :param comp: Component to check
+        :type comp: dict
+        :return: Whether component is run on localhost or not
+        :rtype: bool
+        """
+        try:
+            return self.is_localhost(comp['host'])
+        except exceptions.HostUnknownException as ex:
+            raise ex
+
+    def _handle_sigint(self, signum, frame):
+        self.cleanup(False)