/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: Jelmer Vernooij
  • Date: 2011-11-25 17:54:52 UTC
  • mfrom: (6303 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6321.
  • Revision ID: jelmer@samba.org-20111125175452-v0uwwxqcp97tzuzv
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
27
27
    graph,
28
28
    lock,
29
29
    lockdir,
 
30
    registry,
30
31
    repository as _mod_repository,
31
32
    revision as _mod_revision,
32
33
    static_tuple,
41
42
    SmartProtocolError,
42
43
    )
43
44
from bzrlib.i18n import gettext
 
45
from bzrlib.inventory import Inventory
44
46
from bzrlib.lockable_files import LockableFiles
45
47
from bzrlib.smart import client, vfs, repository as smart_repo
46
48
from bzrlib.smart.client import _SmartClient
47
49
from bzrlib.revision import NULL_REVISION
 
50
from bzrlib.revisiontree import InventoryRevisionTree
48
51
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
49
 
from bzrlib.trace import mutter, note, warning
 
52
from bzrlib.trace import mutter, note, warning, log_exception_quietly
50
53
 
51
54
 
52
55
_DEFAULT_SEARCH_DEPTH = 100
331
334
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
332
335
 
333
336
 
 
337
class RemoteControlStore(config.IniFileStore):
 
338
    """Control store which attempts to use HPSS calls to retrieve control store.
 
339
 
 
340
    Note that this is specific to bzr-based formats.
 
341
    """
 
342
 
 
343
    def __init__(self, bzrdir):
 
344
        super(RemoteControlStore, self).__init__()
 
345
        self.bzrdir = bzrdir
 
346
        self._real_store = None
 
347
 
 
348
    def lock_write(self, token=None):
 
349
        self._ensure_real()
 
350
        return self._real_store.lock_write(token)
 
351
 
 
352
    def unlock(self):
 
353
        self._ensure_real()
 
354
        return self._real_store.unlock()
 
355
 
 
356
    @needs_write_lock
 
357
    def save(self):
 
358
        # We need to be able to override the undecorated implementation
 
359
        self.save_without_locking()
 
360
 
 
361
    def save_without_locking(self):
 
362
        super(RemoteControlStore, self).save()
 
363
 
 
364
    def _ensure_real(self):
 
365
        self.bzrdir._ensure_real()
 
366
        if self._real_store is None:
 
367
            self._real_store = config.ControlStore(self.bzrdir)
 
368
 
 
369
    def external_url(self):
 
370
        return self.bzrdir.user_url
 
371
 
 
372
    def _load_content(self):
 
373
        medium = self.bzrdir._client._medium
 
374
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
375
        try:
 
376
            response, handler = self.bzrdir._call_expecting_body(
 
377
                'BzrDir.get_config_file', path)
 
378
        except errors.UnknownSmartMethod:
 
379
            self._ensure_real()
 
380
            return self._real_store._load_content()
 
381
        if len(response) and response[0] != 'ok':
 
382
            raise errors.UnexpectedSmartServerResponse(response)
 
383
        return handler.read_body_bytes()
 
384
 
 
385
    def _save_content(self, content):
 
386
        # FIXME JRV 2011-11-22: Ideally this should use a
 
387
        # HPSS call too, but at the moment it is not possible
 
388
        # to write lock control directories.
 
389
        self._ensure_real()
 
390
        return self._real_store._save_content(content)
 
391
 
 
392
 
334
393
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
335
394
    """Control directory on a remote server, accessed via bzr:// or similar."""
336
395
 
484
543
 
485
544
    def destroy_repository(self):
486
545
        """See BzrDir.destroy_repository"""
487
 
        self._ensure_real()
488
 
        self._real_bzrdir.destroy_repository()
 
546
        path = self._path_for_remote_call(self._client)
 
547
        try:
 
548
            response = self._call('BzrDir.destroy_repository', path)
 
549
        except errors.UnknownSmartMethod:
 
550
            self._ensure_real()
 
551
            self._real_bzrdir.destroy_repository()
 
552
            return
 
553
        if response[0] != 'ok':
 
554
            raise SmartProtocolError('unexpected response code %s' % (response,))
489
555
 
490
556
    def create_branch(self, name=None, repository=None,
491
557
                      append_revisions_only=None):
513
579
 
514
580
    def destroy_branch(self, name=None):
515
581
        """See BzrDir.destroy_branch"""
516
 
        self._ensure_real()
517
 
        self._real_bzrdir.destroy_branch(name=name)
 
582
        path = self._path_for_remote_call(self._client)
 
583
        try:
 
584
            if name is not None:
 
585
                args = (name, )
 
586
            else:
 
587
                args = ()
 
