← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Martin von Gagern
  • Date: 2010-05-02 18:16:37 UTC
  • mto: This revision was merged to the branch mainline in revision 5203.
  • Revision ID: martin.vgagern@gmx.net-20100502181637-wlkqn31xuybzt9gy
Add blackbox test for cat --directory.

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,
25
24
    debug,
26
25
    errors,
27
26
    graph,
34
33
    static_tuple,
35
34
    symbol_versioning,
36
35
)
37
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
36
from bzrlib.branch import BranchReferenceFormat
38
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
39
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
40
39
from bzrlib.errors import (
44
43
from bzrlib.lockable_files import LockableFiles
45
44
from bzrlib.smart import client, vfs, repository as smart_repo
46
45
from bzrlib.revision import ensure_null, NULL_REVISION
47
 
from bzrlib.repository import RepositoryWriteLockResult
48
46
from bzrlib.trace import mutter, note, warning
49
47
 
50
48
 
214
212
        if len(branch_info) != 2:
215
213
            raise errors.UnexpectedSmartServerResponse(response)
216
214
        branch_ref, branch_name = branch_info
217
 
        format = controldir.network_format_registry.get(control_name)
 
215
        format = bzrdir.network_format_registry.get(control_name)
218
216
        if repo_name:
219
217
            format.repository_format = repository.network_format_registry.get(
220
218
                repo_name)
274
272
    def create_workingtree(self, revision_id=None, from_branch=None):
275
273
        raise errors.NotLocalUrl(self.transport.base)
276
274
 
277
 
    def find_branch_format(self, name=None):
 
275
    def find_branch_format(self):
278
276
        """Find the branch 'format' for this bzrdir.
279
277
 
280
278
        This might be a synthetic object for e.g. RemoteBranch and SVN.
281
279
        """
282
 
        b = self.open_branch(name=name)
 
280
        b = self.open_branch()
283
281
        return b._format
284
282
 
285
 
    def get_branch_reference(self, name=None):
 
283
    def get_branch_reference(self):
286
284
        """See BzrDir.get_branch_reference()."""
287
 
        if name is not None:
288
 
            # XXX JRV20100304: Support opening colocated branches
289
 
            raise errors.NoColocatedBranchSupport(self)
290
285
        response = self._get_branch_reference()
291
286
        if response[0] == 'ref':
292
287
            return response[1]
323
318
            raise errors.UnexpectedSmartServerResponse(response)
324
319
        return response
325
320
 
326
 
    def _get_tree_branch(self, name=None):
 
321
    def _get_tree_branch(self):
327
322
        """See BzrDir._get_tree_branch()."""
328
 
        return None, self.open_branch(name=name)
 
323
        return None, self.open_branch()
329
324
 
330
325
    def open_branch(self, name=None, unsupported=False,
331
326
                    ignore_fallbacks=False):
648
643
        return self._custom_format._serializer
649
644
 
650
645
 
651
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
652
 
    controldir.ControlComponent):
 
646
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
653
647
    """Repository accessed over rpc.
654
648
 
655
649
    For the moment most operations are performed using local transport-backed
698
692
        # Additional places to query for data.
699
693
        self._fallback_repositories = []
700
694
 
701
 
    @property
702
 
    def user_transport(self):
703
 
        return self.bzrdir.user_transport
704
 
 
705
 
    @property
706
 
    def control_transport(self):
707
 
        # XXX: Normally you shouldn't directly get at the remote repository
708
 
        # transport, but I'm not sure it's worth making this method
709
 
        # optional -- mbp 2010-04-21
710
 
        return self.bzrdir.get_repository_transport(None)
711
 
        
712
695
    def __str__(self):
713
696
        return "%s(%s)" % (self.__class__.__name__, self.base)
714
697
 
900
883
    def _has_same_fallbacks(self, other_repo):
901
884
        """Returns true if the repositories have the same fallbacks."""
902
885
        # XXX: copied from Repository; it should be unified into a base class
903
 
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
886
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
904
887
        my_fb = self._fallback_repositories
905
888
        other_fb = other_repo._fallback_repositories
906
889
        if len(my_fb) != len(other_fb):
1002
985
        pass
1003
986
 
1004
987
    def lock_read(self):
1005
 
        """Lock the repository for read operations.
