/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: Andrew Bennetts
  • Date: 2011-02-25 04:44:53 UTC
  • mto: This revision was merged to the branch mainline in revision 5695.
  • Revision ID: andrew.bennetts@canonical.com-20110225044453-2ig5en0bi0uukre6
Fix final bzr-loom test by adding RemoteBranch.heads_to_fetch that can ask the remote branch for the heads to fetch (but uses the cheaper default logic if it knows the remote format has an identical heads_to_fetch as Branch.heads_to_fetch).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
21
21
    branch,
22
22
    bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
32
33
    revision as _mod_revision,
33
34
    static_tuple,
34
35
    symbol_versioning,
 
36
    urlutils,
35
37
)
36
 
from bzrlib.branch import BranchReferenceFormat
 
38
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
37
39
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
40
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
41
from bzrlib.errors import (
43
45
from bzrlib.lockable_files import LockableFiles
44
46
from bzrlib.smart import client, vfs, repository as smart_repo
45
47
from bzrlib.revision import ensure_null, NULL_REVISION
 
48
from bzrlib.repository import RepositoryWriteLockResult
46
49
from bzrlib.trace import mutter, note, warning
47
50
 
48
51
 
212
215
        if len(branch_info) != 2:
213
216
            raise errors.UnexpectedSmartServerResponse(response)
214
217
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
218
        format = controldir.network_format_registry.get(control_name)
216
219
        if repo_name:
217
220
            format.repository_format = repository.network_format_registry.get(
218
221
                repo_name)
244
247
        self._ensure_real()
245
248
        self._real_bzrdir.destroy_repository()
246
249
 
247
 
    def create_branch(self, name=None):
 
250
    def create_branch(self, name=None, repository=None):
248
251
        # as per meta1 formats - just delegate to the format object which may
249
252
        # be parameterised.
250
253
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
254
            name=name, repository=repository)
252
255
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
256
            if not isinstance(repository, RemoteRepository):
 
257
                raise AssertionError(
 
258
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
259
                    % (repository,))
 
260
            result = RemoteBranch(self, repository, real_branch, name=name)
255
261
        else:
256
262
            result = real_branch
257
263
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
275
        self._real_bzrdir.destroy_branch(name=name)
270
276
        self._next_open_branch_result = None
271
277
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
278
    def create_workingtree(self, revision_id=None, from_branch=None,
 
279
        accelerator_tree=None, hardlink=False):
273
280
        raise errors.NotLocalUrl(self.transport.base)
274
281
 
275
 
    def find_branch_format(self):
 
282
    def find_branch_format(self, name=None):
276
283
        """Find the branch 'format' for this bzrdir.
277
284
 
278
285
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
286
        """
280
 
        b = self.open_branch()
 
287
        b = self.open_branch(name=name)
281
288
        return b._format
282
289
 
283
 
    def get_branch_reference(self):
 
290
    def get_branch_reference(self, name=None):
284
291
        """See BzrDir.get_branch_reference()."""
 
292
        if name is not None:
 
293
            # XXX JRV20100304: Support opening colocated branches
 
294
            raise errors.NoColocatedBranchSupport(self)
285
295
        response = self._get_branch_reference()
286
296
        if response[0] == 'ref':
287
297
            return response[1]
318
328
            raise errors.UnexpectedSmartServerResponse(response)
319
329
        return response
320
330
 
321
 
    def _get_tree_branch(self):
 
331
    def _get_tree_branch(self, name=None):
322
332
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
333
        return None, self.open_branch(name=name)
324
334
 
325
335
    def open_branch(self, name=None, unsupported=False,
326
336
                    ignore_fallbacks=False):
441
451
        """Upgrading of remote bzrdirs is not supported yet."""
442
452
        return False
443
453
 
444
 
    def needs_format_conversion(self, format=None):
 
454
    def needs_format_conversion(self, format):
445
455
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
456
        return False
450
457
 
451
458
    def clone(self, url, revision_id=None, force_new_repo=False,
644
651
 
645
652
 
646
653
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
654
    controldir.ControlComponent):
648
655
    """Repository accessed over rpc.
649
656
 
650
657
    For the moment most operations are performed using local transport-backed
895
902
    def _has_same_fallbacks(self, other_repo):
896
903
        """Returns true if the repositories have the same fallbacks."""
897
904
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
905
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
906
        my_fb = self._fallback_repositories
900
907
        other_fb = other_repo._fallback_repositories
901
908
        if len(my_fb) != len(other_fb):
997
1004
        pass
998
1005
 
999
1006
    def lock_read(self):
 
1007
        """Lock the repository for read operations.
 
