#!/usr/bin/env python

# Event Manager for Uzbl

# Copyright (c) 2009-2010, Mason Larobina <mason.larobina@gmail.com>

# Copyright (c) 2009, Dieter Plaetinck <dieter@plaetinck.be>

#

# 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 <http://www.gnu.org/licenses/>.

'''

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'<handler(%s)>' % ', '.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'<plugin(%r)>' % 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 '<uzbl(%s)>' % ', '.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