# server.py - inotify status server

#

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

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

#

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

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 == -1:

                return 'l'

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

        if st:

            status = self.filestatus(wfn, st)

        else:

            self.statcache.pop(wfn, None)

        root, fn = self.split(wfn)

        d = self.dir(self.tree, root)

        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)

        elif not status:

            # a directory is being removed, check its contents

            for subfile, b in oldstatus.copy().iteritems():

                self.updatestatus(wfn + '/' + subfile, 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

            try:

                st = self.stat(wfn)

            except OSError:

                status = state[0]

                self.updatestatus(wfn, None, status=status)

            else:

                self.updatestatus(wfn, st)

        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.