588
            response = self._call('BzrDir.destroy_branch', path, *args)
 
589
        except errors.UnknownSmartMethod:
 
590
            self._ensure_real()
 
591
            self._real_bzrdir.destroy_branch(name=name)
 
592
            self._next_open_branch_result = None
 
593
            return
518
594
        self._next_open_branch_result = None
 
595
        if response[0] != 'ok':
 
596
            raise SmartProtocolError('unexpected response code %s' % (response,))
519
597
 
520
598
    def create_workingtree(self, revision_id=None, from_branch=None,
521
599
        accelerator_tree=None, hardlink=False):
663
741
 
664
742
    def has_workingtree(self):
665
743
        if self._has_working_tree is None:
666
 
            self._ensure_real()
667
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
744
            path = self._path_for_remote_call(self._client)
 
745
            try:
 
746
                response = self._call('BzrDir.has_workingtree', path)
 
747
            except errors.UnknownSmartMethod:
 
748
                self._ensure_real()
 
749
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
750
            else:
 
751
                if response[0] not in ('yes', 'no'):
 
752
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
753
                self._has_working_tree = (response[0] == 'yes')
668
754
        return self._has_working_tree
669
755
 
670
756
    def open_workingtree(self, recommend_upgrade=True):
698
784
        """Upgrading of remote bzrdirs is not supported yet."""
699
785
        return False
700
786
 
701
 
    def clone(self, url, revision_id=None, force_new_repo=False,
702
 
              preserve_stacking=False):
703
 
        self._ensure_real()
704
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
705
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
706
 
 
707
787
    def _get_config(self):
708
788
        return RemoteBzrDirConfig(self)
709
789
 
 
790
    def _get_config_store(self):
 
791
        return RemoteControlStore(self)
 
792
 
710
793
 
711
794
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
712
795
    """Format for repositories accessed over a _SmartClient.
922
1005
        return self._custom_format._serializer
923
1006
 
924
1007
 
925
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
926
 
    controldir.ControlComponent):
 
1008
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1009
        lock._RelockDebugMixin):
927
1010
    """Repository accessed over rpc.
928
1011
 
929
1012
    For the moment most operations are performed using local transport-backed
953
1036
        self._format = format
954
1037
        self._lock_mode = None
955
1038
        self._lock_token = None
 
1039
        self._write_group_tokens = None
956
1040
        self._lock_count = 0
957
1041
        self._leave_lock = False
958
1042
        # Cache of revision parents; misses are cached during read locks, and
998
1082
 
999
1083
        :param suppress_errors: see Repository.abort_write_group.
1000
1084
        """
1001
 
        self._ensure_real()
1002
 
        return self._real_repository.abort_write_group(
1003
 
            suppress_errors=suppress_errors)
 
1085
        if self._real_repository:
 
1086
            self._ensure_real()
 
1087
            return self._real_repository.abort_write_group(
 
1088
                suppress_errors=suppress_errors)
 
1089
        if not self.is_in_write_group():
 
1090
            if suppress_errors:
 
1091
                mutter('(suppressed) not in write group')
 
1092
                return
 
1093
            raise errors.BzrError("not in write group")
 
1094
        path = self.bzrdir._path_for_remote_call(self._client)
 
1095
        try:
 
1096
            response = self._call('Repository.abort_write_group', path,
 
1097
                self._lock_token, self._write_group_tokens)
 
1098
        except Exception, exc:
 
1099
            self._write_group = None
 
1100
            if not suppress_errors:
 
1101
                raise
 
1102
            mutter('abort_write_group failed')
 
1103
            log_exception_quietly()
 
1104
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1105
        else:
 
1106
            if response != ('ok', ):
 
1107
                raise errors.UnexpectedSmartServerResponse(response)
 
1108
            self._write_group_tokens = None
1004
1109
 
1005
1110
    @property
1006
1111
    def chk_bytes(self):
1020
1125
        for older plugins that don't use e.g. the CommitBuilder
1021
1126
        facility.
1022
1127
        """
1023
 
        self._ensure_real()
1024
 
        return self._real_repository.commit_write_group()
 
1128
        if self._real_repository:
 
1129
            self._ensure_real()
 
1130
            return self._real_repository.commit_write_group()
 
1131
        if not self.is_in_write_group():
 
1132
            raise errors.BzrError("not in write group")
 
1133
        path = self.bzrdir._path_for_remote_call(self._client)
 
1134
        response = self._call('Repository.commit_write_group', path,
 
1135
            self._lock_token, self._write_group_tokens)
 
1136
        if response != ('ok', ):
 
1137
            raise errors.UnexpectedSmartServerResponse(response)
 
1138
        self._write_group_tokens = None
