/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 breezy/transport/remote.py

Support user.signingkey configuration variable in .git/config.

Merged from https://code.launchpad.net/~jelmer/brz/local-git-key/+merge/381000

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transport/remote.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""RemoteTransport client for the smart-server.
18
18
 
19
19
This module shouldn't be accessed directly.  The classes defined here should be
20
 
imported from bzrlib.smart.
 
20
imported from breezy.bzr.smart.
21
21
"""
22
22
 
 
23
from __future__ import absolute_import
 
24
 
23
25
__all__ = ['RemoteTransport', 'RemoteTCPTransport', 'RemoteSSHTransport']
24
26
 
25
 
from cStringIO import StringIO
 
27
from io import BytesIO
26
28
 
27
 
from bzrlib import (
 
29
from .. 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,
 
37
from ..bzr import (
 
38
    remote,
39
39
    )
 
40
from ..sixish import PY3
 
41
from ..bzr.smart import client, medium
40
42
 
41
43
 
42
44
class _SmartStat(object):
64
66
    """
65
67
 
66
68
    # When making a readv request, cap it at requesting 5MB of data
67
 
    _max_readv_bytes = 5*1024*1024
 
69
    _max_readv_bytes = 5 * 1024 * 1024
68
70
 
69
71
    # IMPORTANT FOR IMPLEMENTORS: RemoteTransport MUST NOT be given encoding
70
72
    # responsibilities: Put those on SmartClient or similar. This is vital for
100
102
        # what we want to share is really the shared connection.
101
103
 
102
104
        if (_from_transport is not None
103
 
            and isinstance(_from_transport, RemoteTransport)):
 
105
                and isinstance(_from_transport, RemoteTransport)):
104
106
            _client = _from_transport._client
105
107
        elif _from_transport is None:
106
108
            # If no _from_transport is specified, we need to intialize the
149
151
    def is_readonly(self):
150
152
        """Smart server transport can do read/write file operations."""
151
153
        try:
152
 
            resp = self._call2('Transport.is_readonly')
 
154
            resp = self._call2(b'Transport.is_readonly')
153
155
        except errors.UnknownSmartMethod:
154
156
            # XXX: nasty hack: servers before 0.16 don't have a
155
157
            # 'Transport.is_readonly' verb, so we do what clients before 0.16
156
158
            # did: assume False.
157
159
            return False
158
 
        if resp == ('yes', ):
 
160
        if resp == (b'yes', ):
159
161
            return True
160
 
        elif resp == ('no', ):
 
162
        elif resp == (b'no', ):
161
163
            return False
162
164
        else:
163
165
            raise errors.UnexpectedSmartServerResponse(resp)
170
172
 
171
173
    def _remote_path(self, relpath):
172
174
        """Returns the Unicode version of the absolute path for relpath."""
173
 
        return self._combine_paths(self._path, relpath)
 
175
        path = urlutils.URL._combine_paths(self._parsed_url.path, relpath)
 
176
        if not isinstance(path, bytes):
 
177
            path = path.encode()
 
178
        return path
174
179
 
175
180
    def _call(self, method, *args):
176
181
        resp = self._call2(method, *args)
180
185
        """Call a method on the remote server."""
181
186
        try:
182
187
            return self._client.call(method, *args)
183
 
        except errors.ErrorFromSmartServer, err:
 
188
        except errors.ErrorFromSmartServer as err:
184
189
            # The first argument, if present, is always a path.
185
190
            if args:
186
 
                context = {'relpath': args[0]}
 
191
                context = {'relpath': args[0].decode('utf-8')}
187
192
            else:
188
193
                context = {}
189
194
            self._translate_error(err, **context)
192
197
        """Call a method on the remote server with body bytes."""
193
198
        try:
194
199
            return self._client.call_with_body_bytes(method, args, body)
195
 
        except errors.ErrorFromSmartServer, err:
 
200
        except errors.ErrorFromSmartServer as err:
196
201
            # The first argument, if present, is always a path.
197
202
            if args:
198
203
                context = {'relpath': args[0]}
205
210
 
206
211
        :see: Transport.has()
