← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Gary van der Merwe
  • Date: 2010-11-18 08:18:19 UTC
  • mto: This revision was merged to the branch mainline in revision 5543.
  • Revision ID: garyvdm@gmail.com-20101118081819-5bb84wrcl5gim8hb
Update test to match BranchBuilder change.

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" % (
2364
2369
        self._ensure_real()
2365
2370
        return self._real_branch._get_tags_bytes()
2366
2371
 
 
2372
    @needs_read_lock
2367
2373
    def _get_tags_bytes(self):
 
2374
        if self._tags_bytes is None:
 
2375
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2376
        return self._tags_bytes
 
2377
 
 
2378
    def _get_tags_bytes_via_hpss(self):
2368
2379
        medium = self._client._medium
2369
2380
        if medium._is_remote_before((1, 13)):
2370
2381
            return self._vfs_get_tags_bytes()
2380
2391
        return self._real_branch._set_tags_bytes(bytes)
2381
2392
 
2382
2393
    def _set_tags_bytes(self, bytes):
 
2394
        if self.is_locked():
 
2395
            self._tags_bytes = bytes
2383
2396
        medium = self._client._medium
2384
2397
        if medium._is_remote_before((1, 18)):
2385
2398
            self._vfs_set_tags_bytes(bytes)
2396
2409
    def lock_read(self):
2397
2410
        """Lock the branch for read operations.
2398
2411
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
 
2412
        :return: A bzrlib.lock.LogicalLockResult.
2401
2413
        """
2402
2414
        self.repository.lock_read()
2403
2415
        if not self._lock_mode:
2408
2420
                self._real_branch.lock_read()
2409
2421
        else:
2410
2422
            self._lock_count += 1
2411
 
        return self
 
2423
        return lock.LogicalLockResult(self.unlock)
2412
2424
 
2413
2425
    def _remote_lock_write(self, token):
2414
2426
        if token is None:
2418
2430
            repo_token = self.repository.lock_write().repository_token
2419
2431
            self.repository.unlock()
2420
2432
        err_context = {'token': token}
2421
 
        response = self._call(
2422
 
            'Branch.lock_write', self._remote_path(), branch_token,
2423
 
            repo_token or '', **err_context)
 
2433
        try:
 
2434
            response = self._call(
 
2435
                'Branch.lock_write', self._remote_path(), branch_token,
 
2436
                repo_token or '', **err_context)
 
2437
        except errors.LockContention, e:
 
2438
            # The LockContention from the server doesn't have any
 
2439
            # information about the lock_url. We re-raise LockContention
 
2440
            # with valid lock_url.
 
2441
            raise errors.LockContention('(remote lock)',
 
2442
                self.repository.base.split('.bzr/')[0])
2424
2443
        if response[0] != 'ok':
2425
2444
            raise errors.UnexpectedSmartServerResponse(response)
2426
2445
        ok, branch_token, repo_token = response
2447
2466
            self._lock_mode = 'w'
2448
2467
            self._lock_count = 1
2449
2468
        elif self._lock_mode == 'r':
2450
 
            raise errors.ReadOnlyTransaction
 
2469
            raise errors.ReadOnlyError(self)
2451
2470
        else:
2452
2471
            if token is not None:
2453
2472
                # A token was given to lock_write, and we're relocking, so
2787
2806
        medium = self._branch._client._medium
2788
2807
        if medium._is_remote_before((1, 14)):
2789
2808
            return self._vfs_set_option(value, name, section)
 
2809
        if isinstance(value, dict):
 
2810
            if medium._is_remote_before((2, 2)):
 
2811
                return self._vfs_set_option(value, name, section)
 
2812
            return self._set_config_option_dict(value, name, section)
 
2813
        else:
 
2814
            return self._set_config_option(value, name, section)
 
2815
 
 
2816
    def _set_config_option(self, value, name, section):
2790
2817
        try:
2791
2818
            path = self._branch._remote_path()
2792
2819
            response = self._branch._client.call('Branch.set_config_option',
2793
2820
                path, self._branch._lock_token, self._branch._repo_lock_token,
2794
2821
                value.encode('utf8'), name, section or '')
2795
2822
        except errors.UnknownSmartMethod:
 
2823
            medium = self._branch._client._medium
2796
2824
            medium._remember_remote_is_before((1, 14))
2797
2825
            return self._vfs_set_option(value, name, section)
2798
2826
        if response != ():
2799
2827
            raise errors.UnexpectedSmartServerResponse(response)
2800
2828
 
 
2829
    def _serialize_option_dict(self, option_dict):
 
2830
        utf8_dict = {}
 
2831
        for key, value in option_dict.items():
 
2832
            if isinstance(key, unicode):
 
2833
                key = key.encode('utf8')
 
2834
            if isinstance(value, unicode):
 
2835
                value = value.encode('utf8')
 
2836
            utf8_dict[key] = value
 
2837
        return bencode.bencode(utf8_dict)
 
2838
 
 
2839
    def _set_config_option_dict(self, value, name, section):
 
2840
        try:
 
2841
            path = self._branch._remote_path()
 
2842
            serialised_dict = self._serialize_option_dict(value)
 
2843
            response = self._branch._client.call(
 
2844
                'Branch.set_config_option_dict',
 
2845
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
2846
                serialised_dict, name, section or '')
 
2847
        except errors.UnknownSmartMethod:
 
2848
            medium = self._branch._client._medium
 
2849
            medium._remember_remote_is_before((2, 2))
 
2850
            return self._vfs_set_option(value, name, section)
 
2851
        if response != ():
 
2852
            raise errors.UnexpectedSmartServerResponse(response)
 
2853
 
2801
2854
    def _real_object(self):
2802
2855
        self._branch._ensure_real()
2803
2856
        return self._branch._real_branch