This is an archive of the discontinued Mercurial Phabricator instance.

Differential D989

fsmonitor: add new watchman notifications to fsmonitor extension
ClosedPublic

Authored by • ekent on Oct 9 2017, 1:11 PM.

Details

Reviewers
quark
Group Reviewers
hg-reviewers
Commits
rHG4aa57627692a: fsmonitor: add new watchman notifications to fsmonitor extension
Summary

The fsmonitor extension currently sends state-enter and state-leave
notifications to watchman on the update operation. This commit creates
additional notifications for the following events :

  • transaction creation and commit/abort. A state-enter notification will be sent when a transaction is created. It will provide the working copy parent's hash. A state-leave notification will be sent when the transaction is committed or aborted. It will provide the working copy parent's hash.
  • calls to set-parent will cause state-enter and state-leave notifications to be sent. The state-enter notification will be sent prior to the set-parent operation and the working copy parent's hash will be provided at this time. The state-leave notification will be sent after the set-parent operation completes providing the working copy parents hash.
Test Plan

tested on dev server to check that necessary notifications were sent/received

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

• ekent created this revision.Oct 9 2017, 1:11 PM
quark accepted this revision.Oct 9 2017, 2:15 PM
quark added a subscriber: quark.

This was previously reviewed internally.

Closed by commit rHG4aa57627692a: fsmonitor: add new watchman notifications to fsmonitor extension (authored by • ekent). · Explain WhyOct 10 2017, 2:16 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/fsmonitor/__init__.py (108 lines)

Diff 2569

hgext/fsmonitor/__init__.py

