/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/remote.py

  • Committer: Robert Collins
  • Date: 2007-10-15 02:25:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2907.
  • Revision ID: robertc@robertcollins.net-20071015022537-37pczn78yq27f8yg
* New method ``bzrlib.repository.Repository.is_write_locked`` useful for
  determining if a repository is write locked. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/remote.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""RemoteTransport client for the smart-server.
18
18
 
23
23
__all__ = ['RemoteTransport', 'RemoteTCPTransport', 'RemoteSSHTransport']
24
24
 
25
25
from cStringIO import StringIO
 
26
import urllib
 
27
import urlparse
26
28
 
27
29
from bzrlib import (
28
30
    config,
29
31
    debug,
30
32
    errors,
31
 
    remote,
32
33
    trace,
33
34
    transport,
34
35
    urlutils,
35
36
    )
36
 
from bzrlib.smart import client, medium
37
 
from bzrlib.symbol_versioning import (
38
 
    deprecated_method,
39
 
    )
 
37
from bzrlib.smart import client, medium, protocol
 
38
 
 
39
# must do this otherwise urllib can't parse the urls properly :(
 
40
for scheme in ['ssh', 'bzr', 'bzr+loopback', 'bzr+ssh', 'bzr+http', 'bzr+https']:
 
41
    transport.register_urlparse_netloc_protocol(scheme)
 
42
del scheme
 
43
 
 
44
 
 
45
# Port 4155 is the default port for bzr://, registered with IANA.
 
46
BZR_DEFAULT_INTERFACE = '0.0.0.0'
 
47
BZR_DEFAULT_PORT = 4155
40
48
 
41
49
 
42
50
class _SmartStat(object):
54
62
 
55
63
    The connection has a notion of the current directory to which it's
56
64
    connected; this is incorporated in filenames passed to the server.
57
 
 
58
 
    This supports some higher-level RPC operations and can also be treated
 
65
    
 
66
    This supports some higher-level RPC operations and can also be treated 
59
67
    like a Transport to do file-like operations.
60
68
 
61
69
    The connection can be made over a tcp socket, an ssh pipe or a series of
63
71
    RemoteTCPTransport, etc.
64
72
    """
65
73
 
66
 
    # When making a readv request, cap it at requesting 5MB of data
67
 
    _max_readv_bytes = 5*1024*1024
68
 
 
69
74
    # IMPORTANT FOR IMPLEMENTORS: RemoteTransport MUST NOT be given encoding
70
75
    # responsibilities: Put those on SmartClient or similar. This is vital for
71
76
    # the ability to support multiple versions of the smart protocol over time:
72
 
    # RemoteTransport is an adapter from the Transport object model to the
 
77
    # RemoteTransport is an adapter from the Transport object model to the 
73
78
    # SmartClient model, not an encoder.
74
79
 
75
80
    # FIXME: the medium parameter should be private, only the tests requires
83
88
            one is being cloned from.  Attributes such as the medium will
84
89
            be reused.
85
90
 
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.
 
91
        :param medium: The medium to use for this RemoteTransport. This must be
 
92
            supplied if _from_transport is None.
90
93
 
91
94
        :param _client: Override the _SmartClient used by this transport.  This
92
95
            should only be used for testing purposes; normally this is
93
96
            determined from the medium.
94
97
        """
95
 
        super(RemoteTransport, self).__init__(
96
 
            url, _from_transport=_from_transport)
 
98
        super(RemoteTransport, self).__init__(url,
 
99
                                              _from_transport=_from_transport)
97
100
 
98
101
        # The medium is the connection, except when we need to share it with
99
102
        # other objects (RemoteBzrDir, RemoteRepository etc). In these cases
100
103
        # what we want to share is really the shared connection.
101
104
 
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
        if _from_transport is None:
106
106
            # If no _from_transport is specified, we need to intialize the
107
107
            # shared medium.
108
108
            credentials = None
112
112
                    trace.mutter('hpss: Built a new medium: %s',
113
113
                                 medium.__class__.__name__)
