# 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 version 2, incorporated herein by reference.

from mercurial.i18n import _

from mercurial import osutil, util

import common

import errno, os, select, socket, stat, struct, sys, tempfile, time

try:

    import linux as inotify

    from linux import watcher

except ImportError:

    raise

class AlreadyStartedException(Exception): pass

def join(a, b):

    if a:

        if a[-1] == '/':

            return a + b

        return a + '/' + b

    return b

def split(path):

    c = path.rfind('/')

    if c == -1:

        return '', path

    return path[:c], path[c+1:]

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):

        fullpath = rootslash + dirname

        try:

            for name, kind in osutil.listdir(fullpath):

                if kind == stat.S_IFDIR:

                    if name == '.hg':

                        if not top:

                            return

                    else:

                        d = join(dirname, name)

                        if repo.dirstate._ignore(d):

                            continue

                        for subdir in walkit(d, False):

                            yield subdir

        except OSError, err:

            if err.errno not in walk_ignored_errors:

                raise

        yield fullpath

    return walkit('', True)

def walk(repo, root):

    '''Like os.walk, but only yields regular files.'''

    # This function is critical to performance during startup.

    rootslash = repo.root + os.sep

    def walkit(root, reporoot):

        files, dirs = [], []

        try:

            fullpath = rootslash + root

            for name, kind in osutil.listdir(fullpath):

                if kind == stat.S_IFDIR:

                    if name == '.hg':

                        if not reporoot:

                            return

                    else:

                        dirs.append(name)

                        path = join(root, name)

                        if repo.dirstate._ignore(path):

                            continue

                        for result in walkit(path, False):

                            yield result

                elif kind in (stat.S_IFREG, stat.S_IFLNK):

                    files.append(name)

            yield fullpath, dirs, files

        except OSError, err:

                raise

    return walkit(root, root == '')

def _explain_watch_limit(ui, repo):

    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 pollable(object):

    """

    Interface to support polling.

    The file descriptor returned by fileno() is registered to a polling

    object.

    Usage:

        Every tick, check if an event has happened since the last tick:

        * If yes, call handle_events

        * If no, call handle_timeout

    """

    poll_events = select.POLLIN

    instances = {}

    poll = select.poll()

    def fileno(self):

        raise NotImplementedError

    def handle_events(self, events):

        raise NotImplementedError

    def handle_timeout(self):

        raise NotImplementedError

    def shutdown(self):

        raise NotImplementedError

    def register(self, timeout):

        fd = self.fileno()

        pollable.poll.register(fd, pollable.poll_events)

        pollable.instances[fd] = self

        self.registered = True

        self.timeout = timeout

    def unregister(self):

        pollable.poll.unregister(self)

        self.registered = False

    @classmethod

    def run(cls):

        while True:

            timeout = None

            timeobj = None

            for obj in cls.instances.itervalues():

                if obj.timeout is not None and (timeout is None or obj.timeout < timeout):

                    timeout, timeobj = obj.timeout, obj

            try:

                events = cls.poll.poll(timeout)

            except select.error, err:

                if err[0] == errno.EINTR:

                    continue

                raise

            if events:

                by_fd = {}

                for fd, event in events:

                    by_fd.setdefault(fd, []).append(event)

                for fd, events in by_fd.iteritems():

                    cls.instances[fd].handle_pollevents(events)

            elif timeobj:

                timeobj.handle_timeout()

def eventaction(code):

    """

    Decorator to help handle events in repowatcher

    """

    def decorator(f):

        def wrapper(self, wpath):

            if code == 'm' and wpath in self.lastevent and \

                self.lastevent[wpath] in 'cm':

                return

            self.lastevent[wpath] = code

            self.timeout = 250

            f(self, wpath)

        wrapper.func_name = f.func_name

        return wrapper

    return decorator

class directory(object):

    """

    Representing a directory

    * path is the relative path from repo root to this directory

    * files is a dict listing the files in this directory

        - keys are file names

        - values are file status

    * dirs is a dict listing the subdirectories

        - key are subdirectories names

        - values are directory objects

    """

    def __init__(self, relpath=''):

        self.path = relpath

        self.files = {}

        self.dirs = {}

    def dir(self, relpath):

        """

        Returns the directory contained at the relative path relpath.

        Creates the intermediate directories if necessary.

        """

        if not relpath:

            return self

        l = relpath.split('/')

        ret = self

        while l:

            next = l.pop(0)

            try:

                ret = ret.dirs[next]

            except KeyError:

                d = directory(join(ret.path, next))

                ret.dirs[next] = d

                ret = d

        return ret

    def walk(self, states):

        """

        yield (filename, status) pairs for items in the trees

        that have status in states.

        filenames are relative to the repo root

        """

        for file, st in self.files.iteritems():

            if st in states:

                yield join(self.path, file), st

        for dir in self.dirs.itervalues():

            for e in dir.walk(states):

                yield e

    def lookup(self, states, path):

        """

        yield root-relative filenames that match path, and whose

        status are in states:

        * if path is a file, yield path

        * if path is a directory, yield directory files

        * if path is not tracked, yield nothing

        """

        if path[-1] == '/':

            path = path[:-1]

        paths = path.split('/')

        # we need to check separately for last node

        last = paths.pop()

        tree = self

        try:

            for dir in paths:

                tree = tree.dirs[dir]

        except KeyError:

            # path is not tracked

            return

        try:

            # if path is a directory, walk it

            for file, st in tree.dirs[last].walk(states):

                yield file

        except KeyError:

            try:

                if tree.files[last] in states:

                    # path is a file

                    yield path

            except KeyError:

                # path is not tracked

                pass

class repowatcher(pollable):

    """

    Watches inotify events

    """

    statuskeys = 'almr!?'

    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)

    def __init__(self, ui, repo):

        self.ui = ui

        self.repo = repo

        self.wprefix = self.repo.wjoin('')

        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.fileno = self.watcher.fileno

        self.tree = directory()

        self.statcache = {}

        self.statustrees = dict([(s, directory()) for s in self.statuskeys])

        self.last_event = None

        self.lastevent = {}

        self.register(timeout=None)

        self.ds_info = self.dirstate_info()

        self.handle_timeout()

        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)

            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)

    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 filestatus(self, fn, st):

        try:

            type_, mode, size, time = self.repo.dirstate._map[fn][:4]

        except KeyError:

            type_ = '?'

        if type_ == 'n':

            st_mode, st_size, st_mtime = st

            if size == -1:

                return 'l'

            if size and (size != st_size or (mode ^ st_mode) & 0100):

                return 'm'

            if time != int(st_mtime):