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

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
21
21
    branch,
22
22
    bzrdir,
23
23
    config,
24
 
    controldir,
25
24
    debug,
26
25
    errors,
27
26
    graph,
34
33
    static_tuple,
35
34
    symbol_versioning,
36
35
)
37
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
36
from bzrlib.branch import BranchReferenceFormat
38
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
39
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
40
39
from bzrlib.errors import (
44
43
from bzrlib.lockable_files import LockableFiles
45
44
from bzrlib.smart import client, vfs, repository as smart_repo
46
45
from bzrlib.revision import ensure_null, NULL_REVISION
47
 
from bzrlib.repository import RepositoryWriteLockResult
48
46
from bzrlib.trace import mutter, note, warning
49
47
 
50
48
 
274
272
    def create_workingtree(self, revision_id=None, from_branch=None):
275
273
        raise errors.NotLocalUrl(self.transport.base)
276
274
 
277
 
    def find_branch_format(self, name=None):
 
275
    def find_branch_format(self):
278
276
        """Find the branch 'format' for this bzrdir.
279
277
 
280
278
        This might be a synthetic object for e.g. RemoteBranch and SVN.
281
279
        """
282
 
        b = self.open_branch(name=name)
 
280
        b = self.open_branch()
283
281
        return b._format
284
282
 
285
 
    def get_branch_reference(self, name=None):
 
283
    def get_branch_reference(self):
286
284
        """See BzrDir.get_branch_reference()."""
287
 
        if name is not None:
288
 
            # XXX JRV20100304: Support opening colocated branches
289
 
            raise errors.NoColocatedBranchSupport(self)
290
285
        response = self._get_branch_reference()
291
286
        if response[0] == 'ref':
292
287
            return response[1]
323
318
            raise errors.UnexpectedSmartServerResponse(response)
324
319
        return response
325
320
 
326
 
    def _get_tree_branch(self, name=None):
 
321
    def _get_tree_branch(self):
327
322
        """See BzrDir._get_tree_branch()."""
328
 
        return None, self.open_branch(name=name)
 
323
        return None, self.open_branch()
329
324
 
330
325
    def open_branch(self, name=None, unsupported=False,
331
326
                    ignore_fallbacks=False):
649
644
 
650
645
 
651
646
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
652
 
    controldir.ControlComponent):
 
647
    bzrdir.ControlComponent):
653
648
    """Repository accessed over rpc.
654
649
 
655
650
    For the moment most operations are performed using local transport-backed
900
895
    def _has_same_fallbacks(self, other_repo):
901
896
        """Returns true if the repositories have the same fallbacks."""
902
897
        # XXX: copied from Repository; it should be unified into a base class
903
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
898
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
904
899
        my_fb = self._fallback_repositories
905
900
        other_fb = other_repo._fallback_repositories
906
901
        if len(my_fb) != len(other_fb):
1002
997
        pass
1003
998
 
1004
999
    def lock_read(self):
1005
 
        """Lock the repository for read operations.
1006
 
 
1007
 
        :return: A bzrlib.lock.LogicalLockResult.
1008
 
        """
1009
1000
        # wrong eventually - want a local lock cache context
1010
1001
        if not self._lock_mode:
1011
1002
            self._note_lock('r')
1018
1009
                repo.lock_read()
1019
1010
        else:
1020
1011
            self._lock_count += 1
1021
 
        return lock.LogicalLockResult(self.unlock)
1022
1012
 
1023
1013
    def _remote_lock_write(self, token):
1024
1014
        path = self.bzrdir._path_for_remote_call(self._client)
1064
1054
            raise errors.ReadOnlyError(self)
1065
1055
        else:
1066
1056
            self._lock_count += 1
1067
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1057
        return self._lock_token or None
1068
1058
 
1069
1059
    def leave_lock_in_place(self):
1070
1060
        if not self._lock_token:
1316
1306
        return self._real_repository.make_working_trees()
1317
1307
 
1318
1308
    def refresh_data(self):
1319
 
        """Re-read any data needed to synchronise with disk.
 
1309
        """Re-read any data needed to to synchronise with disk.
1320
1310
 
1321
1311
        This method is intended to be called after another repository instance
1322
1312
        (such as one used by a smart server) has inserted data into the
1323
 
        repository. On all repositories this will work outside of write groups.
1324
 
        Some repository formats (pack and newer for bzrlib native formats)
1325
 
        support refresh_data inside write groups. If called inside a write
1326
 
        group on a repository that does not support refreshing in a write group
1327
 
        IsInWriteGroupError will be raised.
 
1313
        repository. It may not be called during a write group, but may be
 
1314
        called at any other time.
1328
1315
        """
 
1316
        if self.is_in_write_group():
 
1317
            raise errors.InternalBzrError(
 
1318
                "May not refresh_data while in a write group.")
1329
1319
        if self._real_repository is not None:
1330
1320
            self._real_repository.refresh_data()
1331
1321
 
1981
1971
        if response_tuple[0] != 'ok':
1982
1972
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1983
1973
        byte_stream = response_handler.read_streamed_body()
1984
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1985
 
            self._record_counter)
 
1974
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1986
1975
        if src_format.network_name() != repo._format.network_name():