207
212
        """
208
 
        resp = self._call2('has', self._remote_path(relpath))
209
 
        if resp == ('yes', ):
 
213
        resp = self._call2(b'has', self._remote_path(relpath))
 
214
        if resp == (b'yes', ):
210
215
            return True
211
 
        elif resp == ('no', ):
 
216
        elif resp == (b'no', ):
212
217
            return False
213
218
        else:
214
219
            raise errors.UnexpectedSmartServerResponse(resp)
218
223
 
219
224
        :see: Transport.get_bytes()/get_file()
220
225
        """
221
 
        return StringIO(self.get_bytes(relpath))
 
226
        return BytesIO(self.get_bytes(relpath))
222
227
 
223
228
    def get_bytes(self, relpath):
224
229
        remote = self._remote_path(relpath)
225
230
        try:
226
 
            resp, response_handler = self._client.call_expecting_body('get', remote)
227
 
        except errors.ErrorFromSmartServer, err:
 
231
            resp, response_handler = self._client.call_expecting_body(
 
232
                b'get', remote)
 
233
        except errors.ErrorFromSmartServer as err:
228
234
            self._translate_error(err, relpath)
229
 
        if resp != ('ok', ):
 
235
        if resp != (b'ok', ):
230
236
            response_handler.cancel_read_body()
231
237
            raise errors.UnexpectedSmartServerResponse(resp)
232
238
        return response_handler.read_body_bytes()
233
239
 
234
240
    def _serialise_optional_mode(self, mode):
235
241
        if mode is None:
236
 
            return ''
 
242
            return b''
237
243
        else:
238
 
            return '%d' % mode
 
244
            return ('%d' % mode).encode('ascii')
239
245
 
240
246
    def mkdir(self, relpath, mode=None):
241
 
        resp = self._call2('mkdir', self._remote_path(relpath),
242
 
            self._serialise_optional_mode(mode))
 
247
        resp = self._call2(b'mkdir', self._remote_path(relpath),
 
248
                           self._serialise_optional_mode(mode))
243
249
 
244
250
    def open_write_stream(self, relpath, mode=None):
245
251
        """See Transport.open_write_stream."""
246
 
        self.put_bytes(relpath, "", mode)
 
252
        self.put_bytes(relpath, b"", mode)
247
253
        result = transport.AppendBasedFileStream(self, relpath)
248
254
        transport._file_streams[self.abspath(relpath)] = result
249
255
        return result
250
256
 
251
 
    def put_bytes(self, relpath, upload_contents, mode=None):
252
 
        # FIXME: upload_file is probably not safe for non-ascii characters -
253
 
        # should probably just pass all parameters as length-delimited
254
 
        # strings?
255
 
        if type(upload_contents) is unicode:
256
 
            # Although not strictly correct, we raise UnicodeEncodeError to be
257
 
            # compatible with other transports.
258
 
            raise UnicodeEncodeError(
259
 
                'undefined', upload_contents, 0, 1,
260
 
                'put_bytes must be given bytes, not unicode.')
261
 
        resp = self._call_with_body_bytes('put',
 
257
    def put_bytes(self, relpath, raw_bytes, mode=None):
 
258
        if not isinstance(raw_bytes, bytes):
 
259
            raise TypeError(
 
260
                'raw_bytes must be bytes string, not %s' % type(raw_bytes))
 
261
        resp = self._call_with_body_bytes(
 
262
            b'put',
262
263
            (self._remote_path(relpath), self._serialise_optional_mode(mode)),
263
 
            upload_contents)
 
264
            raw_bytes)
264
265
        self._ensure_ok(resp)
265
 
        return len(upload_contents)
 
266
        return len(raw_bytes)
266
267
 
267
 
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
 
268
    def put_bytes_non_atomic(self, relpath, raw_bytes, mode=None,
268
269
                             create_parent_dir=False,
269
270
                             dir_mode=None):
270
271
        """See Transport.put_bytes_non_atomic."""
271
272
        # FIXME: no encoding in the transport!
272
 
        create_parent_str = 'F'
 
273
        create_parent_str = b'F'
273
274
        if create_parent_dir:
274
 
            create_parent_str = 'T'
 
275
            create_parent_str = b'T'
275
276
 
