/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: Vincent Ladeuil
  • Date: 2010-01-25 15:55:48 UTC
  • mto: (4985.1.4 add-attr-cleanup)
  • mto: This revision was merged to the branch mainline in revision 4988.
  • Revision ID: v.ladeuil+lp@free.fr-20100125155548-0l352pujvt5bzl5e
Deploy addAttrCleanup on the whole test suite.

Several use case worth mentioning:

- setting a module or any other object attribute is the majority
by far. In some cases the setting itself is deferred but most of
the time we want to set at the same time we add the cleanup.

- there multiple occurrences of protecting hooks or ui factory
which are now useless (the test framework takes care of that now),

- there was some lambda uses that can now be avoided.

That first cleanup already simplifies things a lot.

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, 2007, 2008, 2009 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
27
27
    lock,
28
28
    lockdir,
29
29
    repository,
30
 
    repository as _mod_repository,
31
30
    revision,
32
31
    revision as _mod_revision,
33
 
    static_tuple,
34
32
    symbol_versioning,
35
33
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
34
from bzrlib.branch import BranchReferenceFormat
37
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
36
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
37
from bzrlib.errors import (
43
41
from bzrlib.lockable_files import LockableFiles
44
42
from bzrlib.smart import client, vfs, repository as smart_repo
45
43
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
44
from bzrlib.trace import mutter, note, warning
48
45
 
49
46
 
245
242
        self._ensure_real()
246
243
        self._real_bzrdir.destroy_repository()
247
244
 
248
 
    def create_branch(self, name=None):
 
245
    def create_branch(self):
249
246
        # as per meta1 formats - just delegate to the format object which may
250
247
        # be parameterised.
251
 
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
248
        real_branch = self._format.get_branch_format().initialize(self)
253
249
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
250
            result = RemoteBranch(self, self.find_repository(), real_branch)
256
251
        else:
257
252
            result = real_branch
258
253
        # BzrDir.clone_on_transport() uses the result of create_branch but does
264
259
        self._next_open_branch_result = result
265
260
        return result
266
261
 
267
 
    def destroy_branch(self, name=None):
 
262
    def destroy_branch(self):
268
263
        """See BzrDir.destroy_branch"""
269
264
        self._ensure_real()
270
 
        self._real_bzrdir.destroy_branch(name=name)
 
265
        self._real_bzrdir.destroy_branch()
271
266
        self._next_open_branch_result = None
272
267
 
273
268
    def create_workingtree(self, revision_id=None, from_branch=None):
323
318
        """See BzrDir._get_tree_branch()."""
324
319
        return None, self.open_branch()
325
320
 
326
 
    def open_branch(self, name=None, unsupported=False,
327
 
                    ignore_fallbacks=False):
328
 
        if unsupported:
 
321
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
322
        if _unsupported:
329
323
            raise NotImplementedError('unsupported flag support not implemented yet.')
330
324
        if self._next_open_branch_result is not None:
331
325
            # See create_branch for details.
336
330
        if response[0] == 'ref':
337
331
            # a branch reference, use the existing BranchReference logic.
338
332
            format = BranchReferenceFormat()
339
 
            return format.open(self, name=name, _found=True,
340
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
333
            return format.open(self, _found=True, location=response[1],
 
334
                ignore_fallbacks=ignore_fallbacks)
341
335
        branch_format_name = response[1]
342
336
        if not branch_format_name:
343
337
            branch_format_name = None
344
338
        format = RemoteBranchFormat(network_name=branch_format_name)
345
339
        return RemoteBranch(self, self.find_repository(), format=format,
346
 
            setup_stacking=not ignore_fallbacks, name=name)
 
340
            setup_stacking=not ignore_fallbacks)
347
341
 
348
342
    def _open_repo_v1(self, path):
349
343
        verb = 'BzrDir.find_repository'
426
420
        """Return the path to be used for this bzrdir in a remote call."""
427
421
        return client.remote_path_from_transport(self.root_transport)
428
422
 
429
 
    def get_branch_transport(self, branch_format, name=None):
 
423
    def get_branch_transport(self, branch_format):
430
424
        self._ensure_real()
431
 
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
425
        return self._real_bzrdir.get_branch_transport(branch_format)
432
426
 
433
427
    def get_repository_transport(self, repository_format):
434
428
        self._ensure_real()
644
638
        return self._custom_format._serializer
645
639
 
646
640
 
647
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
 
    bzrdir.ControlComponent):
 