1987
1976
            raise AssertionError(
1988
1977
                "Mismatched RemoteRepository and stream src %r, %r" % (
2398
2387
            self._vfs_set_tags_bytes(bytes)
2399
2388
 
2400
2389
    def lock_read(self):
2401
 
        """Lock the branch for read operations.
2402
 
 
2403
 
        :return: A bzrlib.lock.LogicalLockResult.
2404
 
        """
2405
2390
        self.repository.lock_read()
2406
2391
        if not self._lock_mode:
2407
2392
            self._note_lock('r')
2411
2396
                self._real_branch.lock_read()
2412
2397
        else:
2413
2398
            self._lock_count += 1
2414
 
        return lock.LogicalLockResult(self.unlock)
2415
2399
 
2416
2400
    def _remote_lock_write(self, token):
2417
2401
        if token is None:
2418
2402
            branch_token = repo_token = ''
2419
2403
        else:
2420
2404
            branch_token = token
2421
 
            repo_token = self.repository.lock_write().repository_token
 
2405
            repo_token = self.repository.lock_write()
2422
2406
            self.repository.unlock()
2423
2407
        err_context = {'token': token}
2424
 
        try:
2425
 
            response = self._call(
2426
 
                'Branch.lock_write', self._remote_path(), branch_token,
2427
 
                repo_token or '', **err_context)
2428
 
        except errors.LockContention, e:
2429
 
            # The LockContention from the server doesn't have any
2430
 
            # information about the lock_url. We re-raise LockContention
2431
 
            # with valid lock_url.
2432
 
            raise errors.LockContention('(remote lock)',
2433
 
                self.repository.base.split('.bzr/')[0])
 
2408
        response = self._call(
 
2409
            'Branch.lock_write', self._remote_path(), branch_token,
 
2410
            repo_token or '', **err_context)
2434
2411
        if response[0] != 'ok':
2435
2412
            raise errors.UnexpectedSmartServerResponse(response)
2436
2413
        ok, branch_token, repo_token = response
2457
2434
            self._lock_mode = 'w'
2458
2435
            self._lock_count = 1
2459
2436
        elif self._lock_mode == 'r':
2460
 
            raise errors.ReadOnlyError(self)
 
2437
            raise errors.ReadOnlyTransaction
2461
2438
        else:
2462
2439
            if token is not None:
2463
2440
                # A token was given to lock_write, and we're relocking, so
2468
2445
            self._lock_count += 1
2469
2446
            # Re-lock the repository too.
2470
2447
            self.repository.lock_write(self._repo_lock_token)
2471
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2448
        return self._lock_token or None
2472
2449
 
2473
2450
    def _unlock(self, branch_token, repo_token):
2474
2451
        err_context = {'token': str((branch_token, repo_token))}
2797
2774
        medium = self._branch._client._medium
2798
2775
        if medium._is_remote_before((1, 14)):
2799
2776
            return self._vfs_set_option(value, name, section)
2800
 
        if isinstance(value, dict):
2801
 
            if medium._is_remote_before((2, 2)):
2802
 
                return self._vfs_set_option(value, name, section)
2803
 
            return self._set_config_option_dict(value, name, section)
2804
 
        else:
2805
 
            return self._set_config_option(value, name, section)
2806
 
 
2807
 
    def _set_config_option(self, value, name, section):
2808
2777
        try:
2809
2778
            path = self._branch._remote_path()
2810
2779
            response = self._branch._client.call('Branch.set_config_option',
2811
2780
                path, self._branch._lock_token, self._branch._repo_lock_token,
2812
2781
                value.encode('utf8'), name, section or '')
2813
2782
        except errors.UnknownSmartMethod:
2814
 
            medium = self._branch._client._medium
2815
2783
            medium._remember_remote_is_before((1, 14))
2816
2784
            return self._vfs_set_option(value, name, section)
2817
2785
        if response != ():
2818
2786
            raise errors.UnexpectedSmartServerResponse(response)
2819
2787
 
2820
 
    def _serialize_option_dict(self, option_dict):
2821
 
        utf8_dict = {}
2822
 
        for key, value in option_dict.items():
2823
 
            if isinstance(key, unicode):
2824
 
                key = key.encode('utf8')
2825
 
            if isinstance(value, unicode):
2826
 
                value = value.encode('utf8')
2827
 
            utf8_dict[key] = value
2828
 
        return bencode.bencode(utf8_dict)
2829
 
 
2830
 
    def _set_config_option_dict(self, value, name, section):
2831
 
        try:
2832
 
            path = self._branch._remote_path()
2833
 
            serialised_dict = self._serialize_option_dict(value)
2834
 
            response = self._branch._client.call(
2835
 
                'Branch.set_config_option_dict',
2836
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
2837
 
                serialised_dict, name, section or '')
2838
 
        except errors.UnknownSmartMethod:
2839
 
            medium = self._branch._client._medium
2840
 
            medium._remember_remote_is_before((2, 2))
2841
 
            return self._vfs_set_option(value, name, section)
2842
 
        if response != ():
2843
 
            raise errors.UnexpectedSmartServerResponse(response)
2844
 
 
2845
2788
    def _real_object(self):
2846
2789
        self._branch._ensure_real()
2847
2790
        return self._branch._real_branch