1025
1139
 
1026
1140
    def resume_write_group(self, tokens):
1027
 
        self._ensure_real()
1028
 
        return self._real_repository.resume_write_group(tokens)
 
1141
        if self._real_repository:
 
1142
            return self._real_repository.resume_write_group(tokens)
 
1143
        path = self.bzrdir._path_for_remote_call(self._client)
 
1144
        try:
 
1145
            response = self._call('Repository.check_write_group', path,
 
1146
               self._lock_token, tokens)
 
1147
        except errors.UnknownSmartMethod:
 
1148
            self._ensure_real()
 
1149
            return self._real_repository.resume_write_group(tokens)
 
1150
        if response != ('ok', ):
 
1151
            raise errors.UnexpectedSmartServerResponse(response)
 
1152
        self._write_group_tokens = tokens
1029
1153
 
1030
1154
    def suspend_write_group(self):
1031
 
        self._ensure_real()
1032
 
        return self._real_repository.suspend_write_group()
 
1155
        if self._real_repository:
 
1156
            return self._real_repository.suspend_write_group()
 
1157
        ret = self._write_group_tokens or []
 
1158
        self._write_group_tokens = None
 
1159
        return ret
1033
1160
 
1034
1161
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
1035
1162
        self._ensure_real()
1245
1372
 
1246
1373
    def get_physical_lock_status(self):
1247
1374
        """See Repository.get_physical_lock_status()."""
1248
 
        # should be an API call to the server.
1249
 
        self._ensure_real()
1250
 
        return self._real_repository.get_physical_lock_status()
 
1375
        path = self.bzrdir._path_for_remote_call(self._client)
 
1376
        try:
 
1377
            response = self._call('Repository.get_physical_lock_status', path)
 
1378
        except errors.UnknownSmartMethod:
 
1379
            self._ensure_real()
 
1380
            return self._real_repository.get_physical_lock_status()
 
1381
        if response[0] not in ('yes', 'no'):
 
1382
            raise errors.UnexpectedSmartServerResponse(response)
 
1383
        return (response[0] == 'yes')
1251
1384
 
1252
1385
    def is_in_write_group(self):
1253
1386
        """Return True if there is an open write group.
1254
1387
 
1255
1388
        write groups are only applicable locally for the smart server..
1256
1389
        """
 
1390
        if self._write_group_tokens is not None:
 
1391
            return True
1257
1392
        if self._real_repository:
1258
1393
            return self._real_repository.is_in_write_group()
1259
1394
 
1394
1529
            self._real_repository.lock_write(self._lock_token)
1395
1530
        elif self._lock_mode == 'r':
1396
1531
            self._real_repository.lock_read()
 
1532
        if self._write_group_tokens is not None:
 
1533
            # if we are already in a write group, resume it
 
1534
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1535
            self._write_group_tokens = None
1397
1536
 
1398
1537
    def start_write_group(self):
1399
1538
        """Start a write group on the decorated repository.
1403
1542
        for older plugins that don't use e.g. the CommitBuilder
1404
1543
        facility.
1405
1544
        """
1406
 
        self._ensure_real()
1407
 
        return self._real_repository.start_write_group()
 
1545
        if self._real_repository:
 
1546
            self._ensure_real()
 
1547
            return self._real_repository.start_write_group()
 
1548
        if not self.is_write_locked():
 
1549
            raise errors.NotWriteLocked(self)
 
1550
        if self._write_group_tokens is not None:
 
1551
            raise errors.BzrError('already in a write group')
 
1552
        path = self.bzrdir._path_for_remote_call(self._client)
 
1553
        try:
 
1554
            response = self._call('Repository.start_write_group', path,
 
1555
                self._lock_token)
 
1556
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1557
            self._ensure_real()
 
1558
            return self._real_repository.start_write_group()
 
1559
        if response[0] != 'ok':
 
1560
            raise errors.UnexpectedSmartServerResponse(response)
 
1561
        self._write_group_tokens = response[1]
1408
1562
 
1409
1563
    def _unlock(self, token):
1410
1564
        path = self.bzrdir._path_for_remote_call(self._client)
1437
1591
            # This is just to let the _real_repository stay up to date.
1438
1592
            if self._real_repository is not None:
1439
1593
                self._real_repository.unlock()
 
1594
            elif self._write_group_tokens is not None:
 
1595
                self.abort_write_group()
1440
1596
        finally:
1441
1597
            # The rpc-level lock should be released even if there was a
1442
1598
            # problem releasing the vfs-based lock.
1454
1610
 
1455
1611
    def break_lock(self):
1456
1612
        # should hand off to the network
1457
 
        self._ensure_real()
