Gecko [ goons4good.org ]

Name	Size	Permission	Date
linux	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
__init__.py	3.34 KB	-rw-r--r--	2013-06-01 18:10
__init__.pyc	3.19 KB	-rw-r--r--	2020-03-31 23:33
__init__.pyo	3.19 KB	-rw-r--r--	2020-03-31 23:33
client.py	5.81 KB	-rw-r--r--	2013-06-01 18:10
client.pyc	6.36 KB	-rw-r--r--	2020-03-31 23:33
client.pyo	6.36 KB	-rw-r--r--	2020-03-31 23:33
common.py	1.52 KB	-rw-r--r--	2013-06-01 18:10
common.pyc	998 B	-rw-r--r--	2020-03-31 23:33
common.pyo	998 B	-rw-r--r--	2020-03-31 23:33
linuxserver.py	14.11 KB	-rw-r--r--	2013-06-01 18:10
linuxserver.pyc	16.75 KB	-rw-r--r--	2020-03-31 23:33
linuxserver.pyo	16.71 KB	-rw-r--r--	2020-03-31 23:33
server.py	14.07 KB	-rw-r--r--	2013-06-01 18:10
server.pyc	15.1 KB	-rw-r--r--	2020-03-31 23:33
server.pyo	15.1 KB	-rw-r--r--	2020-03-31 23:33

Rename

# 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'):
                    match.dir(vdir)

return results

@start_server
    def debugquery(self):
        cs, resphdr = self.query('DBUG', '')

nbytes = resphdr[0]
        names = cs.read(nbytes)
        return names.split('\0')