diff options
| -rw-r--r-- | src/core.py | 34 | ||||
| -rwxr-xr-x | src/daemon.py | 63 | ||||
| -rw-r--r-- | src/fifo.py | 70 |
3 files changed, 163 insertions, 4 deletions
diff --git a/src/core.py b/src/core.py index 41a54b23..712eed62 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. @@ -157,7 +159,6 @@ class Core(object): 'M-z': self.go_to_previous_tab, '^L': self.full_screen_redraw, 'M-j': self.go_to_room_number, -# 'M-c': self.coucou, } # Add handlers @@ -191,9 +192,6 @@ class Core(object): for plugin in plugins.split(): self.plugin_manager.load(plugin) - def coucou(self): - self.command_pubsub('pubsub.louiz.org') - def start(self): """ Init curses, create the first tab, etc @@ -1707,3 +1705,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/daemon.py b/src/daemon.py new file mode 100755 index 00000000..a9d888f1 --- /dev/null +++ b/src/daemon.py @@ -0,0 +1,63 @@ +# 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. + +""" +This file is a standalone program that creates a fifo file (if it doesn’t exist +yet), opens it for reading, reads commands from it and executes them (each line +should be a command). + +Usage: ./daemon.py <path_tofifo> + +That fifo should be in a directory, shared through sshfs, with the remote +machine running poezio. Poezio then writes command in it, and this daemon +executes them on the local machine. +Note that you should not start this daemon if you do not trust the remote +machine that is running poezio, since this could make it run any (dangerous) +command on your local machine. +""" + +import sys +import threading +import subprocess + +from fifo import Fifo + +class Executor(threading.Thread): + """ + Just a class to execute commands in a thread. + This way, the execution can totally fail, we don’t care, + and we can start commands without having to wait for them + to return + """ + def __init__(self, command): + threading.Thread.__init__(self) + self.command = command + + def run(self): + print('executing %s' % (self.command,)) + subprocess.call(self.command.split()) + +def main(path): + while True: + fifo = Fifo(path, 'r') + while True: + line = fifo.readline() + if line == '': + del fifo + break + e = Executor(line) + e.start() + +def usage(): + print('Usage: %s <fifo_name>' % (sys.argv[0],)) + +if __name__ == '__main__': + argc = len(sys.argv) + if argc != 2: + usage() + else: + main(sys.argv[1]) 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 |