1006
 
 
1007
 
        :return: A bzrlib.lock.LogicalLockResult.
1008
 
        """
1009
988
        # wrong eventually - want a local lock cache context
1010
989
        if not self._lock_mode:
1011
990
            self._note_lock('r')
1018
997
                repo.lock_read()
1019
998
        else:
1020
999
            self._lock_count += 1
1021
 
        return lock.LogicalLockResult(self.unlock)
1022
1000
 
1023
1001
    def _remote_lock_write(self, token):
1024
1002
        path = self.bzrdir._path_for_remote_call(self._client)
1064
1042
            raise errors.ReadOnlyError(self)
1065
1043
        else:
1066
1044
            self._lock_count += 1
1067
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1045
        return self._lock_token or None
1068
1046
 
1069
1047
    def leave_lock_in_place(self):
1070
1048
        if not self._lock_token:
1256
1234
        # _real_branch had its get_stacked_on_url method called), then the
1257
1235
        # repository to be added may already be in the _real_repositories list.
1258
1236
        if self._real_repository is not None:
1259
 
            fallback_locations = [repo.user_url for repo in
 
1237
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1260
1238
                self._real_repository._fallback_repositories]
1261
 
            if repository.user_url not in fallback_locations:
 
1239
            if repository.bzrdir.root_transport.base not in fallback_locations:
1262
1240
                self._real_repository.add_fallback_repository(repository)
1263
1241
 
1264
1242
    def _check_fallback_repository(self, repository):
1316
1294
        return self._real_repository.make_working_trees()
1317
1295
 
1318
1296
    def refresh_data(self):
1319
 
        """Re-read any data needed to synchronise with disk.
 
1297
        """Re-read any data needed to to synchronise with disk.
1320
1298
 
1321
1299
        This method is intended to be called after another repository instance
1322
1300
        (such as one used by a smart server) has inserted data into the
1323
 
        repository. On all repositories this will work outside of write groups.
1324
 
        Some repository formats (pack and newer for bzrlib native formats)
1325
 
        support refresh_data inside write groups. If called inside a write
1326
 
        group on a repository that does not support refreshing in a write group
1327
 
        IsInWriteGroupError will be raised.
 
1301
        repository. It may not be called during a write group, but may be
 
1302
        called at any other time.
1328
1303
        """
 
1304
        if self.is_in_write_group():
 
1305
            raise errors.InternalBzrError(
 
1306
                "May not refresh_data while in a write group.")
1329
1307
        if self._real_repository is not None:
1330
1308
            self._real_repository.refresh_data()
1331
1309
 
1981
1959
        if response_tuple[0] != 'ok':
1982
1960
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1983
1961
        byte_stream = response_handler.read_streamed_body()
1984
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1985
 
            self._record_counter)
 
1962
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1986
1963
        if src_format.network_name() != repo._format.network_name():
