/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: Canonical.com Patch Queue Manager
  • Date: 2010-06-04 05:59:55 UTC
  • mfrom: (5279.1.1 lazy-import-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20100604055955-98pfcy1bn8oz7749
(spiv) Use lazy imports in bzrilb.merge to minimise the startup cost of
 plugins like news_merge. (Andrew Bennetts)

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):
 
276
    def find_branch_format(self, name=None):
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()
 
281
        b = self.open_branch(name=name)
282
282
        return b._format
283
283
 
284
 
    def get_branch_reference(self):
 
284
    def get_branch_reference(self, name=None):
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)
286
289
        response = self._get_branch_reference()
287
290
        if response[0] == 'ref':
288
291
            return response[1]
319
322
            raise errors.UnexpectedSmartServerResponse(response)
320
323
        return response
321
324
 
322
 
    def _get_tree_branch(self):
 
325
    def _get_tree_branch(self, name=None):
323
326
        """See BzrDir._get_tree_branch()."""
324
 
        return None, self.open_branch()
 
327
        return None, self.open_branch(name=name)
325
328
 
326
329
    def open_branch(self, name=None, unsupported=False,
327
330
                    ignore_fallbacks=False):
896
899
    def _has_same_fallbacks(self, other_repo):
897
900
        """Returns true if the repositories have the same fallbacks."""
898
901
        # XXX: copied from Repository; it should be unified into a base class
899
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
902
        # <https://bugs.launchpad.net/bzr/+bug/401622>
900
903
        my_fb = self._fallback_repositories
901
904
        other_fb = other_repo._fallback_repositories
902
905
        if len(my_fb) != len(other_fb):
1312
1315
        return self._real_repository.make_working_trees()
1313
1316
 
1314
1317
    def refresh_data(self):
1315
 
        """Re-read any data needed to to synchronise with disk.
 
1318
        """Re-read any data needed to synchronise with disk.
1316
1319
 
1317
1320
        This method is intended to be called after another repository instance
1318
1321
        (such as one used by a smart server) has inserted data into the
1319
 
        repository. It may not be called during a write group, but may be
1320
 
        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.
1321
1327
        """
1322
 
        if self.is_in_write_group():
1323
 
            raise errors.InternalBzrError(
1324
 
                "May not refresh_data while in a write group.")
1325
1328
        if self._real_repository is not None:
1326
1329
            self._real_repository.refresh_data()
1327
1330
 
1977
1980
        if response_tuple[0] != 'ok':
1978
1981
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1979
1982
        byte_stream = response_handler.read_streamed_body()
1980
 
        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)
1981
1985
        if src_format.network_name() != repo._format.network_name():
1982
1986
            raise AssertionError(
1983
1987
                "Mismatched RemoteRepository and stream src %r, %r" % (
2445
2449
            self._lock_mode = 'w'
2446
2450
            self._lock_count = 1
2447
2451
        elif self._lock_mode == 'r':
2448
 
            raise errors.ReadOnlyTransaction
 
2452
            raise errors.ReadOnlyError(self)
2449
2453
        else:
2450
2454
            if token is not None:
2451
2455
                # A token was given to lock_write, and we're relocking, so
2785
2789
        medium = self._branch._client._medium
2786
2790
        if medium._is_remote_before((1, 14)):
2787
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):
2788
2800
        try:
2789
2801
            path = self._branch._remote_path()
2790
2802
            response = self._branch._client.call('Branch.set_config_option',
2791
2803
                path, self._branch._lock_token, self._branch._repo_lock_token,
2792
2804
                value.encode('utf8'), name, section or '')
2793
2805
        except errors.UnknownSmartMethod:
 
2806
            medium = self._branch._client._medium
2794
2807
            medium._remember_remote_is_before((1, 14))
2795
2808
            return self._vfs_set_option(value, name, section)
2796
2809
        if response != ():
2797
2810
            raise errors.UnexpectedSmartServerResponse(response)
2798
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
 
2799
2837
    def _real_object(self):
2800
2838
        self._branch._ensure_real()
2801
2839
        return self._branch._real_branch