# client.py - inotify status client

#

# Copyright 2006, 2007, 2008 Bryan O'Sullivan <bos@serpentine.com>

# Copyright 2007, 2008 Brendan Cully <brendan@kublai.com>

# Copyright 2009 Nicolas Dumazet <nicdumz@gmail.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from mercurial.i18n import _

import common, server

import errno, os, socket, struct

class QueryFailed(Exception):

    pass

def start_server(function):

    """

    Decorator.

    Tries to call function, if it fails, try to (re)start inotify server.

    Raise QueryFailed if something went wrong

    """

    def decorated_function(self, *args):

        try:

            return function(self, *args)

        except (OSError, socket.error), err:

            autostart = self.ui.configbool('inotify', 'autostart', True)

            if err.args[0] == errno.ECONNREFUSED:

                self.ui.warn(_('inotify-client: found dead inotify server '

                               'socket; removing it\n'))

                os.unlink(os.path.join(self.root, '.hg', 'inotify.sock'))

            if err.args[0] in (errno.ECONNREFUSED, errno.ENOENT) and autostart:

                try:

                    try:

                        server.start(self.ui, self.dirstate, self.root,

                                     dict(daemon=True, daemon_pipefds=''))

                    except server.AlreadyStartedException, inst:

                        # another process may have started its own

                        # inotify server while this one was starting.

                        self.ui.debug(str(inst))

                except Exception, inst:

                    self.ui.warn(_('inotify-client: could not start inotify '

                                   'server: %s\n') % inst)

                else:

                    try:

                        return function(self, *args)

                    except socket.error, err:

                        self.ui.warn(_('inotify-client: could not talk to new '

                                       'inotify server: %s\n') % err.args[-1])

            elif err.args[0] in (errno.ECONNREFUSED, errno.ENOENT):

                # silently ignore normal errors if autostart is False

                self.ui.debug('(inotify server not running)\n')

            else:

                self.ui.warn(_('inotify-client: failed to contact inotify '

                               'server: %s\n') % err.args[-1])

        self.ui.traceback()

        raise QueryFailed('inotify query failed')

    return decorated_function

class client(object):

    def __init__(self, ui, repo):

        self.ui = ui

        self.dirstate = repo.dirstate

        self.root = repo.root

        self.sock = socket.socket(socket.AF_UNIX)

    def _connect(self):

        sockpath = os.path.join(self.root, '.hg', 'inotify.sock')

        try:

            self.sock.connect(sockpath)

        except socket.error, err:

            if err.args[0] == "AF_UNIX path too long":

                sockpath = os.readlink(sockpath)

                self.sock.connect(sockpath)

            else:

                raise

    def _send(self, type, data):

        """Sends protocol version number, and the data"""

        self.sock.sendall(chr(common.version) + type + data)

        self.sock.shutdown(socket.SHUT_WR)

    def _receive(self, type):

        """

        Read data, check version number, extract headers,

        and returns a tuple (data descriptor, header)

        Raises QueryFailed on error

        """

        cs = common.recvcs(self.sock)

        try:

            version = ord(cs.read(1))

        except TypeError:

            # empty answer, assume the server crashed

            self.ui.warn(_('inotify-client: received empty answer from inotify '

                           'server'))

            raise QueryFailed('server crashed')

        if version != common.version:

            self.ui.warn(_('(inotify: received response from incompatible '

                      'server version %d)\n') % version)

            raise QueryFailed('incompatible server version')

        readtype = cs.read(4)

        if readtype != type:

            self.ui.warn(_('(inotify: received \'%s\' response when expecting'

                       ' \'%s\')\n') % (readtype, type))

            raise QueryFailed('wrong response type')

        hdrfmt = common.resphdrfmts[type]

        hdrsize = common.resphdrsizes[type]

        try:

            resphdr = struct.unpack(hdrfmt, cs.read(hdrsize))

        except struct.error:

            raise QueryFailed('unable to retrieve query response headers')

        return cs, resphdr

    def query(self, type, req):

        self._connect()

        self._send(type, req)

        return self._receive(type)

    @start_server

    def statusquery(self, names, match, ignored, clean, unknown=True):

        def genquery():

            for n in names:

                yield n

            states = 'almrx!'

            if ignored:

                raise ValueError('this is insanity')

            if clean:

                states += 'c'

            if unknown:

                states += '?'

            yield states

        req = '\0'.join(genquery())

        cs, resphdr = self.query('STAT', req)

        def readnames(nbytes):

            if nbytes:

                names = cs.read(nbytes)

                if names:

                    return filter(match, names.split('\0'))

            return []

        results = tuple(map(readnames, resphdr[:-1]))

        if names:

            nbytes = resphdr[-1]

            vdirs = cs.read(nbytes)

            if vdirs:

                for vdir in vdirs.split('\0'):

                    if match.explicitdir:

                        match.explicitdir(vdir)

        return results

    @start_server

    def debugquery(self):

        cs, resphdr = self.query('DBUG', '')

        nbytes = resphdr[0]

        names = cs.read(nbytes)

        return names.split('\0')