# server.py - common entry point for inotify status server

#

# 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 _

from mercurial import cmdutil, osutil, util

import common

import errno

import os

import socket

import stat

import struct

import sys

import tempfile

class AlreadyStartedException(Exception):

    pass

class TimeoutException(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 walk(dirstate, absroot, root):

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

    # This function is critical to performance during startup.

    def walkit(root, reporoot):

        files, dirs = [], []

        try:

            fullpath = join(absroot, 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 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:

            if err.errno == errno.ENOTDIR:

                # fullpath was a directory, but has since been replaced

                # by a file.

                yield fullpath, dirs, files

            elif err.errno not in walk_ignored_errors:

                raise

    return walkit(root, root == '')

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, visited=None):

        """

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

            if visited is not None:

                visited.add(dir.path)

            for e in dir.walk(states):

                yield e

    def lookup(self, states, path, visited):

        """

        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

            visited.add(tree.path)

            return

        try:

            # if path is a directory, walk it

            target = tree.dirs[last]

            visited.add(target.path)

            for file, st in target.walk(states, visited):

                yield file

        except KeyError:

            try:

                if tree.files[last] in states:

                    # path is a file

                    visited.add(tree.path)

                    yield path

            except KeyError:

                # path is not tracked

                pass

class repowatcher(object):

    """

    Watches inotify events

    """

    statuskeys = 'almr!?'

    def __init__(self, ui, dirstate, root):

        self.ui = ui

        self.dirstate = dirstate

        self.wprefix = join(root, '')

        self.prefixlen = len(self.wprefix)

        self.tree = directory()

        self.statcache = {}

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

        self.ds_info = self.dirstate_info()

        self.last_event = None

    def handle_timeout(self):

        pass

    def dirstate_info(self):

        try:

            st = os.lstat(self.wprefix + '.hg/dirstate')

            return st.st_mtime, st.st_ino

        except OSError, err:

            if err.errno != errno.ENOENT:

                raise

            return 0, 0

    def filestatus(self, fn, st):

        try:

            type_, mode, size, time = self.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):

                return 'l'

            return 'n'

        if type_ == '?' and self.dirstate._dirignore(fn):

            # we must check not only if the file is ignored, but if any part

            # of its path match an ignore pattern

            return 'i'

        return type_

    def updatefile(self, wfn, osstat):

        '''

        update the file entry of an existing file.

        osstat: (mode, size, time) tuple, as returned by os.lstat(wfn)

        '''

        self._updatestatus(wfn, self.filestatus(wfn, osstat))

    def deletefile(self, wfn, oldstatus):

        '''

        update the entry of a file which has been deleted.

        oldstatus: char in statuskeys, status of the file before deletion

        '''

        if oldstatus == 'r':

            newstatus = 'r'

        elif oldstatus in 'almn':

            newstatus = '!'

        else:

            newstatus = None

        self.statcache.pop(wfn, None)

        self._updatestatus(wfn, newstatus)

    def _updatestatus(self, wfn, newstatus):

        '''

        Update the stored status of a file.

        newstatus: - char in (statuskeys + 'ni'), new status to apply.

                   - or None, to stop tracking wfn

        '''

        root, fn = split(wfn)

        d = self.tree.dir(root)

        oldstatus = d.files.get(fn)

        # oldstatus can be either:

        # - None : fn is new

        # - a char in statuskeys: fn is a (tracked) file

        if self.ui.debugflag and oldstatus != newstatus:

            self.ui.note(_('status: %r %s -> %s\n') %

                             (wfn, oldstatus, newstatus))

        if oldstatus and oldstatus in self.statuskeys \

            and oldstatus != newstatus:

            del self.statustrees[oldstatus].dir(root).files[fn]

        if newstatus in (None, 'i'):

            d.files.pop(fn, None)

        elif oldstatus != newstatus:

            d.files[fn] = newstatus

            if newstatus != 'n':

                self.statustrees[newstatus].dir(root).files[fn] = newstatus

    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.statustrees[key].walk(key):

            if wfn not in self.dirstate:

                nuke.append(wfn)

        for wfn in nuke:

            root, fn = split(wfn)

            del self.statustrees[key].dir(root).files[fn]

            del self.tree.dir(root).files[fn]

    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 '_ignore' in self.dirstate.__dict__:

            delattr(self.dirstate, '_ignore')

            self.ui.note(_('rescanning due to .hgignore change\n'))

            self.handle_timeout()

            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:

            self.statcache.pop(wpath, None)

            raise

class socketlistener(object):

    """

    Listens for client queries on unix socket inotify.sock

    """

    def __init__(self, ui, root, repowatcher, timeout):

        self.ui = ui

        self.repowatcher = repowatcher

        self.sock = socket.socket(socket.AF_UNIX)

        self.sockpath = join(root, '.hg/inotify.sock')

        self.realsockpath = self.sockpath

        if os.path.islink(self.sockpath):

            if os.path.exists(self.sockpath):

                self.realsockpath = os.readlink(self.sockpath)

            else:

                raise util.Abort('inotify-server: cannot start: '

                                '.hg/inotify.sock is a broken symlink')

        try:

            self.sock.bind(self.realsockpath)

        except socket.error, err:

            if err.args[0] == errno.EADDRINUSE:

                raise AlreadyStartedException(_('cannot start: socket is '

                                                'already bound'))

            if err.args[0] == "AF_UNIX path too long":

                tempdir = tempfile.mkdtemp(prefix="hg-inotify-")

                self.realsockpath = os.path.join(tempdir, "inotify.sock")

                try:

                    self.sock.bind(self.realsockpath)

                    os.symlink(self.realsockpath, self.sockpath)

                except (OSError, socket.error), inst:

                    try:

                        os.unlink(self.realsockpath)

                        pass

                    os.rmdir(tempdir)

                    if inst.errno == errno.EEXIST:

                        raise AlreadyStartedException(_('cannot start: tried '

                            'linking .hg/inotify.sock to a temporary socket but'

                            ' .hg/inotify.sock already exists'))

                    raise

            else:

                raise

        self.sock.listen(5)

        self.fileno = self.sock.fileno

    def answer_stat_query(self, cs):

        names = cs.read().split('\0')

        states = names.pop()

        self.ui.note(_('answering query for %r\n') % states)

        visited = set()

        if not names:

            def genresult(states, tree):

                for fn, state in tree.walk(states):

                    yield fn

        else:

            def genresult(states, tree):

                for fn in names:

                    for f in tree.lookup(states, fn, visited):

                        yield f