202
243
self.version_file(old_root_file_id, old_root)
203
244
self.unversion_file(self._new_root)
205
def fixup_new_roots(self):
206
"""Reinterpret requests to change the root directory
208
Instead of creating a root directory, or moving an existing directory,
209
all the attributes and children of the new root are applied to the
210
existing root directory.
212
This means that the old root trans-id becomes obsolete, so it is
213
recommended only to invoke this after the root trans-id has become
216
new_roots = [k for k, v in self._new_parent.iteritems() if v is
218
if len(new_roots) < 1:
220
if len(new_roots) != 1:
221
raise ValueError('A tree cannot have two roots!')
222
if self._new_root is None:
223
self._new_root = new_roots[0]
225
old_new_root = new_roots[0]
226
# TODO: What to do if a old_new_root is present, but self._new_root is
227
# not listed as being removed? This code explicitly unversions
228
# the old root and versions it with the new file_id. Though that
229
# seems like an incomplete delta
231
# unversion the new root's directory.
232
file_id = self.final_file_id(old_new_root)
233
if old_new_root in self._new_id:
234
self.cancel_versioning(old_new_root)
236
self.unversion_file(old_new_root)
237
# if, at this stage, root still has an old file_id, zap it so we can
238
# stick a new one in.
239
if (self.tree_file_id(self._new_root) is not None and
240
self._new_root not in self._removed_id):
241
self.unversion_file(self._new_root)
242
self.version_file(file_id, self._new_root)
244
# Now move children of new root into old root directory.
245
# Ensure all children are registered with the transaction, but don't
246
# use directly-- some tree children have new parents
247
list(self.iter_tree_children(old_new_root))
248
# Move all children of new root into old root directory.
249
for child in self.by_parent().get(old_new_root, []):
250
self.adjust_path(self.final_name(child), self._new_root, child)
252
# Ensure old_new_root has no directory.
253
if old_new_root in self._new_contents:
254
self.cancel_creation(old_new_root)
256
self.delete_contents(old_new_root)
258
# prevent deletion of root directory.
259
if self._new_root in self._removed_contents:
260
self.cancel_deletion(self._new_root)
262
# destroy path info for old_new_root.
263
del self._new_parent[old_new_root]
264
del self._new_name[old_new_root]
266
246
def trans_id_tree_file_id(self, inventory_id):
267
247
"""Determine the transaction id of a working tree file.
269
249
This reflects only files that already exist, not ones that will be
270
250
added by transactions.
272
if inventory_id is None:
273
raise ValueError('None is not a valid file id')
274
252
path = self._tree.id2path(inventory_id)
275
253
return self.trans_id_tree_path(path)
312
303
return ROOT_PARENT
313
304
return self.trans_id_tree_path(os.path.dirname(path))
306
def create_file(self, contents, trans_id, mode_id=None):
307
"""Schedule creation of a new file.
311
Contents is an iterator of strings, all of which will be written
312
to the target destination.
314
New file takes the permissions of any existing file with that id,
315
unless mode_id is specified.
317
name = self._limbo_name(trans_id)
321
unique_add(self._new_contents, trans_id, 'file')
323
# Clean up the file, it never got registered so
324
# TreeTransform.finalize() won't clean it up.
329
f.writelines(contents)
332
self._set_mode(trans_id, mode_id, S_ISREG)
334
def _set_mode(self, trans_id, mode_id, typefunc):
335
"""Set the mode of new file contents.
336
The mode_id is the existing file to get the mode from (often the same
337
as trans_id). The operation is only performed if there's a mode match
338
according to typefunc.
343
old_path = self._tree_id_paths[mode_id]
347
mode = os.stat(self._tree.abspath(old_path)).st_mode
349
if e.errno == errno.ENOENT:
354
os.chmod(self._limbo_name(trans_id), mode)
356
def create_hardlink(self, path, trans_id):
357
"""Schedule creation of a hard link"""
358
name = self._limbo_name(trans_id)
362
if e.errno != errno.EPERM:
364
raise errors.HardLinkNotSupported(path)
366
unique_add(self._new_contents, trans_id, 'file')
368
# Clean up the file, it never got registered so
369
# TreeTransform.finalize() won't clean it up.
373
def create_directory(self, trans_id):
374
"""Schedule creation of a new directory.
376
See also new_directory.
378
os.mkdir(self._limbo_name(trans_id))
379
unique_add(self._new_contents, trans_id, 'directory')
381
def create_symlink(self, target, trans_id):
382
"""Schedule creation of a new symbolic link.
384
target is a bytestring.
385
See also new_symlink.
388
os.symlink(target, self._limbo_name(trans_id))
389
unique_add(self._new_contents, trans_id, 'symlink')
392
path = FinalPaths(self).get_path(trans_id)
395
raise UnableCreateSymlink(path=path)
397
def cancel_creation(self, trans_id):
398
"""Cancel the creation of new file contents."""
399
del self._new_contents[trans_id]
400
children = self._limbo_children.get(trans_id)
401
# if this is a limbo directory with children, move them before removing
403
if children is not None:
404
self._rename_in_limbo(children)
405
del self._limbo_children[trans_id]
406
del self._limbo_children_names[trans_id]
407
delete_any(self._limbo_name(trans_id))
315
409
def delete_contents(self, trans_id):
316
410
"""Schedule the contents of a path entry for deletion"""
317
# Ensure that the object exists in the WorkingTree, this will raise an
318
# exception if there is a problem
319
411
self.tree_kind(trans_id)
320
412
self._removed_contents.add(trans_id)
922
1065
def get_preview_tree(self):
923
1066
"""Return a tree representing the result of the transform.
925
The tree is a snapshot, and altering the TreeTransform will invalidate
1068
This tree only supports the subset of Tree functionality required
1069
by show_diff_trees. It must only be compared to tt._tree.
928
1071
return _PreviewTree(self)
930
def commit(self, branch, message, merge_parents=None, strict=False):
931
"""Commit the result of this TreeTransform to a branch.
933
:param branch: The branch to commit to.
934
:param message: The message to attach to the commit.
935
:param merge_parents: Additional parents specified by pending merges.
936
:return: The revision_id of the revision committed.
938
self._check_malformed()
940
unversioned = set(self._new_contents).difference(set(self._new_id))
941
for trans_id in unversioned:
942
if self.final_file_id(trans_id) is None:
943
raise errors.StrictCommitFailed()
945
revno, last_rev_id = branch.last_revision_info()
946
if last_rev_id == _mod_revision.NULL_REVISION:
947
if merge_parents is not None:
948
raise ValueError('Cannot supply merge parents for first'
952
parent_ids = [last_rev_id]
953
if merge_parents is not None:
954
parent_ids.extend(merge_parents)
955
if self._tree.get_revision_id() != last_rev_id:
956
raise ValueError('TreeTransform not based on branch basis: %s' %
957
self._tree.get_revision_id())
958
builder = branch.get_commit_builder(parent_ids)
959
preview = self.get_preview_tree()
960
list(builder.record_iter_changes(preview, last_rev_id,
961
self.iter_changes()))
962
builder.finish_inventory()
963
revision_id = builder.commit(message)
964
branch.set_last_revision_info(revno + 1, revision_id)
967
def _text_parent(self, trans_id):
968
file_id = self.tree_file_id(trans_id)
970
if file_id is None or self._tree.kind(file_id) != 'file':
972
except errors.NoSuchFile:
976
def _get_parents_texts(self, trans_id):
977
"""Get texts for compression parents of this file."""
978
file_id = self._text_parent(trans_id)
981
return (self._tree.get_file_text(file_id),)
983
def _get_parents_lines(self, trans_id):
984
"""Get lines for compression parents of this file."""
985
file_id = self._text_parent(trans_id)
988
return (self._tree.get_file_lines(file_id),)
990
def serialize(self, serializer):
991
"""Serialize this TreeTransform.
993
:param serializer: A Serialiser like pack.ContainerSerializer.
995
new_name = dict((k, v.encode('utf-8')) for k, v in
996
self._new_name.items())
997
new_executability = dict((k, int(v)) for k, v in
998
self._new_executability.items())
999
tree_path_ids = dict((k.encode('utf-8'), v)
1000
for k, v in self._tree_path_ids.items())
1002
'_id_number': self._id_number,
1003
'_new_name': new_name,
1004
'_new_parent': self._new_parent,
1005
'_new_executability': new_executability,
1006
'_new_id': self._new_id,
1007
'_tree_path_ids': tree_path_ids,
1008
'_removed_id': list(self._removed_id),
1009
'_removed_contents': list(self._removed_contents),
1010
'_non_present_ids': self._non_present_ids,
1012
yield serializer.bytes_record(bencode.bencode(attribs),
1014
for trans_id, kind in self._new_contents.items():
1016
lines = osutils.chunks_to_lines(
1017
self._read_file_chunks(trans_id))
1018
parents = self._get_parents_lines(trans_id)
1019
mpdiff = multiparent.MultiParent.from_lines(lines, parents)
1020
content = ''.join(mpdiff.to_patch())
1021
if kind == 'directory':
1023
if kind == 'symlink':
1024
content = self._read_symlink_target(trans_id)
1025
yield serializer.bytes_record(content, ((trans_id, kind),))
1027
def deserialize(self, records):
1028
"""Deserialize a stored TreeTransform.
1030
:param records: An iterable of (names, content) tuples, as per
1031
pack.ContainerPushParser.
1033
names, content = records.next()
1034
attribs = bencode.bdecode(content)
1035
self._id_number = attribs['_id_number']
1036
self._new_name = dict((k, v.decode('utf-8'))
1037
for k, v in attribs['_new_name'].items())
1038
self._new_parent = attribs['_new_parent']
1039
self._new_executability = dict((k, bool(v)) for k, v in
1040
attribs['_new_executability'].items())
1041
self._new_id = attribs['_new_id']
1042
self._r_new_id = dict((v, k) for k, v in self._new_id.items())
1043
self._tree_path_ids = {}
1044
self._tree_id_paths = {}
1045
for bytepath, trans_id in attribs['_tree_path_ids'].items():
1046
path = bytepath.decode('utf-8')
1047
self._tree_path_ids[path] = trans_id
1048
self._tree_id_paths[trans_id] = path
1049
self._removed_id = set(attribs['_removed_id'])
1050
self._removed_contents = set(attribs['_removed_contents'])
1051
self._non_present_ids = attribs['_non_present_ids']
1052
for ((trans_id, kind),), content in records:
1054
mpdiff = multiparent.MultiParent.from_patch(content)
1055
lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
1056
self.create_file(lines, trans_id)
1057
if kind == 'directory':
1058
self.create_directory(trans_id)
1059
if kind == 'symlink':
1060
self.create_symlink(content.decode('utf-8'), trans_id)
1063
class DiskTreeTransform(TreeTransformBase):
1064
"""Tree transform storing its contents on disk."""
1066
def __init__(self, tree, limbodir, pb=None,
1067
case_sensitive=True):
1069
:param tree: The tree that will be transformed, but not necessarily
1071
:param limbodir: A directory where new files can be stored until
1072
they are installed in their proper places
1074
:param case_sensitive: If True, the target of the transform is
1075
case sensitive, not just case preserving.
1077
TreeTransformBase.__init__(self, tree, pb, case_sensitive)
1078
self._limbodir = limbodir
1079
self._deletiondir = None
1080
# A mapping of transform ids to their limbo filename
1081
self._limbo_files = {}
1082
# A mapping of transform ids to a set of the transform ids of children
1083
# that their limbo directory has
1084
self._limbo_children = {}
1085
# Map transform ids to maps of child filename to child transform id
1086
self._limbo_children_names = {}
1087
# List of transform ids that need to be renamed from limbo into place
1088
self._needs_rename = set()
1089
self._creation_mtime = None
1092
"""Release the working tree lock, if held, clean up limbo dir.
1094
This is required if apply has not been invoked, but can be invoked
1097
if self._tree is None:
1100
entries = [(self._limbo_name(t), t, k) for t, k in
1101
self._new_contents.iteritems()]
1102
entries.sort(reverse=True)
1103
for path, trans_id, kind in entries:
1106
delete_any(self._limbodir)
1108
# We don't especially care *why* the dir is immortal.
1109
raise ImmortalLimbo(self._limbodir)
1111
if self._deletiondir is not None:
1112
delete_any(self._deletiondir)
1114
raise errors.ImmortalPendingDeletion(self._deletiondir)
1116
TreeTransformBase.finalize(self)
1118
def _limbo_name(self, trans_id):
1119
"""Generate the limbo name of a file"""
1120
limbo_name = self._limbo_files.get(trans_id)
1121
if limbo_name is None:
1122
limbo_name = self._generate_limbo_path(trans_id)
1123
self._limbo_files[trans_id] = limbo_name
1126
def _generate_limbo_path(self, trans_id):
1127
"""Generate a limbo path using the trans_id as the relative path.
1129
This is suitable as a fallback, and when the transform should not be
1130
sensitive to the path encoding of the limbo directory.
1132
self._needs_rename.add(trans_id)
1133
return pathjoin(self._limbodir, trans_id)
1135
def adjust_path(self, name, parent, trans_id):
1136
previous_parent = self._new_parent.get(trans_id)
1137
previous_name = self._new_name.get(trans_id)
1138
TreeTransformBase.adjust_path(self, name, parent, trans_id)
1139
if (trans_id in self._limbo_files and
1140
trans_id not in self._needs_rename):
1141
self._rename_in_limbo([trans_id])
1142
if previous_parent != parent:
1143
self._limbo_children[previous_parent].remove(trans_id)
1144
if previous_parent != parent or previous_name != name:
1145
del self._limbo_children_names[previous_parent][previous_name]
1147
def _rename_in_limbo(self, trans_ids):
1148
"""Fix limbo names so that the right final path is produced.
1150
This means we outsmarted ourselves-- we tried to avoid renaming
1151
these files later by creating them with their final names in their
1152
final parents. But now the previous name or parent is no longer
1153
suitable, so we have to rename them.
1155
Even for trans_ids that have no new contents, we must remove their
1156
entries from _limbo_files, because they are now stale.
1158
for trans_id in trans_ids:
1159
old_path = self._limbo_files.pop(trans_id)
1160
if trans_id not in self._new_contents:
1162
new_path = self._limbo_name(trans_id)
1163
osutils.rename(old_path, new_path)
1164
for descendant in self._limbo_descendants(trans_id):
1165
desc_path = self._limbo_files[descendant]
1166
desc_path = new_path + desc_path[len(old_path):]
1167
self._limbo_files[descendant] = desc_path
1169
def _limbo_descendants(self, trans_id):
1170
"""Return the set of trans_ids whose limbo paths descend from this."""
1171
descendants = set(self._limbo_children.get(trans_id, []))
1172
for descendant in list(descendants):
1173
descendants.update(self._limbo_descendants(descendant))
1176
def create_file(self, contents, trans_id, mode_id=None):
1177
"""Schedule creation of a new file.
1181
Contents is an iterator of strings, all of which will be written
1182
to the target destination.
1184
New file takes the permissions of any existing file with that id,
1185
unless mode_id is specified.
1187
name = self._limbo_name(trans_id)
1188
f = open(name, 'wb')
1191
unique_add(self._new_contents, trans_id, 'file')
1193
# Clean up the file, it never got registered so
1194
# TreeTransform.finalize() won't clean it up.
1199
f.writelines(contents)
1202
self._set_mtime(name)
1203
self._set_mode(trans_id, mode_id, S_ISREG)
1205
def _read_file_chunks(self, trans_id):
1206
cur_file = open(self._limbo_name(trans_id), 'rb')
1208
return cur_file.readlines()
1212
def _read_symlink_target(self, trans_id):
1213
return os.readlink(self._limbo_name(trans_id))
1215
def _set_mtime(self, path):
1216
"""All files that are created get the same mtime.
1218
This time is set by the first object to be created.
1220
if self._creation_mtime is None:
1221
self._creation_mtime = time.time()
1222
os.utime(path, (self._creation_mtime, self._creation_mtime))
1224
def create_hardlink(self, path, trans_id):
1225
"""Schedule creation of a hard link"""
1226
name = self._limbo_name(trans_id)
1230
if e.errno != errno.EPERM:
1232
raise errors.HardLinkNotSupported(path)
1234
unique_add(self._new_contents, trans_id, 'file')
1236
# Clean up the file, it never got registered so
1237
# TreeTransform.finalize() won't clean it up.
1241
def create_directory(self, trans_id):
1242
"""Schedule creation of a new directory.
1244
See also new_directory.
1246
os.mkdir(self._limbo_name(trans_id))
1247
unique_add(self._new_contents, trans_id, 'directory')
1249
def create_symlink(self, target, trans_id):
1250
"""Schedule creation of a new symbolic link.
1252
target is a bytestring.
1253
See also new_symlink.
1256
os.symlink(target, self._limbo_name(trans_id))
1257
unique_add(self._new_contents, trans_id, 'symlink')
1260
path = FinalPaths(self).get_path(trans_id)
1263
raise UnableCreateSymlink(path=path)
1265
def cancel_creation(self, trans_id):
1266
"""Cancel the creation of new file contents."""
1267
del self._new_contents[trans_id]
1268
children = self._limbo_children.get(trans_id)
1269
# if this is a limbo directory with children, move them before removing
1271
if children is not None:
1272
self._rename_in_limbo(children)
1273
del self._limbo_children[trans_id]
1274
del self._limbo_children_names[trans_id]
1275
delete_any(self._limbo_name(trans_id))
1278
class TreeTransform(DiskTreeTransform):
1074
class TreeTransform(TreeTransformBase):
1279
1075
"""Represent a tree transformation.
1281
1077
This object is designed to support incremental generation of the transform,
1370
# Cache of realpath results, to speed up canonical_path
1371
self._realpaths = {}
1372
# Cache of relpath results, to speed up canonical_path
1374
DiskTreeTransform.__init__(self, tree, limbodir, pb,
1167
TreeTransformBase.__init__(self, tree, limbodir, pb,
1375
1168
tree.case_sensitive)
1376
1169
self._deletiondir = deletiondir
1378
def canonical_path(self, path):
1379
"""Get the canonical tree-relative path"""
1380
# don't follow final symlinks
1381
abs = self._tree.abspath(path)
1382
if abs in self._relpaths:
1383
return self._relpaths[abs]
1384
dirname, basename = os.path.split(abs)
1385
if dirname not in self._realpaths:
1386
self._realpaths[dirname] = os.path.realpath(dirname)
1387
dirname = self._realpaths[dirname]
1388
abs = pathjoin(dirname, basename)
1389
if dirname in self._relpaths:
1390
relpath = pathjoin(self._relpaths[dirname], basename)
1391
relpath = relpath.rstrip('/\\')
1393
relpath = self._tree.relpath(abs)
1394
self._relpaths[abs] = relpath
1397
def tree_kind(self, trans_id):
1398
"""Determine the file kind in the working tree.
1400
Raises NoSuchFile if the file does not exist
1402
path = self._tree_id_paths.get(trans_id)
1404
raise NoSuchFile(None)
1406
return file_kind(self._tree.abspath(path))
1408
if e.errno != errno.ENOENT:
1411
raise NoSuchFile(path)
1413
def _set_mode(self, trans_id, mode_id, typefunc):
1414
"""Set the mode of new file contents.
1415
The mode_id is the existing file to get the mode from (often the same
1416
as trans_id). The operation is only performed if there's a mode match
1417
according to typefunc.
1422
old_path = self._tree_id_paths[mode_id]
1426
mode = os.stat(self._tree.abspath(old_path)).st_mode
1428
if e.errno in (errno.ENOENT, errno.ENOTDIR):
1429
# Either old_path doesn't exist, or the parent of the
1430
# target is not a directory (but will be one eventually)
1431
# Either way, we know it doesn't exist *right now*
1432
# See also bug #248448
1437
os.chmod(self._limbo_name(trans_id), mode)
1439
def iter_tree_children(self, parent_id):
1440
"""Iterate through the entry's tree children, if any"""
1442
path = self._tree_id_paths[parent_id]
1446
children = os.listdir(self._tree.abspath(path))
1448
if not (osutils._is_error_enotdir(e)
1449
or e.errno in (errno.ENOENT, errno.ESRCH)):
1453
for child in children:
1454
childpath = joinpath(path, child)
1455
if self._tree.is_control_filename(childpath):
1457
yield self.trans_id_tree_path(childpath)
1459
def _generate_limbo_path(self, trans_id):
1460
"""Generate a limbo path using the final path if possible.
1462
This optimizes the performance of applying the tree transform by
1463
avoiding renames. These renames can be avoided only when the parent
1464
directory is already scheduled for creation.
1466
If the final path cannot be used, falls back to using the trans_id as
1469
parent = self._new_parent.get(trans_id)
1470
# if the parent directory is already in limbo (e.g. when building a
1471
# tree), choose a limbo name inside the parent, to reduce further
1473
use_direct_path = False
1474
if self._new_contents.get(parent) == 'directory':
1475
filename = self._new_name.get(trans_id)
1476
if filename is not None:
1477
if parent not in self._limbo_children:
1478
self._limbo_children[parent] = set()
1479
self._limbo_children_names[parent] = {}
1480
use_direct_path = True
1481
# the direct path can only be used if no other file has
1482
# already taken this pathname, i.e. if the name is unused, or
1483
# if it is already associated with this trans_id.
1484
elif self._case_sensitive_target:
1485
if (self._limbo_children_names[parent].get(filename)
1486
in (trans_id, None)):
1487
use_direct_path = True
1489
for l_filename, l_trans_id in\
1490
self._limbo_children_names[parent].iteritems():
1491
if l_trans_id == trans_id:
1493
if l_filename.lower() == filename.lower():
1496
use_direct_path = True
1498
if not use_direct_path:
1499
return DiskTreeTransform._generate_limbo_path(self, trans_id)
1501
limbo_name = pathjoin(self._limbo_files[parent], filename)
1502
self._limbo_children[parent].add(trans_id)
1503
self._limbo_children_names[parent][filename] = trans_id
1507
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1171
def apply(self, no_conflicts=False, _mover=None):
1508
1172
"""Apply all changes to the inventory and filesystem.
1510
1174
If filesystem or inventory conflicts are present, MalformedTransform
1550
1208
self.finalize()
1551
1209
return _TransformResults(modified_paths, self.rename_count)
1553
def _generate_inventory_delta(self):
1554
"""Generate an inventory delta for the current transform."""
1555
inventory_delta = []
1556
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1557
new_paths = self._inventory_altered()
1558
total_entries = len(new_paths) + len(self._removed_id)
1560
for num, trans_id in enumerate(self._removed_id):
1562
child_pb.update('removing file', num, total_entries)
1563
if trans_id == self._new_root:
1564
file_id = self._tree.get_root_id()
1566
file_id = self.tree_file_id(trans_id)
1567
# File-id isn't really being deleted, just moved
1568
if file_id in self._r_new_id:
1570
path = self._tree_id_paths[trans_id]
1571
inventory_delta.append((path, None, file_id, None))
1572
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1574
entries = self._tree.iter_entries_by_dir(
1575
new_path_file_ids.values())
1576
old_paths = dict((e.file_id, p) for p, e in entries)
1578
for num, (path, trans_id) in enumerate(new_paths):
1580
child_pb.update('adding file',
1581
num + len(self._removed_id), total_entries)
1582
file_id = new_path_file_ids[trans_id]
1587
kind = self.final_kind(trans_id)
1589
kind = self._tree.stored_kind(file_id)
1590
parent_trans_id = self.final_parent(trans_id)
1591
parent_file_id = new_path_file_ids.get(parent_trans_id)
1592
if parent_file_id is None:
1593
parent_file_id = self.final_file_id(parent_trans_id)
1594
if trans_id in self._new_reference_revision:
1595
new_entry = inventory.TreeReference(
1597
self._new_name[trans_id],
1598
self.final_file_id(self._new_parent[trans_id]),
1599
None, self._new_reference_revision[trans_id])
1601
new_entry = inventory.make_entry(kind,
1602
self.final_name(trans_id),
1603
parent_file_id, file_id)
1604
old_path = old_paths.get(new_entry.file_id)
1605
new_executability = self._new_executability.get(trans_id)
1606
if new_executability is not None:
1607
new_entry.executable = new_executability
1608
inventory_delta.append(
1609
(old_path, path, new_entry.file_id, new_entry))
1612
return inventory_delta
1614
def _apply_removals(self, mover):
1211
def _apply_removals(self, inventory_delta, mover):
1615
1212
"""Perform tree operations that remove directory/inventory names.
1617
1214
That is, delete files that are to be deleted, and put any files that
1618
1215
need renaming into limbo. This must be done in strict child-to-parent
1621
If inventory_delta is None, no inventory delta generation is performed.
1623
1218
tree_paths = list(self._tree_path_ids.iteritems())
1624
1219
tree_paths.sort(reverse=True)
1642
1237
self.rename_count += 1
1238
if trans_id in self._removed_id:
1239
if trans_id == self._new_root:
1240
file_id = self._tree.get_root_id()
1242
file_id = self.tree_file_id(trans_id)
1243
# File-id isn't really being deleted, just moved
1244
if file_id in self._r_new_id:
1246
inventory_delta.append((path, None, file_id, None))
1644
1248
child_pb.finished()
1646
def _apply_insertions(self, mover):
1250
def _apply_insertions(self, inventory_delta, mover):
1647
1251
"""Perform tree operations that insert directory/inventory names.
1649
1253
That is, create any files that need to be created, and restore from
1650
1254
limbo any files that needed renaming. This must be done in strict
1651
1255
parent-to-child order.
1653
If inventory_delta is None, no inventory delta is calculated, and
1654
no list of modified paths is returned.
1656
new_paths = self.new_paths(filesystem_only=True)
1257
new_paths = self.new_paths()
1657
1258
modified_paths = []
1658
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1660
1259
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1662
1262
for num, (path, trans_id) in enumerate(new_paths):
1664
child_pb.update('adding file', num, len(new_paths))
1665
full_path = self._tree.abspath(path)
1666
if trans_id in self._needs_rename:
1668
mover.rename(self._limbo_name(trans_id), full_path)
1670
# We may be renaming a dangling inventory id
1671
if e.errno != errno.ENOENT:
1674
self.rename_count += 1
1675
if (trans_id in self._new_contents or
1676
self.path_changed(trans_id)):
1264
child_pb.update('adding file', num, len(new_paths))
1265
if trans_id in self._new_contents or \
1266
self.path_changed(trans_id):
1267
full_path = self._tree.abspath(path)
1268
if trans_id in self._needs_rename:
1270
mover.rename(self._limbo_name(trans_id), full_path)
1272
# We may be renaming a dangling inventory id
1273
if e.errno != errno.ENOENT:
1276
self.rename_count += 1
1677
1277
if trans_id in self._new_contents:
1678
1278
modified_paths.append(full_path)
1279
completed_new.append(trans_id)
1280
file_id = self.final_file_id(trans_id)
1281
if file_id is not None and (trans_id in self._new_id or
1282
trans_id in self._new_name or trans_id in self._new_parent
1283
or trans_id in self._new_executability):
1285
kind = self.final_kind(trans_id)
1287
kind = self._tree.stored_kind(file_id)
1288
if trans_id in self._new_reference_revision:
1289
new_entry = inventory.TreeReference(
1290
self.final_file_id(trans_id),
1291
self._new_name[trans_id],
1292
self.final_file_id(self._new_parent[trans_id]),
1293
None, self._new_reference_revision[trans_id])
1295
new_entry = inventory.make_entry(kind,
1296
self.final_name(trans_id),
1297
self.final_file_id(self.final_parent(trans_id)),
1298
self.final_file_id(trans_id))
1300
old_path = self._tree.id2path(new_entry.file_id)
1301
except errors.NoSuchId:
1303
inventory_delta.append((old_path, path, new_entry.file_id,
1679
1306
if trans_id in self._new_executability:
1680
self._set_executability(path, trans_id)
1307
self._set_executability(path, new_entry, trans_id)
1682
1309
child_pb.finished()
1683
self._new_contents.clear()
1310
for trans_id in completed_new:
1311
del self._new_contents[trans_id]
1684
1312
return modified_paths
1687
class TransformPreview(DiskTreeTransform):
1315
class TransformPreview(TreeTransformBase):
1688
1316
"""A TreeTransform for generating preview trees.
1690
1318
Unlike TreeTransform, this version works when the input tree is a
1738
1362
def __init__(self, transform):
1739
1363
self._transform = transform
1740
1364
self._final_paths = FinalPaths(transform)
1741
self.__by_parent = None
1742
self._parent_ids = []
1743
self._all_children_cache = {}
1744
self._path2trans_id_cache = {}
1745
self._final_name_cache = {}
1746
self._iter_changes_cache = dict((c[0], c) for c in
1747
self._transform.iter_changes())
1366
def _changes(self, file_id):
1367
for changes in self._transform.iter_changes():
1368
if changes[0] == file_id:
1749
1371
def _content_change(self, file_id):
1750
1372
"""Return True if the content of this file changed"""
1751
changes = self._iter_changes_cache.get(file_id)
1373
changes = self._changes(file_id)
1752
1374
# changes[2] is true if the file content changed. See
1753
1375
# InterTree.iter_changes.
1754
1376
return (changes is not None and changes[2])
1756
def _get_repository(self):
1757
repo = getattr(self._transform._tree, '_repository', None)
1759
repo = self._transform._tree.branch.repository
1762
def _iter_parent_trees(self):
1763
for revision_id in self.get_parent_ids():
1765
yield self.revision_tree(revision_id)
1766
except errors.NoSuchRevisionInTree:
1767
yield self._get_repository().revision_tree(revision_id)
1769
1378
def _get_file_revision(self, file_id, vf, tree_revision):
1770
parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1771
self._iter_parent_trees()]
1772
vf.add_lines((file_id, tree_revision), parent_keys,
1773
self.get_file(file_id).readlines())
1774
repo = self._get_repository()
1775
base_vf = repo.texts
1776
if base_vf not in vf.fallback_versionedfiles:
1777
vf.fallback_versionedfiles.append(base_vf)
1778
return tree_revision
1379
return self._transform._tree._get_file_revision(file_id, vf,
1780
1382
def _stat_limbo_file(self, file_id):
1781
1383
trans_id = self._transform.trans_id_file_id(file_id)
1782
1384
name = self._transform._limbo_name(trans_id)
1783
1385
return os.lstat(name)
1786
def _by_parent(self):
1787
if self.__by_parent is None:
1788
self.__by_parent = self._transform.by_parent()
1789
return self.__by_parent
1791
def _comparison_data(self, entry, path):
1792
kind, size, executable, link_or_sha1 = self.path_content_summary(path)
1793
if kind == 'missing':
1797
file_id = self._transform.final_file_id(self._path2trans_id(path))
1798
executable = self.is_executable(file_id, path)
1799
return kind, executable, None
1801
def is_locked(self):
1804
1387
def lock_read(self):
1805
1388
# Perhaps in theory, this should lock the TreeTransform?
1808
1391
def unlock(self):
1873
1428
except NoFinalPath:
1874
1429
raise errors.NoSuchId(self, file_id)
1876
def _all_children(self, trans_id):
1877
children = self._all_children_cache.get(trans_id)
1878
if children is not None:
1880
children = set(self._transform.iter_tree_children(trans_id))
1881
# children in the _new_parent set are provided by _by_parent.
1882
children.difference_update(self._transform._new_parent.keys())
1883
children.update(self._by_parent.get(trans_id, []))
1884
self._all_children_cache[trans_id] = children
1887
def iter_children(self, file_id):
1888
trans_id = self._transform.trans_id_file_id(file_id)
1889
for child_trans_id in self._all_children(trans_id):
1890
yield self._transform.final_file_id(child_trans_id)
1893
possible_extras = set(self._transform.trans_id_tree_path(p) for p
1894
in self._transform._tree.extras())
1895
possible_extras.update(self._transform._new_contents)
1896
possible_extras.update(self._transform._removed_id)
1897
for trans_id in possible_extras:
1898
if self._transform.final_file_id(trans_id) is None:
1899
yield self._final_paths._determine_path(trans_id)
1901
def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
1902
yield_parents=False):
1903
for trans_id, parent_file_id in ordered_entries:
1904
file_id = self._transform.final_file_id(trans_id)
1907
if (specific_file_ids is not None
1908
and file_id not in specific_file_ids):
1911
kind = self._transform.final_kind(trans_id)
1913
kind = self._transform._tree.stored_kind(file_id)
1914
new_entry = inventory.make_entry(
1916
self._transform.final_name(trans_id),
1917
parent_file_id, file_id)
1918
yield new_entry, trans_id
1920
def _list_files_by_dir(self):
1921
todo = [ROOT_PARENT]
1923
while len(todo) > 0:
1925
parent_file_id = self._transform.final_file_id(parent)
1926
children = list(self._all_children(parent))
1927
paths = dict(zip(children, self._final_paths.get_paths(children)))
1928
children.sort(key=paths.get)
1929
todo.extend(reversed(children))
1930
for trans_id in children:
1931
ordered_ids.append((trans_id, parent_file_id))
1934
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
1935
# This may not be a maximally efficient implementation, but it is
1936
# reasonably straightforward. An implementation that grafts the
1937
# TreeTransform changes onto the tree's iter_entries_by_dir results
1938
# might be more efficient, but requires tricky inferences about stack
1940
ordered_ids = self._list_files_by_dir()
1941
for entry, trans_id in self._make_inv_entries(ordered_ids,
1942
specific_file_ids, yield_parents=yield_parents):
1943
yield unicode(self._final_paths.get_path(trans_id)), entry
1945
def _iter_entries_for_dir(self, dir_path):
1946
"""Return path, entry for items in a directory without recursing down."""
1947
dir_file_id = self.path2id(dir_path)
1949
for file_id in self.iter_children(dir_file_id):
1950
trans_id = self._transform.trans_id_file_id(file_id)
1951
ordered_ids.append((trans_id, file_id))
1952
for entry, trans_id in self._make_inv_entries(ordered_ids):
1953
yield unicode(self._final_paths.get_path(trans_id)), entry
1955
def list_files(self, include_root=False, from_dir=None, recursive=True):
1956
"""See WorkingTree.list_files."""
1957
# XXX This should behave like WorkingTree.list_files, but is really
1958
# more like RevisionTree.list_files.
1962
prefix = from_dir + '/'
1963
entries = self.iter_entries_by_dir()
1964
for path, entry in entries:
1965
if entry.name == '' and not include_root:
1968
if not path.startswith(prefix):
1970
path = path[len(prefix):]
1971
yield path, 'V', entry.kind, entry.file_id, entry
1973
if from_dir is None and include_root is True:
1974
root_entry = inventory.make_entry('directory', '',
1975
ROOT_PARENT, self.get_root_id())
1976
yield '', 'V', 'directory', root_entry.file_id, root_entry
1977
entries = self._iter_entries_for_dir(from_dir or '')
1978
for path, entry in entries:
1979
yield path, 'V', entry.kind, entry.file_id, entry
1431
def iter_entries_by_dir(self, specific_file_ids=None):
1432
return self._transform._tree.iter_entries_by_dir(specific_file_ids)
1981
1434
def kind(self, file_id):
1982
1435
trans_id = self._transform.trans_id_file_id(file_id)
1983
1436
return self._transform.final_kind(trans_id)
1985
1438
def stored_kind(self, file_id):
1986
trans_id = self._transform.trans_id_file_id(file_id)
1988
return self._transform._new_contents[trans_id]
1990
return self._transform._tree.stored_kind(file_id)
1439
return self._transform._tree.stored_kind(file_id)
1992
1441
def get_file_mtime(self, file_id, path=None):
1993
1442
"""See Tree.get_file_mtime"""
1994
1443
if not self._content_change(file_id):
1995
return self._transform._tree.get_file_mtime(file_id)
1444
return self._transform._tree.get_file_mtime(file_id, path)
1996
1445
return self._stat_limbo_file(file_id).st_mtime
1998
def _file_size(self, entry, stat_value):
1999
return self.get_file_size(entry.file_id)
2001
1447
def get_file_size(self, file_id):
2002
1448
"""See Tree.get_file_size"""
2003
1449
if self.kind(file_id) == 'file':
2008
1454
def get_file_sha1(self, file_id, path=None, stat_value=None):
2009
trans_id = self._transform.trans_id_file_id(file_id)
2010
kind = self._transform._new_contents.get(trans_id)
2012
return self._transform._tree.get_file_sha1(file_id)
2014
fileobj = self.get_file(file_id)
2016
return sha_file(fileobj)
1455
return self._transform._tree.get_file_sha1(file_id)
2020
1457
def is_executable(self, file_id, path=None):
2023
trans_id = self._transform.trans_id_file_id(file_id)
2025
return self._transform._new_executability[trans_id]
2028
return self._transform._tree.is_executable(file_id, path)
2030
if e.errno == errno.ENOENT:
2033
except errors.NoSuchId:
1458
return self._transform._tree.is_executable(file_id, path)
2036
1460
def path_content_summary(self, path):
2037
trans_id = self._path2trans_id(path)
2038
tt = self._transform
2039
tree_path = tt._tree_id_paths.get(trans_id)
2040
kind = tt._new_contents.get(trans_id)
2042
if tree_path is None or trans_id in tt._removed_contents:
2043
return 'missing', None, None, None
2044
summary = tt._tree.path_content_summary(tree_path)
2045
kind, size, executable, link_or_sha1 = summary
2048
limbo_name = tt._limbo_name(trans_id)
2049
if trans_id in tt._new_reference_revision:
2050
kind = 'tree-reference'
2052
statval = os.lstat(limbo_name)
2053
size = statval.st_size
2054
if not supports_executable():
2057
executable = statval.st_mode & S_IEXEC
2061
if kind == 'symlink':
2062
link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2063
executable = tt._new_executability.get(trans_id, executable)
2064
return kind, size, executable, link_or_sha1
1461
return self._transform._tree.path_content_summary(path)
2066
1463
def iter_changes(self, from_tree, include_unchanged=False,
2067
1464
specific_files=None, pb=None, extra_trees=None,
2068
1465
require_versioned=True, want_unversioned=False):
2069
1466
"""See InterTree.iter_changes.
2071
This has a fast path that is only used when the from_tree matches
2072
the transform tree, and no fancy options are supplied.
1468
This implementation does not support include_unchanged, specific_files,
1469
or want_unversioned. extra_trees, require_versioned, and pb are
2074
if (from_tree is not self._transform._tree or include_unchanged or
2075
specific_files or want_unversioned):
2076
return tree.InterTree(from_tree, self).iter_changes(
2077
include_unchanged=include_unchanged,
2078
specific_files=specific_files,
2080
extra_trees=extra_trees,
2081
require_versioned=require_versioned,
2082
want_unversioned=want_unversioned)
1472
if from_tree is not self._transform._tree:
1473
raise ValueError('from_tree must be transform source tree.')
1474
if include_unchanged:
1475
raise ValueError('include_unchanged is not supported')
1476
if specific_files is not None:
1477
raise ValueError('specific_files is not supported')
2083
1478
if want_unversioned:
2084
1479
raise ValueError('want_unversioned is not supported')
2085
1480
return self._transform.iter_changes()
added
removed
bzrlib/transform.py