1458
 
        return self._real_repository.break_lock()
 
1613
        path = self.bzrdir._path_for_remote_call(self._client)
 
1614
        try:
 
1615
            response = self._call("Repository.break_lock", path)
 
1616
        except errors.UnknownSmartMethod:
 
1617
            self._ensure_real()
 
1618
            return self._real_repository.break_lock()
 
1619
        if response != ('ok',):
 
1620
            raise errors.UnexpectedSmartServerResponse(response)
1459
1621
 
1460
1622
    def _get_tarball(self, compression):
1461
1623
        """Return a TemporaryFile containing a repository tarball.
1479
1641
            return t
1480
1642
        raise errors.UnexpectedSmartServerResponse(response)
1481
1643
 
 
1644
    @needs_read_lock
1482
1645
    def sprout(self, to_bzrdir, revision_id=None):
1483
 
        # TODO: Option to control what format is created?
1484
 
        self._ensure_real()
1485
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1486
 
                                                             shared=False)
 
1646
        """Create a descendent repository for new development.
 
1647
 
 
1648
        Unlike clone, this does not copy the settings of the repository.
 
1649
        """
 
1650
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1487
1651
        dest_repo.fetch(self, revision_id=revision_id)
1488
1652
        return dest_repo
1489
1653
 
 
1654
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1655
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1656
            # use target default format.
 
1657
            dest_repo = a_bzrdir.create_repository()
 
1658
        else:
 
1659
            # Most control formats need the repository to be specifically
 
1660
            # created, but on some old all-in-one formats it's not needed
 
1661
            try:
 
1662
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1663
            except errors.UninitializableFormat:
 
1664
                dest_repo = a_bzrdir.open_repository()
 
1665
        return dest_repo
 
1666
 
1490
1667
    ### These methods are just thin shims to the VFS object for now.
1491
1668
 
 
1669
    @needs_read_lock
1492
1670
    def revision_tree(self, revision_id):
1493
 
        self._ensure_real()
1494
 
        return self._real_repository.revision_tree(revision_id)
 
1671
        revision_id = _mod_revision.ensure_null(revision_id)
 
1672
        if revision_id == _mod_revision.NULL_REVISION:
 
1673
            return InventoryRevisionTree(self,
 
1674
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1675
        else:
 
1676
            return list(self.revision_trees([revision_id]))[0]
1495
1677
 
1496
1678
    def get_serializer_format(self):
1497
 
        self._ensure_real()
1498
 
        return self._real_repository.get_serializer_format()
 
1679
        path = self.bzrdir._path_for_remote_call(self._client)
 
1680
        try:
 
1681
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1682
                path)
 
1683
        except errors.UnknownSmartMethod:
 
1684
            self._ensure_real()
 
1685
            return self._real_repository.get_serializer_format()
 
1686
        if response[0] != 'ok':
 
1687
            raise errors.UnexpectedSmartServerResponse(response)
 
1688
        return response[1]
1499
1689
 
1500
1690
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1501
1691
                           timezone=None, committer=None, revprops=None,
1575
1765
 
1576
1766
    @needs_read_lock
1577
1767
    def get_revision(self, revision_id):
1578
 
        self._ensure_real()
1579
 
        return self._real_repository.get_revision(revision_id)
 
1768
        return self.get_revisions([revision_id])[0]
1580
1769
 
1581
1770
    def get_transaction(self):
1582
1771
        self._ensure_real()
1584
1773
 
1585
1774
    @needs_read_lock
1586
1775
    def clone(self, a_bzrdir, revision_id=None):
1587
 
        self._ensure_real()
1588
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1776
        dest_repo = self._create_sprouting_repo(
 
1777
            a_bzrdir, shared=self.is_shared())
 
1778
        self.copy_content_into(dest_repo, revision_id)
 
1779
        return dest_repo
1589
1780
 
1590
1781
    def make_working_trees(self):
1591
1782
        """See Repository.make_working_trees"""
1592
 
        self._ensure_real()
1593
 
        return self._real_repository.make_working_trees()
 
1783
        path = self.bzrdir._path_for_remote_call(self._client)
 
1784
        try:
 
1785
            response = self._call('Repository.make_working_trees', path)
 
1786
        except errors.UnknownSmartMethod:
 
1787
            self._ensure_real()
 
1788
            return self._real_repository.make_working_trees()
 
1789
        if response[0] not in ('yes', 'no'):
 
1790
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1791
        return response[0] == 'yes'
1594
1792
 
1595
1793
    def refresh_data(self):
1596
1794
        """Re-read any data needed to synchronise with disk.
1841
2039
        return self._real_repository.reconcile(other=other, thorough=thorough)
1842
2040
 
