← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-05-07 11:50:28 UTC
  • mfrom: (5147.4.7 more-colo)
  • Revision ID: pqm@pqm.ubuntu.com-20100507115028-tuuxmnormm8oetw6
(vila, for jelmer) Pass the colocated branch name along in more places,
        add extra tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
33
33
    static_tuple,
34
34
    symbol_versioning,
35
35
)
36
 
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
36
from bzrlib.branch import BranchReferenceFormat
37
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
39
from bzrlib.errors import (
43
43
from bzrlib.lockable_files import LockableFiles
44
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
45
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
47
46
from bzrlib.trace import mutter, note, warning
48
47
 
49
48
 
273
272
    def create_workingtree(self, revision_id=None, from_branch=None):
274
273
        raise errors.NotLocalUrl(self.transport.base)
275
274
 
276
 
    def find_branch_format(self):
 
275
    def find_branch_format(self, name=None):
277
276
        """Find the branch 'format' for this bzrdir.
278
277
 
279
278
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
279
        """
281
 
        b = self.open_branch()
 
280
        b = self.open_branch(name=name)
282
281
        return b._format
283
282
 
284
 
    def get_branch_reference(self):
 
283
    def get_branch_reference(self, name=None):
285
284
        """See BzrDir.get_branch_reference()."""
 
285
        if name is not None:
 
286
            # XXX JRV20100304: Support opening colocated branches
 
287
            raise errors.NoColocatedBranchSupport(self)
286
288
        response = self._get_branch_reference()
287
289
        if response[0] == 'ref':
288
290
            return response[1]
319
321
            raise errors.UnexpectedSmartServerResponse(response)
320
322
        return response
321
323
 
322
 
    def _get_tree_branch(self):
 
324
    def _get_tree_branch(self, name=None):
323
325
        """See BzrDir._get_tree_branch()."""
324
 
        return None, self.open_branch()
 
326
        return None, self.open_branch(name=name)
325
327
 
326
328
    def open_branch(self, name=None, unsupported=False,
327
329
                    ignore_fallbacks=False):
998
1000
        pass
999
1001
 
1000
1002
    def lock_read(self):
1001
 
        """Lock the repository for read operations.
1002
 
 
1003
 
        :return: An object with an unlock method which will release the lock
1004
 
            obtained.
1005
 
        """
1006
1003
        # wrong eventually - want a local lock cache context
1007
1004
        if not self._lock_mode:
1008
1005
            self._note_lock('r')
1015
1012
                repo.lock_read()
1016
1013
        else:
1017
1014
            self._lock_count += 1
1018
 
        return self
1019
1015
 
1020
1016
    def _remote_lock_write(self, token):
1021
1017
        path = self.bzrdir._path_for_remote_call(self._client)
1061
1057
            raise errors.ReadOnlyError(self)
1062
1058
        else:
1063
1059
            self._lock_count += 1
1064
 
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1060
        return self._lock_token or None
1065
1061
 
1066
1062
    def leave_lock_in_place(self):
1067
1063
        if not self._lock_token:
1313
1309
        return self._real_repository.make_working_trees()
1314
1310
 
1315
1311
    def refresh_data(self):
1316
 
        """Re-read any data needed to to synchronise with disk.
 
1312
        """Re-read any data needed to synchronise with disk.
1317
1313
 
1318
1314
        This method is intended to be called after another repository instance
1319
1315
        (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.
 
1316
        repository. On all repositories this will work outside of write groups.
 
1317
        Some repository formats (pack and newer for bzrlib native formats)
 
1318
        support refresh_data inside write groups. If called inside a write
 
1319
        group on a repository that does not support refreshing in a write group
 
1320
        IsInWriteGroupError will be raised.
1322
1321
        """
1323
 
        if self.is_in_write_group():
1324
 
            raise errors.InternalBzrError(
1325
 
                "May not refresh_data while in a write group.")
1326
1322
        if self._real_repository is not None:
1327
1323
            self._real_repository.refresh_data()
1328
1324
 
2394
2390
            self._vfs_set_tags_bytes(bytes)
2395
2391
 
2396
2392
    def lock_read(self):
2397
 
        """Lock the branch for read operations.
2398
 
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
2401
 
        """
2402
2393
        self.repository.lock_read()
2403
2394
        if not self._lock_mode:
2404
2395
            self._note_lock('r')
2408
2399
                self._real_branch.lock_read()
2409
2400
        else:
2410
2401
            self._lock_count += 1
2411
 
        return self
2412
2402
 
2413
2403
    def _remote_lock_write(self, token):
2414
2404
        if token is None:
2415
2405
            branch_token = repo_token = ''
2416
2406
        else:
2417
2407
            branch_token = token
2418
 
            repo_token = self.repository.lock_write().repository_token
 
2408
            repo_token = self.repository.lock_write()
2419
2409
            self.repository.unlock()
2420
2410
        err_context = {'token': token}
2421
2411
        response = self._call(
2458
2448
            self._lock_count += 1
2459
2449
            # Re-lock the repository too.
2460
2450
            self.repository.lock_write(self._repo_lock_token)
2461
 
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
2451
        return self._lock_token or None
2462
2452
 
2463
2453
    def _unlock(self, branch_token, repo_token):
2464
2454
        err_context = {'token': str((branch_token, repo_token))}