87
83
one is being cloned from. Attributes such as the medium will
90
:param medium: The medium to use for this RemoteTransport. This must be
91
supplied if _from_transport is None.
86
:param medium: The medium to use for this RemoteTransport. If None,
87
the medium from the _from_transport is shared. If both this
88
and _from_transport are None, a new medium will be built.
89
_from_transport and medium cannot both be specified.
93
91
:param _client: Override the _SmartClient used by this transport. This
94
92
should only be used for testing purposes; normally this is
95
93
determined from the medium.
97
super(RemoteTransport, self).__init__(url,
98
_from_transport=_from_transport)
95
super(RemoteTransport, self).__init__(
96
url, _from_transport=_from_transport)
100
98
# The medium is the connection, except when we need to share it with
101
99
# other objects (RemoteBzrDir, RemoteRepository etc). In these cases
102
100
# what we want to share is really the shared connection.
104
if _from_transport is None:
102
if (_from_transport is not None
103
and isinstance(_from_transport, RemoteTransport)):
104
_client = _from_transport._client
105
elif _from_transport is None:
105
106
# If no _from_transport is specified, we need to intialize the
107
108
credentials = None
128
139
return None, None
141
def _report_activity(self, bytes, direction):
142
"""See Transport._report_activity.
144
Does nothing; the smart medium will report activity triggered by a
130
149
def is_readonly(self):
131
150
"""Smart server transport can do read/write file operations."""
132
resp = self._call2('Transport.is_readonly')
133
if resp == ('yes', ):
135
elif resp == ('no', ):
137
elif (resp == ('error', "Generic bzr smart protocol error: "
138
"bad request 'Transport.is_readonly'") or
139
resp == ('error', "Generic bzr smart protocol error: "
140
"bad request u'Transport.is_readonly'")):
152
resp = self._call2('Transport.is_readonly')
153
except errors.UnknownSmartMethod:
141
154
# XXX: nasty hack: servers before 0.16 don't have a
142
155
# 'Transport.is_readonly' verb, so we do what clients before 0.16
143
156
# did: assume False.
158
if resp == ('yes', ):
160
elif resp == ('no', ):
146
self._translate_error(resp)
147
raise errors.UnexpectedSmartServerResponse(resp)
163
raise errors.UnexpectedSmartServerResponse(resp)
149
165
def get_smart_client(self):
150
166
return self._get_connection()
152
168
def get_smart_medium(self):
153
169
return self._get_connection()
155
def get_shared_medium(self):
156
return self._get_shared_connection()
158
171
def _remote_path(self, relpath):
159
172
"""Returns the Unicode version of the absolute path for relpath."""
160
173
return self._combine_paths(self._path, relpath)
162
175
def _call(self, method, *args):
163
176
resp = self._call2(method, *args)
164
self._translate_error(resp)
177
self._ensure_ok(resp)
166
179
def _call2(self, method, *args):
167
180
"""Call a method on the remote server."""
168
return self._client.call(method, *args)
182
return self._client.call(method, *args)
183
except errors.ErrorFromSmartServer, err:
184
# The first argument, if present, is always a path.
186
context = {'relpath': args[0]}
189
self._translate_error(err, **context)
170
191
def _call_with_body_bytes(self, method, args, body):
171
192
"""Call a method on the remote server with body bytes."""
172
return self._client.call_with_body_bytes(method, args, body)
194
return self._client.call_with_body_bytes(method, args, body)
195
except errors.ErrorFromSmartServer, err:
196
# The first argument, if present, is always a path.
198
context = {'relpath': args[0]}
201
self._translate_error(err, **context)
174
203
def has(self, relpath):
175
204
"""Indicate whether a remote file of the given name exists or not.
182
211
elif resp == ('no', ):
185
self._translate_error(resp)
214
raise errors.UnexpectedSmartServerResponse(resp)
187
216
def get(self, relpath):
188
217
"""Return file-like object reading the contents of a remote file.
190
219
:see: Transport.get_bytes()/get_file()
192
221
return StringIO(self.get_bytes(relpath))
194
223
def get_bytes(self, relpath):
195
224
remote = self._remote_path(relpath)
196
request = self.get_smart_medium().get_request()
197
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
198
smart_protocol.call('get', remote)
199
resp = smart_protocol.read_response_tuple(True)
226
resp, response_handler = self._client.call_expecting_body('get', remote)
227
except errors.ErrorFromSmartServer, err:
228
self._translate_error(err, relpath)
200
229
if resp != ('ok', ):
201
smart_protocol.cancel_read_body()
202
self._translate_error(resp, relpath)
203
return smart_protocol.read_body_bytes()
230
response_handler.cancel_read_body()
231
raise errors.UnexpectedSmartServerResponse(resp)
232
return response_handler.read_body_bytes()
205
234
def _serialise_optional_mode(self, mode):
280
309
if resp[0] == 'appended':
281
310
return int(resp[1])
282
self._translate_error(resp)
311
raise errors.UnexpectedSmartServerResponse(resp)
284
313
def delete(self, relpath):
285
314
resp = self._call2('delete', self._remote_path(relpath))
286
self._translate_error(resp)
315
self._ensure_ok(resp)
288
317
def external_url(self):
289
318
"""See bzrlib.transport.Transport.external_url."""
290
319
# the external path for RemoteTransports is the base
293
def readv(self, relpath, offsets):
322
def recommended_page_size(self):
323
"""Return the recommended page size for this transport."""
326
def _readv(self, relpath, offsets):
297
330
offsets = list(offsets)
299
332
sorted_offsets = sorted(offsets)
300
# turn the list of offsets into a stack
301
offset_stack = iter(offsets)
302
cur_offset_and_size = offset_stack.next()
303
333
coalesced = list(self._coalesce_offsets(sorted_offsets,
304
334
limit=self._max_readv_combine,
305
fudge_factor=self._bytes_to_read_before_seek))
307
request = self.get_smart_medium().get_request()
308
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
309
smart_protocol.call_with_body_readv_array(
310
('readv', self._remote_path(relpath)),
311
[(c.start, c.length) for c in coalesced])
312
resp = smart_protocol.read_response_tuple(True)
314
if resp[0] != 'readv':
315
# This should raise an exception
316
smart_protocol.cancel_read_body()
317
self._translate_error(resp)
320
# FIXME: this should know how many bytes are needed, for clarity.
321
data = smart_protocol.read_body_bytes()
335
fudge_factor=self._bytes_to_read_before_seek,
336
max_size=self._max_readv_bytes))
338
# now that we've coallesced things, avoid making enormous requests
343
if c.length + cur_len > self._max_readv_bytes:
344
requests.append(cur_request)
348
cur_request.append(c)
351
requests.append(cur_request)
352
if 'hpss' in debug.debug_flags:
353
trace.mutter('%s.readv %s offsets => %s coalesced'
354
' => %s requests (%s)',
355
self.__class__.__name__, len(offsets), len(coalesced),
356
len(requests), sum(map(len, requests)))
322
357
# Cache the results, but only until they have been fulfilled
359
# turn the list of offsets into a single stack to iterate
360
offset_stack = iter(offsets)
361
# using a list so it can be modified when passing down and coming back
362
next_offset = [offset_stack.next()]
363
for cur_request in requests:
365
result = self._client.call_with_body_readv_array(
366
('readv', self._remote_path(relpath),),
367
[(c.start, c.length) for c in cur_request])
368
resp, response_handler = result
369
except errors.ErrorFromSmartServer, err:
370
self._translate_error(err, relpath)
372
if resp[0] != 'readv':
373
# This should raise an exception
374
response_handler.cancel_read_body()
375
raise errors.UnexpectedSmartServerResponse(resp)
377
for res in self._handle_response(offset_stack, cur_request,
383
def _handle_response(self, offset_stack, coalesced, response_handler,
384
data_map, next_offset):
385
cur_offset_and_size = next_offset[0]
386
# FIXME: this should know how many bytes are needed, for clarity.
387
data = response_handler.read_body_bytes()
324
389
for c_offset in coalesced:
325
390
if len(data) < c_offset.length:
326
391
raise errors.ShortReadvError(relpath, c_offset.start,
327
392
c_offset.length, actual=len(data))
328
393
for suboffset, subsize in c_offset.ranges:
329
394
key = (c_offset.start+suboffset, subsize)
330
data_map[key] = data[suboffset:suboffset+subsize]
331
data = data[c_offset.length:]
395
this_data = data[data_offset+suboffset:
396
data_offset+suboffset+subsize]
397
# Special case when the data is in-order, rather than packing
398
# into a map and then back out again. Benchmarking shows that
399
# this has 100% hit rate, but leave in the data_map work just
401
# TODO: Could we get away with using buffer() to avoid the
402
# memory copy? Callers would need to realize they may
403
# not have a real string.
404
if key == cur_offset_and_size:
405
yield cur_offset_and_size[0], this_data
406
cur_offset_and_size = next_offset[0] = offset_stack.next()
408
data_map[key] = this_data
409
data_offset += c_offset.length
333
411
# Now that we've read some data, see if we can yield anything back
334
412
while cur_offset_and_size in data_map:
335
413
this_data = data_map.pop(cur_offset_and_size)
336
414
yield cur_offset_and_size[0], this_data
337
cur_offset_and_size = offset_stack.next()
415
cur_offset_and_size = next_offset[0] = offset_stack.next()
339
417
def rename(self, rel_from, rel_to):
340
418
self._call('rename',
349
427
def rmdir(self, relpath):
350
428
resp = self._call('rmdir', self._remote_path(relpath))
352
def _translate_error(self, resp, orig_path=None):
353
"""Raise an exception from a response"""
360
elif what == 'NoSuchFile':
361
if orig_path is not None:
362
error_path = orig_path
365
raise errors.NoSuchFile(error_path)
366
elif what == 'error':
367
raise errors.SmartProtocolError(unicode(resp[1]))
368
elif what == 'FileExists':
369
raise errors.FileExists(resp[1])
370
elif what == 'DirectoryNotEmpty':
371
raise errors.DirectoryNotEmpty(resp[1])
372
elif what == 'ShortReadvError':
373
raise errors.ShortReadvError(resp[1], int(resp[2]),
374
int(resp[3]), int(resp[4]))
375
elif what in ('UnicodeEncodeError', 'UnicodeDecodeError'):
376
encoding = str(resp[1]) # encoding must always be a string
380
reason = str(resp[5]) # reason must always be a string
381
if val.startswith('u:'):
382
val = val[2:].decode('utf-8')
383
elif val.startswith('s:'):
384
val = val[2:].decode('base64')
385
if what == 'UnicodeDecodeError':
386
raise UnicodeDecodeError(encoding, val, start, end, reason)
387
elif what == 'UnicodeEncodeError':
388
raise UnicodeEncodeError(encoding, val, start, end, reason)
389
elif what == "ReadOnlyError":
390
raise errors.TransportNotPossible('readonly transport')
391
elif what == "ReadError":
392
if orig_path is not None:
393
error_path = orig_path
396
raise errors.ReadError(error_path)
398
raise errors.SmartProtocolError('unexpected smart server error: %r' % (resp,))
430
def _ensure_ok(self, resp):
432
raise errors.UnexpectedSmartServerResponse(resp)
434
def _translate_error(self, err, relpath=None):
435
remote._translate_error(err, path=relpath)
400
437
def disconnect(self):
401
438
self.get_smart_medium().disconnect()
403
def delete_tree(self, relpath):
404
raise errors.TransportNotPossible('readonly transport')
406
440
def stat(self, relpath):
407
441
resp = self._call2('stat', self._remote_path(relpath))
408
442
if resp[0] == 'stat':
409
443
return _SmartStat(int(resp[1]), int(resp[2], 8))
411
self._translate_error(resp)
444
raise errors.UnexpectedSmartServerResponse(resp)
413
446
## def lock_read(self, relpath):
414
447
## """Lock the given file for shared (read) access.
430
463
resp = self._call2('list_dir', self._remote_path(relpath))
431
464
if resp[0] == 'names':
432
465
return [name.encode('ascii') for name in resp[1:]]
434
self._translate_error(resp)
466
raise errors.UnexpectedSmartServerResponse(resp)
436
468
def iter_files_recursive(self):
437
469
resp = self._call2('iter_files_recursive', self._remote_path(''))
438
470
if resp[0] == 'names':
441
self._translate_error(resp)
472
raise errors.UnexpectedSmartServerResponse(resp)
444
475
class RemoteTCPTransport(RemoteTransport):
445
476
"""Connection to smart server over plain tcp.
447
478
This is essentially just a factory to get 'RemoteTransport(url,
448
479
SmartTCPClientMedium).
451
482
def _build_medium(self):
452
assert self.base.startswith('bzr://')
453
if self._port is None:
454
self._port = BZR_DEFAULT_PORT
455
return medium.SmartTCPClientMedium(self._host, self._port), None
483
client_medium = medium.SmartTCPClientMedium(
484
self._host, self._port, self.base)
485
return client_medium, None
488
class RemoteTCPTransportV2Only(RemoteTransport):
489
"""Connection to smart server over plain tcp with the client hard-coded to
490
assume protocol v2 and remote server version <= 1.6.
492
This should only be used for testing.
495
def _build_medium(self):
496
client_medium = medium.SmartTCPClientMedium(
497
self._host, self._port, self.base)
498
client_medium._protocol_version = 2
499
client_medium._remember_remote_is_before((1, 6))
500
return client_medium, None
458
503
class RemoteSSHTransport(RemoteTransport):
465
510
def _build_medium(self):
466
assert self.base.startswith('bzr+ssh://')
467
# ssh will prompt the user for a password if needed and if none is
468
# provided but it will not give it back, so no credentials can be
470
return medium.SmartSSHClientMedium(self._host, self._port,
471
self._user, self._password), None
511
location_config = config.LocationConfig(self.base)
512
bzr_remote_path = location_config.get_bzr_remote_path()
515
auth = config.AuthenticationConfig()
516
user = auth.get_user('ssh', self._host, self._port)
517
client_medium = medium.SmartSSHClientMedium(self._host, self._port,
518
user, self._password, self.base,
519
bzr_remote_path=bzr_remote_path)
520
return client_medium, (user, self._password)
474
523
class RemoteHTTPTransport(RemoteTransport):
475
524
"""Just a way to connect between a bzr+http:// url and http://.
477
526
This connection operates slightly differently than the RemoteSSHTransport.
478
527
It uses a plain http:// transport underneath, which defines what remote
479
528
.bzr/smart URL we are connected to. From there, all paths that are sent are
521
568
smart requests may be different). This is so that the server doesn't
522
569
have to handle .bzr/smart requests at arbitrary places inside .bzr
523
570
directories, just at the initial URL the user uses.
525
The exception is parent paths (i.e. relative_url of "..").
528
573
abs_url = self.abspath(relative_url)
530
575
abs_url = self.base
531
# We either use the exact same http_transport (for child locations), or
532
# a clone of the underlying http_transport (for parent locations). This
533
# means we share the connection.
534
norm_base = urlutils.normalize_url(self.base)
535
norm_abs_url = urlutils.normalize_url(abs_url)
536
normalized_rel_url = urlutils.relative_url(norm_base, norm_abs_url)
537
if normalized_rel_url == ".." or normalized_rel_url.startswith("../"):
538
http_transport = self._http_transport.clone(normalized_rel_url)
540
http_transport = self._http_transport
541
576
return RemoteHTTPTransport(abs_url,
542
577
_from_transport=self,
543
http_transport=http_transport)
578
http_transport=self._http_transport)
580
def _redirected_to(self, source, target):
581
"""See transport._redirected_to"""
582
redirected = self._http_transport._redirected_to(source, target)
583
if (redirected is not None
584
and isinstance(redirected, type(self._http_transport))):
585
return RemoteHTTPTransport('bzr+' + redirected.external_url(),
586
http_transport=redirected)
588
# Either None or a transport for a different protocol
592
class HintingSSHTransport(transport.Transport):
593
"""Simple transport that handles ssh:// and points out bzr+ssh://."""
595
def __init__(self, url):
596
raise errors.UnsupportedProtocol(url,
597
'bzr supports bzr+ssh to operate over ssh, use "bzr+%s".' % url)
546
600
def get_test_permutations():
added
removed
bzrlib/transport/remote.py
