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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-22 00:56:52 UTC
  • mfrom: (6621.2.26 py3_pokes)
  • Revision ID: jelmer@jelmer.uk-20170522005652-yjahcr9hwmjkno7n
Merge Python3 porting work ('py3 pokes')

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/remote.py
19
19
import bz2
20
20
import zlib
21
21
 
22
 
from breezy 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 breezy.branch import BranchReferenceFormat, BranchWriteLockResult
47
 
from breezy.decorators import needs_read_lock, needs_write_lock, only_raises
48
 
from breezy.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 breezy.i18n import gettext
53
 
from breezy.inventory import Inventory
54
 
from breezy.lockable_files import LockableFiles
55
 
from breezy.smart import client, vfs, repository as smart_repo
56
 
from breezy.smart.client import _SmartClient
57
 
from breezy.revision import NULL_REVISION
58
 
from breezy.revisiontree import InventoryRevisionTree
59
 
from breezy.repository import RepositoryWriteLockResult, _LazyListJoin
60
 
from breezy.serializer import format_registry as serializer_format_registry
61
 
from breezy.trace import mutter, note, warning, log_exception_quietly
62
 
from breezy.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
 
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
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
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
 
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 breezy.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':
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
 
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':
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,
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