/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 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
273
273
    def create_workingtree(self, revision_id=None, from_branch=None):
274
274
        raise errors.NotLocalUrl(self.transport.base)
275
275
 
276
 
    def find_branch_format(self, name=None):
 
276
    def find_branch_format(self):
277
277
        """Find the branch 'format' for this bzrdir.
278
278
 
279
279
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
280
        """
281
 
        b = self.open_branch(name=name)
 
281
        b = self.open_branch()
282
282
        return b._format
283
283
 
284
 
    def get_branch_reference(self, name=None):
 
284
    def get_branch_reference(self):
285
285
        """See BzrDir.get_branch_reference()."""
286
 
        if name is not None:
287
 
            # XXX JRV20100304: Support opening colocated branches
288
 
            raise errors.NoColocatedBranchSupport(self)
289
286
        response = self._get_branch_reference()
290
287
        if response[0] == 'ref':
291
288
            return response[1]
322
319
            raise errors.UnexpectedSmartServerResponse(response)
323
320
        return response
324
321
 
325
 
    def _get_tree_branch(self, name=None):
 
322
    def _get_tree_branch(self):
326
323
        """See BzrDir._get_tree_branch()."""
327
 
        return None, self.open_branch(name=name)
 
324
        return None, self.open_branch()
328
325
 
329
326
    def open_branch(self, name=None, unsupported=False,
330
327
                    ignore_fallbacks=False):
899
896
    def _has_same_fallbacks(self, other_repo):
900
897
        """Returns true if the repositories have the same fallbacks."""
901
898
        # XXX: copied from Repository; it should be unified into a base class
902
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
899
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
903
900
        my_fb = self._fallback_repositories
904
901
        other_fb = other_repo._fallback_repositories
905
902
        if len(my_fb) != len(other_fb):
1003
1000
    def lock_read(self):
1004
1001
        """Lock the repository for read operations.
1005
1002
 
1006
 
        :return: A bzrlib.lock.LogicalLockResult.
 
1003
        :return: An object with an unlock method which will release the lock
 
1004
            obtained.
1007
1005
        """
1008
1006
        # wrong eventually - want a local lock cache context
1009
1007
        if not self._lock_mode:
1017
1015
                repo.lock_read()
1018
1016
        else:
1019
1017
            self._lock_count += 1
1020
 
        return lock.LogicalLockResult(self.unlock)
 
1018
        return self
1021
1019
 
1022
1020
    def _remote_lock_write(self, token):
1023
1021
        path = self.bzrdir._path_for_remote_call(self._client)
1315
1313
        return self._real_repository.make_working_trees()
1316
1314
 
1317
1315
    def refresh_data(self):
1318
 
        """Re-read any data needed to synchronise with disk.
 
1316
        """Re-read any data needed to to synchronise with disk.
1319
1317
 
1320
1318
        This method is intended to be called after another repository instance
1321
1319
        (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.
 
1320
        repository. It may not be called during a write group, but may be
 
1321
        called at any other time.
1327
1322
        """
 
1323
        if self.is_in_write_group():
 
1324
            raise errors.InternalBzrError(
 
1325
                "May not refresh_data while in a write group.")
1328
1326
        if self._real_repository is not None:
1329
1327
            self._real_repository.refresh_data()
1330
1328
 
1980
1978
        if response_tuple[0] != 'ok':
1981
1979
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
1980
        byte_stream = response_handler.read_streamed_body()
1983
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1984
 
            self._record_counter)
 
1981
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1985
1982
        if src_format.network_name() != repo._format.network_name():
1986
1983
            raise AssertionError(
1987
1984
                "Mismatched RemoteRepository and stream src %r, %r" % (
2399
2396
    def lock_read(self):
2400
2397
        """Lock the branch for read operations.
2401
2398
 
2402
 
        :return: A bzrlib.lock.LogicalLockResult.
 
2399
        :return: An object with an unlock method which will release the lock
 
2400
            obtained.
2403
2401
        """
2404
2402
        self.repository.lock_read()
2405
2403
        if not self._lock_mode:
2410
2408
                self._real_branch.lock_read()
2411
2409
        else:
2412
2410
            self._lock_count += 1
2413
 
        return lock.LogicalLockResult(self.unlock)
 
2411
        return self
2414
2412
 
2415
2413
    def _remote_lock_write(self, token):
2416
2414
        if token is None:
2449
2447
            self._lock_mode = 'w'
2450
2448
            self._lock_count = 1
2451
2449
        elif self._lock_mode == 'r':
2452
 
            raise errors.ReadOnlyError(self)
 
2450
            raise errors.ReadOnlyTransaction
2453
2451
        else:
2454
2452
            if token is not None:
2455
2453
                # A token was given to lock_write, and we're relocking, so
2789
2787
        medium = self._branch._client._medium
2790
2788
        if medium._is_remote_before((1, 14)):
2791
2789
            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
2790
        try:
2801
2791
            path = self._branch._remote_path()
2802
2792
            response = self._branch._client.call('Branch.set_config_option',
2803
2793
                path, self._branch._lock_token, self._branch._repo_lock_token,
2804
2794
                value.encode('utf8'), name, section or '')
2805
2795
        except errors.UnknownSmartMethod:
2806
 
            medium = self._branch._client._medium
2807
2796
            medium._remember_remote_is_before((1, 14))
2808
2797
            return self._vfs_set_option(value, name, section)
2809
2798
        if response != ():
2810
2799
            raise errors.UnexpectedSmartServerResponse(response)
2811
2800
 
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
2801
    def _real_object(self):
2838
2802
        self._branch._ensure_real()
2839
2803
        return self._branch._real_branch