1008
 
 
1009
        :return: A bzrlib.lock.LogicalLockResult.
 
1010
        """
1000
1011
        # wrong eventually - want a local lock cache context
1001
1012
        if not self._lock_mode:
1002
1013
            self._note_lock('r')
1009
1020
                repo.lock_read()
1010
1021
        else:
1011
1022
            self._lock_count += 1
 
1023
        return lock.LogicalLockResult(self.unlock)
1012
1024
 
1013
1025
    def _remote_lock_write(self, token):
1014
1026
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1066
            raise errors.ReadOnlyError(self)
1055
1067
        else:
1056
1068
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1069
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1070
 
1059
1071
    def leave_lock_in_place(self):
1060
1072
        if not self._lock_token:
1306
1318
        return self._real_repository.make_working_trees()
1307
1319
 
1308
1320
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1321
        """Re-read any data needed to synchronise with disk.
1310
1322
 
1311
1323
        This method is intended to be called after another repository instance
1312
1324
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
 
1325
        repository. On all repositories this will work outside of write groups.
 
1326
        Some repository formats (pack and newer for bzrlib native formats)
 
1327
        support refresh_data inside write groups. If called inside a write
 
1328
        group on a repository that does not support refreshing in a write group
 
1329
        IsInWriteGroupError will be raised.
1315
1330
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1331
        if self._real_repository is not None:
1320
1332
            self._real_repository.refresh_data()
1321
1333
 
1333
1345
        return result
1334
1346
 
1335
1347
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1348
    def search_missing_revision_ids(self, other,
 
1349
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1350
            find_ghosts=True, revision_ids=None, if_present_ids=None):
1337
1351
        """Return the revision ids that other has that this does not.
1338
1352
 
1339
1353
        These are returned in topological order.
1340
1354
 
1341
1355
        revision_id: only return revision ids included by revision_id.
1342
1356
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1357
        if symbol_versioning.deprecated_passed(revision_id):
 
1358
            symbol_versioning.warn(
 
1359
                'search_missing_revision_ids(revision_id=...) was '
 
1360
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1361
                DeprecationWarning, stacklevel=2)
 
1362
            if revision_ids is not None:
 
1363
                raise AssertionError(
 
1364
                    'revision_ids is mutually exclusive with revision_id')
 
1365
            if revision_id is not None:
 
1366
                revision_ids = [revision_id]
 
1367
        inter_repo = repository.InterRepository.get(other, self)
 
1368
        return inter_repo.search_missing_revision_ids(
 
1369
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1370
            if_present_ids=if_present_ids)
1345
1371
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1372
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1373
            fetch_spec=None):
1348
1374
        # No base implementation to use as RemoteRepository is not a subclass
1349
1375
        # of Repository; so this is a copy of Repository.fetch().
1367
1393
        # the InterRepository base class, which raises an
1368
1394
        # IncompatibleRepositories when asked to fetch.
1369
1395
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1396
        return inter.fetch(revision_id=revision_id,
1371
1397
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1398
 
1373
1399
    def create_bundle(self, target, base, fileobj, format=None):
1748
1774
        return '\n'.join((start_keys, stop_keys, count))
1749
1775
 
1750
1776
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
1777
        parts = search_result.get_network_struct()
1757
1778
        return '\n'.join(parts)
1758
1779
 
1759
1780
    def autopack(self):
1953
1974
        candidate_verbs = [
1954
1975
            ('Repository.get_stream_1.19', (1, 19)),
1955
1976
            ('Repository.get_stream', (1, 13))]
 
1977
 
1956
1978
        found_verb = False
1957
1979
        for verb, version in candidate_verbs:
1958
1980
            if medium._is_remote_before(version):
1962
1984
                    verb, args, search_bytes)
1963
1985
            except errors.UnknownSmartMethod:
1964
1986
                medium._remember_remote_is_before(version)
 
1987
            except errors.UnknownErrorFromSmartServer, e:
 
1988
                if isinstance(search, graph.EverythingResult):
 
1989
                    error_verb = e.error_from_smart_server.error_verb
 
1990
                    if error_verb == 'BadSearch':
 
1991
                        # Pre-2.4 servers don't support this sort of search.
 
1992
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
1993
                        # good idea in general?  It might provide a little bit
 
1994
                        # of protection against client-side bugs.
 
1995
                        medium._remember_remote_is_before((2, 4))
 
1996
                        break
 
1997
                raise
1965
1998
            else:
1966
1999
                response_tuple, response_handler = response
1967
2000
                found_verb = True
1971
2004
        if response_tuple[0] != 'ok':
1972
2005
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2006
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2007
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2008
            self._record_counter)
1975
2009
        if src_format.network_name() != repo._format.network_name():
1976
2010
            raise AssertionError(
1977
2011
                "Mismatched RemoteRepository and stream src %r, %r" % (
2081
2115
                                  name=name)
2082
2116
        return result
2083
2117
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2118
    def initialize(self, a_bzrdir, name=None, repository=None):
2085
2119
        # 1) get the network name to use.
2086
2120
        if self._custom_format:
2087
2121
            network_name = self._custom_format.network_name()
2115
2149
        # Turn the response into a RemoteRepository object.
2116
2150
        format = RemoteBranchFormat(network_name=response[1])
2117
2151
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2152
        repo_path = response[2]
 
2153
        if repository is not None:
 
2154
            remote_repo_url = urlutils.join(medium.base, repo_path)
 
2155
            url_diff = urlutils.relative_url(repository.user_url,
 
2156
                    remote_repo_url)
 
2157
            if url_diff != '.':
 
2158
                raise AssertionError(
 
2159
                    'repository.user_url %r does not match URL from server '
 
2160
                    'response (%r + %r)'
 
2161
                    % (repository.user_url, medium.base, repo_path))
 
2162
            remote_repo = repository
2120
2163
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2164
            if repo_path == '':
 
2165
                repo_bzrdir = a_bzrdir
 
2166
            else:
 
2167
                repo_bzrdir = RemoteBzrDir(
 
2168
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2169
                    a_bzrdir._client)
 
2170
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2171
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2172
            format=format, setup_stacking=False, name=name)
2127
2173
        # XXX: We know this is a new branch, so it must have revno 0, revid
2148
2194
        self._ensure_real()
2149
2195
        return self._custom_format.supports_set_append_revisions_only()
2150
2196
 
 
2197
    def _native_heads_to_fetch(self):
 
2198
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2199
        # implementation is not overridden vs the base class, we can use the
 
2200
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2201
        # usually free in terms of net round trips, as the last-revision and
 
2202
        # tags info fetched is cached and would be fetched anyway.
 
2203
        self._ensure_real()
 
2204
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2205
            branch_class = self._custom_format._branch_class()
 
2206
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2207
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2208
                return True
 
2209
        return False
2151
2210
 
2152
2211
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2212
    """Branch stored on a server accessed by HPSS RPC.
