1
# Copyright (C) 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""RemoteTransport client for the smart-server.
19
This module shouldn't be accessed directly. The classes defined here should be
20
imported from bzrlib.smart.
23
__all__ = ['RemoteTransport', 'RemoteTCPTransport', 'RemoteSSHTransport']
25
from cStringIO import StringIO
37
from bzrlib.smart import client, medium, protocol
40
# Port 4155 is the default port for bzr://, registered with IANA.
41
BZR_DEFAULT_INTERFACE = '0.0.0.0'
42
BZR_DEFAULT_PORT = 4155
45
class _SmartStat(object):
47
def __init__(self, size, mode):
52
class RemoteTransport(transport.ConnectedTransport):
53
"""Connection to a smart server.
55
The connection holds references to the medium that can be used to send
56
requests to the server.
58
The connection has a notion of the current directory to which it's
59
connected; this is incorporated in filenames passed to the server.
61
This supports some higher-level RPC operations and can also be treated
62
like a Transport to do file-like operations.
64
The connection can be made over a tcp socket, an ssh pipe or a series of
65
http requests. There are concrete subclasses for each type:
66
RemoteTCPTransport, etc.
69
# IMPORTANT FOR IMPLEMENTORS: RemoteTransport MUST NOT be given encoding
70
# responsibilities: Put those on SmartClient or similar. This is vital for
71
# the ability to support multiple versions of the smart protocol over time:
72
# RemoteTransport is an adapter from the Transport object model to the
73
# SmartClient model, not an encoder.
75
# FIXME: the medium parameter should be private, only the tests requires
76
# it. It may be even clearer to define a TestRemoteTransport that handles
77
# the specific cases of providing a _client and/or a _medium, and leave
78
# RemoteTransport as an abstract class.
79
def __init__(self, url, _from_transport=None, medium=None, _client=None):
82
:param _from_transport: Another RemoteTransport instance that this
83
one is being cloned from. Attributes such as the medium will
86
:param medium: The medium to use for this RemoteTransport. This must be
87
supplied if _from_transport is None.
89
:param _client: Override the _SmartClient used by this transport. This
90
should only be used for testing purposes; normally this is
91
determined from the medium.
93
super(RemoteTransport, self).__init__(url,
94
_from_transport=_from_transport)
96
# The medium is the connection, except when we need to share it with
97
# other objects (RemoteBzrDir, RemoteRepository etc). In these cases
98
# what we want to share is really the shared connection.
100
if _from_transport is None:
101
# If no _from_transport is specified, we need to intialize the
105
medium, credentials = self._build_medium()
106
if 'hpss' in debug.debug_flags:
107
trace.mutter('hpss: Built a new medium: %s',
108
medium.__class__.__name__)
109
self._shared_connection = transport._SharedConnection(medium,
113
self._client = client._SmartClient(self.get_shared_medium())
115
self._client = _client
117
def _build_medium(self):
118
"""Create the medium if _from_transport does not provide one.
120
The medium is analogous to the connection for ConnectedTransport: it
121
allows connection sharing.
126
def is_readonly(self):
127
"""Smart server transport can do read/write file operations."""
128
resp = self._call2('Transport.is_readonly')
129
if resp == ('yes', ):
131
elif resp == ('no', ):
133
elif (resp == ('error', "Generic bzr smart protocol error: "
134
"bad request 'Transport.is_readonly'") or
135
resp == ('error', "Generic bzr smart protocol error: "
136
"bad request u'Transport.is_readonly'")):
137
# XXX: nasty hack: servers before 0.16 don't have a
138
# 'Transport.is_readonly' verb, so we do what clients before 0.16
142
self._translate_error(resp)
143
raise errors.UnexpectedSmartServerResponse(resp)
145
def get_smart_client(self):
146
return self._get_connection()
148
def get_smart_medium(self):
149
return self._get_connection()
151
def get_shared_medium(self):
152
return self._get_shared_connection()
154
def _remote_path(self, relpath):
155
"""Returns the Unicode version of the absolute path for relpath."""
156
return self._combine_paths(self._path, relpath)
158
def _call(self, method, *args):
159
resp = self._call2(method, *args)
160
self._translate_error(resp)
162
def _call2(self, method, *args):
163
"""Call a method on the remote server."""
164
return self._client.call(method, *args)
166
def _call_with_body_bytes(self, method, args, body):
167
"""Call a method on the remote server with body bytes."""
168
return self._client.call_with_body_bytes(method, args, body)
170
def has(self, relpath):
171
"""Indicate whether a remote file of the given name exists or not.
173
:see: Transport.has()
175
resp = self._call2('has', self._remote_path(relpath))
176
if resp == ('yes', ):
178
elif resp == ('no', ):
181
self._translate_error(resp)
183
def get(self, relpath):
184
"""Return file-like object reading the contents of a remote file.
186
:see: Transport.get_bytes()/get_file()
188
return StringIO(self.get_bytes(relpath))
190
def get_bytes(self, relpath):
191
remote = self._remote_path(relpath)
192
request = self.get_smart_medium().get_request()
193
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
194
smart_protocol.call('get', remote)
195
resp = smart_protocol.read_response_tuple(True)
197
smart_protocol.cancel_read_body()
198
self._translate_error(resp, relpath)
199
return smart_protocol.read_body_bytes()
201
def _serialise_optional_mode(self, mode):
207
def mkdir(self, relpath, mode=None):
208
resp = self._call2('mkdir', self._remote_path(relpath),
209
self._serialise_optional_mode(mode))
210
self._translate_error(resp)
212
def open_write_stream(self, relpath, mode=None):
213
"""See Transport.open_write_stream."""
214
self.put_bytes(relpath, "", mode)
215
result = transport.AppendBasedFileStream(self, relpath)
216
transport._file_streams[self.abspath(relpath)] = result
219
def put_bytes(self, relpath, upload_contents, mode=None):
220
# FIXME: upload_file is probably not safe for non-ascii characters -
221
# should probably just pass all parameters as length-delimited
223
if type(upload_contents) is unicode:
224
# Although not strictly correct, we raise UnicodeEncodeError to be
225
# compatible with other transports.
226
raise UnicodeEncodeError(
227
'undefined', upload_contents, 0, 1,
228
'put_bytes must be given bytes, not unicode.')
229
resp = self._call_with_body_bytes('put',
230
(self._remote_path(relpath), self._serialise_optional_mode(mode)),
232
self._translate_error(resp)
233
return len(upload_contents)
235
def put_bytes_non_atomic(self, relpath, bytes, mode=None,
236
create_parent_dir=False,
238
"""See Transport.put_bytes_non_atomic."""
239
# FIXME: no encoding in the transport!
240
create_parent_str = 'F'
241
if create_parent_dir:
242
create_parent_str = 'T'
244
resp = self._call_with_body_bytes(
246
(self._remote_path(relpath), self._serialise_optional_mode(mode),
247
create_parent_str, self._serialise_optional_mode(dir_mode)),
249
self._translate_error(resp)
251
def put_file(self, relpath, upload_file, mode=None):
252
# its not ideal to seek back, but currently put_non_atomic_file depends
253
# on transports not reading before failing - which is a faulty
254
# assumption I think - RBC 20060915
255
pos = upload_file.tell()
257
return self.put_bytes(relpath, upload_file.read(), mode)
259
upload_file.seek(pos)
262
def put_file_non_atomic(self, relpath, f, mode=None,
263
create_parent_dir=False,
265
return self.put_bytes_non_atomic(relpath, f.read(), mode=mode,
266
create_parent_dir=create_parent_dir,
269
def append_file(self, relpath, from_file, mode=None):
270
return self.append_bytes(relpath, from_file.read(), mode)
272
def append_bytes(self, relpath, bytes, mode=None):
273
resp = self._call_with_body_bytes(
275
(self._remote_path(relpath), self._serialise_optional_mode(mode)),
277
if resp[0] == 'appended':
279
self._translate_error(resp)
281
def delete(self, relpath):
282
resp = self._call2('delete', self._remote_path(relpath))
283
self._translate_error(resp)
285
def external_url(self):
286
"""See bzrlib.transport.Transport.external_url."""
287
# the external path for RemoteTransports is the base
290
def _readv(self, relpath, offsets):
294
offsets = list(offsets)
296
sorted_offsets = sorted(offsets)
297
# turn the list of offsets into a stack
298
offset_stack = iter(offsets)
299
cur_offset_and_size = offset_stack.next()
300
coalesced = list(self._coalesce_offsets(sorted_offsets,
301
limit=self._max_readv_combine,
302
fudge_factor=self._bytes_to_read_before_seek))
304
request = self.get_smart_medium().get_request()
305
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
306
smart_protocol.call_with_body_readv_array(
307
('readv', self._remote_path(relpath)),
308
[(c.start, c.length) for c in coalesced])
309
resp = smart_protocol.read_response_tuple(True)
311
if resp[0] != 'readv':
312
# This should raise an exception
313
smart_protocol.cancel_read_body()
314
self._translate_error(resp)
317
# FIXME: this should know how many bytes are needed, for clarity.
318
data = smart_protocol.read_body_bytes()
319
# Cache the results, but only until they have been fulfilled
321
for c_offset in coalesced:
322
if len(data) < c_offset.length:
323
raise errors.ShortReadvError(relpath, c_offset.start,
324
c_offset.length, actual=len(data))
325
for suboffset, subsize in c_offset.ranges:
326
key = (c_offset.start+suboffset, subsize)
327
data_map[key] = data[suboffset:suboffset+subsize]
328
data = data[c_offset.length:]
330
# Now that we've read some data, see if we can yield anything back
331
while cur_offset_and_size in data_map:
332
this_data = data_map.pop(cur_offset_and_size)
333
yield cur_offset_and_size[0], this_data
334
cur_offset_and_size = offset_stack.next()
336
def rename(self, rel_from, rel_to):
338
self._remote_path(rel_from),
339
self._remote_path(rel_to))
341
def move(self, rel_from, rel_to):
343
self._remote_path(rel_from),
344
self._remote_path(rel_to))
346
def rmdir(self, relpath):
347
resp = self._call('rmdir', self._remote_path(relpath))
349
def _translate_error(self, resp, orig_path=None):
350
"""Raise an exception from a response"""
357
elif what == 'NoSuchFile':
358
if orig_path is not None:
359
error_path = orig_path
362
raise errors.NoSuchFile(error_path)
363
elif what == 'error':
364
raise errors.SmartProtocolError(unicode(resp[1]))
365
elif what == 'FileExists':
366
raise errors.FileExists(resp[1])
367
elif what == 'DirectoryNotEmpty':
368
raise errors.DirectoryNotEmpty(resp[1])
369
elif what == 'ShortReadvError':
370
raise errors.ShortReadvError(resp[1], int(resp[2]),
371
int(resp[3]), int(resp[4]))
372
elif what in ('UnicodeEncodeError', 'UnicodeDecodeError'):
373
encoding = str(resp[1]) # encoding must always be a string
377
reason = str(resp[5]) # reason must always be a string
378
if val.startswith('u:'):
379
val = val[2:].decode('utf-8')
380
elif val.startswith('s:'):
381
val = val[2:].decode('base64')
382
if what == 'UnicodeDecodeError':
383
raise UnicodeDecodeError(encoding, val, start, end, reason)
384
elif what == 'UnicodeEncodeError':
385
raise UnicodeEncodeError(encoding, val, start, end, reason)
386
elif what == "ReadOnlyError":
387
raise errors.TransportNotPossible('readonly transport')
388
elif what == "ReadError":
389
if orig_path is not None:
390
error_path = orig_path
393
raise errors.ReadError(error_path)
395
raise errors.SmartProtocolError('unexpected smart server error: %r' % (resp,))
397
def disconnect(self):
398
self.get_smart_medium().disconnect()
400
def delete_tree(self, relpath):
401
raise errors.TransportNotPossible('readonly transport')
403
def stat(self, relpath):
404
resp = self._call2('stat', self._remote_path(relpath))
405
if resp[0] == 'stat':
406
return _SmartStat(int(resp[1]), int(resp[2], 8))
408
self._translate_error(resp)
410
## def lock_read(self, relpath):
411
## """Lock the given file for shared (read) access.
412
## :return: A lock object, which should be passed to Transport.unlock()
414
## # The old RemoteBranch ignore lock for reading, so we will
415
## # continue that tradition and return a bogus lock object.
416
## class BogusLock(object):
417
## def __init__(self, path):
421
## return BogusLock(relpath)
426
def list_dir(self, relpath):
427
resp = self._call2('list_dir', self._remote_path(relpath))
428
if resp[0] == 'names':
429
return [name.encode('ascii') for name in resp[1:]]
431
self._translate_error(resp)
433
def iter_files_recursive(self):
434
resp = self._call2('iter_files_recursive', self._remote_path(''))
435
if resp[0] == 'names':
438
self._translate_error(resp)
441
class RemoteTCPTransport(RemoteTransport):
442
"""Connection to smart server over plain tcp.
444
This is essentially just a factory to get 'RemoteTransport(url,
445
SmartTCPClientMedium).
448
def _build_medium(self):
449
assert self.base.startswith('bzr://')
450
return medium.SmartTCPClientMedium(self._host, self._port), None
453
class RemoteSSHTransport(RemoteTransport):
454
"""Connection to smart server over SSH.
456
This is essentially just a factory to get 'RemoteTransport(url,
457
SmartSSHClientMedium).
460
def _build_medium(self):
461
assert self.base.startswith('bzr+ssh://')
462
# ssh will prompt the user for a password if needed and if none is
463
# provided but it will not give it back, so no credentials can be
465
location_config = config.LocationConfig(self.base)
466
bzr_remote_path = location_config.get_bzr_remote_path()
467
return medium.SmartSSHClientMedium(self._host, self._port,
468
self._user, self._password, bzr_remote_path=bzr_remote_path), None
471
class RemoteHTTPTransport(RemoteTransport):
472
"""Just a way to connect between a bzr+http:// url and http://.
474
This connection operates slightly differently than the RemoteSSHTransport.
475
It uses a plain http:// transport underneath, which defines what remote
476
.bzr/smart URL we are connected to. From there, all paths that are sent are
477
sent as relative paths, this way, the remote side can properly
478
de-reference them, since it is likely doing rewrite rules to translate an
479
HTTP path into a local path.
482
def __init__(self, base, _from_transport=None, http_transport=None):
483
assert ( base.startswith('bzr+http://') or base.startswith('bzr+https://') )
485
if http_transport is None:
486
# FIXME: the password may be lost here because it appears in the
487
# url only for an intial construction (when the url came from the
489
http_url = base[len('bzr+'):]
490
self._http_transport = transport.get_transport(http_url)
492
self._http_transport = http_transport
493
super(RemoteHTTPTransport, self).__init__(
494
base, _from_transport=_from_transport)
496
def _build_medium(self):
497
# We let http_transport take care of the credentials
498
return self._http_transport.get_smart_medium(), None
500
def _remote_path(self, relpath):
501
"""After connecting, HTTP Transport only deals in relative URLs."""
502
# Adjust the relpath based on which URL this smart transport is
504
http_base = urlutils.normalize_url(self._http_transport.base)
505
url = urlutils.join(self.base[len('bzr+'):], relpath)
506
url = urlutils.normalize_url(url)
507
return urlutils.relative_url(http_base, url)
509
def clone(self, relative_url):
510
"""Make a new RemoteHTTPTransport related to me.
512
This is re-implemented rather than using the default
513
RemoteTransport.clone() because we must be careful about the underlying
516
Also, the cloned smart transport will POST to the same .bzr/smart
517
location as this transport (although obviously the relative paths in the
518
smart requests may be different). This is so that the server doesn't
519
have to handle .bzr/smart requests at arbitrary places inside .bzr
520
directories, just at the initial URL the user uses.
522
The exception is parent paths (i.e. relative_url of "..").
525
abs_url = self.abspath(relative_url)
528
# We either use the exact same http_transport (for child locations), or
529
# a clone of the underlying http_transport (for parent locations). This
530
# means we share the connection.
531
norm_base = urlutils.normalize_url(self.base)
532
norm_abs_url = urlutils.normalize_url(abs_url)
533
normalized_rel_url = urlutils.relative_url(norm_base, norm_abs_url)
534
if normalized_rel_url == ".." or normalized_rel_url.startswith("../"):
535
http_transport = self._http_transport.clone(normalized_rel_url)
537
http_transport = self._http_transport
538
return RemoteHTTPTransport(abs_url,
539
_from_transport=self,
540
http_transport=http_transport)
543
def get_test_permutations():
544
"""Return (transport, server) permutations for testing."""
545
### We may need a little more test framework support to construct an
546
### appropriate RemoteTransport in the future.
547
from bzrlib.smart import server
548
return [(RemoteTCPTransport, server.SmartTCPServer_for_testing)]
added
removed
bzrlib/transport/remote.py
