view mercurial/interfaces/util.py @ 45095:8e04607023e5

procutil: ensure that procutil.std{out,err}.write() writes all bytes

Python 3 offers different kind of streams and it’s not guaranteed for all of
them that calling write() writes all bytes.

When Python is started in unbuffered mode, sys.std{out,err}.buffer are
instances of io.FileIO, whose write() can write less bytes for
platform-specific reasons (e.g. Linux has a 0x7ffff000 bytes maximum and could
write less if interrupted by a signal; when writing to Windows consoles, it’s
limited to 32767 bytes to avoid the "not enough space" error). This can lead to
silent loss of data, both when using sys.std{out,err}.buffer (which may in fact
not be a buffered stream) and when using the text streams sys.std{out,err}
(I’ve created a CPython bug report for that:
https://bugs.python.org/issue41221).

Python may fix the problem at some point. For now, we implement our own wrapper
for procutil.std{out,err} that calls the raw stream’s write() method until all
bytes have been written. We don’t use sys.std{out,err} for larger writes, so I
think it’s not worth the effort to patch them.

# util.py - Utilities for declaring interfaces.
#
# Copyright 2018 Gregory Szorc <[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.

# zope.interface imposes a run-time cost due to module import overhead and
# bookkeeping for declaring interfaces. So, we use stubs for various
# zope.interface primitives unless instructed otherwise.

from __future__ import absolute_import

from .. import encoding

if encoding.environ.get(b'HGREALINTERFACES'):
    from ..thirdparty.zope import interface as zi

    Attribute = zi.Attribute
    Interface = zi.Interface
    implementer = zi.implementer
else:

    class Attribute(object):
        def __init__(self, __name__, __doc__=b''):
            pass

    class Interface(object):
        def __init__(
            self, name, bases=(), attrs=None, __doc__=None, __module__=None
        ):
            pass

    def implementer(*ifaces):
        def wrapper(cls):
            return cls

        return wrapper