16
16
"""Implementation of Transport over http.
19
from bzrlib.transport import Transport, register_transport
20
from bzrlib.errors import (TransportNotPossible, NoSuchFile,
21
NonRelativePath, TransportError)
20
23
from cStringIO import StringIO
21
import urllib, urllib2
23
from warnings import warn
25
from bzrlib.transport import Transport, Server
26
from bzrlib.errors import (TransportNotPossible, NoSuchFile,
27
TransportError, ConnectionError)
28
27
from bzrlib.errors import BzrError, BzrCheckError
29
28
from bzrlib.branch import Branch
30
29
from bzrlib.trace import mutter
33
def extract_auth(url, password_manager):
35
Extract auth parameters from am HTTP/HTTPS url and add them to the given
36
password manager. Return the url, minus those auth parameters (which
39
assert url.startswith('http://') or url.startswith('https://')
40
scheme, host = url.split('//', 1)
42
host, path = host.split('/', 1)
48
auth, host = host.split('@', 1)
50
username, password = auth.split(':', 1)
52
username, password = auth, None
54
host, port = host.split(':', 1)
56
# FIXME: if password isn't given, should we ask for it?
57
if password is not None:
58
username = urllib.unquote(username)
59
password = urllib.unquote(password)
60
password_manager.add_password(None, host, username, password)
61
url = scheme + '//' + host + port + path
31
# velocitynet.com.au transparently proxies connections and thereby
32
# breaks keep-alive -- sucks!
66
37
mutter("get_url %s" % url)
67
manager = urllib2.HTTPPasswordMgrWithDefaultRealm()
68
url = extract_auth(url, manager)
69
auth_handler = urllib2.HTTPBasicAuthHandler(manager)
70
opener = urllib2.build_opener(auth_handler)
71
url_f = opener.open(url)
38
url_f = urllib2.urlopen(url)
41
class HttpTransportError(TransportError):
74
44
class HttpTransport(Transport):
75
45
"""This is the transport agent for http:// access.
109
77
"""Return the full url to the given relative path.
110
78
This can be supplied with a string or a list
112
assert isinstance(relpath, basestring)
113
80
if isinstance(relpath, basestring):
114
relpath_parts = relpath.split('/')
116
# TODO: Don't call this with an array - no magic interfaces
117
relpath_parts = relpath[:]
118
if len(relpath_parts) > 1:
119
if relpath_parts[0] == '':
120
raise ValueError("path %r within branch %r seems to be absolute"
121
% (relpath, self._path))
122
if relpath_parts[-1] == '':
123
raise ValueError("path %r within branch %r seems to be a directory"
124
% (relpath, self._path))
125
82
basepath = self._path.split('/')
126
83
if len(basepath) > 0 and basepath[-1] == '':
127
84
basepath = basepath[:-1]
128
for p in relpath_parts:
130
if len(basepath) == 0:
131
89
# In most filesystems, a request for the parent
132
90
# of root, just returns root.
135
elif p == '.' or p == '':
138
97
basepath.append(p)
139
99
# Possibly, we could use urlparse.urljoin() here, but
140
100
# I'm concerned about when it chooses to strip the last
141
101
# portion of the path, and when it doesn't.
154
121
cleaner if we just do an http HEAD request, and parse
159
path = self.abspath(relpath)
125
f = get_url(self.abspath(relpath))
161
126
# Without the read and then close()
162
127
# we tend to have busy sockets.
166
except urllib2.URLError, e:
167
mutter('url error code: %s for has url: %r', e.code, path)
133
except urllib2.URLError:
171
135
except IOError, e:
172
mutter('io error: %s %s for has url: %r',
173
e.errno, errno.errorcode.get(e.errno), path)
174
136
if e.errno == errno.ENOENT:
176
raise TransportError(orig_error=e)
138
raise HttpTransportError(orig_error=e)
178
140
def get(self, relpath, decode=False):
179
141
"""Get the file at the given relative path.
181
143
:param relpath: The relative path to the file
185
path = self.abspath(relpath)
187
except urllib2.HTTPError, e:
188
mutter('url error code: %s for has url: %r', e.code, path)
190
raise NoSuchFile(path, extra=e)
192
except (BzrError, IOError), e:
193
if hasattr(e, 'errno'):
194
mutter('io error: %s %s for has url: %r',
195
e.errno, errno.errorcode.get(e.errno), path)
196
if e.errno == errno.ENOENT:
197
raise NoSuchFile(path, extra=e)
198
raise ConnectionError(msg = "Error retrieving %s: %s"
146
return get_url(self.abspath(relpath))
147
except (BzrError, urllib2.URLError, IOError), e:
148
raise NoSuchFile(msg = "Error retrieving %s: %s"
199
149
% (self.abspath(relpath), str(e)),
202
def put(self, relpath, f, mode=None):
152
def get_partial(self, relpath, start, length=None):
153
"""Get just part of a file.
155
:param relpath: Path to the file, relative to base
156
:param start: The starting position to read from
157
:param length: The length to read. A length of None indicates
158
read to the end of the file.
159
:return: A file-like object containing at least the specified bytes.
160
Some implementations may return objects which can be read
161
past this length, but this is not guaranteed.
163
# TODO: You can make specialized http requests for just
164
# a portion of the file. Figure out how to do that.
165
# For now, urllib2 returns files that cannot seek() so
166
# we just read bytes off the beginning, until we
167
# get to the point that we care about.
168
f = self.get(relpath)
169
# TODO: read in smaller chunks, in case things are
170
# buffered internally.
174
def put(self, relpath, f):
203
175
"""Copy the file-like or string object into the location.
205
177
:param relpath: Location to put the contents, relative to base.
284
248
raise TransportNotPossible('http does not support lock_write()')
287
#---------------- test server facilities ----------------
288
import BaseHTTPServer, SimpleHTTPServer, socket, time
292
class WebserverNotAvailable(Exception):
296
class BadWebserverPath(ValueError):
298
return 'path %s is not in %s' % self.args
301
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
303
def log_message(self, format, *args):
304
self.server.test_case.log("webserver - %s - - [%s] %s",
305
self.address_string(),
306
self.log_date_time_string(),
309
def handle_one_request(self):
310
"""Handle a single HTTP request.
312
You normally don't need to override this method; see the class
313
__doc__ string for information on how to handle specific HTTP
314
commands such as GET and POST.
317
for i in xrange(1,11): # Don't try more than 10 times
319
self.raw_requestline = self.rfile.readline()
320
except socket.error, e:
321
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
322
# omitted for now because some tests look at the log of
323
# the server and expect to see no errors. see recent
324
# email thread. -- mbp 20051021.
325
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
331
if not self.raw_requestline:
332
self.close_connection = 1
334
if not self.parse_request(): # An error code has been sent, just exit
336
mname = 'do_' + self.command
337
if not hasattr(self, mname):
338
self.send_error(501, "Unsupported method (%r)" % self.command)
340
method = getattr(self, mname)
343
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
344
def __init__(self, server_address, RequestHandlerClass, test_case):
345
BaseHTTPServer.HTTPServer.__init__(self, server_address,
347
self.test_case = test_case
350
class HttpServer(Server):
351
"""A test server for http transports."""
353
_HTTP_PORTS = range(13000, 0x8000)
355
def _http_start(self):
357
for port in self._HTTP_PORTS:
359
httpd = TestingHTTPServer(('localhost', port),
360
TestingHTTPRequestHandler,
362
except socket.error, e:
363
if e.args[0] == errno.EADDRINUSE:
365
print >>sys.stderr, "Cannot run webserver :-("
371
raise WebserverNotAvailable("Cannot run webserver :-( "
372
"no free ports in range %s..%s" %
373
(_HTTP_PORTS[0], _HTTP_PORTS[-1]))
375
self._http_base_url = 'http://localhost:%s/' % port
376
self._http_starting.release()
377
httpd.socket.settimeout(0.1)
379
while self._http_running:
381
httpd.handle_request()
382
except socket.timeout:
385
def _get_remote_url(self, path):
386
path_parts = path.split(os.path.sep)
387
if os.path.isabs(path):
388
if path_parts[:len(self._local_path_parts)] != \
389
self._local_path_parts:
390
raise BadWebserverPath(path, self.test_dir)
391
remote_path = '/'.join(path_parts[len(self._local_path_parts):])
393
remote_path = '/'.join(path_parts)
395
self._http_starting.acquire()
396
self._http_starting.release()
397
return self._http_base_url + remote_path
399
def log(self, *args, **kwargs):
400
"""Capture Server log output."""
401
self.logs.append(args[3])
404
"""See bzrlib.transport.Server.setUp."""
405
self._home_dir = os.getcwdu()
406
self._local_path_parts = self._home_dir.split(os.path.sep)
407
self._http_starting = threading.Lock()
408
self._http_starting.acquire()
409
self._http_running = True
410
self._http_base_url = None
411
self._http_thread = threading.Thread(target=self._http_start)
412
self._http_thread.setDaemon(True)
413
self._http_thread.start()
414
self._http_proxy = os.environ.get("http_proxy")
415
if self._http_proxy is not None:
416
del os.environ["http_proxy"]
420
"""See bzrlib.transport.Server.tearDown."""
421
self._http_running = False
422
self._http_thread.join()
423
if self._http_proxy is not None:
425
os.environ["http_proxy"] = self._http_proxy
428
"""See bzrlib.transport.Server.get_url."""
429
return self._get_remote_url(self._home_dir)
431
def get_bogus_url(self):
432
"""See bzrlib.transport.Server.get_bogus_url."""
433
return 'http://jasldkjsalkdjalksjdkljasd'
436
def get_test_permutations():
437
"""Return the permutations to be used in testing."""
438
warn("There are no HTTPS transport provider tests yet.")
439
return [(HttpTransport, HttpServer),
250
register_transport('http://', HttpTransport)
251
register_transport('https://', HttpTransport)
added
removed
bzrlib/transport/http.py
