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