1987
1964
            raise AssertionError(
1988
1965
                "Mismatched RemoteRepository and stream src %r, %r" % (
2204
2181
            self._real_branch = None
2205
2182
        # Fill out expected attributes of branch for bzrlib API users.
2206
2183
        self._clear_cached_state()
2207
 
        # TODO: deprecate self.base in favor of user_url
2208
 
        self.base = self.bzrdir.user_url
 
2184
        self.base = self.bzrdir.root_transport.base
2209
2185
        self._name = name
2210
2186
        self._control_files = None
2211
2187
        self._lock_mode = None
2398
2374
            self._vfs_set_tags_bytes(bytes)
2399
2375
 
2400
2376
    def lock_read(self):
2401
 
        """Lock the branch for read operations.
2402
 
 
2403
 
        :return: A bzrlib.lock.LogicalLockResult.
2404
 
        """
2405
2377
        self.repository.lock_read()
2406
2378
        if not self._lock_mode:
2407
2379
            self._note_lock('r')
2411
2383
                self._real_branch.lock_read()
2412
2384
        else:
2413
2385
            self._lock_count += 1
2414
 
        return lock.LogicalLockResult(self.unlock)
2415
2386
 
2416
2387
    def _remote_lock_write(self, token):
2417
2388
        if token is None:
2418
2389
            branch_token = repo_token = ''
2419
2390
        else:
2420
2391
            branch_token = token
2421
 
            repo_token = self.repository.lock_write().repository_token
 
2392
            repo_token = self.repository.lock_write()
2422
2393
            self.repository.unlock()
2423
2394
        err_context = {'token': token}
2424
 
        try:
2425
 
            response = self._call(
2426
 
                'Branch.lock_write', self._remote_path(), branch_token,
2427
 
                repo_token or '', **err_context)
2428
 
        except errors.LockContention, e:
2429
 
            # The LockContention from the server doesn't have any
2430
 
            # information about the lock_url. We re-raise LockContention
2431
 
            # with valid lock_url.
2432
 
            raise errors.LockContention('(remote lock)',
2433
 
                self.repository.base.split('.bzr/')[0])
 
2395
        response = self._call(
 
2396
            'Branch.lock_write', self._remote_path(), branch_token,
 
2397
            repo_token or '', **err_context)
2434
2398
        if response[0] != 'ok':
2435
2399
            raise errors.UnexpectedSmartServerResponse(response)
2436
2400
        ok, branch_token, repo_token = response
2457
2421
            self._lock_mode = 'w'
2458
2422
            self._lock_count = 1
2459
2423
        elif self._lock_mode == 'r':
2460
 
            raise errors.ReadOnlyError(self)
 
2424
            raise errors.ReadOnlyTransaction
2461
2425
        else:
2462
2426
            if token is not None:
2463
2427
                # A token was given to lock_write, and we're relocking, so
2468
2432
            self._lock_count += 1
2469
2433
            # Re-lock the repository too.
2470
2434
            self.repository.lock_write(self._repo_lock_token)
2471
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2435
        return self._lock_token or None
2472
2436
 
2473
2437
    def _unlock(self, branch_token, repo_token):
2474
2438
        err_context = {'token': str((branch_token, repo_token))}
2797
2761
        medium = self._branch._client._medium
2798
2762
        if medium._is_remote_before((1, 14)):
2799
2763
            return self._vfs_set_option(value, name, section)
2800
 
        if isinstance(value, dict):
2801
 
            if medium._is_remote_before((2, 2)):
2802
 
                return self._vfs_set_option(value, name, section)
2803
 
            return self._set_config_option_dict(value, name, section)
2804
 
        else:
2805
 
            return self._set_config_option(value, name, section)
2806
 
 
2807
 
    def _set_config_option(self, value, name, section):
2808
2764
        try:
2809
2765
            path = self._branch._remote_path()
2810
2766
            response = self._branch._client.call('Branch.set_config_option',
2811
2767
                path, self._branch._lock_token, self._branch._repo_lock_token,
2812
2768
                value.encode('utf8'), name, section or '')
2813
2769
        except errors.UnknownSmartMethod:
2814
 
            medium = self._branch._client._medium
2815
2770
            medium._remember_remote_is_before((1, 14))
2816
2771
            return self._vfs_set_option(value, name, section)
2817
2772
        if response != ():
2818
2773
            raise errors.UnexpectedSmartServerResponse(response)
2819
2774
 
2820
 
    def _serialize_option_dict(self, option_dict):
2821
 
        utf8_dict = {}
2822
 
        for key, value in option_dict.items():
2823
 
            if isinstance(key, unicode):
2824
 
                key = key.encode('utf8')
2825
 
            if isinstance(value, unicode):
2826
 
                value = value.encode('utf8')
2827
 
            utf8_dict[key] = value
2828
 
        return bencode.bencode(utf8_dict)
2829
 
 
2830
 
    def _set_config_option_dict(self, value, name, section):
2831
 
        try:
2832
 
            path = self._branch._remote_path()
2833
 
            serialised_dict = self._serialize_option_dict(value)
2834
 
            response = self._branch._client.call(
2835
 
                'Branch.set_config_option_dict',
2836
 
                path, self._branch._lock_token, self._branch._repo_lock_token,
2837
 
                serialised_dict, name, section or '')
2838
 
        except errors.UnknownSmartMethod:
2839
 
            medium = self._branch._client._medium
2840
 
            medium._remember_remote_is_before((2, 2))
2841
 
            return self._vfs_set_option(value, name, section)
2842
 
        if response != ():
2843
 
            raise errors.UnexpectedSmartServerResponse(response)
2844
 
 
2845
2775
    def _real_object(self):
2846
2776
        self._branch._ensure_real()
2847
2777
        return self._branch._real_branch