/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
19
19
import bz2
20
20
import zlib
21
21
 
22
 
from bzrlib import (
 
22
from . import (
23
23
    bencode,
24
24
    branch,
25
25
    bzrdir as _mod_bzrdir,
43
43
    vf_repository,
44
44
    vf_search,
45
45
    )
46
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
47
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
48
 
from bzrlib.errors import (
 
46
from .branch import BranchReferenceFormat, BranchWriteLockResult
 
47
from .decorators import needs_read_lock, needs_write_lock, only_raises
 
48
from .errors import (
49
49
    NoSuchRevision,
50
50
    SmartProtocolError,
51
51
    )
52
 
from bzrlib.i18n import gettext
53
 
from bzrlib.inventory import Inventory
54
 
from bzrlib.lockable_files import LockableFiles
55
 
from bzrlib.smart import client, vfs, repository as smart_repo
56
 
from bzrlib.smart.client import _SmartClient
57
 
from bzrlib.revision import NULL_REVISION
58
 
from bzrlib.revisiontree import InventoryRevisionTree
59
 
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
60
 
from bzrlib.serializer import format_registry as serializer_format_registry
61
 
from bzrlib.trace import mutter, note, warning, log_exception_quietly
62
 
from bzrlib.versionedfile import FulltextContentFactory
 
52
from .i18n import gettext
 
53
from .inventory import Inventory
 
54
from .lockable_files import LockableFiles
 
55
from .smart import client, vfs, repository as smart_repo
 
56
from .smart.client import _SmartClient
 
57
from .revision import NULL_REVISION
 
58
from .revisiontree import InventoryRevisionTree
 
59
from .repository import RepositoryWriteLockResult, _LazyListJoin
 
60
from .serializer import format_registry as serializer_format_registry
 
61
from .trace import mutter, note, warning, log_exception_quietly
 
62
from .versionedfile import FulltextContentFactory
63
63
 
64
64
 
65
65
_DEFAULT_SEARCH_DEPTH = 100
71
71
    def _call(self, method, *args, **err_context):
72
72
        try:
73
73
            return self._client.call(method, *args)
74
 
        except errors.ErrorFromSmartServer, err:
 
74
        except errors.ErrorFromSmartServer as err:
75
75
            self._translate_error(err, **err_context)
76
76
 
77
77
    def _call_expecting_body(self, method, *args, **err_context):
78
78
        try:
79
79
            return self._client.call_expecting_body(method, *args)
80
 
        except errors.ErrorFromSmartServer, err:
 
80
        except errors.ErrorFromSmartServer as err:
81
81
            self._translate_error(err, **err_context)
82
82
 
83
83
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
84
84
        try:
85
85
            return self._client.call_with_body_bytes(method, args, body_bytes)
86
 
        except errors.ErrorFromSmartServer, err:
 
86
        except errors.ErrorFromSmartServer as err:
87
87
            self._translate_error(err, **err_context)
88
88
 
89
89
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
91
91
        try:
92
92
            return self._client.call_with_body_bytes_expecting_body(
93
93
                method, args, body_bytes)
94
 
        except errors.ErrorFromSmartServer, err:
 
94
        except errors.ErrorFromSmartServer as err:
95
95
            self._translate_error(err, **err_context)
96
96
 
97
97
 
105
105
    return format
106
106
 
107
107
 
108
 
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
108
# Note that RemoteBzrDirProber lives in breezy.bzrdir so breezy.remote
109
109
# does not have to be imported unless a remote format is involved.
110
110
 
111
111
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
159
159
        path = client.remote_path_from_transport(transport)
160
160
        try:
161
161
            response = client.call('BzrDirFormat.initialize', path)
162
 
        except errors.ErrorFromSmartServer, err:
 
162
        except errors.ErrorFromSmartServer as err:
163
163
            _translate_error(err, path=path)
164
164
        if response[0] != 'ok':
165
165
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
265
265
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
266
266
                make_working_trees=make_working_trees, shared_repo=shared_repo,
267
267
                vfs_only=True)
268
 
        except errors.ErrorFromSmartServer, err:
 
268
        except errors.ErrorFromSmartServer as err:
269
269
            _translate_error(err, path=path)
270
270
        repo_path = response[0]
271
271
        bzrdir_name = response[6]
558
558
        except errors.UnknownSmartMethod:
559
559
            medium._remember_remote_is_before((1, 13))
560
560
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
561
 
        except errors.UnknownErrorFromSmartServer, err:
 
561
        except errors.UnknownErrorFromSmartServer as err:
562
562
            if err.error_tuple != ('BranchReference',):
563
563
                raise
564
564
            # We need to resolve the branch reference to determine the
1050
1050
        elif self._network_name:
1051
1051
            network_name = self._network_name
1052
1052
        else:
1053
 
            # Select the current bzrlib default and ask for that.
 
1053
            # Select the current breezy default and ask for that.
1054
1054
            reference_bzrdir_format = controldir.format_registry.get('default')()
1055
1055
            reference_format = reference_bzrdir_format.repository_format
1056
1056
            network_name = reference_format.network_name()
1219
1219
        try:
1220
1220
            response = self._call('Repository.abort_write_group', path,
1221
1221
                self._lock_token, self._write_group_tokens)
1222
 
        except Exception, exc:
 
1222
        except Exception as exc:
1223
1223
            self._write_group = None
1224
1224
            if not suppress_errors:
1225
1225
                raise
1408
1408
    @needs_read_lock
1409
1409
    def has_revision(self, revision_id):
1410
1410
        """True if this repository has a copy of the revision."""
1411
 
        # Copy of bzrlib.repository.Repository.has_revision
 
1411
        # Copy of breezy.repository.Repository.has_revision
1412
1412
        return revision_id in self.has_revisions((revision_id,))
1413
1413
 
1414
1414
    @needs_read_lock
1418
1418
        :param revision_ids: An iterable of revision_ids.
1419
1419
        :return: A set of the revision_ids that were present.
1420
1420
        """
1421
 
        # Copy of bzrlib.repository.Repository.has_revisions
 
1421
        # Copy of breezy.repository.Repository.has_revisions
1422
1422
        parent_map = self.get_parent_map(revision_ids)
1423
1423
        result = set(parent_map)
1424
1424
        if _mod_revision.NULL_REVISION in revision_ids:
1486
1486
                result[key] = int(val_text)
1487
1487
            elif key in ('firstrev', 'latestrev'):
1488
1488
                values = val_text.split(' ')[1:]
1489
 
                result[key] = (float(values[0]), long(values[1]))
 
1489
                result[key] = (float(values[0]), int(values[1]))
1490
1490
 
1491
1491
        return result
1492
1492
 
1540
1540
    def lock_read(self):
1541
1541
        """Lock the repository for read operations.
1542
1542
 
1543
 
        :return: A bzrlib.lock.LogicalLockResult.
 
1543
        :return: A breezy.lock.LogicalLockResult.
1544
1544
        """
1545
1545
        # wrong eventually - want a local lock cache context
1546
1546
        if not self._lock_mode:
2075
2075
        This method is intended to be called after another repository instance
2076
2076
        (such as one used by a smart server) has inserted data into the
2077
2077
        repository. On all repositories this will work outside of write groups.
2078
 
        Some repository formats (pack and newer for bzrlib native formats)
 
2078
        Some repository formats (pack and newer for breezy native formats)
2079
2079
        support refresh_data inside write groups. If called inside a write
2080
2080
        group on a repository that does not support refreshing in a write group
2081
2081
        IsInWriteGroupError will be raised.
2245
2245
                yield identifier, bytes_iterator
2246
2246
 
2247
2247
    def get_cached_parent_map(self, revision_ids):
2248
 
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2248
        """See breezy.CachingParentsProvider.get_cached_parent_map"""
2249
2249
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
2250
2250
 
2251
2251
    def get_parent_map(self, revision_ids):
2252
 
        """See bzrlib.Graph.get_parent_map()."""
 
2252
        """See breezy.Graph.get_parent_map()."""
2253
2253
        return self._make_parents_provider().get_parent_map(revision_ids)
2254
2254
 
2255
2255
    def _get_parent_map_rpc(self, keys):
2324
2324
        body = self._serialise_search_recipe(recipe)
2325
2325
        path = self.bzrdir._path_for_remote_call(self._client)
2326
2326
        for key in keys:
2327
 
            if type(key) is not str:
 
2327
            if not isinstance(key, str):
2328
2328
                raise ValueError(
2329
2329
                    "key %r not a plain string" % (key,))
2330
2330
        verb = 'Repository.get_parent_map'
2381
2381
        except errors.UnknownSmartMethod:
2382
2382
            self._ensure_real()
2383
2383
            return self._real_repository.get_signature_text(revision_id)
2384
 
        except errors.NoSuchRevision, err:
 
2384
        except errors.NoSuchRevision as err:
2385
2385
            for fallback in self._fallback_repositories:
2386
2386
                try:
2387
2387
                    return fallback.get_signature_text(revision_id)
2402
2402
 
2403
2403
    @needs_write_lock
2404
2404
    def reconcile(self, other=None, thorough=False):
2405
 
        from bzrlib.reconcile import RepoReconciler
 
2405
        from .reconcile import RepoReconciler
2406
2406
        path = self.bzrdir._path_for_remote_call(self._client)
2407
2407
        try:
2408
2408
            response, handler = self._call_expecting_body(
3000
3000
                    verb, args, search_bytes)
3001
3001
            except errors.UnknownSmartMethod:
3002
3002
                medium._remember_remote_is_before(version)
3003
 
            except errors.UnknownErrorFromSmartServer, e:
 
3003
            except errors.UnknownErrorFromSmartServer as e:
3004
3004
                if isinstance(search, vf_search.EverythingResult):
3005
3005
                    error_verb = e.error_from_smart_server.error_verb
3006
3006
                    if error_verb == 'BadSearch':
3147
3147
        if self._custom_format:
3148
3148
            network_name = self._custom_format.network_name()
3149
3149
        else:
3150
 
            # Select the current bzrlib default and ask for that.
 
3150
            # Select the current breezy default and ask for that.
3151
3151
            reference_bzrdir_format = controldir.format_registry.get('default')()
3152
3152
            reference_format = reference_bzrdir_format.get_branch_format()
3153
3153
            self._custom_format = reference_format
3238
3238
        self._ensure_real()
3239
3239
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
3240
3240
            branch_class = self._custom_format._branch_class()
3241
 
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
3242
 
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3241
            heads_to_fetch_impl = branch_class.heads_to_fetch.__func__
 
3242
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.__func__:
3243
3243
                return True
3244
3244
        return False
3245
3245
 
3335
3335
            self._real_branch.repository = self.repository
3336
3336
        else:
3337
3337
            self._real_branch = None
3338
 
        # Fill out expected attributes of branch for bzrlib API users.
 
3338
        # Fill out expected attributes of branch for breezy API users.
3339
3339
        self._clear_cached_state()
3340
3340
        # TODO: deprecate self.base in favor of user_url
3341
3341
        self.base = self.bzrdir.user_url
3380
3380
        try:
3381
3381
            fallback_url = self.get_stacked_on_url()
3382
3382
        except (errors.NotStacked, errors.UnstackableBranchFormat,
3383
 
            errors.UnstackableRepositoryFormat), e:
 
3383
            errors.UnstackableRepositoryFormat) as e:
3384
3384
            return
3385
3385
        self._is_stacked = True
3386
3386
        if possible_transports is None:
3505
3505
            # self._translate_error, so we can't use self._call either.
3506
3506
            response = self._client.call('Branch.get_stacked_on_url',
3507
3507
                self._remote_path())
3508
 
        except errors.ErrorFromSmartServer, err:
 
3508
        except errors.ErrorFromSmartServer as err:
3509
3509
            # there may not be a repository yet, so we can't call through
3510
3510
            # its _translate_error
3511
3511
            _translate_error(err, branch=self)
3512
 
        except errors.UnknownSmartMethod, err:
 
3512
        except errors.UnknownSmartMethod as err:
3513
3513
            self._ensure_real()
3514
3514
            return self._real_branch.get_stacked_on_url()
3515
3515
        if response[0] != 'ok':
3521
3521
        # We need the stacked_on_url to be visible both locally (to not query
3522
3522
        # it repeatedly) and remotely (so smart verbs can get it server side)
3523
3523
        # Without the following line,
3524
 
        # bzrlib.tests.per_branch.test_create_clone.TestCreateClone
 
3524
        # breezy.tests.per_branch.test_create_clone.TestCreateClone
3525
3525
        # .test_create_clone_on_transport_stacked_hooks_get_stacked_branch
3526
3526
        # fails for remote branches -- vila 2012-01-04
3527
3527
        self.conf_store.save_changes()
3574
3574
    def lock_read(self):
3575
3575
        """Lock the branch for read operations.
3576
3576
 
3577
 
        :return: A bzrlib.lock.LogicalLockResult.
 
3577
        :return: A breezy.lock.LogicalLockResult.
3578
3578
        """
3579
3579
        self.repository.lock_read()
3580
3580
        if not self._lock_mode:
3599
3599
            response = self._call(
3600
3600
                'Branch.lock_write', self._remote_path(), branch_token,
3601
3601
                repo_token or '', **err_context)
3602
 
        except errors.LockContention, e:
 
3602
        except errors.LockContention as e:
3603
3603
            # The LockContention from the server doesn't have any
3604
3604
            # information about the lock_url. We re-raise LockContention
3605
3605
            # with valid lock_url.
3820
3820
            return self._vfs_set_parent_location(url)
3821
3821
        try:
3822
3822
            call_url = url or ''
3823
 
            if type(call_url) is not str:
 
3823
            if not isinstance(call_url, str):
3824
3824
                raise AssertionError('url must be a str or None (%s)' % url)
3825
3825
            response = self._call('Branch.set_parent_location',
3826
3826
                self._remote_path(), self._lock_token, self._repo_lock_token,
3983
3983
 
3984
3984
    It is a low-level object that considers config data to be name/value pairs
3985
3985
    that may be associated with a section. Assigning meaning to the these
3986
 
    values is done at higher levels like bzrlib.config.TreeConfig.
 
3986
    values is done at higher levels like breezy.config.TreeConfig.
3987
3987
    """
3988
3988
 
3989
3989
    def get_option(self, name, section=None, default=None):
4165
4165
    def find(name):
4166
4166
        try:
4167
4167
            return context[name]
4168
 
        except KeyError, key_err:
 
4168
        except KeyError as key_err:
4169
4169
            mutter('Missing key %r in context %r', key_err.args[0], context)
4170
4170
            raise err
4171
4171
    def get_path():
4174
4174
        """
4175
4175
        try:
4176
4176
            return context['path']
4177
 
        except KeyError, key_err:
 
4177
        except KeyError as key_err:
4178
4178
            try:
4179
4179
                return err.error_args[0]
4180
 
            except IndexError, idx_err:
 
4180
            except IndexError as idx_err:
4181
4181
                mutter(
4182
4182
                    'Missing key %r in context %r', key_err.args[0], context)
4183
4183
                raise err