276
277
        resp = self._call_with_body_bytes(
277
 
            'put_non_atomic',
 
278
            b'put_non_atomic',
278
279
            (self._remote_path(relpath), self._serialise_optional_mode(mode),
279
280
             create_parent_str, self._serialise_optional_mode(dir_mode)),
280
 
            bytes)
 
281
            raw_bytes)
281
282
        self._ensure_ok(resp)
282
283
 
283
284
    def put_file(self, relpath, upload_file, mode=None):
303
304
 
304
305
    def append_bytes(self, relpath, bytes, mode=None):
305
306
        resp = self._call_with_body_bytes(
306
 
            'append',
 
307
            b'append',
307
308
            (self._remote_path(relpath), self._serialise_optional_mode(mode)),
308
309
            bytes)
309
 
        if resp[0] == 'appended':
 
310
        if resp[0] == b'appended':
310
311
            return int(resp[1])
311
312
        raise errors.UnexpectedSmartServerResponse(resp)
312
313
 
313
314
    def delete(self, relpath):
314
 
        resp = self._call2('delete', self._remote_path(relpath))
 
315
        resp = self._call2(b'delete', self._remote_path(relpath))
315
316
        self._ensure_ok(resp)
316
317
 
317
318
    def external_url(self):
318
 
        """See bzrlib.transport.Transport.external_url."""
 
319
        """See breezy.transport.Transport.external_url."""
319
320
        # the external path for RemoteTransports is the base
320
321
        return self.base
321
322
 
331
332
 
332
333
        sorted_offsets = sorted(offsets)
333
334
        coalesced = list(self._coalesce_offsets(sorted_offsets,
334
 
                               limit=self._max_readv_combine,
335
 
                               fudge_factor=self._bytes_to_read_before_seek,
336
 
                               max_size=self._max_readv_bytes))
 
335
                                                limit=self._max_readv_combine,
 
336
                                                fudge_factor=self._bytes_to_read_before_seek,
 
337
                                                max_size=self._max_readv_bytes))
337
338
 
338
339
        # now that we've coallesced things, avoid making enormous requests
339
340
        requests = []
359
360
        # turn the list of offsets into a single stack to iterate
360
361
        offset_stack = iter(offsets)
361
362
        # using a list so it can be modified when passing down and coming back
362
 
        next_offset = [offset_stack.next()]
 
363
        next_offset = [next(offset_stack)]
363
364
        for cur_request in requests:
364
365
            try:
365
366
                result = self._client.call_with_body_readv_array(
366
 
                    ('readv', self._remote_path(relpath),),
 
367
                    (b'readv', self._remote_path(relpath),),
367
368
                    [(c.start, c.length) for c in cur_request])
368
369
                resp, response_handler = result
369
 
            except errors.ErrorFromSmartServer, err:
 
370
            except errors.ErrorFromSmartServer as err:
370
371
                self._translate_error(err, relpath)
371
372
 
372
 
            if resp[0] != 'readv':
 
373
            if resp[0] != b'readv':
373
374
                # This should raise an exception
374
375
                response_handler.cancel_read_body()
375
376
                raise errors.UnexpectedSmartServerResponse(resp)
389
390
        for c_offset in coalesced:
390
391
            if len(data) < c_offset.length:
391
392
                raise errors.ShortReadvError(relpath, c_offset.start,
392
 
                            c_offset.length, actual=len(data))
 
393
                                             c_offset.length, actual=len(data))
393
394
            for suboffset, subsize in c_offset.ranges:
394
 
                key = (c_offset.start+suboffset, subsize)
395
 
                this_data = data[data_offset+suboffset:
396
 
                                 data_offset+suboffset+subsize]
 
395
                key = (c_offset.start + suboffset, subsize)
 
396
                this_data = data[data_offset + suboffset:
 
397
                                 data_offset + suboffset + subsize]
397
398
                # Special case when the data is in-order, rather than packing
398
399
                # into a map and then back out again. Benchmarking shows that
399
400
                # this has 100% hit rate, but leave in the data_map work just
403
404
                #       not have a real string.
404
405
                if key == cur_offset_and_size:
405
406
                    yield cur_offset_and_size[0], this_data
406
 
                    cur_offset_and_size = next_offset[0] = offset_stack.next()
 
407
                    try:
 
