46
49
from bzrlib.decorators import needs_read_lock, needs_write_lock
50
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
51
HistoryMissing, InvalidRevisionId,
52
InvalidRevisionNumber, LockError, NoSuchFile,
53
NoSuchRevision, NotVersionedError,
54
NotBranchError, UninitializableFormat,
55
UnlistableStore, UnlistableBranch,
47
57
from bzrlib.hooks import Hooks
48
from bzrlib.symbol_versioning import (
52
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
58
from bzrlib.symbol_versioning import (deprecated_function,
62
zero_eight, zero_nine, zero_sixteen,
65
from bzrlib.trace import mutter, mutter_callsite, note
55
68
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
319
335
The delta is relative to its mainline predecessor, or the
320
336
empty tree for revision 1.
338
assert isinstance(revno, int)
322
339
rh = self.revision_history()
323
340
if not (1 <= revno <= len(rh)):
324
raise errors.InvalidRevisionNumber(revno)
341
raise InvalidRevisionNumber(revno)
325
342
return self.repository.get_revision_delta(rh[revno-1])
327
def get_stacked_on_url(self):
328
"""Get the URL this branch is stacked against.
344
@deprecated_method(zero_sixteen)
345
def get_root_id(self):
346
"""Return the id of this branches root
330
:raises NotStacked: If the branch is not stacked.
331
:raises UnstackableBranchFormat: If the branch does not support
348
Deprecated: branches don't have root ids-- trees do.
349
Use basis_tree().get_root_id() instead.
334
raise NotImplementedError(self.get_stacked_on_url)
351
raise NotImplementedError(self.get_root_id)
336
353
def print_file(self, file, revision_id):
337
354
"""Print `file` to stdout."""
465
468
common_index = min(self_len, other_len) -1
466
469
if common_index >= 0 and \
467
470
self_history[common_index] != other_history[common_index]:
468
raise errors.DivergedBranches(self, other)
471
raise DivergedBranches(self, other)
470
473
if stop_revision is None:
471
474
stop_revision = other_len
476
assert isinstance(stop_revision, int)
473
477
if stop_revision > other_len:
474
478
raise errors.NoSuchRevision(self, stop_revision)
475
479
return other_history[self_len:stop_revision]
478
def update_revisions(self, other, stop_revision=None, overwrite=False,
481
def update_revisions(self, other, stop_revision=None):
480
482
"""Pull in new perfect-fit revisions.
482
484
:param other: Another Branch to pull from
483
485
:param stop_revision: Updated until the given revision
484
:param overwrite: Always set the branch pointer, rather than checking
485
to see if it is a proper descendant.
486
:param graph: A Graph object that can be used to query history
487
information. This can be None.
492
other_revno, other_last_revision = other.last_revision_info()
493
stop_revno = None # unknown
494
if stop_revision is None:
495
stop_revision = other_last_revision
496
if _mod_revision.is_null(stop_revision):
497
# if there are no commits, we're done.
499
stop_revno = other_revno
501
# what's the current last revision, before we fetch [and change it
503
last_rev = _mod_revision.ensure_null(self.last_revision())
504
# we fetch here so that we don't process data twice in the common
505
# case of having something to pull, and so that the check for
506
# already merged can operate on the just fetched graph, which will
507
# be cached in memory.
508
self.fetch(other, stop_revision)
509
# Check to see if one is an ancestor of the other
512
graph = self.repository.get_graph()
513
if self._check_if_descendant_or_diverged(
514
stop_revision, last_rev, graph, other):
515
# stop_revision is a descendant of last_rev, but we aren't
516
# overwriting, so we're done.
518
if stop_revno is None:
520
graph = self.repository.get_graph()
521
this_revno, this_last_revision = self.last_revision_info()
522
stop_revno = graph.find_distance_to_null(stop_revision,
523
[(other_last_revision, other_revno),
524
(this_last_revision, this_revno)])
525
self.set_last_revision_info(stop_revno, stop_revision)
488
raise NotImplementedError(self.update_revisions)
529
490
def revision_id_to_revno(self, revision_id):
530
491
"""Given a revision id, return its revno"""
567
528
"""Return `Tree` object for last revision."""
568
529
return self.repository.revision_tree(self.last_revision())
531
def rename_one(self, from_rel, to_rel):
534
This can change the directory or the filename or both.
536
raise NotImplementedError(self.rename_one)
538
def move(self, from_paths, to_name):
541
to_name must exist as a versioned directory.
543
If to_name exists and is a directory, the files are moved into
544
it, keeping their old names. If it is a directory,
546
Note that to_name is only the last component of the new name;
547
this doesn't change the directory.
549
This returns a list of (from_path, to_path) pairs for each
552
raise NotImplementedError(self.move)
570
554
def get_parent(self):
571
555
"""Return the parent location of the branch.
672
656
revision_id: if not None, the revision history in the new branch will
673
657
be truncated to end with revision_id.
675
result = to_bzrdir.create_branch()
659
result = self._format.initialize(to_bzrdir)
676
660
self.copy_content_into(result, revision_id=revision_id)
680
664
def sprout(self, to_bzrdir, revision_id=None):
681
665
"""Create a new line of development from the branch, into to_bzrdir.
683
to_bzrdir controls the branch format.
685
667
revision_id: if not None, the revision history in the new branch will
686
668
be truncated to end with revision_id.
688
result = to_bzrdir.create_branch()
670
result = self._format.initialize(to_bzrdir)
689
671
self.copy_content_into(result, revision_id=revision_id)
690
672
result.set_parent(self.bzrdir.root_transport.base)
787
759
def create_checkout(self, to_location, revision_id=None,
788
lightweight=False, accelerator_tree=None,
790
761
"""Create a checkout of a branch.
792
763
:param to_location: The url to produce the checkout at
793
764
:param revision_id: The revision to check out
794
765
:param lightweight: If True, produce a lightweight checkout, otherwise,
795
766
produce a bound branch (heavyweight checkout)
796
:param accelerator_tree: A tree which can be used for retrieving file
797
contents more quickly than the revision tree, i.e. a workingtree.
798
The revision tree will be used for cases where accelerator_tree's
799
content is different.
800
:param hardlink: If true, hard-link files from accelerator_tree,
802
767
:return: The tree of the created checkout
804
769
t = transport.get_transport(to_location)
853
806
def supports_tags(self):
854
807
return self._format.supports_tags()
856
def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
858
"""Ensure that revision_b is a descendant of revision_a.
860
This is a helper function for update_revisions.
862
:raises: DivergedBranches if revision_b has diverged from revision_a.
863
:returns: True if revision_b is a descendant of revision_a.
865
relation = self._revision_relations(revision_a, revision_b, graph)
866
if relation == 'b_descends_from_a':
868
elif relation == 'diverged':
869
raise errors.DivergedBranches(self, other_branch)
870
elif relation == 'a_descends_from_b':
873
raise AssertionError("invalid relation: %r" % (relation,))
875
def _revision_relations(self, revision_a, revision_b, graph):
876
"""Determine the relationship between two revisions.
878
:returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
880
heads = graph.heads([revision_a, revision_b])
881
if heads == set([revision_b]):
882
return 'b_descends_from_a'
883
elif heads == set([revision_a, revision_b]):
884
# These branches have diverged
886
elif heads == set([revision_a]):
887
return 'a_descends_from_b'
889
raise AssertionError("invalid heads: %r" % (heads,))
892
810
class BranchFormat(object):
893
811
"""An encapsulation of the initialization and open routines for a format.
1109
1023
# local is the local branch or None, master is the target branch,
1110
1024
# and an empty branch recieves new_revno of 0, new_revid of None.
1111
1025
self['post_uncommit'] = []
1113
# Invoked before the tip of a branch changes.
1114
# the api signature is
1115
# (params) where params is a ChangeBranchTipParams with the members
1116
# (branch, old_revno, new_revno, old_revid, new_revid)
1117
self['pre_change_branch_tip'] = []
1119
# Invoked after the tip of a branch changes.
1120
# the api signature is
1121
# (params) where params is a ChangeBranchTipParams with the members
1122
# (branch, old_revno, new_revno, old_revid, new_revid)
1123
self['post_change_branch_tip'] = []
1126
1028
# install the default hooks into the Branch class.
1127
1029
Branch.hooks = BranchHooks()
1130
class ChangeBranchTipParams(object):
1131
"""Object holding parameters passed to *_change_branch_tip hooks.
1133
There are 5 fields that hooks may wish to access:
1135
:ivar branch: the branch being changed
1136
:ivar old_revno: revision number before the change
1137
:ivar new_revno: revision number after the change
1138
:ivar old_revid: revision id before the change
1139
:ivar new_revid: revision id after the change
1141
The revid fields are strings. The revno fields are integers.
1144
def __init__(self, branch, old_revno, new_revno, old_revid, new_revid):
1145
"""Create a group of ChangeBranchTip parameters.
1147
:param branch: The branch being changed.
1148
:param old_revno: Revision number before the change.
1149
:param new_revno: Revision number after the change.
1150
:param old_revid: Tip revision id before the change.
1151
:param new_revid: Tip revision id after the change.
1153
self.branch = branch
1154
self.old_revno = old_revno
1155
self.new_revno = new_revno
1156
self.old_revid = old_revid
1157
self.new_revid = new_revid
1159
def __eq__(self, other):
1160
return self.__dict__ == other.__dict__
1163
return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1164
self.__class__.__name__, self.branch,
1165
self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1168
1032
class BzrBranchFormat4(BranchFormat):
1169
1033
"""Bzr branch format 4.
1207
1071
return "Bazaar-NG branch format 4"
1210
class BranchFormatMetadir(BranchFormat):
1211
"""Common logic for meta-dir based branch formats."""
1213
def _branch_class(self):
1214
"""What class to instantiate on open calls."""
1215
raise NotImplementedError(self._branch_class)
1074
class BzrBranchFormat5(BranchFormat):
1075
"""Bzr branch format 5.
1078
- a revision-history file.
1080
- a lock dir guarding the branch itself
1081
- all of this stored in a branch/ subdirectory
1082
- works with shared repositories.
1084
This format is new in bzr 0.8.
1087
def get_format_string(self):
1088
"""See BranchFormat.get_format_string()."""
1089
return "Bazaar-NG branch format 5\n"
1091
def get_format_description(self):
1092
"""See BranchFormat.get_format_description()."""
1093
return "Branch format 5"
1095
def initialize(self, a_bzrdir):
1096
"""Create a branch of this format in a_bzrdir."""
1097
utf8_files = [('revision-history', ''),
1098
('branch-name', ''),
1100
return self._initialize_helper(a_bzrdir, utf8_files)
1103
super(BzrBranchFormat5, self).__init__()
1104
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1217
1106
def open(self, a_bzrdir, _found=False):
1218
"""Return the branch object for a_bzrdir.
1107
"""Return the branch object for a_bzrdir
1220
1109
_found is a private parameter, do not use it. It is used to indicate
1221
1110
if format probing has already be done.
1224
1113
format = BranchFormat.find_format(a_bzrdir)
1225
if format.__class__ != self.__class__:
1226
raise AssertionError("wrong format %r found for %r" %
1114
assert format.__class__ == self.__class__
1229
1116
transport = a_bzrdir.get_branch_transport(None)
1230
1117
control_files = lockable_files.LockableFiles(transport, 'lock',
1231
1118
lockdir.LockDir)
1232
return self._branch_class()(_format=self,
1119
return BzrBranch5(_format=self,
1233
1120
_control_files=control_files,
1234
1121
a_bzrdir=a_bzrdir,
1235
1122
_repository=a_bzrdir.find_repository())
1236
except errors.NoSuchFile:
1237
raise errors.NotBranchError(path=transport.base)
1240
super(BranchFormatMetadir, self).__init__()
1241
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1243
def supports_tags(self):
1247
class BzrBranchFormat5(BranchFormatMetadir):
1248
"""Bzr branch format 5.
1251
- a revision-history file.
1253
- a lock dir guarding the branch itself
1254
- all of this stored in a branch/ subdirectory
1255
- works with shared repositories.
1257
This format is new in bzr 0.8.
1260
def _branch_class(self):
1263
def get_format_string(self):
1264
"""See BranchFormat.get_format_string()."""
1265
return "Bazaar-NG branch format 5\n"
1267
def get_format_description(self):
1268
"""See BranchFormat.get_format_description()."""
1269
return "Branch format 5"
1271
def initialize(self, a_bzrdir):
1272
"""Create a branch of this format in a_bzrdir."""
1273
utf8_files = [('revision-history', ''),
1274
('branch-name', ''),
1276
return self._initialize_helper(a_bzrdir, utf8_files)
1278
def supports_tags(self):
1282
class BzrBranchFormat6(BranchFormatMetadir):
1124
raise NotBranchError(path=transport.base)
1127
class BzrBranchFormat6(BzrBranchFormat5):
1283
1128
"""Branch format with last-revision and tags.
1285
1130
Unlike previous formats, this has no explicit revision history. Instead,
1304
1146
def initialize(self, a_bzrdir):
1305
1147
"""Create a branch of this format in a_bzrdir."""
1306
1148
utf8_files = [('last-revision', '0 null:\n'),
1307
('branch.conf', ''),
1310
return self._initialize_helper(a_bzrdir, utf8_files)
1313
class BzrBranchFormat7(BranchFormatMetadir):
1314
"""Branch format with last-revision, tags, and a stacked location pointer.
1316
The stacked location pointer is passed down to the repository and requires
1317
a repository format with supports_external_lookups = True.
1319
This format was introduced in bzr 1.6.
1322
def _branch_class(self):
1325
def get_format_string(self):
1326
"""See BranchFormat.get_format_string()."""
1327
return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
1329
def get_format_description(self):
1330
"""See BranchFormat.get_format_description()."""
1331
return "Branch format 7"
1333
def initialize(self, a_bzrdir):
1334
"""Create a branch of this format in a_bzrdir."""
1335
utf8_files = [('last-revision', '0 null:\n'),
1336
('branch.conf', ''),
1339
return self._initialize_helper(a_bzrdir, utf8_files)
1342
super(BzrBranchFormat7, self).__init__()
1343
self._matchingbzrdir.repository_format = \
1344
RepositoryFormatPackDevelopment1Subtree()
1346
def supports_stacking(self):
1149
('branch-name', ''),
1150
('branch.conf', ''),
1153
return self._initialize_helper(a_bzrdir, utf8_files)
1155
def open(self, a_bzrdir, _found=False):
1156
"""Return the branch object for a_bzrdir
1158
_found is a private parameter, do not use it. It is used to indicate
1159
if format probing has already be done.
1162
format = BranchFormat.find_format(a_bzrdir)
1163
assert format.__class__ == self.__class__
1164
transport = a_bzrdir.get_branch_transport(None)
1165
control_files = lockable_files.LockableFiles(transport, 'lock',
1167
return BzrBranch6(_format=self,
1168
_control_files=control_files,
1170
_repository=a_bzrdir.find_repository())
1172
def supports_tags(self):
1453
1266
Note that it's "local" in the context of the filesystem; it doesn't
1454
1267
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1455
1268
it's writable, and can be accessed via the normal filesystem API.
1457
:ivar _transport: Transport for file operations on this branch's
1458
control files, typically pointing to the .bzr/branch directory.
1459
:ivar repository: Repository for this branch.
1460
:ivar base: The url of the base directory for this branch; the one
1461
containing the .bzr directory.
1464
1271
def __init__(self, _format=None,
1465
1272
_control_files=None, a_bzrdir=None, _repository=None):
1466
1273
"""Create new branch object at a particular location."""
1274
Branch.__init__(self)
1467
1275
if a_bzrdir is None:
1468
1276
raise ValueError('a_bzrdir must be supplied')
1470
1278
self.bzrdir = a_bzrdir
1279
# self._transport used to point to the directory containing the
1280
# control directory, but was not used - now it's just the transport
1281
# for the branch control files. mbp 20070212
1471
1282
self._base = self.bzrdir.transport.clone('..').base
1472
# XXX: We should be able to just do
1473
# self.base = self.bzrdir.root_transport.base
1474
# but this does not quite work yet -- mbp 20080522
1475
1283
self._format = _format
1476
1284
if _control_files is None:
1477
1285
raise ValueError('BzrBranch _control_files is None')
1478
1286
self.control_files = _control_files
1479
1287
self._transport = _control_files._transport
1480
1288
self.repository = _repository
1481
Branch.__init__(self)
1483
1290
def __str__(self):
1484
1291
return '%s(%r)' % (self.__class__.__name__, self.base)
1541
1360
This performs the actual writing to disk.
1542
1361
It is intended to be called by BzrBranch5.set_revision_history."""
1543
self._transport.put_bytes(
1544
'revision-history', '\n'.join(history),
1545
mode=self.bzrdir._get_file_mode())
1362
self.control_files.put_bytes(
1363
'revision-history', '\n'.join(history))
1547
1365
@needs_write_lock
1548
1366
def set_revision_history(self, rev_history):
1549
1367
"""See Branch.set_revision_history."""
1550
1368
if 'evil' in debug.debug_flags:
1551
1369
mutter_callsite(3, "set_revision_history scales with history.")
1552
check_not_reserved_id = _mod_revision.check_not_reserved_id
1553
for rev_id in rev_history:
1554
check_not_reserved_id(rev_id)
1555
if Branch.hooks['post_change_branch_tip']:
1556
# Don't calculate the last_revision_info() if there are no hooks
1558
old_revno, old_revid = self.last_revision_info()
1559
if len(rev_history) == 0:
1560
revid = _mod_revision.NULL_REVISION
1562
revid = rev_history[-1]
1563
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
1370
self._clear_cached_state()
1564
1371
self._write_revision_history(rev_history)
1565
self._clear_cached_state()
1566
1372
self._cache_revision_history(rev_history)
1567
1373
for hook in Branch.hooks['set_rh']:
1568
1374
hook(self, rev_history)
1569
if Branch.hooks['post_change_branch_tip']:
1570
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
1572
def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
1573
"""Run the pre_change_branch_tip hooks."""
1574
hooks = Branch.hooks['pre_change_branch_tip']
1577
old_revno, old_revid = self.last_revision_info()
1578
params = ChangeBranchTipParams(
1579
self, old_revno, new_revno, old_revid, new_revid)
1583
except errors.TipChangeRejected:
1586
exc_info = sys.exc_info()
1587
hook_name = Branch.hooks.get_hook_name(hook)
1588
raise errors.HookFailed(
1589
'pre_change_branch_tip', hook_name, exc_info)
1591
def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
1592
"""Run the post_change_branch_tip hooks."""
1593
hooks = Branch.hooks['post_change_branch_tip']
1596
new_revno, new_revid = self.last_revision_info()
1597
params = ChangeBranchTipParams(
1598
self, old_revno, new_revno, old_revid, new_revid)
1602
1376
@needs_write_lock
1603
1377
def set_last_revision_info(self, revno, revision_id):
1604
1378
"""Set the last revision of this branch.
1632
1401
if 'evil' in debug.debug_flags:
1633
1402
mutter_callsite(4, "_lefthand_history scales with history.")
1634
1403
# stop_revision must be a descendant of last_revision
1635
graph = self.repository.get_graph()
1636
if last_rev is not None:
1637
if not graph.is_ancestor(last_rev, revision_id):
1638
# our previous tip is not merged into stop_revision
1639
raise errors.DivergedBranches(self, other_branch)
1404
stop_graph = self.repository.get_revision_graph(revision_id)
1405
if (last_rev is not None and last_rev != _mod_revision.NULL_REVISION
1406
and last_rev not in stop_graph):
1407
# our previous tip is not merged into stop_revision
1408
raise errors.DivergedBranches(self, other_branch)
1640
1409
# make a new revision history from the graph
1641
parents_map = graph.get_parent_map([revision_id])
1642
if revision_id not in parents_map:
1643
raise errors.NoSuchRevision(self, revision_id)
1644
1410
current_rev_id = revision_id
1645
1411
new_history = []
1646
check_not_reserved_id = _mod_revision.check_not_reserved_id
1647
# Do not include ghosts or graph origin in revision_history
1648
while (current_rev_id in parents_map and
1649
len(parents_map[current_rev_id]) > 0):
1650
check_not_reserved_id(current_rev_id)
1412
while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1651
1413
new_history.append(current_rev_id)
1652
current_rev_id = parents_map[current_rev_id][0]
1653
parents_map = graph.get_parent_map([current_rev_id])
1414
current_rev_id_parents = stop_graph[current_rev_id]
1416
current_rev_id = current_rev_id_parents[0]
1418
current_rev_id = None
1654
1419
new_history.reverse()
1655
1420
return new_history
1668
1433
self.set_revision_history(self._lefthand_history(revision_id,
1669
1434
last_rev, other_branch))
1437
def update_revisions(self, other, stop_revision=None):
1438
"""See Branch.update_revisions."""
1441
if stop_revision is None:
1442
stop_revision = other.last_revision()
1443
if stop_revision is None:
1444
# if there are no commits, we're done.
1446
# whats the current last revision, before we fetch [and change it
1448
last_rev = _mod_revision.ensure_null(self.last_revision())
1449
# we fetch here so that we don't process data twice in the common
1450
# case of having something to pull, and so that the check for
1451
# already merged can operate on the just fetched graph, which will
1452
# be cached in memory.
1453
self.fetch(other, stop_revision)
1454
if self.repository.get_graph().is_ancestor(stop_revision,
1457
self.generate_revision_history(stop_revision, last_rev=last_rev,
1671
1462
def basis_tree(self):
1672
1463
"""See Branch.basis_tree."""
1673
1464
return self.repository.revision_tree(self.last_revision())
1675
1466
@needs_write_lock
1676
1467
def pull(self, source, overwrite=False, stop_revision=None,
1677
_hook_master=None, run_hooks=True, possible_transports=None,
1678
_override_hook_target=None):
1468
_hook_master=None, run_hooks=True, possible_transports=None):
1679
1469
"""See Branch.pull.
1681
1471
:param _hook_master: Private parameter - set the branch to
1682
be supplied as the master to pull hooks.
1472
be supplied as the master to push hooks.
1683
1473
:param run_hooks: Private parameter - if false, this branch
1684
1474
is being called because it's the master of the primary branch,
1685
1475
so it should not run its hooks.
1686
:param _override_hook_target: Private parameter - set the branch to be
1687
supplied as the target_branch to pull hooks.
1689
1477
result = PullResult()
1690
1478
result.source_branch = source
1691
if _override_hook_target is None:
1692
result.target_branch = self
1694
result.target_branch = _override_hook_target
1479
result.target_branch = self
1695
1480
source.lock_read()
1697
# We assume that during 'pull' the local repository is closer than
1699
graph = self.repository.get_graph(source.repository)
1700
1482
result.old_revno, result.old_revid = self.last_revision_info()
1701
self.update_revisions(source, stop_revision, overwrite=overwrite,
1484
self.update_revisions(source, stop_revision)
1485
except DivergedBranches:
1489
if stop_revision is None:
1490
stop_revision = source.last_revision()
1491
self.generate_revision_history(stop_revision)
1703
1492
result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
1704
1493
result.new_revno, result.new_revid = self.last_revision_info()
1705
1494
if _hook_master:
1706
1495
result.master_branch = _hook_master
1707
result.local_branch = result.target_branch
1496
result.local_branch = self
1709
result.master_branch = result.target_branch
1498
result.master_branch = self
1710
1499
result.local_branch = None
1712
1501
for hook in Branch.hooks['post_pull']:
1994
class BzrBranch7(BzrBranch5):
1995
"""A branch with support for a fallback repository."""
1997
def _get_fallback_repository(self, url):
1998
"""Get the repository we fallback to at url."""
1999
url = urlutils.join(self.base, url)
2000
return bzrdir.BzrDir.open(url).open_branch().repository
2002
def _activate_fallback_location(self, url):
2003
"""Activate the branch/repository from url as a fallback repository."""
2004
self.repository.add_fallback_repository(
2005
self._get_fallback_repository(url))
2007
def _open_hook(self):
1804
class BzrBranchExperimental(BzrBranch5):
1805
"""Bzr experimental branch format
1808
- a revision-history file.
1810
- a lock dir guarding the branch itself
1811
- all of this stored in a branch/ subdirectory
1812
- works with shared repositories.
1813
- a tag dictionary in the branch
1815
This format is new in bzr 0.15, but shouldn't be used for real data,
1818
This class acts as it's own BranchFormat.
1821
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1824
def get_format_string(cls):
1825
"""See BranchFormat.get_format_string()."""
1826
return "Bazaar-NG branch format experimental\n"
1829
def get_format_description(cls):
1830
"""See BranchFormat.get_format_description()."""
1831
return "Experimental branch format"
1834
def get_reference(cls, a_bzrdir):
1835
"""Get the target reference of the branch in a_bzrdir.
1837
format probing must have been completed before calling
1838
this method - it is assumed that the format of the branch
1839
in a_bzrdir is correct.
1841
:param a_bzrdir: The bzrdir to get the branch data from.
1842
:return: None if the branch is not a reference branch.
1847
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1849
branch_transport = a_bzrdir.get_branch_transport(cls)
1850
control_files = lockable_files.LockableFiles(branch_transport,
1851
lock_filename, lock_class)
1852
control_files.create_lock()
1853
control_files.lock_write()
2009
url = self.get_stacked_on_url()
2010
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2011
errors.UnstackableBranchFormat):
2014
self._activate_fallback_location(url)
2016
def _check_stackable_repo(self):
2017
if not self.repository._format.supports_external_lookups:
2018
raise errors.UnstackableRepositoryFormat(self.repository._format,
2019
self.repository.base)
2021
def __init__(self, *args, **kwargs):
2022
super(BzrBranch7, self).__init__(*args, **kwargs)
2023
self._last_revision_info_cache = None
2024
self._partial_revision_history_cache = []
2026
def _clear_cached_state(self):
2027
super(BzrBranch7, self)._clear_cached_state()
2028
self._last_revision_info_cache = None
2029
self._partial_revision_history_cache = []
2031
def _last_revision_info(self):
2032
revision_string = self._transport.get_bytes('last-revision')
1855
for filename, content in utf8_files:
1856
control_files.put_utf8(filename, content)
1858
control_files.unlock()
1861
def initialize(cls, a_bzrdir):
1862
"""Create a branch of this format in a_bzrdir."""
1863
utf8_files = [('format', cls.get_format_string()),
1864
('revision-history', ''),
1865
('branch-name', ''),
1868
cls._initialize_control_files(a_bzrdir, utf8_files,
1869
'lock', lockdir.LockDir)
1870
return cls.open(a_bzrdir, _found=True)
1873
def open(cls, a_bzrdir, _found=False):
1874
"""Return the branch object for a_bzrdir
1876
_found is a private parameter, do not use it. It is used to indicate
1877
if format probing has already be done.
1880
format = BranchFormat.find_format(a_bzrdir)
1881
assert format.__class__ == cls
1882
transport = a_bzrdir.get_branch_transport(None)
1883
control_files = lockable_files.LockableFiles(transport, 'lock',
1885
return cls(_format=cls,
1886
_control_files=control_files,
1888
_repository=a_bzrdir.find_repository())
1891
def is_supported(cls):
1894
def _make_tags(self):
1895
return BasicTags(self)
1898
def supports_tags(cls):
1902
BranchFormat.register_format(BzrBranchExperimental)
1905
class BzrBranch6(BzrBranch5):
1908
def last_revision_info(self):
1909
revision_string = self.control_files.get('last-revision').read()
2033
1910
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2034
1911
revision_id = cache_utf8.get_cached_utf8(revision_id)
2035
1912
revno = int(revno)
2036
1913
return revno, revision_id
1915
def last_revision(self):
1916
"""Return last revision id, or None"""
1917
revision_id = self.last_revision_info()[1]
2038
1920
def _write_last_revision_info(self, revno, revision_id):
2039
1921
"""Simply write out the revision id, with no checks.
2044
1926
Intended to be called by set_last_revision_info and
2045
1927
_write_revision_history.
2047
revision_id = _mod_revision.ensure_null(revision_id)
1929
if revision_id is None:
1930
revision_id = 'null:'
2048
1931
out_string = '%d %s\n' % (revno, revision_id)
2049
self._transport.put_bytes('last-revision', out_string,
2050
mode=self.bzrdir._get_file_mode())
1932
self.control_files.put_bytes('last-revision', out_string)
2052
1934
@needs_write_lock
2053
1935
def set_last_revision_info(self, revno, revision_id):
2054
revision_id = _mod_revision.ensure_null(revision_id)
2055
old_revno, old_revid = self.last_revision_info()
2056
1936
if self._get_append_revisions_only():
2057
1937
self._check_history_violation(revision_id)
2058
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2059
1938
self._write_last_revision_info(revno, revision_id)
2060
1939
self._clear_cached_state()
2061
self._last_revision_info_cache = revno, revision_id
2062
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2064
1941
def _check_history_violation(self, revision_id):
2065
1942
last_revision = _mod_revision.ensure_null(self.last_revision())
2071
1948
def _gen_revision_history(self):
2072
1949
"""Generate the revision history from last revision
2074
last_revno, last_revision = self.last_revision_info()
2075
self._extend_partial_history(stop_index=last_revno-1)
2076
return list(reversed(self._partial_revision_history_cache))
2078
def _extend_partial_history(self, stop_index=None, stop_revision=None):
2079
"""Extend the partial history to include a given index
2081
If a stop_index is supplied, stop when that index has been reached.
2082
If a stop_revision is supplied, stop when that revision is
2083
encountered. Otherwise, stop when the beginning of history is
2086
:param stop_index: The index which should be present. When it is
2087
present, history extension will stop.
2088
:param revision_id: The revision id which should be present. When
2089
it is encountered, history extension will stop.
2091
repo = self.repository
2092
if len(self._partial_revision_history_cache) == 0:
2093
iterator = repo.iter_reverse_revision_history(self.last_revision())
2095
start_revision = self._partial_revision_history_cache[-1]
2096
iterator = repo.iter_reverse_revision_history(start_revision)
2097
#skip the last revision in the list
2098
next_revision = iterator.next()
2099
for revision_id in iterator:
2100
self._partial_revision_history_cache.append(revision_id)
2101
if (stop_index is not None and
2102
len(self._partial_revision_history_cache) > stop_index):
2104
if revision_id == stop_revision:
1951
history = list(self.repository.iter_reverse_revision_history(
1952
self.last_revision()))
2107
1956
def _write_revision_history(self, history):
2108
1957
"""Factored out of set_revision_history.
2183
2025
self.get_config().set_user_option('append_revisions_only', value,
2184
2026
warn_masked=True)
2186
def set_stacked_on_url(self, url):
2187
self._check_stackable_repo()
2190
old_url = self.get_stacked_on_url()
2191
except (errors.NotStacked, errors.UnstackableBranchFormat,
2192
errors.UnstackableRepositoryFormat):
2195
# repositories don't offer an interface to remove fallback
2196
# repositories today; take the conceptually simpler option and just
2198
self.repository = self.bzrdir.find_repository()
2199
# for every revision reference the branch has, ensure it is pulled
2201
source_repository = self._get_fallback_repository(old_url)
2202
for revision_id in chain([self.last_revision()],
2203
self.tags.get_reverse_tag_dict()):
2204
self.repository.fetch(source_repository, revision_id,
2207
self._activate_fallback_location(url)
2208
# write this out after the repository is stacked to avoid setting a
2209
# stacked config that doesn't work.
2210
self._set_config_location('stacked_on_location', url)
2212
2028
def _get_append_revisions_only(self):
2213
2029
value = self.get_config().get_user_option('append_revisions_only')
2214
2030
return value == 'True'
2245
2061
def _make_tags(self):
2246
2062
return BasicTags(self)
2249
def generate_revision_history(self, revision_id, last_rev=None,
2251
"""See BzrBranch5.generate_revision_history"""
2252
history = self._lefthand_history(revision_id, last_rev, other_branch)
2253
revno = len(history)
2254
self.set_last_revision_info(revno, revision_id)
2257
def get_rev_id(self, revno, history=None):
2258
"""Find the revision id of the specified revno."""
2260
return _mod_revision.NULL_REVISION
2262
last_revno, last_revision_id = self.last_revision_info()
2263
if revno <= 0 or revno > last_revno:
2264
raise errors.NoSuchRevision(self, revno)
2266
if history is not None:
2267
return history[revno - 1]
2269
index = last_revno - revno
2270
if len(self._partial_revision_history_cache) <= index:
2271
self._extend_partial_history(stop_index=index)
2272
if len(self._partial_revision_history_cache) > index:
2273
return self._partial_revision_history_cache[index]
2275
raise errors.NoSuchRevision(self, revno)
2278
def revision_id_to_revno(self, revision_id):
2279
"""Given a revision id, return its revno"""
2280
if _mod_revision.is_null(revision_id):
2283
index = self._partial_revision_history_cache.index(revision_id)
2285
self._extend_partial_history(stop_revision=revision_id)
2286
index = len(self._partial_revision_history_cache) - 1
2287
if self._partial_revision_history_cache[index] != revision_id:
2288
raise errors.NoSuchRevision(self, revision_id)
2289
return self.revno() - index
2292
class BzrBranch6(BzrBranch7):
2293
"""See BzrBranchFormat6 for the capabilities of this branch.
2295
This subclass of BzrBranch7 disables the new features BzrBranch7 added,
2299
def get_stacked_on_url(self):
2300
raise errors.UnstackableBranchFormat(self._format, self.base)
2302
def set_stacked_on_url(self, url):
2303
raise errors.UnstackableBranchFormat(self._format, self.base)
2306
2065
######################################################################
2307
2066
# results of operations
2408
2163
new_branch.tags._set_tag_dict({})
2410
2165
# Copying done; now update target format
2411
new_branch._transport.put_bytes('format',
2412
format.get_format_string(),
2413
mode=new_branch.bzrdir._get_file_mode())
2166
new_branch.control_files.put_utf8('format',
2167
format.get_format_string())
2415
2169
# Clean up old files
2416
new_branch._transport.delete('revision-history')
2170
new_branch.control_files._transport.delete('revision-history')
2418
2172
branch.set_parent(None)
2419
except errors.NoSuchFile:
2421
2175
branch.set_bound_location(None)
2424
class Converter6to7(object):
2425
"""Perform an in-place upgrade of format 6 to format 7"""
2427
def convert(self, branch):
2428
format = BzrBranchFormat7()
2429
branch._set_config_location('stacked_on_location', '')
2430
# update target format
2431
branch._transport.put_bytes('format', format.get_format_string())
added
removed
bzrlib/branch.py
