This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3237

httppeer: perform capabilities request in makepeer()
ClosedPublic

Authored by indygreg on Apr 10 2018, 9:28 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG8b8a845c85fc: httppeer: perform capabilities request in makepeer()
Summary

Previously, we constructed an httppeer then always ran _fetchcaps()
to issue the capabilities command.

We want to issue the capabilities command before constructing a
peer instance so we can construct an appropriate peer instance
depending on the capabilities result.

With the code for making and sending requests moved out of httppeer,
it is now possible to send command requests without an httppeer.

This commit creates a new function for making the capabilities
request and calls it as part of makepeer().

This code should be functionality equivalent to what existed before.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Apr 10 2018, 9:28 PM
durin42 accepted this revision.Apr 11 2018, 12:49 PM
This revision is now accepted and ready to land.Apr 11 2018, 12:49 PM
Closed by commit rHG8b8a845c85fc: httppeer: perform capabilities request in makepeer() (authored by indygreg). · Explain WhyApr 11 2018, 1:01 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7998

mercurial/debugcommands.py

peer = httppeer.httpv2peer(ui, path, opener) peer = httppeer.httpv2peer(ui, path, opener)
elif opts['peer'] == 'raw': elif opts['peer'] == 'raw':
ui.write(_('using raw connection to peer\n')) ui.write(_('using raw connection to peer\n'))
peer = None peer = None
elif opts['peer']: elif opts['peer']:
raise error.Abort(_('--peer %s not supported with HTTP peers') % raise error.Abort(_('--peer %s not supported with HTTP peers') %
opts['peer']) opts['peer'])
else: else:
url, caps = httppeer.performhandshake(ui, url, opener,
httppeer.urlreq.request)
peer = httppeer.httppeer(ui, path, url, opener, peer = httppeer.httppeer(ui, path, url, opener,
requestbuilder=httppeer.urlreq.request) httppeer.urlreq.request,
peer._fetchcaps() caps)
# We /could/ populate stdin/stdout with sock.makefile()... # We /could/ populate stdin/stdout with sock.makefile()...
else: else:
raise error.Abort(_('unsupported connection configuration')) raise error.Abort(_('unsupported connection configuration'))
batchedcommands = None batchedcommands = None
# Now perform actions based on the parsed wire language instructions. # Now perform actions based on the parsed wire language instructions.

mercurial/httppeer.py