2357
2416
        self._ensure_real()
2358
2417
        return self._real_branch._get_tags_bytes()
2359
2418
 
 
2419
    @needs_read_lock
2360
2420
    def _get_tags_bytes(self):
 
2421
        if self._tags_bytes is None:
 
2422
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2423
        return self._tags_bytes
 
2424
 
 
2425
    def _get_tags_bytes_via_hpss(self):
2361
2426
        medium = self._client._medium
2362
2427
        if medium._is_remote_before((1, 13)):
2363
2428
            return self._vfs_get_tags_bytes()
2373
2438
        return self._real_branch._set_tags_bytes(bytes)
2374
2439
 
2375
2440
    def _set_tags_bytes(self, bytes):
 
2441
        if self.is_locked():
 
2442
            self._tags_bytes = bytes
2376
2443
        medium = self._client._medium
2377
2444
        if medium._is_remote_before((1, 18)):
2378
2445
            self._vfs_set_tags_bytes(bytes)
2387
2454
            self._vfs_set_tags_bytes(bytes)
2388
2455
 
2389
2456
    def lock_read(self):
 
2457
        """Lock the branch for read operations.
 
2458
 
 
2459
        :return: A bzrlib.lock.LogicalLockResult.
 
2460
        """
2390
2461
        self.repository.lock_read()
2391
2462
        if not self._lock_mode:
2392
2463
            self._note_lock('r')
2396
2467
                self._real_branch.lock_read()
2397
2468
        else:
2398
2469
            self._lock_count += 1
 
2470
        return lock.LogicalLockResult(self.unlock)
2399
2471
 
2400
2472
    def _remote_lock_write(self, token):
2401
2473
        if token is None:
2402
2474
            branch_token = repo_token = ''
2403
2475
        else:
2404
2476
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2477
            repo_token = self.repository.lock_write().repository_token
2406
2478
            self.repository.unlock()
2407
2479
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2480
        try:
 
2481
            response = self._call(
 
2482
                'Branch.lock_write', self._remote_path(), branch_token,
 
2483
                repo_token or '', **err_context)
 
2484
        except errors.LockContention, e:
 
2485
            # The LockContention from the server doesn't have any
 
2486
            # information about the lock_url. We re-raise LockContention
 
2487
            # with valid lock_url.
 
