/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: Parth Malwankar
  • Date: 2010-04-14 10:12:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5156.
  • Revision ID: parth.malwankar@gmail.com-20100414101222-uiu2ucurptoz1dg1
improved bug description.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
27
27
    lock,
28
28
    lockdir,
29
29
    repository,
30
 
    repository as _mod_repository,
31
30
    revision,
32
31
    revision as _mod_revision,
33
32
    static_tuple,
34
33
    symbol_versioning,
35
34
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
35
from bzrlib.branch import BranchReferenceFormat
37
36
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
37
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
38
from bzrlib.errors import (
43
42
from bzrlib.lockable_files import LockableFiles
44
43
from bzrlib.smart import client, vfs, repository as smart_repo
45
44
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
45
from bzrlib.trace import mutter, note, warning
48
46
 
49
47
 
273
271
    def create_workingtree(self, revision_id=None, from_branch=None):
274
272
        raise errors.NotLocalUrl(self.transport.base)
275
273
 
276
 
    def find_branch_format(self, name=None):
 
274
    def find_branch_format(self):
277
275
        """Find the branch 'format' for this bzrdir.
278
276
 
279
277
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
278
        """
281
 
        b = self.open_branch(name=name)
 
279
        b = self.open_branch()
282
280
        return b._format
283
281
 
284
 
    def get_branch_reference(self, name=None):
 
282
    def get_branch_reference(self):
285
283
        """See BzrDir.get_branch_reference()."""
286
 
        if name is not None:
287
 
            # XXX JRV20100304: Support opening colocated branches
288
 
            raise errors.NoColocatedBranchSupport(self)
289
284
        response = self._get_branch_reference()
290
285
        if response[0] == 'ref':
291
286
            return response[1]
322
317
            raise errors.UnexpectedSmartServerResponse(response)
323
318
        return response
324
319
 
325
 
    def _get_tree_branch(self, name=None):
 
320
    def _get_tree_branch(self):
326
321
        """See BzrDir._get_tree_branch()."""
327
 
        return None, self.open_branch(name=name)
 
322
        return None, self.open_branch()
328
323
 
329
324
    def open_branch(self, name=None, unsupported=False,
330
325
                    ignore_fallbacks=False):
647
642
        return self._custom_format._serializer
648
643
 
649
644
 
650
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
 
    bzrdir.ControlComponent):
 
645
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
652
646
    """Repository accessed over rpc.
653
647
 
654
648
    For the moment most operations are performed using local transport-backed
697
691
        # Additional places to query for data.
698
692
        self._fallback_repositories = []
699
693
 
700
 
    @property
701
 
    def user_transport(self):
702
 
        return self.bzrdir.user_transport
703
 
 
704
 
    @property
705
 
    def control_transport(self):
706
 
        # XXX: Normally you shouldn't directly get at the remote repository
707
 
        # transport, but I'm not sure it's worth making this method
708
 
        # optional -- mbp 2010-04-21
709
 
        return self.bzrdir.get_repository_transport(None)
710
 
        
711
694
    def __str__(self):
712
695
        return "%s(%s)" % (self.__class__.__name__, self.base)
713
696
 
1001
984
        pass
1002
985
 
1003
986
    def lock_read(self):
1004
 
        """Lock the repository for read operations.
1005
 
 
1006
 
        :return: A bzrlib.lock.LogicalLockResult.
1007
 
        """
1008
987
        # wrong eventually - want a local lock cache context
1009
988
        if not self._lock_mode:
1010
989
            self._note_lock('r')
1017
996
                repo.lock_read()
1018
997
        else:
1019
998
            self._lock_count += 1
1020
 
        return lock.LogicalLockResult(self.unlock)
1021
999
 
1022
1000
    def _remote_lock_write(self, token):
1023
1001
        path = self.bzrdir._path_for_remote_call(self._client)
1063
1041
            raise errors.ReadOnlyError(self)
1064
1042
        else:
1065
1043
            self._lock_count += 1
1066
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1044
        return self._lock_token or None
1067
1045
 
1068
1046
    def leave_lock_in_place(self):
1069
1047
        if not self._lock_token:
1249
1227
            # state, so always add a lock here. If a caller passes us a locked
1250
1228
            # repository, they are responsible for unlocking it later.
1251
1229
            repository.lock_read()
1252
 
        self._check_fallback_repository(repository)
1253
1230
        self._fallback_repositories.append(repository)
1254
1231
        # If self._real_repository was parameterised already (e.g. because a
1255
1232
        # _real_branch had its get_stacked_on_url method called), then the
1256
1233
        # repository to be added may already be in the _real_repositories list.
1257
1234
        if self._real_repository is not None:
1258
 
            fallback_locations = [repo.user_url for repo in
 
1235
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
1259
1236
                self._real_repository._fallback_repositories]
1260
 
            if repository.user_url not in fallback_locations:
 
1237
            if repository.bzrdir.root_transport.base not in fallback_locations:
1261
1238
                self._real_repository.add_fallback_repository(repository)
1262
1239
 
1263
 
    def _check_fallback_repository(self, repository):
1264
 
        """Check that this repository can fallback to repository safely.
1265
 
 
1266
 
        Raise an error if not.
1267
 
 
1268
 
        :param repository: A repository to fallback to.
1269
 
        """
1270
 
        return _mod_repository.InterRepository._assert_same_model(
1271
 
            self, repository)
1272
 
 
1273
1240
    def add_inventory(self, revid, inv, parents):
1274
1241
        self._ensure_real()
1275
1242
        return self._real_repository.add_inventory(revid, inv, parents)
1315
1282
        return self._real_repository.make_working_trees()
1316
1283
 
1317
1284
    def refresh_data(self):
1318
 
        """Re-read any data needed to synchronise with disk.
 
1285
        """Re-read any data needed to to synchronise with disk.
1319
1286
 
1320
1287
        This method is intended to be called after another repository instance
1321
1288
        (such as one used by a smart server) has inserted data into the
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.
 
1289
        repository. It may not be called during a write group, but may be
 
1290
        called at any other time.
1327
1291
        """
 
1292
        if self.is_in_write_group():
 
1293
            raise errors.InternalBzrError(
 
1294
                "May not refresh_data while in a write group.")
1328
1295
        if self._real_repository is not None:
1329
1296
            self._real_repository.refresh_data()
1330
1297
 
1628
1595
        return self._real_repository.inventories
1629
1596
 
1630
1597
    @needs_write_lock
1631
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1598
    def pack(self, hint=None):
1632
1599
        """Compress the data within the repository.
1633
1600
 
1634
1601
        This is not currently implemented within the smart server.
1635
1602
        """
1636
1603
        self._ensure_real()
1637
 
        return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
 
1604
        return self._real_repository.pack(hint=hint)
1638
1605
 
1639
1606
    @property
1640
1607
    def revisions(self):
2202
2169
            self._real_branch = None
2203
2170
        # Fill out expected attributes of branch for bzrlib API users.
2204
2171
        self._clear_cached_state()
2205
 
        # TODO: deprecate self.base in favor of user_url
2206
 
        self.base = self.bzrdir.user_url
 
2172
        self.base = self.bzrdir.root_transport.base
2207
2173
        self._name = name
2208
2174
        self._control_files = None
2209
2175
        self._lock_mode = None
2396
2362
            self._vfs_set_tags_bytes(bytes)
2397
2363
 
2398
2364
    def lock_read(self):
2399
 
        """Lock the branch for read operations.
2400
 
 
2401
 
        :return: A bzrlib.lock.LogicalLockResult.
2402
 
        """
2403
2365
        self.repository.lock_read()
2404
2366
        if not self._lock_mode:
2405
2367
            self._note_lock('r')
2409
2371
                self._real_branch.lock_read()
2410
2372
        else:
2411
2373
            self._lock_count += 1
2412
 
        return lock.LogicalLockResult(self.unlock)
2413
2374
 
2414
2375
    def _remote_lock_write(self, token):
2415
2376
        if token is None:
2416
2377
            branch_token = repo_token = ''
2417
2378
        else:
2418
2379
            branch_token = token
2419
 
            repo_token = self.repository.lock_write().repository_token
 
2380
            repo_token = self.repository.lock_write()
2420
2381
            self.repository.unlock()
2421
2382
        err_context = {'token': token}
2422
2383
        response = self._call(
2459
2420
            self._lock_count += 1
2460
2421
            # Re-lock the repository too.
2461
2422
            self.repository.lock_write(self._repo_lock_token)
2462
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2423
        return self._lock_token or None
2463
2424
 
2464
2425
    def _unlock(self, branch_token, repo_token):
2465
2426
        err_context = {'token': str((branch_token, repo_token))}