Remote execution.

We can use a fifo to write command, and execute them on the local
machine by running a simple daemon.

2 files changed, 100 insertions, 0 deletions

diff --git a/src/core.py b/src/core.py
index 41a54b23..2b305f21 100644
--- a/src/core.py
+++ b/src/core.py
@@ -49,6 +49,7 @@ from contact import Contact, Resource
 from text_buffer import TextBuffer
 from keyboard import read_char
 from theming import get_theme
+from fifo import Fifo
 
 # http://xmpp.org/extensions/xep-0045.html#errorstatus
 ERROR_AND_STATUS_CODES = {
@@ -94,6 +95,7 @@ class Core(object):
         sys.excepthook = self.on_exception
         self.running = True
         self.xmpp = singleton.Singleton(connection.Connection)
+        self.remote_fifo = None
         # a unique buffer used to store global informations
         # that are displayed in almost all tabs, in an
         # information window.
@@ -1707,3 +1709,31 @@ class Core(object):
             return False
         self.current_tab().command_say(msg)
         return True
+
+    def exec_command(self, command):
+        """
+        Execute an external command on the local or a remote
+        machine, depending on the conf. For example, to open a link in a
+        browser, do exec_command("firefox http://poezio.eu"),
+        and this will call the command on the correct computer.
+        The remote execution is done by writing the command on a fifo.
+        That fifo has to be on the machine where poezio is running, and
+        accessible (through sshfs for example) from the local machine (where
+        poezio is not running). A very simple daemon reads on that fifo,
+        and executes any command that is read in it.
+        """
+        if config.get('exec_remote', 'false') == 'true':
+            # We just write the command in the fifo
+            if not self.remote_fifo:
+                try:
+                    self.remote_fifo = Fifo(os.path.join(config.get('remote_fifo_path', './'), 'poezio.fifo'), 'w')
+                except (OSError, IOError) as e:
+                    self.information('Could not open fifo file for writing: %s' % (e,), 'Error')
+                    return
+            try:
+                self.remote_fifo.write(command)
+            except (IOError) as e:
+                self.information('Could not execute [%s]: %s' % (command, e,), 'Error')
+                self.remote_fifo = None
+        else:
+            pass
diff --git a/src/fifo.py b/src/fifo.py
new file mode 100644
index 00000000..8306e24b
--- /dev/null
+++ b/src/fifo.py
@@ -0,0 +1,70 @@
+# Copyright 2011 Florent Le Coz <louiz@louiz.org>
+#
+# This file is part of Poezio.
+#
+# Poezio is free software: you can redistribute it and/or modify
+# it under the terms of the zlib license. See the COPYING file.
+
+"""
+Defines the Fifo class
+"""
+
+import logging
+log = logging.getLogger(__name__)
+
+import os
+import threading
+
+class OpenTrick(threading.Thread):
+    """
+    A threaded trick to make the open for writing succeed.
+    A fifo cannot be opened for writing if it has not been
+    yet opened by the other hand for reading.
+    So, we just open the fifo for reading and close it
+    immediately afterwards.
+    Once that is done, we can freely keep the fifo open for
+    writing and write things in it. The writing can fail if
+    there’s still nothing reading that fifo, but we just yell
+    an error in that case.
+    """
+    def __init__(self, path):
+        threading.Thread.__init__(self)
+        self.path = path
+
+    def run(self):
+        open(self.path, 'r').close()
+
+
+class Fifo(object):
+    """
+    Just a simple file handler, writing and reading in a fifo.
+    Mode is either 'r' or 'w', just like the mode for the open()
+    function.
+    """
+    def __init__(self, path, mode):
+        self.trick = None
+        if not os.path.exists(path):
+            os.mkfifo(path)
+        if mode == 'w':
+            self.trick = OpenTrick(path)
+            # that thread will wait until we open it for writing
+            self.trick.start()
+        self.fd = open(path, mode)
+
+    def write(self, data):
+        """
+        Try to write on the fifo. If that fails, this means
+        that nothing has that fifo opened, so the writing is useless,
+        so we just return (and display an error telling that, somewhere).
+        """
+        self.fd.write(data)
+        self.fd.flush()
+
+    def readline(self):
+        return self.fd.readline()
+
+    def __del__(self):
+        try:
+            self.fd.close()
+        except:
+            pass