mercurial-crew-with-dirclash: comparison mercurial/keepalive.py

equal deleted inserted replaced

-:e4b5e48052c6
+:c4325f0a9b91
 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #   Lesser General Public License for more details.
 #
 #   You should have received a copy of the GNU Lesser General Public
 #   License along with this library; if not, write to the
 #      Free Software Foundation, Inc.,
 #      59 Temple Place, Suite 330,
 #      Boston, MA  02111-1307  USA
 # This file is part of urlgrabber, a high-level cross-protocol url-grabber
 # Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko
 >>> import urllib2
 >>> from keepalive import HTTPHandler
 >>> keepalive_handler = HTTPHandler()
 >>> opener = urllib2.build_opener(keepalive_handler)
 >>> urllib2.install_opener(opener)
 >>>
 >>> fo = urllib2.urlopen('http://www.python.org')
 If a connection to a given host is requested, and all of the existing
 connections are still in use, another connection will be opened.  If
 the handler tries to use an existing connection but it fails in some
 DEBUG = None
 import sys
 if sys.version_info < (2, 4): HANDLE_ERRORS = 1
 else: HANDLE_ERRORS = 0
 class ConnectionManager:
 """
 The connection manager must be able to:
 * keep track of all existing
 """
 self._lock.release()
 def set_ready(self, connection, ready):
 try: self._readymap[connection] = ready
 except KeyError: pass
 def get_ready_conn(self, host):
 conn = None
 self._lock.acquire()
 try:
 if self._hostmap.has_key(host):
 return dict(self._hostmap)
 class HTTPHandler(urllib2.HTTPHandler):
 def __init__(self):
 self._cm = ConnectionManager()
 #### Connection Management
 def open_connections(self):
 """return a list of connected hosts and the number of connections
 to each.  [('foo.com:80', 2), ('bar.org', 1)]"""
 return [(host, len(li)) for (host, li) in self._cm.get_all().items()]
 host is the host:port spec, as in 'www.cnn.com:8080' as passed in.
 no error occurs if there is no connection to that host."""
 for h in self._cm.get_all(host):
 self._cm.remove(h)
 h.close()
 def close_all(self):
 """close all open connections"""
 for host, conns in self._cm.get_all().items():
 for h in conns:
 self._cm.remove(h)
 h.close()
 def _request_closed(self, request, host, connection):
 """tells us that this request is now closed and the the
 connection is ready for another request"""
 self._cm.set_ready(connection, 1)
 def _remove_connection(self, host, connection, close=0):
 if close: connection.close()
 self._cm.remove(connection)
 #### Transaction Execution
 def http_open(self, req):
 return self.do_open(HTTPConnection, req)
 def do_open(self, http_class, req):
 self._cm.add(host, h, 0)
 self._start_transaction(h, req)
 r = h.getresponse()
 except (socket.error, httplib.HTTPException), err:
 raise urllib2.URLError(err)
 # if not a persistent connection, don't try to reuse it
 if r.will_close: self._cm.remove(h)
 if DEBUG: DEBUG.info("STATUS: %s, %s", r.status, r.reason)
 r._handler = self
 r._url = req.get_full_url()
 r._connection = h
 r.code = r.status
 r.headers = r.msg
 r.msg = r.reason
 if r.status == 200 or not HANDLE_ERRORS:
 return r
 else:
 return self.parent.error('http', req, r,
 r.status, r.msg, r.headers)
 if DEBUG: DEBUG.error("unexpected exception - closing " + \
 "connection to %s (%d)", host, id(h))
 self._cm.remove(h)
 h.close()
 raise
 if r is None or r.version == 9:
 # httplib falls back to assuming HTTP 0.9 if it gets a
 # bad header back.  This is most likely to happen if
 # the socket has been closed by the server since we
 # last used the connection.
 # the read method wraps the original to accomodate buffering,
 # although read() never adds to the buffer.
 # Both readline and readlines have been stolen with almost no
 # modification from socket.py
 def __init__(self, sock, debuglevel=0, strict=0, method=None):
 if method: # the httplib in python 2.3 uses the method arg
 httplib.HTTPResponse.__init__(self, sock, debuglevel, method)
 else: # 2.2 doesn't
 self._connection)
 def close_connection(self):
 self._handler._remove_connection(self._host, self._connection, close=1)
 self.close()
 def info(self):
 return self.headers
 def geturl(self):
 return self._url
 class HTTPConnection(httplib.HTTPConnection):
 # use the modified response class
 response_class = HTTPResponse
 #########################################################################
 #####   TEST FUNCTIONS
 #########################################################################
 def error_handler(url):
 keepalive_handler.close_all()
 def continuity(url):
 import md5
 format = '%25s: %s'
 # first fetch the file with the normal http handler
 opener = urllib2.build_opener()
 urllib2.install_opener(opener)
 fo = urllib2.urlopen(url)
 foo = fo.read()
 opener = urllib2.build_opener(HTTPHandler())
 urllib2.install_opener(opener)
 t2 = fetch(N, url)
 print '  TIME: %.3f s' % t2
 print '  improvement factor: %.2f' % (t1/t2, )
 def fetch(N, url, delay=0):
 import time
 lens = []
 starttime = time.time()
 for i in range(N):
 DEBUG = FakeLogger()
 print "  fetching the file to establish a connection"
 fo = urllib2.urlopen(url)
 data1 = fo.read()
 fo.close()
 i = 20
 print "  waiting %i seconds for the server to close the connection" % i
 while i > 0:
 sys.stdout.write('\r  %2i' % i)
 sys.stdout.flush()
 else:
 print '  ERROR: DATA DIFFER'
 DEBUG = dbbackup
 def test(url, N=10):
 print "checking error hander (do this on a non-200)"
 try: error_handler(url)
 except IOError, e:
 print "exiting - exception will prevent further tests"
 print "performing speed comparison"
 comp(N, url)
 print
 print "performing dropped-connection check"
 test_timeout(url)
 if __name__ == '__main__':
 import time
 import sys
 try:
 N = int(sys.argv[1])

changeset 2600	c4325f0a9b91
parent 2444	5eb02f9ed804
child 4026	8520a773a141