hgext/logtoprocess.py

test: update test-sparse-revlog.t output

This test is skipped unless a large artefact is pre-build. It seems like nobody
ran it in a while. Changeset 3764330f76a6 changed the expected output but
nobody noticed.

This changeset focus on the first and simpler step: putting the expected output
back to what one would get by running this test.

However this test changes highlight a couple of deeper issues:

1) Even if the revision content did not changed, a change in the delta
contained in the bundle affected the delta stored in the final revlog, changing
the test result. Since we are testing the delta computation strategy with
sparse, we should not blindly reuse the delta-base from the bundled delta.

2) A change in the format of the repository used to generate the bundle changed
the delta stored in the bundle. We should get a more stable output to avoid
future instabilities of this test.

3) The test is it not run by CI or developer.

We'll try to address all this issues in the coming changesets.

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