1843
2041
    def all_revision_ids(self):
1844
 
        self._ensure_real()
1845
 
        return self._real_repository.all_revision_ids()
 
2042
        path = self.bzrdir._path_for_remote_call(self._client)
 
2043
        try:
 
2044
            response_tuple, response_handler = self._call_expecting_body(
 
2045
                "Repository.all_revision_ids", path)
 
2046
        except errors.UnknownSmartMethod:
 
2047
            self._ensure_real()
 
2048
            return self._real_repository.all_revision_ids()
 
2049
        if response_tuple != ("ok", ):
 
2050
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2051
        revids = set(response_handler.read_body_bytes().splitlines())
 
2052
        for fallback in self._fallback_repositories:
 
2053
            revids.update(set(fallback.all_revision_ids()))
 
2054
        return list(revids)
1846
2055
 
1847
2056
    @needs_read_lock
1848
2057
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1852
2061
 
1853
2062
    @needs_read_lock
1854
2063
    def get_revision_delta(self, revision_id, specific_fileids=None):
1855
 
        self._ensure_real()
1856
 
        return self._real_repository.get_revision_delta(revision_id,
1857
 
            specific_fileids=specific_fileids)
 
2064
        r = self.get_revision(revision_id)
 
2065
        return list(self.get_deltas_for_revisions([r],
 
2066
            specific_fileids=specific_fileids))[0]
1858
2067
 
1859
2068
    @needs_read_lock
1860
2069
    def revision_trees(self, revision_ids):
1873
2082
            callback_refs=callback_refs, check_repo=check_repo)
1874
2083
 
1875
2084
    def copy_content_into(self, destination, revision_id=None):
1876
 
        self._ensure_real()
1877
 
        return self._real_repository.copy_content_into(
1878
 
            destination, revision_id=revision_id)
 
2085
        """Make a complete copy of the content in self into destination.
 
2086
 
 
2087
        This is a destructive operation! Do not use it on existing
 
2088
        repositories.
 
2089
        """
 
2090
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2091
        return interrepo.copy_content(revision_id)
1879
2092
 
1880
2093
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1881
2094
        # get a tarball of the remote repository, and copy from that into the
1994
2207
    def _serializer(self):
1995
2208
        return self._format._serializer
1996
2209
 
 
2210
    @needs_write_lock
1997
2211
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1998
 
        self._ensure_real()
1999
 
        return self._real_repository.store_revision_signature(
2000
 
            gpg_strategy, plaintext, revision_id)
 
2212
        signature = gpg_strategy.sign(plaintext)
 
2213
        self.add_signature_text(revision_id, signature)
2001
2214
 
2002
2215
    def add_signature_text(self, revision_id, signature):
2003
2216
        self._ensure_real()
2004
2217
        return self._real_repository.add_signature_text(revision_id, signature)
2005
2218
 
2006
2219
    def has_signature_for_revision_id(self, revision_id):
 
2220
        path = self.bzrdir._path_for_remote_call(self._client)
 
2221
        try:
 
2222
            response = self._call('Repository.has_signature_for_revision_id',
 
2223
                path, revision_id)
 
2224
        except errors.UnknownSmartMethod:
 
2225
            self._ensure_real()
 
2226
            return self._real_repository.has_signature_for_revision_id(
 
2227
                revision_id)
 
2228
        if response[0] not in ('yes', 'no'):
 
2229
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2230
        return (response[0] == 'yes')
 
2231
 
 
2232
    def verify_revision_signature(self, revision_id, gpg_strategy):
2007
2233
        self._ensure_real()
2008
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2234
        return self._real_repository.verify_revision_signature(
 
2235
            revision_id, gpg_strategy)
2009
2236
 
2010
2237
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
2011
2238
        self._ensure_real()
2481
2708
                return True
2482
2709
        return False
2483
2710
 
 
2711
 
 
2712
class RemoteBranchStore(config.IniFileStore):
 
2713
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2714
 
 
2715
    Note that this is specific to bzr-based formats.
 
