« back to all changes in this revision
Viewing changes to bzrlib/_dirstate_helpers_pyx.pyx
- browse files at revision 4641.5.14
- compare with another revision
- compare with revision 6170
- download diff
- download tarball
- view history from revision 4641.5.14
- Committer: John Arbash Meinel
- Date: 2009-09-02 13:32:52 UTC
- mfrom: (4634.6.14 2.0)
- mto: (4634.6.15 2.0)
- mto: This revision was merged to the branch mainline in revision 4667.
- Revision ID: john@arbash-meinel.com-20090902133252-t2t94xtckoliv2th
Merge lp:bzr/2.0 to resolve NEWS issues.
- files added:
- doc/developers/content-filtering.txt
- files removed:
- doc/en/migration
- files modified:
- NEWS
added
removed
bzrlib/_dirstate_helpers_pyx.pyx
28
28
29
29
from bzrlib import cache_utf8, errors, osutils
30
30
from bzrlib.dirstate import DirState
31
from bzrlib.osutils import pathjoin, splitpath
31
from bzrlib.osutils import parent_directories, pathjoin, splitpath
32
32
33
33
34
34
# This is the Windows equivalent of ENOTDIR
963
963
964
964
cdef class ProcessEntryC:
965
965
966
cdef int doing_consistency_expansion
966
967
cdef object old_dirname_to_file_id # dict
967
968
cdef object new_dirname_to_file_id # dict
968
969
cdef object last_source_parent
969
970
cdef object last_target_parent
970
cdef object include_unchanged
971
cdef int include_unchanged
972
cdef int partial
971
973
cdef object use_filesystem_for_exec
972
974
cdef object utf8_decode
973
975
cdef readonly object searched_specific_files
976
cdef readonly object searched_exact_paths
974
977
cdef object search_specific_files
978
# The parents up to the root of the paths we are searching.
979
# After all normal paths are returned, these specific items are returned.
980
cdef object search_specific_file_parents
975
981
cdef object state
976
982
# Current iteration variables:
977
983
cdef object current_root
989
995
cdef object current_block_list
990
996
cdef object current_dir_info
991
997
cdef object current_dir_list
998
cdef object _pending_consistent_entries # list
992
999
cdef int path_index
993
1000
cdef object root_dir_info
994
1001
cdef object bisect_left
995
1002
cdef object pathjoin
996
1003
cdef object fstat
1004
# A set of the ids we've output when doing partial output.
1005
cdef object seen_ids
997
1006
cdef object sha_file
998
1007
999
1008
def __init__(self, include_unchanged, use_filesystem_for_exec,
1000
1009
search_specific_files, state, source_index, target_index,
1001
1010
want_unversioned, tree):
1011
self.doing_consistency_expansion = 0
1002
1012
self.old_dirname_to_file_id = {}
1003
1013
self.new_dirname_to_file_id = {}
1014
# Are we doing a partial iter_changes?
1015
self.partial = set(['']).__ne__(search_specific_files)
1004
1016
# Using a list so that we can access the values and change them in
1005
1017
# nested scope. Each one is [path, file_id, entry]
1006
1018
self.last_source_parent = [None, None]
1007
1019
self.last_target_parent = [None, None]
1008
self.include_unchanged = include_unchanged
1020
if include_unchanged is None:
1021
self.include_unchanged = False
1022
else:
1023
self.include_unchanged = int(include_unchanged)
1009
1024
self.use_filesystem_for_exec = use_filesystem_for_exec
1010
1025
self.utf8_decode = cache_utf8._utf8_decode
1011
1026
# for all search_indexs in each path at or under each element of
1012
# search_specific_files, if the detail is relocated: add the id, and add the
1013
# relocated path as one to search if its not searched already. If the
1014
# detail is not relocated, add the id.
1027
# search_specific_files, if the detail is relocated: add the id, and
1028
# add the relocated path as one to search if its not searched already.
1029
# If the detail is not relocated, add the id.
1015
1030
self.searched_specific_files = set()
1031
# When we search exact paths without expanding downwards, we record
1032
# that here.
1033
self.searched_exact_paths = set()
1016
1034
self.search_specific_files = search_specific_files
1035
# The parents up to the root of the paths we are searching.
1036
# After all normal paths are returned, these specific items are returned.
1037
self.search_specific_file_parents = set()
1038
# The ids we've sent out in the delta.
1039
self.seen_ids = set()
1017
1040
self.state = state
1018
1041
self.current_root = None
1019
1042
self.current_root_unicode = None
1035
1058
self.current_block_pos = -1
1036
1059
self.current_dir_info = None
1037
1060
self.current_dir_list = None
1061
self._pending_consistent_entries = []
1038
1062
self.path_index = 0
1039
1063
self.root_dir_info = None
1040
1064
self.bisect_left = bisect.bisect_left
1041
1065
self.pathjoin = osutils.pathjoin
1042
1066
self.fstat = os.fstat
1043
1067
self.sha_file = osutils.sha_file
1068
if target_index != 0:
1069
# A lot of code in here depends on target_index == 0
1070
raise errors.BzrError('unsupported target index')
1044
1071
1045
1072
cdef _process_entry(self, entry, path_info):
1046
1073
"""Compare an entry and real disk to generate delta information.
1047
1074
1048
1075
:param path_info: top_relpath, basename, kind, lstat, abspath for
1049
the path of entry. If None, then the path is considered absent.
1050
(Perhaps we should pass in a concrete entry for this ?)
1076
the path of entry. If None, then the path is considered absent in
1077
the target (Perhaps we should pass in a concrete entry for this ?)
1051
1078
Basename is returned as a utf8 string because we expect this
1052
1079
tuple will be ignored, and don't want to take the time to
1053
1080
decode.
1054
1081
:return: (iter_changes_result, changed). If the entry has not been
1055
1082
handled then changed is None. Otherwise it is False if no content
1056
or metadata changes have occured, and None if any content or
1057
metadata change has occured. If self.include_unchanged is True then
1083
or metadata changes have occured, and True if any content or
1084
metadata change has occurred. If self.include_unchanged is True then
1058
1085
if changed is not None, iter_changes_result will always be a result
1059
1086
tuple. Otherwise, iter_changes_result is None unless changed is
1060
1087
True.
1099
1126
else:
1100
1127
# add the source to the search path to find any children it
1101
1128
# has. TODO ? : only add if it is a container ?
1102
if not osutils.is_inside_any(self.searched_specific_files,
1103
source_details[1]):
1129
if (not self.doing_consistency_expansion and
1130
not osutils.is_inside_any(self.searched_specific_files,
1131
source_details[1])):
1104
1132
self.search_specific_files.add(source_details[1])
1133
# expanding from a user requested path, parent expansion
1134
# for delta consistency happens later.
1105
1135
# generate the old path; this is needed for stating later
1106
1136
# as well.
1107
1137
old_path = source_details[1]
1180
1210
file_id = entry[0][2]
1181
1211
self.old_dirname_to_file_id[old_path] = file_id
1182
1212
# parent id is the entry for the path in the target tree
1183
if old_dirname == self.last_source_parent[0]:
1213
if old_basename and old_dirname == self.last_source_parent[0]:
1214
# use a cached hit for non-root source entries.
1184
1215
source_parent_id = self.last_source_parent[1]
1185
1216
else:
1186
1217
try:
1196
1227
self.last_source_parent[0] = old_dirname
1197
1228
self.last_source_parent[1] = source_parent_id
1198
1229
new_dirname = entry[0][0]
1199
if new_dirname == self.last_target_parent[0]:
1230
if entry[0][1] and new_dirname == self.last_target_parent[0]:
1231
# use a cached hit for non-root target entries.
1200
1232
target_parent_id = self.last_target_parent[1]
1201
1233
else:
1202
1234
try:
1313
1345
# a renamed parent. TODO: handle this efficiently. Its not
1314
1346
# common case to rename dirs though, so a correct but slow
1315
1347
# implementation will do.
1316
if not osutils.is_inside_any(self.searched_specific_files, target_details[1]):
1348
if (not self.doing_consistency_expansion and
1349
not osutils.is_inside_any(self.searched_specific_files,
1350
target_details[1])):
1317
1351
self.search_specific_files.add(target_details[1])
1352
# We don't expand the specific files parents list here as
1353
# the path is absent in target and won't create a delta with
1354
# missing parent.
1318
1355
elif ((source_minikind == c'r' or source_minikind == c'a') and
1319
1356
(target_minikind == c'r' or target_minikind == c'a')):
1320
1357
# neither of the selected trees contain this path,
1334
1371
def iter_changes(self):
1335
1372
return self
1336
1373
1374
cdef void _gather_result_for_consistency(self, result):
1375
"""Check a result we will yield to make sure we are consistent later.
1376
1377
This gathers result's parents into a set to output later.
1378
1379
:param result: A result tuple.
1380
"""
1381
if not self.partial or not result[0]:
1382
return
1383
self.seen_ids.add(result[0])
1384
new_path = result[1][1]
1385
if new_path:
1386
# Not the root and not a delete: queue up the parents of the path.
1387
self.search_specific_file_parents.update(
1388
osutils.parent_directories(new_path.encode('utf8')))
1389
# Add the root directory which parent_directories does not
1390
# provide.
1391
self.search_specific_file_parents.add('')
1392
1337
1393
cdef void _update_current_block(self):
1338
1394
if (self.block_index < len(self.state._dirblocks) and
1339
1395
osutils.is_inside(self.current_root, self.state._dirblocks[self.block_index][0])):
1406
1462
entry = self.root_entries[self.root_entries_pos]
1407
1463
self.root_entries_pos = self.root_entries_pos + 1
1408
1464
result, changed = self._process_entry(entry, self.root_dir_info)
1409
if changed is not None and changed or self.include_unchanged:
1410
return result
1465
if changed is not None:
1466
if changed:
1467
self._gather_result_for_consistency(result)
1468
if changed or self.include_unchanged:
1469
return result
1411
1470
# Have we finished the prior root, or never started one ?
1412
1471
if self.current_root is None:
1413
1472
# TODO: the pending list should be lexically sorted? the
1416
1475
self.current_root = self.search_specific_files.pop()
1417
1476
except KeyError:
1418
1477
raise StopIteration()
1419
self.current_root_unicode = self.current_root.decode('utf8')
1420
1478
self.searched_specific_files.add(self.current_root)
1421
1479
# process the entries for this containing directory: the rest will be
1422
1480
# found by their parents recursively.
1423
1481
self.root_entries = self.state._entries_for_path(self.current_root)
1424
1482
self.root_entries_len = len(self.root_entries)
1483
self.current_root_unicode = self.current_root.decode('utf8')
1425
1484
self.root_abspath = self.tree.abspath(self.current_root_unicode)
1426
1485
try:
1427
1486
root_stat = os.lstat(self.root_abspath)
1458
1517
result, changed = self._process_entry(entry, self.root_dir_info)
1459
1518
if changed is not None:
1460
1519
path_handled = -1
1520
if changed:
1521
self._gather_result_for_consistency(result)
1461
1522
if changed or self.include_unchanged:
1462
1523
return result
1463
1524
# handle unversioned specified paths:
1476
1537
)
1477
1538
# If we reach here, the outer flow continues, which enters into the
1478
1539
# per-root setup logic.
1479
if self.current_dir_info is None and self.current_block is None:
1540
if (self.current_dir_info is None and self.current_block is None and not
1541
self.doing_consistency_expansion):
1480
1542
# setup iteration of this root:
1481
1543
self.current_dir_list = None
1482
1544
if self.root_dir_info and self.root_dir_info[2] == 'tree-reference':
1606
1668
# advance the entry only, after processing.
1607
1669
result, changed = self._process_entry(current_entry, None)
1608
1670
if changed is not None:
1671
if changed:
1672
self._gather_result_for_consistency(result)
1609
1673
if changed or self.include_unchanged:
1610
1674
return result
1611
1675
self.block_index = self.block_index + 1
1618
1682
# More supplied paths to process
1619
1683
self.current_root = None
1620
1684
return self._iter_next()
1685
# Start expanding more conservatively, adding paths the user may not
1686
# have intended but required for consistent deltas.
1687
self.doing_consistency_expansion = 1
1688
if not self._pending_consistent_entries:
1689
self._pending_consistent_entries = self._next_consistent_entries()
1690
while self._pending_consistent_entries:
1691
result, changed = self._pending_consistent_entries.pop()
1692
if changed is not None:
1693
return result
1621
1694
raise StopIteration()
1622
1695
1623
1696
cdef object _maybe_tree_ref(self, current_path_info):
1705
1778
current_path_info)
1706
1779
if changed is not None:
1707
1780
path_handled = -1
1781
if not changed and not self.include_unchanged:
1782
changed = None
1708
1783
# >- loop control starts here:
1709
1784
# >- entry
1710
1785
if advance_entry and current_entry is not None:
1726
1801
except UnicodeDecodeError:
1727
1802
raise errors.BadFilenameEncoding(
1728
1803
current_path_info[0], osutils._fs_enc)
1729
if result is not None:
1804
if changed is not None:
1730
1805
raise AssertionError(
1731
1806
"result is not None: %r" % result)
1732
1807
result = (None,
1737
1812
(None, self.utf8_decode(current_path_info[1])[0]),
1738
1813
(None, current_path_info[2]),
1739
1814
(None, new_executable))
1815
changed = True
1740
1816
# dont descend into this unversioned path if it is
1741
1817
# a dir
1742
1818
if current_path_info[2] in ('directory'):
1755
1831
current_path_info)
1756
1832
else:
1757
1833
current_path_info = None
1758
if result is not None:
1834
if changed is not None:
1759
1835
# Found a result on this pass, yield it
1760
return result
1836
if changed:
1837
self._gather_result_for_consistency(result)
1838
if changed or self.include_unchanged:
1839
return result
1761
1840
if self.current_block is not None:
1762
1841
self.block_index = self.block_index + 1
1763
1842
self._update_current_block()
1769
1848
self.current_dir_list = self.current_dir_info[1]
1770
1849
except StopIteration:
1771
1850
self.current_dir_info = None
1851
1852
cdef object _next_consistent_entries(self):
1853
"""Grabs the next specific file parent case to consider.
1854
1855
:return: A list of the results, each of which is as for _process_entry.
1856
"""
1857
results = []
1858
while self.search_specific_file_parents:
1859
# Process the parent directories for the paths we were iterating.
1860
# Even in extremely large trees this should be modest, so currently
1861
# no attempt is made to optimise.
1862
path_utf8 = self.search_specific_file_parents.pop()
1863
if path_utf8 in self.searched_exact_paths:
1864
# We've examined this path.
1865
continue
1866
if osutils.is_inside_any(self.searched_specific_files, path_utf8):
1867
# We've examined this path.
1868
continue
1869
path_entries = self.state._entries_for_path(path_utf8)
1870
# We need either one or two entries. If the path in
1871
# self.target_index has moved (so the entry in source_index is in
1872
# 'ar') then we need to also look for the entry for this path in
1873
# self.source_index, to output the appropriate delete-or-rename.
1874
selected_entries = []
1875
found_item = False
1876
for candidate_entry in path_entries:
1877
# Find entries present in target at this path:
1878
if candidate_entry[1][self.target_index][0] not in 'ar':
1879
found_item = True
1880
selected_entries.append(candidate_entry)
1881
# Find entries present in source at this path:
1882
elif (self.source_index is not None and
1883
candidate_entry[1][self.source_index][0] not in 'ar'):
1884
found_item = True
1885
if candidate_entry[1][self.target_index][0] == 'a':
1886
# Deleted, emit it here.
1887
selected_entries.append(candidate_entry)
1888
else:
1889
# renamed, emit it when we process the directory it
1890
# ended up at.
1891
self.search_specific_file_parents.add(
1892
candidate_entry[1][self.target_index][1])
1893
if not found_item:
1894
raise AssertionError(
1895
"Missing entry for specific path parent %r, %r" % (
1896
path_utf8, path_entries))
1897
path_info = self._path_info(path_utf8, path_utf8.decode('utf8'))
1898
for entry in selected_entries:
1899
if entry[0][2] in self.seen_ids:
1900
continue
1901
result, changed = self._process_entry(entry, path_info)
1902
if changed is None:
1903
raise AssertionError(
1904
"Got entry<->path mismatch for specific path "
1905
"%r entry %r path_info %r " % (
1906
path_utf8, entry, path_info))
1907
# Only include changes - we're outside the users requested
1908
# expansion.
1909
if changed:
1910
self._gather_result_for_consistency(result)
1911
if (result[6][0] == 'directory' and
1912
result[6][1] != 'directory'):
1913
# This stopped being a directory, the old children have
1914
# to be included.
1915
if entry[1][self.source_index][0] == 'r':
1916
# renamed, take the source path
1917
entry_path_utf8 = entry[1][self.source_index][1]
1918
else:
1919
entry_path_utf8 = path_utf8
1920
initial_key = (entry_path_utf8, '', '')
1921
block_index, _ = self.state._find_block_index_from_key(
1922
initial_key)
1923
if block_index == 0:
1924
# The children of the root are in block index 1.
1925
block_index = block_index + 1
1926
current_block = None
1927
if block_index < len(self.state._dirblocks):
1928
current_block = self.state._dirblocks[block_index]
1929
if not osutils.is_inside(
1930
entry_path_utf8, current_block[0]):
1931
# No entries for this directory at all.
1932
current_block = None
1933
if current_block is not None:
1934
for entry in current_block[1]:
1935
if entry[1][self.source_index][0] in 'ar':
1936
# Not in the source tree, so doesn't have to be
1937
# included.
1938
continue
1939
# Path of the entry itself.
1940
self.search_specific_file_parents.add(
1941
self.pathjoin(*entry[0][:2]))
1942
if changed or self.include_unchanged:
1943
results.append((result, changed))
1944
self.searched_exact_paths.add(path_utf8)
1945
return results
1946
1947
cdef object _path_info(self, utf8_path, unicode_path):
1948
"""Generate path_info for unicode_path.
1949
1950
:return: None if unicode_path does not exist, or a path_info tuple.
1951
"""
1952
abspath = self.tree.abspath(unicode_path)
1953
try:
1954
stat = os.lstat(abspath)
1955
except OSError, e:
1956
if e.errno == errno.ENOENT:
1957
# the path does not exist.
1958
return None
1959
else:
1960
raise
1961
utf8_basename = utf8_path.rsplit('/', 1)[-1]
1962
dir_info = (utf8_path, utf8_basename,
1963
osutils.file_kind_from_stat_mode(stat.st_mode), stat,
1964
abspath)
1965
if dir_info[2] == 'directory':
1966
if self.tree._directory_is_tree_reference(
1967
unicode_path):
1968
self.root_dir_info = self.root_dir_info[:2] + \
1969
('tree-reference',) + self.root_dir_info[3:]
1970
return dir_info
Loggerhead is a web-based interface for Breezy
Version: 2.0.1