(safeurl, version)) (safeurl, version))
if compressible: if compressible:
resp = util.compengines['zlib'].decompressorreader(resp) resp = util.compengines['zlib'].decompressorreader(resp)
return respurl, resp return respurl, resp
class httppeer(wireproto.wirepeer): class httppeer(wireproto.wirepeer):
def __init__(self, ui, path, url, opener, requestbuilder): def __init__(self, ui, path, url, opener, requestbuilder, caps):
self.ui = ui self.ui = ui
self._path = path self._path = path
self._url = url self._url = url
self._caps = None self._caps = caps
self._urlopener = opener self._urlopener = opener
self._requestbuilder = requestbuilder self._requestbuilder = requestbuilder
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 close(self): def close(self):
pass pass
# End of ipeerconnection interface. # End of ipeerconnection interface.
# Begin of ipeercommands interface. # Begin of ipeercommands interface.
def capabilities(self): def capabilities(self):
# self._fetchcaps() should have been called as part of peer
# handshake. So self._caps should always be set.
assert self._caps is not None
return self._caps return self._caps
# End of ipeercommands interface. # End of ipeercommands interface.
# look up capabilities only when needed # look up capabilities only when needed
def _fetchcaps(self):
self._caps = set(self._call('capabilities').split())
def _callstream(self, cmd, _compressible=False, **args): def _callstream(self, cmd, _compressible=False, **args):
args = pycompat.byteskwargs(args) args = pycompat.byteskwargs(args)
req, cu, qs = makev1commandrequest(self.ui, self._requestbuilder, req, cu, qs = makev1commandrequest(self.ui, self._requestbuilder,
self._caps, self.capable, self._caps, self.capable,
self._url, cmd, args) self._url, cmd, args)
resp = sendrequest(self.ui, self._urlopener, req) resp = sendrequest(self.ui, self._urlopener, req)
results.append(decoder.decode()) results.append(decoder.decode())
else: else:
results.append(meta['data']) results.append(meta['data'])
else: else:
error.ProgrammingError('unhandled action: %s' % action) error.ProgrammingError('unhandled action: %s' % action)
return results return results
def performhandshake(ui, url, opener, requestbuilder):
# The handshake is a request to the capabilities command.
caps = None
def capable(x):
raise error.ProgrammingError('should not be called')
req, requrl, qs = makev1commandrequest(ui, requestbuilder, caps,
capable, url, 'capabilities',
{})
resp = sendrequest(ui, opener, req)
respurl, resp = parsev1commandresponse(ui, url, requrl, qs, resp,
compressible=False)
try:
rawcaps = resp.read()
finally:
resp.close()
return respurl, set(rawcaps.split())
def makepeer(ui, path, requestbuilder=urlreq.request): def makepeer(ui, path, requestbuilder=urlreq.request):
"""Construct an appropriate HTTP peer instance. """Construct an appropriate HTTP peer instance.
``requestbuilder`` is the type used for constructing HTTP requests. ``requestbuilder`` is the type used for constructing HTTP requests.
It exists as an argument so extensions can override the default. It exists as an argument so extensions can override the default.
""" """
u = util.url(path) u = util.url(path)
if u.query or u.fragment: if u.query or u.fragment:
raise error.Abort(_('unsupported URL component: "%s"') % raise error.Abort(_('unsupported URL component: "%s"') %
(u.query or u.fragment)) (u.query or u.fragment))
# urllib cannot handle URLs with embedded user or passwd. # urllib cannot handle URLs with embedded user or passwd.
url, authinfo = u.authinfo() url, authinfo = u.authinfo()
ui.debug('using %s\n' % url) ui.debug('using %s\n' % url)
opener = urlmod.opener(ui, authinfo) opener = urlmod.opener(ui, authinfo)
return httppeer(ui, path, url, opener, requestbuilder) respurl, caps = performhandshake(ui, url, opener, requestbuilder)
return httppeer(ui, path, respurl, opener, requestbuilder, caps)
def instance(ui, path, create): def instance(ui, path, create):
if create: if create:
raise error.Abort(_('cannot create new http repository')) raise error.Abort(_('cannot create new http repository'))
try: try:
if path.startswith('https:') and not urlmod.has_https: if path.startswith('https:') and not urlmod.has_https:
raise error.Abort(_('Python support for SSL and HTTPS ' raise error.Abort(_('Python support for SSL and HTTPS '
'is not installed')) 'is not installed'))
inst = makepeer(ui, path) inst = makepeer(ui, path)
inst._fetchcaps()
return inst return inst
except error.RepoError as httpexception: except error.RepoError as httpexception:
try: try:
r = statichttprepo.instance(ui, "static-" + path, create) r = statichttprepo.instance(ui, "static-" + path, create)
ui.note(_('(falling back to static-http)\n')) ui.note(_('(falling back to static-http)\n'))
return r return r
except error.RepoError: except error.RepoError:
raise httpexception # use the original http RepoError instead raise httpexception # use the original http RepoError instead

tests/test-check-interfaces.py

def filtered(self, name): def filtered(self, name):
pass pass
def _restrictcapabilities(self, caps): def _restrictcapabilities(self, caps):
pass pass
class dummyopener(object): class dummyopener(object):
handlers = [] handlers = []
# Facilitates testing sshpeer without requiring an SSH server. # Facilitates testing sshpeer without requiring a server.
class badpeer(httppeer.httppeer): class badpeer(httppeer.httppeer):
def __init__(self): def __init__(self):
super(badpeer, self).__init__(None, None, None, dummyopener(), None) super(badpeer, self).__init__(None, None, None, dummyopener(), None,
None)
self.badattribute = True self.badattribute = True
def badmethod(self): def badmethod(self):
pass pass
class dummypipe(object): class dummypipe(object):
def close(self): def close(self):
pass pass
def main(): def main():
ui = uimod.ui() ui = uimod.ui()
# Needed so we can open a local repo with obsstore without a warning. # Needed so we can open a local repo with obsstore without a warning.
ui.setconfig('experimental', 'evolution.createmarkers', True) ui.setconfig('experimental', 'evolution.createmarkers', True)
checkzobject(badpeer()) checkzobject(badpeer())
ziverify.verifyClass(repository.ipeerbaselegacycommands, ziverify.verifyClass(repository.ipeerbaselegacycommands,
httppeer.httppeer) httppeer.httppeer)
checkzobject(httppeer.httppeer(None, None, None, dummyopener(), None)) checkzobject(httppeer.httppeer(None, None, None, dummyopener(), None, None))
ziverify.verifyClass(repository.ipeerbase, ziverify.verifyClass(repository.ipeerbase,
localrepo.localpeer) localrepo.localpeer)
checkzobject(localrepo.localpeer(dummyrepo())) checkzobject(localrepo.localpeer(dummyrepo()))
ziverify.verifyClass(repository.ipeerbaselegacycommands, ziverify.verifyClass(repository.ipeerbaselegacycommands,
sshpeer.sshv1peer) sshpeer.sshv1peer)
checkzobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(), checkzobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(),