--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/__init__.py Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,104 @@
+# __init__.py - inotify-based status acceleration for Linux
+#
+# Copyright 2006, 2007, 2008 Bryan O'Sullivan <bos@serpentine.com>
+# Copyright 2007, 2008 Brendan Cully <brendan@kublai.com>
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+'''inotify-based status acceleration for Linux systems
+'''
+
+# todo: socket permissions
+
+from mercurial.i18n import gettext as _
+from mercurial import cmdutil, util
+import client, errno, os, server, socket
+from weakref import proxy
+
+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):
+ self.master = server.Master(ui, repo, timeout)
+
+ 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 repo.local():
+ 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, files, match, list_ignored, list_clean,
+ list_unknown=True):
+ try:
+ if not list_ignored and not self.inotifyserver:
+ result = client.query(ui, repo, files, match, False,
+ list_clean, list_unknown)
+ if result is not None:
+ return result
+ except socket.error, err:
+ if err[0] == errno.ECONNREFUSED:
+ ui.warn(_('(found dead inotify server socket; '
+ 'removing it)\n'))
+ os.unlink(repo.join('inotify.sock'))
+ elif err[0] != errno.ENOENT:
+ raise
+ if ui.configbool('inotify', 'autostart'):
+ query = None
+ ui.debug(_('(starting inotify server)\n'))
+ try:
+ server.start(ui, repo)
+ query = client.query
+ except server.AlreadyStartedException, inst:
+ # another process may have started its own
+ # inotify server while this one was starting.
+ ui.debug(str(inst))
+ query = client.query
+ except Exception, inst:
+ ui.warn(_('could not start inotify server: '
+ '%s\n') % inst)
+ ui.print_exc()
+
+ if query:
+ try:
+ return query(ui, repo, files or [], match,
+ list_ignored, list_clean, list_unknown)
+ except socket.error, err:
+ ui.warn(_('could not talk to new inotify '
+ 'server: %s\n') % err[1])
+ ui.print_exc()
+
+ return super(inotifydirstate, self).status(
+ files, match or util.always, list_ignored, list_clean,
+ list_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]...')),
+ }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/client.py Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,55 @@
+# client.py - inotify status client
+#
+# Copyright 2006, 2007, 2008 Bryan O'Sullivan <bos@serpentine.com>
+# Copyright 2007, 2008 Brendan Cully <brendan@kublai.com>
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+from mercurial.i18n import gettext as _
+from mercurial import ui
+import common
+import os, select, socket, stat, struct, sys
+
+def query(ui, repo, names, match, list_ignored, list_clean, list_unknown=True):
+ sock = socket.socket(socket.AF_UNIX)
+ sockpath = repo.join('inotify.sock')
+ sock.connect(sockpath)
+
+ def genquery():
+ for n in names or []:
+ yield n
+ states = 'almrx!'
+ if list_ignored:
+ raise ValueError('this is insanity')
+ if list_clean: states += 'n'
+ if list_unknown: states += '?'
+ yield states
+
+ req = '\0'.join(genquery())
+
+ sock.sendall(chr(common.version))
+ sock.sendall(req)
+ sock.shutdown(socket.SHUT_WR)
+
+ cs = common.recvcs(sock)
+ version = ord(cs.read(1))
+
+ if version != common.version:
+ ui.warn(_('(inotify: received response from incompatible server '
+ 'version %d)\n') % version)
+ return None
+
+ try:
+ resphdr = struct.unpack(common.resphdrfmt, cs.read(common.resphdrsize))
+ except struct.error:
+ return None
+
+ def readnames(nbytes):
+ if nbytes:
+ names = cs.read(nbytes)
+ if names:
+ return filter(match, names.split('\0'))
+ return []
+
+ return map(readnames, resphdr)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/common.py Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,26 @@
+# server.py - inotify common protocol code
+#
+# Copyright 2006, 2007, 2008 Bryan O'Sullivan <bos@serpentine.com>
+# Copyright 2007, 2008 Brendan Cully <brendan@kublai.com>
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+import cStringIO, socket, struct
+
+version = 1
+
+resphdrfmt = '>llllllll'
+resphdrsize = struct.calcsize(resphdrfmt)
+
+def recvcs(sock):
+ cs = cStringIO.StringIO()
+ s = True
+ try:
+ while s:
+ s = sock.recv(65536)
+ cs.write(s)
+ finally:
+ sock.shutdown(socket.SHUT_RD)
+ cs.seek(0)
+ return cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/linux/__init__.py Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,41 @@
+# __init__.py - low-level interfaces to the Linux inotify subsystem
+
+# Copyright 2006 Bryan O'Sullivan <bos@serpentine.com>
+
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of version 2.1 of the GNU Lesser General Public
+# License, incorporated herein by reference.
+
+'''Low-level interface to the Linux inotify subsystem.
+
+The inotify subsystem provides an efficient mechanism for file status
+monitoring and change notification.
+
+This package provides the low-level inotify system call interface and
+associated constants and helper functions.
+
+For a higher-level interface that remains highly efficient, use the
+inotify.watcher package.'''
+
+__author__ = "Bryan O'Sullivan <bos@serpentine.com>"
+
+from _inotify import *
+
+procfs_path = '/proc/sys/fs/inotify'
+
+def _read_procfs_value(name):
+ def read_value():
+ try:
+ return int(open(procfs_path + '/' + name).read())
+ except OSError, err:
+ return None
+
+ read_value.__doc__ = '''Return the value of the %s setting from /proc.
+
+ If inotify is not enabled on this system, return None.''' % name
+
+ return read_value
+
+max_queued_events = _read_procfs_value('max_queued_events')
+max_user_instances = _read_procfs_value('max_user_instances')
+max_user_watches = _read_procfs_value('max_user_watches')
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/linux/_inotify.c Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,608 @@
+/*
+ * _inotify.c - Python extension interfacing to the Linux inotify subsystem
+ *
+ * Copyright 2006 Bryan O'Sullivan <bos@serpentine.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 2.1 of the GNU Lesser General
+ * Public License, incorporated herein by reference.
+ */
+
+#include <Python.h>
+#include <alloca.h>
+#include <sys/inotify.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+static PyObject *init(PyObject *self, PyObject *args)
+{
+ PyObject *ret = NULL;
+ int fd = -1;
+
+ if (!PyArg_ParseTuple(args, ":init"))
+ goto bail;
+
+ Py_BEGIN_ALLOW_THREADS
+ fd = inotify_init();
+ Py_END_ALLOW_THREADS
+
+ if (fd == -1) {
+ PyErr_SetFromErrno(PyExc_OSError);
+ goto bail;
+ }
+
+ ret = PyInt_FromLong(fd);
+ if (ret == NULL)
+ goto bail;
+
+ goto done;
+
+bail:
+ if (fd != -1)
+ close(fd);
+
+ Py_CLEAR(ret);
+
+done:
+ return ret;
+}
+
+PyDoc_STRVAR(
+ init_doc,
+ "init() -> fd\n"
+ "\n"
+ "Initialise an inotify instance.\n"
+ "Return a file descriptor associated with a new inotify event queue.");
+
+static PyObject *add_watch(PyObject *self, PyObject *args)
+{
+ PyObject *ret = NULL;
+ uint32_t mask;
+ int wd = -1;
+ char *path;
+ int fd;
+
+ if (!PyArg_ParseTuple(args, "isI:add_watch", &fd, &path, &mask))
+ goto bail;
+
+ Py_BEGIN_ALLOW_THREADS
+ wd = inotify_add_watch(fd, path, mask);
+ Py_END_ALLOW_THREADS
+
+ if (wd == -1) {
+ PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
+ goto bail;
+ }
+
+ ret = PyInt_FromLong(wd);
+ if (ret == NULL)
+ goto bail;
+
+ goto done;
+
+bail:
+ if (wd != -1)
+ inotify_rm_watch(fd, wd);
+
+ Py_CLEAR(ret);
+
+done:
+ return ret;
+}
+
+PyDoc_STRVAR(
+ add_watch_doc,
+ "add_watch(fd, path, mask) -> wd\n"
+ "\n"
+ "Add a watch to an inotify instance, or modify an existing watch.\n"
+ "\n"
+ " fd: file descriptor returned by init()\n"
+ " path: path to watch\n"
+ " mask: mask of events to watch for\n"
+ "\n"
+ "Return a unique numeric watch descriptor for the inotify instance\n"
+ "mapped by the file descriptor.");
+
+static PyObject *remove_watch(PyObject *self, PyObject *args)
+{
+ PyObject *ret = NULL;
+ uint32_t wd;
+ int fd;
+ int r;
+
+ if (!PyArg_ParseTuple(args, "iI:remove_watch", &fd, &wd))
+ goto bail;
+
+ Py_BEGIN_ALLOW_THREADS
+ r = inotify_rm_watch(fd, wd);
+ Py_END_ALLOW_THREADS
+
+ if (r == -1) {
+ PyErr_SetFromErrno(PyExc_OSError);
+ goto bail;
+ }
+
+ Py_INCREF(Py_None);
+
+ goto done;
+
+bail:
+ Py_CLEAR(ret);
+
+done:
+ return ret;
+}
+
+PyDoc_STRVAR(
+ remove_watch_doc,
+ "remove_watch(fd, wd)\n"
+ "\n"
+ " fd: file descriptor returned by init()\n"
+ " wd: watch descriptor returned by add_watch()\n"
+ "\n"
+ "Remove a watch associated with the watch descriptor wd from the\n"
+ "inotify instance associated with the file descriptor fd.\n"
+ "\n"
+ "Removing a watch causes an IN_IGNORED event to be generated for this\n"
+ "watch descriptor.");
+
+#define bit_name(x) {x, #x}
+
+static struct {
+ int bit;
+ const char *name;
+ PyObject *pyname;
+} bit_names[] = {
+ bit_name(IN_ACCESS),
+ bit_name(IN_MODIFY),
+ bit_name(IN_ATTRIB),
+ bit_name(IN_CLOSE_WRITE),
+ bit_name(IN_CLOSE_NOWRITE),
+ bit_name(IN_OPEN),
+ bit_name(IN_MOVED_FROM),
+ bit_name(IN_MOVED_TO),
+ bit_name(IN_CREATE),
+ bit_name(IN_DELETE),
+ bit_name(IN_DELETE_SELF),
+ bit_name(IN_MOVE_SELF),
+ bit_name(IN_UNMOUNT),
+ bit_name(IN_Q_OVERFLOW),
+ bit_name(IN_IGNORED),
+ bit_name(IN_ONLYDIR),
+ bit_name(IN_DONT_FOLLOW),
+ bit_name(IN_MASK_ADD),
+ bit_name(IN_ISDIR),
+ bit_name(IN_ONESHOT),
+ {0}
+};
+
+static PyObject *decode_mask(int mask)
+{
+ PyObject *ret = PyList_New(0);
+ int i;
+
+ if (ret == NULL)
+ goto bail;
+
+ for (i = 0; bit_names[i].bit; i++) {
+ if (mask & bit_names[i].bit) {
+ if (bit_names[i].pyname == NULL) {
+ bit_names[i].pyname = PyString_FromString(bit_names[i].name);
+ if (bit_names[i].pyname == NULL)
+ goto bail;
+ }
+ Py_INCREF(bit_names[i].pyname);
+ if (PyList_Append(ret, bit_names[i].pyname) == -1)
+ goto bail;
+ }
+ }
+
+ goto done;
+
+bail:
+ Py_CLEAR(ret);
+
+done:
+ return ret;
+}
+
+static PyObject *pydecode_mask(PyObject *self, PyObject *args)
+{
+ int mask;
+
+ if (!PyArg_ParseTuple(args, "i:decode_mask", &mask))
+ return NULL;
+
+ return decode_mask(mask);
+}
+
+PyDoc_STRVAR(
+ decode_mask_doc,
+ "decode_mask(mask) -> list_of_strings\n"
+ "\n"
+ "Decode an inotify mask value into a list of strings that give the\n"
+ "name of each bit set in the mask.");
+
+static char doc[] = "Low-level inotify interface wrappers.";
+
+static void define_const(PyObject *dict, const char *name, uint32_t val)
+{
+ PyObject *pyval = PyInt_FromLong(val);
+ PyObject *pyname = PyString_FromString(name);
+
+ if (!pyname || !pyval)
+ goto bail;
+
+ PyDict_SetItem(dict, pyname, pyval);
+
+bail:
+ Py_XDECREF(pyname);
+ Py_XDECREF(pyval);
+}
+
+static void define_consts(PyObject *dict)
+{
+ define_const(dict, "IN_ACCESS", IN_ACCESS);
+ define_const(dict, "IN_MODIFY", IN_MODIFY);
+ define_const(dict, "IN_ATTRIB", IN_ATTRIB);
+ define_const(dict, "IN_CLOSE_WRITE", IN_CLOSE_WRITE);
+ define_const(dict, "IN_CLOSE_NOWRITE", IN_CLOSE_NOWRITE);
+ define_const(dict, "IN_OPEN", IN_OPEN);
+ define_const(dict, "IN_MOVED_FROM", IN_MOVED_FROM);
+ define_const(dict, "IN_MOVED_TO", IN_MOVED_TO);
+
+ define_const(dict, "IN_CLOSE", IN_CLOSE);
+ define_const(dict, "IN_MOVE", IN_MOVE);
+
+ define_const(dict, "IN_CREATE", IN_CREATE);
+ define_const(dict, "IN_DELETE", IN_DELETE);
+ define_const(dict, "IN_DELETE_SELF", IN_DELETE_SELF);
+ define_const(dict, "IN_MOVE_SELF", IN_MOVE_SELF);
+ define_const(dict, "IN_UNMOUNT", IN_UNMOUNT);
+ define_const(dict, "IN_Q_OVERFLOW", IN_Q_OVERFLOW);
+ define_const(dict, "IN_IGNORED", IN_IGNORED);
+
+ define_const(dict, "IN_ONLYDIR", IN_ONLYDIR);
+ define_const(dict, "IN_DONT_FOLLOW", IN_DONT_FOLLOW);
+ define_const(dict, "IN_MASK_ADD", IN_MASK_ADD);
+ define_const(dict, "IN_ISDIR", IN_ISDIR);
+ define_const(dict, "IN_ONESHOT", IN_ONESHOT);
+ define_const(dict, "IN_ALL_EVENTS", IN_ALL_EVENTS);
+}
+
+struct event {
+ PyObject_HEAD
+ PyObject *wd;
+ PyObject *mask;
+ PyObject *cookie;
+ PyObject *name;
+};
+
+static PyObject *event_wd(PyObject *self, void *x)
+{
+ struct event *evt = (struct event *) self;
+ Py_INCREF(evt->wd);
+ return evt->wd;
+}
+
+static PyObject *event_mask(PyObject *self, void *x)
+{
+ struct event *evt = (struct event *) self;
+ Py_INCREF(evt->mask);
+ return evt->mask;
+}
+
+static PyObject *event_cookie(PyObject *self, void *x)
+{
+ struct event *evt = (struct event *) self;
+ Py_INCREF(evt->cookie);
+ return evt->cookie;
+}
+
+static PyObject *event_name(PyObject *self, void *x)
+{
+ struct event *evt = (struct event *) self;
+ Py_INCREF(evt->name);
+ return evt->name;
+}
+
+static struct PyGetSetDef event_getsets[] = {
+ {"wd", event_wd, NULL,
+ "watch descriptor"},
+ {"mask", event_mask, NULL,
+ "event mask"},
+ {"cookie", event_cookie, NULL,
+ "rename cookie, if rename-related event"},
+ {"name", event_name, NULL,
+ "file name"},
+ {NULL}
+};
+
+PyDoc_STRVAR(
+ event_doc,
+ "event: Structure describing an inotify event.");
+
+static PyObject *event_new(PyTypeObject *t, PyObject *a, PyObject *k)
+{
+ return (*t->tp_alloc)(t, 0);
+}
+
+static void event_dealloc(struct event *evt)
+{
+ Py_XDECREF(evt->wd);
+ Py_XDECREF(evt->mask);
+ Py_XDECREF(evt->cookie);
+ Py_XDECREF(evt->name);
+
+ (*evt->ob_type->tp_free)(evt);
+}
+
+static PyObject *event_repr(struct event *evt)
+{
+ int wd = PyInt_AsLong(evt->wd);
+ int cookie = evt->cookie == Py_None ? -1 : PyInt_AsLong(evt->cookie);
+ PyObject *ret = NULL, *pymasks = NULL, *pymask = NULL;
+ PyObject *join = NULL;
+ char *maskstr;
+
+ join = PyString_FromString("|");
+ if (join == NULL)
+ goto bail;
+
+ pymasks = decode_mask(PyInt_AsLong(evt->mask));
+ if (pymasks == NULL)
+ goto bail;
+
+ pymask = _PyString_Join(join, pymasks);
+ if (pymask == NULL)
+ goto bail;
+
+ maskstr = PyString_AsString(pymask);
+
+ if (evt->name != Py_None) {
+ PyObject *pyname = PyString_Repr(evt->name, 1);
+ char *name = pyname ? PyString_AsString(pyname) : "???";
+
+ if (cookie == -1)
+ ret = PyString_FromFormat("event(wd=%d, mask=%s, name=%s)",
+ wd, maskstr, name);
+ else
+ ret = PyString_FromFormat("event(wd=%d, mask=%s, "
+ "cookie=0x%x, name=%s)",
+ wd, maskstr, cookie, name);
+
+ Py_XDECREF(pyname);
+ } else {
+ if (cookie == -1)
+ ret = PyString_FromFormat("event(wd=%d, mask=%s)",
+ wd, maskstr);
+ else {
+ ret = PyString_FromFormat("event(wd=%d, mask=%s, cookie=0x%x)",
+ wd, maskstr, cookie);
+ }
+ }
+
+ goto done;
+bail:
+ Py_CLEAR(ret);
+
+done:
+ Py_XDECREF(pymask);
+ Py_XDECREF(pymasks);
+ Py_XDECREF(join);
+
+ return ret;
+}
+
+static PyTypeObject event_type = {
+ PyObject_HEAD_INIT(NULL)
+ 0, /*ob_size*/
+ "_inotify.event", /*tp_name*/
+ sizeof(struct event), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ (destructor)event_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ (reprfunc)event_repr, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ event_doc, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ event_getsets, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ event_new, /* tp_new */
+};
+
+PyObject *read_events(PyObject *self, PyObject *args)
+{
+ PyObject *ctor_args = NULL;
+ PyObject *pybufsize = NULL;
+ PyObject *ret = NULL;
+ int bufsize = 65536;
+ char *buf = NULL;
+ int nread, pos;
+ int fd;
+
+ if (!PyArg_ParseTuple(args, "i|O:read", &fd, &pybufsize))
+ goto bail;
+
+ if (pybufsize && pybufsize != Py_None)
+ bufsize = PyInt_AsLong(pybufsize);
+
+ ret = PyList_New(0);
+ if (ret == NULL)
+ goto bail;
+
+ if (bufsize <= 0) {
+ int r;
+
+ Py_BEGIN_ALLOW_THREADS
+ r = ioctl(fd, FIONREAD, &bufsize);
+ Py_END_ALLOW_THREADS
+
+ if (r == -1) {
+ PyErr_SetFromErrno(PyExc_OSError);
+ goto bail;
+ }
+ if (bufsize == 0)
+ goto done;
+ }
+ else {
+ static long name_max;
+ static long name_fd = -1;
+ long min;
+
+ if (name_fd != fd) {
+ name_fd = fd;
+ Py_BEGIN_ALLOW_THREADS
+ name_max = fpathconf(fd, _PC_NAME_MAX);
+ Py_END_ALLOW_THREADS
+ }
+
+ min = sizeof(struct inotify_event) + name_max + 1;
+
+ if (bufsize < min) {
+ PyErr_Format(PyExc_ValueError, "bufsize must be at least %d",
+ (int) min);
+ goto bail;
+ }
+ }
+
+ buf = alloca(bufsize);
+
+ Py_BEGIN_ALLOW_THREADS
+ nread = read(fd, buf, bufsize);
+ Py_END_ALLOW_THREADS
+
+ if (nread == -1) {
+ PyErr_SetFromErrno(PyExc_OSError);
+ goto bail;
+ }
+
+ ctor_args = PyTuple_New(0);
+
+ if (ctor_args == NULL)
+ goto bail;
+
+ pos = 0;
+
+ while (pos < nread) {
+ struct inotify_event *in = (struct inotify_event *) (buf + pos);
+ struct event *evt;
+ PyObject *obj;
+
+ obj = PyObject_CallObject((PyObject *) &event_type, ctor_args);
+
+ if (obj == NULL)
+ goto bail;
+
+ evt = (struct event *) obj;
+
+ evt->wd = PyInt_FromLong(in->wd);
+ evt->mask = PyInt_FromLong(in->mask);
+ if (in->mask & IN_MOVE)
+ evt->cookie = PyInt_FromLong(in->cookie);
+ else {
+ Py_INCREF(Py_None);
+ evt->cookie = Py_None;
+ }
+ if (in->len)
+ evt->name = PyString_FromString(in->name);
+ else {
+ Py_INCREF(Py_None);
+ evt->name = Py_None;
+ }
+
+ if (!evt->wd || !evt->mask || !evt->cookie || !evt->name)
+ goto mybail;
+
+ if (PyList_Append(ret, obj) == -1)
+ goto mybail;
+
+ pos += sizeof(struct inotify_event) + in->len;
+ continue;
+
+ mybail:
+ Py_CLEAR(evt->wd);
+ Py_CLEAR(evt->mask);
+ Py_CLEAR(evt->cookie);
+ Py_CLEAR(evt->name);
+ Py_DECREF(obj);
+
+ goto bail;
+ }
+
+ goto done;
+
+bail:
+ Py_CLEAR(ret);
+
+done:
+ Py_XDECREF(ctor_args);
+
+ return ret;
+}
+
+PyDoc_STRVAR(
+ read_doc,
+ "read(fd, bufsize[=65536]) -> list_of_events\n"
+ "\n"
+ "\nRead inotify events from a file descriptor.\n"
+ "\n"
+ " fd: file descriptor returned by init()\n"
+ " bufsize: size of buffer to read into, in bytes\n"
+ "\n"
+ "Return a list of event objects.\n"
+ "\n"
+ "If bufsize is > 0, block until events are available to be read.\n"
+ "Otherwise, immediately return all events that can be read without\n"
+ "blocking.");
+
+
+static PyMethodDef methods[] = {
+ {"init", init, METH_VARARGS, init_doc},
+ {"add_watch", add_watch, METH_VARARGS, add_watch_doc},
+ {"remove_watch", remove_watch, METH_VARARGS, remove_watch_doc},
+ {"read", read_events, METH_VARARGS, read_doc},
+ {"decode_mask", pydecode_mask, METH_VARARGS, decode_mask_doc},
+ {NULL},
+};
+
+void init_inotify(void)
+{
+ PyObject *mod, *dict;
+
+ if (PyType_Ready(&event_type) == -1)
+ return;
+
+ mod = Py_InitModule3("_inotify", methods, doc);
+
+ dict = PyModule_GetDict(mod);
+
+ if (dict)
+ define_consts(dict);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/linux/watcher.py Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,335 @@
+# watcher.py - high-level interfaces to the Linux inotify subsystem
+
+# Copyright 2006 Bryan O'Sullivan <bos@serpentine.com>
+
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of version 2.1 of the GNU Lesser General Public
+# License, incorporated herein by reference.
+
+'''High-level interfaces to the Linux inotify subsystem.
+
+The inotify subsystem provides an efficient mechanism for file status
+monitoring and change notification.
+
+The Watcher class hides the low-level details of the inotify
+interface, and provides a Pythonic wrapper around it. It generates
+events that provide somewhat more information than raw inotify makes
+available.
+
+The AutoWatcher class is more useful, as it automatically watches
+newly-created directories on your behalf.'''
+
+__author__ = "Bryan O'Sullivan <bos@serpentine.com>"
+
+import _inotify as inotify
+import array
+import errno
+import fcntl
+import os
+import termios
+
+
+class Event(object):
+ '''Derived inotify event class.
+
+ The following fields are available:
+
+ mask: event mask, indicating what kind of event this is
+
+ cookie: rename cookie, if a rename-related event
+
+ path: path of the directory in which the event occurred
+
+ name: name of the directory entry to which the event occurred
+ (may be None if the event happened to a watched directory)
+
+ fullpath: complete path at which the event occurred
+
+ wd: watch descriptor that triggered this event'''
+
+ __slots__ = (
+ 'cookie',
+ 'fullpath',
+ 'mask',
+ 'name',
+ 'path',
+ 'raw',
+ 'wd',
+ )
+
+ def __init__(self, raw, path):
+ self.path = path
+ self.raw = raw
+ if raw.name:
+ self.fullpath = path + '/' + raw.name
+ else:
+ self.fullpath = path
+
+ self.wd = raw.wd
+ self.mask = raw.mask
+ self.cookie = raw.cookie
+ self.name = raw.name
+
+ def __repr__(self):
+ r = repr(self.raw)
+ return 'Event(path=' + repr(self.path) + ', ' + r[r.find('(')+1:]
+
+
+_event_props = {
+ 'access': 'File was accessed',
+ 'modify': 'File was modified',
+ 'attrib': 'Attribute of a directory entry was changed',
+ 'close_write': 'File was closed after being written to',
+ 'close_nowrite': 'File was closed without being written to',
+ 'open': 'File was opened',
+ 'moved_from': 'Directory entry was renamed from this name',
+ 'moved_to': 'Directory entry was renamed to this name',
+ 'create': 'Directory entry was created',
+ 'delete': 'Directory entry was deleted',
+ 'delete_self': 'The watched directory entry was deleted',
+ 'move_self': 'The watched directory entry was renamed',
+ 'unmount': 'Directory was unmounted, and can no longer be watched',
+ 'q_overflow': 'Kernel dropped events due to queue overflow',
+ 'ignored': 'Directory entry is no longer being watched',
+ 'isdir': 'Event occurred on a directory',
+ }
+
+for k, v in _event_props.iteritems():
+ mask = getattr(inotify, 'IN_' + k.upper())
+ def getter(self):
+ return self.mask & mask
+ getter.__name__ = k
+ getter.__doc__ = v
+ setattr(Event, k, property(getter, doc=v))
+
+del _event_props
+
+
+class Watcher(object):
+ '''Provide a Pythonic interface to the low-level inotify API.
+
+ Also adds derived information to each event that is not available
+ through the normal inotify API, such as directory name.'''
+
+ __slots__ = (
+ 'fd',
+ '_paths',
+ '_wds',
+ )
+
+ def __init__(self):
+ '''Create a new inotify instance.'''
+
+ self.fd = inotify.init()
+ self._paths = {}
+ self._wds = {}
+
+ def fileno(self):
+ '''Return the file descriptor this watcher uses.
+
+ Useful for passing to select and poll.'''
+
+ return self.fd
+
+ def add(self, path, mask):
+ '''Add or modify a watch.
+
+ Return the watch descriptor added or modified.'''
+
+ path = os.path.normpath(path)
+ wd = inotify.add_watch(self.fd, path, mask)
+ self._paths[path] = wd, mask
+ self._wds[wd] = path, mask
+ return wd
+
+ def remove(self, wd):
+ '''Remove the given watch.'''
+
+ inotify.remove_watch(self.fd, wd)
+ self._remove(wd)
+
+ def _remove(self, wd):
+ path_mask = self._wds.pop(wd, None)
+ if path_mask is not None:
+ self._paths.pop(path_mask[0])
+
+ def path(self, path):
+ '''Return a (watch descriptor, event mask) pair for the given path.
+
+ If the path is not being watched, return None.'''
+
+ return self._paths.get(path)
+
+ def wd(self, wd):
+ '''Return a (path, event mask) pair for the given watch descriptor.
+
+ If the watch descriptor is not valid or not associated with
+ this watcher, return None.'''
+
+ return self._wds.get(wd)
+
+ def read(self, bufsize=None):
+ '''Read a list of queued inotify events.
+
+ If bufsize is zero, only return those events that can be read
+ immediately without blocking. Otherwise, block until events are
+ available.'''
+
+ events = []
+ for evt in inotify.read(self.fd, bufsize):
+ events.append(Event(evt, self._wds[evt.wd][0]))
+ if evt.mask & inotify.IN_IGNORED:
+ self._remove(evt.wd)
+ elif evt.mask & inotify.IN_UNMOUNT:
+ self.close()
+ return events
+
+ def close(self):
+ '''Shut down this watcher.
+
+ All subsequent method calls are likely to raise exceptions.'''
+
+ os.close(self.fd)
+ self.fd = None
+ self._paths = None
+ self._wds = None
+
+ def __len__(self):
+ '''Return the number of active watches.'''
+
+ return len(self._paths)
+
+ def __iter__(self):
+ '''Yield a (path, watch descriptor, event mask) tuple for each
+ entry being watched.'''
+
+ for path, (wd, mask) in self._paths.iteritems():
+ yield path, wd, mask
+
+ def __del__(self):
+ if self.fd is not None:
+ os.close(self.fd)
+
+ ignored_errors = [errno.ENOENT, errno.EPERM, errno.ENOTDIR]
+
+ def add_iter(self, path, mask, onerror=None):
+ '''Add or modify watches over path and its subdirectories.
+
+ Yield each added or modified watch descriptor.
+
+ To ensure that this method runs to completion, you must
+ iterate over all of its results, even if you do not care what
+ they are. For example:
+
+ for wd in w.add_iter(path, mask):
+ pass
+
+ By default, errors are ignored. If optional arg "onerror" is
+ specified, it should be a function; it will be called with one
+ argument, an OSError instance. It can report the error to
+ continue with the walk, or raise the exception to abort the
+ walk.'''
+
+ # Add the IN_ONLYDIR flag to the event mask, to avoid a possible
+ # race when adding a subdirectory. In the time between the
+ # event being queued by the kernel and us processing it, the
+ # directory may have been deleted, or replaced with a different
+ # kind of entry with the same name.
+
+ submask = mask | inotify.IN_ONLYDIR
+
+ try:
+ yield self.add(path, mask)
+ except OSError, err:
+ if onerror and err.errno not in self.ignored_errors:
+ onerror(err)
+ for root, dirs, names in os.walk(path, topdown=False, onerror=onerror):
+ for d in dirs:
+ try:
+ yield self.add(root + '/' + d, submask)
+ except OSError, err:
+ if onerror and err.errno not in self.ignored_errors:
+ onerror(err)
+
+ def add_all(self, path, mask, onerror=None):
+ '''Add or modify watches over path and its subdirectories.
+
+ Return a list of added or modified watch descriptors.
+
+ By default, errors are ignored. If optional arg "onerror" is
+ specified, it should be a function; it will be called with one
+ argument, an OSError instance. It can report the error to
+ continue with the walk, or raise the exception to abort the
+ walk.'''
+
+ return [w for w in self.add_iter(path, mask, onerror)]
+
+
+class AutoWatcher(Watcher):
+ '''Watcher class that automatically watches newly created directories.'''
+
+ __slots__ = (
+ 'addfilter',
+ )
+
+ def __init__(self, addfilter=None):
+ '''Create a new inotify instance.
+
+ This instance will automatically watch newly created
+ directories.
+
+ If the optional addfilter parameter is not None, it must be a
+ callable that takes one parameter. It will be called each time
+ a directory is about to be automatically watched. If it returns
+ True, the directory will be watched if it still exists,
+ otherwise, it will beb skipped.'''
+
+ super(AutoWatcher, self).__init__()
+ self.addfilter = addfilter
+
+ _dir_create_mask = inotify.IN_ISDIR | inotify.IN_CREATE
+
+ def read(self, bufsize=None):
+ events = super(AutoWatcher, self).read(bufsize)
+ for evt in events:
+ if evt.mask & self._dir_create_mask == self._dir_create_mask:
+ if self.addfilter is None or self.addfilter(evt):
+ parentmask = self._wds[evt.wd][1]
+ # See note about race avoidance via IN_ONLYDIR above.
+ mask = parentmask | inotify.IN_ONLYDIR
+ try:
+ self.add_all(evt.fullpath, mask)
+ except OSError, err:
+ if err.errno not in self.ignored_errors:
+ raise
+ return events
+
+
+class Threshold(object):
+ '''Class that indicates whether a file descriptor has reached a
+ threshold of readable bytes available.
+
+ This class is not thread-safe.'''
+
+ __slots__ = (
+ 'fd',
+ 'threshold',
+ '_iocbuf',
+ )
+
+ def __init__(self, fd, threshold=1024):
+ self.fd = fd
+ self.threshold = threshold
+ self._iocbuf = array.array('i', [0])
+
+ def readable(self):
+ '''Return the number of bytes readable on this file descriptor.'''
+
+ fcntl.ioctl(self.fd, termios.FIONREAD, self._iocbuf, True)
+ return self._iocbuf[0]
+
+ def __call__(self):
+ '''Indicate whether the number of readable bytes has met or
+ exceeded the threshold.'''
+
+ return self.readable() >= self.threshold
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hgext/inotify/server.py Wed Mar 12 15:30:11 2008 -0700
@@ -0,0 +1,717 @@
+# server.py - inotify status server
+#
+# Copyright 2006, 2007, 2008 Bryan O'Sullivan <bos@serpentine.com>
+# Copyright 2007, 2008 Brendan Cully <brendan@kublai.com>
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+from mercurial.i18n import gettext as _
+from mercurial import osutil, ui, util
+import common
+import errno, os, select, socket, stat, struct, sys, time
+
+try:
+ import hgext.inotify.linux as inotify
+ from hgext.inotify.linux import watcher
+except ImportError:
+ print >> sys.stderr, '*** native support is required for this extension'
+ raise
+
+class AlreadyStartedException(Exception): pass
+
+def join(a, b):
+ if a:
+ if a[-1] == '/':
+ return a + b
+ return a + '/' + b
+ return b
+
+walk_ignored_errors = (errno.ENOENT, errno.ENAMETOOLONG)
+
+def walkrepodirs(repo):
+ '''Iterate over all subdirectories of this repo.
+ Exclude the .hg directory, any nested repos, and ignored dirs.'''
+ rootslash = repo.root + os.sep
+ def walkit(dirname, top):
+ hginside = False
+ try:
+ for name, kind in osutil.listdir(rootslash + dirname):
+ if kind == stat.S_IFDIR:
+ if name == '.hg':
+ hginside = True
+ if not top: break
+ else:
+ d = join(dirname, name)
+ if repo.dirstate._ignore(d):
+ continue
+ for subdir, hginsub in walkit(d, False):
+ if not hginsub:
+ yield subdir, False
+ except OSError, err:
+ if err.errno not in walk_ignored_errors:
+ raise
+ yield rootslash + dirname, hginside
+ for dirname, hginside in walkit('', True):
+ yield dirname
+
+def walk(repo, root):
+ '''Like os.walk, but only yields regular files.'''
+
+ # This function is critical to performance during startup.
+
+ reporoot = root == ''
+ rootslash = repo.root + os.sep
+
+ def walkit(root, reporoot):
+ files, dirs = [], []
+ hginside = False
+
+ try:
+ fullpath = rootslash + root
+ for name, kind in osutil.listdir(fullpath):
+ if kind == stat.S_IFDIR:
+ if name == '.hg':
+ hginside = True
+ if reporoot:
+ continue
+ else:
+ break
+ dirs.append(name)
+ elif kind in (stat.S_IFREG, stat.S_IFLNK):
+ path = join(root, name)
+ files.append((name, kind))
+
+ yield hginside, fullpath, dirs, files
+
+ for subdir in dirs:
+ path = join(root, subdir)
+ if repo.dirstate._ignore(path):
+ continue
+ for result in walkit(path, False):
+ if not result[0]:
+ yield result
+ except OSError, err:
+ if err.errno not in walk_ignored_errors:
+ raise
+ for result in walkit(root, reporoot):
+ yield result[1:]
+
+def _explain_watch_limit(ui, repo, count):
+ path = '/proc/sys/fs/inotify/max_user_watches'
+ try:
+ limit = int(file(path).read())
+ except IOError, err:
+ if err.errno != errno.ENOENT:
+ raise
+ raise util.Abort(_('this system does not seem to '
+ 'support inotify'))
+ ui.warn(_('*** the current per-user limit on the number '
+ 'of inotify watches is %s\n') % limit)
+ ui.warn(_('*** this limit is too low to watch every '
+ 'directory in this repository\n'))
+ ui.warn(_('*** counting directories: '))
+ ndirs = len(list(walkrepodirs(repo)))
+ ui.warn(_('found %d\n') % ndirs)
+ newlimit = min(limit, 1024)
+ while newlimit < ((limit + ndirs) * 1.1):
+ newlimit *= 2
+ ui.warn(_('*** to raise the limit from %d to %d (run as root):\n') %
+ (limit, newlimit))
+ ui.warn(_('*** echo %d > %s\n') % (newlimit, path))
+ raise util.Abort(_('cannot watch %s until inotify watch limit is raised')
+ % repo.root)
+
+class Watcher(object):
+ poll_events = select.POLLIN
+ statuskeys = 'almr!?'
+
+ def __init__(self, ui, repo, master):
+ self.ui = ui
+ self.repo = repo
+ self.wprefix = self.repo.wjoin('')
+ self.timeout = None
+ self.master = master
+ self.mask = (
+ inotify.IN_ATTRIB |
+ inotify.IN_CREATE |
+ inotify.IN_DELETE |
+ inotify.IN_DELETE_SELF |
+ inotify.IN_MODIFY |
+ inotify.IN_MOVED_FROM |
+ inotify.IN_MOVED_TO |
+ inotify.IN_MOVE_SELF |
+ inotify.IN_ONLYDIR |
+ inotify.IN_UNMOUNT |
+ 0)
+ try:
+ self.watcher = watcher.Watcher()
+ except OSError, err:
+ raise util.Abort(_('inotify service not available: %s') %
+ err.strerror)
+ self.threshold = watcher.Threshold(self.watcher)
+ self.registered = True
+ self.fileno = self.watcher.fileno
+
+ self.repo.dirstate.__class__.inotifyserver = True
+
+ self.tree = {}
+ self.statcache = {}
+ self.statustrees = dict([(s, {}) for s in self.statuskeys])
+
+ self.watches = 0
+ self.last_event = None
+
+ self.eventq = {}
+ self.deferred = 0
+
+ self.ds_info = self.dirstate_info()
+ self.scan()
+
+ def event_time(self):
+ last = self.last_event
+ now = time.time()
+ self.last_event = now
+
+ if last is None:
+ return 'start'
+ delta = now - last
+ if delta < 5:
+ return '+%.3f' % delta
+ if delta < 50:
+ return '+%.2f' % delta
+ return '+%.1f' % delta
+
+ def dirstate_info(self):
+ try:
+ st = os.lstat(self.repo.join('dirstate'))
+ return st.st_mtime, st.st_ino
+ except OSError, err:
+ if err.errno != errno.ENOENT:
+ raise
+ return 0, 0
+
+ def add_watch(self, path, mask):
+ if not path:
+ return
+ if self.watcher.path(path) is None:
+ if self.ui.debugflag:
+ self.ui.note(_('watching %r\n') % path[len(self.wprefix):])
+ try:
+ self.watcher.add(path, mask)
+ self.watches += 1
+ except OSError, err:
+ if err.errno in (errno.ENOENT, errno.ENOTDIR):
+ return
+ if err.errno != errno.ENOSPC:
+ raise
+ _explain_watch_limit(self.ui, self.repo, self.watches)
+
+ def setup(self):
+ self.ui.note(_('watching directories under %r\n') % self.repo.root)
+ self.add_watch(self.repo.path, inotify.IN_DELETE)
+ self.check_dirstate()
+
+ def wpath(self, evt):
+ path = evt.fullpath
+ if path == self.repo.root:
+ return ''
+ if path.startswith(self.wprefix):
+ return path[len(self.wprefix):]
+ raise 'wtf? ' + path
+
+ def dir(self, tree, path):
+ if path:
+ for name in path.split('/'):
+ tree.setdefault(name, {})
+ tree = tree[name]
+ return tree
+
+ def lookup(self, path, tree):
+ if path:
+ try:
+ for name in path.split('/'):
+ tree = tree[name]
+ except KeyError:
+ return 'x'
+ except TypeError:
+ return 'd'
+ return tree
+
+ def split(self, path):
+ c = path.rfind('/')
+ if c == -1:
+ return '', path
+ return path[:c], path[c+1:]
+
+ def filestatus(self, fn, st):
+ try:
+ type_, mode, size, time = self.repo.dirstate._map[fn][:4]
+ except KeyError:
+ type_ = '?'
+ if type_ == 'n':
+ if not st:
+ return '!'
+ st_mode, st_size, st_mtime = st
+ if size and (size != st_size or (mode ^ st_mode) & 0100):
+ return 'm'
+ if time != int(st_mtime):
+ return 'l'
+ return 'n'
+ if type_ in 'ma' and not st:
+ return '!'
+ if type_ == '?' and self.repo.dirstate._ignore(fn):
+ return 'i'
+ return type_
+
+ def updatestatus(self, wfn, st=None, status=None, oldstatus=None):
+ if st:
+ status = self.filestatus(wfn, st)
+ else:
+ self.statcache.pop(wfn, None)
+ root, fn = self.split(wfn)
+ d = self.dir(self.tree, root)
+ if oldstatus is None:
+ oldstatus = d.get(fn)
+ isdir = False
+ if oldstatus:
+ try:
+ if not status:
+ if oldstatus in 'almn':
+ status = '!'
+ elif oldstatus == 'r':
+ status = 'r'
+ except TypeError:
+ # oldstatus may be a dict left behind by a deleted
+ # directory
+ isdir = True
+ else:
+ if oldstatus in self.statuskeys and oldstatus != status:
+ del self.dir(self.statustrees[oldstatus], root)[fn]
+ if self.ui.debugflag and oldstatus != status:
+ if isdir:
+ self.ui.note('status: %r dir(%d) -> %s\n' %
+ (wfn, len(oldstatus), status))
+ else:
+ self.ui.note('status: %r %s -> %s\n' %
+ (wfn, oldstatus, status))
+ if not isdir:
+ if status and status != 'i':
+ d[fn] = status
+ if status in self.statuskeys:
+ dd = self.dir(self.statustrees[status], root)
+ if oldstatus != status or fn not in dd:
+ dd[fn] = status
+ else:
+ d.pop(fn, None)
+
+ def check_deleted(self, key):
+ # Files that had been deleted but were present in the dirstate
+ # may have vanished from the dirstate; we must clean them up.
+ nuke = []
+ for wfn, ignore in self.walk(key, self.statustrees[key]):
+ if wfn not in self.repo.dirstate:
+ nuke.append(wfn)
+ for wfn in nuke:
+ root, fn = self.split(wfn)
+ del self.dir(self.statustrees[key], root)[fn]
+ del self.dir(self.tree, root)[fn]
+
+ def scan(self, topdir=''):
+ self.handle_timeout()
+ ds = self.repo.dirstate._map.copy()
+ self.add_watch(join(self.repo.root, topdir), self.mask)
+ for root, dirs, entries in walk(self.repo, topdir):
+ for d in dirs:
+ self.add_watch(join(root, d), self.mask)
+ wroot = root[len(self.wprefix):]
+ d = self.dir(self.tree, wroot)
+ for fn, kind in entries:
+ wfn = join(wroot, fn)
+ self.updatestatus(wfn, self.getstat(wfn))
+ ds.pop(wfn, None)
+ wtopdir = topdir
+ if wtopdir and wtopdir[-1] != '/':
+ wtopdir += '/'
+ for wfn, state in ds.iteritems():
+ if not wfn.startswith(wtopdir):
+ continue
+ status = state[0]
+ st = self.getstat(wfn)
+ if status == 'r' and not st:
+ self.updatestatus(wfn, st, status=status)
+ else:
+ self.updatestatus(wfn, st, oldstatus=status)
+ self.check_deleted('!')
+ self.check_deleted('r')
+
+ def check_dirstate(self):
+ ds_info = self.dirstate_info()
+ if ds_info == self.ds_info:
+ return
+ self.ds_info = ds_info
+ if not self.ui.debugflag:
+ self.last_event = None
+ self.ui.note(_('%s dirstate reload\n') % self.event_time())
+ self.repo.dirstate.invalidate()
+ self.scan()
+ self.ui.note(_('%s end dirstate reload\n') % self.event_time())
+
+ def walk(self, states, tree, prefix=''):
+ # This is the "inner loop" when talking to the client.
+
+ for name, val in tree.iteritems():
+ path = join(prefix, name)
+ try:
+ if val in states:
+ yield path, val
+ except TypeError:
+ for p in self.walk(states, val, path):
+ yield p
+
+ def update_hgignore(self):
+ # An update of the ignore file can potentially change the
+ # states of all unknown and ignored files.
+
+ # XXX If the user has other ignore files outside the repo, or
+ # changes their list of ignore files at run time, we'll
+ # potentially never see changes to them. We could get the
+ # client to report to us what ignore data they're using.
+ # But it's easier to do nothing than to open that can of
+ # worms.
+
+ if self.repo.dirstate.ignorefunc is not None:
+ self.repo.dirstate.ignorefunc = None
+ self.ui.note('rescanning due to .hgignore change\n')
+ self.scan()
+
+ def getstat(self, wpath):
+ try:
+ return self.statcache[wpath]
+ except KeyError:
+ try:
+ return self.stat(wpath)
+ except OSError, err:
+ if err.errno != errno.ENOENT:
+ raise
+
+ def stat(self, wpath):
+ try:
+ st = os.lstat(join(self.wprefix, wpath))
+ ret = st.st_mode, st.st_size, st.st_mtime
+ self.statcache[wpath] = ret
+ return ret
+ except OSError, err:
+ self.statcache.pop(wpath, None)
+ raise
+
+ def created(self, wpath):
+ if wpath == '.hgignore':
+ self.update_hgignore()
+ try:
+ st = self.stat(wpath)
+ if stat.S_ISREG(st[0]):
+ self.updatestatus(wpath, st)
+ except OSError, err:
+ pass
+
+ def modified(self, wpath):
+ if wpath == '.hgignore':
+ self.update_hgignore()
+ try:
+ st = self.stat(wpath)
+ if stat.S_ISREG(st[0]):
+ if self.repo.dirstate[wpath] in 'lmn':
+ self.updatestatus(wpath, st)
+ except OSError:
+ pass
+
+ def deleted(self, wpath):
+ if wpath == '.hgignore':
+ self.update_hgignore()
+ elif wpath.startswith('.hg/'):
+ if wpath == '.hg/wlock':
+ self.check_dirstate()
+ return
+
+ self.updatestatus(wpath, None)
+
+ def schedule_work(self, wpath, evt):
+ self.eventq.setdefault(wpath, [])
+ prev = self.eventq[wpath]
+ try:
+ if prev and evt == 'm' and prev[-1] in 'cm':
+ return
+ self.eventq[wpath].append(evt)
+ finally:
+ self.deferred += 1
+ self.timeout = 250
+
+ def deferred_event(self, wpath, evt):
+ if evt == 'c':
+ self.created(wpath)
+ elif evt == 'm':
+ self.modified(wpath)
+ elif evt == 'd':
+ self.deleted(wpath)
+
+ def process_create(self, wpath, evt):
+ if self.ui.debugflag:
+ self.ui.note(_('%s event: created %s\n') %
+ (self.event_time(), wpath))
+
+ if evt.mask & inotify.IN_ISDIR:
+ self.scan(wpath)
+ else:
+ self.schedule_work(wpath, 'c')
+
+ def process_delete(self, wpath, evt):
+ if self.ui.debugflag:
+ self.ui.note(('%s event: deleted %s\n') %
+ (self.event_time(), wpath))
+
+ if evt.mask & inotify.IN_ISDIR:
+ self.scan(wpath)
+ else:
+ self.schedule_work(wpath, 'd')
+
+ def process_modify(self, wpath, evt):
+ if self.ui.debugflag:
+ self.ui.note(_('%s event: modified %s\n') %
+ (self.event_time(), wpath))
+
+ if not (evt.mask & inotify.IN_ISDIR):
+ self.schedule_work(wpath, 'm')
+
+ def process_unmount(self, evt):
+ self.ui.warn(_('filesystem containing %s was unmounted\n') %
+ evt.fullpath)
+ sys.exit(0)
+
+ def handle_event(self, fd, event):
+ if self.ui.debugflag:
+ self.ui.note('%s readable: %d bytes\n' %
+ (self.event_time(), self.threshold.readable()))
+ if not self.threshold():
+ if self.registered:
+ if self.ui.debugflag:
+ self.ui.note('%s below threshold - unhooking\n' %
+ (self.event_time()))
+ self.master.poll.unregister(fd)
+ self.registered = False
+ self.timeout = 250
+ else:
+ self.read_events()
+
+ def read_events(self, bufsize=None):
+ events = self.watcher.read(bufsize)
+ if self.ui.debugflag:
+ self.ui.note('%s reading %d events\n' %
+ (self.event_time(), len(events)))
+ for evt in events:
+ wpath = self.wpath(evt)
+ if evt.mask & inotify.IN_UNMOUNT:
+ self.process_unmount(wpath, evt)
+ elif evt.mask & (inotify.IN_MODIFY | inotify.IN_ATTRIB):
+ self.process_modify(wpath, evt)
+ elif evt.mask & (inotify.IN_DELETE | inotify.IN_DELETE_SELF |
+ inotify.IN_MOVED_FROM):
+ self.process_delete(wpath, evt)
+ elif evt.mask & (inotify.IN_CREATE | inotify.IN_MOVED_TO):
+ self.process_create(wpath, evt)
+
+ def handle_timeout(self):
+ if not self.registered:
+ if self.ui.debugflag:
+ self.ui.note('%s hooking back up with %d bytes readable\n' %
+ (self.event_time(), self.threshold.readable()))
+ self.read_events(0)
+ self.master.poll.register(self, select.POLLIN)
+ self.registered = True
+
+ if self.eventq:
+ if self.ui.debugflag:
+ self.ui.note('%s processing %d deferred events as %d\n' %
+ (self.event_time(), self.deferred,
+ len(self.eventq)))
+ eventq = self.eventq.items()
+ eventq.sort()
+ for wpath, evts in eventq:
+ for evt in evts:
+ self.deferred_event(wpath, evt)
+ self.eventq.clear()
+ self.deferred = 0
+ self.timeout = None
+
+ def shutdown(self):
+ self.watcher.close()
+
+class Server(object):
+ poll_events = select.POLLIN
+
+ def __init__(self, ui, repo, watcher, timeout):
+ self.ui = ui
+ self.repo = repo
+ self.watcher = watcher
+ self.timeout = timeout
+ self.sock = socket.socket(socket.AF_UNIX)
+ self.sockpath = self.repo.join('inotify.sock')
+ try:
+ self.sock.bind(self.sockpath)
+ except socket.error, err:
+ if err[0] == errno.EADDRINUSE:
+ raise AlreadyStartedException(_('could not start server: %s') \
+ % err[1])
+ raise
+ self.sock.listen(5)
+ self.fileno = self.sock.fileno
+
+ def handle_timeout(self):
+ pass
+
+ def handle_event(self, fd, event):
+ sock, addr = self.sock.accept()
+
+ cs = common.recvcs(sock)
+ version = ord(cs.read(1))
+
+ sock.sendall(chr(common.version))
+
+ if version != common.version:
+ self.ui.warn(_('received query from incompatible client '
+ 'version %d\n') % version)
+ return
+
+ names = cs.read().split('\0')
+
+ states = names.pop()
+
+ self.ui.note(_('answering query for %r\n') % states)
+
+ if self.watcher.timeout:
+ # We got a query while a rescan is pending. Make sure we
+ # rescan before responding, or we could give back a wrong
+ # answer.
+ self.watcher.handle_timeout()
+
+ if not names:
+ def genresult(states, tree):
+ for fn, state in self.watcher.walk(states, tree):
+ yield fn
+ else:
+ def genresult(states, tree):
+ for fn in names:
+ l = self.watcher.lookup(fn, tree)
+ try:
+ if l in states:
+ yield fn
+ except TypeError:
+ for f, s in self.watcher.walk(states, l, fn):
+ yield f
+
+ results = ['\0'.join(r) for r in [
+ genresult('l', self.watcher.statustrees['l']),
+ genresult('m', self.watcher.statustrees['m']),
+ genresult('a', self.watcher.statustrees['a']),
+ genresult('r', self.watcher.statustrees['r']),
+ genresult('!', self.watcher.statustrees['!']),
+ '?' in states and genresult('?', self.watcher.statustrees['?']) or [],
+ [],
+ 'c' in states and genresult('n', self.watcher.tree) or [],
+ ]]
+
+ try:
+ try:
+ sock.sendall(struct.pack(common.resphdrfmt,
+ *map(len, results)))
+ sock.sendall(''.join(results))
+ finally:
+ sock.shutdown(socket.SHUT_WR)
+ except socket.error, err:
+ if err[0] != errno.EPIPE:
+ raise
+
+ def shutdown(self):
+ self.sock.close()
+ try:
+ os.unlink(self.sockpath)
+ except OSError, err:
+ if err.errno != errno.ENOENT:
+ raise
+
+class Master(object):
+ def __init__(self, ui, repo, timeout=None):
+ self.ui = ui
+ self.repo = repo
+ self.poll = select.poll()
+ self.watcher = Watcher(ui, repo, self)
+ self.server = Server(ui, repo, self.watcher, timeout)
+ self.table = {}
+ for obj in (self.watcher, self.server):
+ fd = obj.fileno()
+ self.table[fd] = obj
+ self.poll.register(fd, obj.poll_events)
+
+ def register(self, fd, mask):
+ self.poll.register(fd, mask)
+
+ def shutdown(self):
+ for obj in self.table.itervalues():
+ obj.shutdown()
+
+ def run(self):
+ self.watcher.setup()
+ self.ui.note(_('finished setup\n'))
+ if os.getenv('TIME_STARTUP'):
+ sys.exit(0)
+ while True:
+ timeout = None
+ timeobj = None
+ for obj in self.table.itervalues():
+ if obj.timeout is not None and (timeout is None or obj.timeout < timeout):
+ timeout, timeobj = obj.timeout, obj
+ try:
+ if self.ui.debugflag:
+ if timeout is None:
+ self.ui.note('polling: no timeout\n')
+ else:
+ self.ui.note('polling: %sms timeout\n' % timeout)
+ events = self.poll.poll(timeout)
+ except select.error, err:
+ if err[0] == errno.EINTR:
+ continue
+ raise
+ if events:
+ for fd, event in events:
+ self.table[fd].handle_event(fd, event)
+ elif timeobj:
+ timeobj.handle_timeout()
+
+def start(ui, repo):
+ m = Master(ui, repo)
+ sys.stdout.flush()
+ sys.stderr.flush()
+
+ pid = os.fork()
+ if pid:
+ return pid
+
+ os.setsid()
+
+ fd = os.open('/dev/null', os.O_RDONLY)
+ os.dup2(fd, 0)
+ if fd > 0:
+ os.close(fd)
+
+ fd = os.open(ui.config('inotify', 'log', '/dev/null'),
+ os.O_RDWR | os.O_CREAT | os.O_TRUNC)
+ os.dup2(fd, 1)
+ os.dup2(fd, 2)
+ if fd > 2:
+ os.close(fd)
+
+ try:
+ m.run()
+ finally:
+ m.shutdown()
+ os._exit(0)
--- a/setup.py Wed Mar 12 22:20:10 2008 +0100
+++ b/setup.py Wed Mar 12 15:30:11 2008 -0700
@@ -59,6 +59,14 @@
Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c'])
]
+packages = ['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert']
+
+if sys.platform == 'linux2' and os.uname()[2] > '2.6':
+ # the inotify extension is only usable with Linux 2.6 kernels
+ ext_modules.append(Extension('hgext.inotify.linux._inotify',
+ ['hgext/inotify/linux/_inotify.c']))
+ packages.extend(['hgext.inotify', 'hgext.inotify.linux'])
+
try:
import posix
ext_modules.append(Extension('mercurial.osutil', ['mercurial/osutil.c']))
@@ -73,7 +81,7 @@
description='Scalable distributed SCM',
license='GNU GPL',
scripts=['hg'],
- packages=['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert'],
+ packages=packages,
ext_modules=ext_modules,
data_files=[(os.path.join('mercurial', root),
[os.path.join(root, file_) for file_ in files])