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
class _SmartStat(object):
42
def __init__(self, size, mode):
47
class RemoteTransport(transport.ConnectedTransport):
48
"""Connection to a smart server.
50
The connection holds references to the medium that can be used to send
51
requests to the server.
53
The connection has a notion of the current directory to which it's
54
connected; this is incorporated in filenames passed to the server.
56
This supports some higher-level RPC operations and can also be treated
57
like a Transport to do file-like operations.
59
The connection can be made over a tcp socket, an ssh pipe or a series of
60
http requests. There are concrete subclasses for each type:
61
RemoteTCPTransport, etc.
64
# IMPORTANT FOR IMPLEMENTORS: RemoteTransport MUST NOT be given encoding
65
# responsibilities: Put those on SmartClient or similar. This is vital for
66
# the ability to support multiple versions of the smart protocol over time:
67
# RemoteTransport is an adapter from the Transport object model to the
68
# SmartClient model, not an encoder.
70
# FIXME: the medium parameter should be private, only the tests requires
71
# it. It may be even clearer to define a TestRemoteTransport that handles
72
# the specific cases of providing a _client and/or a _medium, and leave
73
# RemoteTransport as an abstract class.
74
def __init__(self, url, _from_transport=None, medium=None, _client=None):
77
:param _from_transport: Another RemoteTransport instance that this
78
one is being cloned from. Attributes such as the medium will
81
:param medium: The medium to use for this RemoteTransport. This must be
82
supplied if _from_transport is None.
84
:param _client: Override the _SmartClient used by this transport. This
85
should only be used for testing purposes; normally this is
86
determined from the medium.
88
super(RemoteTransport, self).__init__(url,
89
_from_transport=_from_transport)
91
# The medium is the connection, except when we need to share it with
92
# other objects (RemoteBzrDir, RemoteRepository etc). In these cases
93
# what we want to share is really the shared connection.
95
if _from_transport is None:
96
# If no _from_transport is specified, we need to intialize the
100
medium, credentials = self._build_medium()
101
if 'hpss' in debug.debug_flags:
102
trace.mutter('hpss: Built a new medium: %s',
103
medium.__class__.__name__)
104
self._shared_connection = transport._SharedConnection(medium,
109
self._client = client._SmartClient(self.get_shared_medium())
111
self._client = _client
113
def _build_medium(self):
114
"""Create the medium if _from_transport does not provide one.
116
The medium is analogous to the connection for ConnectedTransport: it
117
allows connection sharing.
122
def is_readonly(self):
123
"""Smart server transport can do read/write file operations."""
124
resp = self._call2('Transport.is_readonly')
125
if resp == ('yes', ):
127
elif resp == ('no', ):
129
elif (resp == ('error', "Generic bzr smart protocol error: "
130
"bad request 'Transport.is_readonly'") or
131
resp == ('error', "Generic bzr smart protocol error: "
132
"bad request u'Transport.is_readonly'")):
133
# XXX: nasty hack: servers before 0.16 don't have a
134
# 'Transport.is_readonly' verb, so we do what clients before 0.16
138
self._translate_error(resp)
139
raise errors.UnexpectedSmartServerResponse(resp)
141
def get_smart_client(self):
142
return self._get_connection()
144
def get_smart_medium(self):
145
return self._get_connection()
147
def get_shared_medium(self):
148
return self._get_shared_connection()
150
def _remote_path(self, relpath):
151
"""Returns the Unicode version of the absolute path for relpath."""
152
return self._combine_paths(self._path, relpath)
154
def _call(self, method, *args):
155
resp = self._call2(method, *args)
156
self._translate_error(resp)
158
def _call2(self, method, *args):
159
"""Call a method on the remote server."""
160
return self._client.call(method, *args)
162
def _call_with_body_bytes(self, method, args, body):
163
"""Call a method on the remote server with body bytes."""
164
return self._client.call_with_body_bytes(method, args, body)
166
def has(self, relpath):
167
"""Indicate whether a remote file of the given name exists or not.
169
:see: Transport.has()
171
resp = self._call2('has', self._remote_path(relpath))
172
if resp == ('yes', ):
174
elif resp == ('no', ):
177
self._translate_error(resp)
179
def get(self, relpath):
180
"""Return file-like object reading the contents of a remote file.
182
:see: Transport.get_bytes()/get_file()
184
return StringIO(self.get_bytes(relpath))
186
def get_bytes(self, relpath):
187
remote = self._remote_path(relpath)
188
request = self.get_smart_medium().get_request()
189
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
190
smart_protocol.call('get', remote)
191
resp = smart_protocol.read_response_tuple(True)
193
smart_protocol.cancel_read_body()
194
self._translate_error(resp, relpath)
195
return smart_protocol.read_body_bytes()
197
def _serialise_optional_mode(self, mode):
203
def mkdir(self, relpath, mode=None):
204
resp = self._call2('mkdir', self._remote_path(relpath),
205
self._serialise_optional_mode(mode))
206
self._translate_error(resp)
208
def open_write_stream(self, relpath, mode=None):
209
"""See Transport.open_write_stream."""
210
self.put_bytes(relpath, "", mode)
211
result = transport.AppendBasedFileStream(self, relpath)
212
transport._file_streams[self.abspath(relpath)] = result
215
def put_bytes(self, relpath, upload_contents, mode=None):
216
# FIXME: upload_file is probably not safe for non-ascii characters -
217
# should probably just pass all parameters as length-delimited
219
if type(upload_contents) is unicode:
220
# Although not strictly correct, we raise UnicodeEncodeError to be
221
# compatible with other transports.
222
raise UnicodeEncodeError(
223
'undefined', upload_contents, 0, 1,
224
'put_bytes must be given bytes, not unicode.')
225
resp = self._call_with_body_bytes('put',
226
(self._remote_path(relpath), self._serialise_optional_mode(mode)),
228
self._translate_error(resp)
229
return len(upload_contents)
231
def put_bytes_non_atomic(self, relpath, bytes, mode=None,
232
create_parent_dir=False,
234
"""See Transport.put_bytes_non_atomic."""
235
# FIXME: no encoding in the transport!
236
create_parent_str = 'F'
237
if create_parent_dir:
238
create_parent_str = 'T'
240
resp = self._call_with_body_bytes(
242
(self._remote_path(relpath), self._serialise_optional_mode(mode),
243
create_parent_str, self._serialise_optional_mode(dir_mode)),
245
self._translate_error(resp)
247
def put_file(self, relpath, upload_file, mode=None):
248
# its not ideal to seek back, but currently put_non_atomic_file depends
249
# on transports not reading before failing - which is a faulty
250
# assumption I think - RBC 20060915
251
pos = upload_file.tell()
253
return self.put_bytes(relpath, upload_file.read(), mode)
255
upload_file.seek(pos)
258
def put_file_non_atomic(self, relpath, f, mode=None,
259
create_parent_dir=False,
261
return self.put_bytes_non_atomic(relpath, f.read(), mode=mode,
262
create_parent_dir=create_parent_dir,
265
def append_file(self, relpath, from_file, mode=None):
266
return self.append_bytes(relpath, from_file.read(), mode)
268
def append_bytes(self, relpath, bytes, mode=None):
269
resp = self._call_with_body_bytes(
271
(self._remote_path(relpath), self._serialise_optional_mode(mode)),
273
if resp[0] == 'appended':
275
self._translate_error(resp)
277
def delete(self, relpath):
278
resp = self._call2('delete', self._remote_path(relpath))
279
self._translate_error(resp)
281
def external_url(self):
282
"""See bzrlib.transport.Transport.external_url."""
283
# the external path for RemoteTransports is the base
286
def _readv(self, relpath, offsets):
290
offsets = list(offsets)
292
sorted_offsets = sorted(offsets)
293
# turn the list of offsets into a stack
294
offset_stack = iter(offsets)
295
cur_offset_and_size = offset_stack.next()
296
coalesced = list(self._coalesce_offsets(sorted_offsets,
297
limit=self._max_readv_combine,
298
fudge_factor=self._bytes_to_read_before_seek))
300
request = self.get_smart_medium().get_request()
301
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
302
smart_protocol.call_with_body_readv_array(
303
('readv', self._remote_path(relpath)),
304
[(c.start, c.length) for c in coalesced])
305
resp = smart_protocol.read_response_tuple(True)
307
if resp[0] != 'readv':
308
# This should raise an exception
309
smart_protocol.cancel_read_body()
310
self._translate_error(resp)
313
# FIXME: this should know how many bytes are needed, for clarity.
314
data = smart_protocol.read_body_bytes()
315
# Cache the results, but only until they have been fulfilled
317
for c_offset in coalesced:
318
if len(data) < c_offset.length:
319
raise errors.ShortReadvError(relpath, c_offset.start,
320
c_offset.length, actual=len(data))
321
for suboffset, subsize in c_offset.ranges:
322
key = (c_offset.start+suboffset, subsize)
323
data_map[key] = data[suboffset:suboffset+subsize]
324
data = data[c_offset.length:]
326
# Now that we've read some data, see if we can yield anything back
327
while cur_offset_and_size in data_map:
328
this_data = data_map.pop(cur_offset_and_size)
329
yield cur_offset_and_size[0], this_data
330
cur_offset_and_size = offset_stack.next()
332
def rename(self, rel_from, rel_to):
334
self._remote_path(rel_from),
335
self._remote_path(rel_to))
337
def move(self, rel_from, rel_to):
339
self._remote_path(rel_from),
340
self._remote_path(rel_to))
342
def rmdir(self, relpath):
343
resp = self._call('rmdir', self._remote_path(relpath))
345
def _translate_error(self, resp, orig_path=None):
346
"""Raise an exception from a response"""
353
elif what == 'NoSuchFile':
354
if orig_path is not None:
355
error_path = orig_path
358
raise errors.NoSuchFile(error_path)
359
elif what == 'error':
360
raise errors.SmartProtocolError(unicode(resp[1]))
361
elif what == 'FileExists':
362
raise errors.FileExists(resp[1])
363
elif what == 'DirectoryNotEmpty':
364
raise errors.DirectoryNotEmpty(resp[1])
365
elif what == 'ShortReadvError':
366
raise errors.ShortReadvError(resp[1], int(resp[2]),
367
int(resp[3]), int(resp[4]))
368
elif what in ('UnicodeEncodeError', 'UnicodeDecodeError'):
369
encoding = str(resp[1]) # encoding must always be a string
373
reason = str(resp[5]) # reason must always be a string
374
if val.startswith('u:'):
375
val = val[2:].decode('utf-8')
376
elif val.startswith('s:'):
377
val = val[2:].decode('base64')
378
if what == 'UnicodeDecodeError':
379
raise UnicodeDecodeError(encoding, val, start, end, reason)
380
elif what == 'UnicodeEncodeError':
381
raise UnicodeEncodeError(encoding, val, start, end, reason)
382
elif what == "ReadOnlyError":
383
raise errors.TransportNotPossible('readonly transport')
384
elif what == "ReadError":
385
if orig_path is not None:
386
error_path = orig_path
389
raise errors.ReadError(error_path)
390
elif what == "PermissionDenied":
391
if orig_path is not None:
392
error_path = orig_path
395
raise errors.PermissionDenied(error_path)
397
raise errors.SmartProtocolError('unexpected smart server error: %r' % (resp,))
399
def disconnect(self):
400
self.get_smart_medium().disconnect()
402
def delete_tree(self, relpath):
403
raise errors.TransportNotPossible('readonly transport')
405
def stat(self, relpath):
406
resp = self._call2('stat', self._remote_path(relpath))
407
if resp[0] == 'stat':
408
return _SmartStat(int(resp[1]), int(resp[2], 8))
410
self._translate_error(resp)
412
## def lock_read(self, relpath):
413
## """Lock the given file for shared (read) access.
414
## :return: A lock object, which should be passed to Transport.unlock()
416
## # The old RemoteBranch ignore lock for reading, so we will
417
## # continue that tradition and return a bogus lock object.
418
## class BogusLock(object):
419
## def __init__(self, path):
423
## return BogusLock(relpath)
428
def list_dir(self, relpath):
429
resp = self._call2('list_dir', self._remote_path(relpath))
430
if resp[0] == 'names':
431
return [name.encode('ascii') for name in resp[1:]]
433
self._translate_error(resp)
435
def iter_files_recursive(self):
436
resp = self._call2('iter_files_recursive', self._remote_path(''))
437
if resp[0] == 'names':
440
self._translate_error(resp)
443
class RemoteTCPTransport(RemoteTransport):
444
"""Connection to smart server over plain tcp.
446
This is essentially just a factory to get 'RemoteTransport(url,
447
SmartTCPClientMedium).
450
def _build_medium(self):
451
assert self.base.startswith('bzr://')
452
return medium.SmartTCPClientMedium(self._host, self._port), None
455
class RemoteSSHTransport(RemoteTransport):
456
"""Connection to smart server over SSH.
458
This is essentially just a factory to get 'RemoteTransport(url,
459
SmartSSHClientMedium).
462
def _build_medium(self):
463
assert self.base.startswith('bzr+ssh://')
464
# ssh will prompt the user for a password if needed and if none is
465
# provided but it will not give it back, so no credentials can be
467
location_config = config.LocationConfig(self.base)
468
bzr_remote_path = location_config.get_bzr_remote_path()
469
return medium.SmartSSHClientMedium(self._host, self._port,
470
self._user, self._password, bzr_remote_path=bzr_remote_path), None
473
class RemoteHTTPTransport(RemoteTransport):
474
"""Just a way to connect between a bzr+http:// url and http://.
476
This connection operates slightly differently than the RemoteSSHTransport.
477
It uses a plain http:// transport underneath, which defines what remote
478
.bzr/smart URL we are connected to. From there, all paths that are sent are
479
sent as relative paths, this way, the remote side can properly
480
de-reference them, since it is likely doing rewrite rules to translate an
481
HTTP path into a local path.
484
def __init__(self, base, _from_transport=None, http_transport=None):
485
assert ( base.startswith('bzr+http://') or base.startswith('bzr+https://') )
487
if http_transport is None:
488
# FIXME: the password may be lost here because it appears in the
489
# url only for an intial construction (when the url came from the
491
http_url = base[len('bzr+'):]
492
self._http_transport = transport.get_transport(http_url)
494
self._http_transport = http_transport
495
super(RemoteHTTPTransport, self).__init__(
496
base, _from_transport=_from_transport)
498
def _build_medium(self):
499
# We let http_transport take care of the credentials
500
return self._http_transport.get_smart_medium(), None
502
def _remote_path(self, relpath):
503
"""After connecting, HTTP Transport only deals in relative URLs."""
504
# Adjust the relpath based on which URL this smart transport is
506
http_base = urlutils.normalize_url(self.get_smart_medium().base)
507
url = urlutils.join(self.base[len('bzr+'):], relpath)
508
url = urlutils.normalize_url(url)
509
return urlutils.relative_url(http_base, url)
511
def clone(self, relative_url):
512
"""Make a new RemoteHTTPTransport related to me.
514
This is re-implemented rather than using the default
515
RemoteTransport.clone() because we must be careful about the underlying
518
Also, the cloned smart transport will POST to the same .bzr/smart
519
location as this transport (although obviously the relative paths in the
520
smart requests may be different). This is so that the server doesn't
521
have to handle .bzr/smart requests at arbitrary places inside .bzr
522
directories, just at the initial URL the user uses.
525
abs_url = self.abspath(relative_url)
528
return RemoteHTTPTransport(abs_url,
529
_from_transport=self,
530
http_transport=self._http_transport)
533
def get_test_permutations():
534
"""Return (transport, server) permutations for testing."""
535
### We may need a little more test framework support to construct an
536
### appropriate RemoteTransport in the future.
537
from bzrlib.smart import server
538
return [(RemoteTCPTransport, server.SmartTCPServer_for_testing)]
added
removed
bzrlib/transport/remote.py