408
                        cur_offset_and_size = next_offset[0] = next(
 
409
                            offset_stack)
 
410
                    except StopIteration:
 
411
                        return
407
412
                else:
408
413
                    data_map[key] = this_data
409
414
            data_offset += c_offset.length
412
417
            while cur_offset_and_size in data_map:
413
418
                this_data = data_map.pop(cur_offset_and_size)
414
419
                yield cur_offset_and_size[0], this_data
415
 
                cur_offset_and_size = next_offset[0] = offset_stack.next()
 
420
                try:
 
421
                    cur_offset_and_size = next_offset[0] = next(offset_stack)
 
422
                except StopIteration:
 
423
                    return
416
424
 
417
425
    def rename(self, rel_from, rel_to):
418
 
        self._call('rename',
 
426
        self._call(b'rename',
419
427
                   self._remote_path(rel_from),
420
428
                   self._remote_path(rel_to))
421
429
 
422
430
    def move(self, rel_from, rel_to):
423
 
        self._call('move',
 
431
        self._call(b'move',
424
432
                   self._remote_path(rel_from),
425
433
                   self._remote_path(rel_to))
426
434
 
427
435
    def rmdir(self, relpath):
428
 
        resp = self._call('rmdir', self._remote_path(relpath))
 
436
        resp = self._call(b'rmdir', self._remote_path(relpath))
429
437
 
430
438
    def _ensure_ok(self, resp):
431
 
        if resp[0] != 'ok':
 
439
        if resp[0] != b'ok':
432
440
            raise errors.UnexpectedSmartServerResponse(resp)
433
441
 
434
442
    def _translate_error(self, err, relpath=None):
435
443
        remote._translate_error(err, path=relpath)
436
444
 
437
445
    def disconnect(self):
438
 
        self.get_smart_medium().disconnect()
 
446
        m = self.get_smart_medium()
 
447
        if m is not None:
 
448
            m.disconnect()
439
449
 
440
450
    def stat(self, relpath):
441
 
        resp = self._call2('stat', self._remote_path(relpath))
442
 
        if resp[0] == 'stat':
 
451
        resp = self._call2(b'stat', self._remote_path(relpath))
 
452
        if resp[0] == b'stat':
443
453
            return _SmartStat(int(resp[1]), int(resp[2], 8))
444
454
        raise errors.UnexpectedSmartServerResponse(resp)
445
455
 
446
 
    ## def lock_read(self, relpath):
447
 
    ##     """Lock the given file for shared (read) access.
448
 
    ##     :return: A lock object, which should be passed to Transport.unlock()
449
 
    ##     """
450
 
    ##     # The old RemoteBranch ignore lock for reading, so we will
451
 
    ##     # continue that tradition and return a bogus lock object.
452
 
    ##     class BogusLock(object):
453
 
    ##         def __init__(self, path):
 
456
    # def lock_read(self, relpath):
 
457
    # """Lock the given file for shared (read) access.
 
458
    # :return: A lock object, which should be passed to Transport.unlock()
 
459
    # """
 
460
    # The old RemoteBranch ignore lock for reading, so we will
 
461
    # continue that tradition and return a bogus lock object.
 
462
    # class BogusLock(object):
 
463
    # def __init__(self, path):
454
464
    ##             self.path = path
455
 
    ##         def unlock(self):
456
 
    ##             pass
457
 
    ##     return BogusLock(relpath)
 
465
    # def unlock(self):
 
466
    # pass
 
467
    # return BogusLock(relpath)
458
468
 
459
469
    def listable(self):
460
470
        return True
461
471
 
462
472
    def list_dir(self, relpath):
463
 
        resp = self._call2('list_dir', self._remote_path(relpath))
464
 
        if resp[0] == 'names':
465
 
            return [name.encode('ascii') for name in resp[1:]]
 
473
        resp = self._call2(b'list_dir', self._remote_path(relpath))
 
474
        if resp[0] == b'names':
 
475
            return [name.decode('utf-8') if PY3 else name for name in resp[1:]]
466
476
        raise errors.UnexpectedSmartServerResponse(resp)
467
477
 
468
478
    def iter_files_recursive(self):
469
 
        resp = self._call2('iter_files_recursive', self._remote_path(''))
470
 
        if resp[0] == 'names':
471
 
            return resp[1:]
 
479
        resp = self._call2(b'iter_files_recursive', self._remote_path(''))
 
480
        if resp[0] == b'names':
 
481
            return [name.decode('utf-8') if PY3 else name for name in resp[1:]]
472
482
        raise errors.UnexpectedSmartServerResponse(resp)
473
483
 
474
484
 
481
491
 
482
492
    def _build_medium(self):
483
493
        client_medium = medium.SmartTCPClientMedium(
484
 
            self._host, self._port, self.base)
 
494
            self._parsed_url.host, self._parsed_url.port, self.base)
485
495
        return client_medium, None
486
496
 
487
497
 
494
504
 
495
505
    def _build_medium(self):
496
506
        client_medium = medium.SmartTCPClientMedium(
497
 
            self._host, self._port, self.base)
 
507
            self._parsed_url.host, self._parsed_url.port, self.base)
