summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core.py172
-rwxr-xr-xsrc/daemon.py50
-rw-r--r--src/data_forms.py21
-rw-r--r--src/fifo.py70
-rw-r--r--src/plugin.py86
-rw-r--r--src/plugin_manager.py125
-rw-r--r--src/tabs.py4
7 files changed, 502 insertions, 26 deletions
diff --git a/src/core.py b/src/core.py
index 8c4ad258..ac8842e7 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
@@ -45,6 +48,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 = {
@@ -75,6 +79,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.
@@ -83,6 +94,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.
@@ -101,6 +113,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),
@@ -110,11 +123,7 @@ class Core(object):
'prev': (self.rotate_rooms_left, _("Usage: /prev\nPrev: Go to the previous room."), None),
'win': (self.command_win, _("Usage: /win <number>\nWin: Go to the specified room."), self.completion_win),
'w': (self.command_win, _("Usage: /w <number>\nW: Go to the specified room."), self.completion_win),
- 'show': (self.command_status, _('Usage: /show <availability> [status message]\nShow: Sets your availability and (optionaly) your status message. The <availability> argument is one of \"available, chat, away, afk, dnd, busy, xa\" and the optional [status] argument will be your status message.'), self.completion_status),
'status': (self.command_status, _('Usage: /status <availability> [status message]\nStatus: Sets your availability and (optionaly) your status message. The <availability> argument is one of \"available, chat, away, afk, dnd, busy, xa\" and the optional [status] argument will be your status message.'), self.completion_status),
- 'away': (self.command_away, _("Usage: /away [message]\nAway: Sets your availability to away and (optionaly) your status message. This is equivalent to '/status away [message]'"), None),
- 'busy': (self.command_busy, _("Usage: /busy [message]\nBusy: Sets your availability to busy and (optionaly) your status message. This is equivalent to '/status busy [message]'"), None),
- 'available': (self.command_avail, _("Usage: /available [message]\nAvailable: Sets your availability to available and (optionaly) your status message. This is equivalent to '/status available [message]'"), None),
'bookmark': (self.command_bookmark, _("Usage: /bookmark [roomname][/nick]\nBookmark: Bookmark the specified room (you will then auto-join it on each poezio start). This commands uses the same syntaxe as /join. Type /help join for syntaxe examples. Note that when typing \"/bookmark\" on its own, the room will be bookmarked with the nickname you\'re currently using in this room (instead of default_nick)"), None),
'set': (self.command_set, _("Usage: /set <option> [value]\nSet: Sets the value to the option in your configuration file. You can, for example, change your default nickname by doing `/set default_nick toto` or your resource with `/set resource blabla`. You can also set an empty value (nothing) by providing no [value] after <option>."), None),
'theme': (self.command_theme, _('Usage: /theme\nTheme: Reload the theme defined in the config file.'), None),
@@ -124,7 +133,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 = {
@@ -144,7 +154,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
@@ -170,8 +179,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):
"""
@@ -199,6 +213,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.
@@ -1117,6 +1182,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]
@@ -1390,24 +1477,6 @@ class Core(object):
msg = "%s=%s" % (option, value)
self.information(msg, 'Info')
- def command_away(self, arg):
- """
- /away [msg]
- """
- self.command_status("away "+arg)
-
- def command_busy(self, arg):
- """
- /busy [msg]
- """
- self.command_status("busy "+arg)
-
- def command_avail(self, arg):
- """
- /avail [msg]
- """
- self.command_status("available "+arg)
-
def close_tab(self, tab=None):
"""
Close the given tab. If None, close the current one
@@ -1599,3 +1668,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.strip(), 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..f23d6b5f
--- /dev/null
+++ b/src/daemon.py
@@ -0,0 +1,50 @@
+#/usr/bin/env python3
+# 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 reads commands on
+stdin and executes them (each line should be a command).
+
+Usage: cat some_fifo | ./daemon.py
+
+Poezio writes commands in the fifo, 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
+
+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.strip(),))
+ subprocess.call(self.command.split())
+
+def main():
+ while True:
+ line = sys.stdin.readline()
+ if line == '':
+ break
+ e = Executor(line)
+ e.start()
+
+if __name__ == '__main__':
+ main()
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 1209038c..07652f74 100644
--- a/src/tabs.py
+++ b/src/tabs.py
@@ -323,6 +323,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()
@@ -392,6 +393,9 @@ class ChatTab(Tab):
self.text_win.refresh()
self.input.refresh()
+ def get_conversation_messages(self):
+ return self._room.messages
+
def command_say(self, line):
raise NotImplementedError
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-03 20:42:38 +0000