inotify: Separate query sending logic from Server starting.

Use a decorator around the public statusquery method of Client:

start_server(query_to_server):
    try:
        query_to_server()
    except QueryFailed:
        [error recovery, inotify Server (re)starting]
        query_to_server()

This way, introducing a new xxxquery Client method is easy:
one has only to code the protocol part of xxxquery, ignoring errors,
and decorating it using start_server to handle server recovery
and (re)starts

hgext/inotify/__init__.py

@@ -1,127 +1,92 b''
 # __init__.py - inotify-based status acceleration for Linux
 #
 # Copyright 2006, 2007, 2008 Bryan O'Sullivan <[e-mail]>
 # Copyright 2007, 2008 Brendan Cully <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 '''inotify-based status acceleration for Linux systems
 '''
 
 # todo: socket permissions
 
 from mercurial.i18n import _
 from mercurial import cmdutil, util
-import errno, os, server, socket
+import os, server
 from weakref import proxy
-from client import client
+from client import client, QueryFailed
 
 def serve(ui, repo, **opts):
     '''start an inotify server for this repository'''
     timeout = opts.get('timeout')
     if timeout:
         timeout = float(timeout) * 1e3
 
     class service:
         def init(self):
             try:
                 self.master = server.master(ui, repo, timeout)
             except server.AlreadyStartedException, inst:
                 raise util.Abort(str(inst))
 
         def run(self):
             try:
                 self.master.run()
             finally:
                 self.master.shutdown()
 
     service = service()
     cmdutil.service(opts, initfn=service.init, runfn=service.run)
 
 def reposetup(ui, repo):
     if not hasattr(repo, 'dirstate'):
         return
 
     # XXX: weakref until hg stops relying on __del__
     repo = proxy(repo)
 
     class inotifydirstate(repo.dirstate.__class__):
         # Set to True if we're the inotify server, so we don't attempt
         # to recurse.
         inotifyserver = False
 
         def status(self, match, ignored, clean, unknown=True):
             files = match.files()
             if '.' in files:
                 files = []
-            cli = client(ui, repo)
-            try:
-                if not ignored and not self.inotifyserver:
+            if not ignored and not self.inotifyserver:
+                cli = client(ui, repo)
+                try:
                     result = cli.statusquery(files, match, False,
-                                             clean, unknown)
-                    if result and ui.config('inotify', 'debug'):
+                                            clean, unknown)
+                except QueryFailed, instr:
+                    ui.debug(str(instr))
+                    pass
+                else:
+                    if ui.config('inotify', 'debug'):
                         r2 = super(inotifydirstate, self).status(
                             match, False, clean, unknown)
                         for c,a,b in zip('LMARDUIC', result, r2):
                             for f in a:
                                 if f not in b:
                                     ui.warn('*** inotify: %s +%s\n' % (c, f))
                             for f in b:
                                 if f not in a:
                                     ui.warn('*** inotify: %s -%s\n' % (c, f))
                         result = r2
-
-                    if result is not None:
-                        return result
-            except (OSError, socket.error), err:
-                autostart = ui.configbool('inotify', 'autostart', True)
-
-                if err[0] == errno.ECONNREFUSED:
-                    ui.warn(_('(found dead inotify server socket; '
-                                   'removing it)\n'))
-                    os.unlink(repo.join('inotify.sock'))
-                if err[0] in (errno.ECONNREFUSED, errno.ENOENT) and autostart:
-                    ui.debug(_('(starting inotify server)\n'))
-                    try:
-                        try:
-                            server.start(ui, repo)
-                        except server.AlreadyStartedException, inst:
-                            # another process may have started its own
-                            # inotify server while this one was starting.
-                            ui.debug(str(inst))
-                    except Exception, inst:
-                        ui.warn(_('could not start inotify server: '
-                                       '%s\n') % inst)
-                    else:
-                        # server is started, send query again
-                        try:
-                            return cli.statusquery(files, match, ignored,
-                                                   clean, unknown)
-                        except socket.error, err:
-                            ui.warn(_('could not talk to new inotify '
-                                           'server: %s\n') % err[-1])
-                elif err[0] in (errno.ECONNREFUSED, errno.ENOENT):
-                    # silently ignore normal errors if autostart is False
-                    ui.debug(_('(inotify server not running)\n'))
-                else:
-                    ui.warn(_('failed to contact inotify server: %s\n')
-                             % err[-1])
-                ui.traceback()
-                # replace by old status function
-                self.status = super(inotifydirstate, self).status
-
+                    return result
             return super(inotifydirstate, self).status(
                 match, ignored, clean, unknown)
 
     repo.dirstate.__class__ = inotifydirstate
 
 cmdtable = {
     '^inserve':
     (serve,
      [('d', 'daemon', None, _('run server in background')),
       ('', 'daemon-pipefds', '', _('used internally by daemon mode')),
       ('t', 'idle-timeout', '', _('minutes to sit idle before exiting')),
       ('', 'pid-file', '', _('name of file to write process ID to'))],
      _('hg inserve [OPT]...')),
     }

hgext/inotify/client.py

@@ -1,94 +1,142 b''
 # client.py - inotify status client
 #
 # Copyright 2006, 2007, 2008 Bryan O'Sullivan <[e-mail]>
 # Copyright 2007, 2008 Brendan Cully <[e-mail]>
 # Copyright 2009 Nicolas Dumazet <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 from mercurial.i18n import _
-import common
-import os, socket, struct
+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):
+        result = None
+        try:
+            return function(self, *args)
+        except (OSError, socket.error), err:
+            autostart = self.ui.configbool('inotify', 'autostart', True)
+
+            if err[0] == errno.ECONNREFUSED:
+                self.ui.warn(_('(found dead inotify server socket; '
+                               'removing it)\n'))
+                os.unlink(self.repo.join('inotify.sock'))
+            if err[0] in (errno.ECONNREFUSED, errno.ENOENT) and autostart:
+                self.ui.debug(_('(starting inotify server)\n'))
+                try:
+                    try:
+                        server.start(self.ui, self.repo)
+                    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(_('could not start inotify server: '
+                                   '%s\n') % inst)
+                else:
+                    try:
+                        return function(self, *args)
+                    except socket.error, err:
+                        self.ui.warn(_('could not talk to new inotify '
+                                       'server: %s\n') % err[-1])
+            elif err[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(_('failed to contact inotify server: %s\n')
+                         % err[-1])
+
+        self.ui.traceback()
+        raise QueryFailed('inotify query failed')
+
+    return decorated_function
+
 
 class client(object):
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
         self.sock = socket.socket(socket.AF_UNIX)
 
     def _connect(self):
         sockpath = self.repo.join('inotify.sock')
         try:
             self.sock.connect(sockpath)
         except socket.error, err:
             if err[0] == "AF_UNIX path too long":
                 sockpath = os.readlink(sockpath)
                 self.sock.connect(sockpath)
             else:
                 raise
 
     def _send(self, data):
         """Sends protocol version number, and the data"""
         self.sock.sendall(chr(common.version) + data)
 
         self.sock.shutdown(socket.SHUT_WR)
 
     def _receive(self):
         """
         Read data, check version number, extract headers,
         and returns a tuple (data descriptor, header)
-        Returns (None, None) on error
+        Raises QueryFailed on error
         """
         cs = common.recvcs(self.sock)
         version = ord(cs.read(1))
         if version != common.version:
             self.ui.warn(_('(inotify: received response from incompatible '
                       'server version %d)\n') % version)
-            return None, None
+            raise QueryFailed('incompatible server version')
 
         # only one type of request is supported for now
         type = 'STAT'
         hdrfmt = common.resphdrfmts[type]
         hdrsize = common.resphdrsizes[type]
         try:
             resphdr = struct.unpack(hdrfmt, cs.read(hdrsize))
         except struct.error:
-            return None, None
+            raise QueryFailed('unable to retrieve query response headers')
 
         return cs, resphdr
 
     def query(self, req):
         self._connect()
 
         self._send(req)
 
         return self._receive()
 
+    @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(req)
 
-        if not cs:
-            return None
-
         def readnames(nbytes):
             if nbytes:
                 names = cs.read(nbytes)
                 if names:
                     return filter(match, names.split('\0'))
             return []
 
         return map(readnames, resphdr)