← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Martin
  • Date: 2010-10-13 16:44:48 UTC
  • mto: This revision was merged to the branch mainline in revision 5494.
  • Revision ID: gzlist@googlemail.com-20101013164448-6fg84e7fuw29zhwr
Don't rely on bzrlib importing itself in _format_version_tuple doctest

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
21
21
    branch,
22
22
    bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
213
214
        if len(branch_info) != 2:
214
215
            raise errors.UnexpectedSmartServerResponse(response)
215
216
        branch_ref, branch_name = branch_info
216
 
        format = bzrdir.network_format_registry.get(control_name)
 
217
        format = controldir.network_format_registry.get(control_name)
217
218
        if repo_name:
218
219
            format.repository_format = repository.network_format_registry.get(
219
220
                repo_name)
270
271
        self._real_bzrdir.destroy_branch(name=name)
271
272
        self._next_open_branch_result = None
272
273
 
273
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
274
    def create_workingtree(self, revision_id=None, from_branch=None,
 
275
        accelerator_tree=None, hardlink=False):
274
276
        raise errors.NotLocalUrl(self.transport.base)
275
277
 
276
 
    def find_branch_format(self):
 
278
    def find_branch_format(self, name=None):
277
279
        """Find the branch 'format' for this bzrdir.
278
280
 
279
281
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
282
        """
281
 
        b = self.open_branch()
 
283
        b = self.open_branch(name=name)
282
284
        return b._format
283
285
 
284
 
    def get_branch_reference(self):
 
286
    def get_branch_reference(self, name=None):
285
287
        """See BzrDir.get_branch_reference()."""
 
288
        if name is not None:
 
289
            # XXX JRV20100304: Support opening colocated branches
 
290
            raise errors.NoColocatedBranchSupport(self)
286
291
        response = self._get_branch_reference()
287
292
        if response[0] == 'ref':
288
293
            return response[1]
319
324
            raise errors.UnexpectedSmartServerResponse(response)
320
325
        return response
321
326
 
322
 
    def _get_tree_branch(self):
 
327
    def _get_tree_branch(self, name=None):
323
328
        """See BzrDir._get_tree_branch()."""
324
 
        return None, self.open_branch()
 
329
        return None, self.open_branch(name=name)
325
330
 
326
331
    def open_branch(self, name=None, unsupported=False,
327
332
                    ignore_fallbacks=False):
645
650
 
646
651
 
647
652
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
 
    bzrdir.ControlComponent):
 
653
    controldir.ControlComponent):
649
654
    """Repository accessed over rpc.
650
655
 
651
656
    For the moment most operations are performed using local transport-backed
896
901
    def _has_same_fallbacks(self, other_repo):
897
902
        """Returns true if the repositories have the same fallbacks."""
898
903
        # XXX: copied from Repository; it should be unified into a base class
899
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
904
        # <https://bugs.launchpad.net/bzr/+bug/401622>
900
905
        my_fb = self._fallback_repositories
901
906
        other_fb = other_repo._fallback_repositories
902
907
        if len(my_fb) != len(other_fb):
1000
1005
    def lock_read(self):
1001
1006
        """Lock the repository for read operations.
1002
1007
 
1003
 
        :return: An object with an unlock method which will release the lock
1004
 
            obtained.
 
1008
        :return: A bzrlib.lock.LogicalLockResult.
1005
1009
        """
1006
1010
        # wrong eventually - want a local lock cache context
1007
1011
        if not self._lock_mode:
1015
1019
                repo.lock_read()
1016
1020
        else:
1017
1021
            self._lock_count += 1
1018
 
        return self
 
1022
        return lock.LogicalLockResult(self.unlock)
1019
1023
 
1020
1024
    def _remote_lock_write(self, token):
1021
1025
        path = self.bzrdir._path_for_remote_call(self._client)
1313
1317
        return self._real_repository.make_working_trees()
1314
1318
 
1315
1319
    def refresh_data(self):
1316
 
        """Re-read any data needed to to synchronise with disk.
 
1320
        """Re-read any data needed to synchronise with disk.
1317
1321
 
1318
1322
        This method is intended to be called after another repository instance
1319
1323
        (such as one used by a smart server) has inserted data into the
1320
 
        repository. It may not be called during a write group, but may be
1321
 
        called at any other time.
 
1324
        repository. On all repositories this will work outside of write groups.
 
1325
        Some repository formats (pack and newer for bzrlib native formats)
 
1326
        support refresh_data inside write groups. If called inside a write
 
1327
        group on a repository that does not support refreshing in a write group
 
1328
        IsInWriteGroupError will be raised.
1322
1329
        """
1323
 
        if self.is_in_write_group():
1324
 
            raise errors.InternalBzrError(
1325
 
                "May not refresh_data while in a write group.")
1326
1330
        if self._real_repository is not None:
1327
1331
            self._real_repository.refresh_data()
1328
1332
 
