263
217
self.version_file(old_root_file_id, old_root)
264
218
self.unversion_file(self._new_root)
220
def fixup_new_roots(self):
221
"""Reinterpret requests to change the root directory
223
Instead of creating a root directory, or moving an existing directory,
224
all the attributes and children of the new root are applied to the
225
existing root directory.
227
This means that the old root trans-id becomes obsolete, so it is
228
recommended only to invoke this after the root trans-id has become
232
new_roots = [k for k, v in self._new_parent.iteritems() if v is
234
if len(new_roots) < 1:
236
if len(new_roots) != 1:
237
raise ValueError('A tree cannot have two roots!')
238
if self._new_root is None:
239
self._new_root = new_roots[0]
241
old_new_root = new_roots[0]
242
# unversion the new root's directory.
243
if self.final_kind(self._new_root) is None:
244
file_id = self.final_file_id(old_new_root)
246
file_id = self.final_file_id(self._new_root)
247
if old_new_root in self._new_id:
248
self.cancel_versioning(old_new_root)
250
self.unversion_file(old_new_root)
251
# if, at this stage, root still has an old file_id, zap it so we can
252
# stick a new one in.
253
if (self.tree_file_id(self._new_root) is not None and
254
self._new_root not in self._removed_id):
255
self.unversion_file(self._new_root)
256
if file_id is not None:
257
self.version_file(file_id, self._new_root)
259
# Now move children of new root into old root directory.
260
# Ensure all children are registered with the transaction, but don't
261
# use directly-- some tree children have new parents
262
list(self.iter_tree_children(old_new_root))
263
# Move all children of new root into old root directory.
264
for child in self.by_parent().get(old_new_root, []):
265
self.adjust_path(self.final_name(child), self._new_root, child)
267
# Ensure old_new_root has no directory.
268
if old_new_root in self._new_contents:
269
self.cancel_creation(old_new_root)
271
self.delete_contents(old_new_root)
273
# prevent deletion of root directory.
274
if self._new_root in self._removed_contents:
275
self.cancel_deletion(self._new_root)
277
# destroy path info for old_new_root.
278
del self._new_parent[old_new_root]
279
del self._new_name[old_new_root]
266
281
def trans_id_tree_file_id(self, inventory_id):
267
282
"""Determine the transaction id of a working tree file.
269
284
This reflects only files that already exist, not ones that will be
270
285
added by transactions.
331
327
return ROOT_PARENT
332
328
return self.trans_id_tree_path(os.path.dirname(path))
334
def create_file(self, contents, trans_id, mode_id=None):
335
"""Schedule creation of a new file.
339
Contents is an iterator of strings, all of which will be written
340
to the target destination.
342
New file takes the permissions of any existing file with that id,
343
unless mode_id is specified.
345
name = self._limbo_name(trans_id)
349
unique_add(self._new_contents, trans_id, 'file')
351
# Clean up the file, it never got registered so
352
# TreeTransform.finalize() won't clean it up.
357
f.writelines(contents)
360
self._set_mode(trans_id, mode_id, S_ISREG)
362
def _set_mode(self, trans_id, mode_id, typefunc):
363
"""Set the mode of new file contents.
364
The mode_id is the existing file to get the mode from (often the same
365
as trans_id). The operation is only performed if there's a mode match
366
according to typefunc.
371
old_path = self._tree_id_paths[mode_id]
375
mode = os.stat(self._tree.abspath(old_path)).st_mode
377
if e.errno in (errno.ENOENT, errno.ENOTDIR):
378
# Either old_path doesn't exist, or the parent of the
379
# target is not a directory (but will be one eventually)
380
# Either way, we know it doesn't exist *right now*
381
# See also bug #248448
386
os.chmod(self._limbo_name(trans_id), mode)
388
def create_hardlink(self, path, trans_id):
389
"""Schedule creation of a hard link"""
390
name = self._limbo_name(trans_id)
394
if e.errno != errno.EPERM:
396
raise errors.HardLinkNotSupported(path)
398
unique_add(self._new_contents, trans_id, 'file')
400
# Clean up the file, it never got registered so
401
# TreeTransform.finalize() won't clean it up.
405
def create_directory(self, trans_id):
406
"""Schedule creation of a new directory.
408
See also new_directory.
410
os.mkdir(self._limbo_name(trans_id))
411
unique_add(self._new_contents, trans_id, 'directory')
413
def create_symlink(self, target, trans_id):
414
"""Schedule creation of a new symbolic link.
416
target is a bytestring.
417
See also new_symlink.
420
os.symlink(target, self._limbo_name(trans_id))
421
unique_add(self._new_contents, trans_id, 'symlink')
424
path = FinalPaths(self).get_path(trans_id)
427
raise UnableCreateSymlink(path=path)
429
def cancel_creation(self, trans_id):
430
"""Cancel the creation of new file contents."""
431
del self._new_contents[trans_id]
432
children = self._limbo_children.get(trans_id)
433
# if this is a limbo directory with children, move them before removing
435
if children is not None:
436
self._rename_in_limbo(children)
437
del self._limbo_children[trans_id]
438
del self._limbo_children_names[trans_id]
439
delete_any(self._limbo_name(trans_id))
441
330
def delete_contents(self, trans_id):
442
331
"""Schedule the contents of a path entry for deletion"""
443
self.tree_kind(trans_id)
444
self._removed_contents.add(trans_id)
332
kind = self.tree_kind(trans_id)
334
self._removed_contents.add(trans_id)
446
336
def cancel_deletion(self, trans_id):
447
337
"""Cancel a scheduled deletion"""
504
394
return sorted(FinalPaths(self).get_paths(new_ids))
506
396
def _inventory_altered(self):
507
"""Get the trans_ids and paths of files needing new inv entries."""
509
for id_set in [self._new_name, self._new_parent, self._new_id,
397
"""Determine which trans_ids need new Inventory entries.
399
An new entry is needed when anything that would be reflected by an
400
inventory entry changes, including file name, file_id, parent file_id,
401
file kind, and the execute bit.
403
Some care is taken to return entries with real changes, not cases
404
where the value is deleted and then restored to its original value,
405
but some actually unchanged values may be returned.
407
:returns: A list of (path, trans_id) for all items requiring an
408
inventory change. Ordered by path.
411
# Find entries whose file_ids are new (or changed).
412
new_file_id = set(t for t in self._new_id
413
if self._new_id[t] != self.tree_file_id(t))
414
for id_set in [self._new_name, self._new_parent, new_file_id,
510
415
self._new_executability]:
511
new_ids.update(id_set)
416
changed_ids.update(id_set)
417
# removing implies a kind change
512
418
changed_kind = set(self._removed_contents)
513
420
changed_kind.intersection_update(self._new_contents)
514
changed_kind.difference_update(new_ids)
515
changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
517
new_ids.update(changed_kind)
518
return sorted(FinalPaths(self).get_paths(new_ids))
520
def tree_kind(self, trans_id):
521
"""Determine the file kind in the working tree.
523
Raises NoSuchFile if the file does not exist
525
path = self._tree_id_paths.get(trans_id)
527
raise NoSuchFile(None)
529
return file_kind(self._tree.abspath(path))
531
if e.errno != errno.ENOENT:
534
raise NoSuchFile(path)
421
# Ignore entries that are already known to have changed.
422
changed_kind.difference_update(changed_ids)
423
# to keep only the truly changed ones
424
changed_kind = (t for t in changed_kind
425
if self.tree_kind(t) != self.final_kind(t))
426
# all kind changes will alter the inventory
427
changed_ids.update(changed_kind)
428
# To find entries with changed parent_ids, find parents which existed,
429
# but changed file_id.
430
changed_file_id = set(t for t in new_file_id if t in self._removed_id)
431
# Now add all their children to the set.
432
for parent_trans_id in new_file_id:
433
changed_ids.update(self.iter_tree_children(parent_trans_id))
434
return sorted(FinalPaths(self).get_paths(changed_ids))
536
436
def final_kind(self, trans_id):
537
437
"""Determine the final file kind, after any changes applied.
539
Raises NoSuchFile if the file does not exist/has no contents.
540
(It is conceivable that a path would be created without the
541
corresponding contents insertion command)
439
:return: None if the file does not exist/has no contents. (It is
440
conceivable that a path would be created without the corresponding
441
contents insertion command)
543
443
if trans_id in self._new_contents:
544
444
return self._new_contents[trans_id]
545
445
elif trans_id in self._removed_contents:
546
raise NoSuchFile(None)
548
448
return self.tree_kind(trans_id)
666
573
# ensure that all children are registered with the transaction
667
574
list(self.iter_tree_children(parent_id))
669
def iter_tree_children(self, parent_id):
670
"""Iterate through the entry's tree children, if any"""
672
path = self._tree_id_paths[parent_id]
676
children = os.listdir(self._tree.abspath(path))
678
if not (osutils._is_error_enotdir(e)
679
or e.errno in (errno.ENOENT, errno.ESRCH)):
683
for child in children:
684
childpath = joinpath(path, child)
685
if self._tree.is_control_filename(childpath):
687
yield self.trans_id_tree_path(childpath)
576
@deprecated_method(deprecated_in((2, 3, 0)))
689
577
def has_named_child(self, by_parent, parent_id, name):
691
children = by_parent[parent_id]
694
for child in children:
578
return self._has_named_child(
579
name, parent_id, known_children=by_parent.get(parent_id, []))
581
def _has_named_child(self, name, parent_id, known_children):
582
"""Does a parent already have a name child.
584
:param name: The searched for name.
586
:param parent_id: The parent for which the check is made.
588
:param known_children: The already known children. This should have
589
been recently obtained from `self.by_parent.get(parent_id)`
590
(or will be if None is passed).
592
if known_children is None:
593
known_children = self.by_parent().get(parent_id, [])
594
for child in known_children:
695
595
if self.final_name(child) == name:
698
path = self._tree_id_paths[parent_id]
597
parent_path = self._tree_id_paths.get(parent_id, None)
598
if parent_path is None:
599
# No parent... no children
701
childpath = joinpath(path, name)
702
child_id = self._tree_path_ids.get(childpath)
601
child_path = joinpath(parent_path, name)
602
child_id = self._tree_path_ids.get(child_path, None)
703
603
if child_id is None:
704
return lexists(self._tree.abspath(childpath))
604
# Not known by the tree transform yet, check the filesystem
605
return osutils.lexists(self._tree.abspath(child_path))
706
if self.final_parent(child_id) != parent_id:
708
if child_id in self._removed_contents:
709
# XXX What about dangling file-ids?
607
raise AssertionError('child_id is missing: %s, %s, %s'
608
% (name, parent_id, child_id))
610
def _available_backup_name(self, name, target_id):
611
"""Find an available backup name.
613
:param name: The basename of the file.
615
:param target_id: The directory trans_id where the backup should
618
known_children = self.by_parent().get(target_id, [])
619
return osutils.available_backup_name(
621
lambda base: self._has_named_child(
622
base, target_id, known_children))
714
624
def _parent_loops(self):
715
625
"""No entry should be its own ancestor"""
836
741
def _parent_type_conflicts(self, by_parent):
837
"""parents must have directory 'contents'."""
742
"""Children must have a directory parent"""
839
744
for parent_id, children in by_parent.iteritems():
840
745
if parent_id is ROOT_PARENT:
842
if not self._any_contents(children):
748
for child_id in children:
749
if self.final_kind(child_id) is not None:
844
for child in children:
846
self.final_kind(child)
850
kind = self.final_kind(parent_id)
754
# There is at least a child, so we need an existing directory to
756
kind = self.final_kind(parent_id)
758
# The directory will be deleted
854
759
conflicts.append(('missing parent', parent_id))
855
760
elif kind != "directory":
761
# Meh, we need a *directory* to put something in it
856
762
conflicts.append(('non-directory parent', parent_id))
859
def _any_contents(self, trans_ids):
860
"""Return true if any of the trans_ids, will have contents."""
861
for trans_id in trans_ids:
863
kind = self.final_kind(trans_id)
869
def _limbo_name(self, trans_id):
870
"""Generate the limbo name of a file"""
871
limbo_name = self._limbo_files.get(trans_id)
872
if limbo_name is not None:
874
parent = self._new_parent.get(trans_id)
875
# if the parent directory is already in limbo (e.g. when building a
876
# tree), choose a limbo name inside the parent, to reduce further
878
use_direct_path = False
879
if self._new_contents.get(parent) == 'directory':
880
filename = self._new_name.get(trans_id)
881
if filename is not None:
882
if parent not in self._limbo_children:
883
self._limbo_children[parent] = set()
884
self._limbo_children_names[parent] = {}
885
use_direct_path = True
886
# the direct path can only be used if no other file has
887
# already taken this pathname, i.e. if the name is unused, or
888
# if it is already associated with this trans_id.
889
elif self._case_sensitive_target:
890
if (self._limbo_children_names[parent].get(filename)
891
in (trans_id, None)):
892
use_direct_path = True
894
for l_filename, l_trans_id in\
895
self._limbo_children_names[parent].iteritems():
896
if l_trans_id == trans_id:
898
if l_filename.lower() == filename.lower():
901
use_direct_path = True
904
limbo_name = pathjoin(self._limbo_files[parent], filename)
905
self._limbo_children[parent].add(trans_id)
906
self._limbo_children_names[parent][filename] = trans_id
908
limbo_name = pathjoin(self._limbodir, trans_id)
909
self._needs_rename.add(trans_id)
910
self._limbo_files[trans_id] = limbo_name
913
765
def _set_executability(self, path, trans_id):
914
766
"""Set the executability of versioned files """
915
767
if supports_executable():
1121
1012
def get_preview_tree(self):
1122
1013
"""Return a tree representing the result of the transform.
1124
This tree only supports the subset of Tree functionality required
1125
by show_diff_trees. It must only be compared to tt._tree.
1015
The tree is a snapshot, and altering the TreeTransform will invalidate
1127
1018
return _PreviewTree(self)
1020
def commit(self, branch, message, merge_parents=None, strict=False,
1021
timestamp=None, timezone=None, committer=None, authors=None,
1022
revprops=None, revision_id=None):
1023
"""Commit the result of this TreeTransform to a branch.
1025
:param branch: The branch to commit to.
1026
:param message: The message to attach to the commit.
1027
:param merge_parents: Additional parent revision-ids specified by
1029
:param strict: If True, abort the commit if there are unversioned
1031
:param timestamp: if not None, seconds-since-epoch for the time and
1032
date. (May be a float.)
1033
:param timezone: Optional timezone for timestamp, as an offset in
1035
:param committer: Optional committer in email-id format.
1036
(e.g. "J Random Hacker <jrandom@example.com>")
1037
:param authors: Optional list of authors in email-id format.
1038
:param revprops: Optional dictionary of revision properties.
1039
:param revision_id: Optional revision id. (Specifying a revision-id
1040
may reduce performance for some non-native formats.)
1041
:return: The revision_id of the revision committed.
1043
self._check_malformed()
1045
unversioned = set(self._new_contents).difference(set(self._new_id))
1046
for trans_id in unversioned:
1047
if self.final_file_id(trans_id) is None:
1048
raise errors.StrictCommitFailed()
1050
revno, last_rev_id = branch.last_revision_info()
1051
if last_rev_id == _mod_revision.NULL_REVISION:
1052
if merge_parents is not None:
1053
raise ValueError('Cannot supply merge parents for first'
1057
parent_ids = [last_rev_id]
1058
if merge_parents is not None:
1059
parent_ids.extend(merge_parents)
1060
if self._tree.get_revision_id() != last_rev_id:
1061
raise ValueError('TreeTransform not based on branch basis: %s' %
1062
self._tree.get_revision_id())
1063
revprops = commit.Commit.update_revprops(revprops, branch, authors)
1064
builder = branch.get_commit_builder(parent_ids,
1065
timestamp=timestamp,
1067
committer=committer,
1069
revision_id=revision_id)
1070
preview = self.get_preview_tree()
1071
list(builder.record_iter_changes(preview, last_rev_id,
1072
self.iter_changes()))
1073
builder.finish_inventory()
1074
revision_id = builder.commit(message)
1075
branch.set_last_revision_info(revno + 1, revision_id)
1129
1078
def _text_parent(self, trans_id):
1130
1079
file_id = self.tree_file_id(trans_id)
1226
1171
self.create_symlink(content.decode('utf-8'), trans_id)
1229
class TreeTransform(TreeTransformBase):
1174
class DiskTreeTransform(TreeTransformBase):
1175
"""Tree transform storing its contents on disk."""
1177
def __init__(self, tree, limbodir, pb=None,
1178
case_sensitive=True):
1180
:param tree: The tree that will be transformed, but not necessarily
1182
:param limbodir: A directory where new files can be stored until
1183
they are installed in their proper places
1185
:param case_sensitive: If True, the target of the transform is
1186
case sensitive, not just case preserving.
1188
TreeTransformBase.__init__(self, tree, pb, case_sensitive)
1189
self._limbodir = limbodir
1190
self._deletiondir = None
1191
# A mapping of transform ids to their limbo filename
1192
self._limbo_files = {}
1193
self._possibly_stale_limbo_files = set()
1194
# A mapping of transform ids to a set of the transform ids of children
1195
# that their limbo directory has
1196
self._limbo_children = {}
1197
# Map transform ids to maps of child filename to child transform id
1198
self._limbo_children_names = {}
1199
# List of transform ids that need to be renamed from limbo into place
1200
self._needs_rename = set()
1201
self._creation_mtime = None
1204
"""Release the working tree lock, if held, clean up limbo dir.
1206
This is required if apply has not been invoked, but can be invoked
1209
if self._tree is None:
1212
limbo_paths = self._limbo_files.values() + list(
1213
self._possibly_stale_limbo_files)
1214
limbo_paths = sorted(limbo_paths, reverse=True)
1215
for path in limbo_paths:
1219
if e.errno != errno.ENOENT:
1221
# XXX: warn? perhaps we just got interrupted at an
1222
# inconvenient moment, but perhaps files are disappearing
1225
delete_any(self._limbodir)
1227
# We don't especially care *why* the dir is immortal.
1228
raise ImmortalLimbo(self._limbodir)
1230
if self._deletiondir is not None:
1231
delete_any(self._deletiondir)
1233
raise errors.ImmortalPendingDeletion(self._deletiondir)
1235
TreeTransformBase.finalize(self)
1237
def _limbo_name(self, trans_id):
1238
"""Generate the limbo name of a file"""
1239
limbo_name = self._limbo_files.get(trans_id)
1240
if limbo_name is None:
1241
limbo_name = self._generate_limbo_path(trans_id)
1242
self._limbo_files[trans_id] = limbo_name
1245
def _generate_limbo_path(self, trans_id):
1246
"""Generate a limbo path using the trans_id as the relative path.
1248
This is suitable as a fallback, and when the transform should not be
1249
sensitive to the path encoding of the limbo directory.
1251
self._needs_rename.add(trans_id)
1252
return pathjoin(self._limbodir, trans_id)
1254
def adjust_path(self, name, parent, trans_id):
1255
previous_parent = self._new_parent.get(trans_id)
1256
previous_name = self._new_name.get(trans_id)
1257
TreeTransformBase.adjust_path(self, name, parent, trans_id)
1258
if (trans_id in self._limbo_files and
1259
trans_id not in self._needs_rename):
1260
self._rename_in_limbo([trans_id])
1261
if previous_parent != parent:
1262
self._limbo_children[previous_parent].remove(trans_id)
1263
if previous_parent != parent or previous_name != name:
1264
del self._limbo_children_names[previous_parent][previous_name]
1266
def _rename_in_limbo(self, trans_ids):
1267
"""Fix limbo names so that the right final path is produced.
1269
This means we outsmarted ourselves-- we tried to avoid renaming
1270
these files later by creating them with their final names in their
1271
final parents. But now the previous name or parent is no longer
1272
suitable, so we have to rename them.
1274
Even for trans_ids that have no new contents, we must remove their
1275
entries from _limbo_files, because they are now stale.
1277
for trans_id in trans_ids:
1278
old_path = self._limbo_files[trans_id]
1279
self._possibly_stale_limbo_files.add(old_path)
1280
del self._limbo_files[trans_id]
1281
if trans_id not in self._new_contents:
1283
new_path = self._limbo_name(trans_id)
1284
os.rename(old_path, new_path)
1285
self._possibly_stale_limbo_files.remove(old_path)
1286
for descendant in self._limbo_descendants(trans_id):
1287
desc_path = self._limbo_files[descendant]
1288
desc_path = new_path + desc_path[len(old_path):]
1289
self._limbo_files[descendant] = desc_path
1291
def _limbo_descendants(self, trans_id):
1292
"""Return the set of trans_ids whose limbo paths descend from this."""
1293
descendants = set(self._limbo_children.get(trans_id, []))
1294
for descendant in list(descendants):
1295
descendants.update(self._limbo_descendants(descendant))
1298
def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1299
"""Schedule creation of a new file.
1303
:param contents: an iterator of strings, all of which will be written
1304
to the target destination.
1305
:param trans_id: TreeTransform handle
1306
:param mode_id: If not None, force the mode of the target file to match
1307
the mode of the object referenced by mode_id.
1308
Otherwise, we will try to preserve mode bits of an existing file.
1309
:param sha1: If the sha1 of this content is already known, pass it in.
1310
We can use it to prevent future sha1 computations.
1312
name = self._limbo_name(trans_id)
1313
f = open(name, 'wb')
1315
unique_add(self._new_contents, trans_id, 'file')
1316
f.writelines(contents)
1319
self._set_mtime(name)
1320
self._set_mode(trans_id, mode_id, S_ISREG)
1321
# It is unfortunate we have to use lstat instead of fstat, but we just
1322
# used utime and chmod on the file, so we need the accurate final
1324
if sha1 is not None:
1325
self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1327
def _read_file_chunks(self, trans_id):
1328
cur_file = open(self._limbo_name(trans_id), 'rb')
1330
return cur_file.readlines()
1334
def _read_symlink_target(self, trans_id):
1335
return os.readlink(self._limbo_name(trans_id))
1337
def _set_mtime(self, path):
1338
"""All files that are created get the same mtime.
1340
This time is set by the first object to be created.
1342
if self._creation_mtime is None:
1343
self._creation_mtime = time.time()
1344
os.utime(path, (self._creation_mtime, self._creation_mtime))
1346
def create_hardlink(self, path, trans_id):
1347
"""Schedule creation of a hard link"""
1348
name = self._limbo_name(trans_id)
1352
if e.errno != errno.EPERM:
1354
raise errors.HardLinkNotSupported(path)
1356
unique_add(self._new_contents, trans_id, 'file')
1358
# Clean up the file, it never got registered so
1359
# TreeTransform.finalize() won't clean it up.
1363
def create_directory(self, trans_id):
1364
"""Schedule creation of a new directory.
1366
See also new_directory.
1368
os.mkdir(self._limbo_name(trans_id))
1369
unique_add(self._new_contents, trans_id, 'directory')
1371
def create_symlink(self, target, trans_id):
1372
"""Schedule creation of a new symbolic link.
1374
target is a bytestring.
1375
See also new_symlink.
1378
os.symlink(target, self._limbo_name(trans_id))
1379
unique_add(self._new_contents, trans_id, 'symlink')
1382
path = FinalPaths(self).get_path(trans_id)
1385
raise UnableCreateSymlink(path=path)
1387
def cancel_creation(self, trans_id):
1388
"""Cancel the creation of new file contents."""
1389
del self._new_contents[trans_id]
1390
if trans_id in self._observed_sha1s:
1391
del self._observed_sha1s[trans_id]
1392
children = self._limbo_children.get(trans_id)
1393
# if this is a limbo directory with children, move them before removing
1395
if children is not None:
1396
self._rename_in_limbo(children)
1397
del self._limbo_children[trans_id]
1398
del self._limbo_children_names[trans_id]
1399
delete_any(self._limbo_name(trans_id))
1401
def new_orphan(self, trans_id, parent_id):
1402
# FIXME: There is no tree config, so we use the branch one (it's weird
1403
# to define it this way as orphaning can only occur in a working tree,
1404
# but that's all we have (for now). It will find the option in
1405
# locations.conf or bazaar.conf though) -- vila 20100916
1406
conf = self._tree.branch.get_config()
1407
conf_var_name = 'bzr.transform.orphan_policy'
1408
orphan_policy = conf.get_user_option(conf_var_name)
1409
default_policy = orphaning_registry.default_key
1410
if orphan_policy is None:
1411
orphan_policy = default_policy
1412
if orphan_policy not in orphaning_registry:
1413
trace.warning('%s (from %s) is not a known policy, defaulting '
1414
'to %s' % (orphan_policy, conf_var_name, default_policy))
1415
orphan_policy = default_policy
1416
handle_orphan = orphaning_registry.get(orphan_policy)
1417
handle_orphan(self, trans_id, parent_id)
1420
class OrphaningError(errors.BzrError):
1422
# Only bugs could lead to such exception being seen by the user
1423
internal_error = True
1424
_fmt = "Error while orphaning %s in %s directory"
1426
def __init__(self, orphan, parent):
1427
errors.BzrError.__init__(self)
1428
self.orphan = orphan
1429
self.parent = parent
1432
class OrphaningForbidden(OrphaningError):
1434
_fmt = "Policy: %s doesn't allow creating orphans."
1436
def __init__(self, policy):
1437
errors.BzrError.__init__(self)
1438
self.policy = policy
1441
def move_orphan(tt, orphan_id, parent_id):
1442
"""See TreeTransformBase.new_orphan.
1444
This creates a new orphan in the `bzr-orphans` dir at the root of the
1447
:param tt: The TreeTransform orphaning `trans_id`.
1449
:param orphan_id: The trans id that should be orphaned.
1451
:param parent_id: The orphan parent trans id.
1453
# Add the orphan dir if it doesn't exist
1454
orphan_dir_basename = 'bzr-orphans'
1455
od_id = tt.trans_id_tree_path(orphan_dir_basename)
1456
if tt.final_kind(od_id) is None:
1457
tt.create_directory(od_id)
1458
parent_path = tt._tree_id_paths[parent_id]
1459
# Find a name that doesn't exist yet in the orphan dir
1460
actual_name = tt.final_name(orphan_id)
1461
new_name = tt._available_backup_name(actual_name, od_id)
1462
tt.adjust_path(new_name, od_id, orphan_id)
1463
trace.warning('%s has been orphaned in %s'
1464
% (joinpath(parent_path, actual_name), orphan_dir_basename))
1467
def refuse_orphan(tt, orphan_id, parent_id):
1468
"""See TreeTransformBase.new_orphan.
1470
This refuses to create orphan, letting the caller handle the conflict.
1472
raise OrphaningForbidden('never')
1475
orphaning_registry = registry.Registry()
1476
orphaning_registry.register(
1477
'conflict', refuse_orphan,
1478
'Leave orphans in place and create a conflict on the directory.')
1479
orphaning_registry.register(
1480
'move', move_orphan,
1481
'Move orphans into the bzr-orphans directory.')
1482
orphaning_registry._set_default_key('conflict')
1485
class TreeTransform(DiskTreeTransform):
1230
1486
"""Represent a tree transformation.
1232
1488
This object is designed to support incremental generation of the transform,
1321
TreeTransformBase.__init__(self, tree, limbodir, pb,
1577
# Cache of realpath results, to speed up canonical_path
1578
self._realpaths = {}
1579
# Cache of relpath results, to speed up canonical_path
1581
DiskTreeTransform.__init__(self, tree, limbodir, pb,
1322
1582
tree.case_sensitive)
1323
1583
self._deletiondir = deletiondir
1585
def canonical_path(self, path):
1586
"""Get the canonical tree-relative path"""
1587
# don't follow final symlinks
1588
abs = self._tree.abspath(path)
1589
if abs in self._relpaths:
1590
return self._relpaths[abs]
1591
dirname, basename = os.path.split(abs)
1592
if dirname not in self._realpaths:
1593
self._realpaths[dirname] = os.path.realpath(dirname)
1594
dirname = self._realpaths[dirname]
1595
abs = pathjoin(dirname, basename)
1596
if dirname in self._relpaths:
1597
relpath = pathjoin(self._relpaths[dirname], basename)
1598
relpath = relpath.rstrip('/\\')
1600
relpath = self._tree.relpath(abs)
1601
self._relpaths[abs] = relpath
1604
def tree_kind(self, trans_id):
1605
"""Determine the file kind in the working tree.
1607
:returns: The file kind or None if the file does not exist
1609
path = self._tree_id_paths.get(trans_id)
1613
return file_kind(self._tree.abspath(path))
1614
except errors.NoSuchFile:
1617
def _set_mode(self, trans_id, mode_id, typefunc):
1618
"""Set the mode of new file contents.
1619
The mode_id is the existing file to get the mode from (often the same
1620
as trans_id). The operation is only performed if there's a mode match
1621
according to typefunc.
1626
old_path = self._tree_id_paths[mode_id]
1630
mode = os.stat(self._tree.abspath(old_path)).st_mode
1632
if e.errno in (errno.ENOENT, errno.ENOTDIR):
1633
# Either old_path doesn't exist, or the parent of the
1634
# target is not a directory (but will be one eventually)
1635
# Either way, we know it doesn't exist *right now*
1636
# See also bug #248448
1641
os.chmod(self._limbo_name(trans_id), mode)
1643
def iter_tree_children(self, parent_id):
1644
"""Iterate through the entry's tree children, if any"""
1646
path = self._tree_id_paths[parent_id]
1650
children = os.listdir(self._tree.abspath(path))
1652
if not (osutils._is_error_enotdir(e)
1653
or e.errno in (errno.ENOENT, errno.ESRCH)):
1657
for child in children:
1658
childpath = joinpath(path, child)
1659
if self._tree.is_control_filename(childpath):
1661
yield self.trans_id_tree_path(childpath)
1663
def _generate_limbo_path(self, trans_id):
1664
"""Generate a limbo path using the final path if possible.
1666
This optimizes the performance of applying the tree transform by
1667
avoiding renames. These renames can be avoided only when the parent
1668
directory is already scheduled for creation.
1670
If the final path cannot be used, falls back to using the trans_id as
1673
parent = self._new_parent.get(trans_id)
1674
# if the parent directory is already in limbo (e.g. when building a
1675
# tree), choose a limbo name inside the parent, to reduce further
1677
use_direct_path = False
1678
if self._new_contents.get(parent) == 'directory':
1679
filename = self._new_name.get(trans_id)
1680
if filename is not None:
1681
if parent not in self._limbo_children:
1682
self._limbo_children[parent] = set()
1683
self._limbo_children_names[parent] = {}
1684
use_direct_path = True
1685
# the direct path can only be used if no other file has
1686
# already taken this pathname, i.e. if the name is unused, or
1687
# if it is already associated with this trans_id.
1688
elif self._case_sensitive_target:
1689
if (self._limbo_children_names[parent].get(filename)
1690
in (trans_id, None)):
1691
use_direct_path = True
1693
for l_filename, l_trans_id in\
1694
self._limbo_children_names[parent].iteritems():
1695
if l_trans_id == trans_id:
1697
if l_filename.lower() == filename.lower():
1700
use_direct_path = True
1702
if not use_direct_path:
1703
return DiskTreeTransform._generate_limbo_path(self, trans_id)
1705
limbo_name = pathjoin(self._limbo_files[parent], filename)
1706
self._limbo_children[parent].add(trans_id)
1707
self._limbo_children_names[parent][filename] = trans_id
1325
1711
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1326
1712
"""Apply all changes to the inventory and filesystem.
1477
1865
modified_paths = []
1478
1866
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1480
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1868
child_pb = ui.ui_factory.nested_progress_bar()
1482
1870
for num, (path, trans_id) in enumerate(new_paths):
1483
1871
if (num % 10) == 0:
1484
child_pb.update('adding file', num, len(new_paths))
1872
child_pb.update(gettext('adding file'), num, len(new_paths))
1485
1873
full_path = self._tree.abspath(path)
1486
1874
if trans_id in self._needs_rename:
1488
1876
mover.rename(self._limbo_name(trans_id), full_path)
1877
except errors.TransformRenameFailed, e:
1490
1878
# We may be renaming a dangling inventory id
1491
1879
if e.errno != errno.ENOENT:
1494
1882
self.rename_count += 1
1883
# TODO: if trans_id in self._observed_sha1s, we should
1884
# re-stat the final target, since ctime will be
1885
# updated by the change.
1495
1886
if (trans_id in self._new_contents or
1496
1887
self.path_changed(trans_id)):
1497
1888
if trans_id in self._new_contents:
1498
1889
modified_paths.append(full_path)
1499
1890
if trans_id in self._new_executability:
1500
1891
self._set_executability(path, trans_id)
1892
if trans_id in self._observed_sha1s:
1893
o_sha1, o_st_val = self._observed_sha1s[trans_id]
1894
st = osutils.lstat(full_path)
1895
self._observed_sha1s[trans_id] = (o_sha1, st)
1502
1897
child_pb.finished()
1898
for path, trans_id in new_paths:
1899
# new_paths includes stuff like workingtree conflicts. Only the
1900
# stuff in new_contents actually comes from limbo.
1901
if trans_id in self._limbo_files:
1902
del self._limbo_files[trans_id]
1503
1903
self._new_contents.clear()
1504
1904
return modified_paths
1507
class TransformPreview(TreeTransformBase):
1906
def _apply_observed_sha1s(self):
1907
"""After we have finished renaming everything, update observed sha1s
1909
This has to be done after self._tree.apply_inventory_delta, otherwise
1910
it doesn't know anything about the files we are updating. Also, we want
1911
to do this as late as possible, so that most entries end up cached.
1913
# TODO: this doesn't update the stat information for directories. So
1914
# the first 'bzr status' will still need to rewrite
1915
# .bzr/checkout/dirstate. However, we at least don't need to
1916
# re-read all of the files.
1917
# TODO: If the operation took a while, we could do a time.sleep(3) here
1918
# to allow the clock to tick over and ensure we won't have any
1919
# problems. (we could observe start time, and finish time, and if
1920
# it is less than eg 10% overhead, add a sleep call.)
1921
paths = FinalPaths(self)
1922
for trans_id, observed in self._observed_sha1s.iteritems():
1923
path = paths.get_path(trans_id)
1924
# We could get the file_id, but dirstate prefers to use the path
1925
# anyway, and it is 'cheaper' to determine.
1926
# file_id = self._new_id[trans_id]
1927
self._tree._observed_sha1(None, path, observed)
1930
class TransformPreview(DiskTreeTransform):
1508
1931
"""A TreeTransform for generating preview trees.
1510
1933
Unlike TreeTransform, this version works when the input tree is a
1753
2188
ordered_ids = self._list_files_by_dir()
1754
2189
for entry, trans_id in self._make_inv_entries(ordered_ids,
1756
yield unicode(self._final_paths.get_path(trans_id)), entry
1758
def list_files(self, include_root=False):
1759
"""See Tree.list_files."""
2190
specific_file_ids, yield_parents=yield_parents):
2191
yield unicode(self._final_paths.get_path(trans_id)), entry
2193
def _iter_entries_for_dir(self, dir_path):
2194
"""Return path, entry for items in a directory without recursing down."""
2195
dir_file_id = self.path2id(dir_path)
2197
for file_id in self.iter_children(dir_file_id):
2198
trans_id = self._transform.trans_id_file_id(file_id)
2199
ordered_ids.append((trans_id, file_id))
2200
for entry, trans_id in self._make_inv_entries(ordered_ids):
2201
yield unicode(self._final_paths.get_path(trans_id)), entry
2203
def list_files(self, include_root=False, from_dir=None, recursive=True):
2204
"""See WorkingTree.list_files."""
1760
2205
# XXX This should behave like WorkingTree.list_files, but is really
1761
2206
# more like RevisionTree.list_files.
1762
for path, entry in self.iter_entries_by_dir():
1763
if entry.name == '' and not include_root:
1765
yield path, 'V', entry.kind, entry.file_id, entry
2210
prefix = from_dir + '/'
2211
entries = self.iter_entries_by_dir()
2212
for path, entry in entries:
2213
if entry.name == '' and not include_root:
2216
if not path.startswith(prefix):
2218
path = path[len(prefix):]
2219
yield path, 'V', entry.kind, entry.file_id, entry
2221
if from_dir is None and include_root is True:
2222
root_entry = inventory.make_entry('directory', '',
2223
ROOT_PARENT, self.get_root_id())
2224
yield '', 'V', 'directory', root_entry.file_id, root_entry
2225
entries = self._iter_entries_for_dir(from_dir or '')
2226
for path, entry in entries:
2227
yield path, 'V', entry.kind, entry.file_id, entry
1767
2229
def kind(self, file_id):
1768
2230
trans_id = self._transform.trans_id_file_id(file_id)
2150
2655
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
2152
2657
total = len(desired_files) + offset
2153
2659
if accelerator_tree is None:
2154
2660
new_desired_files = desired_files
2156
2662
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2157
unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
2158
in iter if not (c or e[0] != e[1]))
2663
unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2664
in iter if not (c or e[0] != e[1])]
2665
if accelerator_tree.supports_content_filtering():
2666
unchanged = [(f, p) for (f, p) in unchanged
2667
if not accelerator_tree.iter_search_rules([p]).next()]
2668
unchanged = dict(unchanged)
2159
2669
new_desired_files = []
2161
for file_id, trans_id in desired_files:
2671
for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2162
2672
accelerator_path = unchanged.get(file_id)
2163
2673
if accelerator_path is None:
2164
new_desired_files.append((file_id, trans_id))
2674
new_desired_files.append((file_id,
2675
(trans_id, tree_path, text_sha1)))
2166
pb.update('Adding file contents', count + offset, total)
2677
pb.update(gettext('Adding file contents'), count + offset, total)
2168
2679
tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2171
2682
contents = accelerator_tree.get_file(file_id, accelerator_path)
2683
if wt.supports_content_filtering():
2684
filters = wt._content_filter_stack(tree_path)
2685
contents = filtered_output_bytes(contents, filters,
2686
ContentFilterContext(tree_path, tree))
2173
tt.create_file(contents, trans_id)
2688
tt.create_file(contents, trans_id, sha1=text_sha1)
2692
except AttributeError:
2693
# after filtering, contents may no longer be file-like
2177
2696
offset += count
2178
for count, (trans_id, contents) in enumerate(tree.iter_files_bytes(
2179
new_desired_files)):
2180
tt.create_file(contents, trans_id)
2181
pb.update('Adding file contents', count + offset, total)
2697
for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2698
tree.iter_files_bytes(new_desired_files)):
2699
if wt.supports_content_filtering():
2700
filters = wt._content_filter_stack(tree_path)
2701
contents = filtered_output_bytes(contents, filters,
2702
ContentFilterContext(tree_path, tree))
2703
tt.create_file(contents, trans_id, sha1=text_sha1)
2704
pb.update(gettext('Adding file contents'), count + offset, total)
2184
2707
def _reparent_children(tt, old_parent, new_parent):
2185
2708
for child in tt.iter_tree_children(old_parent):
2186
2709
tt.adjust_path(tt.final_name(child), new_parent, child)
2188
2712
def _reparent_transform_children(tt, old_parent, new_parent):
2189
2713
by_parent = tt.by_parent()
2190
2714
for child in by_parent[old_parent]:
2191
2715
tt.adjust_path(tt.final_name(child), new_parent, child)
2192
2716
return by_parent[old_parent]
2194
2719
def _content_match(tree, entry, file_id, kind, target_path):
2195
2720
if entry.kind != kind:
2197
2722
if entry.kind == "directory":
2199
2724
if entry.kind == "file":
2200
if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2725
f = file(target_path, 'rb')
2727
if tree.get_file_text(file_id) == f.read():
2202
2731
elif entry.kind == "symlink":
2203
2732
if tree.get_symlink_target(file_id) == os.readlink(target_path):
2418
2953
if basis_tree is None:
2419
2954
basis_tree = working_tree.basis_tree()
2420
2955
basis_tree.lock_read()
2421
if file_id in basis_tree:
2956
if basis_tree.has_id(file_id):
2422
2957
if wt_sha1 != basis_tree.get_file_sha1(file_id):
2423
2958
keep_content = True
2424
elif kind[1] is None and not versioned[1]:
2959
elif target_kind is None and not target_versioned:
2425
2960
keep_content = True
2426
if kind[0] is not None:
2961
if wt_kind is not None:
2427
2962
if not keep_content:
2428
2963
tt.delete_contents(trans_id)
2429
elif kind[1] is not None:
2430
parent_trans_id = tt.trans_id_file_id(parent[0])
2431
by_parent = tt.by_parent()
2432
backup_name = _get_backup_name(name[0], by_parent,
2433
parent_trans_id, tt)
2964
elif target_kind is not None:
2965
parent_trans_id = tt.trans_id_file_id(wt_parent)
2966
backup_name = tt._available_backup_name(
2967
wt_name, parent_trans_id)
2434
2968
tt.adjust_path(backup_name, parent_trans_id, trans_id)
2435
new_trans_id = tt.create_path(name[0], parent_trans_id)
2436
if versioned == (True, True):
2969
new_trans_id = tt.create_path(wt_name, parent_trans_id)
2970
if wt_versioned and target_versioned:
2437
2971
tt.unversion_file(trans_id)
2438
2972
tt.version_file(file_id, new_trans_id)
2439
2973
# New contents should have the same unix perms as old
2441
2975
mode_id = trans_id
2442
2976
trans_id = new_trans_id
2443
if kind[1] in ('directory', 'tree-reference'):
2977
if target_kind in ('directory', 'tree-reference'):
2444
2978
tt.create_directory(trans_id)
2445
if kind[1] == 'tree-reference':
2979
if target_kind == 'tree-reference':
2446
2980
revision = target_tree.get_reference_revision(file_id,
2448
2982
tt.set_tree_reference(revision, trans_id)
2449
elif kind[1] == 'symlink':
2983
elif target_kind == 'symlink':
2450
2984
tt.create_symlink(target_tree.get_symlink_target(file_id),
2452
elif kind[1] == 'file':
2986
elif target_kind == 'file':
2453
2987
deferred_files.append((file_id, (trans_id, mode_id)))
2454
2988
if basis_tree is None:
2455
2989
basis_tree = working_tree.basis_tree()
2456
2990
basis_tree.lock_read()
2457
2991
new_sha1 = target_tree.get_file_sha1(file_id)
2458
if (file_id in basis_tree and new_sha1 ==
2459
basis_tree.get_file_sha1(file_id)):
2992
if (basis_tree.has_id(file_id) and
2993
new_sha1 == basis_tree.get_file_sha1(file_id)):
2460
2994
if file_id in merge_modified:
2461
2995
del merge_modified[file_id]
2463
2997
merge_modified[file_id] = new_sha1
2465
2999
# preserve the execute bit when backing up
2466
if keep_content and executable[0] == executable[1]:
2467
tt.set_executability(executable[1], trans_id)
2468
elif kind[1] is not None:
2469
raise AssertionError(kind[1])
2470
if versioned == (False, True):
3000
if keep_content and wt_executable == target_executable:
3001
tt.set_executability(target_executable, trans_id)
3002
elif target_kind is not None:
3003
raise AssertionError(target_kind)
3004
if not wt_versioned and target_versioned:
2471
3005
tt.version_file(file_id, trans_id)
2472
if versioned == (True, False):
3006
if wt_versioned and not target_versioned:
2473
3007
tt.unversion_file(trans_id)
2474
if (name[1] is not None and
2475
(name[0] != name[1] or parent[0] != parent[1])):
2476
if name[1] == '' and parent[1] is None:
3008
if (target_name is not None and
3009
(wt_name != target_name or wt_parent != target_parent)):
3010
if target_name == '' and target_parent is None:
2477
3011
parent_trans = ROOT_PARENT
2479
parent_trans = tt.trans_id_file_id(parent[1])
2480
tt.adjust_path(name[1], parent_trans, trans_id)
2481
if executable[0] != executable[1] and kind[1] == "file":
2482
tt.set_executability(executable[1], trans_id)
2483
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2485
tt.create_file(bytes, trans_id, mode_id)
3013
parent_trans = tt.trans_id_file_id(target_parent)
3014
if wt_parent is None and wt_versioned:
3015
tt.adjust_root_path(target_name, parent_trans)
3017
tt.adjust_path(target_name, parent_trans, trans_id)
3018
if wt_executable != target_executable and target_kind == "file":
3019
tt.set_executability(target_executable, trans_id)
3020
if working_tree.supports_content_filtering():
3021
for index, ((trans_id, mode_id), bytes) in enumerate(
3022
target_tree.iter_files_bytes(deferred_files)):
3023
file_id = deferred_files[index][0]
3024
# We're reverting a tree to the target tree so using the
3025
# target tree to find the file path seems the best choice
3026
# here IMO - Ian C 27/Oct/2009
3027
filter_tree_path = target_tree.id2path(file_id)
3028
filters = working_tree._content_filter_stack(filter_tree_path)
3029
bytes = filtered_output_bytes(bytes, filters,
3030
ContentFilterContext(filter_tree_path, working_tree))
3031
tt.create_file(bytes, trans_id, mode_id)
3033
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
3035
tt.create_file(bytes, trans_id, mode_id)
3036
tt.fixup_new_roots()
2487
3038
if basis_tree is not None:
2488
3039
basis_tree.unlock()
2489
3040
return merge_modified
2492
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
3043
def resolve_conflicts(tt, pb=None, pass_func=None):
2493
3044
"""Make many conflict-resolution attempts, but die if they fail"""
2494
3045
if pass_func is None:
2495
3046
pass_func = conflict_pass
2496
3047
new_conflicts = set()
3048
pb = ui.ui_factory.nested_progress_bar()
2498
3050
for n in range(10):
2499
pb.update('Resolution pass', n+1, 10)
3051
pb.update(gettext('Resolution pass'), n+1, 10)
2500
3052
conflicts = tt.find_conflicts()
2501
3053
if len(conflicts) == 0:
2502
3054
return new_conflicts
2503
3055
new_conflicts.update(pass_func(tt, conflicts))
2504
3056
raise MalformedTransform(conflicts=conflicts)
2509
3061
def conflict_pass(tt, conflicts, path_tree=None):
added
removed
bzrlib/transform.py