114
114
            self._shared_connection = transport._SharedConnection(medium,
115
 
                                                                  credentials,
116
 
                                                                  self.base)
117
 
        elif medium is None:
118
 
            # No medium was specified, so share the medium from the
119
 
            # _from_transport.
120
 
            medium = self._shared_connection.connection
121
 
        else:
122
 
            raise AssertionError(
123
 
                "Both _from_transport (%r) and medium (%r) passed to "
124
 
                "RemoteTransport.__init__, but these parameters are mutally "
125
 
                "exclusive." % (_from_transport, medium))
 
115
                                                                  credentials)
126
116
 
127
117
        if _client is None:
128
 
            self._client = client._SmartClient(medium)
 
118
            self._client = client._SmartClient(self.get_shared_medium())
129
119
        else:
130
120
            self._client = _client
131
121
 
138
128
        # No credentials
139
129
        return None, None
140
130
 
141
 
    def _report_activity(self, bytes, direction):
142
 
        """See Transport._report_activity.
143
 
 
144
 
        Does nothing; the smart medium will report activity triggered by a
145
 
        RemoteTransport.
146
 
        """
147
 
        pass
148
 
 
149
131
    def is_readonly(self):
150
132
        """Smart server transport can do read/write file operations."""
151
 
        try:
152
 
            resp = self._call2('Transport.is_readonly')
153
 
        except errors.UnknownSmartMethod:
 
133
        resp = self._call2('Transport.is_readonly')
 
134
        if resp == ('yes', ):
 
135
            return True
 
136
        elif resp == ('no', ):
 
137
            return False
 
138
        elif (resp == ('error', "Generic bzr smart protocol error: "
 
139
                                "bad request 'Transport.is_readonly'") or
 
140
              resp == ('error', "Generic bzr smart protocol error: "
 
141
                                "bad request u'Transport.is_readonly'")):
154
142
            # XXX: nasty hack: servers before 0.16 don't have a
155
143
            # 'Transport.is_readonly' verb, so we do what clients before 0.16
156
144
            # did: assume False.
157
145
            return False
158
 
        if resp == ('yes', ):
159
 
            return True
160
 
        elif resp == ('no', ):
161
 
            return False
162
146
        else:
163
 
            raise errors.UnexpectedSmartServerResponse(resp)
 
147
            self._translate_error(resp)
 
148
        raise errors.UnexpectedSmartServerResponse(resp)
164
149
 
165
150
    def get_smart_client(self):
166
151
        return self._get_connection()
168
153
    def get_smart_medium(self):
169
154
        return self._get_connection()
170
155
 
 
156
    def get_shared_medium(self):
 
157
        return self._get_shared_connection()
 
158
 
171
159
    def _remote_path(self, relpath):
172
160
        """Returns the Unicode version of the absolute path for relpath."""
173
161
        return self._combine_paths(self._path, relpath)
174
162
 
175
163
    def _call(self, method, *args):
176
164
        resp = self._call2(method, *args)
177
 
        self._ensure_ok(resp)
 
165
        self._translate_error(resp)
178
166
 
179
167
    def _call2(self, method, *args):
180
168
        """Call a method on the remote server."""
181
 
        try:
182
 
            return self._client.call(method, *args)
183
 
        except errors.ErrorFromSmartServer, err:
184
 
            # The first argument, if present, is always a path.
185
 
            if args:
186
 
                context = {'relpath': args[0]}
187
 
            else:
188
 
                context = {}
189
 
            self._translate_error(err, **context)
 
169
        return self._client.call(method, *args)
190
170
 
191
171
    def _call_with_body_bytes(self, method, args, body):
192
172
        """Call a method on the remote server with body bytes."""
193
 
        try:
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.
197
 
            if args:
198
 
                context = {'relpath': args[0]}
199
 
            else:
200
 
                context = {}
201
 
            self._translate_error(err, **context)
 
173
        return self._client.call_with_body_bytes(method, args, body)
202
174
 
203
175
    def has(self, relpath):
204
176
        """Indicate whether a remote file of the given name exists or not.
211
183
        elif resp == ('no', ):
212
184
            return False
213
185
        else:
214
 
            raise errors.UnexpectedSmartServerResponse(resp)
 
186
            self._translate_error(resp)
215
187
 
216
188
    def get(self, relpath):
217
189
        """Return file-like object reading the contents of a remote file.
218
 
 
 
190
        
219
191
        :see: Transport.get_bytes()/get_file()
220
192
        """
221
193
        return StringIO(self.get_bytes(relpath))
222
194
 
223
195
    def get_bytes(self, relpath):
224
196
        remote = self._remote_path(relpath)
225
 
        try:
226
 
            resp, response_handler = self._client.call_expecting_body('get', remote)
227
 
        except errors.ErrorFromSmartServer, err:
228
 
            self._translate_error(err, relpath)
 
197
        request = self.get_smart_medium().get_request()
 
198
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
 
199
        smart_protocol.call('get', remote)
 
200
        resp = smart_protocol.read_response_tuple(True)
229
201
        if resp != ('ok', ):
230
 
            response_handler.cancel_read_body()
231
 
            raise errors.UnexpectedSmartServerResponse(resp)
232
 
        return response_handler.read_body_bytes()
 
202
            smart_protocol.cancel_read_body()
 
203
            self._translate_error(resp, relpath)
 
204
        return smart_protocol.read_body_bytes()
233
205
 
234
206
    def _serialise_optional_mode(self, mode):
235
207
        if mode is None:
240
212
    def mkdir(self, relpath, mode=None):
241
213
        resp = self._call2('mkdir', self._remote_path(relpath),
242
214
            self._serialise_optional_mode(mode))
 
215
        self._translate_error(resp)
243
216
 
244
217
    def open_write_stream(self, relpath, mode=None):
245
218
        """See Transport.open_write_stream."""
261
234
        resp = self._call_with_body_bytes('put',
262
235
            (self._remote_path(relpath), self._serialise_optional_mode(mode)),
263
236
            upload_contents)
264
 
        self._ensure_ok(resp)
 
237
        self._translate_error(resp)
265
238
        return len(upload_contents)
266
239
 
267
240
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
278
251
            (self._remote_path(relpath), self._serialise_optional_mode(mode),
279
252
             create_parent_str, self._serialise_optional_mode(dir_mode)),
280
253
            bytes)
281
 
        self._ensure_ok(resp)
 
254
        self._translate_error(resp)
282
255
 
283
256
    def put_file(self, relpath, upload_file, mode=None):
284
257
        # its not ideal to seek back, but currently put_non_atomic_file depends
300
273
 
301
274
    def append_file(self, relpath, from_file, mode=None):
302
275
        return self.append_bytes(relpath, from_file.read(), mode)
303
 
 
 
276
        
304
277
    def append_bytes(self, relpath, bytes, mode=None):
305
278
        resp = self._call_with_body_bytes(
306
279
            'append',
308
281
            bytes)
309
282
        if resp[0] == 'appended':
310
283
            return int(resp[1])
311
 
        raise errors.UnexpectedSmartServerResponse(resp)
 
284
        self._translate_error(resp)
312
285
 
313
286
    def delete(self, relpath):
314
287
        resp = self._call2('delete', self._remote_path(relpath))
315
 
        self._ensure_ok(resp)
 
288
        self._translate_error(resp)
316
289
 
317
290
    def external_url(self):
318
291
        """See bzrlib.transport.Transport.external_url."""
319
292
        # the external path for RemoteTransports is the base
320
293
        return self.base
321
294
 
322
 
    def recommended_page_size(self):
323
 
        """Return the recommended page size for this transport."""
324
 
        return 64 * 1024
325
 
 
326
295
    def _readv(self, relpath, offsets):
327
296
        if not offsets:
328
297
            return
330
299
        offsets = list(offsets)
331
300
 
332
301
        sorted_offsets = sorted(offsets)
 
302
        # turn the list of offsets into a stack
 
303
        offset_stack = iter(offsets)
 
304
        cur_offset_and_size = offset_stack.next()
333
305
        coalesced = list(self._coalesce_offsets(sorted_offsets,
334
306
                               limit=self._max_readv_combine,
335
 
                               fudge_factor=self._bytes_to_read_before_seek,
336
 
                               max_size=self._max_readv_bytes))
337
 
 
338
 
        # now that we've coallesced things, avoid making enormous requests
339
 
        requests = []
340
 
        cur_request = []
341
 
        cur_len = 0
342
 
        for c in coalesced:
343
 
            if c.length + cur_len > self._max_readv_bytes:
344
 
                requests.append(cur_request)
345
 
                cur_request = [c]
346
 
                cur_len = c.length
347
 
                continue
348
 
            cur_request.append(c)
349
 
            cur_len += c.length
350
 
        if cur_request:
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)))
 
307
                               fudge_factor=self._bytes_to_read_before_seek))
 
308
 
 
309
        request = self.get_smart_medium().get_request()
 
310
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
 
311
        smart_protocol.call_with_body_readv_array(
 
312
            ('readv', self._remote_path(relpath)),
 
313
            [(c.start, c.length) for c in coalesced])
 
314
        resp = smart_protocol.read_response_tuple(True)
 
315
 
 
316
        if resp[0] != 'readv':
 
317
            # This should raise an exception
 
318
            smart_protocol.cancel_read_body()
 
319
            self._translate_error(resp)
 
320
            return
 
321
 
 
322
        # FIXME: this should know how many bytes are needed, for clarity.
 
323
        data = smart_protocol.read_body_bytes()
357
324
        # Cache the results, but only until they have been fulfilled
358
325
        data_map = {}
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:
364
 
            try:
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)
371
 
 
372
 
            if resp[0] != 'readv':
373
 
                # This should raise an exception
374
 
                response_handler.cancel_read_body()
375
 
                raise errors.UnexpectedSmartServerResponse(resp)
376
 
 
377
 
            for res in self._handle_response(offset_stack, cur_request,
378
 
                                             response_handler,
379
 
                                             data_map,
380
 
                                             next_offset):
381
 
                yield res
382
 
 
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()
388
 
        data_offset = 0
389
326
        for c_offset in coalesced:
390
327
            if len(data) < c_offset.length:
391
328
                raise errors.ShortReadvError(relpath, c_offset.start,
392
329
                            c_offset.length, actual=len(data))
393
330
            for suboffset, subsize in c_offset.ranges:
394
331
                key = (c_offset.start+suboffset, subsize)
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
400
 
                # in case.
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()
407
 
                else:
408
 
                    data_map[key] = this_data
409
 
            data_offset += c_offset.length
 
332
                data_map[key] = data[suboffset:suboffset+subsize]
 
333
            data = data[c_offset.length:]
410
334
 
411
335
            # Now that we've read some data, see if we can yield anything back
412
336
            while cur_offset_and_size in data_map:
413
337
                this_data = data_map.pop(cur_offset_and_size)
414
338
                yield cur_offset_and_size[0], this_data
415
 
                cur_offset_and_size = next_offset[0] = offset_stack.next()
 
339
                cur_offset_and_size = offset_stack.next()
416
340
 
417
341
    def rename(self, rel_from, rel_to):
418
342
        self._call('rename',
427
351
    def rmdir(self, relpath):
428
352
        resp = self._call('rmdir', self._remote_path(relpath))
429
353
 
430
 
    def _ensure_ok(self, resp):
431
 
        if resp[0] != 'ok':
432
 
            raise errors.UnexpectedSmartServerResponse(resp)
433
 
 
434
 
    def _translate_error(self, err, relpath=None):
435
 
        remote._translate_error(err, path=relpath)
 
354
    def _translate_error(self, resp, orig_path=None):
 
355
        """Raise an exception from a response"""
 
356
        if resp is None:
 
357
            what = None
 
358
        else:
 
359
            what = resp[0]
 
360
        if what == 'ok':
 
361
            return
 
362
        elif what == 'NoSuchFile':
 
363
            if orig_path is not None:
 
364
                error_path = orig_path
 
365
            else:
 
366
                error_path = resp[1]
 
367
            raise errors.NoSuchFile(error_path)
 
368
        elif what == 'error':
 
369
            raise errors.SmartProtocolError(unicode(resp[1]))
 
370
        elif what == 'FileExists':
 
371
            raise errors.FileExists(resp[1])
 
372
        elif what == 'DirectoryNotEmpty':
 
373
            raise errors.DirectoryNotEmpty(resp[1])
 
374
        elif what == 'ShortReadvError':
 
375
            raise errors.ShortReadvError(resp[1], int(resp[2]),
 
376
                                         int(resp[3]), int(resp[4]))
 
377
        elif what in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
378
            encoding = str(resp[1]) # encoding must always be a string
 
379
            val = resp[2]
 
380
            start = int(resp[3])
 
381
            end = int(resp[4])
 
382
            reason = str(resp[5]) # reason must always be a string
 
383
            if val.startswith('u:'):
 
384
                val = val[2:].decode('utf-8')
 
385
            elif val.startswith('s:'):
 
386
                val = val[2:].decode('base64')
 
387
            if what == 'UnicodeDecodeError':
 
388
                raise UnicodeDecodeError(encoding, val, start, end, reason)
 
389
            elif what == 'UnicodeEncodeError':
 
390
                raise UnicodeEncodeError(encoding, val, start, end, reason)
 
391
        elif what == "ReadOnlyError":
 
392
            raise errors.TransportNotPossible('readonly transport')
 
393
        elif what == "ReadError":
 
394
            if orig_path is not None:
 
395
                error_path = orig_path
 
396
            else:
 
397
                error_path = resp[1]
 
398
            raise errors.ReadError(error_path)
 
399
        else:
 
400
            raise errors.SmartProtocolError('unexpected smart server error: %r' % (resp,))
436
401
 
437
402
    def disconnect(self):
438
403
        self.get_smart_medium().disconnect()
439
404
 
 
405
    def delete_tree(self, relpath):
 
406
        raise errors.TransportNotPossible('readonly transport')
 
407
 
440
408
    def stat(self, relpath):
441
409
        resp = self._call2('stat', self._remote_path(relpath))
442
410
        if resp[0] == 'stat':
443
411
            return _SmartStat(int(resp[1]), int(resp[2], 8))
444
 
        raise errors.UnexpectedSmartServerResponse(resp)
 
412
        else:
 
413
            self._translate_error(resp)
445
414
 
446
415
    ## def lock_read(self, relpath):
447
416
    ##     """Lock the given file for shared (read) access.
463
432
        resp = self._call2('list_dir', self._remote_path(relpath))
464
433
        if resp[0] == 'names':
465
434
            return [name.encode('ascii') for name in resp[1:]]
466
 
        raise errors.UnexpectedSmartServerResponse(resp)
 
435
        else:
 
436
            self._translate_error(resp)
467
437
 
468
438
    def iter_files_recursive(self):
469
439
        resp = self._call2('iter_files_recursive', self._remote_path(''))
470
440
        if resp[0] == 'names':
471
441
            return resp[1:]
472
 
        raise errors.UnexpectedSmartServerResponse(resp)
 
442
        else:
 
443
            self._translate_error(resp)
473
444
 
474
445
 
475
446
class RemoteTCPTransport(RemoteTransport):
476
447
    """Connection to smart server over plain tcp.
477
 
 
 
448
    
478
449
    This is essentially just a factory to get 'RemoteTransport(url,
479
450
        SmartTCPClientMedium).
480
451
    """
481
452
 
482
453
    def _build_medium(self):
483
 
        client_medium = medium.SmartTCPClientMedium(
484
 
            self._host, self._port, self.base)
485
 
        return client_medium, None
486
 
 
487
 
 
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.
491
 
 
492
 
    This should only be used for testing.
493
 
    """
494
 
 
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
 
454
        assert self.base.startswith('bzr://')
 
455
        return medium.SmartTCPClientMedium(self._host, self._port), None
501
456
 
502
457
 
503
458
class RemoteSSHTransport(RemoteTransport):
508
463
    """
509
464
 
510
465
    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
 
469
        # stored.
511
470
        location_config = config.LocationConfig(self.base)
512
471
        bzr_remote_path = location_config.get_bzr_remote_path()
513
 
        user = self._user
514
 
        if user is None:
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)
 
472
        return medium.SmartSSHClientMedium(self._host, self._port,
 
473
            self._user, self._password, bzr_remote_path=bzr_remote_path), None
521
474
 
522
475
 
523
476
class RemoteHTTPTransport(RemoteTransport):
524
477
    """Just a way to connect between a bzr+http:// url and http://.
525
 
 
 
478
    
526
479
    This connection operates slightly differently than the RemoteSSHTransport.
527
480
    It uses a plain http:// transport underneath, which defines what remote
528
481
    .bzr/smart URL we are connected to. From there, all paths that are sent are
532
485
    """
533
486
 
534
487
    def __init__(self, base, _from_transport=None, http_transport=None):
 
488
        assert ( base.startswith('bzr+http://') or base.startswith('bzr+https://') )
 
489
 
535
490
        if http_transport is None:
536
491
            # FIXME: the password may be lost here because it appears in the
537
492
            # url only for an intial construction (when the url came from the
551
506
        """After connecting, HTTP Transport only deals in relative URLs."""
552
507
        # Adjust the relpath based on which URL this smart transport is
553
508
        # connected to.
554
 
        http_base = urlutils.normalize_url(self.get_smart_medium().base)
 
509
        http_base = urlutils.normalize_url(self._http_transport.base)
555
510
        url = urlutils.join(self.base[len('bzr+'):], relpath)
556
511
        url = urlutils.normalize_url(url)
557
512
        return urlutils.relative_url(http_base, url)
568
523
        smart requests may be different).  This is so that the server doesn't
569
524
        have to handle .bzr/smart requests at arbitrary places inside .bzr
570
525
        directories, just at the initial URL the user uses.
 
526
 
 
527
        The exception is parent paths (i.e. relative_url of "..").
571
528
        """
572
529
        if relative_url:
573
530
            abs_url = self.abspath(relative_url)
574
531
        else:
575
532
            abs_url = self.base
 
533
        # We either use the exact same http_transport (for child locations), or
 
534
        # a clone of the underlying http_transport (for parent locations).  This
 
535
        # means we share the connection.
 
536
        norm_base = urlutils.normalize_url(self.base)
 
537
        norm_abs_url = urlutils.normalize_url(abs_url)
 
538
        normalized_rel_url = urlutils.relative_url(norm_base, norm_abs_url)
 
539
        if normalized_rel_url == ".." or normalized_rel_url.startswith("../"):
 
540
            http_transport = self._http_transport.clone(normalized_rel_url)
 
541
        else:
 
542
            http_transport = self._http_transport
576
543
        return RemoteHTTPTransport(abs_url,
577
544
                                   _from_transport=self,
578
 
                                   http_transport=self._http_transport)
579
 
 
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)
587
 
        else:
588
 
            # Either None or a transport for a different protocol
589
 
            return redirected
590
 
 
591
 
 
592
 
class HintingSSHTransport(transport.Transport):
593
 
    """Simple transport that handles ssh:// and points out bzr+ssh://."""
594
 
 
595
 
    def __init__(self, url):
596
 
        raise errors.UnsupportedProtocol(url,
597
 
            'bzr supports bzr+ssh to operate over ssh, use "bzr+%s".' % url)
 
545
                                   http_transport=http_transport)
598
546
 
599
547
 
600
548
def get_test_permutations():
601
549
    """Return (transport, server) permutations for testing."""
602
550
    ### We may need a little more test framework support to construct an
603
551
    ### appropriate RemoteTransport in the future.
604
 
    from bzrlib.tests import test_server
605
 
    return [(RemoteTCPTransport, test_server.SmartTCPServer_for_testing)]
 
552
    from bzrlib.smart import server
 
553
    return [(RemoteTCPTransport, server.SmartTCPServer_for_testing)]