2488
            raise errors.LockContention('(remote lock)',
 
2489
                self.repository.base.split('.bzr/')[0])
2411
2490
        if response[0] != 'ok':
2412
2491
            raise errors.UnexpectedSmartServerResponse(response)
2413
2492
        ok, branch_token, repo_token = response
2434
2513
            self._lock_mode = 'w'
2435
2514
            self._lock_count = 1
2436
2515
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2516
            raise errors.ReadOnlyError(self)
2438
2517
        else:
2439
2518
            if token is not None:
2440
2519
                # A token was given to lock_write, and we're relocking, so
2445
2524
            self._lock_count += 1
2446
2525
            # Re-lock the repository too.
2447
2526
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2527
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2528
 
2450
2529
    def _unlock(self, branch_token, repo_token):
2451
2530
        err_context = {'token': str((branch_token, repo_token))}
2715
2794
        self._ensure_real()
2716
2795
        return self._real_branch.set_push_location(location)
2717
2796
 
 
2797
    def heads_to_fetch(self):
 
2798
        if self._format._native_heads_to_fetch():
 
2799
            return branch.Branch.heads_to_fetch(self)
 
2800
        medium = self._client._medium
 
2801
        if medium._is_remote_before((2, 4)):
 
2802
            return self._vfs_heads_to_fetch()
 
2803
        try:
 
2804
            return self._rpc_heads_to_fetch()
 
2805
        except errors.UnknownSmartMethod:
 
2806
            medium._remember_remote_is_before((2, 4))
 
2807
            return self._vfs_heads_to_fetch()
 
2808
 
 
2809
    def _rpc_heads_to_fetch(self):
 
2810
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
2811
        if len(response) != 2:
 
2812
            raise errors.UnexpectedSmartServerResponse(response)
 
2813
        must_fetch, if_present_fetch = response
 
2814
        return set(must_fetch), set(if_present_fetch)
 
2815
 
 
2816
    def _vfs_heads_to_fetch(self):
 
2817
        self._ensure_real()
 
2818
        return self._real_branch.heads_to_fetch()
 
2819
 
2718
2820
 
2719
2821
class RemoteConfig(object):
2720
2822
    """A Config that reads and writes from smart verbs.
2774
2876
        medium = self._branch._client._medium
2775
2877
        if medium._is_remote_before((1, 14)):
2776
2878
            return self._vfs_set_option(value, name, section)
 
2879
        if isinstance(value, dict):
 
2880
            if medium._is_remote_before((2, 2)):
 
2881
                return self._vfs_set_option(value, name, section)
 
2882
            return self._set_config_option_dict(value, name, section)
 
2883
        else:
 
2884
            return self._set_config_option(value, name, section)
 
2885
 
 
2886
    def _set_config_option(self, value, name, section):
2777
2887
        try:
2778
2888
            path = self._branch._remote_path()
2779
2889
            response = self._branch._client.call('Branch.set_config_option',
2780
2890
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
2891
                value.encode('utf8'), name, section or '')
2782
2892
        except errors.UnknownSmartMethod:
 
2893
            medium = self._branch._client._medium
2783
2894
            medium._remember_remote_is_before((1, 14))
2784
2895
            return self._vfs_set_option(value, name, section)
2785
2896
        if response != ():
2786
2897
            raise errors.UnexpectedSmartServerResponse(response)
2787
2898
 
 
2899
    def _serialize_option_dict(self, option_dict):
 
2900
        utf8_dict = {}
 
2901
        for key, value in option_dict.items():
 
2902
            if isinstance(key, unicode):
 
2903
                key = key.encode('utf8')
 
2904
            if isinstance(value, unicode):
 
2905
                value = value.encode('utf8')
 
2906
            utf8_dict[key] = value
 
2907
        return bencode.bencode(utf8_dict)
 
2908
 
 
2909
    def _set_config_option_dict(self, value, name, section):
 
2910
        try:
 
2911
            path = self._branch._remote_path()
 
2912
            serialised_dict = self._serialize_option_dict(value)
 
2913
            response = self._branch._client.call(
 
2914
                'Branch.set_config_option_dict',
 
2915
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
2916
                serialised_dict, name, section or '')
 
2917
        except errors.UnknownSmartMethod:
 
2918
            medium = self._branch._client._medium
 
2919
            medium._remember_remote_is_before((2, 2))
 
2920
            return self._vfs_set_option(value, name, section)
 
2921
        if response != ():
 
2922
            raise errors.UnexpectedSmartServerResponse(response)
 
2923
 
2788
2924
    def _real_object(self):
2789
2925
        self._branch._ensure_real()
2790
2926
        return self._branch._real_branch