« back to all changes in this revision
Viewing changes to bzrlib/dirstate.py
- browse files at revision 5340.14.2
- compare with another revision
- compare with revision 3763.8.1
- download diff
- download tarball
- view history from revision 5340.14.2
- Committer: John Arbash Meinel
- Date: 2011-05-26 08:05:45 UTC
- mfrom: (5916 +trunk)
- mto: This revision was merged to the branch mainline in revision 5917.
- Revision ID: john@arbash-meinel.com-20110526080545-5tprxfczyj4bfk0o
Merge bzr.dev 5916 and make sure the right patch is applied.
- files added:
- doc/ja/tutorials/licence.txt
- files removed:
- bzrlib/tests/blackbox/test_breakin.py
- files modified:
- Makefile
added
removed
bzrlib/dirstate.py
20
20
lines by NL. The field delimiters are ommitted in the grammar, line delimiters
21
21
are not - this is done for clarity of reading. All string data is in utf8.
22
22
23
MINIKIND = "f" | "d" | "l" | "a" | "r" | "t";
24
NL = "\n";
25
NULL = "\0";
26
WHOLE_NUMBER = {digit}, digit;
27
BOOLEAN = "y" | "n";
28
REVISION_ID = a non-empty utf8 string;
29
30
dirstate format = header line, full checksum, row count, parent details,
31
ghost_details, entries;
32
header line = "#bazaar dirstate flat format 3", NL;
33
full checksum = "crc32: ", ["-"], WHOLE_NUMBER, NL;
34
row count = "num_entries: ", WHOLE_NUMBER, NL;
35
parent_details = WHOLE NUMBER, {REVISION_ID}* NL;
36
ghost_details = WHOLE NUMBER, {REVISION_ID}*, NL;
37
entries = {entry};
38
entry = entry_key, current_entry_details, {parent_entry_details};
39
entry_key = dirname, basename, fileid;
40
current_entry_details = common_entry_details, working_entry_details;
41
parent_entry_details = common_entry_details, history_entry_details;
42
common_entry_details = MINIKIND, fingerprint, size, executable
43
working_entry_details = packed_stat
44
history_entry_details = REVISION_ID;
45
executable = BOOLEAN;
46
size = WHOLE_NUMBER;
47
fingerprint = a nonempty utf8 sequence with meaning defined by minikind.
48
49
Given this definition, the following is useful to know:
50
entry (aka row) - all the data for a given key.
51
entry[0]: The key (dirname, basename, fileid)
52
entry[0][0]: dirname
53
entry[0][1]: basename
54
entry[0][2]: fileid
55
entry[1]: The tree(s) data for this path and id combination.
56
entry[1][0]: The current tree
57
entry[1][1]: The second tree
58
59
For an entry for a tree, we have (using tree 0 - current tree) to demonstrate:
60
entry[1][0][0]: minikind
61
entry[1][0][1]: fingerprint
62
entry[1][0][2]: size
63
entry[1][0][3]: executable
64
entry[1][0][4]: packed_stat
65
OR (for non tree-0)
66
entry[1][1][4]: revision_id
23
::
24
25
MINIKIND = "f" | "d" | "l" | "a" | "r" | "t";
26
NL = "\\n";
27
NULL = "\\0";
28
WHOLE_NUMBER = {digit}, digit;
29
BOOLEAN = "y" | "n";
30
REVISION_ID = a non-empty utf8 string;
31
32
dirstate format = header line, full checksum, row count, parent details,
33
ghost_details, entries;
34
header line = "#bazaar dirstate flat format 3", NL;
35
full checksum = "crc32: ", ["-"], WHOLE_NUMBER, NL;
36
row count = "num_entries: ", WHOLE_NUMBER, NL;
37
parent_details = WHOLE NUMBER, {REVISION_ID}* NL;
38
ghost_details = WHOLE NUMBER, {REVISION_ID}*, NL;
39
entries = {entry};
40
entry = entry_key, current_entry_details, {parent_entry_details};
41
entry_key = dirname, basename, fileid;
42
current_entry_details = common_entry_details, working_entry_details;
43
parent_entry_details = common_entry_details, history_entry_details;
44
common_entry_details = MINIKIND, fingerprint, size, executable
45
working_entry_details = packed_stat
46
history_entry_details = REVISION_ID;
47
executable = BOOLEAN;
48
size = WHOLE_NUMBER;
49
fingerprint = a nonempty utf8 sequence with meaning defined by minikind.
50
51
Given this definition, the following is useful to know::
52
53
entry (aka row) - all the data for a given key.
54
entry[0]: The key (dirname, basename, fileid)
55
entry[0][0]: dirname
56
entry[0][1]: basename
57
entry[0][2]: fileid
58
entry[1]: The tree(s) data for this path and id combination.
59
entry[1][0]: The current tree
60
entry[1][1]: The second tree
61
62
For an entry for a tree, we have (using tree 0 - current tree) to demonstrate::
63
64
entry[1][0][0]: minikind
65
entry[1][0][1]: fingerprint
66
entry[1][0][2]: size
67
entry[1][0][3]: executable
68
entry[1][0][4]: packed_stat
69
70
OR (for non tree-0)::
71
72
entry[1][1][4]: revision_id
67
73
68
74
There may be multiple rows at the root, one per id present in the root, so the
69
in memory root row is now:
70
self._dirblocks[0] -> ('', [entry ...]),
71
and the entries in there are
72
entries[0][0]: ''
73
entries[0][1]: ''
74
entries[0][2]: file_id
75
entries[1][0]: The tree data for the current tree for this fileid at /
76
etc.
77
78
Kinds:
79
'r' is a relocated entry: This path is not present in this tree with this id,
80
but the id can be found at another location. The fingerprint is used to
81
point to the target location.
82
'a' is an absent entry: In that tree the id is not present at this path.
83
'd' is a directory entry: This path in this tree is a directory with the
84
current file id. There is no fingerprint for directories.
85
'f' is a file entry: As for directory, but it's a file. The fingerprint is the
86
sha1 value of the file's canonical form, i.e. after any read filters have
87
been applied to the convenience form stored in the working tree.
88
'l' is a symlink entry: As for directory, but a symlink. The fingerprint is the
89
link target.
90
't' is a reference to a nested subtree; the fingerprint is the referenced
91
revision.
75
in memory root row is now::
76
77
self._dirblocks[0] -> ('', [entry ...]),
78
79
and the entries in there are::
80
81
entries[0][0]: ''
82
entries[0][1]: ''
83
entries[0][2]: file_id
84
entries[1][0]: The tree data for the current tree for this fileid at /
85
etc.
86
87
Kinds::
88
89
'r' is a relocated entry: This path is not present in this tree with this
90
id, but the id can be found at another location. The fingerprint is
91
used to point to the target location.
92
'a' is an absent entry: In that tree the id is not present at this path.
93
'd' is a directory entry: This path in this tree is a directory with the
94
current file id. There is no fingerprint for directories.
95
'f' is a file entry: As for directory, but it's a file. The fingerprint is
96
the sha1 value of the file's canonical form, i.e. after any read
97
filters have been applied to the convenience form stored in the working
98
tree.
99
'l' is a symlink entry: As for directory, but a symlink. The fingerprint is
100
the link target.
101
't' is a reference to a nested subtree; the fingerprint is the referenced
102
revision.
92
103
93
104
Ordering:
94
105
95
The entries on disk and in memory are ordered according to the following keys:
106
The entries on disk and in memory are ordered according to the following keys::
96
107
97
108
directory, as a list of components
98
109
filename
99
110
file-id
100
111
101
112
--- Format 1 had the following different definition: ---
102
rows = dirname, NULL, basename, NULL, MINIKIND, NULL, fileid_utf8, NULL,
103
WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target,
104
{PARENT ROW}
105
PARENT ROW = NULL, revision_utf8, NULL, MINIKIND, NULL, dirname, NULL,
106
basename, NULL, WHOLE NUMBER (* size *), NULL, "y" | "n", NULL,
107
SHA1
113
114
::
115
116
rows = dirname, NULL, basename, NULL, MINIKIND, NULL, fileid_utf8, NULL,
117
WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target,
118
{PARENT ROW}
119
PARENT ROW = NULL, revision_utf8, NULL, MINIKIND, NULL, dirname, NULL,
120
basename, NULL, WHOLE NUMBER (* size *), NULL, "y" | "n", NULL,
121
SHA1
108
122
109
123
PARENT ROW's are emitted for every parent that is not in the ghosts details
110
124
line. That is, if the parents are foo, bar, baz, and the ghosts are bar, then
135
149
----
136
150
137
151
Design priorities:
138
1) Fast end to end use for bzr's top 5 uses cases. (commmit/diff/status/merge/???)
139
2) fall back current object model as needed.
140
3) scale usably to the largest trees known today - say 50K entries. (mozilla
152
1. Fast end to end use for bzr's top 5 uses cases. (commmit/diff/status/merge/???)
153
2. fall back current object model as needed.
154
3. scale usably to the largest trees known today - say 50K entries. (mozilla
141
155
is an example of this)
142
156
143
157
144
158
Locking:
159
145
160
Eventually reuse dirstate objects across locks IFF the dirstate file has not
146
161
been modified, but will require that we flush/ignore cached stat-hit data
147
162
because we won't want to restat all files on disk just because a lock was
148
163
acquired, yet we cannot trust the data after the previous lock was released.
149
164
150
Memory representation:
165
Memory representation::
166
151
167
vector of all directories, and vector of the childen ?
152
168
i.e.
153
169
root_entrie = (direntry for root, [parent_direntries_for_root]),
167
183
- What's the risk of error here? Once we have the base format being processed
168
184
we should have a net win regardless of optimality. So we are going to
169
185
go with what seems reasonable.
186
170
187
open questions:
171
188
172
189
Maybe we should do a test profile of the core structure - 10K simulated
371
388
# A pack_stat (the x's) that is just noise and will never match the output
372
389
# of base64 encode.
373
390
NULLSTAT = 'x' * 32
374
NULL_PARENT_DETAILS = ('a', '', 0, False, '')
391
NULL_PARENT_DETAILS = static_tuple.StaticTuple('a', '', 0, False, '')
375
392
376
393
HEADER_FORMAT_2 = '#bazaar dirstate flat format 2\n'
377
394
HEADER_FORMAT_3 = '#bazaar dirstate flat format 3\n'
1205
1222
def _fields_per_entry(self):
1206
1223
"""How many null separated fields should be in each entry row.
1207
1224
1208
Each line now has an extra '\n' field which is not used
1225
Each line now has an extra '\\n' field which is not used
1209
1226
so we just skip over it
1210
entry size:
1227
1228
entry size::
1211
1229
3 fields for the key
1212
1230
+ number of fields per tree_data (5) * tree count
1213
1231
+ newline
1360
1378
delta = sorted(self._check_delta_is_valid(delta), reverse=True)
1361
1379
for old_path, new_path, file_id, inv_entry in delta:
1362
1380
if (file_id in insertions) or (file_id in removals):
1363
raise errors.InconsistentDelta(old_path or new_path, file_id,
1381
self._raise_invalid(old_path or new_path, file_id,
1364
1382
"repeated file_id")
1365
1383
if old_path is not None:
1366
1384
old_path = old_path.encode('utf-8')
1369
1387
new_ids.add(file_id)
1370
1388
if new_path is not None:
1371
1389
if inv_entry is None:
1372
raise errors.InconsistentDelta(new_path, file_id,
1390
self._raise_invalid(new_path, file_id,
1373
1391
"new_path with no entry")
1374
1392
new_path = new_path.encode('utf-8')
1375
1393
dirname_utf8, basename = osutils.split(new_path)
1416
1434
# _get_entry raises BzrError when a request is inconsistent; we
1417
1435
# want such errors to be shown as InconsistentDelta - and that
1418
1436
# fits the behaviour we trigger.
1419
raise errors.InconsistentDeltaDelta(delta, "error from _get_entry.")
1437
raise errors.InconsistentDeltaDelta(delta,
1438
"error from _get_entry. %s" % (e,))
1420
1439
1421
1440
def _apply_removals(self, removals):
1422
1441
for file_id, path in sorted(removals, reverse=True,
1427
1446
try:
1428
1447
entry = self._dirblocks[block_i][1][entry_i]
1429
1448
except IndexError:
1430
self._changes_aborted = True
1431
raise errors.InconsistentDelta(path, file_id,
1449
self._raise_invalid(path, file_id,
1432
1450
"Wrong path for old path.")
1433
1451
if not f_present or entry[1][0][0] in 'ar':
1434
self._changes_aborted = True
1435
raise errors.InconsistentDelta(path, file_id,
1452
self._raise_invalid(path, file_id,
1436
1453
"Wrong path for old path.")
1437
1454
if file_id != entry[0][2]:
1438
self._changes_aborted = True
1439
raise errors.InconsistentDelta(path, file_id,
1455
self._raise_invalid(path, file_id,
1440
1456
"Attempt to remove path has wrong id - found %r."
1441
1457
% entry[0][2])
1442
1458
self._make_absent(entry)
1452
1468
# be due to it being in a parent tree, or a corrupt delta.
1453
1469
for child_entry in self._dirblocks[block_i][1]:
1454
1470
if child_entry[1][0][0] not in ('r', 'a'):
1455
self._changes_aborted = True
1456
raise errors.InconsistentDelta(path, entry[0][2],
1471
self._raise_invalid(path, entry[0][2],
1457
1472
"The file id was deleted but its children were "
1458
1473
"not deleted.")
1459
1474
1463
1478
self.update_minimal(key, minikind, executable, fingerprint,
1464
1479
path_utf8=path_utf8)
1465
1480
except errors.NotVersionedError:
1466
self._changes_aborted = True
1467
raise errors.InconsistentDelta(path_utf8.decode('utf8'), key[2],
1481
self._raise_invalid(path_utf8.decode('utf8'), key[2],
1468
1482
"Missing parent")
1469
1483
1470
1484
def update_basis_by_delta(self, delta, new_revid):
1522
1536
new_ids = set()
1523
1537
for old_path, new_path, file_id, inv_entry in delta:
1524
1538
if inv_entry is not None and file_id != inv_entry.file_id:
1525
raise errors.InconsistentDelta(new_path, file_id,
1539
self._raise_invalid(new_path, file_id,
1526
1540
"mismatched entry file_id %r" % inv_entry)
1527
if new_path is not None:
1541
if new_path is None:
1542
new_path_utf8 = None
1543
else:
1528
1544
if inv_entry is None:
1529
raise errors.InconsistentDelta(new_path, file_id,
1545
self._raise_invalid(new_path, file_id,
1530
1546
"new_path with no entry")
1531
1547
new_path_utf8 = encode(new_path)
1532
1548
# note the parent for validation
1534
1550
if basename_utf8:
1535
1551
parents.add((dirname_utf8, inv_entry.parent_id))
1536
1552
if old_path is None:
1537
adds.append((None, encode(new_path), file_id,
1553
old_path_utf8 = None
1554
else:
1555
old_path_utf8 = encode(old_path)
1556
if old_path is None:
1557
adds.append((None, new_path_utf8, file_id,
1538
1558
inv_to_entry(inv_entry), True))
1539
1559
new_ids.add(file_id)
1540
1560
elif new_path is None:
1541
deletes.append((encode(old_path), None, file_id, None, True))
1542
elif (old_path, new_path) != root_only:
1561
deletes.append((old_path_utf8, None, file_id, None, True))
1562
elif (old_path, new_path) == root_only:
1563
# change things in-place
1564
# Note: the case of a parent directory changing its file_id
1565
# tends to break optimizations here, because officially
1566
# the file has actually been moved, it just happens to
1567
# end up at the same path. If we can figure out how to
1568
# handle that case, we can avoid a lot of add+delete
1569
# pairs for objects that stay put.
1570
# elif old_path == new_path:
1571
changes.append((old_path_utf8, new_path_utf8, file_id,
1572
inv_to_entry(inv_entry)))
1573
else:
1543
1574
# Renames:
1544
1575
# Because renames must preserve their children we must have
1545
1576
# processed all relocations and removes before hand. The sort
1555
1586
self._update_basis_apply_deletes(deletes)
1556
1587
deletes = []
1557
1588
# Split into an add/delete pair recursively.
1558
adds.append((None, new_path_utf8, file_id,
1559
inv_to_entry(inv_entry), False))
1589
adds.append((old_path_utf8, new_path_utf8, file_id,
1590
inv_to_entry(inv_entry), False))
1560
1591
# Expunge deletes that we've seen so that deleted/renamed
1561
1592
# children of a rename directory are handled correctly.
1562
new_deletes = reversed(list(self._iter_child_entries(1,
1563
encode(old_path))))
1593
new_deletes = reversed(list(
1594
self._iter_child_entries(1, old_path_utf8)))
1564
1595
# Remove the current contents of the tree at orig_path, and
1565
1596
# reinsert at the correct new path.
1566
1597
for entry in new_deletes:
1567
if entry[0][0]:
1568
source_path = entry[0][0] + '/' + entry[0][1]
1598
child_dirname, child_basename, child_file_id = entry[0]
1599
if child_dirname:
1600
source_path = child_dirname + '/' + child_basename
1569
1601
else:
1570
source_path = entry[0][1]
1602
source_path = child_basename
1571
1603
if new_path_utf8:
1572
1604
target_path = new_path_utf8 + source_path[len(old_path):]
1573
1605
else:
1574
1606
if old_path == '':
1575
1607
raise AssertionError("cannot rename directory to"
1576
" itself")
1608
" itself")
1577
1609
target_path = source_path[len(old_path) + 1:]
1578
1610
adds.append((None, target_path, entry[0][2], entry[1][1], False))
1579
1611
deletes.append(
1580
1612
(source_path, target_path, entry[0][2], None, False))
1581
deletes.append(
1582
(encode(old_path), new_path, file_id, None, False))
1583
else:
1584
# changes to just the root should not require remove/insertion
1585
# of everything.
1586
changes.append((encode(old_path), encode(new_path), file_id,
1587
inv_to_entry(inv_entry)))
1613
deletes.append((old_path_utf8, new_path, file_id, None, False))
1588
1614
self._check_delta_ids_absent(new_ids, delta, 1)
1589
1615
try:
1590
1616
# Finish expunging deletes/first half of renames.
1600
1626
if 'integrity error' not in str(e):
1601
1627
raise
1602
1628
# _get_entry raises BzrError when a request is inconsistent; we
1603
# want such errors to be shown as InconsistentDelta - and that
1604
# fits the behaviour we trigger. Partof this is driven by dirstate
1605
# only supporting deltas that turn the basis into a closer fit to
1606
# the active tree.
1607
raise errors.InconsistentDeltaDelta(delta, "error from _get_entry.")
1629
# want such errors to be shown as InconsistentDelta - and that
1630
# fits the behaviour we trigger.
1631
raise errors.InconsistentDeltaDelta(delta,
1632
"error from _get_entry. %s" % (e,))
1608
1633
1609
1634
self._mark_modified(header_modified=True)
1610
1635
self._id_index = None
1626
1651
if entry[0][2] != file_id:
1627
1652
# Different file_id, so not what we want.
1628
1653
continue
1629
# NB: No changes made before this helper is called, so no need
1630
# to set the _changes_aborted flag.
1631
raise errors.InconsistentDelta(
1632
("%s/%s" % key[0:2]).decode('utf8'), file_id,
1654
self._raise_invalid(("%s/%s" % key[0:2]).decode('utf8'), file_id,
1633
1655
"This file_id is new in the delta but already present in "
1634
1656
"the target")
1635
1657
1658
def _raise_invalid(self, path, file_id, reason):
1659
self._changes_aborted = True
1660
raise errors.InconsistentDelta(path, file_id, reason)
1661
1636
1662
def _update_basis_apply_adds(self, adds):
1637
1663
"""Apply a sequence of adds to tree 1 during update_basis_by_delta.
1638
1664
1646
1672
"""
1647
1673
# Adds are accumulated partly from renames, so can be in any input
1648
1674
# order - sort it.
1649
adds.sort()
1675
# TODO: we may want to sort in dirblocks order. That way each entry
1676
# will end up in the same directory, allowing the _get_entry
1677
# fast-path for looking up 2 items in the same dir work.
1678
adds.sort(key=lambda x: x[1])
1650
1679
# adds is now in lexographic order, which places all parents before
1651
1680
# their children, so we can process it linearly.
1652
1681
absent = 'ar'
1682
st = static_tuple.StaticTuple
1653
1683
for old_path, new_path, file_id, new_details, real_add in adds:
1654
# the entry for this file_id must be in tree 0.
1655
entry = self._get_entry(0, file_id, new_path)
1656
if entry[0] is None:
1657
# new_path is not versioned in the active WT state,
1658
# but we are adding it to the basis tree state, we
1659
# need to create a new entry record for it.
1660
dirname, basename = osutils.split(new_path)
1661
entry_key = (dirname, basename, file_id)
1662
_, block = self._find_block(entry_key, add_if_missing=True)
1663
index, _ = self._find_entry_index(entry_key, block)
1664
entry = (entry_key, [DirState.NULL_PARENT_DETAILS]*2)
1665
block.insert(index, entry)
1666
elif entry[0][2] != file_id:
1667
self._changes_aborted = True
1668
raise errors.InconsistentDelta(new_path, file_id,
1669
'working tree does not contain new entry')
1670
if real_add and entry[1][1][0] not in absent:
1671
self._changes_aborted = True
1672
raise errors.InconsistentDelta(new_path, file_id,
1673
'The entry was considered to be a genuinely new record,'
1674
' but there was already an old record for it.')
1675
# We don't need to update the target of an 'r' because the handling
1676
# of renames turns all 'r' situations into a delete at the original
1677
# location.
1678
entry[1][1] = new_details
1684
dirname, basename = osutils.split(new_path)
1685
entry_key = st(dirname, basename, file_id)
1686
block_index, present = self._find_block_index_from_key(entry_key)
1687
if not present:
1688
self._raise_invalid(new_path, file_id,
1689
"Unable to find block for this record."
1690
" Was the parent added?")
1691
block = self._dirblocks[block_index][1]
1692
entry_index, present = self._find_entry_index(entry_key, block)
1693
if real_add:
1694
if old_path is not None:
1695
self._raise_invalid(new_path, file_id,
1696
'considered a real add but still had old_path at %s'
1697
% (old_path,))
1698
if present:
1699
entry = block[entry_index]
1700
basis_kind = entry[1][1][0]
1701
if basis_kind == 'a':
1702
entry[1][1] = new_details
1703
elif basis_kind == 'r':
1704
raise NotImplementedError()
1705
else:
1706
self._raise_invalid(new_path, file_id,
1707
"An entry was marked as a new add"
1708
" but the basis target already existed")
1709
else:
1710
# The exact key was not found in the block. However, we need to
1711
# check if there is a key next to us that would have matched.
1712
# We only need to check 2 locations, because there are only 2
1713
# trees present.
1714
for maybe_index in range(entry_index-1, entry_index+1):
1715
if maybe_index < 0 or maybe_index >= len(block):
1716
continue
1717
maybe_entry = block[maybe_index]
1718
if maybe_entry[0][:2] != (dirname, basename):
1719
# Just a random neighbor
1720
continue
1721
if maybe_entry[0][2] == file_id:
1722
raise AssertionError(
1723
'_find_entry_index didnt find a key match'
1724
' but walking the data did, for %s'
1725
% (entry_key,))
1726
basis_kind = maybe_entry[1][1][0]
1727
if basis_kind not in 'ar':
1728
self._raise_invalid(new_path, file_id,
1729
"we have an add record for path, but the path"
1730
" is already present with another file_id %s"
1731
% (maybe_entry[0][2],))
1732
1733
entry = (entry_key, [DirState.NULL_PARENT_DETAILS,
1734
new_details])
1735
block.insert(entry_index, entry)
1736
1737
active_kind = entry[1][0][0]
1738
if active_kind == 'a':
1739
# The active record shows up as absent, this could be genuine,
1740
# or it could be present at some other location. We need to
1741
# verify.
1742
id_index = self._get_id_index()
1743
# The id_index may not be perfectly accurate for tree1, because
1744
# we haven't been keeping it updated. However, it should be
1745
# fine for tree0, and that gives us enough info for what we
1746
# need
1747
keys = id_index.get(file_id, ())
1748
for key in keys:
1749
block_i, entry_i, d_present, f_present = \
1750
self._get_block_entry_index(key[0], key[1], 0)
1751
if not f_present:
1752
continue
1753
active_entry = self._dirblocks[block_i][1][entry_i]
1754
if (active_entry[0][2] != file_id):
1755
# Some other file is at this path, we don't need to
1756
# link it.
1757
continue
1758
real_active_kind = active_entry[1][0][0]
1759
if real_active_kind in 'ar':
1760
# We found a record, which was not *this* record,
1761
# which matches the file_id, but is not actually
1762
# present. Something seems *really* wrong.
1763
self._raise_invalid(new_path, file_id,
1764
"We found a tree0 entry that doesnt make sense")
1765
# Now, we've found a tree0 entry which matches the file_id
1766
# but is at a different location. So update them to be
1767
# rename records.
1768
active_dir, active_name = active_entry[0][:2]
1769
if active_dir:
1770
active_path = active_dir + '/' + active_name
1771
else:
1772
active_path = active_name
1773
active_entry[1][1] = st('r', new_path, 0, False, '')
1774
entry[1][0] = st('r', active_path, 0, False, '')
1775
elif active_kind == 'r':
1776
raise NotImplementedError()
1777
1778
new_kind = new_details[0]
1779
if new_kind == 'd':
1780
self._ensure_block(block_index, entry_index, new_path)
1679
1781
1680
1782
def _update_basis_apply_changes(self, changes):
1681
1783
"""Apply a sequence of changes to tree 1 during update_basis_by_delta.
1686
1788
absent = 'ar'
1687
1789
for old_path, new_path, file_id, new_details in changes:
1688
1790
# the entry for this file_id must be in tree 0.
1689
entry = self._get_entry(0, file_id, new_path)
1690
if entry[0] is None or entry[0][2] != file_id:
1691
self._changes_aborted = True
1692
raise errors.InconsistentDelta(new_path, file_id,
1693
'working tree does not contain new entry')
1694
if (entry[1][0][0] in absent or
1695
entry[1][1][0] in absent):
1696
self._changes_aborted = True
1697
raise errors.InconsistentDelta(new_path, file_id,
1698
'changed considered absent')
1791
entry = self._get_entry(1, file_id, new_path)
1792
if entry[0] is None or entry[1][1][0] in 'ar':
1793
self._raise_invalid(new_path, file_id,
1794
'changed entry considered not present')
1699
1795
entry[1][1] = new_details
1700
1796
1701
1797
def _update_basis_apply_deletes(self, deletes):
1713
1809
null = DirState.NULL_PARENT_DETAILS
1714
1810
for old_path, new_path, file_id, _, real_delete in deletes:
1715
1811
if real_delete != (new_path is None):
1716
self._changes_aborted = True
1717
raise AssertionError("bad delete delta")
1812
self._raise_invalid(old_path, file_id, "bad delete delta")
1718
1813
# the entry for this file_id must be in tree 1.
1719
1814
dirname, basename = osutils.split(old_path)
1720
1815
block_index, entry_index, dir_present, file_present = \
1721
1816
self._get_block_entry_index(dirname, basename, 1)
1722
1817
if not file_present:
1723
self._changes_aborted = True
1724
raise errors.InconsistentDelta(old_path, file_id,
1818
self._raise_invalid(old_path, file_id,
1725
1819
'basis tree does not contain removed entry')
1726
1820
entry = self._dirblocks[block_index][1][entry_index]
1821
# The state of the entry in the 'active' WT
1822
active_kind = entry[1][0][0]
1727
1823
if entry[0][2] != file_id:
1728
self._changes_aborted = True
1729
raise errors.InconsistentDelta(old_path, file_id,
1824
self._raise_invalid(old_path, file_id,
1730
1825
'mismatched file_id in tree 1')
1731
if real_delete:
1732
if entry[1][0][0] == 'a':
1733
# The file was marked as deleted in the active
1734
# state, and it is now deleted in the basis state,
1735
# so just remove the record entirely
1736
del self._dirblocks[block_index][1][entry_index]
1737
else:
1738
# The basis entry needs to be marked deleted
1739
entry[1][1] = null
1740
# If we are deleting a directory, we need to make sure
1741
# that all of its children are already deleted
1826
dir_block = ()
1827
old_kind = entry[1][1][0]
1828
if active_kind in 'ar':
1829
# The active tree doesn't have this file_id.
1830
# The basis tree is changing this record. If this is a
1831
# rename, then we don't want the record here at all
1832
# anymore. If it is just an in-place change, we want the
1833
# record here, but we'll add it if we need to. So we just
1834
# delete it
1835
if active_kind == 'r':
1836
active_path = entry[1][0][1]
1837
active_entry = self._get_entry(0, file_id, active_path)
1838
if active_entry[1][1][0] != 'r':
1839
self._raise_invalid(old_path, file_id,
1840
"Dirstate did not have matching rename entries")
1841
elif active_entry[1][0][0] in 'ar':
1842
self._raise_invalid(old_path, file_id,
1843
"Dirstate had a rename pointing at an inactive"
1844
" tree0")
1845
active_entry[1][1] = null
1846
del self._dirblocks[block_index][1][entry_index]
1847
if old_kind == 'd':
1848
# This was a directory, and the active tree says it
1849
# doesn't exist, and now the basis tree says it doesn't
1850
# exist. Remove its dirblock if present
1851
(dir_block_index,
1852
present) = self._find_block_index_from_key(
1853
(old_path, '', ''))
1854
if present:
1855
dir_block = self._dirblocks[dir_block_index][1]
1856
if not dir_block:
1857
# This entry is empty, go ahead and just remove it
1858
del self._dirblocks[dir_block_index]
1859
else:
1860
# There is still an active record, so just mark this
1861
# removed.
1862
entry[1][1] = null
1742
1863
block_i, entry_i, d_present, f_present = \
1743
self._get_block_entry_index(old_path, '', 0)
1864
self._get_block_entry_index(old_path, '', 1)
1744
1865
if d_present:
1745
# The dir block is still present in the dirstate; this could
1746
# be due to it being in a parent tree, or a corrupt delta.
1747
for child_entry in self._dirblocks[block_i][1]:
1748
if child_entry[1][1][0] not in ('r', 'a'):
1749
self._changes_aborted = True
1750
raise errors.InconsistentDelta(old_path, entry[0][2],
1751
"The file id was deleted but its children were "
1752
"not deleted.")
1753
else:
1754
if entry[1][0][0] == 'a':
1755
self._changes_aborted = True
1756
raise errors.InconsistentDelta(old_path, file_id,
1757
'The entry was considered a rename, but the source path'
1758
' is marked as absent.')
1759
# For whatever reason, we were asked to rename an entry
1760
# that was originally marked as deleted. This could be
1761
# because we are renaming the parent directory, and the WT
1762
# current state has the file marked as deleted.
1763
elif entry[1][0][0] == 'r':
1764
# implement the rename
1765
del self._dirblocks[block_index][1][entry_index]
1766
else:
1767
# it is being resurrected here, so blank it out temporarily.
1768
# should be equivalent to entry[1][1] = null
1769
self._dirblocks[block_index][1][entry_index][1][1] = null
1866
dir_block = self._dirblocks[block_i][1]
1867
for child_entry in dir_block:
1868
child_basis_kind = child_entry[1][1][0]
1869
if child_basis_kind not in 'ar':
1870
self._raise_invalid(old_path, file_id,
1871
"The file id was deleted but its children were "
1872
"not deleted.")
1770
1873
1771
1874
def _after_delta_check_parents(self, parents, index):
1772
1875
"""Check that parents required by the delta are all intact.
1781
1884
# has the right file id.
1782
1885
entry = self._get_entry(index, file_id, dirname_utf8)
1783
1886
if entry[1] is None:
1784
self._changes_aborted = True
1785
raise errors.InconsistentDelta(dirname_utf8.decode('utf8'),
1887
self._raise_invalid(dirname_utf8.decode('utf8'),
1786
1888
file_id, "This parent is not present.")
1787
1889
# Parents of things must be directories
1788
1890
if entry[1][index][0] != 'd':
1789
self._changes_aborted = True
1790
raise errors.InconsistentDelta(dirname_utf8.decode('utf8'),
1891
self._raise_invalid(dirname_utf8.decode('utf8'),
1791
1892
file_id, "This parent is not a directory.")
1792
1893
1793
1894
def _observed_sha1(self, entry, sha1, stat_value,
2019
2120
entry_index += 1
2020
2121
return block_index, entry_index, True, False
2021
2122
2022
def _get_entry(self, tree_index, fileid_utf8=None, path_utf8=None, include_deleted=False):
2123
def _get_entry(self, tree_index, fileid_utf8=None, path_utf8=None,
2124
include_deleted=False):
2023
2125
"""Get the dirstate entry for path in tree tree_index.
2024
2126
2025
2127
If either file_id or path is supplied, it is used as the key to lookup.
2224
2326
2225
2327
def _get_id_index(self):
2226
2328
"""Get an id index of self._dirblocks.
2227
2329
2228
2330
This maps from file_id => [(directory, name, file_id)] entries where
2229
2331
that file_id appears in one of the trees.
2230
2332
"""
2244
2346
# such, we use a simple tuple, and do our own uniqueness checks. While
2245
2347
# the 'in' check is O(N) since N is nicely bounded it shouldn't ever
2246
2348
# cause quadratic failure.
2247
# TODO: This should use StaticTuple
2248
2349
file_id = entry_key[2]
2249
2350
entry_key = static_tuple.StaticTuple.from_sequence(entry_key)
2250
2351
if file_id not in id_index:
2925
3026
# This entry has the same path (but a different id) as
2926
3027
# the new entry we're adding, and is present in ths
2927
3028
# tree.
2928
raise errors.InconsistentDelta(
3029
self._raise_invalid(
2929
3030
("%s/%s" % key[0:2]).decode('utf8'), key[2],
2930
3031
"Attempt to add item at path already occupied by "
2931
3032
"id %r" % entry[0][2])
3689
3790
raise AssertionError("don't know how to compare "
3690
3791
"source_minikind=%r, target_minikind=%r"
3691
3792
% (source_minikind, target_minikind))
3692
## import pdb;pdb.set_trace()
3693
3793
return None, None
3694
3794
3695
3795
def __iter__(self):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1