2716
    """
 
2717
 
 
2718
    def __init__(self, branch):
 
2719
        super(RemoteBranchStore, self).__init__()
 
2720
        self.branch = branch
 
2721
        self.id = "branch"
 
2722
        self._real_store = None
 
2723
 
 
2724
    def lock_write(self, token=None):
 
2725
        return self.branch.lock_write(token)
 
2726
 
 
2727
    def unlock(self):
 
2728
        return self.branch.unlock()
 
2729
 
 
2730
    @needs_write_lock
 
2731
    def save(self):
 
2732
        # We need to be able to override the undecorated implementation
 
2733
        self.save_without_locking()
 
2734
 
 
2735
    def save_without_locking(self):
 
2736
        super(RemoteBranchStore, self).save()
 
2737
 
 
2738
    def external_url(self):
 
2739
        return self.branch.user_url
 
2740
 
 
2741
    def _load_content(self):
 
2742
        path = self.branch._remote_path()
 
2743
        try:
 
2744
            response, handler = self.branch._call_expecting_body(
 
2745
                'Branch.get_config_file', path)
 
2746
        except errors.UnknownSmartMethod:
 
2747
            self._ensure_real()
 
2748
            return self._real_store._load_content()
 
2749
        if len(response) and response[0] != 'ok':
 
2750
            raise errors.UnexpectedSmartServerResponse(response)
 
2751
        return handler.read_body_bytes()
 
2752
 
 
2753
    def _save_content(self, content):
 
2754
        path = self.branch._remote_path()
 
2755
        try:
 
2756
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
2757
                'Branch.put_config_file', (path,
 
2758
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2759
                content)
 
2760
        except errors.UnknownSmartMethod:
 
2761
            self._ensure_real()
 
2762
            return self._real_store._save_content(content)
 
2763
        handler.cancel_read_body()
 
2764
        if response != ('ok', ):
 
2765
            raise errors.UnexpectedSmartServerResponse(response)
 
2766
 
 
2767
    def _ensure_real(self):
 
2768
        self.branch._ensure_real()
 
2769
        if self._real_store is None:
 
2770
            self._real_store = config.BranchStore(self.branch)
 
2771
 
 
2772
 
2484
2773
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2485
2774
    """Branch stored on a server accessed by HPSS RPC.
2486
2775
 
2575
2864
    def _get_config(self):
2576
2865
        return RemoteBranchConfig(self)
2577
2866
 
 
2867
    def _get_config_store(self):
 
2868
        return RemoteBranchStore(self)
 
2869
 
2578
2870
    def _get_real_transport(self):
2579
2871
        # if we try vfs access, return the real branch's vfs transport
2580
2872
        self._ensure_real()
2656
2948
 
2657
2949
    def get_physical_lock_status(self):
2658
2950
        """See Branch.get_physical_lock_status()."""
2659
 
        # should be an API call to the server, as branches must be lockable.
2660
 
        self._ensure_real()
2661
 
        return self._real_branch.get_physical_lock_status()
 
2951
        try:
 
2952
            response = self._client.call('Branch.get_physical_lock_status',
 
2953
                self._remote_path())
 
2954
        except errors.UnknownSmartMethod:
 
2955
            self._ensure_real()
 
2956
            return self._real_branch.get_physical_lock_status()
 
2957
        if response[0] not in ('yes', 'no'):
 
2958
            raise errors.UnexpectedSmartServerResponse(response)
 
2959
        return (response[0] == 'yes')
2662
2960
 
2663
2961
    def get_stacked_on_url(self):
2664
2962
        """Get the URL this branch is stacked against.
2848
3146
            self.repository.unlock()
2849
3147
 
2850
3148
    def break_lock(self):
2851
 
        self._ensure_real()
2852
 
        return self._real_branch.break_lock()
 
3149
        try:
 
3150
            response = self._call(
 
3151
                'Branch.break_lock', self._remote_path())
 
3152
        except errors.UnknownSmartMethod:
 
3153
            self._ensure_real()
 
3154
            return self._real_branch.break_lock()
 
3155
        if response != ('ok',):
 
3156
            raise errors.UnexpectedSmartServerResponse(response)
2853
3157
 
2854
3158
    def leave_lock_in_place(self):
2855
3159
        if not self._lock_token:
3029
3333
        return self._lock_count >= 1
3030
3334
 
3031
3335
    @needs_read_lock
 
3336
    def revision_id_to_dotted_revno(self, revision_id):
 
3337
        """Given a revision id, return its dotted revno.
 
3338
 
 
3339
        :return: a tuple like (1,) or (400,1,3).
 
3340
        """
 
3341
        try:
 
3342
            response = self._call('Branch.revision_id_to_revno',
 
3343
                self._remote_path(), revision_id)
 
3344
        except errors.UnknownSmartMethod:
 
3345
            self._ensure_real()
 
3346
            return self._real_branch.revision_id_to_revno(revision_id)
 
3347
        if response[0] == 'ok':
 
3348
            return tuple([int(x) for x in response[1:]])
 
3349
        else:
 
3350
            raise errors.UnexpectedSmartServerResponse(response)
 
3351
 
 
3352
    @needs_read_lock
3032
3353
    def revision_id_to_revno(self, revision_id):
3033
 
        self._ensure_real()
3034
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3354
        """Given a revision id on the branch mainline, return its revno.
 