641
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
649
642
    """Repository accessed over rpc.
650
643
 
651
644
    For the moment most operations are performed using local transport-backed
694
687
        # Additional places to query for data.
695
688
        self._fallback_repositories = []
696
689
 
697
 
    @property
698
 
    def user_transport(self):
699
 
        return self.bzrdir.user_transport
700
 
 
701
 
    @property
702
 
    def control_transport(self):
703
 
        # XXX: Normally you shouldn't directly get at the remote repository
704
 
        # transport, but I'm not sure it's worth making this method
705
 
        # optional -- mbp 2010-04-21
706
 
        return self.bzrdir.get_repository_transport(None)
707
 
        
708
690
    def __str__(self):
709
691
        return "%s(%s)" % (self.__class__.__name__, self.base)
710
692
 
918
900
        parents_provider = self._make_parents_provider(other_repository)
919
901
        return graph.Graph(parents_provider)
920
902
 
921
 
    @needs_read_lock
922
 
    def get_known_graph_ancestry(self, revision_ids):
923
 
        """Return the known graph for a set of revision ids and their ancestors.
924
 
        """
925
 
        st = static_tuple.StaticTuple
926
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
927
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
928
 
        return graph.GraphThunkIdsToKeys(known_graph)
929
 
 
930
903
    def gather_stats(self, revid=None, committers=None):
931
904
        """See Repository.gather_stats()."""
932
905
        path = self.bzrdir._path_for_remote_call(self._client)
998
971
        pass
999
972
 
1000
973
    def lock_read(self):
1001
 
        """Lock the repository for read operations.
1002
 
 
1003
 
        :return: A bzrlib.lock.LogicalLockResult.
1004
 
        """
1005
974
        # wrong eventually - want a local lock cache context
1006
975
        if not self._lock_mode:
1007
976
            self._note_lock('r')
1014
983
                repo.lock_read()
1015
984
        else:
1016
985
            self._lock_count += 1
1017
 
        return lock.LogicalLockResult(self.unlock)
1018
986
 
1019
987
    def _remote_lock_write(self, token):
1020
988
        path = self.bzrdir._path_for_remote_call(self._client)
1060
1028
            raise errors.ReadOnlyError(self)
1061
1029
        else:
1062
1030
            self._lock_count += 1
1063
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1031
        return self._lock_token or None
1064
1032
 
1065
1033
    def leave_lock_in_place(self):
1066
1034
        if not self._lock_token:
1246
1214
            # state, so always add a lock here. If a caller passes us a locked
1247
1215
            # repository, they are responsible for unlocking it later.
1248
1216
            repository.lock_read()
1249
 
        self._check_fallback_repository(repository)
1250
1217
        self._fallback_repositories.append(repository)
1251
1218
        # If self._real_repository was parameterised already (e.g. because a
1252
1219
        # _real_branch had its get_stacked_on_url method called), then the
1253
1220
        # repository to be added may already be in the _real_repositories list.
1254
1221
        if self._real_repository is not None:
1255
 
            fallback_locations = [repo.user_url for repo in
 
1222
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1256
1223
                self._real_repository._fallback_repositories]
1257
 
            if repository.user_url not in fallback_locations:
 
1224
            if repository.bzrdir.root_transport.base not in fallback_locations:
1258
1225
                self._real_repository.add_fallback_repository(repository)
1259
1226
 
1260
 
    def _check_fallback_repository(self, repository):
1261
 
        """Check that this repository can fallback to repository safely.
1262
 
 
1263
 
        Raise an error if not.
1264
 
 
1265
 
        :param repository: A repository to fallback to.
