← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Vincent Ladeuil
  • Date: 2010-07-15 13:39:38 UTC
  • mto: This revision was merged to the branch mainline in revision 5347.
  • Revision ID: v.ladeuil+lp@free.fr-20100715133938-ig82bitvdfonfu6w
Delete bzrlib.transform.create_by_entry (no deprecation tests).

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):
1000
1003
    def lock_read(self):
1001
1004
        """Lock the repository for read operations.
1002
1005
 
1003
 
        :return: An object with an unlock method which will release the lock
1004
 
            obtained.
 
1006
        :return: A bzrlib.lock.LogicalLockResult.
1005
1007
        """
1006
1008
        # wrong eventually - want a local lock cache context
1007
1009
        if not self._lock_mode:
1015
1017
                repo.lock_read()
1016
1018
        else:
1017
1019
            self._lock_count += 1
1018
 
        return self
 
1020
        return lock.LogicalLockResult(self.unlock)
1019
1021
 
1020
1022
    def _remote_lock_write(self, token):
1021
1023
        path = self.bzrdir._path_for_remote_call(self._client)
1313
1315
        return self._real_repository.make_working_trees()
1314
1316
 
1315
1317
    def refresh_data(self):
1316
 
        """Re-read any data needed to to synchronise with disk.
 
1318
        """Re-read any data needed to synchronise with disk.
1317
1319
 
1318
1320
        This method is intended to be called after another repository instance
1319
1321
        (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.
 
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.
1322
1327
        """
1323
 
        if self.is_in_write_group():
1324
 
            raise errors.InternalBzrError(
1325
 
                "May not refresh_data while in a write group.")
1326
1328
        if self._real_repository is not None:
1327
1329
            self._real_repository.refresh_data()
1328
1330
 
1978
1980
        if response_tuple[0] != 'ok':
1979
1981
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
1982
        byte_stream = response_handler.read_streamed_body()
1981
 
        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)
1982
1985
        if src_format.network_name() != repo._format.network_name():
1983
1986
            raise AssertionError(
1984
1987
                "Mismatched RemoteRepository and stream src %r, %r" % (
2396
2399
    def lock_read(self):
2397
2400
        """Lock the branch for read operations.
2398
2401
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
 
2402
        :return: A bzrlib.lock.LogicalLockResult.
2401
2403
        """
2402
2404
        self.repository.lock_read()
2403
2405
        if not self._lock_mode:
2408
2410
                self._real_branch.lock_read()
2409
2411
        else:
2410
2412
            self._lock_count += 1
2411
 
        return self
 
2413
        return lock.LogicalLockResult(self.unlock)
2412
2414
 
2413
2415
    def _remote_lock_write(self, token):
2414
2416
        if token is None:
2418
2420
            repo_token = self.repository.lock_write().repository_token
2419
2421
            self.repository.unlock()
2420
2422
        err_context = {'token': token}
2421
 
        response = self._call(
2422
 
            'Branch.lock_write', self._remote_path(), branch_token,
2423
 
            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])
2424
2433
        if response[0] != 'ok':
2425
2434
            raise errors.UnexpectedSmartServerResponse(response)
2426
2435
        ok, branch_token, repo_token = response
2447
2456
            self._lock_mode = 'w'
2448
2457
            self._lock_count = 1
2449
2458
        elif self._lock_mode == 'r':
2450
 
            raise errors.ReadOnlyTransaction
 
2459
            raise errors.ReadOnlyError(self)
2451
2460
        else:
2452
2461
            if token is not None:
2453
2462
                # A token was given to lock_write, and we're relocking, so
2787
2796
        medium = self._branch._client._medium
2788
2797
        if medium._is_remote_before((1, 14)):
2789
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):
2790
2807
        try:
2791
2808
            path = self._branch._remote_path()
2792
2809
            response = self._branch._client.call('Branch.set_config_option',
2793
2810
                path, self._branch._lock_token, self._branch._repo_lock_token,
2794
2811
                value.encode('utf8'), name, section or '')
2795
2812
        except errors.UnknownSmartMethod:
 
2813
            medium = self._branch._client._medium
2796
2814
            medium._remember_remote_is_before((1, 14))
2797
2815
            return self._vfs_set_option(value, name, section)
2798
2816
        if response != ():
2799
2817
            raise errors.UnexpectedSmartServerResponse(response)
2800
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
 
2801
2844
    def _real_object(self):
2802
2845
        self._branch._ensure_real()
2803
2846
        return self._branch._real_branch