13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""WorkingTree4 format and implementation.
29
29
from bzrlib.lazy_import import lazy_import
30
30
lazy_import(globals(), """
31
from bisect import bisect_left
33
from copy import deepcopy
35
42
from bzrlib import (
45
conflicts as _mod_conflicts,
43
55
revision as _mod_revision,
49
65
import bzrlib.branch
66
from bzrlib.transport import get_transport
70
from bzrlib import symbol_versioning
53
71
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
72
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
56
73
import bzrlib.mutabletree
57
74
from bzrlib.mutabletree import needs_tree_write_lock
58
75
from bzrlib.osutils import (
65
from bzrlib.trace import mutter
85
from bzrlib.trace import mutter, note
66
86
from bzrlib.transport.local import LocalTransport
67
87
from bzrlib.tree import InterTree
88
from bzrlib.progress import DummyProgress, ProgressPhase
89
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
90
from bzrlib.rio import RioReader, rio_file, Stanza
91
from bzrlib.symbol_versioning import (deprecated_passed,
68
96
from bzrlib.tree import Tree
69
97
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
185
213
WorkingTree3._comparison_data(self, entry, path)
186
214
# it looks like a plain directory, but it's really a reference -- see
188
if (self._repo_supports_tree_reference and kind == 'directory'
189
and entry is not None and entry.kind == 'tree-reference'):
216
if (self._repo_supports_tree_reference and
217
kind == 'directory' and
218
self._directory_is_tree_reference(path)):
190
219
kind = 'tree-reference'
191
220
return kind, executable, stat_value
218
247
return self._dirstate
219
248
local_path = self.bzrdir.get_workingtree_transport(None
220
249
).local_abspath('dirstate')
221
self._dirstate = dirstate.DirState.on_file(local_path,
222
self._sha1_provider())
250
self._dirstate = dirstate.DirState.on_file(local_path)
223
251
return self._dirstate
225
def _sha1_provider(self):
226
"""A function that returns a SHA1Provider suitable for this tree.
228
:return: None if content filtering is not supported by this tree.
229
Otherwise, a SHA1Provider is returned that sha's the canonical
230
form of files, i.e. after read filters are applied.
232
if self.supports_content_filtering():
233
return ContentFilterAwareSHA1Provider(self)
237
253
def filter_unversioned_files(self, paths):
238
254
"""Filter out paths that are versioned.
322
338
parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
323
339
elif kind == 'tree-reference':
324
340
if not self._repo_supports_tree_reference:
325
raise errors.UnsupportedOperation(
326
self._generate_inventory,
327
self.branch.repository)
341
raise AssertionError(
343
"doesn't support tree references "
344
"required by entry %r"
328
346
inv_entry.reference_revision = link_or_sha1 or None
329
347
elif kind != 'symlink':
330
348
raise AssertionError("unknown kind %r" % kind)
435
453
return osutils.lexists(pathjoin(
436
454
self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
438
def has_or_had_id(self, file_id):
439
state = self.current_dirstate()
440
row, parents = self._get_entry(file_id=file_id)
441
return row is not None
444
457
def id2path(self, file_id):
445
458
"Convert a file-id to a path."
551
564
def _kind(self, relpath):
552
565
abspath = self.abspath(relpath)
553
566
kind = file_kind(abspath)
554
if (self._repo_supports_tree_reference and kind == 'directory'):
555
entry = self._get_entry(path=relpath)
556
if entry[1] is not None:
557
if entry[1][0][0] == 't':
558
kind = 'tree-reference'
567
if (self._repo_supports_tree_reference and
568
kind == 'directory' and
569
self._directory_is_tree_reference(relpath)):
570
kind = 'tree-reference'
692
704
from_entry = self._get_entry(path=from_rel)
693
705
if from_entry == (None, None):
694
706
raise errors.BzrMoveFailedError(from_rel,to_dir,
695
errors.NotVersionedError(path=from_rel))
707
errors.NotVersionedError(path=str(from_rel)))
697
709
from_id = from_entry[0][2]
698
710
to_rel = pathjoin(to_dir, from_tail)
1200
1212
# just forget the whole block.
1201
1213
entry_index = 0
1202
1214
while entry_index < len(block[1]):
1215
# Mark this file id as having been removed
1203
1216
entry = block[1][entry_index]
1204
if entry[1][0][0] in 'ar':
1205
# don't remove absent or renamed entries
1217
ids_to_unversion.discard(entry[0][2])
1218
if (entry[1][0][0] in 'ar' # don't remove absent or renamed
1220
or not state._make_absent(entry)):
1206
1221
entry_index += 1
1208
# Mark this file id as having been removed
1209
ids_to_unversion.discard(entry[0][2])
1210
if not state._make_absent(entry):
1211
# The block has not shrunk.
1213
1222
# go to the next block. (At the moment we dont delete empty
1215
1224
block_index += 1
1267
1276
if self._dirty:
1268
1277
raise AssertionError("attempting to write an inventory when the "
1269
1278
"dirstate is dirty will lose pending changes")
1270
had_inventory = self._inventory is not None
1271
# Setting self._inventory = None forces the dirstate to regenerate the
1272
# working inventory. We do this because self.inventory may be inv, or
1273
# may have been modified, and either case would prevent a clean delta
1275
self._inventory = None
1277
delta = inv._make_delta(self.inventory)
1279
self.apply_inventory_delta(delta)
1279
self.current_dirstate().set_state_from_inventory(inv)
1280
self._make_dirty(reset_inventory=False)
1281
if self._inventory is not None:
1281
1282
self._inventory = inv
1285
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1287
def __init__(self, tree):
1290
def sha1(self, abspath):
1291
"""See dirstate.SHA1Provider.sha1()."""
1292
filters = self.tree._content_filter_stack(
1293
self.tree.relpath(osutils.safe_unicode(abspath)))
1294
return internal_size_sha_file_byname(abspath, filters)[1]
1296
def stat_and_sha1(self, abspath):
1297
"""See dirstate.SHA1Provider.stat_and_sha1()."""
1298
filters = self.tree._content_filter_stack(
1299
self.tree.relpath(osutils.safe_unicode(abspath)))
1300
file_obj = file(abspath, 'rb', 65000)
1302
statvalue = os.fstat(file_obj.fileno())
1304
file_obj = filtered_input_file(file_obj, filters)
1305
sha1 = osutils.size_sha_file(file_obj)[1]
1308
return statvalue, sha1
1311
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1312
"""Dirstate working tree that supports content filtering.
1314
The dirstate holds the hash and size of the canonical form of the file,
1315
and most methods must return that.
1318
def _file_content_summary(self, path, stat_result):
1319
# This is to support the somewhat obsolete path_content_summary method
1320
# with content filtering: see
1321
# <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1323
# If the dirstate cache is up to date and knows the hash and size,
1325
# Otherwise if there are no content filters, return the on-disk size
1326
# and leave the hash blank.
1327
# Otherwise, read and filter the on-disk file and use its size and
1330
# The dirstate doesn't store the size of the canonical form so we
1331
# can't trust it for content-filtered trees. We just return None.
1332
dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1333
executable = self._is_executable_from_path_and_stat(path, stat_result)
1334
return ('file', None, executable, dirstate_sha1)
1337
1286
class WorkingTree4(DirStateWorkingTree):
1338
1287
"""This is the Format 4 working tree.
1350
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1299
class WorkingTree5(DirStateWorkingTree):
1351
1300
"""This is the Format 5 working tree.
1353
1302
This differs from WorkingTree4 by:
1354
1303
- Supporting content filtering.
1356
This is new in bzr 1.11.
1360
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1361
"""This is the Format 6 working tree.
1363
This differs from WorkingTree5 by:
1364
1304
- Supporting a current view that may mask the set of files in a tree
1365
1305
impacted by most user operations.
1367
This is new in bzr 1.14.
1307
This is new in bzr 1.11.
1370
1310
def _make_views(self):
1447
1387
if basis_root_id is not None:
1448
1388
wt._set_root_id(basis_root_id)
1450
if wt.supports_content_filtering():
1451
# The original tree may not have the same content filters
1452
# applied so we can't safely build the inventory delta from
1454
delta_from_tree = False
1456
delta_from_tree = True
1457
1390
# delta_from_tree is safe even for DirStateRevisionTrees,
1458
1391
# because wt4.apply_inventory_delta does not mutate the input
1459
1392
# inventory entries.
1460
1393
transform.build_tree(basis, wt, accelerator_tree,
1462
delta_from_tree=delta_from_tree)
1394
hardlink=hardlink, delta_from_tree=True)
1541
1469
"""See WorkingTreeFormat.get_format_description()."""
1542
1470
return "Working tree format 5"
1544
def supports_content_filtering(self):
1548
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1549
"""WorkingTree format supporting views.
1552
upgrade_recommended = False
1554
_tree_class = WorkingTree6
1556
def get_format_string(self):
1557
"""See WorkingTreeFormat.get_format_string()."""
1558
return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1560
def get_format_description(self):
1561
"""See WorkingTreeFormat.get_format_description()."""
1562
return "Working tree format 6"
1564
1472
def _init_custom_control_files(self, wt):
1565
1473
"""Subclasses with custom control files should override this method."""
1566
1474
wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1575
1483
class DirStateRevisionTree(Tree):
1576
"""A revision tree pulling the inventory from a dirstate.
1578
Note that this is one of the historical (ie revision) trees cached in the
1579
dirstate for easy access, not the workingtree.
1484
"""A revision tree pulling the inventory from a dirstate."""
1582
1486
def __init__(self, dirstate, revision_id, repository):
1583
1487
self._dirstate = dirstate
1756
1660
parent_index = self._get_parent_index()
1757
1661
last_changed_revision = entry[1][parent_index][4]
1759
rev = self._repository.get_revision(last_changed_revision)
1760
except errors.NoSuchRevision:
1761
raise errors.FileTimestampUnavailable(self.id2path(file_id))
1762
return rev.timestamp
1662
return self._repository.get_revision(last_changed_revision).timestamp
1764
1664
def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
1665
entry = self._get_entry(file_id=file_id, path=path)
1777
1677
return self.inventory[file_id].text_size
1779
1679
def get_file_text(self, file_id, path=None):
1780
_, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1781
return ''.join(content)
1680
return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1783
1682
def get_reference_revision(self, file_id, path=None):
1784
1683
return self.inventory[file_id].reference_revision
1803
1702
if entry[1][parent_index][0] != 'l':
1806
target = entry[1][parent_index][1]
1807
target = target.decode('utf8')
1705
# At present, none of the tree implementations supports non-ascii
1706
# symlink targets. So we will just assume that the dirstate path is
1708
return entry[1][parent_index][1]
1810
1710
def get_revision_id(self):
1811
1711
"""Return the revision id for this tree."""
1859
1759
return ie.executable
1861
def list_files(self, include_root=False, from_dir=None, recursive=True):
1761
def list_files(self, include_root=False):
1862
1762
# We use a standard implementation, because DirStateRevisionTree is
1863
1763
# dealing with one of the parents of the current state
1864
1764
inv = self._get_inventory()
1865
if from_dir is None:
1868
from_dir_id = inv.path2id(from_dir)
1869
if from_dir_id is None:
1870
# Directory not versioned
1872
entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1873
if inv.root is not None and not include_root and from_dir is None:
1765
entries = inv.iter_entries()
1766
if self.inventory.root is not None and not include_root:
1875
1768
for path, entry in entries:
1876
1769
yield path, 'V', entry.kind, entry.file_id, entry
1981
def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1874
def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
1983
1875
from bzrlib.tests.test__dirstate_helpers import \
1984
compiled_dirstate_helpers_feature
1985
test_case.requireFeature(compiled_dirstate_helpers_feature)
1986
from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1876
CompiledDirstateHelpersFeature
1877
if not CompiledDirstateHelpersFeature.available():
1878
from bzrlib.tests import UnavailableFeature
1879
raise UnavailableFeature(CompiledDirstateHelpersFeature)
1880
from bzrlib._dirstate_helpers_c import ProcessEntryC
1987
1881
result = klass.make_source_parent_tree(source, target)
1988
1882
result[1]._iter_changes = ProcessEntryC
2027
1923
require_versioned, want_unversioned=want_unversioned)
2028
1924
parent_ids = self.target.get_parent_ids()
2029
1925
if not (self.source._revision_id in parent_ids
2030
or self.source._revision_id == _mod_revision.NULL_REVISION):
1926
or self.source._revision_id == NULL_REVISION):
2031
1927
raise AssertionError(
2032
1928
"revision {%s} is not stored in {%s}, but %s "
2033
1929
"can only be used for trees stored in the dirstate"
2034
1930
% (self.source._revision_id, self.target, self.iter_changes))
2035
1931
target_index = 0
2036
if self.source._revision_id == _mod_revision.NULL_REVISION:
1932
if self.source._revision_id == NULL_REVISION:
2037
1933
source_index = None
2038
1934
indices = (target_index,)
2055
1951
specific_files = set([''])
2056
1952
# -- specific_files is now a utf8 path set --
1953
search_specific_files = set()
2058
1954
# -- get the state object and prepare it.
2059
1955
state = self.target.current_dirstate()
2060
1956
state._read_dirblocks_if_needed()
2061
1957
if require_versioned:
2062
1958
# -- check all supplied paths are versioned in a search tree. --
1959
all_versioned = True
2064
1960
for path in specific_files:
2065
1961
path_entries = state._entries_for_path(path)
2066
1962
if not path_entries:
2067
1963
# this specified path is not present at all: error
2068
not_versioned.append(path)
1964
all_versioned = False
2070
1966
found_versioned = False
2071
1967
# for each id at this path
2072
1968
for entry in path_entries:
2079
1975
if not found_versioned:
2080
1976
# none of the indexes was not 'absent' at all ids for this
2082
not_versioned.append(path)
2083
if len(not_versioned) > 0:
2084
raise errors.PathsNotVersionedError(not_versioned)
1978
all_versioned = False
1980
if not all_versioned:
1981
raise errors.PathsNotVersionedError(specific_files)
2085
1982
# -- remove redundancy in supplied specific_files to prevent over-scanning --
2086
search_specific_files = osutils.minimum_path_selection(specific_files)
1983
for path in specific_files:
1984
other_specific_files = specific_files.difference(set([path]))
1985
if not osutils.is_inside_any(other_specific_files, path):
1986
# this is a top level path, we must check it.
1987
search_specific_files.add(path)
2088
1989
use_filesystem_for_exec = (sys.platform != 'win32')
2089
1990
iter_changes = self.target._iter_changes(include_unchanged,
2101
2002
(revisiontree.RevisionTree, DirStateRevisionTree)):
2103
2004
# the source revid must be in the target dirstate
2104
if not (source._revision_id == _mod_revision.NULL_REVISION or
2005
if not (source._revision_id == NULL_REVISION or
2105
2006
source._revision_id in target.get_parent_ids()):
2106
2007
# TODO: what about ghosts? it may well need to
2107
2008
# check for them explicitly.
2168
2069
# tree during upgrade.
2169
2070
tree._control_files.lock_write()
2171
self.update_format(tree)
2173
tree._control_files.unlock()
2175
def update_format(self, tree):
2176
"""Change the format marker."""
2177
tree._transport.put_bytes('format',
2178
self.target_format.get_format_string(),
2179
mode=tree.bzrdir._get_file_mode())
2182
class Converter4or5to6(object):
2183
"""Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2186
self.target_format = WorkingTreeFormat6()
2188
def convert(self, tree):
2189
# lock the control files not the tree, so that we don't get tree
2190
# on-unlock behaviours, and so that no-one else diddles with the
2191
# tree during upgrade.
2192
tree._control_files.lock_write()
2194
2072
self.init_custom_control_files(tree)
2195
2073
self.update_format(tree)
added
removed
bzrlib/workingtree_4.py
