( )⚙ D4878 url: Allow to configure timeout on http connection

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4878

url: Allow to configure timeout on http connection
ClosedPublic

Authored by ced on Oct 4 2018, 5:36 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG6509fcec830c: url: allow to configure timeout on http connection
rHGe4a73d589006: url: Allow to configure timeout on http connection
Summary

By default, httplib.HTTPConnection opens connection with no timeout.
If the server is hanging, Mercurial will wait indefinitely. This may be an
issue for automated scripts.

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

ced created this revision.Oct 4 2018, 5:36 AM
Closed by commit rHGe4a73d589006: url: Allow to configure timeout on http connection (authored by ced). · Explain WhyOct 4 2018, 11:46 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/configitems.py (5 lines)
Mmercurial/help/config.txt (10 lines)
Mmercurial/keepalive.py (5 lines)
Mmercurial/url.py (15 lines)

Diff 11677

mercurial/configitems.py

default=list, default=list,
) )
coreconfigitem('http_proxy', 'passwd', coreconfigitem('http_proxy', 'passwd',
default=None, default=None,
) )
coreconfigitem('http_proxy', 'user', coreconfigitem('http_proxy', 'user',
default=None, default=None,
) )
coreconfigitem('http', 'timeout',
default=None,
)
coreconfigitem('logtoprocess', 'commandexception', coreconfigitem('logtoprocess', 'commandexception',
default=None, default=None,
) )
coreconfigitem('logtoprocess', 'commandfinish', coreconfigitem('logtoprocess', 'commandfinish',
default=None, default=None,
) )
coreconfigitem('logtoprocess', 'command', coreconfigitem('logtoprocess', 'command',
default=None, default=None,

mercurial/help/config.txt

``user`` ``user``
Optional. User name to authenticate with at the proxy server. Optional. User name to authenticate with at the proxy server.
``always`` ``always``
Optional. Always use the proxy, even for localhost and any entries Optional. Always use the proxy, even for localhost and any entries
in ``http_proxy.no``. (default: False) in ``http_proxy.no``. (default: False)
``http``
----------
Used to configure access to Mercurial repositories via HTTP.
``timeout``
If set, blocking operations will timeout after that many seconds.
(default: None)
``merge`` ``merge``
--------- ---------
This section specifies behavior during merges and updates. This section specifies behavior during merges and updates.
``checkignored`` ``checkignored``
Controls behavior when an ignored file on disk has the same name as a tracked Controls behavior when an ignored file on disk has the same name as a tracked
file in the changeset being merged or updated to, and has different file in the changeset being merged or updated to, and has different

mercurial/keepalive.py

def get_all(self, host=None): def get_all(self, host=None):
if host: if host:
return list(self._hostmap.get(host, [])) return list(self._hostmap.get(host, []))
else: else:
return dict(self._hostmap) return dict(self._hostmap)
class KeepAliveHandler(object): class KeepAliveHandler(object):
def __init__(self): def __init__(self, timeout=None):
self._cm = ConnectionManager() self._cm = ConnectionManager()
self._timeout = timeout
self.requestscount = 0 self.requestscount = 0
self.sentbytescount = 0 self.sentbytescount = 0
#### Connection Management #### Connection Management
def open_connections(self): def open_connections(self):
"""return a list of connected hosts and the number of connections """return a list of connected hosts and the number of connections
to each. [('foo.com:80', 2), ('bar.org', 1)]""" to each. [('foo.com:80', 2), ('bar.org', 1)]"""
return [(host, len(li)) for (host, li) in self._cm.get_all().items()] return [(host, len(li)) for (host, li) in self._cm.get_all().items()]
# connection is bad - possibly closed by server # connection is bad - possibly closed by server
# discard it and ask for the next free connection # discard it and ask for the next free connection
h.close() h.close()
self._cm.remove(h) self._cm.remove(h)
h = self._cm.get_ready_conn(host) h = self._cm.get_ready_conn(host)
else: else:
# no (working) free connections were found. Create a new one. # no (working) free connections were found. Create a new one.
h = http_class(host) h = http_class(host, timeout=self._timeout)
if DEBUG: if DEBUG:
DEBUG.info("creating new connection to %s (%d)", DEBUG.info("creating new connection to %s (%d)",
host, id(h)) host, id(h))
self._cm.add(host, h, 0) self._cm.add(host, h, 0)
self._start_transaction(h, req) self._start_transaction(h, req)
r = h.getresponse() r = h.getresponse()
# The string form of BadStatusLine is the status line. Add some context # The string form of BadStatusLine is the status line. Add some context
# to make the error message slightly more useful. # to make the error message slightly more useful.

mercurial/url.py

self.sock = self._create_connection((self.host, self.port), self.sock = self._create_connection((self.host, self.port),
self.timeout, self.timeout,
self.source_address) self.source_address)
if self._tunnel_host: if self._tunnel_host:
self._tunnel() self._tunnel()
class logginghttphandler(httphandler): class logginghttphandler(httphandler):
"""HTTP handler that logs socket I/O.""" """HTTP handler that logs socket I/O."""
def __init__(self, logfh, name, observeropts): def __init__(self, logfh, name, observeropts, timeout=None):
super(logginghttphandler, self).__init__() super(logginghttphandler, self).__init__(timeout=timeout)
self._logfh = logfh self._logfh = logfh
self._logname = name self._logname = name
self._observeropts = observeropts self._observeropts = observeropts
# do_open() calls the passed class to instantiate an HTTPConnection. We # do_open() calls the passed class to instantiate an HTTPConnection. We
# pass in a callable method that creates a custom HTTPConnection instance # pass in a callable method that creates a custom HTTPConnection instance
# whose callback to create the socket knows how to proxy the socket. # whose callback to create the socket knows how to proxy the socket.
_generic_proxytunnel(self) _generic_proxytunnel(self)
host = self.realhostport.rsplit(':', 1)[0] host = self.realhostport.rsplit(':', 1)[0]
self.sock = sslutil.wrapsocket( self.sock = sslutil.wrapsocket(
self.sock, self.key_file, self.cert_file, ui=self.ui, self.sock, self.key_file, self.cert_file, ui=self.ui,
serverhostname=host) serverhostname=host)
sslutil.validatesocket(self.sock) sslutil.validatesocket(self.sock)
class httpshandler(keepalive.KeepAliveHandler, urlreq.httpshandler): class httpshandler(keepalive.KeepAliveHandler, urlreq.httpshandler):
def __init__(self, ui): def __init__(self, ui, timeout=None):
keepalive.KeepAliveHandler.__init__(self) keepalive.KeepAliveHandler.__init__(self, timeout=timeout)
urlreq.httpshandler.__init__(self) urlreq.httpshandler.__init__(self)
self.ui = ui self.ui = ui
self.pwmgr = passwordmgr(self.ui, self.pwmgr = passwordmgr(self.ui,
self.ui.httppasswordmgrdb) self.ui.httppasswordmgrdb)
def _start_transaction(self, h, req): def _start_transaction(self, h, req):
_generic_start_transaction(self, h, req) _generic_start_transaction(self, h, req)
return keepalive.KeepAliveHandler._start_transaction(self, h, req) return keepalive.KeepAliveHandler._start_transaction(self, h, req)
``loggingfh`` denotes a file object to log events to. ``loggingfh`` denotes a file object to log events to.
``loggingname`` denotes the name of the to print when logging. ``loggingname`` denotes the name of the to print when logging.
``loggingopts`` is a dict of keyword arguments to pass to the constructed ``loggingopts`` is a dict of keyword arguments to pass to the constructed
``util.socketobserver`` instance. ``util.socketobserver`` instance.
``sendaccept`` allows controlling whether the ``Accept`` request header ``sendaccept`` allows controlling whether the ``Accept`` request header
is sent. The header is sent by default. is sent. The header is sent by default.
''' '''
timeout = ui.configwith(float, 'http', 'timeout')
handlers = [] handlers = []
if loggingfh: if loggingfh:
handlers.append(logginghttphandler(loggingfh, loggingname, handlers.append(logginghttphandler(loggingfh, loggingname,
loggingopts or {})) loggingopts or {}, timeout=timeout))
# We don't yet support HTTPS when logging I/O. If we attempt to open # We don't yet support HTTPS when logging I/O. If we attempt to open
# an HTTPS URL, we'll likely fail due to unknown protocol. # an HTTPS URL, we'll likely fail due to unknown protocol.
else: else:
handlers.append(httphandler()) handlers.append(httphandler(timeout=timeout))
if has_https: if has_https:
handlers.append(httpshandler(ui)) handlers.append(httpshandler(ui, timeout=timeout))
handlers.append(proxyhandler(ui)) handlers.append(proxyhandler(ui))
passmgr = passwordmgr(ui, ui.httppasswordmgrdb) passmgr = passwordmgr(ui, ui.httppasswordmgrdb)
if authinfo is not None: if authinfo is not None:
realm, uris, user, passwd = authinfo realm, uris, user, passwd = authinfo
saveduser, savedpass = passmgr.find_stored_password(uris[0]) saveduser, savedpass = passmgr.find_stored_password(uris[0])
if user != saveduser or passwd: if user != saveduser or passwd: