diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/core.py | 150 | ||||
| -rwxr-xr-x | src/daemon.py | 63 | ||||
| -rw-r--r-- | src/data_forms.py | 21 | ||||
| -rw-r--r-- | src/fifo.py | 70 | ||||
| -rw-r--r-- | src/plugin.py | 86 | ||||
| -rw-r--r-- | src/plugin_manager.py | 125 | ||||
| -rw-r--r-- | src/tabs.py | 4 |
7 files changed, 515 insertions, 4 deletions
diff --git a/src/core.py b/src/core.py index 8abaec63..1fb06b38 100644 --- a/src/core.py +++ b/src/core.py @@ -16,6 +16,7 @@ import threading import traceback from datetime import datetime +from inspect import getargspec import common import theming @@ -36,6 +37,8 @@ import windows import connection import timed_events +from plugin_manager import PluginManager + from data_forms import DataFormsTab from config import config, options from logger import logger @@ -46,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 = { @@ -76,6 +80,13 @@ class Core(object): """ User interface using ncurses """ + + # dict containing the name of the internal events + # used with the plugins, the key is the name of the event + # and the value is the number of arguments the handler must take + internal_events = { + 'enter': 2, + } def __init__(self): # All uncaught exception are given to this callback, instead # of being displayed on the screen and exiting the program. @@ -84,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. @@ -102,6 +114,7 @@ class Core(object): # a completion function, taking a Input as argument. Can be None) # The completion function should return True if a completion was # made ; False otherwise + self.plugin_manager = PluginManager(self) self.commands = { 'help': (self.command_help, '\_o< KOIN KOIN KOIN', self.completion_help), 'join': (self.command_join, _("Usage: /join [room_name][@server][/nick] [password]\nJoin: Join the specified room. You can specify a nickname after a slash (/). If no nickname is specified, you will use the default_nick in the configuration file. You can omit the room name: you will then join the room you\'re looking at (useful if you were kicked). You can also provide a room_name without specifying a server, the server of the room you're currently in will be used. You can also provide a password to join the room.\nExamples:\n/join room@server.tld\n/join room@server.tld/John\n/join room2\n/join /me_again\n/join\n/join room@server.tld/my_nick password\n/join / password"), self.completion_join), @@ -125,7 +138,8 @@ class Core(object): 'connect': (self.command_reconnect, _('Usage: /connect\nConnect: disconnect from the remote server if you are currently connected and then connect to it again'), None), 'server_cycle': (self.command_server_cycle, _('Usage: /server_cycle [domain] [message]\nServer Cycle: disconnect and reconnects in all the rooms in domain.'), None), 'bind': (self.command_bind, _('Usage: /bind <key> <equ>\nBind: bind a key to an other key or to a “command”. For example "/bind ^H KEY_UP" makes Control + h do the same same than the Up key.'), None), -# nope 'pubsub': (self.command_pubsub, _('Usage: /pubsub <domain>\nPubsub: Open a pubsub browser on the given domain'), None), + 'load': (self.command_load, _('Usage: /load <plugin>\nLoad: Load the specified plugin'), self.plugin_manager.completion_load), + 'unload': (self.command_unload, _('Usage: /unload <plugin>\nUnload: Unload the specified plugin'), self.plugin_manager.completion_unload), } self.key_func = { @@ -145,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 @@ -171,8 +184,13 @@ class Core(object): self.timed_events = set() - def coucou(self): - self.command_pubsub('pubsub.louiz.org') + self.connected_events = {} + self.autoload_plugins() + + def autoload_plugins(self): + plugins = config.get('plugins_autoload', '') + for plugin in plugins.split(): + self.plugin_manager.load(plugin) def start(self): """ @@ -200,6 +218,57 @@ class Core(object): )) self.refresh_window() + def connect(self, event, handler): + """ + Connect an handler to an internal event of poezio + (eg "enter pressed in a chattab") + """ + # Fail if the method doesn’t take at least the good number of arguments + # or if the event is unknown + if not event in self.internal_events \ + or len(getargspec(handler).args) < self.internal_events[event]: + return False + + module_name = handler.__module__ + if not event in self.connected_events: + self.connected_events[event] = {} + if not module_name in self.connected_events[event]: + self.connected_events[event][module_name] = [] + + self.connected_events[event][module_name].append(handler) + return True + + def run_event(self, event, **kwargs): + """ + Call the handlers associated with an event + """ + if event in self.connected_events: + for module in self.connected_events[event]: + for handler in self.connected_events[event][module]: + try: + handler(**kwargs) + except: + import traceback + tp = traceback.format_exc() + module_name = handler.__name__ + log.debug('ERROR: in plugin %s, \n%s' % (module_name, tp)) + + def disconnect(self, event, handler): + """ + Disconnect a handler from an event + """ + if not event in self.internal_events: + return False + + module_name = getmodule(handler).__name__ + if not event in self.connected_events: + return False + if not module_name in self.connected_events[event]: + return False + + self.connected_events[event][module_name].remove(handler) + return True + def resize_global_information_win(self): """ Resize the global_information_win only once at each resize. @@ -1124,6 +1193,28 @@ class Core(object): def completion_status(self, the_input): return the_input.auto_completion([status for status in possible_show], ' ') + def command_load(self, arg): + """ + /load <plugin> + """ + args = arg.split() + if len(args) != 1: + self.command_help('load') + return + filename = args[0] + self.plugin_manager.load(filename) + + def command_unload(self, arg): + """ + /unload <plugin> + """ + args = arg.split() + if len(args) != 1: + self.command_help('unload') + return + filename = args[0] + self.plugin_manager.unload(filename) + def command_message(self, arg): """ /message <jid> [message] @@ -1604,3 +1695,54 @@ class Core(object): if not self.running or self.background is True: return curses.doupdate() + + def send_message(self, msg): + """ + Function to use in plugins to send a message in the current conversation. + Returns False if the current tab is not a conversation tab + """ + if not isinstance(self.current_tab(), tabs.ChatTab): + 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. + """ + command = '%s\n' % (command,) + 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 + + def get_conversation_messages(self): + """ + Returns a list of all the messages in the current chat. + If the current tab is not a ChatTab, returns None. + + Messages are namedtuples of the form + ('txt nick_color time str_time nickname user') + """ + if not isinstance(self.current_tab(), tabs.ChatTab): + return None + return self.current_tab().get_conversation_messages() 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/data_forms.py b/src/data_forms.py index a7bbe97f..8445d3d2 100644 --- a/src/data_forms.py +++ b/src/data_forms.py @@ -152,6 +152,26 @@ class DummyInput(FieldInput, windows.Win): def is_dummy(self): return True +class ColoredLabel(windows.Win): + def __init__(self, text): + self.text = text + self.color = 14 + windows.Win.__init__(self) + + def resize(self, height, width, y, x): + self._resize(height, width, y, x) + + def set_color(self, color): + self.color = color + self.refresh() + + def refresh(self): + with g_lock: + self._win.attron(curses.color_pair(self.color)) + self.addstr(0, 0, self.text) + self._win.attroff(curses.color_pair(self.color)) + self._refresh() + class BooleanWin(FieldInput, windows.Win): def __init__(self, field): FieldInput.__init__(self, field) @@ -502,6 +522,7 @@ class FormWin(object): for i, inp in enumerate(self.inputs): if i >= self.height: break + inp['label'].refresh() inp['input'].refresh() inp['label'].refresh() if self.current_input < self.height-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 diff --git a/src/plugin.py b/src/plugin.py new file mode 100644 index 00000000..a8eb5934 --- /dev/null +++ b/src/plugin.py @@ -0,0 +1,86 @@ +import os +from configparser import ConfigParser +import config +import inspect +import traceback + +class PluginConfig(config.Config): + def __init__(self, filename): + ConfigParser.__init__(self) + self.__config_file__ = filename + self.read() + + def read(self): + """Read the config file""" + ConfigParser.read(self, self.__config_file__) + + def write(self): + """Write the config to the disk""" + try: + fp = open(self.__config_file__, 'w') + ConfigParser.write(self, fp) + fp.close() + return True + except IOError: + return False + + +class SafetyMetaclass(type): + # A hack + core = None + + @staticmethod + def safe_func(f): + def helper(*args, **kwargs): + try: + return f(*args, **kwargs) + except: + if inspect.stack()[1][1] == inspect.getfile(f): + raise + elif SafetyMetaclass.core: + SafetyMetaclass.core.information(traceback.format_exc()) + return None + return helper + + def __new__(meta, name, bases, class_dict): + for k, v in class_dict.items(): + if inspect.isfunction(v): + class_dict[k] = SafetyMetaclass.safe_func(v) + return type.__new__(meta, name, bases, class_dict) + +class BasePlugin(object, metaclass=SafetyMetaclass): + """ + Class that all plugins derive from. Any methods beginning with command_ + are interpreted as a command and beginning with on_ are interpreted as + event handlers + """ + + def __init__(self, plugin_manager, core, plugins_conf_dir): + self.core = core + # More hack; luckily we'll never have more than one core object + SafetyMetaclass.core = core + self.plugin_manager = plugin_manager + conf = os.path.join(plugins_conf_dir, self.__module__+'.cfg') + self.config = PluginConfig(conf) + self.init() + + def init(self): + pass + + def cleanup(self): + pass + + def unload(self): + self.cleanup() + + def add_command(self, name, handler, help, completion=None): + return self.plugin_manager.add_command(self.__module__, name, handler, help, completion) + + def del_command(self, name): + return self.plugin_manager.del_command(self.__module__, name) + + def add_event_handler(self, event_name, handler): + return self.plugin_manager.add_event_handler(self.__module__, event_name, handler) + + def del_event_handler(self, event_name, handler): + return self.plugin_manager.del_event_handler(self.__module__, event_name, handler) diff --git a/src/plugin_manager.py b/src/plugin_manager.py new file mode 100644 index 00000000..5bd6d75b --- /dev/null +++ b/src/plugin_manager.py @@ -0,0 +1,125 @@ +import imp +import os +import sys +from config import config +from gettext import gettext as _ + +plugins_dir = config.get('plugins_dir', '') +plugins_dir = plugins_dir or\ + os.path.join(os.environ.get('XDG_DATA_HOME') or\ + os.path.join(os.environ.get('HOME'), '.local', 'share'), + 'poezio', 'plugins') + +config_home = os.environ.get("XDG_CONFIG_HOME") +if not config_home: + config_home = os.path.join(os.environ.get('HOME'), '.config') +plugins_conf_dir = os.path.join(config_home, 'poezio', 'plugins') + +try: + os.makedirs(plugins_dir) +except OSError: + pass + +try: + os.makedirs(plugins_conf_dir) +except OSError: + pass + +sys.path.append(plugins_dir) + +class PluginManager(object): + def __init__(self, core): + self.core = core + self.modules = {} # module name -> module object + self.plugins = {} # module name -> plugin object + self.commands = {} # module name -> dict of commands loaded for the module + self.event_handlers = {} # module name -> list of event_name/handler pairs loaded for the module + + def load(self, name): + if name in self.plugins: + self.unload(name) + + try: + if name in self.modules: + imp.acquire_lock() + module = imp.reload(self.modules[name]) + imp.release_lock() + else: + file, filename, info = imp.find_module(name, [plugins_dir]) + imp.acquire_lock() + module = imp.load_module(name, file, filename, info) + imp.release_lock() + except Exception as e: + import traceback + self.core.information(_("Could not load plugin: ") + traceback.format_exc(), 'Error') + return + finally: + if imp.lock_held(): + imp.release_lock() + + self.modules[name] = module + self.commands[name] = {} + self.event_handlers[name] = [] + self.plugins[name] = module.Plugin(self, self.core, plugins_conf_dir) + + def unload(self, name): + if name in self.plugins: + try: + for command in self.commands[name].keys(): + del self.core.commands[command] + for event_name, handler in self.event_handlers[name]: + self.core.xmpp.del_event_handler(event_name, handler) + for event_name in self.core.internal_events: + if name in event_name: + del event_name[name] + + self.plugins[name].unload() + del self.plugins[name] + del self.commands[name] + del self.event_handlers[name] + except Exception as e: + import traceback + self.core.information(_("Could not unload plugin (may not be safe to try again): ") + traceback.format_exc()) + + def del_command(self, module_name, name): + if name in self.commands[module_name]: + del self.commands[module_name][name] + if name in self.core.commands: + del self.core.commands[name] + + def add_command(self, module_name, name, handler, help, completion=None): + if name in self.core.commands: + raise Exception(_("Command '%s' already exists") % (name,)) + + commands = self.commands[module_name] + commands[name] = (handler, help, completion) + self.core.commands[name] = (handler, help, completion) + + def add_event_handler(self, module_name, event_name, handler): + eh = self.event_handlers[module_name] + eh.append((event_name, handler)) + self.core.xmpp.add_event_handler(event_name, handler) + + def del_event_handler(self, module_name, event_name, handler): + self.core.xmpp.del_event_handler(event_name, handler) + eh = self.event_handlers[module_name] + eh = list(filter(lambda e : e != (event_name, handler), eh)) + + def completion_load(self, the_input): + """ + completion function that completes the name of the plugins, from + all .py files in plugins_dir + """ + try: + names = os.listdir(plugins_dir) + except OSError as e: + self.core.information(_('Completion failed: %s' % e), 'Error') + return + plugins_files = [name[:-3] for name in names if name.endswith('.py')] + return the_input.auto_completion(plugins_files, '') + + def completion_unload(self, the_input): + """ + completion function that completes the name of the plugins that are loaded + """ + return the_input.auto_completion(list(self.plugins.keys()), '') diff --git a/src/tabs.py b/src/tabs.py index 8c4e8717..b0de89c0 100644 --- a/src/tabs.py +++ b/src/tabs.py @@ -304,6 +304,7 @@ class ChatTab(Tab): if not self.execute_command(clean_text): if txt.startswith('//'): txt = txt[1:] + self.core.run_event('enter', line=txt) self.command_say(txt) self.cancel_paused_delay() @@ -373,6 +374,9 @@ class ChatTab(Tab): self.text_win.refresh(self._room) self.input.refresh() + def get_conversation_messages(self): + return self._room.messages + def command_say(self, line): raise NotImplementedError |