1978
1982
        if response_tuple[0] != 'ok':
1979
1983
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
1984
        byte_stream = response_handler.read_streamed_body()
1981
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
1985
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
1986
            self._record_counter)
1982
1987
        if src_format.network_name() != repo._format.network_name():
1983
1988
            raise AssertionError(
1984
1989
                "Mismatched RemoteRepository and stream src %r, %r" % (
2396
2401
    def lock_read(self):
2397
2402
        """Lock the branch for read operations.
2398
2403
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
 
2404
        :return: A bzrlib.lock.LogicalLockResult.
2401
2405
        """
2402
2406
        self.repository.lock_read()
2403
2407
        if not self._lock_mode:
2408
2412
                self._real_branch.lock_read()
2409
2413
        else:
2410
2414
            self._lock_count += 1
2411
 
        return self
 
2415
        return lock.LogicalLockResult(self.unlock)
2412
2416
 
2413
2417
    def _remote_lock_write(self, token):
2414
2418
        if token is None:
2418
2422
            repo_token = self.repository.lock_write().repository_token
2419
2423
            self.repository.unlock()
2420
2424
        err_context = {'token': token}
2421
 
        response = self._call(
2422
 
            'Branch.lock_write', self._remote_path(), branch_token,
2423
 
            repo_token or '', **err_context)
 
2425
        try:
 
2426
            response = self._call(
 
2427
                'Branch.lock_write', self._remote_path(), branch_token,
 
2428
                repo_token or '', **err_context)
 
2429
        except errors.LockContention, e:
 
2430
            # The LockContention from the server doesn't have any
 
2431
            # information about the lock_url. We re-raise LockContention
 
2432
            # with valid lock_url.
 
2433
            raise errors.LockContention('(remote lock)',
 
2434
                self.repository.base.split('.bzr/')[0])
2424
2435
        if response[0] != 'ok':
2425
2436
            raise errors.UnexpectedSmartServerResponse(response)
2426
2437
        ok, branch_token, repo_token = response
2447
2458
            self._lock_mode = 'w'
2448
2459
            self._lock_count = 1
2449
2460
        elif self._lock_mode == 'r':
2450
 
            raise errors.ReadOnlyTransaction
 
2461
            raise errors.ReadOnlyError(self)
2451
2462
        else:
2452
2463
            if token is not None:
2453
2464
                # A token was given to lock_write, and we're relocking, so
2787
2798
        medium = self._branch._client._medium
2788
2799
        if medium._is_remote_before((1, 14)):
2789
2800
            return self._vfs_set_option(value, name, section)
 
2801
        if isinstance(value, dict):
 
2802
            if medium._is_remote_before((2, 2)):
 
2803
                return self._vfs_set_option(value, name, section)
 
2804
            return self._set_config_option_dict(value, name, section)
 
2805
        else:
 
2806
            return self._set_config_option(value, name, section)
 
2807
 
 
2808
    def _set_config_option(self, value, name, section):
2790
2809
        try:
2791
2810
            path = self._branch._remote_path()
2792
2811
            response = self._branch._client.call('Branch.set_config_option',
2793
2812
                path, self._branch._lock_token, self._branch._repo_lock_token,
2794
2813
                value.encode('utf8'), name, section or '')
2795
2814
        except errors.UnknownSmartMethod:
 
2815
            medium = self._branch._client._medium
2796
2816
            medium._remember_remote_is_before((1, 14))
2797
2817
            return self._vfs_set_option(value, name, section)
2798
2818
        if response != ():
2799
2819
            raise errors.UnexpectedSmartServerResponse(response)
2800
2820
 
 
2821
    def _serialize_option_dict(self, option_dict):
 
2822
        utf8_dict = {}
 
2823
        for key, value in option_dict.items():
 
2824
            if isinstance(key, unicode):
 
2825
                key = key.encode('utf8')
 
2826
            if isinstance(value, unicode):
 
2827
                value = value.encode('utf8')
 
2828
            utf8_dict[key] = value
 
2829
        return bencode.bencode(utf8_dict)
 
2830
 
 
2831
    def _set_config_option_dict(self, value, name, section):
 
2832
        try:
 
2833
            path = self._branch._remote_path()
 
2834
            serialised_dict = self._serialize_option_dict(value)
 
2835
            response = self._branch._client.call(
 
2836
                'Branch.set_config_option_dict',
 
2837
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
2838
                serialised_dict, name, section or '')
 
2839
        except errors.UnknownSmartMethod:
 
2840
            medium = self._branch._client._medium
 
2841
            medium._remember_remote_is_before((2, 2))
 
2842
            return self._vfs_set_option(value, name, section)
 
2843
        if response != ():
 
2844
            raise errors.UnexpectedSmartServerResponse(response)
 
2845
 
2801
2846
    def _real_object(self):
2802
2847
        self._branch._ensure_real()
2803
2848
        return self._branch._real_branch