From 841914c050bc00a39d9313c05856568696e58a23 Mon Sep 17 00:00:00 2001 From: Brendan Taylor Date: Mon, 11 Apr 2011 19:59:51 -0600 Subject: move examples/data/scripts/uzbl-event-manager to bin/uzbl-event-manager --- examples/data/scripts/uzbl-event-manager | 991 ------------------------------- 1 file changed, 991 deletions(-) delete mode 100755 examples/data/scripts/uzbl-event-manager (limited to 'examples/data') diff --git a/examples/data/scripts/uzbl-event-manager b/examples/data/scripts/uzbl-event-manager deleted file mode 100755 index cb462c7..0000000 --- a/examples/data/scripts/uzbl-event-manager +++ /dev/null @@ -1,991 +0,0 @@ -#!/usr/bin/env python - -# Event Manager for Uzbl -# Copyright (c) 2009-2010, Mason Larobina -# Copyright (c) 2009, Dieter Plaetinck -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see . - -''' - -E V E N T _ M A N A G E R . P Y -=============================== - -Event manager for uzbl written in python. - -''' - -import atexit -import imp -import logging -import os -import socket -import sys -import time -import weakref -import re -from collections import defaultdict -from functools import partial -from glob import glob -from itertools import count -from optparse import OptionParser -from select import select -from signal import signal, SIGTERM, SIGINT -from socket import socket, AF_UNIX, SOCK_STREAM -from traceback import format_exc - -def xdghome(key, default): - '''Attempts to use the environ XDG_*_HOME paths if they exist otherwise - use $HOME and the default path.''' - - xdgkey = "XDG_%s_HOME" % key - if xdgkey in os.environ.keys() and os.environ[xdgkey]: - return os.environ[xdgkey] - - return os.path.join(os.environ['HOME'], default) - -# `make install` will put the correct value here for your system -PREFIX = '/usr/local/' - -# Setup xdg paths. -DATA_DIR = os.path.join(xdghome('DATA', '.local/share/'), 'uzbl/') -CACHE_DIR = os.path.join(xdghome('CACHE', '.cache/'), 'uzbl/') - -# Define some globals. -SCRIPTNAME = os.path.basename(sys.argv[0]) - -def get_exc(): - '''Format `format_exc` for logging.''' - return "\n%s" % format_exc().rstrip() - -def expandpath(path): - '''Expand and realpath paths.''' - return os.path.realpath(os.path.expandvars(path)) - -def ascii(u): - '''Convert unicode strings into ascii for transmission over - ascii-only streams/sockets/devices.''' - return u.encode('utf-8') - - -def daemonize(): - '''Daemonize the process using the Stevens' double-fork magic.''' - - logger.info('entering daemon mode') - - try: - if os.fork(): - os._exit(0) - - except OSError: - logger.critical(get_exc()) - sys.exit(1) - - os.chdir('/') - os.setsid() - os.umask(0) - - try: - if os.fork(): - os._exit(0) - - except OSError: - logger.critical(get_exc()) - sys.exit(1) - - if sys.stdout.isatty(): - sys.stdout.flush() - sys.stderr.flush() - - devnull = '/dev/null' - stdin = file(devnull, 'r') - stdout = file(devnull, 'a+') - stderr = file(devnull, 'a+', 0) - - os.dup2(stdin.fileno(), sys.stdin.fileno()) - os.dup2(stdout.fileno(), sys.stdout.fileno()) - os.dup2(stderr.fileno(), sys.stderr.fileno()) - - logger.info('entered daemon mode') - - -def make_dirs(path): - '''Make all basedirs recursively as required.''' - - try: - dirname = os.path.dirname(path) - if not os.path.isdir(dirname): - logger.debug('creating directories %r' % dirname) - os.makedirs(dirname) - - except OSError: - logger.error(get_exc()) - - -class EventHandler(object): - '''Event handler class. Used to store args and kwargs which are merged - come time to call the callback with the event args and kwargs.''' - - nextid = count().next - - def __init__(self, plugin, event, callback, args, kwargs): - self.id = self.nextid() - self.plugin = plugin - self.event = event - self.callback = callback - self.args = args - self.kwargs = kwargs - - - def __repr__(self): - elems = ['id=%d' % self.id, 'event=%s' % self.event, - 'callback=%r' % self.callback] - - if self.args: - elems.append('args=%s' % repr(self.args)) - - if self.kwargs: - elems.append('kwargs=%s' % repr(self.kwargs)) - - elems.append('plugin=%s' % self.plugin.name) - return u'' % ', '.join(elems) - - - def call(self, uzbl, *args, **kwargs): - '''Execute the handler function and merge argument lists.''' - - args = args + self.args - kwargs = dict(self.kwargs.items() + kwargs.items()) - self.callback(uzbl, *args, **kwargs) - - - - - -class Plugin(object): - '''Plugin module wrapper object.''' - - # Special functions exported from the Plugin instance to the - # plugin namespace. - special_functions = ['require', 'export', 'export_dict', 'connect', - 'connect_dict', 'logger', 'unquote', 'splitquoted'] - - - def __init__(self, parent, name, path, plugin): - self.parent = parent - self.name = name - self.path = path - self.plugin = plugin - self.logger = get_logger('plugin.%s' % name) - - # Weakrefs to all handlers created by this plugin - self.handlers = set([]) - - # Plugins init hook - init = getattr(plugin, 'init', None) - self.init = init if callable(init) else None - - # Plugins optional after hook - after = getattr(plugin, 'after', None) - self.after = after if callable(after) else None - - # Plugins optional cleanup hook - cleanup = getattr(plugin, 'cleanup', None) - self.cleanup = cleanup if callable(cleanup) else None - - assert init or after or cleanup, "missing hooks in plugin" - - # Export plugin's instance methods to plugin namespace - for attr in self.special_functions: - plugin.__dict__[attr] = getattr(self, attr) - - - def __repr__(self): - return u'' % self.plugin - - - def export(self, uzbl, attr, object, prepend=True): - '''Attach `object` to `uzbl` instance. This is the preferred method - of sharing functionality, functions, data and objects between - plugins. - - If the object is callable you may wish to turn the callable object - in to a meta-instance-method by prepending `uzbl` to the call stack. - You can change this behaviour with the `prepend` argument. - ''' - - assert attr not in uzbl.exports, "attr %r already exported by %r" %\ - (attr, uzbl.exports[attr][0]) - - prepend = True if prepend and callable(object) else False - uzbl.__dict__[attr] = partial(object, uzbl) if prepend else object - uzbl.exports[attr] = (self, object, prepend) - uzbl.logger.info('exported %r to %r by plugin %r, prepended %r' - % (object, 'uzbl.%s' % attr, self.name, prepend)) - - - def export_dict(self, uzbl, exports): - for (attr, object) in exports.items(): - self.export(uzbl, attr, object) - - - def find_handler(self, event, callback, args, kwargs): - '''Check if a handler with the identical callback and arguments - exists and return it.''' - - # Remove dead refs - self.handlers -= set(filter(lambda ref: not ref(), self.handlers)) - - # Find existing identical handler - for handler in [ref() for ref in self.handlers]: - if handler.event == event and handler.callback == callback \ - and handler.args == args and handler.kwargs == kwargs: - return handler - - - def connect(self, uzbl, event, callback, *args, **kwargs): - '''Create an event handler object which handles `event` events. - - Arguments passed to the connect function (`args` and `kwargs`) are - stored in the handler object and merged with the event arguments - come handler execution. - - All handler functions must behave like a `uzbl` instance-method (that - means `uzbl` is prepended to the callback call arguments).''' - - # Sanitise and check event name - event = event.upper().strip() - assert event and ' ' not in event - - assert callable(callback), 'callback must be callable' - - # Check if an identical handler already exists - handler = self.find_handler(event, callback, args, kwargs) - if not handler: - # Create a new handler - handler = EventHandler(self, event, callback, args, kwargs) - self.handlers.add(weakref.ref(handler)) - self.logger.info('new %r' % handler) - - uzbl.handlers[event].append(handler) - uzbl.logger.info('connected %r' % handler) - return handler - - - def connect_dict(self, uzbl, connects): - for (event, callback) in connects.items(): - self.connect(uzbl, event, callback) - - - def require(self, plugin): - '''Check that plugin with name `plugin` has been loaded. Use this to - ensure that your plugins dependencies have been met.''' - - assert plugin in self.parent.plugins, self.logger.critical( - 'plugin %r required by plugin %r' (plugin, self.name)) - - @classmethod - def unquote(cls, s): - '''Removes quotation marks around strings if any and interprets - \\-escape sequences using `string_escape`''' - if s and s[0] == s[-1] and s[0] in ['"', "'"]: - s = s[1:-1] - return s.encode('utf-8').decode('string_escape').decode('utf-8') - - _splitquoted = re.compile("( |\"(?:\\\\.|[^\"])*?\"|'(?:\\\\.|[^'])*?')") - @classmethod - def splitquoted(cls, text): - '''Splits string on whitespace while respecting quotations''' - return [cls.unquote(p) for p in cls._splitquoted.split(text) if p.strip()] - - -class Uzbl(object): - def __init__(self, parent, child_socket): - self.opts = opts - self.parent = parent - self.child_socket = child_socket - self.time = time.time() - self.pid = None - self.name = None - - # Flag if the instance has raised the INSTANCE_START event. - self.instance_start = False - - # Use name "unknown" until name is discovered. - self.logger = get_logger('uzbl-instance[]') - - # Track plugin event handlers and exported functions. - self.exports = {} - self.handlers = defaultdict(list) - - # Internal vars - self._depth = 0 - self._buffer = '' - - - def __repr__(self): - return '' % ', '.join([ - 'pid=%s' % (self.pid if self.pid else "Unknown"), - 'name=%s' % ('%r' % self.name if self.name else "Unknown"), - 'uptime=%f' % (time.time()-self.time), - '%d exports' % len(self.exports.keys()), - '%d handlers' % sum([len(l) for l in self.handlers.values()])]) - - - def init_plugins(self): - '''Call the init and after hooks in all loaded plugins for this - instance.''' - - # Initialise each plugin with the current uzbl instance. - for plugin in self.parent.plugins.values(): - if plugin.init: - self.logger.debug('calling %r plugin init hook' % plugin.name) - plugin.init(self) - - # Allow plugins to use exported features of other plugins by calling an - # optional `after` function in the plugins namespace. - for plugin in self.parent.plugins.values(): - if plugin.after: - self.logger.debug('calling %r plugin after hook'%plugin.name) - plugin.after(self) - - - def send(self, msg): - '''Send a command to the uzbl instance via the child socket - instance.''' - - msg = msg.strip() - assert self.child_socket, "socket inactive" - - if opts.print_events: - print ascii(u'%s<-- %s' % (' ' * self._depth, msg)) - - self.child_socket.send(ascii("%s\n" % msg)) - - - def read(self): - '''Read data from the child socket and pass lines to the parse_msg - function.''' - - try: - raw = unicode(self.child_socket.recv(8192), 'utf-8', 'ignore') - if not raw: - self.logger.debug('read null byte') - return self.close() - - except: - self.logger.error(get_exc()) - return self.close() - - lines = (self._buffer + raw).split('\n') - self._buffer = lines.pop() - - for line in filter(None, map(unicode.strip, lines)): - try: - self.parse_msg(line.strip()) - - except: - self.logger.error(get_exc()) - self.logger.error('erroneous event: %r' % line) - - - def parse_msg(self, line): - '''Parse an incoming message from a uzbl instance. Event strings - will be parsed into `self.event(event, args)`.''' - - # Split by spaces (and fill missing with nulls) - elems = (line.split(' ', 3) + ['',]*3)[:4] - - # Ignore non-event messages. - if elems[0] != 'EVENT': - logger.info('non-event message: %r' % line) - if opts.print_events: - print '--- %s' % ascii(line) - return - - # Check event string elements - (name, event, args) = elems[1:] - assert name and event, 'event string missing elements' - if not self.name: - self.name = name - self.logger = get_logger('uzbl-instance%s' % name) - self.logger.info('found instance name %r' % name) - - assert self.name == name, 'instance name mismatch' - - # Handle the event with the event handlers through the event method - self.event(event, args) - - - def event(self, event, *args, **kargs): - '''Raise an event.''' - - event = event.upper() - - if not opts.daemon_mode and opts.print_events: - elems = [event,] - if args: elems.append(unicode(args)) - if kargs: elems.append(unicode(kargs)) - print ascii(u'%s--> %s' % (' ' * self._depth, ' '.join(elems))) - - if event == "INSTANCE_START" and args: - assert not self.instance_start, 'instance already started' - - self.pid = int(args[0]) - self.logger.info('found instance pid %r' % self.pid) - - self.init_plugins() - - elif event == "INSTANCE_EXIT": - self.logger.info('uzbl instance exit') - self.close() - - if event not in self.handlers: - return - - for handler in self.handlers[event]: - self._depth += 1 - try: - handler.call(self, *args, **kargs) - - except: - self.logger.error(get_exc()) - - self._depth -= 1 - - - def close_connection(self, child_socket): - '''Close child socket and delete the uzbl instance created for that - child socket connection.''' - - - def close(self): - '''Close the client socket and call the plugin cleanup hooks.''' - - self.logger.debug('called close method') - - # Remove self from parent uzbls dict. - if self.child_socket in self.parent.uzbls: - self.logger.debug('removing self from uzbls list') - del self.parent.uzbls[self.child_socket] - - try: - if self.child_socket: - self.logger.debug('closing child socket') - self.child_socket.close() - - except: - self.logger.error(get_exc()) - - finally: - self.child_socket = None - - # Call plugins cleanup hooks. - for plugin in self.parent.plugins.values(): - if plugin.cleanup: - self.logger.debug('calling %r plugin cleanup hook' - % plugin.name) - plugin.cleanup(self) - - logger.info('removed %r' % self) - - -class UzblEventDaemon(object): - def __init__(self): - self.opts = opts - self.server_socket = None - self._quit = False - - # Hold uzbl instances - # {child socket: Uzbl instance, ..} - self.uzbls = {} - - # Hold plugins - # {plugin name: Plugin instance, ..} - self.plugins = {} - - # Register that the event daemon server has started by creating the - # pid file. - make_pid_file(opts.pid_file) - - # Register a function to clean up the socket and pid file on exit. - atexit.register(self.quit) - - # Add signal handlers. - for sigint in [SIGTERM, SIGINT]: - signal(sigint, self.quit) - - # Load plugins into self.plugins - self.load_plugins(opts.plugins) - - - def load_plugins(self, plugins): - '''Load event manager plugins.''' - - for path in plugins: - logger.debug('loading plugin %r' % path) - (dir, file) = os.path.split(path) - name = file[:-3] if file.lower().endswith('.py') else file - - info = imp.find_module(name, [dir,]) - module = imp.load_module(name, *info) - - # Check if the plugin has a callable hook. - hooks = filter(callable, [getattr(module, attr, None) \ - for attr in ['init', 'after', 'cleanup']]) - assert hooks, "no hooks in plugin %r" % module - - logger.debug('creating plugin instance for %r plugin' % name) - plugin = Plugin(self, name, path, module) - self.plugins[name] = plugin - logger.info('new %r' % plugin) - - - def create_server_socket(self): - '''Create the event manager daemon socket for uzbl instance duplex - communication.''' - - # Close old socket. - self.close_server_socket() - - sock = socket(AF_UNIX, SOCK_STREAM) - sock.bind(opts.server_socket) - sock.listen(5) - - self.server_socket = sock - logger.debug('bound server socket to %r' % opts.server_socket) - - - def run(self): - '''Main event daemon loop.''' - - logger.debug('entering main loop') - - # Create and listen on the server socket - self.create_server_socket() - - if opts.daemon_mode: - # Daemonize the process - daemonize() - - # Update the pid file - make_pid_file(opts.pid_file) - - try: - # Accept incoming connections and listen for incoming data - self.listen() - - except: - if not self._quit: - logger.critical(get_exc()) - - # Clean up and exit - self.quit() - - logger.debug('exiting main loop') - - - def listen(self): - '''Accept incoming connections and constantly poll instance sockets - for incoming data.''' - - logger.info('listening on %r' % opts.server_socket) - - # Count accepted connections - connections = 0 - - while (self.uzbls or not connections) or (not opts.auto_close): - socks = [self.server_socket] + self.uzbls.keys() - reads, _, errors = select(socks, [], socks, 1) - - if self.server_socket in reads: - reads.remove(self.server_socket) - - # Accept connection and create uzbl instance. - child_socket = self.server_socket.accept()[0] - self.uzbls[child_socket] = Uzbl(self, child_socket) - connections += 1 - - for uzbl in [self.uzbls[s] for s in reads]: - uzbl.read() - - for uzbl in [self.uzbls[s] for s in errors]: - uzbl.logger.error('socket read error') - uzbl.close() - - logger.info('auto closing') - - - def close_server_socket(self): - '''Close and delete the server socket.''' - - try: - if self.server_socket: - logger.debug('closing server socket') - self.server_socket.close() - self.server_socket = None - - if os.path.exists(opts.server_socket): - logger.info('unlinking %r' % opts.server_socket) - os.unlink(opts.server_socket) - - except: - logger.error(get_exc()) - - - def quit(self, sigint=None, *args): - '''Close all instance socket objects, server socket and delete the - pid file.''' - - if sigint == SIGTERM: - logger.critical('caught SIGTERM, exiting') - - elif sigint == SIGINT: - logger.critical('caught SIGINT, exiting') - - elif not self._quit: - logger.debug('shutting down event manager') - - self.close_server_socket() - - for uzbl in self.uzbls.values(): - uzbl.close() - - del_pid_file(opts.pid_file) - - if not self._quit: - logger.info('event manager shut down') - self._quit = True - - -def make_pid_file(pid_file): - '''Creates a pid file at `pid_file`, fails silently.''' - - try: - logger.debug('creating pid file %r' % pid_file) - make_dirs(pid_file) - pid = os.getpid() - fileobj = open(pid_file, 'w') - fileobj.write('%d' % pid) - fileobj.close() - logger.info('created pid file %r with pid %d' % (pid_file, pid)) - - except: - logger.error(get_exc()) - - -def del_pid_file(pid_file): - '''Deletes a pid file at `pid_file`, fails silently.''' - - if os.path.isfile(pid_file): - try: - logger.debug('deleting pid file %r' % pid_file) - os.remove(pid_file) - logger.info('deleted pid file %r' % pid_file) - - except: - logger.error(get_exc()) - - -def get_pid(pid_file): - '''Reads a pid from pid file `pid_file`, fails None.''' - - try: - logger.debug('reading pid file %r' % pid_file) - fileobj = open(pid_file, 'r') - pid = int(fileobj.read()) - fileobj.close() - logger.info('read pid %d from pid file %r' % (pid, pid_file)) - return pid - - except (IOError, ValueError): - logger.error(get_exc()) - return None - - -def pid_running(pid): - '''Checks if a process with a pid `pid` is running.''' - - try: - os.kill(pid, 0) - except OSError: - return False - else: - return True - - -def term_process(pid): - '''Asks nicely then forces process with pid `pid` to exit.''' - - try: - logger.info('sending SIGTERM to process with pid %r' % pid) - os.kill(pid, SIGTERM) - - except OSError: - logger.error(get_exc()) - - logger.debug('waiting for process with pid %r to exit' % pid) - start = time.time() - while True: - if not pid_running(pid): - logger.debug('process with pid %d exit' % pid) - return True - - if (time.time()-start) > 5: - logger.warning('process with pid %d failed to exit' % pid) - logger.info('sending SIGKILL to process with pid %d' % pid) - try: - os.kill(pid, SIGKILL) - except: - logger.critical(get_exc()) - raise - - if (time.time()-start) > 10: - logger.critical('unable to kill process with pid %d' % pid) - raise OSError - - time.sleep(0.25) - - -def stop_action(): - '''Stop the event manager daemon.''' - - pid_file = opts.pid_file - if not os.path.isfile(pid_file): - logger.error('could not find running event manager with pid file %r' - % opts.pid_file) - return - - pid = get_pid(pid_file) - if not pid_running(pid): - logger.debug('no process with pid %r' % pid) - del_pid_file(pid_file) - return - - logger.debug('terminating process with pid %r' % pid) - term_process(pid) - del_pid_file(pid_file) - logger.info('stopped event manager process with pid %d' % pid) - - -def start_action(): - '''Start the event manager daemon.''' - - pid_file = opts.pid_file - if os.path.isfile(pid_file): - pid = get_pid(pid_file) - if pid_running(pid): - logger.error('event manager already started with pid %d' % pid) - return - - logger.info('no process with pid %d' % pid) - del_pid_file(pid_file) - - UzblEventDaemon().run() - - -def restart_action(): - '''Restart the event manager daemon.''' - - stop_action() - start_action() - - -def list_action(): - '''List all the plugins that would be loaded in the current search - dirs.''' - - names = {} - for plugin in opts.plugins: - (head, tail) = os.path.split(plugin) - if tail not in names: - names[tail] = plugin - - for plugin in sorted(names.values()): - print plugin - - -if __name__ == "__main__": - parser = OptionParser('usage: %prog [options] {start|stop|restart|list}') - add = parser.add_option - - add('-v', '--verbose', - dest='verbose', default=2, action='count', - help='increase verbosity') - - add('-d', '--plugin-dir', - dest='plugin_dirs', action='append', metavar="DIR", default=[], - help='add extra plugin search dir, same as `-l "DIR/*.py"`') - - add('-l', '--load-plugin', - dest='load_plugins', action='append', metavar="PLUGIN", default=[], - help='load plugin, loads before plugins in search dirs') - - socket_location = os.path.join(CACHE_DIR, 'event_daemon') - add('-s', '--server-socket', - dest='server_socket', metavar="SOCKET", default=socket_location, - help='server AF_UNIX socket location') - - add('-p', '--pid-file', - metavar="FILE", dest='pid_file', - help='pid file location, defaults to server socket + .pid') - - add('-n', '--no-daemon', - dest='daemon_mode', action='store_false', default=True, - help='do not daemonize the process') - - add('-a', '--auto-close', - dest='auto_close', action='store_true', default=False, - help='auto close after all instances disconnect') - - add('-i', '--no-default-dirs', - dest='default_dirs', action='store_false', default=True, - help='ignore the default plugin search dirs') - - add('-o', '--log-file', - dest='log_file', metavar='FILE', - help='write logging output to a file, defaults to server socket +' - ' .log') - - add('-q', '--quiet-events', - dest='print_events', action="store_false", default=True, - help="silence the printing of events to stdout") - - (opts, args) = parser.parse_args() - - opts.server_socket = expandpath(opts.server_socket) - - # Set default pid file location - if not opts.pid_file: - opts.pid_file = "%s.pid" % opts.server_socket - - else: - opts.pid_file = expandpath(opts.pid_file) - - # Set default log file location - if not opts.log_file: - opts.log_file = "%s.log" % opts.server_socket - - else: - opts.log_file = expandpath(opts.log_file) - - # Logging setup - log_level = logging.CRITICAL - opts.verbose*10 - - # Console logging handler - ch = logging.StreamHandler() - ch.setLevel(max(log_level+10, 10)) - ch.setFormatter(logging.Formatter( - '%(name)s: %(levelname)s: %(message)s')) - - # File logging handler - fh = logging.FileHandler(opts.log_file, 'w', 'utf-8', 1) - fh.setLevel(max(log_level, 10)) - fh.setFormatter(logging.Formatter( - '[%(created)f] %(name)s: %(levelname)s: %(message)s')) - - # logging.getLogger wrapper which sets the levels and adds the - # file and console handlers automagically - def get_logger(name): - handlers = [ch, fh] - level = [max(log_level, 10),] - logger = logging.getLogger(name) - logger.setLevel(level[0]) - for handler in handlers: - logger.addHandler(handler) - - return logger - - # Get main logger - logger = get_logger(SCRIPTNAME) - logger.info('logging to %r' % opts.log_file) - - plugins = {} - - # Load all `opts.load_plugins` into the plugins list - for path in opts.load_plugins: - path = expandpath(path) - matches = glob(path) - if not matches: - parser.error('cannot find plugin(s): %r' % path) - - for plugin in matches: - (head, tail) = os.path.split(plugin) - if tail not in plugins: - logger.debug('found plugin: %r' % plugin) - plugins[tail] = plugin - - else: - logger.debug('ignoring plugin: %r' % plugin) - - # Add default plugin locations - if opts.default_dirs: - logger.debug('adding default plugin dirs to plugin dirs list') - opts.plugin_dirs += [os.path.join(DATA_DIR, 'plugins/'), - os.path.join(PREFIX, 'share/uzbl/examples/data/plugins/')] - - else: - logger.debug('ignoring default plugin dirs') - - # Load all plugins in `opts.plugin_dirs` into the plugins list - for dir in opts.plugin_dirs: - dir = expandpath(dir) - logger.debug('searching plugin dir: %r' % dir) - for plugin in glob(os.path.join(dir, '*.py')): - (head, tail) = os.path.split(plugin) - if tail not in plugins: - logger.debug('found plugin: %r' % plugin) - plugins[tail] = plugin - - else: - logger.debug('ignoring plugin: %r' % plugin) - - plugins = plugins.values() - - # Check all the paths in the plugins list are files - for plugin in plugins: - if not os.path.isfile(plugin): - parser.error('plugin not a file: %r' % plugin) - - if opts.auto_close: logger.debug('will auto close') - else: logger.debug('will not auto close') - - if opts.daemon_mode: logger.debug('will daemonize') - else: logger.debug('will not daemonize') - - opts.plugins = plugins - - # init like {start|stop|..} daemon actions - daemon_actions = {'start': start_action, 'stop': stop_action, - 'restart': restart_action, 'list': list_action} - - if len(args) == 1: - action = args[0] - if action not in daemon_actions: - parser.error('invalid action: %r' % action) - - elif not args: - logger.warning('no daemon action given, assuming %r' % 'start') - action = 'start' - - else: - parser.error('invalid action argument: %r' % args) - - logger.info('daemon action %r' % action) - # Do action - daemon_actions[action]() - - logger.debug('process CPU time: %f' % time.clock()) - -# vi: set et ts=4: -- cgit v1.2.3