← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-05-21 13:36:51 UTC
  • mfrom: (5243.2.1 readdir_cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20100521133651-p62dndo2giy5ls21
(lifeless) Some cleanups to the readdir pyrex code for a little efficiency
 and to avoid compile warnings. (John A Meinel)

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