498
508
        client_medium._protocol_version = 2
499
509
        client_medium._remember_remote_is_before((1, 6))
500
510
        return client_medium, None
510
520
    def _build_medium(self):
511
521
        location_config = config.LocationConfig(self.base)
512
522
        bzr_remote_path = location_config.get_bzr_remote_path()
513
 
        user = self._user
 
523
        user = self._parsed_url.user
514
524
        if user is None:
515
525
            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)
 
526
            user = auth.get_user('ssh', self._parsed_url.host,
 
527
                                 self._parsed_url.port)
 
528
        ssh_params = medium.SSHParams(self._parsed_url.host,
 
529
                                      self._parsed_url.port, user, self._parsed_url.password,
 
530
                                      bzr_remote_path)
 
531
        client_medium = medium.SmartSSHClientMedium(self.base, ssh_params)
 
532
        return client_medium, (user, self._parsed_url.password)
521
533
 
522
534
 
523
535
class RemoteHTTPTransport(RemoteTransport):
537
549
            # url only for an intial construction (when the url came from the
538
550
            # command-line).
539
551
            http_url = base[len('bzr+'):]
540
 
            self._http_transport = transport.get_transport(http_url)
 
552
            self._http_transport = transport.get_transport_from_url(http_url)
541
553
        else:
542
554
            self._http_transport = http_transport
543
555
        super(RemoteHTTPTransport, self).__init__(
581
593
        """See transport._redirected_to"""
582
594
        redirected = self._http_transport._redirected_to(source, target)
583
595
        if (redirected is not None
584
 
            and isinstance(redirected, type(self._http_transport))):
 
596
                and isinstance(redirected, type(self._http_transport))):
585
597
            return RemoteHTTPTransport('bzr+' + redirected.external_url(),
586
598
                                       http_transport=redirected)
587
599
        else:
590
602
 
591
603
 
592
604
class HintingSSHTransport(transport.Transport):
593
 
    """Simple transport that handles ssh:// and points out bzr+ssh://."""
 
605
    """Simple transport that handles ssh:// and points out bzr+ssh:// and git+ssh://."""
 
606
 
 
607
    # TODO(jelmer): Implement support for detecting whether the repository at the
 
608
    # other end is a git or bzr repository.
594
609
 
595
610
    def __init__(self, url):
596
 
        raise errors.UnsupportedProtocol(url,
597
 
            'bzr supports bzr+ssh to operate over ssh, use "bzr+%s".' % url)
 
611
        raise errors.UnsupportedProtocol(
 
612
            url, 'Use bzr+ssh for Bazaar operations over SSH, e.g. "bzr+%s". '
 
613
            'Use git+ssh for Git operations over SSH, e.g. "git+%s".' % (url, url))
598
614
 
599
615
 
600
616
def get_test_permutations():
601
617
    """Return (transport, server) permutations for testing."""
602
 
    ### We may need a little more test framework support to construct an
603
 
    ### appropriate RemoteTransport in the future.
604
 
    from bzrlib.tests import test_server
 
618
    # We may need a little more test framework support to construct an
 
619
    # appropriate RemoteTransport in the future.
 
620
    from ..tests import test_server
605
621
    return [(RemoteTCPTransport, test_server.SmartTCPServer_for_testing)]