# __init__.py - fsmonitor initialization and overrides

#

# Copyright 2013-2016 Facebook, Inc.

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''Faster status operations with the Watchman file monitor (EXPERIMENTAL)

Integrates the file-watching program Watchman with Mercurial to produce faster

status results.

On a particular Linux system, for a real-world repository with over 400,000

files hosted on ext4, vanilla `hg status` takes 1.3 seconds. On the same

system, with fsmonitor it takes about 0.3 seconds.

fsmonitor requires no configuration -- it will tell Watchman about your

repository as necessary. You'll need to install Watchman from

https://facebook.github.io/watchman/ and make sure it is in your PATH.

fsmonitor is incompatible with the largefiles and eol extensions, and

will disable itself if any of those are active.

The following configuration options exist:

::

    [fsmonitor]

    mode = {off, on, paranoid}

When `mode = off`, fsmonitor will disable itself (similar to not loading the

extension at all). When `mode = on`, fsmonitor will be enabled (the default).

When `mode = paranoid`, fsmonitor will query both Watchman and the filesystem,

and ensure that the results are consistent.

::

    [fsmonitor]

    timeout = (float)

A value, in seconds, that determines how long fsmonitor will wait for Watchman

to return results. Defaults to `2.0`.

::

    [fsmonitor]

    blacklistusers = (list of userids)

A list of usernames for which fsmonitor will disable itself altogether.

::

    [fsmonitor]

    walk_on_invalidate = (boolean)

Whether or not to walk the whole repo ourselves when our cached state has been

invalidated, for example when Watchman has been restarted or .hgignore rules

have been changed. Walking the repo in that case can result in competing for

I/O with Watchman. For large repos it is recommended to set this value to

false. You may wish to set this to true if you have a very fast filesystem

that can outpace the IPC overhead of getting the result data for the full repo

from Watchman. Defaults to false.

::

    [fsmonitor]

    warn_when_unused = (boolean)

Whether to print a warning during certain operations when fsmonitor would be

beneficial to performance but isn't enabled.

::

    [fsmonitor]

    warn_update_file_count = (integer)

If ``warn_when_unused`` is set and fsmonitor isn't enabled, a warning will

be printed during working directory updates if this many files will be

created.

