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)
23
20
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)
27
28
from bzrlib.errors import BzrError, BzrCheckError
28
29
from bzrlib.branch import Branch
29
30
from bzrlib.trace import mutter
31
# velocitynet.com.au transparently proxies connections and thereby
32
# breaks keep-alive -- sucks!
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
37
66
mutter("get_url %s" % url)
38
url_f = urllib2.urlopen(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)
41
class HttpTransportError(TransportError):
44
74
class HttpTransport(Transport):
45
75
"""This is the transport agent for http:// access.
77
109
"""Return the full url to the given relative path.
78
110
This can be supplied with a string or a list
112
assert isinstance(relpath, basestring)
80
113
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))
82
125
basepath = self._path.split('/')
83
126
if len(basepath) > 0 and basepath[-1] == '':
84
127
basepath = basepath[:-1]
128
for p in relpath_parts:
130
if len(basepath) == 0:
89
131
# In most filesystems, a request for the parent
90
132
# of root, just returns root.
135
elif p == '.' or p == '':
97
138
basepath.append(p)
99
139
# Possibly, we could use urlparse.urljoin() here, but
100
140
# I'm concerned about when it chooses to strip the last
101
141
# portion of the path, and when it doesn't.
121
154
cleaner if we just do an http HEAD request, and parse
125
f = get_url(self.abspath(relpath))
159
path = self.abspath(relpath)
126
161
# Without the read and then close()
127
162
# we tend to have busy sockets.
133
except urllib2.URLError:
166
except urllib2.URLError, e:
167
mutter('url error code: %s for has url: %r', e.code, path)
135
171
except IOError, e:
172
mutter('io error: %s %s for has url: %r',
173
e.errno, errno.errorcode.get(e.errno), path)
136
174
if e.errno == errno.ENOENT:
138
raise HttpTransportError(orig_error=e)
176
raise TransportError(orig_error=e)
140
178
def get(self, relpath, decode=False):
141
179
"""Get the file at the given relative path.
143
181
:param relpath: The relative path to the file
146
return get_url(self.abspath(relpath))
147
except (BzrError, urllib2.URLError, IOError), e:
148
raise NoSuchFile(msg = "Error retrieving %s: %s"
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"
149
199
% (self.abspath(relpath), str(e)),
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):
202
def put(self, relpath, f, mode=None):
175
203
"""Copy the file-like or string object into the location.
177
205
:param relpath: Location to put the contents, relative to base.
248
280
raise TransportNotPossible('http does not support lock_write()')
250
register_transport('http://', HttpTransport)
251
register_transport('https://', HttpTransport)
283
#---------------- test server facilities ----------------
284
import BaseHTTPServer, SimpleHTTPServer, socket, time
288
class WebserverNotAvailable(Exception):
292
class BadWebserverPath(ValueError):
294
return 'path %s is not in %s' % self.args
297
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
299
def log_message(self, format, *args):
300
self.server.test_case.log("webserver - %s - - [%s] %s",
301
self.address_string(),
302
self.log_date_time_string(),
305
def handle_one_request(self):
306
"""Handle a single HTTP request.
308
You normally don't need to override this method; see the class
309
__doc__ string for information on how to handle specific HTTP
310
commands such as GET and POST.
313
for i in xrange(1,11): # Don't try more than 10 times
315
self.raw_requestline = self.rfile.readline()
316
except socket.error, e:
317
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
318
# omitted for now because some tests look at the log of
319
# the server and expect to see no errors. see recent
320
# email thread. -- mbp 20051021.
321
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
327
if not self.raw_requestline:
328
self.close_connection = 1
330
if not self.parse_request(): # An error code has been sent, just exit
332
mname = 'do_' + self.command
333
if not hasattr(self, mname):
334
self.send_error(501, "Unsupported method (%r)" % self.command)
336
method = getattr(self, mname)
339
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
340
def __init__(self, server_address, RequestHandlerClass, test_case):
341
BaseHTTPServer.HTTPServer.__init__(self, server_address,
343
self.test_case = test_case
346
class HttpServer(Server):
347
"""A test server for http transports."""
349
_HTTP_PORTS = range(13000, 0x8000)
351
def _http_start(self):
353
for port in self._HTTP_PORTS:
355
httpd = TestingHTTPServer(('localhost', port),
356
TestingHTTPRequestHandler,
358
except socket.error, e:
359
if e.args[0] == errno.EADDRINUSE:
361
print >>sys.stderr, "Cannot run webserver :-("
367
raise WebserverNotAvailable("Cannot run webserver :-( "
368
"no free ports in range %s..%s" %
369
(_HTTP_PORTS[0], _HTTP_PORTS[-1]))
371
self._http_base_url = 'http://localhost:%s/' % port
372
self._http_starting.release()
373
httpd.socket.settimeout(0.1)
375
while self._http_running:
377
httpd.handle_request()
378
except socket.timeout:
381
def _get_remote_url(self, path):
382
path_parts = path.split(os.path.sep)
383
if os.path.isabs(path):
384
if path_parts[:len(self._local_path_parts)] != \
385
self._local_path_parts:
386
raise BadWebserverPath(path, self.test_dir)
387
remote_path = '/'.join(path_parts[len(self._local_path_parts):])
389
remote_path = '/'.join(path_parts)
391
self._http_starting.acquire()
392
self._http_starting.release()
393
return self._http_base_url + remote_path
395
def log(self, *args, **kwargs):
396
"""Capture Server log output."""
397
self.logs.append(args[3])
400
"""See bzrlib.transport.Server.setUp."""
401
self._home_dir = os.getcwdu()
402
self._local_path_parts = self._home_dir.split(os.path.sep)
403
self._http_starting = threading.Lock()
404
self._http_starting.acquire()
405
self._http_running = True
406
self._http_base_url = None
407
self._http_thread = threading.Thread(target=self._http_start)
408
self._http_thread.setDaemon(True)
409
self._http_thread.start()
410
self._http_proxy = os.environ.get("http_proxy")
411
if self._http_proxy is not None:
412
del os.environ["http_proxy"]
416
"""See bzrlib.transport.Server.tearDown."""
417
self._http_running = False
418
self._http_thread.join()
419
if self._http_proxy is not None:
421
os.environ["http_proxy"] = self._http_proxy
424
"""See bzrlib.transport.Server.get_url."""
425
return self._get_remote_url(self._home_dir)
427
def get_bogus_url(self):
428
"""See bzrlib.transport.Server.get_bogus_url."""
429
return 'http://jasldkjsalkdjalksjdkljasd'
432
def get_test_permutations():
433
"""Return the permutations to be used in testing."""
434
warn("There are no HTTPS transport provider tests yet.")
435
return [(HttpTransport, HttpServer),
added
removed
bzrlib/transport/http.py