3355
 
 
3356
        :return: an integer
 
3357
        """
 
3358
        try:
 
3359
            response = self._call('Branch.revision_id_to_revno',
 
3360
                self._remote_path(), revision_id)
 
3361
        except errors.UnknownSmartMethod:
 
3362
            self._ensure_real()
 
3363
            return self._real_branch.revision_id_to_revno(revision_id)
 
3364
        if response[0] == 'ok':
 
3365
            if len(response) == 2:
 
3366
                return int(response[1])
 
3367
            raise NoSuchRevision(self, revision_id)
 
3368
        else:
 
3369
            raise errors.UnexpectedSmartServerResponse(response)
3035
3370
 
3036
3371
    @needs_write_lock
3037
3372
    def set_last_revision_info(self, revno, revision_id):
3276
3611
        tar.extract(tarinfo, to_dir)
3277
3612
 
3278
3613
 
 
3614
error_translators = registry.Registry()
 
3615
no_context_error_translators = registry.Registry()
 
3616
 
 
3617
 
3279
3618
def _translate_error(err, **context):
3280
3619
    """Translate an ErrorFromSmartServer into a more useful error.
3281
3620
 
3310
3649
                    'Missing key %r in context %r', key_err.args[0], context)
3311
3650
                raise err
3312
3651
 
3313
 
    if err.error_verb == 'NoSuchRevision':
3314
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
3315
 
    elif err.error_verb == 'nosuchrevision':
3316
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
3317
 
    elif err.error_verb == 'nobranch':
3318
 
        if len(err.error_args) >= 1:
3319
 
            extra = err.error_args[0]
3320
 
        else:
3321
 
            extra = None
3322
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
3323
 
            detail=extra)
3324
 
    elif err.error_verb == 'norepository':
3325
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
3326
 
    elif err.error_verb == 'UnlockableTransport':
3327
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
3328
 
    elif err.error_verb == 'TokenMismatch':
3329
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
3330
 
    elif err.error_verb == 'Diverged':
3331
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
3332
 
    elif err.error_verb == 'NotStacked':
3333
 
        raise errors.NotStacked(branch=find('branch'))
3334
 
    elif err.error_verb == 'PermissionDenied':
3335
 
        path = get_path()
3336
 
        if len(err.error_args) >= 2:
3337
 
            extra = err.error_args[1]
3338
 
        else:
3339
 
            extra = None
3340
 
        raise errors.PermissionDenied(path, extra=extra)
3341
 
    elif err.error_verb == 'ReadError':
3342
 
        path = get_path()
3343
 
        raise errors.ReadError(path)
3344
 
    elif err.error_verb == 'NoSuchFile':
3345
 
        path = get_path()
3346
 
        raise errors.NoSuchFile(path)
3347
 
    _translate_error_without_context(err)
3348
 
 
3349
 
 
3350
 
def _translate_error_without_context(err):
3351
 
    """Translate any ErrorFromSmartServer values that don't require context"""
3352
 
    if err.error_verb == 'IncompatibleRepositories':
3353
 
        raise errors.IncompatibleRepositories(err.error_args[0],
3354
 
            err.error_args[1], err.error_args[2])
3355
 
    elif err.error_verb == 'LockContention':
3356
 
        raise errors.LockContention('(remote lock)')
3357
 
    elif err.error_verb == 'LockFailed':
3358
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
3359
 
    elif err.error_verb == 'TipChangeRejected':
3360
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
3361
 
    elif err.error_verb == 'UnstackableBranchFormat':
3362
 
        raise errors.UnstackableBranchFormat(*err.error_args)
3363
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
3364
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
3365
 
    elif err.error_verb == 'FileExists':
3366
 
        raise errors.FileExists(err.error_args[0])
3367
 
    elif err.error_verb == 'DirectoryNotEmpty':
3368
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
3369
 
    elif err.error_verb == 'ShortReadvError':
3370
 
        args = err.error_args
3371
 
        raise errors.ShortReadvError(
3372
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
3373
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
3652
    try:
 
3653
        translator = error_translators.get(err.error_verb)
 
3654
    except KeyError:
 
3655
        pass
 
3656
    else:
 
3657
        raise translator(err, find, get_path)
 
3658
    try:
 
3659
        translator = no_context_error_translators.get(err.error_verb)
 
3660
    except KeyError:
 
3661
        raise errors.UnknownErrorFromSmartServer(err)
 
3662
    else:
 
3663
        raise translator(err)
 
3664
 
 
3665
 
 
3666
error_translators.register('NoSuchRevision',
 
3667
    lambda err, find, get_path: NoSuchRevision(
 
3668
        find('branch'), err.error_args[0]))
 
3669
error_translators.register('nosuchrevision',
 
3670
    lambda err, find, get_path: NoSuchRevision(
 
3671
        find('repository'), err.error_args[0]))
 
3672
 
 
3673
def _translate_nobranch_error(err, find, get_path):
 
3674
    if len(err.error_args) >= 1:
 
3675
        extra = err.error_args[0]
 
3676
    else:
 
3677
        extra = None
 
3678
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3679
        detail=extra)
 