1266
 
        """
1267
 
        return _mod_repository.InterRepository._assert_same_model(
1268
 
            self, repository)
1269
 
 
1270
1227
    def add_inventory(self, revid, inv, parents):
1271
1228
        self._ensure_real()
1272
1229
        return self._real_repository.add_inventory(revid, inv, parents)
1273
1230
 
1274
1231
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1275
 
            parents, basis_inv=None, propagate_caches=False):
 
1232
                               parents):
1276
1233
        self._ensure_real()
1277
1234
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
1278
 
            delta, new_revision_id, parents, basis_inv=basis_inv,
1279
 
            propagate_caches=propagate_caches)
 
1235
            delta, new_revision_id, parents)
1280
1236
 
1281
1237
    def add_revision(self, rev_id, rev, inv=None, config=None):
1282
1238
        self._ensure_real()
1541
1497
        return self._real_repository.get_signature_text(revision_id)
1542
1498
 
1543
1499
    @needs_read_lock
1544
 
    def _get_inventory_xml(self, revision_id):
1545
 
        self._ensure_real()
1546
 
        return self._real_repository._get_inventory_xml(revision_id)
 
1500
    def get_inventory_xml(self, revision_id):
 
1501
        self._ensure_real()
 
1502
        return self._real_repository.get_inventory_xml(revision_id)
 
1503
 
 
1504
    def deserialise_inventory(self, revision_id, xml):
 
1505
        self._ensure_real()
 
1506
        return self._real_repository.deserialise_inventory(revision_id, xml)
1547
1507
 
1548
1508
    def reconcile(self, other=None, thorough=False):
1549
1509
        self._ensure_real()
1625
1585
        return self._real_repository.inventories
1626
1586
 
1627
1587
    @needs_write_lock
1628
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1588
    def pack(self, hint=None):
1629
1589
        """Compress the data within the repository.
1630
1590
 
1631
1591
        This is not currently implemented within the smart server.
1632
1592
        """
1633
1593
        self._ensure_real()
1634
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1594
        return self._real_repository.pack(hint=hint)
1635
1595
 
1636
1596
    @property
1637
1597
    def revisions(self):
2065
2025
    def network_name(self):
2066
2026
        return self._network_name
2067
2027
 
2068
 
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2069
 
        return a_bzrdir.open_branch(name=name, 
2070
 
            ignore_fallbacks=ignore_fallbacks)
 
2028
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
2029
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2071
2030
 
2072
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2031
    def _vfs_initialize(self, a_bzrdir):
2073
2032
        # Initialisation when using a local bzrdir object, or a non-vfs init
2074
2033
        # method is not available on the server.
2075
2034
        # self._custom_format is always set - the start of initialize ensures
2076
2035
        # that.
2077
2036
        if isinstance(a_bzrdir, RemoteBzrDir):
2078
2037
            a_bzrdir._ensure_real()
2079
 
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2080
 
                name)
 
2038
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2081
2039
        else:
2082
2040
            # We assume the bzrdir is parameterised; it may not be.
2083
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2041
            result = self._custom_format.initialize(a_bzrdir)
2084
2042
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2085
2043
            not isinstance(result, RemoteBranch)):
2086
 
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2087
 
                                  name=name)
 
2044
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2088
2045
        return result
2089
2046
 
2090
 
    def initialize(self, a_bzrdir, name=None):
 
2047
    def initialize(self, a_bzrdir):
2091
2048
        # 1) get the network name to use.
2092
2049
        if self._custom_format:
2093
2050
            network_name = self._custom_format.network_name()
2099
2056
            network_name = reference_format.network_name()
2100
2057
        # Being asked to create on a non RemoteBzrDir:
2101
2058
        if not isinstance(a_bzrdir, RemoteBzrDir):
2102
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2059
            return self._vfs_initialize(a_bzrdir)
2103
2060
        medium = a_bzrdir._client._medium
2104
2061
        if medium._is_remote_before((1, 13)):
2105
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2062
            return self._vfs_initialize(a_bzrdir)
2106
2063
        # Creating on a remote bzr dir.
2107
2064
        # 2) try direct creation via RPC
2108
2065
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
 
        if name is not None:
2110
 
            # XXX JRV20100304: Support creating colocated branches
2111
 
            raise errors.NoColocatedBranchSupport(self)
2112
2066
        verb = 'BzrDir.create_branch'
2113
2067
        try:
2114
2068
            response = a_bzrdir._call(verb, path, network_name)
2115
2069
        except errors.UnknownSmartMethod:
2116
2070
            # Fallback - use vfs methods
2117
2071
            medium._remember_remote_is_before((1, 13))
2118
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2072
            return self._vfs_initialize(a_bzrdir)
2119
2073
        if response[0] != 'ok':
2120
2074
            raise errors.UnexpectedSmartServerResponse(response)
2121
2075
        # Turn the response into a RemoteRepository object.
2129
2083
                a_bzrdir._client)
2130
2084
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2131
2085
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2132
 
            format=format, setup_stacking=False, name=name)
 
2086
            format=format, setup_stacking=False)
2133
2087
        # XXX: We know this is a new branch, so it must have revno 0, revid
2134
2088
        # NULL_REVISION. Creating the branch locked would make this be unable
2135
2089
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2162
2116
    """
