( )⚙ D3069 peer: make ui an attribute

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3069

peer: make ui an attribute
ClosedPublic

Authored by indygreg on Apr 3 2018, 10:00 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGe826fe7a08c7: peer: make ui an attribute
Summary

With abc interfaces, instance attributes could not satisfy
@abc.abstractproperty requirements because interface conformance
was tested at type creation time. When we created the abc
peer interfaces, we had to make "ui" a @property to satisfy
abc.

Now that peer interfaces are using zope.interface and there is no
import time validation (but there are tests validating instances
conform to the interface), we can go back to using regular object
attributes.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Apr 3 2018, 10:00 PM
Closed by commit rHGe826fe7a08c7: peer: make ui an attribute (authored by indygreg). · Explain WhyApr 4 2018, 9:39 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7612

mercurial/httppeer.py

'_multifile only supports seeking to start, but that ' '_multifile only supports seeking to start, but that '
'could be fixed if you need it') 'could be fixed if you need it')
for f in self._fileobjs: for f in self._fileobjs:
f.seek(0) f.seek(0)
self._index = 0 self._index = 0
class httppeer(wireproto.wirepeer): class httppeer(wireproto.wirepeer):
def __init__(self, ui, path, url, opener): def __init__(self, ui, path, url, opener):
self._ui = ui self.ui = ui
self._path = path self._path = path
self._url = url self._url = url
self._caps = None self._caps = None
self._urlopener = opener self._urlopener = opener
# This is an its own attribute to facilitate extensions overriding # This is an its own attribute to facilitate extensions overriding
# the default type. # the default type.
self._requestbuilder = urlreq.request self._requestbuilder = urlreq.request
def __del__(self): def __del__(self):
for h in self._urlopener.handlers: for h in self._urlopener.handlers:
h.close() h.close()
getattr(h, "close_all", lambda: None)() getattr(h, "close_all", lambda: None)()
def _openurl(self, req): def _openurl(self, req):
if (self._ui.debugflag if (self.ui.debugflag
and self._ui.configbool('devel', 'debug.peer-request')): and self.ui.configbool('devel', 'debug.peer-request')):
dbg = self._ui.debug dbg = self.ui.debug
line = 'devel-peer-request: %s\n' line = 'devel-peer-request: %s\n'
dbg(line % '%s %s' % (req.get_method(), req.get_full_url())) dbg(line % '%s %s' % (req.get_method(), req.get_full_url()))
hgargssize = None hgargssize = None
for header, value in sorted(req.header_items()): for header, value in sorted(req.header_items()):
if header.startswith('X-hgarg-'): if header.startswith('X-hgarg-'):
if hgargssize is None: if hgargssize is None:
hgargssize = 0 hgargssize = 0
length = getattr(data, 'length', None) length = getattr(data, 'length', None)
if length is None: if length is None:
length = len(data) length = len(data)
dbg(line % ' %d bytes of data' % length) dbg(line % ' %d bytes of data' % length)
start = util.timer() start = util.timer()
ret = self._urlopener.open(req) ret = self._urlopener.open(req)
if self._ui.configbool('devel', 'debug.peer-request'): if self.ui.configbool('devel', 'debug.peer-request'):
dbg(line % ' finished in %.4f seconds (%s)' dbg(line % ' finished in %.4f seconds (%s)'
% (util.timer() - start, ret.code)) % (util.timer() - start, ret.code))
return ret return ret
# Begin of ipeerconnection interface. # Begin of ipeerconnection interface.
@util.propertycache
def ui(self):
return self._ui
def url(self): def url(self):
return self._path return self._path
def local(self): def local(self):
return None return None
def peer(self): def peer(self):
return self return self

mercurial/localrepo.py

'''peer for a local repo; reflects only the most recent API''' '''peer for a local repo; reflects only the most recent API'''
def __init__(self, repo, caps=None): def __init__(self, repo, caps=None):
super(localpeer, self).__init__() super(localpeer, self).__init__()
if caps is None: if caps is None:
caps = moderncaps.copy() caps = moderncaps.copy()
self._repo = repo.filtered('served') self._repo = repo.filtered('served')
self._ui = repo.ui self.ui = repo.ui
self._caps = repo._restrictcapabilities(caps) self._caps = repo._restrictcapabilities(caps)
# Begin of _basepeer interface. # Begin of _basepeer interface.
@util.propertycache
def ui(self):
return self._ui
def url(self): def url(self):
return self._repo.url() return self._repo.url()
def local(self): def local(self):
return self._repo return self._repo
def peer(self): def peer(self):
return self return self

mercurial/sshpeer.py

``proc`` is a handle on the underlying SSH process. ``proc`` is a handle on the underlying SSH process.
``stdin``, ``stdout``, and ``stderr`` are handles on the stdio ``stdin``, ``stdout``, and ``stderr`` are handles on the stdio
pipes for that process. pipes for that process.
``caps`` is a set of capabilities supported by the remote. ``caps`` is a set of capabilities supported by the remote.
``autoreadstderr`` denotes whether to automatically read from ``autoreadstderr`` denotes whether to automatically read from
stderr and to forward its output. stderr and to forward its output.
""" """
self._url = url self._url = url
self._ui = ui self.ui = ui
# self._subprocess is unused. Keeping a handle on the process # self._subprocess is unused. Keeping a handle on the process
# holds a reference and prevents it from being garbage collected. # holds a reference and prevents it from being garbage collected.
self._subprocess = proc self._subprocess = proc
# And we hook up our "doublepipe" wrapper to allow querying # And we hook up our "doublepipe" wrapper to allow querying
# stderr any time we perform I/O. # stderr any time we perform I/O.
if autoreadstderr: if autoreadstderr:
stdout = doublepipe(ui, util.bufferedinputpipe(stdout), stderr) stdout = doublepipe(ui, util.bufferedinputpipe(stdout), stderr)
stdin = doublepipe(ui, stdin, stderr) stdin = doublepipe(ui, stdin, stderr)
self._pipeo = stdin self._pipeo = stdin
self._pipei = stdout self._pipei = stdout
self._pipee = stderr self._pipee = stderr
self._caps = caps self._caps = caps
self._autoreadstderr = autoreadstderr self._autoreadstderr = autoreadstderr
# Commands that have a "framed" response where the first line of the # Commands that have a "framed" response where the first line of the
# response contains the length of that response. # response contains the length of that response.
_FRAMED_COMMANDS = { _FRAMED_COMMANDS = {
'batch', 'batch',
} }
# Begin of ipeerconnection interface. # Begin of ipeerconnection interface.
@util.propertycache
def ui(self):
return self._ui
def url(self): def url(self):
return self._url return self._url
def local(self): def local(self):
return None return None
def peer(self): def peer(self):
return self return self

tests/test-wireproto.py

wireprototypes.TRANSPORTS['dummyproto'] = { wireprototypes.TRANSPORTS['dummyproto'] = {
'transport': 'dummy', 'transport': 'dummy',
'version': 1, 'version': 1,
} }
class clientpeer(wireproto.wirepeer): class clientpeer(wireproto.wirepeer):
def __init__(self, serverrepo, ui): def __init__(self, serverrepo, ui):
self.serverrepo = serverrepo self.serverrepo = serverrepo
self._ui = ui self.ui = ui
@property
def ui(self):
return self._ui
def url(self): def url(self):
return b'test' return b'test'
def local(self): def local(self):
return None return None
def peer(self): def peer(self):