/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
899
899
    def _has_same_fallbacks(self, other_repo):
900
900
        """Returns true if the repositories have the same fallbacks."""
901
901
        # XXX: copied from Repository; it should be unified into a base class
902
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
902
        # <https://bugs.launchpad.net/bzr/+bug/401622>
903
903
        my_fb = self._fallback_repositories
904
904
        other_fb = other_repo._fallback_repositories
905
905
        if len(my_fb) != len(other_fb):
1980
1980
        if response_tuple[0] != 'ok':
1981
1981
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
1982
        byte_stream = response_handler.read_streamed_body()
1983
 
        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)
1984
1985
        if src_format.network_name() != repo._format.network_name():
1985
1986
            raise AssertionError(
1986
1987
                "Mismatched RemoteRepository and stream src %r, %r" % (
2419
2420
            repo_token = self.repository.lock_write().repository_token
2420
2421
            self.repository.unlock()
2421
2422
        err_context = {'token': token}
2422
 
        response = self._call(
2423
 
            'Branch.lock_write', self._remote_path(), branch_token,
2424
 
            repo_token or '', **err_context)
 
2423
        try:
 
2424
            response = self._call(
 
2425
                'Branch.lock_write', self._remote_path(), branch_token,
 
2426
                repo_token or '', **err_context)
 
2427
        except errors.LockContention, e:
 
2428
            # The LockContention from the server doesn't have any
 
2429
            # information about the lock_url. We re-raise LockContention
 
2430
            # with valid lock_url.
 
2431
            raise errors.LockContention('(remote lock)',
 
2432
                self.repository.base.split('.bzr/')[0])
2425
2433
        if response[0] != 'ok':
2426
2434
            raise errors.UnexpectedSmartServerResponse(response)
2427
2435
        ok, branch_token, repo_token = response
2448
2456
            self._lock_mode = 'w'
2449
2457
            self._lock_count = 1
2450
2458
        elif self._lock_mode == 'r':
2451
 
            raise errors.ReadOnlyTransaction
 
2459
            raise errors.ReadOnlyError(self)
2452
2460
        else:
2453
2461
            if token is not None:
2454
2462
                # A token was given to lock_write, and we're relocking, so
2788
2796
        medium = self._branch._client._medium
2789
2797
        if medium._is_remote_before((1, 14)):
2790
2798
            return self._vfs_set_option(value, name, section)
 
2799
        if isinstance(value, dict):
 
2800
            if medium._is_remote_before((2, 2)):
 
2801
                return self._vfs_set_option(value, name, section)
 
2802
            return self._set_config_option_dict(value, name, section)
 
2803
        else:
 
2804
            return self._set_config_option(value, name, section)
 
2805
 
 
2806
    def _set_config_option(self, value, name, section):
2791
2807
        try:
2792
2808
            path = self._branch._remote_path()
2793
2809
            response = self._branch._client.call('Branch.set_config_option',
2794
2810
                path, self._branch._lock_token, self._branch._repo_lock_token,
2795
2811
                value.encode('utf8'), name, section or '')
2796
2812
        except errors.UnknownSmartMethod:
 
2813
            medium = self._branch._client._medium
2797
2814
            medium._remember_remote_is_before((1, 14))
2798
2815
            return self._vfs_set_option(value, name, section)
2799
2816
        if response != ():
2800
2817
            raise errors.UnexpectedSmartServerResponse(response)
2801
2818
 
 
2819
    def _serialize_option_dict(self, option_dict):
 
2820
        utf8_dict = {}
 
2821
        for key, value in option_dict.items():
 
2822
            if isinstance(key, unicode):
 
2823
                key = key.encode('utf8')
 
2824
            if isinstance(value, unicode):
 
2825
                value = value.encode('utf8')
 
2826
            utf8_dict[key] = value
 
2827
        return bencode.bencode(utf8_dict)
 
2828
 
 
2829
    def _set_config_option_dict(self, value, name, section):
 
2830
        try:
 
2831
            path = self._branch._remote_path()
 
2832
            serialised_dict = self._serialize_option_dict(value)
 
2833
            response = self._branch._client.call(
 
2834
                'Branch.set_config_option_dict',
 
2835
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
2836
                serialised_dict, name, section or '')
 
2837
        except errors.UnknownSmartMethod:
 
2838
            medium = self._branch._client._medium
 
2839
            medium._remember_remote_is_before((2, 2))
 
2840
            return self._vfs_set_option(value, name, section)
 
2841
        if response != ():
 
2842
            raise errors.UnexpectedSmartServerResponse(response)
 
2843
 
2802
2844
    def _real_object(self):
2803
2845
        self._branch._ensure_real()
2804
2846
        return self._branch._real_branch