annotate mercurial/py3kcompat.py @ 29917:f32f8bf5dc4c

streamclone: force @filecache properties to be reloaded from file

Before this patch, consumev1() invokes repo.invalidate() after closing
transaction, to force @filecache properties to be reloaded from files
at next access, because streamclone writes data into files directly.

But this doesn't work as expected in the case below:

  1. at closing transaction, repo._refreshfilecachestats() refreshes
     file stat of each @filecache properties with streamclone-ed files

     This means that in-memory properties are treated as valid.

  2. but streamclone doesn't changes in-memory properties

     This means that in-memory properties are actually invalid.

  3. repo.invalidate() just forces to examine file stat of @filecache
     properties at the first access after it

     Such examination should concludes that reloading from file isn't
     needed, because file stat was already refreshed at (1).

     Therefore, invalid in-memory cached properties (2) are
     unintentionally treated as valid (1).

This patch invokes repo.invalidate() with clearfilecache=True, to
force @filecache properties to be reloaded from file at next access.

BTW, it is accidental that repo.invalidate() without
clearfilecache=True in streamclone case seems to work as expected
before this patch.

If transaction is started via "filtered repo" object,
repo._refreshfilecachestats() tries to refresh file stat of each
@filecache properties on "filtered repo" object, even though all of
them are stored into "unfiltered repo" object.

In this case, repo._refreshfilecachestats() does nothing
unintentionally, but this unexpected behavior causes reloading
@filecache properties after repo.invalidate().

This is reason why this patch should be applied before making
_refreshfilecachestats() correctly refresh file stat of @filecache
properties.

# py3kcompat.py - compatibility definitions for running hg in py3k
#
# Copyright 2010 Renato Cunha <[e-mail]>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import builtins
import numbers

Number = numbers.Number

def bytesformatter(format, args):
    '''Custom implementation of a formatter for bytestrings.

    This function currently relies on the string formatter to do the
    formatting and always returns bytes objects.

    >>> bytesformatter(20, 10)
    0
    >>> bytesformatter('unicode %s, %s!', ('string', 'foo'))
    b'unicode string, foo!'
    >>> bytesformatter(b'test %s', 'me')
    b'test me'
    >>> bytesformatter('test %s', 'me')
    b'test me'
    >>> bytesformatter(b'test %s', b'me')
    b'test me'
    >>> bytesformatter('test %s', b'me')
    b'test me'
    >>> bytesformatter('test %d: %s', (1, b'result'))
    b'test 1: result'
    '''
    # The current implementation just converts from bytes to unicode, do
    # what's needed and then convert the results back to bytes.
    # Another alternative is to use the Python C API implementation.
    if isinstance(format, Number):
        # If the fixer erroneously passes a number remainder operation to
        # bytesformatter, we just return the correct operation
        return format % args
    if isinstance(format, bytes):
        format = format.decode('utf-8', 'surrogateescape')
    if isinstance(args, bytes):
        args = args.decode('utf-8', 'surrogateescape')
    if isinstance(args, tuple):
        newargs = []
        for arg in args:
            if isinstance(arg, bytes):
                arg = arg.decode('utf-8', 'surrogateescape')
            newargs.append(arg)
        args = tuple(newargs)
    ret = format % args
    return ret.encode('utf-8', 'surrogateescape')
builtins.bytesformatter = bytesformatter

origord = builtins.ord
def fakeord(char):
    if isinstance(char, int):
        return char
    return origord(char)
builtins.ord = fakeord

if __name__ == '__main__':
    import doctest
    doctest.testmod()