from __future__ import absolute_import from __future__ import absolute_import
import codecs import codecs
import hashlib import hashlib
import os import os
import stat import stat
import sys import sys
import weakref
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
hex,
nullid,
)
from mercurial import ( from mercurial import (
context, context,
encoding, encoding,
error, error,
extensions, extensions,
localrepo, localrepo,
merge, merge,
pathutil, pathutil,
clock = wctx.repo()._fsmonitorstate.getlastclock() or self._startclock clock = wctx.repo()._fsmonitorstate.getlastclock() or self._startclock
hashignore = _hashignore(wctx.repo().dirstate._ignore) hashignore = _hashignore(wctx.repo().dirstate._ignore)
notefiles = (status.modified + status.added + status.removed + notefiles = (status.modified + status.added + status.removed +
status.deleted + status.unknown) status.deleted + status.unknown)
wctx.repo()._fsmonitorstate.set(clock, hashignore, notefiles) wctx.repo()._fsmonitorstate.set(clock, hashignore, notefiles)
def makedirstate(repo, dirstate): def makedirstate(repo, dirstate):
class fsmonitordirstate(dirstate.__class__): class fsmonitordirstate(dirstate.__class__):
def _fsmonitorinit(self, fsmonitorstate, watchmanclient): def _fsmonitorinit(self, repo):
# _fsmonitordisable is used in paranoid mode # _fsmonitordisable is used in paranoid mode
self._fsmonitordisable = False self._fsmonitordisable = False
self._fsmonitorstate = fsmonitorstate self._fsmonitorstate = repo._fsmonitorstate
self._watchmanclient = watchmanclient self._watchmanclient = repo._watchmanclient
self._repo = weakref.proxy(repo)
def walk(self, *args, **kwargs): def walk(self, *args, **kwargs):
orig = super(fsmonitordirstate, self).walk orig = super(fsmonitordirstate, self).walk
if self._fsmonitordisable: if self._fsmonitordisable:
return orig(*args, **kwargs) return orig(*args, **kwargs)
return overridewalk(orig, self, *args, **kwargs) return overridewalk(orig, self, *args, **kwargs)
def rebuild(self, *args, **kwargs): def rebuild(self, *args, **kwargs):
self._fsmonitorstate.invalidate() self._fsmonitorstate.invalidate()
return super(fsmonitordirstate, self).rebuild(*args, **kwargs) return super(fsmonitordirstate, self).rebuild(*args, **kwargs)
def invalidate(self, *args, **kwargs): def invalidate(self, *args, **kwargs):
self._fsmonitorstate.invalidate() self._fsmonitorstate.invalidate()
return super(fsmonitordirstate, self).invalidate(*args, **kwargs) return super(fsmonitordirstate, self).invalidate(*args, **kwargs)
if dirstate._ui.configbool(
"experimental", "fsmonitor.wc_change_notify"):
def setparents(self, p1, p2=nullid):
with state_update(self._repo, name="hg.wc_change",
oldnode=self._pl[0], newnode=p1,
partial=False):
return super(fsmonitordirstate, self).setparents(p1, p2)
dirstate.__class__ = fsmonitordirstate dirstate.__class__ = fsmonitordirstate
dirstate._fsmonitorinit(repo._fsmonitorstate, repo._watchmanclient) dirstate._fsmonitorinit(repo)
def wrapdirstate(orig, self): def wrapdirstate(orig, self):
ds = orig(self) ds = orig(self)
# only override the dirstate when Watchman is available for the repo # only override the dirstate when Watchman is available for the repo
if util.safehasattr(self, '_fsmonitorstate'): if util.safehasattr(self, '_fsmonitorstate'):
makedirstate(self, ds) makedirstate(self, ds)
return ds return ds
finally: finally:
try: try:
os.utime(os.path.dirname(link_name), None) os.utime(os.path.dirname(link_name), None)
except OSError: except OSError:
pass pass
class state_update(object): class state_update(object):
''' This context manager is responsible for dispatching the state-enter ''' This context manager is responsible for dispatching the state-enter
and state-leave signals to the watchman service ''' and state-leave signals to the watchman service. The enter and leave
methods can be invoked manually (for scenarios where context manager
def __init__(self, repo, node, distance, partial): semantics are not possible). If parameters oldnode and newnode are None,
self.repo = repo they will be populated based on current working copy in enter and
self.node = node leave, respectively. Similarly, if the distance is none, it will be
calculated based on the oldnode and newnode in the leave method.'''
def __init__(self, repo, name, oldnode=None, newnode=None, distance=None,
partial=False):
self.repo = repo.unfiltered()
self.name = name
self.oldnode = oldnode
self.newnode = newnode
self.distance = distance self.distance = distance
self.partial = partial self.partial = partial
self._lock = None self._lock = None
self.need_leave = False self.need_leave = False
def __enter__(self): def __enter__(self):
self.enter()
def enter(self):
# We explicitly need to take a lock here, before we proceed to update # We explicitly need to take a lock here, before we proceed to update
# watchman about the update operation, so that we don't race with # watchman about the update operation, so that we don't race with
# some other actor. merge.update is going to take the wlock almost # some other actor. merge.update is going to take the wlock almost
# immediately anyway, so this is effectively extending the lock # immediately anyway, so this is effectively extending the lock
# around a couple of short sanity checks. # around a couple of short sanity checks.
if self.oldnode is None:
self.oldnode = self.repo['.'].node()
self._lock = self.repo.wlock() self._lock = self.repo.wlock()
self.need_leave = self._state('state-enter') self.need_leave = self._state(
'state-enter',
hex(self.oldnode))
return self return self
def __exit__(self, type_, value, tb): def __exit__(self, type_, value, tb):
abort = True if type_ else False
self.exit(abort=abort)
def exit(self, abort=False):
try: try:
if self.need_leave: if self.need_leave:
status = 'ok' if type_ is None else 'failed' status = 'failed' if abort else 'ok'
self._state('state-leave', status=status) if self.newnode is None:
self.newnode = self.repo['.'].node()
if self.distance is None:
self.distance = calcdistance(
self.repo, self.oldnode, self.newnode)
self._state(
'state-leave',
hex(self.newnode),
status=status)
finally: finally:
self.need_leave = False
if self._lock: if self._lock:
self._lock.release() self._lock.release()
def _state(self, cmd, status='ok'): def _state(self, cmd, commithash, status='ok'):
if not util.safehasattr(self.repo, '_watchmanclient'): if not util.safehasattr(self.repo, '_watchmanclient'):
return False return False
try: try:
commithash = self.repo[self.node].hex()
self.repo._watchmanclient.command(cmd, { self.repo._watchmanclient.command(cmd, {
'name': 'hg.update', 'name': self.name,
'metadata': { 'metadata': {
# the target revision # the target revision
'rev': commithash, 'rev': commithash,
# approximate number of commits between current and target # approximate number of commits between current and target
'distance': self.distance, 'distance': self.distance if self.distance else 0,
# success/failure (only really meaningful for state-leave) # success/failure (only really meaningful for state-leave)
'status': status, 'status': status,
# whether the working copy parent is changing # whether the working copy parent is changing
'partial': self.partial, 'partial': self.partial,
}}) }})
return True return True
except Exception as e: except Exception as e:
# Swallow any errors; fire and forget # Swallow any errors; fire and forget
# and state-leave commands. This allows clients to perform more intelligent # and state-leave commands. This allows clients to perform more intelligent
# settling during bulk file change scenarios # settling during bulk file change scenarios
# https://facebook.github.io/watchman/docs/cmd/subscribe.html#advanced-settling # https://facebook.github.io/watchman/docs/cmd/subscribe.html#advanced-settling
def wrapupdate(orig, repo, node, branchmerge, force, ancestor=None, def wrapupdate(orig, repo, node, branchmerge, force, ancestor=None,
mergeancestor=False, labels=None, matcher=None, **kwargs): mergeancestor=False, labels=None, matcher=None, **kwargs):
distance = 0 distance = 0
partial = True partial = True
oldnode = repo['.'].node()
newnode = repo[node].node()
if matcher is None or matcher.always(): if matcher is None or matcher.always():
partial = False partial = False
distance = calcdistance(repo.unfiltered(), repo['.'].node(), distance = calcdistance(repo.unfiltered(), oldnode, newnode)
repo[node].node())
with state_update(repo, node, distance, partial): with state_update(repo, name="hg.update", oldnode=oldnode, newnode=newnode,
distance=distance, partial=partial):
return orig( return orig(
repo, node, branchmerge, force, ancestor, mergeancestor, repo, node, branchmerge, force, ancestor, mergeancestor,
labels, matcher, **kwargs) labels, matcher, **kwargs)
def reposetup(ui, repo): def reposetup(ui, repo):
# We don't work with largefiles or inotify # We don't work with largefiles or inotify
exts = extensions.enabled() exts = extensions.enabled()
for ext in _blacklist: for ext in _blacklist:
# repo.dirstate is not a fsmonitordirstate # repo.dirstate is not a fsmonitordirstate
makedirstate(repo, dirstate) makedirstate(repo, dirstate)
class fsmonitorrepo(repo.__class__): class fsmonitorrepo(repo.__class__):
def status(self, *args, **kwargs): def status(self, *args, **kwargs):
orig = super(fsmonitorrepo, self).status orig = super(fsmonitorrepo, self).status
return overridestatus(orig, self, *args, **kwargs) return overridestatus(orig, self, *args, **kwargs)
if ui.configbool("experimental", "fsmonitor.transaction_notify"):
def transaction(self, *args, **kwargs):
tr = super(fsmonitorrepo, self).transaction(
*args, **kwargs)
if tr.count != 1:
return tr
stateupdate = state_update(self, name="hg.transaction")
stateupdate.enter()
class fsmonitortrans(tr.__class__):
def _abort(self):
try:
result = super(fsmonitortrans, self)._abort()
finally:
stateupdate.exit(abort=True)
return result
def close(self):
try:
result = super(fsmonitortrans, self).close()
finally:
if self.count == 0:
stateupdate.exit()
return result
tr.__class__ = fsmonitortrans
return tr
repo.__class__ = fsmonitorrepo repo.__class__ = fsmonitorrepo