This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5954

watchman: add the possibility to set the exact watchman binary location
ClosedPublic

Authored by lothiraldan on Feb 13 2019, 11:22 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG57264906a996: watchman: add the possibility to set the exact watchman binary location
Summary

This is necessary to make rolling releases of new watchman versions across
users.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

Diff 14076

hgext/fsmonitor/__init__.py

default=False, default=False,
) )
configitem('fsmonitor', 'timeout', configitem('fsmonitor', 'timeout',
default='2', default='2',
) )
configitem('fsmonitor', 'blacklistusers', configitem('fsmonitor', 'blacklistusers',
default=list, default=list,
) )
configitem('fsmonitor', 'watchman_exe',
default='watchman',
)
configitem('fsmonitor', 'verbose', configitem('fsmonitor', 'verbose',
default=True, default=True,
) )
configitem('experimental', 'fsmonitor.transaction_notify', configitem('experimental', 'fsmonitor.transaction_notify',
default=False, default=False,
) )
# This extension is incompatible with the following blacklisted extensions # This extension is incompatible with the following blacklisted extensions

hgext/fsmonitor/pywatchman/__init__.py

def setTimeout(self, value): def setTimeout(self, value):
self.transport.setTimeout(value) self.transport.setTimeout(value)
class UnixSocketTransport(Transport): class UnixSocketTransport(Transport):
""" local unix domain socket transport """ """ local unix domain socket transport """
sock = None sock = None
def __init__(self, sockpath, timeout): def __init__(self, sockpath, timeout, watchman_exe):
self.sockpath = sockpath self.sockpath = sockpath
self.timeout = timeout self.timeout = timeout
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try: try:
sock.settimeout(self.timeout) sock.settimeout(self.timeout)
sock.connect(self.sockpath) sock.connect(self.sockpath)
self.sock = sock self.sock = sock
return False return False
return GetOverlappedResult(pipe, olap, nbytes, False) return GetOverlappedResult(pipe, olap, nbytes, False)
class WindowsNamedPipeTransport(Transport): class WindowsNamedPipeTransport(Transport):
""" connect to a named pipe """ """ connect to a named pipe """
def __init__(self, sockpath, timeout): def __init__(self, sockpath, timeout, watchman_exe):
self.sockpath = sockpath self.sockpath = sockpath
self.timeout = int(math.ceil(timeout * 1000)) self.timeout = int(math.ceil(timeout * 1000))
self._iobuf = None self._iobuf = None
self.pipe = CreateFile(sockpath, GENERIC_READ | GENERIC_WRITE, 0, None, self.pipe = CreateFile(sockpath, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, None) OPEN_EXISTING, FILE_FLAG_OVERLAPPED, None)
if self.pipe == INVALID_HANDLE_VALUE: if self.pipe == INVALID_HANDLE_VALUE:
limits this implementation to JSON input and output only at this time. limits this implementation to JSON input and output only at this time.
It is the responsibility of the caller to set the send and It is the responsibility of the caller to set the send and
receive codecs appropriately. receive codecs appropriately.
""" """
proc = None proc = None
closed = True closed = True
def __init__(self, sockpath, timeout): def __init__(self, sockpath, timeout, watchman_exe):
self.sockpath = sockpath self.sockpath = sockpath
self.timeout = timeout self.timeout = timeout
self.watchman_exe = watchman_exe
def close(self): def close(self):
if self.proc: if self.proc:
if self.proc.pid is not None: if self.proc.pid is not None:
self.proc.kill() self.proc.kill()
self.proc.stdin.close() self.proc.stdin.close()
self.proc.stdout.close() self.proc.stdout.close()
self.proc = None self.proc = None
def _connect(self): def _connect(self):
if self.proc: if self.proc:
return self.proc return self.proc
args = [ args = [
'watchman', self.watchman_exe,
'--sockname={0}'.format(self.sockpath), '--sockname={0}'.format(self.sockpath),
'--logfile=/BOGUS', '--logfile=/BOGUS',
'--statefile=/BOGUS', '--statefile=/BOGUS',
'--no-spawn', '--no-spawn',
'--no-local', '--no-local',
'--no-pretty', '--no-pretty',
'-j', '-j',
] ]
sendConn = None sendConn = None
recvConn = None recvConn = None
subs = {} # Keyed by subscription name subs = {} # Keyed by subscription name
sub_by_root = {} # Keyed by root, then by subscription name sub_by_root = {} # Keyed by root, then by subscription name
logs = [] # When log level is raised logs = [] # When log level is raised
unilateral = ['log', 'subscription'] unilateral = ['log', 'subscription']
tport = None tport = None
useImmutableBser = None useImmutableBser = None
watchman_exe = None
def __init__(self, def __init__(self,
sockpath=None, sockpath=None,
timeout=1.0, timeout=1.0,
transport=None, transport=None,
sendEncoding=None, sendEncoding=None,
recvEncoding=None, recvEncoding=None,
useImmutableBser=False): useImmutableBser=False,
watchman_exe=None):
self.sockpath = sockpath self.sockpath = sockpath
self.timeout = timeout self.timeout = timeout
self.useImmutableBser = useImmutableBser self.useImmutableBser = useImmutableBser
self.watchman_exe = watchman_exe
if inspect.isclass(transport) and issubclass(transport, Transport): if inspect.isclass(transport) and issubclass(transport, Transport):
self.transport = transport self.transport = transport
else: else:
transport = transport or os.getenv('WATCHMAN_TRANSPORT') or 'local' transport = transport or os.getenv('WATCHMAN_TRANSPORT') or 'local'
if transport == 'local' and os.name == 'nt': if transport == 'local' and os.name == 'nt':
self.transport = WindowsNamedPipeTransport self.transport = WindowsNamedPipeTransport
elif transport == 'local': elif transport == 'local':
def _resolvesockname(self): def _resolvesockname(self):
# if invoked via a trigger, watchman will set this env var; we # if invoked via a trigger, watchman will set this env var; we
# should use it unless explicitly set otherwise # should use it unless explicitly set otherwise
path = os.getenv('WATCHMAN_SOCK') path = os.getenv('WATCHMAN_SOCK')
if path: if path:
return path return path
cmd = ['watchman', '--output-encoding=bser', 'get-sockname'] cmd = [self.watchman_exe, '--output-encoding=bser', 'get-sockname']
try: try:
args = dict(stdout=subprocess.PIPE, args = dict(stdout=subprocess.PIPE,
stderr=subprocess.PIPE, stderr=subprocess.PIPE,
close_fds=os.name != 'nt') close_fds=os.name != 'nt')
if os.name == 'nt': if os.name == 'nt':
# if invoked via an application with graphical user interface, # if invoked via an application with graphical user interface,
# this call will cause a brief command window pop-up. # this call will cause a brief command window pop-up.
""" establish transport connection """ """ establish transport connection """
if self.recvConn: if self.recvConn:
return return
if self.sockpath is None: if self.sockpath is None:
self.sockpath = self._resolvesockname() self.sockpath = self._resolvesockname()
self.tport = self.transport(self.sockpath, self.timeout) self.tport = self.transport(self.sockpath, self.timeout, self.watchman_exe)
self.sendConn = self.sendCodec(self.tport) self.sendConn = self.sendCodec(self.tport)
self.recvConn = self.recvCodec(self.tport) self.recvConn = self.recvCodec(self.tport)
def __del__(self): def __del__(self):
self.close() self.close()
def close(self): def close(self):
if self.tport: if self.tport:

hgext/fsmonitor/watchmanclient.py

# couldn't figure out our user # couldn't figure out our user
return None return None
def _command(self, *args): def _command(self, *args):
watchmanargs = (args[0], self._root) + args[1:] watchmanargs = (args[0], self._root) + args[1:]
try: try:
if self._watchmanclient is None: if self._watchmanclient is None:
self._firsttime = False self._firsttime = False
watchman_exe = self._ui.configpath('fsmonitor', 'watchman_exe')
self._watchmanclient = pywatchman.client( self._watchmanclient = pywatchman.client(
timeout=self._timeout, timeout=self._timeout,
useImmutableBser=True) useImmutableBser=True,
watchman_exe=watchman_exe)
return self._watchmanclient.query(*watchmanargs) return self._watchmanclient.query(*watchmanargs)
except pywatchman.CommandError as ex: except pywatchman.CommandError as ex:
if 'unable to resolve root' in ex.msg: if 'unable to resolve root' in ex.msg:
raise WatchmanNoRoot(self._root, ex.msg) raise WatchmanNoRoot(self._root, ex.msg)
raise Unavailable(ex.msg) raise Unavailable(ex.msg)
except pywatchman.WatchmanError as ex: except pywatchman.WatchmanError as ex:
raise Unavailable(str(ex)) raise Unavailable(str(ex))