'''

# Platforms Supported

# ===================

#

# **Linux:** *Stable*. Watchman and fsmonitor are both known to work reliably,

#   even under severe loads.

#

# **Mac OS X:** *Stable*. The Mercurial test suite passes with fsmonitor

#   turned on, on case-insensitive HFS+. There has been a reasonable amount of

#   user testing under normal loads.

#

# **Solaris, BSD:** *Alpha*. watchman and fsmonitor are believed to work, but

#   very little testing has been done.

#

# **Windows:** *Alpha*. Not in a release version of watchman or fsmonitor yet.

#

# Known Issues

# ============

#

# * fsmonitor will disable itself if any of the following extensions are

#   enabled: largefiles, inotify, eol; or if the repository has subrepos.

# * fsmonitor will produce incorrect results if nested repos that are not

#   subrepos exist. *Workaround*: add nested repo paths to your `.hgignore`.

#

# The issues related to nested repos and subrepos are probably not fundamental

# ones. Patches to fix them are welcome.

from __future__ import absolute_import

import codecs

import hashlib

import os

import stat

import sys

import tempfile

import weakref

from mercurial.i18n import _

from mercurial.node import hex

from mercurial.pycompat import open

from mercurial import (

    context,

    encoding,

    error,

    extensions,

    localrepo,

    merge,

    pathutil,

    pycompat,

    registrar,

    scmutil,

    util,

)

from mercurial import match as matchmod

from mercurial.utils import stringutil

from . import (

    pywatchman,

    state,

    watchmanclient,

)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = b'ships-with-hg-core'

configtable = {}

configitem = registrar.configitem(configtable)

configitem(

    b'fsmonitor', b'mode', default=b'on',

)

configitem(

    b'fsmonitor', b'walk_on_invalidate', default=False,

)

configitem(

    b'fsmonitor', b'timeout', default=b'2',

)

configitem(

    b'fsmonitor', b'blacklistusers', default=list,

)

configitem(

    b'fsmonitor', b'watchman_exe', default=b'watchman',

)

configitem(

    b'fsmonitor', b'verbose', default=True, experimental=True,

)

configitem(

    b'experimental', b'fsmonitor.transaction_notify', default=False,

)

# This extension is incompatible with the following blacklisted extensions

# and will disable itself when encountering one of these:

_blacklist = [b'largefiles', b'eol']

def debuginstall(ui, fm):

    fm.write(

        b"fsmonitor-watchman",

        _(b"fsmonitor checking for watchman binary... (%s)\n"),

        ui.configpath(b"fsmonitor", b"watchman_exe"),

    )

    root = tempfile.mkdtemp()

    c = watchmanclient.client(ui, root)

    err = None

    try:

        v = c.command(b"version")

        fm.write(

            b"fsmonitor-watchman-version",

            _(b" watchman binary version %s\n"),

            pycompat.bytestr(v["version"]),

        )

    except watchmanclient.Unavailable as e:

        err = str(e)

    fm.condwrite(

        err,

        b"fsmonitor-watchman-error",

        _(b" watchman binary missing or broken: %s\n"),

        err,

    )

    return 1 if err else 0

def _handleunavailable(ui, state, ex):

    """Exception handler for Watchman interaction exceptions"""

    if isinstance(ex, watchmanclient.Unavailable):

        # experimental config: fsmonitor.verbose

        if ex.warn and ui.configbool(b'fsmonitor', b'verbose'):

            if b'illegal_fstypes' not in stringutil.forcebytestr(ex):

                ui.warn(stringutil.forcebytestr(ex) + b'\n')

        if ex.invalidate:

            state.invalidate()

        # experimental config: fsmonitor.verbose

        if ui.configbool(b'fsmonitor', b'verbose'):

    else:

def _hashignore(ignore):

    """Calculate hash for ignore patterns and filenames

    If this information changes between Mercurial invocations, we can't

    rely on Watchman information anymore and have to re-scan the working

    copy.

    """

    sha1 = hashlib.sha1()

    sha1.update(repr(ignore))

    return sha1.hexdigest()

_watchmanencoding = pywatchman.encoding.get_local_encoding()

_fsencoding = sys.getfilesystemencoding() or sys.getdefaultencoding()

_fixencoding = codecs.lookup(_watchmanencoding) != codecs.lookup(_fsencoding)

def _watchmantofsencoding(path):

    """Fix path to match watchman and local filesystem encoding

    watchman's paths encoding can differ from filesystem encoding. For example,

    on Windows, it's always utf-8.

    """

    try:

        decoded = path.decode(_watchmanencoding)

    except UnicodeDecodeError as e:

        raise error.Abort(

            stringutil.forcebytestr(e), hint=b'watchman encoding error'

        )

    try:

        encoded = decoded.encode(_fsencoding, 'strict')

    except UnicodeEncodeError as e:

        raise error.Abort(stringutil.forcebytestr(e))

    return encoded

def overridewalk(orig, self, match, subrepos, unknown, ignored, full=True):

    '''Replacement for dirstate.walk, hooking into Watchman.

    Whenever full is False, ignored is False, and the Watchman client is

    available, use Watchman combined with saved state to possibly return only a

    subset of files.'''

    def bail(reason):

        self._ui.debug(b'fsmonitor: fallback to core status, %s\n' % reason)

        return orig(match, subrepos, unknown, ignored, full=True)

    if full:

        return bail(b'full rewalk requested')

    if ignored:

        return bail(b'listing ignored files')

    if not self._watchmanclient.available():

        return bail(b'client unavailable')

    state = self._fsmonitorstate

    clock, ignorehash, notefiles = state.get()

    if not clock:

        if state.walk_on_invalidate:

            return bail(b'no clock')

        # Initial NULL clock value, see

        # https://facebook.github.io/watchman/docs/clockspec.html

        clock = b'c:0:0'

        notefiles = []

    ignore = self._ignore

    dirignore = self._dirignore

    if unknown:

        if _hashignore(ignore) != ignorehash and clock != b'c:0:0':

            # ignore list changed -- can't rely on Watchman state any more

            if state.walk_on_invalidate:

                return bail(b'ignore rules changed')

            notefiles = []

            clock = b'c:0:0'

    else:

        # always ignore

        ignore = util.always

        dirignore = util.always

    matchfn = match.matchfn

    matchalways = match.always()

    dmap = self._map

    if util.safehasattr(dmap, b'_map'):

        # for better performance, directly access the inner dirstate map if the

        # standard dirstate implementation is in use.

        dmap = dmap._map

    nonnormalset = self._map.nonnormalset

    copymap = self._map.copymap

    getkind = stat.S_IFMT

    dirkind = stat.S_IFDIR

    regkind = stat.S_IFREG

    lnkkind = stat.S_IFLNK

    join = self._join

    normcase = util.normcase

    fresh_instance = False

    exact = skipstep3 = False

    if match.isexact():  # match.exact

        exact = True

        dirignore = util.always  # skip step 2

    elif match.prefix():  # match.match, no patterns

        skipstep3 = True

    if not exact and self._checkcase:

        # note that even though we could receive directory entries, we're only

        # interested in checking if a file with the same name exists. So only

        # normalize files if possible.

        normalize = self._normalizefile

        skipstep3 = False

    else:

        normalize = None

    # step 1: find all explicit files

    results, work, dirsnotfound = self._walkexplicit(match, subrepos)

    skipstep3 = skipstep3 and not (work or dirsnotfound)

    work = [d for d in work if not dirignore(d[0])]

    if not work and (exact or skipstep3):

        for s in subrepos:

            del results[s]

        del results[b'.hg']

        return results

    # step 2: query Watchman

    try:

        # Use the user-configured timeout for the query.

        # Add a little slack over the top of the user query to allow for

        # overheads while transferring the data

        self._watchmanclient.settimeout(state.timeout + 0.1)

        result = self._watchmanclient.command(

            b'query',

            {

                b'fields': [b'mode', b'mtime', b'size', b'exists', b'name'],

                b'since': clock,

                b'expression': [

                    b'not',

                    [

                        b'anyof',

                        [b'dirname', b'.hg'],

                        [b'name', b'.hg', b'wholename'],

                    ],

                ],

                b'sync_timeout': int(state.timeout * 1000),

                b'empty_on_fresh_instance': state.walk_on_invalidate,

            },

        )

    except Exception as ex:

        _handleunavailable(self._ui, state, ex)

        self._watchmanclient.clearconnection()

        return bail(b'exception during run')

    else:

        # We need to propagate the last observed clock up so that we

        # can use it for our next query

        state.setlastclock(result[b'clock'])

        if result[b'is_fresh_instance']:

            if state.walk_on_invalidate:

                state.invalidate()

                return bail(b'fresh instance')

            fresh_instance = True

            # Ignore any prior noteable files from the state info

            notefiles = []

    # for file paths which require normalization and we encounter a case

    # collision, we store our own foldmap

    if normalize:

        foldmap = dict((normcase(k), k) for k in results)

    switch_slashes = pycompat.ossep == b'\\'

    # The order of the results is, strictly speaking, undefined.

    # For case changes on a case insensitive filesystem we may receive

    # two entries, one with exists=True and another with exists=False.

    # The exists=True entries in the same response should be interpreted

    # as being happens-after the exists=False entries due to the way that

    # Watchman tracks files.  We use this property to reconcile deletes

    # for name case changes.

    for entry in result[b'files']:

        fname = entry[b'name']

        if _fixencoding:

            fname = _watchmantofsencoding(fname)

        if switch_slashes:

            fname = fname.replace(b'\\', b'/')

        if normalize:

            normed = normcase(fname)

            fname = normalize(fname, True, True)

            foldmap[normed] = fname