3680
 
 
3681
error_translators.register('nobranch', _translate_nobranch_error)
 
3682
error_translators.register('norepository',
 
3683
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3684
        find('bzrdir')))
 
3685
error_translators.register('UnlockableTransport',
 
3686
    lambda err, find, get_path: errors.UnlockableTransport(
 
3687
        find('bzrdir').root_transport))
 
3688
error_translators.register('TokenMismatch',
 
3689
    lambda err, find, get_path: errors.TokenMismatch(
 
3690
        find('token'), '(remote token)'))
 
3691
error_translators.register('Diverged',
 
3692
    lambda err, find, get_path: errors.DivergedBranches(
 
3693
        find('branch'), find('other_branch')))
 
3694
error_translators.register('NotStacked',
 
3695
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3696
 
 
3697
def _translate_PermissionDenied(err, find, get_path):
 
3698
    path = get_path()
 
3699
    if len(err.error_args) >= 2:
 
3700
        extra = err.error_args[1]
 
3701
    else:
 
3702
        extra = None
 
3703
    return errors.PermissionDenied(path, extra=extra)
 
3704
 
 
3705
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3706
error_translators.register('ReadError',
 
3707
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3708
error_translators.register('NoSuchFile',
 
3709
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3710
no_context_error_translators.register('IncompatibleRepositories',
 
3711
    lambda err: errors.IncompatibleRepositories(
 
3712
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3713
no_context_error_translators.register('LockContention',
 
3714
    lambda err: errors.LockContention('(remote lock)'))
 
3715
no_context_error_translators.register('LockFailed',
 
3716
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3717
no_context_error_translators.register('TipChangeRejected',
 
3718
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
3719
no_context_error_translators.register('UnstackableBranchFormat',
 
3720
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
3721
no_context_error_translators.register('UnstackableRepositoryFormat',
 
3722
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
3723
no_context_error_translators.register('FileExists',
 
3724
    lambda err: errors.FileExists(err.error_args[0]))
 
3725
no_context_error_translators.register('DirectoryNotEmpty',
 
3726
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
3727
 
 
3728
def _translate_short_readv_error(err):
 
3729
    args = err.error_args
 
3730
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
3731
        int(args[3]))
 
3732
 
 
3733
no_context_error_translators.register('ShortReadvError',
 
3734
    _translate_short_readv_error)
 
3735
 
 
3736
def _translate_unicode_error(err):
3374
3737
        encoding = str(err.error_args[0]) # encoding must always be a string
3375
3738
        val = err.error_args[1]
3376
3739
        start = int(err.error_args[2])
3384
3747
            raise UnicodeDecodeError(encoding, val, start, end, reason)
3385
3748
        elif err.error_verb == 'UnicodeEncodeError':
3386
3749
            raise UnicodeEncodeError(encoding, val, start, end, reason)
3387
 
    elif err.error_verb == 'ReadOnlyError':
3388
 
        raise errors.TransportNotPossible('readonly transport')
3389
 
    elif err.error_verb == 'MemoryError':
3390
 
        raise errors.BzrError("remote server out of memory\n"
3391
 
            "Retry non-remotely, or contact the server admin for details.")
3392
 
    raise errors.UnknownErrorFromSmartServer(err)
 
3750
 
 
3751
no_context_error_translators.register('UnicodeEncodeError',
 
3752
    _translate_unicode_error)
 
3753
no_context_error_translators.register('UnicodeDecodeError',
 
3754
    _translate_unicode_error)
 
3755
no_context_error_translators.register('ReadOnlyError',
 
3756
    lambda err: errors.TransportNotPossible('readonly transport'))
 
3757
no_context_error_translators.register('MemoryError',
 
3758
    lambda err: errors.BzrError("remote server out of memory\n"
 
3759
        "Retry non-remotely, or contact the server admin for details."))
 
3760
 
 
3761
no_context_error_translators.register('BzrCheckError',
 
3762
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
3763
 
 
3764
error_translators.register('UnsuspendableWriteGroup',
 
3765
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3766
        repository=find('repository')))
 
3767
error_translators.register('UnresumableWriteGroup',
 
3768
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3769
        repository=find('repository'), write_groups=err.error_args[0],
 
3770
        reason=err.error_args[1]))