##// END OF EJS Templates
largefiles: port wrapped functions to exthelper...
largefiles: port wrapped functions to exthelper Things get interesting in the commit. I hadn't seen issue6033 on Windows, and yet it is now reproducible 100% of the time on Windows 10 with this commit. I didn't test Linux. (For comparison, after seeing this issue, I tested on the parent with --loop, and it failed 5 times out of over 1300 tests.) The strange thing is that largefiles has nothing to do with that test (it's not even mentioned there). It isn't autoloading run amuck- it occurs even if largefiles is explicitly disabled, and also if the entry in afterhgrcload() is commented out. It's also not the import of lfutil- I disabled that by copying the function into lfs and removing the import, and the problem still occurs. Experimenting further, it seems that the problem is isolated to 3 entries: exchange.pushoperation, hg.clone, and cmdutil.revert. If those decorators are all commented out, the test passes when run in a loop for awhile. (Obviously, some largefiles tests will fail.) But if any one is commented back in, the test fails immediately. I left one method related to wrapping the wire protocol, because it seemed more natural with the TODO. Also, exthelper doesn't support wrapping functions from another extension, only commands in another extension. I didn't try to figure out why rebase is both command wrapped and function wrapped.

File last commit:

r40794:691c68bc default
r41092:0a7f582f default
Show More
logtoprocess.py
75 lines | 2.5 KiB | text/x-python | PythonLexer
# logtoprocess.py - send ui.log() data to a subprocess
#
# Copyright 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.
"""send ui.log() data to a subprocess (EXPERIMENTAL)
This extension lets you specify a shell command per ui.log() event,
sending all remaining arguments to as environment variables to that command.
Positional arguments construct a log message, which is passed in the `MSG1`
environment variables. Each keyword argument is set as a `OPT_UPPERCASE_KEY`
variable (so the key is uppercased, and prefixed with `OPT_`). The original
event name is passed in the `EVENT` environment variable, and the process ID
of mercurial is given in `HGPID`.
So given a call `ui.log('foo', 'bar %s\n', 'baz', spam='eggs'), a script
configured for the `foo` event can expect an environment with `MSG1=bar baz`,
and `OPT_SPAM=eggs`.
Scripts are configured in the `[logtoprocess]` section, each key an event name.
For example::
[logtoprocess]
commandexception = echo "$MSG1" > /var/log/mercurial_exceptions.log
would log the warning message and traceback of any failed command dispatch.
Scripts are run asynchronously as detached daemon processes; mercurial will
not ensure that they exit cleanly.
"""
from __future__ import absolute_import
import os
from mercurial.utils import (
procutil,
)
# 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 = 'ships-with-hg-core'
class processlogger(object):
"""Map log events to external commands
Arguments are passed on as environment variables.
"""
def __init__(self, ui):
self._scripts = dict(ui.configitems(b'logtoprocess'))
def tracked(self, event):
return bool(self._scripts.get(event))
def log(self, ui, event, msg, opts):
script = self._scripts[event]
env = {
b'EVENT': event,
b'HGPID': os.getpid(),
b'MSG1': msg,
}
# keyword arguments get prefixed with OPT_ and uppercased
env.update((b'OPT_%s' % key.upper(), value)
for key, value in opts.items())
fullenv = procutil.shellenviron(env)
procutil.runbgcommand(script, fullenv, shell=True)
def uipopulate(ui):
ui.setlogger(b'logtoprocess', processlogger(ui))