2163
2117
 
2164
2118
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2165
 
        _client=None, format=None, setup_stacking=True, name=None):
 
2119
        _client=None, format=None, setup_stacking=True):
2166
2120
        """Create a RemoteBranch instance.
2167
2121
 
2168
2122
        :param real_branch: An optional local implementation of the branch
2174
2128
        :param setup_stacking: If True make an RPC call to determine the
2175
2129
            stacked (or not) status of the branch. If False assume the branch
2176
2130
            is not stacked.
2177
 
        :param name: Colocated branch name
2178
2131
        """
2179
2132
        # We intentionally don't call the parent class's __init__, because it
2180
2133
        # will try to assign to self.tags, which is a property in this subclass.
2199
2152
            self._real_branch = None
2200
2153
        # Fill out expected attributes of branch for bzrlib API users.
2201
2154
        self._clear_cached_state()
2202
 
        # TODO: deprecate self.base in favor of user_url
2203
 
        self.base = self.bzrdir.user_url
2204
 
        self._name = name
 
2155
        self.base = self.bzrdir.root_transport.base
2205
2156
        self._control_files = None
2206
2157
        self._lock_mode = None
2207
2158
        self._lock_token = None
2272
2223
                    'to use vfs implementation')
2273
2224
            self.bzrdir._ensure_real()
2274
2225
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2275
 
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
2226
                ignore_fallbacks=self._real_ignore_fallbacks)
2276
2227
            if self.repository._real_repository is None:
2277
2228
                # Give the remote repository the matching real repo.
2278
2229
                real_repo = self._real_branch.repository
2393
2344
            self._vfs_set_tags_bytes(bytes)
2394
2345
 
2395
2346
    def lock_read(self):
2396
 
        """Lock the branch for read operations.
2397
 
 
2398
 
        :return: A bzrlib.lock.LogicalLockResult.
2399
 
        """
2400
2347
        self.repository.lock_read()
2401
2348
        if not self._lock_mode:
2402
2349
            self._note_lock('r')
2406
2353
                self._real_branch.lock_read()
2407
2354
        else:
2408
2355
            self._lock_count += 1
2409
 
        return lock.LogicalLockResult(self.unlock)
2410
2356
 
2411
2357
    def _remote_lock_write(self, token):
2412
2358
        if token is None:
2413
2359
            branch_token = repo_token = ''
2414
2360
        else:
2415
2361
            branch_token = token
2416
 
            repo_token = self.repository.lock_write().repository_token
 
2362
            repo_token = self.repository.lock_write()
2417
2363
            self.repository.unlock()
2418
2364
        err_context = {'token': token}
2419
2365
        response = self._call(
2456
2402
            self._lock_count += 1
2457
2403
            # Re-lock the repository too.
2458
2404
            self.repository.lock_write(self._repo_lock_token)
2459
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2405
        return self._lock_token or None
2460
2406
 
2461
2407
    def _unlock(self, branch_token, repo_token):
2462
2408
        err_context = {'token': str((branch_token, repo_token))}