835
894
self.create_symlink(target, trans_id)
838
def new_orphan(self, trans_id, parent_id):
839
"""Schedule an item to be orphaned.
841
When a directory is about to be removed, its children, if they are not
842
versioned are moved out of the way: they don't have a parent anymore.
844
:param trans_id: The trans_id of the existing item.
845
:param parent_id: The parent trans_id of the item.
847
raise NotImplementedError(self.new_orphan)
849
def _get_potential_orphans(self, dir_id):
850
"""Find the potential orphans in a directory.
852
A directory can't be safely deleted if there are versioned files in it.
853
If all the contained files are unversioned then they can be orphaned.
855
The 'None' return value means that the directory contains at least one
856
versioned file and should not be deleted.
858
:param dir_id: The directory trans id.
860
:return: A list of the orphan trans ids or None if at least one
861
versioned file is present.
864
# Find the potential orphans, stop if one item should be kept
865
for child_tid in self.by_parent()[dir_id]:
866
if child_tid in self._removed_contents:
867
# The child is removed as part of the transform. Since it was
868
# versioned before, it's not an orphan
870
elif self.final_file_id(child_tid) is None:
871
# The child is not versioned
872
orphans.append(child_tid)
874
# We have a versioned file here, searching for orphans is
880
def _affected_ids(self):
881
"""Return the set of transform ids affected by the transform"""
882
trans_ids = set(self._removed_id)
883
trans_ids.update(self._new_id.keys())
884
trans_ids.update(self._removed_contents)
885
trans_ids.update(self._new_contents.keys())
886
trans_ids.update(self._new_executability.keys())
887
trans_ids.update(self._new_name.keys())
888
trans_ids.update(self._new_parent.keys())
891
def _get_file_id_maps(self):
892
"""Return mapping of file_ids to trans_ids in the to and from states"""
893
trans_ids = self._affected_ids()
896
# Build up two dicts: trans_ids associated with file ids in the
897
# FROM state, vs the TO state.
898
for trans_id in trans_ids:
899
from_file_id = self.tree_file_id(trans_id)
900
if from_file_id is not None:
901
from_trans_ids[from_file_id] = trans_id
902
to_file_id = self.final_file_id(trans_id)
903
if to_file_id is not None:
904
to_trans_ids[to_file_id] = trans_id
905
return from_trans_ids, to_trans_ids
907
def _from_file_data(self, from_trans_id, from_versioned, file_id):
908
"""Get data about a file in the from (tree) state
910
Return a (name, parent, kind, executable) tuple
912
from_path = self._tree_id_paths.get(from_trans_id)
914
# get data from working tree if versioned
915
from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
916
from_name = from_entry.name
917
from_parent = from_entry.parent_id
920
if from_path is None:
921
# File does not exist in FROM state
925
# File exists, but is not versioned. Have to use path-
927
from_name = os.path.basename(from_path)
928
tree_parent = self.get_tree_parent(from_trans_id)
929
from_parent = self.tree_file_id(tree_parent)
930
if from_path is not None:
931
from_kind, from_executable, from_stats = \
932
self._tree._comparison_data(from_entry, from_path)
935
from_executable = False
936
return from_name, from_parent, from_kind, from_executable
938
def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
939
"""Get data about a file in the to (target) state
941
Return a (name, parent, kind, executable) tuple
943
to_name = self.final_name(to_trans_id)
944
to_kind = self.final_kind(to_trans_id)
945
to_parent = self.final_file_id(self.final_parent(to_trans_id))
946
if to_trans_id in self._new_executability:
947
to_executable = self._new_executability[to_trans_id]
948
elif to_trans_id == from_trans_id:
949
to_executable = from_executable
951
to_executable = False
952
return to_name, to_parent, to_kind, to_executable
954
def iter_changes(self):
955
"""Produce output in the same format as Tree.iter_changes.
957
Will produce nonsensical results if invoked while inventory/filesystem
958
conflicts (as reported by TreeTransform.find_conflicts()) are present.
960
This reads the Transform, but only reproduces changes involving a
961
file_id. Files that are not versioned in either of the FROM or TO
962
states are not reflected.
964
final_paths = FinalPaths(self)
965
from_trans_ids, to_trans_ids = self._get_file_id_maps()
967
# Now iterate through all active file_ids
968
for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
970
from_trans_id = from_trans_ids.get(file_id)
971
# find file ids, and determine versioning state
972
if from_trans_id is None:
973
from_versioned = False
974
from_trans_id = to_trans_ids[file_id]
976
from_versioned = True
977
to_trans_id = to_trans_ids.get(file_id)
978
if to_trans_id is None:
980
to_trans_id = from_trans_id
984
from_name, from_parent, from_kind, from_executable = \
985
self._from_file_data(from_trans_id, from_versioned, file_id)
987
to_name, to_parent, to_kind, to_executable = \
988
self._to_file_data(to_trans_id, from_trans_id, from_executable)
990
if not from_versioned:
993
from_path = self._tree_id_paths.get(from_trans_id)
997
to_path = final_paths.get_path(to_trans_id)
998
if from_kind != to_kind:
1000
elif to_kind in ('file', 'symlink') and (
1001
to_trans_id != from_trans_id or
1002
to_trans_id in self._new_contents):
1004
if (not modified and from_versioned == to_versioned and
1005
from_parent==to_parent and from_name == to_name and
1006
from_executable == to_executable):
1008
results.append((file_id, (from_path, to_path), modified,
1009
(from_versioned, to_versioned),
1010
(from_parent, to_parent),
1011
(from_name, to_name),
1012
(from_kind, to_kind),
1013
(from_executable, to_executable)))
1014
return iter(sorted(results, key=lambda x:x[1]))
1016
def get_preview_tree(self):
1017
"""Return a tree representing the result of the transform.
1019
The tree is a snapshot, and altering the TreeTransform will invalidate
1022
return _PreviewTree(self)
1024
def commit(self, branch, message, merge_parents=None, strict=False,
1025
timestamp=None, timezone=None, committer=None, authors=None,
1026
revprops=None, revision_id=None):
1027
"""Commit the result of this TreeTransform to a branch.
1029
:param branch: The branch to commit to.
1030
:param message: The message to attach to the commit.
1031
:param merge_parents: Additional parent revision-ids specified by
1033
:param strict: If True, abort the commit if there are unversioned
1035
:param timestamp: if not None, seconds-since-epoch for the time and
1036
date. (May be a float.)
1037
:param timezone: Optional timezone for timestamp, as an offset in
1039
:param committer: Optional committer in email-id format.
1040
(e.g. "J Random Hacker <jrandom@example.com>")
1041
:param authors: Optional list of authors in email-id format.
1042
:param revprops: Optional dictionary of revision properties.
1043
:param revision_id: Optional revision id. (Specifying a revision-id
1044
may reduce performance for some non-native formats.)
1045
:return: The revision_id of the revision committed.
1047
self._check_malformed()
1049
unversioned = set(self._new_contents).difference(set(self._new_id))
1050
for trans_id in unversioned:
1051
if self.final_file_id(trans_id) is None:
1052
raise errors.StrictCommitFailed()
1054
revno, last_rev_id = branch.last_revision_info()
1055
if last_rev_id == _mod_revision.NULL_REVISION:
1056
if merge_parents is not None:
1057
raise ValueError('Cannot supply merge parents for first'
1061
parent_ids = [last_rev_id]
1062
if merge_parents is not None:
1063
parent_ids.extend(merge_parents)
1064
if self._tree.get_revision_id() != last_rev_id:
1065
raise ValueError('TreeTransform not based on branch basis: %s' %
1066
self._tree.get_revision_id())
1067
revprops = commit.Commit.update_revprops(revprops, branch, authors)
1068
builder = branch.get_commit_builder(parent_ids,
1069
timestamp=timestamp,
1071
committer=committer,
1073
revision_id=revision_id)
1074
preview = self.get_preview_tree()
1075
list(builder.record_iter_changes(preview, last_rev_id,
1076
self.iter_changes()))
1077
builder.finish_inventory()
1078
revision_id = builder.commit(message)
1079
branch.set_last_revision_info(revno + 1, revision_id)
1082
def _text_parent(self, trans_id):
1083
file_id = self.tree_file_id(trans_id)
1085
if file_id is None or self._tree.kind(file_id) != 'file':
1087
except errors.NoSuchFile:
1091
def _get_parents_texts(self, trans_id):
1092
"""Get texts for compression parents of this file."""
1093
file_id = self._text_parent(trans_id)
1096
return (self._tree.get_file_text(file_id),)
1098
def _get_parents_lines(self, trans_id):
1099
"""Get lines for compression parents of this file."""
1100
file_id = self._text_parent(trans_id)
1103
return (self._tree.get_file_lines(file_id),)
1105
def serialize(self, serializer):
1106
"""Serialize this TreeTransform.
1108
:param serializer: A Serialiser like pack.ContainerSerializer.
1110
new_name = dict((k, v.encode('utf-8')) for k, v in
1111
self._new_name.items())
1112
new_executability = dict((k, int(v)) for k, v in
1113
self._new_executability.items())
1114
tree_path_ids = dict((k.encode('utf-8'), v)
1115
for k, v in self._tree_path_ids.items())
1117
'_id_number': self._id_number,
1118
'_new_name': new_name,
1119
'_new_parent': self._new_parent,
1120
'_new_executability': new_executability,
1121
'_new_id': self._new_id,
1122
'_tree_path_ids': tree_path_ids,
1123
'_removed_id': list(self._removed_id),
1124
'_removed_contents': list(self._removed_contents),
1125
'_non_present_ids': self._non_present_ids,
1127
yield serializer.bytes_record(bencode.bencode(attribs),
1129
for trans_id, kind in self._new_contents.items():
1131
lines = osutils.chunks_to_lines(
1132
self._read_file_chunks(trans_id))
1133
parents = self._get_parents_lines(trans_id)
1134
mpdiff = multiparent.MultiParent.from_lines(lines, parents)
1135
content = ''.join(mpdiff.to_patch())
1136
if kind == 'directory':
1138
if kind == 'symlink':
1139
content = self._read_symlink_target(trans_id)
1140
yield serializer.bytes_record(content, ((trans_id, kind),))
1142
def deserialize(self, records):
1143
"""Deserialize a stored TreeTransform.
1145
:param records: An iterable of (names, content) tuples, as per
1146
pack.ContainerPushParser.
1148
names, content = records.next()
1149
attribs = bencode.bdecode(content)
1150
self._id_number = attribs['_id_number']
1151
self._new_name = dict((k, v.decode('utf-8'))
1152
for k, v in attribs['_new_name'].items())
1153
self._new_parent = attribs['_new_parent']
1154
self._new_executability = dict((k, bool(v)) for k, v in
1155
attribs['_new_executability'].items())
1156
self._new_id = attribs['_new_id']
1157
self._r_new_id = dict((v, k) for k, v in self._new_id.items())
1158
self._tree_path_ids = {}
1159
self._tree_id_paths = {}
1160
for bytepath, trans_id in attribs['_tree_path_ids'].items():
1161
path = bytepath.decode('utf-8')
1162
self._tree_path_ids[path] = trans_id
1163
self._tree_id_paths[trans_id] = path
1164
self._removed_id = set(attribs['_removed_id'])
1165
self._removed_contents = set(attribs['_removed_contents'])
1166
self._non_present_ids = attribs['_non_present_ids']
1167
for ((trans_id, kind),), content in records:
1169
mpdiff = multiparent.MultiParent.from_patch(content)
1170
lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
1171
self.create_file(lines, trans_id)
1172
if kind == 'directory':
1173
self.create_directory(trans_id)
1174
if kind == 'symlink':
1175
self.create_symlink(content.decode('utf-8'), trans_id)
1178
class DiskTreeTransform(TreeTransformBase):
1179
"""Tree transform storing its contents on disk."""
1181
def __init__(self, tree, limbodir, pb=None,
1182
case_sensitive=True):
1184
:param tree: The tree that will be transformed, but not necessarily
1186
:param limbodir: A directory where new files can be stored until
1187
they are installed in their proper places
1189
:param case_sensitive: If True, the target of the transform is
1190
case sensitive, not just case preserving.
1192
TreeTransformBase.__init__(self, tree, pb, case_sensitive)
1193
self._limbodir = limbodir
1194
self._deletiondir = None
1195
# A mapping of transform ids to their limbo filename
1196
self._limbo_files = {}
1197
self._possibly_stale_limbo_files = set()
1198
# A mapping of transform ids to a set of the transform ids of children
1199
# that their limbo directory has
1200
self._limbo_children = {}
1201
# Map transform ids to maps of child filename to child transform id
1202
self._limbo_children_names = {}
1203
# List of transform ids that need to be renamed from limbo into place
1204
self._needs_rename = set()
1205
self._creation_mtime = None
1208
"""Release the working tree lock, if held, clean up limbo dir.
1210
This is required if apply has not been invoked, but can be invoked
1213
if self._tree is None:
1216
limbo_paths = self._limbo_files.values() + list(
1217
self._possibly_stale_limbo_files)
1218
limbo_paths = sorted(limbo_paths, reverse=True)
1219
for path in limbo_paths:
1223
if e.errno != errno.ENOENT:
1225
# XXX: warn? perhaps we just got interrupted at an
1226
# inconvenient moment, but perhaps files are disappearing
1229
delete_any(self._limbodir)
1231
# We don't especially care *why* the dir is immortal.
1232
raise ImmortalLimbo(self._limbodir)
1234
if self._deletiondir is not None:
1235
delete_any(self._deletiondir)
1237
raise errors.ImmortalPendingDeletion(self._deletiondir)
1239
TreeTransformBase.finalize(self)
1241
def _limbo_name(self, trans_id):
1242
"""Generate the limbo name of a file"""
1243
limbo_name = self._limbo_files.get(trans_id)
1244
if limbo_name is None:
1245
limbo_name = self._generate_limbo_path(trans_id)
1246
self._limbo_files[trans_id] = limbo_name
1249
def _generate_limbo_path(self, trans_id):
1250
"""Generate a limbo path using the trans_id as the relative path.
1252
This is suitable as a fallback, and when the transform should not be
1253
sensitive to the path encoding of the limbo directory.
1255
self._needs_rename.add(trans_id)
1256
return pathjoin(self._limbodir, trans_id)
1258
def adjust_path(self, name, parent, trans_id):
1259
previous_parent = self._new_parent.get(trans_id)
1260
previous_name = self._new_name.get(trans_id)
1261
TreeTransformBase.adjust_path(self, name, parent, trans_id)
1262
if (trans_id in self._limbo_files and
1263
trans_id not in self._needs_rename):
1264
self._rename_in_limbo([trans_id])
1265
if previous_parent != parent:
1266
self._limbo_children[previous_parent].remove(trans_id)
1267
if previous_parent != parent or previous_name != name:
1268
del self._limbo_children_names[previous_parent][previous_name]
1270
def _rename_in_limbo(self, trans_ids):
1271
"""Fix limbo names so that the right final path is produced.
1273
This means we outsmarted ourselves-- we tried to avoid renaming
1274
these files later by creating them with their final names in their
1275
final parents. But now the previous name or parent is no longer
1276
suitable, so we have to rename them.
1278
Even for trans_ids that have no new contents, we must remove their
1279
entries from _limbo_files, because they are now stale.
1281
for trans_id in trans_ids:
1282
old_path = self._limbo_files[trans_id]
1283
self._possibly_stale_limbo_files.add(old_path)
1284
del self._limbo_files[trans_id]
1285
if trans_id not in self._new_contents:
1287
new_path = self._limbo_name(trans_id)
1288
os.rename(old_path, new_path)
1289
self._possibly_stale_limbo_files.remove(old_path)
1290
for descendant in self._limbo_descendants(trans_id):
1291
desc_path = self._limbo_files[descendant]
1292
desc_path = new_path + desc_path[len(old_path):]
1293
self._limbo_files[descendant] = desc_path
1295
def _limbo_descendants(self, trans_id):
1296
"""Return the set of trans_ids whose limbo paths descend from this."""
1297
descendants = set(self._limbo_children.get(trans_id, []))
1298
for descendant in list(descendants):
1299
descendants.update(self._limbo_descendants(descendant))
1302
def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1303
"""Schedule creation of a new file.
1307
:param contents: an iterator of strings, all of which will be written
1308
to the target destination.
1309
:param trans_id: TreeTransform handle
1310
:param mode_id: If not None, force the mode of the target file to match
1311
the mode of the object referenced by mode_id.
1312
Otherwise, we will try to preserve mode bits of an existing file.
1313
:param sha1: If the sha1 of this content is already known, pass it in.
1314
We can use it to prevent future sha1 computations.
1316
name = self._limbo_name(trans_id)
1317
f = open(name, 'wb')
1319
unique_add(self._new_contents, trans_id, 'file')
1320
f.writelines(contents)
1323
self._set_mtime(name)
1324
self._set_mode(trans_id, mode_id, S_ISREG)
1325
# It is unfortunate we have to use lstat instead of fstat, but we just
1326
# used utime and chmod on the file, so we need the accurate final
1328
if sha1 is not None:
1329
self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1331
def _read_file_chunks(self, trans_id):
1332
cur_file = open(self._limbo_name(trans_id), 'rb')
1334
return cur_file.readlines()
1338
def _read_symlink_target(self, trans_id):
1339
return os.readlink(self._limbo_name(trans_id))
1341
def _set_mtime(self, path):
1342
"""All files that are created get the same mtime.
1344
This time is set by the first object to be created.
1346
if self._creation_mtime is None:
1347
self._creation_mtime = time.time()
1348
os.utime(path, (self._creation_mtime, self._creation_mtime))
1350
def create_hardlink(self, path, trans_id):
1351
"""Schedule creation of a hard link"""
1352
name = self._limbo_name(trans_id)
1356
if e.errno != errno.EPERM:
1358
raise errors.HardLinkNotSupported(path)
1360
unique_add(self._new_contents, trans_id, 'file')
1362
# Clean up the file, it never got registered so
1363
# TreeTransform.finalize() won't clean it up.
1367
def create_directory(self, trans_id):
1368
"""Schedule creation of a new directory.
1370
See also new_directory.
1372
os.mkdir(self._limbo_name(trans_id))
1373
unique_add(self._new_contents, trans_id, 'directory')
1375
def create_symlink(self, target, trans_id):
1376
"""Schedule creation of a new symbolic link.
1378
target is a bytestring.
1379
See also new_symlink.
1382
os.symlink(target, self._limbo_name(trans_id))
1383
unique_add(self._new_contents, trans_id, 'symlink')
1386
path = FinalPaths(self).get_path(trans_id)
1389
raise UnableCreateSymlink(path=path)
1391
def cancel_creation(self, trans_id):
1392
"""Cancel the creation of new file contents."""
1393
del self._new_contents[trans_id]
1394
if trans_id in self._observed_sha1s:
1395
del self._observed_sha1s[trans_id]
1396
children = self._limbo_children.get(trans_id)
1397
# if this is a limbo directory with children, move them before removing
1399
if children is not None:
1400
self._rename_in_limbo(children)
1401
del self._limbo_children[trans_id]
1402
del self._limbo_children_names[trans_id]
1403
delete_any(self._limbo_name(trans_id))
1405
def new_orphan(self, trans_id, parent_id):
1406
# FIXME: There is no tree config, so we use the branch one (it's weird
1407
# to define it this way as orphaning can only occur in a working tree,
1408
# but that's all we have (for now). It will find the option in
1409
# locations.conf or bazaar.conf though) -- vila 20100916
1410
conf = self._tree.branch.get_config()
1411
conf_var_name = 'bzr.transform.orphan_policy'
1412
orphan_policy = conf.get_user_option(conf_var_name)
1413
default_policy = orphaning_registry.default_key
1414
if orphan_policy is None:
1415
orphan_policy = default_policy
1416
if orphan_policy not in orphaning_registry:
1417
trace.warning('%s (from %s) is not a known policy, defaulting '
1418
'to %s' % (orphan_policy, conf_var_name, default_policy))
1419
orphan_policy = default_policy
1420
handle_orphan = orphaning_registry.get(orphan_policy)
1421
handle_orphan(self, trans_id, parent_id)
1424
class OrphaningError(errors.BzrError):
1426
# Only bugs could lead to such exception being seen by the user
1427
internal_error = True
1428
_fmt = "Error while orphaning %s in %s directory"
1430
def __init__(self, orphan, parent):
1431
errors.BzrError.__init__(self)
1432
self.orphan = orphan
1433
self.parent = parent
1436
class OrphaningForbidden(OrphaningError):
1438
_fmt = "Policy: %s doesn't allow creating orphans."
1440
def __init__(self, policy):
1441
errors.BzrError.__init__(self)
1442
self.policy = policy
1445
def move_orphan(tt, orphan_id, parent_id):
1446
"""See TreeTransformBase.new_orphan.
1448
This creates a new orphan in the `bzr-orphans` dir at the root of the
1451
:param tt: The TreeTransform orphaning `trans_id`.
1453
:param orphan_id: The trans id that should be orphaned.
1455
:param parent_id: The orphan parent trans id.
1457
# Add the orphan dir if it doesn't exist
1458
orphan_dir_basename = 'bzr-orphans'
1459
od_id = tt.trans_id_tree_path(orphan_dir_basename)
1460
if tt.final_kind(od_id) is None:
1461
tt.create_directory(od_id)
1462
parent_path = tt._tree_id_paths[parent_id]
1463
# Find a name that doesn't exist yet in the orphan dir
1464
actual_name = tt.final_name(orphan_id)
1465
new_name = tt._available_backup_name(actual_name, od_id)
1466
tt.adjust_path(new_name, od_id, orphan_id)
1467
trace.warning('%s has been orphaned in %s'
1468
% (joinpath(parent_path, actual_name), orphan_dir_basename))
1471
def refuse_orphan(tt, orphan_id, parent_id):
1472
"""See TreeTransformBase.new_orphan.
1474
This refuses to create orphan, letting the caller handle the conflict.
1476
raise OrphaningForbidden('never')
1479
orphaning_registry = registry.Registry()
1480
orphaning_registry.register(
1481
'conflict', refuse_orphan,
1482
'Leave orphans in place and create a conflict on the directory.')
1483
orphaning_registry.register(
1484
'move', move_orphan,
1485
'Move orphans into the bzr-orphans directory.')
1486
orphaning_registry._set_default_key('conflict')
1489
class TreeTransform(DiskTreeTransform):
1490
"""Represent a tree transformation.
1492
This object is designed to support incremental generation of the transform,
1495
However, it gives optimum performance when parent directories are created
1496
before their contents. The transform is then able to put child files
1497
directly in their parent directory, avoiding later renames.
1499
It is easy to produce malformed transforms, but they are generally
1500
harmless. Attempting to apply a malformed transform will cause an
1501
exception to be raised before any modifications are made to the tree.
1503
Many kinds of malformed transforms can be corrected with the
1504
resolve_conflicts function. The remaining ones indicate programming error,
1505
such as trying to create a file with no path.
1507
Two sets of file creation methods are supplied. Convenience methods are:
1512
These are composed of the low-level methods:
1514
* create_file or create_directory or create_symlink
1518
Transform/Transaction ids
1519
-------------------------
1520
trans_ids are temporary ids assigned to all files involved in a transform.
1521
It's possible, even common, that not all files in the Tree have trans_ids.
1523
trans_ids are used because filenames and file_ids are not good enough
1524
identifiers; filenames change, and not all files have file_ids. File-ids
1525
are also associated with trans-ids, so that moving a file moves its
1528
trans_ids are only valid for the TreeTransform that generated them.
1532
Limbo is a temporary directory use to hold new versions of files.
1533
Files are added to limbo by create_file, create_directory, create_symlink,
1534
and their convenience variants (new_*). Files may be removed from limbo
1535
using cancel_creation. Files are renamed from limbo into their final
1536
location as part of TreeTransform.apply
1538
Limbo must be cleaned up, by either calling TreeTransform.apply or
1539
calling TreeTransform.finalize.
1541
Files are placed into limbo inside their parent directories, where
1542
possible. This reduces subsequent renames, and makes operations involving
1543
lots of files faster. This optimization is only possible if the parent
1544
directory is created *before* creating any of its children, so avoid
1545
creating children before parents, where possible.
1549
This temporary directory is used by _FileMover for storing files that are
1550
about to be deleted. In case of rollback, the files will be restored.
1551
FileMover does not delete files until it is sure that a rollback will not
1554
def __init__(self, tree, pb=None):
1555
"""Note: a tree_write lock is taken on the tree.
1557
Use TreeTransform.finalize() to release the lock (can be omitted if
1558
TreeTransform.apply() called).
1560
tree.lock_tree_write()
1563
limbodir = urlutils.local_path_from_url(
1564
tree._transport.abspath('limbo'))
1568
if e.errno == errno.EEXIST:
1569
raise ExistingLimbo(limbodir)
1570
deletiondir = urlutils.local_path_from_url(
1571
tree._transport.abspath('pending-deletion'))
1573
os.mkdir(deletiondir)
1575
if e.errno == errno.EEXIST:
1576
raise errors.ExistingPendingDeletion(deletiondir)
1581
# Cache of realpath results, to speed up canonical_path
1582
self._realpaths = {}
1583
# Cache of relpath results, to speed up canonical_path
1585
DiskTreeTransform.__init__(self, tree, limbodir, pb,
1586
tree.case_sensitive)
1587
self._deletiondir = deletiondir
1589
def canonical_path(self, path):
1590
"""Get the canonical tree-relative path"""
1591
# don't follow final symlinks
1592
abs = self._tree.abspath(path)
1593
if abs in self._relpaths:
1594
return self._relpaths[abs]
1595
dirname, basename = os.path.split(abs)
1596
if dirname not in self._realpaths:
1597
self._realpaths[dirname] = os.path.realpath(dirname)
1598
dirname = self._realpaths[dirname]
1599
abs = pathjoin(dirname, basename)
1600
if dirname in self._relpaths:
1601
relpath = pathjoin(self._relpaths[dirname], basename)
1602
relpath = relpath.rstrip('/\\')
1604
relpath = self._tree.relpath(abs)
1605
self._relpaths[abs] = relpath
1608
def tree_kind(self, trans_id):
1609
"""Determine the file kind in the working tree.
1611
:returns: The file kind or None if the file does not exist
1613
path = self._tree_id_paths.get(trans_id)
1617
return file_kind(self._tree.abspath(path))
1618
except errors.NoSuchFile:
1621
def _set_mode(self, trans_id, mode_id, typefunc):
1622
"""Set the mode of new file contents.
1623
The mode_id is the existing file to get the mode from (often the same
1624
as trans_id). The operation is only performed if there's a mode match
1625
according to typefunc.
1630
old_path = self._tree_id_paths[mode_id]
1634
mode = os.stat(self._tree.abspath(old_path)).st_mode
1636
if e.errno in (errno.ENOENT, errno.ENOTDIR):
1637
# Either old_path doesn't exist, or the parent of the
1638
# target is not a directory (but will be one eventually)
1639
# Either way, we know it doesn't exist *right now*
1640
# See also bug #248448
1645
os.chmod(self._limbo_name(trans_id), mode)
1647
def iter_tree_children(self, parent_id):
1648
"""Iterate through the entry's tree children, if any"""
1650
path = self._tree_id_paths[parent_id]
1654
children = os.listdir(self._tree.abspath(path))
1656
if not (osutils._is_error_enotdir(e)
1657
or e.errno in (errno.ENOENT, errno.ESRCH)):
1661
for child in children:
1662
childpath = joinpath(path, child)
1663
if self._tree.is_control_filename(childpath):
1665
yield self.trans_id_tree_path(childpath)
1667
def _generate_limbo_path(self, trans_id):
1668
"""Generate a limbo path using the final path if possible.
1670
This optimizes the performance of applying the tree transform by
1671
avoiding renames. These renames can be avoided only when the parent
1672
directory is already scheduled for creation.
1674
If the final path cannot be used, falls back to using the trans_id as
1677
parent = self._new_parent.get(trans_id)
1678
# if the parent directory is already in limbo (e.g. when building a
1679
# tree), choose a limbo name inside the parent, to reduce further
1681
use_direct_path = False
1682
if self._new_contents.get(parent) == 'directory':
1683
filename = self._new_name.get(trans_id)
1684
if filename is not None:
1685
if parent not in self._limbo_children:
1686
self._limbo_children[parent] = set()
1687
self._limbo_children_names[parent] = {}
1688
use_direct_path = True
1689
# the direct path can only be used if no other file has
1690
# already taken this pathname, i.e. if the name is unused, or
1691
# if it is already associated with this trans_id.
1692
elif self._case_sensitive_target:
1693
if (self._limbo_children_names[parent].get(filename)
1694
in (trans_id, None)):
1695
use_direct_path = True
1697
for l_filename, l_trans_id in\
1698
self._limbo_children_names[parent].iteritems():
1699
if l_trans_id == trans_id:
1701
if l_filename.lower() == filename.lower():
1704
use_direct_path = True
1706
if not use_direct_path:
1707
return DiskTreeTransform._generate_limbo_path(self, trans_id)
1709
limbo_name = pathjoin(self._limbo_files[parent], filename)
1710
self._limbo_children[parent].add(trans_id)
1711
self._limbo_children_names[parent][filename] = trans_id
1715
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1716
"""Apply all changes to the inventory and filesystem.
1718
If filesystem or inventory conflicts are present, MalformedTransform
1721
If apply succeeds, finalize is not necessary.
1723
:param no_conflicts: if True, the caller guarantees there are no
1724
conflicts, so no check is made.
1725
:param precomputed_delta: An inventory delta to use instead of
1727
:param _mover: Supply an alternate FileMover, for testing
1729
if not no_conflicts:
1730
self._check_malformed()
1731
child_pb = ui.ui_factory.nested_progress_bar()
1733
if precomputed_delta is None:
1734
child_pb.update('Apply phase', 0, 2)
1735
inventory_delta = self._generate_inventory_delta()
1738
inventory_delta = precomputed_delta
1741
mover = _FileMover()
1745
child_pb.update('Apply phase', 0 + offset, 2 + offset)
1746
self._apply_removals(mover)
1747
child_pb.update('Apply phase', 1 + offset, 2 + offset)
1748
modified_paths = self._apply_insertions(mover)
1753
mover.apply_deletions()
1756
self._tree.apply_inventory_delta(inventory_delta)
1757
self._apply_observed_sha1s()
1760
return _TransformResults(modified_paths, self.rename_count)
1762
def _generate_inventory_delta(self):
1763
"""Generate an inventory delta for the current transform."""
1764
inventory_delta = []
1765
child_pb = ui.ui_factory.nested_progress_bar()
1766
new_paths = self._inventory_altered()
1767
total_entries = len(new_paths) + len(self._removed_id)
1769
for num, trans_id in enumerate(self._removed_id):
1771
child_pb.update('removing file', num, total_entries)
1772
if trans_id == self._new_root:
1773
file_id = self._tree.get_root_id()
1775
file_id = self.tree_file_id(trans_id)
1776
# File-id isn't really being deleted, just moved
1777
if file_id in self._r_new_id:
1779
path = self._tree_id_paths[trans_id]
1780
inventory_delta.append((path, None, file_id, None))
1781
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1783
entries = self._tree.iter_entries_by_dir(
1784
new_path_file_ids.values())
1785
old_paths = dict((e.file_id, p) for p, e in entries)
1787
for num, (path, trans_id) in enumerate(new_paths):
1789
child_pb.update('adding file',
1790
num + len(self._removed_id), total_entries)
1791
file_id = new_path_file_ids[trans_id]
1795
kind = self.final_kind(trans_id)
1797
kind = self._tree.stored_kind(file_id)
1798
parent_trans_id = self.final_parent(trans_id)
1799
parent_file_id = new_path_file_ids.get(parent_trans_id)
1800
if parent_file_id is None:
1801
parent_file_id = self.final_file_id(parent_trans_id)
1802
if trans_id in self._new_reference_revision:
1803
new_entry = inventory.TreeReference(
1805
self._new_name[trans_id],
1806
self.final_file_id(self._new_parent[trans_id]),
1807
None, self._new_reference_revision[trans_id])
1809
new_entry = inventory.make_entry(kind,
1810
self.final_name(trans_id),
1811
parent_file_id, file_id)
1812
old_path = old_paths.get(new_entry.file_id)
1813
new_executability = self._new_executability.get(trans_id)
1814
if new_executability is not None:
1815
new_entry.executable = new_executability
1816
inventory_delta.append(
1817
(old_path, path, new_entry.file_id, new_entry))
1820
return inventory_delta
1822
def _apply_removals(self, mover):
1823
"""Perform tree operations that remove directory/inventory names.
1825
That is, delete files that are to be deleted, and put any files that
1826
need renaming into limbo. This must be done in strict child-to-parent
1829
If inventory_delta is None, no inventory delta generation is performed.
1831
tree_paths = list(self._tree_path_ids.iteritems())
1832
tree_paths.sort(reverse=True)
1833
child_pb = ui.ui_factory.nested_progress_bar()
1835
for num, (path, trans_id) in enumerate(tree_paths):
1836
# do not attempt to move root into a subdirectory of itself.
1839
child_pb.update('removing file', num, len(tree_paths))
1840
full_path = self._tree.abspath(path)
1841
if trans_id in self._removed_contents:
1842
delete_path = os.path.join(self._deletiondir, trans_id)
1843
mover.pre_delete(full_path, delete_path)
1844
elif (trans_id in self._new_name
1845
or trans_id in self._new_parent):
1847
mover.rename(full_path, self._limbo_name(trans_id))
1848
except errors.TransformRenameFailed, e:
1849
if e.errno != errno.ENOENT:
1852
self.rename_count += 1
1856
def _apply_insertions(self, mover):
1857
"""Perform tree operations that insert directory/inventory names.
1859
That is, create any files that need to be created, and restore from
1860
limbo any files that needed renaming. This must be done in strict
1861
parent-to-child order.
1863
If inventory_delta is None, no inventory delta is calculated, and
1864
no list of modified paths is returned.
1866
new_paths = self.new_paths(filesystem_only=True)
1868
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1870
child_pb = ui.ui_factory.nested_progress_bar()
1872
for num, (path, trans_id) in enumerate(new_paths):
1874
child_pb.update('adding file', num, len(new_paths))
1875
full_path = self._tree.abspath(path)
1876
if trans_id in self._needs_rename:
1878
mover.rename(self._limbo_name(trans_id), full_path)
1879
except errors.TransformRenameFailed, e:
1880
# We may be renaming a dangling inventory id
1881
if e.errno != errno.ENOENT:
1884
self.rename_count += 1
1885
# TODO: if trans_id in self._observed_sha1s, we should
1886
# re-stat the final target, since ctime will be
1887
# updated by the change.
1888
if (trans_id in self._new_contents or
1889
self.path_changed(trans_id)):
1890
if trans_id in self._new_contents:
1891
modified_paths.append(full_path)
1892
if trans_id in self._new_executability:
1893
self._set_executability(path, trans_id)
1894
if trans_id in self._observed_sha1s:
1895
o_sha1, o_st_val = self._observed_sha1s[trans_id]
1896
st = osutils.lstat(full_path)
1897
self._observed_sha1s[trans_id] = (o_sha1, st)
1900
for path, trans_id in new_paths:
1901
# new_paths includes stuff like workingtree conflicts. Only the
1902
# stuff in new_contents actually comes from limbo.
1903
if trans_id in self._limbo_files:
1904
del self._limbo_files[trans_id]
1905
self._new_contents.clear()
1906
return modified_paths
1908
def _apply_observed_sha1s(self):
1909
"""After we have finished renaming everything, update observed sha1s
1911
This has to be done after self._tree.apply_inventory_delta, otherwise
1912
it doesn't know anything about the files we are updating. Also, we want
1913
to do this as late as possible, so that most entries end up cached.
1915
# TODO: this doesn't update the stat information for directories. So
1916
# the first 'bzr status' will still need to rewrite
1917
# .bzr/checkout/dirstate. However, we at least don't need to
1918
# re-read all of the files.
1919
# TODO: If the operation took a while, we could do a time.sleep(3) here
1920
# to allow the clock to tick over and ensure we won't have any
1921
# problems. (we could observe start time, and finish time, and if
1922
# it is less than eg 10% overhead, add a sleep call.)
1923
paths = FinalPaths(self)
1924
for trans_id, observed in self._observed_sha1s.iteritems():
1925
path = paths.get_path(trans_id)
1926
# We could get the file_id, but dirstate prefers to use the path
1927
# anyway, and it is 'cheaper' to determine.
1928
# file_id = self._new_id[trans_id]
1929
self._tree._observed_sha1(None, path, observed)
1932
class TransformPreview(DiskTreeTransform):
1933
"""A TreeTransform for generating preview trees.
1935
Unlike TreeTransform, this version works when the input tree is a
1936
RevisionTree, rather than a WorkingTree. As a result, it tends to ignore
1937
unversioned files in the input tree.
1940
def __init__(self, tree, pb=None, case_sensitive=True):
1942
limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1943
DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1945
def canonical_path(self, path):
1948
def tree_kind(self, trans_id):
1949
path = self._tree_id_paths.get(trans_id)
1952
kind = self._tree.path_content_summary(path)[0]
1953
if kind == 'missing':
1957
def _set_mode(self, trans_id, mode_id, typefunc):
1958
"""Set the mode of new file contents.
1959
The mode_id is the existing file to get the mode from (often the same
1960
as trans_id). The operation is only performed if there's a mode match
1961
according to typefunc.
1963
# is it ok to ignore this? probably
1966
def iter_tree_children(self, parent_id):
1967
"""Iterate through the entry's tree children, if any"""
1969
path = self._tree_id_paths[parent_id]
1972
file_id = self.tree_file_id(parent_id)
1975
entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1976
children = getattr(entry, 'children', {})
1977
for child in children:
1978
childpath = joinpath(path, child)
1979
yield self.trans_id_tree_path(childpath)
1981
def new_orphan(self, trans_id, parent_id):
1982
raise NotImplementedError(self.new_orphan)
1985
class _PreviewTree(tree.InventoryTree):
1986
"""Partial implementation of Tree to support show_diff_trees"""
1988
def __init__(self, transform):
1989
self._transform = transform
1990
self._final_paths = FinalPaths(transform)
1991
self.__by_parent = None
1992
self._parent_ids = []
1993
self._all_children_cache = {}
1994
self._path2trans_id_cache = {}
1995
self._final_name_cache = {}
1996
self._iter_changes_cache = dict((c[0], c) for c in
1997
self._transform.iter_changes())
1999
def _content_change(self, file_id):
2000
"""Return True if the content of this file changed"""
2001
changes = self._iter_changes_cache.get(file_id)
2002
# changes[2] is true if the file content changed. See
2003
# InterTree.iter_changes.
2004
return (changes is not None and changes[2])
2006
def _get_repository(self):
2007
repo = getattr(self._transform._tree, '_repository', None)
2009
repo = self._transform._tree.branch.repository
2012
def _iter_parent_trees(self):
2013
for revision_id in self.get_parent_ids():
2015
yield self.revision_tree(revision_id)
2016
except errors.NoSuchRevisionInTree:
2017
yield self._get_repository().revision_tree(revision_id)
2019
def _get_file_revision(self, file_id, vf, tree_revision):
2020
parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
2021
self._iter_parent_trees()]
2022
vf.add_lines((file_id, tree_revision), parent_keys,
2023
self.get_file_lines(file_id))
2024
repo = self._get_repository()
2025
base_vf = repo.texts
2026
if base_vf not in vf.fallback_versionedfiles:
2027
vf.fallback_versionedfiles.append(base_vf)
2028
return tree_revision
2030
def _stat_limbo_file(self, file_id=None, trans_id=None):
2031
if trans_id is None:
2032
trans_id = self._transform.trans_id_file_id(file_id)
2033
name = self._transform._limbo_name(trans_id)
2034
return os.lstat(name)
2037
def _by_parent(self):
2038
if self.__by_parent is None:
2039
self.__by_parent = self._transform.by_parent()
2040
return self.__by_parent
2042
def _comparison_data(self, entry, path):
2043
kind, size, executable, link_or_sha1 = self.path_content_summary(path)
2044
if kind == 'missing':
2048
file_id = self._transform.final_file_id(self._path2trans_id(path))
2049
executable = self.is_executable(file_id, path)
2050
return kind, executable, None
2052
def is_locked(self):
2055
def lock_read(self):
2056
# Perhaps in theory, this should lock the TreeTransform?
2063
def inventory(self):
2064
"""This Tree does not use inventory as its backing data."""
2065
raise NotImplementedError(_PreviewTree.inventory)
2067
def get_root_id(self):
2068
return self._transform.final_file_id(self._transform.root)
2070
def all_file_ids(self):
2071
tree_ids = set(self._transform._tree.all_file_ids())
2072
tree_ids.difference_update(self._transform.tree_file_id(t)
2073
for t in self._transform._removed_id)
2074
tree_ids.update(self._transform._new_id.values())
2078
return iter(self.all_file_ids())
2080
def _has_id(self, file_id, fallback_check):
2081
if file_id in self._transform._r_new_id:
2083
elif file_id in set([self._transform.tree_file_id(trans_id) for
2084
trans_id in self._transform._removed_id]):
2087
return fallback_check(file_id)
2089
def has_id(self, file_id):
2090
return self._has_id(file_id, self._transform._tree.has_id)
2092
def has_or_had_id(self, file_id):
2093
return self._has_id(file_id, self._transform._tree.has_or_had_id)
2095
def _path2trans_id(self, path):
2096
# We must not use None here, because that is a valid value to store.
2097
trans_id = self._path2trans_id_cache.get(path, object)
2098
if trans_id is not object:
2100
segments = splitpath(path)
2101
cur_parent = self._transform.root
2102
for cur_segment in segments:
2103
for child in self._all_children(cur_parent):
2104
final_name = self._final_name_cache.get(child)
2105
if final_name is None:
2106
final_name = self._transform.final_name(child)
2107
self._final_name_cache[child] = final_name
2108
if final_name == cur_segment:
2112
self._path2trans_id_cache[path] = None
2114
self._path2trans_id_cache[path] = cur_parent
2117
def path2id(self, path):
2118
return self._transform.final_file_id(self._path2trans_id(path))
2120
def id2path(self, file_id):
2121
trans_id = self._transform.trans_id_file_id(file_id)
2123
return self._final_paths._determine_path(trans_id)
2125
raise errors.NoSuchId(self, file_id)
2127
def _all_children(self, trans_id):
2128
children = self._all_children_cache.get(trans_id)
2129
if children is not None:
2131
children = set(self._transform.iter_tree_children(trans_id))
2132
# children in the _new_parent set are provided by _by_parent.
2133
children.difference_update(self._transform._new_parent.keys())
2134
children.update(self._by_parent.get(trans_id, []))
2135
self._all_children_cache[trans_id] = children
2138
def iter_children(self, file_id):
2139
trans_id = self._transform.trans_id_file_id(file_id)
2140
for child_trans_id in self._all_children(trans_id):
2141
yield self._transform.final_file_id(child_trans_id)
2144
possible_extras = set(self._transform.trans_id_tree_path(p) for p
2145
in self._transform._tree.extras())
2146
possible_extras.update(self._transform._new_contents)
2147
possible_extras.update(self._transform._removed_id)
2148
for trans_id in possible_extras:
2149
if self._transform.final_file_id(trans_id) is None:
2150
yield self._final_paths._determine_path(trans_id)
2152
def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
2153
yield_parents=False):
2154
for trans_id, parent_file_id in ordered_entries:
2155
file_id = self._transform.final_file_id(trans_id)
2158
if (specific_file_ids is not None
2159
and file_id not in specific_file_ids):
2161
kind = self._transform.final_kind(trans_id)
2163
kind = self._transform._tree.stored_kind(file_id)
2164
new_entry = inventory.make_entry(
2166
self._transform.final_name(trans_id),
2167
parent_file_id, file_id)
2168
yield new_entry, trans_id
2170
def _list_files_by_dir(self):
2171
todo = [ROOT_PARENT]
2173
while len(todo) > 0:
2175
parent_file_id = self._transform.final_file_id(parent)
2176
children = list(self._all_children(parent))
2177
paths = dict(zip(children, self._final_paths.get_paths(children)))
2178
children.sort(key=paths.get)
2179
todo.extend(reversed(children))
2180
for trans_id in children:
2181
ordered_ids.append((trans_id, parent_file_id))
2184
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
2185
# This may not be a maximally efficient implementation, but it is
2186
# reasonably straightforward. An implementation that grafts the
2187
# TreeTransform changes onto the tree's iter_entries_by_dir results
2188
# might be more efficient, but requires tricky inferences about stack
2190
ordered_ids = self._list_files_by_dir()
2191
for entry, trans_id in self._make_inv_entries(ordered_ids,
2192
specific_file_ids, yield_parents=yield_parents):
2193
yield unicode(self._final_paths.get_path(trans_id)), entry
2195
def _iter_entries_for_dir(self, dir_path):
2196
"""Return path, entry for items in a directory without recursing down."""
2197
dir_file_id = self.path2id(dir_path)
2199
for file_id in self.iter_children(dir_file_id):
2200
trans_id = self._transform.trans_id_file_id(file_id)
2201
ordered_ids.append((trans_id, file_id))
2202
for entry, trans_id in self._make_inv_entries(ordered_ids):
2203
yield unicode(self._final_paths.get_path(trans_id)), entry
2205
def list_files(self, include_root=False, from_dir=None, recursive=True):
2206
"""See WorkingTree.list_files."""
2207
# XXX This should behave like WorkingTree.list_files, but is really
2208
# more like RevisionTree.list_files.
2212
prefix = from_dir + '/'
2213
entries = self.iter_entries_by_dir()
2214
for path, entry in entries:
2215
if entry.name == '' and not include_root:
2218
if not path.startswith(prefix):
2220
path = path[len(prefix):]
2221
yield path, 'V', entry.kind, entry.file_id, entry
2223
if from_dir is None and include_root is True:
2224
root_entry = inventory.make_entry('directory', '',
2225
ROOT_PARENT, self.get_root_id())
2226
yield '', 'V', 'directory', root_entry.file_id, root_entry
2227
entries = self._iter_entries_for_dir(from_dir or '')
2228
for path, entry in entries:
2229
yield path, 'V', entry.kind, entry.file_id, entry
2231
def kind(self, file_id):
2232
trans_id = self._transform.trans_id_file_id(file_id)
2233
return self._transform.final_kind(trans_id)
2235
def stored_kind(self, file_id):
2236
trans_id = self._transform.trans_id_file_id(file_id)
2238
return self._transform._new_contents[trans_id]
2240
return self._transform._tree.stored_kind(file_id)
2242
def get_file_mtime(self, file_id, path=None):
2243
"""See Tree.get_file_mtime"""
2244
if not self._content_change(file_id):
2245
return self._transform._tree.get_file_mtime(file_id)
2246
return self._stat_limbo_file(file_id).st_mtime
2248
def _file_size(self, entry, stat_value):
2249
return self.get_file_size(entry.file_id)
2251
def get_file_size(self, file_id):
2252
"""See Tree.get_file_size"""
2253
trans_id = self._transform.trans_id_file_id(file_id)
2254
kind = self._transform.final_kind(trans_id)
2257
if trans_id in self._transform._new_contents:
2258
return self._stat_limbo_file(trans_id=trans_id).st_size
2259
if self.kind(file_id) == 'file':
2260
return self._transform._tree.get_file_size(file_id)
2264
def get_file_sha1(self, file_id, path=None, stat_value=None):
2265
trans_id = self._transform.trans_id_file_id(file_id)
2266
kind = self._transform._new_contents.get(trans_id)
2268
return self._transform._tree.get_file_sha1(file_id)
2270
fileobj = self.get_file(file_id)
2272
return sha_file(fileobj)
2276
def is_executable(self, file_id, path=None):
2279
trans_id = self._transform.trans_id_file_id(file_id)
2281
return self._transform._new_executability[trans_id]
2284
return self._transform._tree.is_executable(file_id, path)
2286
if e.errno == errno.ENOENT:
2289
except errors.NoSuchId:
2292
def has_filename(self, path):
2293
trans_id = self._path2trans_id(path)
2294
if trans_id in self._transform._new_contents:
2296
elif trans_id in self._transform._removed_contents:
2299
return self._transform._tree.has_filename(path)
2301
def path_content_summary(self, path):
2302
trans_id = self._path2trans_id(path)
2303
tt = self._transform
2304
tree_path = tt._tree_id_paths.get(trans_id)
2305
kind = tt._new_contents.get(trans_id)
2307
if tree_path is None or trans_id in tt._removed_contents:
2308
return 'missing', None, None, None
2309
summary = tt._tree.path_content_summary(tree_path)
2310
kind, size, executable, link_or_sha1 = summary
2313
limbo_name = tt._limbo_name(trans_id)
2314
if trans_id in tt._new_reference_revision:
2315
kind = 'tree-reference'
2317
statval = os.lstat(limbo_name)
2318
size = statval.st_size
2319
if not supports_executable():
2322
executable = statval.st_mode & S_IEXEC
2326
if kind == 'symlink':
2327
link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2328
executable = tt._new_executability.get(trans_id, executable)
2329
return kind, size, executable, link_or_sha1
2331
def iter_changes(self, from_tree, include_unchanged=False,
2332
specific_files=None, pb=None, extra_trees=None,
2333
require_versioned=True, want_unversioned=False):
2334
"""See InterTree.iter_changes.
2336
This has a fast path that is only used when the from_tree matches
2337
the transform tree, and no fancy options are supplied.
2339
if (from_tree is not self._transform._tree or include_unchanged or
2340
specific_files or want_unversioned):
2341
return tree.InterTree(from_tree, self).iter_changes(
2342
include_unchanged=include_unchanged,
2343
specific_files=specific_files,
2345
extra_trees=extra_trees,
2346
require_versioned=require_versioned,
2347
want_unversioned=want_unversioned)
2348
if want_unversioned:
2349
raise ValueError('want_unversioned is not supported')
2350
return self._transform.iter_changes()
2352
def get_file(self, file_id, path=None):
2353
"""See Tree.get_file"""
2354
if not self._content_change(file_id):
2355
return self._transform._tree.get_file(file_id, path)
2356
trans_id = self._transform.trans_id_file_id(file_id)
2357
name = self._transform._limbo_name(trans_id)
2358
return open(name, 'rb')
2360
def get_file_with_stat(self, file_id, path=None):
2361
return self.get_file(file_id, path), None
2363
def annotate_iter(self, file_id,
2364
default_revision=_mod_revision.CURRENT_REVISION):
2365
changes = self._iter_changes_cache.get(file_id)
2369
changed_content, versioned, kind = (changes[2], changes[3],
2373
get_old = (kind[0] == 'file' and versioned[0])
2375
old_annotation = self._transform._tree.annotate_iter(file_id,
2376
default_revision=default_revision)
2380
return old_annotation
2381
if not changed_content:
2382
return old_annotation
2383
# TODO: This is doing something similar to what WT.annotate_iter is
2384
# doing, however it fails slightly because it doesn't know what
2385
# the *other* revision_id is, so it doesn't know how to give the
2386
# other as the origin for some lines, they all get
2387
# 'default_revision'
2388
# It would be nice to be able to use the new Annotator based
2389
# approach, as well.
2390
return annotate.reannotate([old_annotation],
2391
self.get_file(file_id).readlines(),
2394
def get_symlink_target(self, file_id, path=None):
2395
"""See Tree.get_symlink_target"""
2396
if not self._content_change(file_id):
2397
return self._transform._tree.get_symlink_target(file_id)
2398
trans_id = self._transform.trans_id_file_id(file_id)
2399
name = self._transform._limbo_name(trans_id)
2400
return osutils.readlink(name)
2402
def walkdirs(self, prefix=''):
2403
pending = [self._transform.root]
2404
while len(pending) > 0:
2405
parent_id = pending.pop()
2408
prefix = prefix.rstrip('/')
2409
parent_path = self._final_paths.get_path(parent_id)
2410
parent_file_id = self._transform.final_file_id(parent_id)
2411
for child_id in self._all_children(parent_id):
2412
path_from_root = self._final_paths.get_path(child_id)
2413
basename = self._transform.final_name(child_id)
2414
file_id = self._transform.final_file_id(child_id)
2415
kind = self._transform.final_kind(child_id)
2416
if kind is not None:
2417
versioned_kind = kind
2420
versioned_kind = self._transform._tree.stored_kind(file_id)
2421
if versioned_kind == 'directory':
2422
subdirs.append(child_id)
2423
children.append((path_from_root, basename, kind, None,
2424
file_id, versioned_kind))
2426
if parent_path.startswith(prefix):
2427
yield (parent_path, parent_file_id), children
2428
pending.extend(sorted(subdirs, key=self._final_paths.get_path,
2431
def get_parent_ids(self):
2432
return self._parent_ids
2434
def set_parent_ids(self, parent_ids):
2435
self._parent_ids = parent_ids
2437
def get_revision_tree(self, revision_id):
2438
return self._transform._tree.get_revision_tree(revision_id)
2441
897
def joinpath(parent, child):
2442
898
"""Join tree-relative paths, handling the tree root specially"""
2443
899
if parent is None or parent == "":
2473
929
self._known_paths[trans_id] = self._determine_path(trans_id)
2474
930
return self._known_paths[trans_id]
2476
def get_paths(self, trans_ids):
2477
return [(self.get_path(t), t) for t in trans_ids]
2481
932
def topology_sorted_ids(tree):
2482
933
"""Determine the topological order of the ids in a tree"""
2483
934
file_ids = list(tree)
2484
935
file_ids.sort(key=tree.id2path)
2488
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
2489
delta_from_tree=False):
2490
"""Create working tree for a branch, using a TreeTransform.
2492
This function should be used on empty trees, having a tree root at most.
2493
(see merge and revert functionality for working with existing trees)
2495
Existing files are handled like so:
2497
- Existing bzrdirs take precedence over creating new items. They are
2498
created as '%s.diverted' % name.
2499
- Otherwise, if the content on disk matches the content we are building,
2500
it is silently replaced.
2501
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
2503
:param tree: The tree to convert wt into a copy of
2504
:param wt: The working tree that files will be placed into
2505
:param accelerator_tree: A tree which can be used for retrieving file
2506
contents more quickly than tree itself, i.e. a workingtree. tree
2507
will be used for cases where accelerator_tree's content is different.
2508
:param hardlink: If true, hard-link files to accelerator_tree, where
2509
possible. accelerator_tree must implement abspath, i.e. be a
2511
:param delta_from_tree: If true, build_tree may use the input Tree to
2512
generate the inventory delta.
2514
wt.lock_tree_write()
2518
if accelerator_tree is not None:
2519
accelerator_tree.lock_read()
2521
return _build_tree(tree, wt, accelerator_tree, hardlink,
2524
if accelerator_tree is not None:
2525
accelerator_tree.unlock()
2532
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
2533
"""See build_tree."""
2534
for num, _unused in enumerate(wt.all_file_ids()):
2535
if num > 0: # more than just a root
2536
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
938
def build_tree(tree, wt):
939
"""Create working tree for a branch, using a Transaction."""
2537
940
file_trans_id = {}
2538
top_pb = ui.ui_factory.nested_progress_bar()
941
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2539
942
pp = ProgressPhase("Build phase", 2, top_pb)
2540
if tree.inventory.root is not None:
2541
# This is kind of a hack: we should be altering the root
2542
# as part of the regular tree shape diff logic.
2543
# The conditional test here is to avoid doing an
2544
# expensive operation (flush) every time the root id
2545
# is set within the tree, nor setting the root and thus
2546
# marking the tree as dirty, because we use two different
2547
# idioms here: tree interfaces and inventory interfaces.
2548
if wt.get_root_id() != tree.get_root_id():
2549
wt.set_root_id(tree.get_root_id())
2551
943
tt = TreeTransform(wt)
2555
file_trans_id[wt.get_root_id()] = \
2556
tt.trans_id_tree_file_id(wt.get_root_id())
2557
pb = ui.ui_factory.nested_progress_bar()
946
file_trans_id[wt.get_root_id()] = tt.trans_id_tree_file_id(wt.get_root_id())
947
file_ids = topology_sorted_ids(tree)
948
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2559
deferred_contents = []
2561
total = len(tree.inventory)
2563
precomputed_delta = []
2565
precomputed_delta = None
2566
# Check if tree inventory has content. If so, we populate
2567
# existing_files with the directory content. If there are no
2568
# entries we skip populating existing_files as its not used.
2569
# This improves performance and unncessary work on large
2570
# directory trees. (#501307)
2572
existing_files = set()
2573
for dir, files in wt.walkdirs():
2574
existing_files.update(f[0] for f in files)
2575
for num, (tree_path, entry) in \
2576
enumerate(tree.inventory.iter_entries_by_dir()):
2577
pb.update("Building tree", num - len(deferred_contents), total)
950
for num, file_id in enumerate(file_ids):
951
pb.update("Building tree", num, len(file_ids))
952
entry = tree.inventory[file_id]
2578
953
if entry.parent_id is None:
2581
file_id = entry.file_id
2583
precomputed_delta.append((None, tree_path, file_id, entry))
2584
if tree_path in existing_files:
2585
target_path = wt.abspath(tree_path)
2586
kind = file_kind(target_path)
2587
if kind == "directory":
2589
bzrdir.BzrDir.open(target_path)
2590
except errors.NotBranchError:
2594
if (file_id not in divert and
2595
_content_match(tree, entry, file_id, kind,
2597
tt.delete_contents(tt.trans_id_tree_path(tree_path))
2598
if kind == 'directory':
955
if entry.parent_id not in file_trans_id:
956
raise repr(entry.parent_id)
2600
957
parent_id = file_trans_id[entry.parent_id]
2601
if entry.kind == 'file':
2602
# We *almost* replicate new_by_entry, so that we can defer
2603
# getting the file text, and get them all at once.
2604
trans_id = tt.create_path(entry.name, parent_id)
2605
file_trans_id[file_id] = trans_id
2606
tt.version_file(file_id, trans_id)
2607
executable = tree.is_executable(file_id, tree_path)
2609
tt.set_executability(executable, trans_id)
2610
trans_data = (trans_id, tree_path, entry.text_sha1)
2611
deferred_contents.append((file_id, trans_data))
2613
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2616
new_trans_id = file_trans_id[file_id]
2617
old_parent = tt.trans_id_tree_path(tree_path)
2618
_reparent_children(tt, old_parent, new_trans_id)
2619
offset = num + 1 - len(deferred_contents)
2620
_create_files(tt, tree, deferred_contents, pb, offset,
2621
accelerator_tree, hardlink)
958
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2625
divert_trans = set(file_trans_id[f] for f in divert)
2626
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
2627
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
2628
if len(raw_conflicts) > 0:
2629
precomputed_delta = None
2630
conflicts = cook_conflicts(raw_conflicts, tt)
2631
for conflict in conflicts:
2632
trace.warning(unicode(conflict))
2634
wt.add_conflicts(conflicts)
2635
except errors.UnsupportedOperation:
2637
result = tt.apply(no_conflicts=True,
2638
precomputed_delta=precomputed_delta)
2641
966
top_pb.finished()
2645
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
2647
total = len(desired_files) + offset
2649
if accelerator_tree is None:
2650
new_desired_files = desired_files
2652
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2653
unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2654
in iter if not (c or e[0] != e[1])]
2655
if accelerator_tree.supports_content_filtering():
2656
unchanged = [(f, p) for (f, p) in unchanged
2657
if not accelerator_tree.iter_search_rules([p]).next()]
2658
unchanged = dict(unchanged)
2659
new_desired_files = []
2661
for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2662
accelerator_path = unchanged.get(file_id)
2663
if accelerator_path is None:
2664
new_desired_files.append((file_id,
2665
(trans_id, tree_path, text_sha1)))
2667
pb.update('Adding file contents', count + offset, total)
2669
tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2672
contents = accelerator_tree.get_file(file_id, accelerator_path)
2673
if wt.supports_content_filtering():
2674
filters = wt._content_filter_stack(tree_path)
2675
contents = filtered_output_bytes(contents, filters,
2676
ContentFilterContext(tree_path, tree))
2678
tt.create_file(contents, trans_id, sha1=text_sha1)
2682
except AttributeError:
2683
# after filtering, contents may no longer be file-like
2687
for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2688
tree.iter_files_bytes(new_desired_files)):
2689
if wt.supports_content_filtering():
2690
filters = wt._content_filter_stack(tree_path)
2691
contents = filtered_output_bytes(contents, filters,
2692
ContentFilterContext(tree_path, tree))
2693
tt.create_file(contents, trans_id, sha1=text_sha1)
2694
pb.update('Adding file contents', count + offset, total)
2697
def _reparent_children(tt, old_parent, new_parent):
2698
for child in tt.iter_tree_children(old_parent):
2699
tt.adjust_path(tt.final_name(child), new_parent, child)
2702
def _reparent_transform_children(tt, old_parent, new_parent):
2703
by_parent = tt.by_parent()
2704
for child in by_parent[old_parent]:
2705
tt.adjust_path(tt.final_name(child), new_parent, child)
2706
return by_parent[old_parent]
2709
def _content_match(tree, entry, file_id, kind, target_path):
2710
if entry.kind != kind:
2712
if entry.kind == "directory":
2714
if entry.kind == "file":
2715
f = file(target_path, 'rb')
2717
if tree.get_file_text(file_id) == f.read():
2721
elif entry.kind == "symlink":
2722
if tree.get_symlink_target(file_id) == os.readlink(target_path):
2727
def resolve_checkout(tt, conflicts, divert):
2728
new_conflicts = set()
2729
for c_type, conflict in ((c[0], c) for c in conflicts):
2730
# Anything but a 'duplicate' would indicate programmer error
2731
if c_type != 'duplicate':
2732
raise AssertionError(c_type)
2733
# Now figure out which is new and which is old
2734
if tt.new_contents(conflict[1]):
2735
new_file = conflict[1]
2736
old_file = conflict[2]
2738
new_file = conflict[2]
2739
old_file = conflict[1]
2741
# We should only get here if the conflict wasn't completely
2743
final_parent = tt.final_parent(old_file)
2744
if new_file in divert:
2745
new_name = tt.final_name(old_file)+'.diverted'
2746
tt.adjust_path(new_name, final_parent, new_file)
2747
new_conflicts.add((c_type, 'Diverted to',
2748
new_file, old_file))
2750
new_name = tt.final_name(old_file)+'.moved'
2751
tt.adjust_path(new_name, final_parent, old_file)
2752
new_conflicts.add((c_type, 'Moved existing file to',
2753
old_file, new_file))
2754
return new_conflicts
2757
968
def new_by_entry(tt, entry, parent_id, tree):
2758
969
"""Create a new file according to its inventory entry"""
2846
1071
contents_mod = True
2847
1072
meta_mod = False
2848
1073
if has_contents is True:
2849
if entry.kind != working_kind:
1074
real_e_kind = entry.kind
1075
if real_e_kind == 'root_directory':
1076
real_e_kind = 'directory'
1077
if real_e_kind != working_kind:
2850
1078
contents_mod, meta_mod = True, False
2852
cur_entry._read_tree_state(working_tree.id2path(file_id),
1080
cur_entry._read_tree_state(working_tree.id2path(file_id),
2854
1082
contents_mod, meta_mod = entry.detect_changes(cur_entry)
2855
1083
cur_entry._forget_tree_state()
2856
1084
return has_contents, contents_mod, meta_mod
2859
def revert(working_tree, target_tree, filenames, backups=False,
2860
pb=None, change_reporter=None):
1087
def revert(working_tree, target_tree, filenames, backups=False,
1088
pb=DummyProgress()):
2861
1089
"""Revert a working tree's contents to those of a target tree."""
2862
target_tree.lock_read()
2863
pb = ui.ui_factory.nested_progress_bar()
1090
interesting_ids = find_interesting(working_tree, target_tree, filenames)
1091
def interesting(file_id):
1092
return interesting_ids is None or file_id in interesting_ids
2864
1094
tt = TreeTransform(working_tree, pb)
2866
pp = ProgressPhase("Revert phase", 3, pb)
2867
conflicts, merge_modified = _prepare_revert_transform(
2868
working_tree, target_tree, tt, filenames, backups, pp)
2870
change_reporter = delta._ChangeReporter(
2871
unversioned_filter=working_tree.is_ignored)
2872
delta.report_changes(tt.iter_changes(), change_reporter)
1096
merge_modified = working_tree.merge_modified()
1098
def trans_id_file_id(file_id):
1100
return trans_id[file_id]
1102
return tt.trans_id_tree_file_id(file_id)
1104
pp = ProgressPhase("Revert phase", 4, pb)
1106
sorted_interesting = [i for i in topology_sorted_ids(target_tree) if
1108
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1110
by_parent = tt.by_parent()
1111
for id_num, file_id in enumerate(sorted_interesting):
1112
child_pb.update("Reverting file", id_num+1,
1113
len(sorted_interesting))
1114
if file_id not in working_tree.inventory:
1115
entry = target_tree.inventory[file_id]
1116
parent_id = trans_id_file_id(entry.parent_id)
1117
e_trans_id = new_by_entry(tt, entry, parent_id, target_tree)
1118
trans_id[file_id] = e_trans_id
1120
backup_this = backups
1121
if file_id in merge_modified:
1123
del merge_modified[file_id]
1124
change_entry(tt, file_id, working_tree, target_tree,
1125
trans_id_file_id, backup_this, trans_id,
1130
wt_interesting = [i for i in working_tree.inventory if interesting(i)]
1131
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1133
for id_num, file_id in enumerate(wt_interesting):
1134
child_pb.update("New file check", id_num+1,
1135
len(sorted_interesting))
1136
if file_id not in target_tree:
1137
trans_id = tt.trans_id_tree_file_id(file_id)
1138
tt.unversion_file(trans_id)
1139
if file_id in merge_modified:
1140
tt.delete_contents(trans_id)
1141
del merge_modified[file_id]
1145
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1147
raw_conflicts = resolve_conflicts(tt, child_pb)
1150
conflicts = cook_conflicts(raw_conflicts, tt)
2873
1151
for conflict in conflicts:
2874
trace.warning(unicode(conflict))
2875
1153
pp.next_phase()
2877
working_tree.set_merge_modified(merge_modified)
1155
working_tree.set_merge_modified({})
2879
target_tree.unlock()
2882
1159
return conflicts
2885
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2886
backups, pp, basis_tree=None,
2887
merge_modified=None):
2888
child_pb = ui.ui_factory.nested_progress_bar()
2890
if merge_modified is None:
2891
merge_modified = working_tree.merge_modified()
2892
merge_modified = _alter_files(working_tree, target_tree, tt,
2893
child_pb, filenames, backups,
2894
merge_modified, basis_tree)
2897
child_pb = ui.ui_factory.nested_progress_bar()
2899
raw_conflicts = resolve_conflicts(tt, child_pb,
2900
lambda t, c: conflict_pass(t, c, target_tree))
2903
conflicts = cook_conflicts(raw_conflicts, tt)
2904
return conflicts, merge_modified
2907
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
2908
backups, merge_modified, basis_tree=None):
2909
if basis_tree is not None:
2910
basis_tree.lock_read()
2911
# We ask the working_tree for its changes relative to the target, rather
2912
# than the target changes relative to the working tree. Because WT4 has an
2913
# optimizer to compare itself to a target, but no optimizer for the
2915
change_list = working_tree.iter_changes(target_tree,
2916
specific_files=specific_files, pb=pb)
2917
if target_tree.get_root_id() is None:
2923
for id_num, (file_id, path, changed_content, versioned, parent, name,
2924
kind, executable) in enumerate(change_list):
2925
target_path, wt_path = path
2926
target_versioned, wt_versioned = versioned
2927
target_parent, wt_parent = parent
2928
target_name, wt_name = name
2929
target_kind, wt_kind = kind
2930
target_executable, wt_executable = executable
2931
if skip_root and wt_parent is None:
2933
trans_id = tt.trans_id_file_id(file_id)
2936
keep_content = False
2937
if wt_kind == 'file' and (backups or target_kind is None):
2938
wt_sha1 = working_tree.get_file_sha1(file_id)
2939
if merge_modified.get(file_id) != wt_sha1:
2940
# acquire the basis tree lazily to prevent the
2941
# expense of accessing it when it's not needed ?
2942
# (Guessing, RBC, 200702)
2943
if basis_tree is None:
2944
basis_tree = working_tree.basis_tree()
2945
basis_tree.lock_read()
2946
if basis_tree.has_id(file_id):
2947
if wt_sha1 != basis_tree.get_file_sha1(file_id):
2949
elif target_kind is None and not target_versioned:
2951
if wt_kind is not None:
2952
if not keep_content:
2953
tt.delete_contents(trans_id)
2954
elif target_kind is not None:
2955
parent_trans_id = tt.trans_id_file_id(wt_parent)
2956
backup_name = tt._available_backup_name(
2957
wt_name, parent_trans_id)
2958
tt.adjust_path(backup_name, parent_trans_id, trans_id)
2959
new_trans_id = tt.create_path(wt_name, parent_trans_id)
2960
if wt_versioned and target_versioned:
2961
tt.unversion_file(trans_id)
2962
tt.version_file(file_id, new_trans_id)
2963
# New contents should have the same unix perms as old
2966
trans_id = new_trans_id
2967
if target_kind in ('directory', 'tree-reference'):
2968
tt.create_directory(trans_id)
2969
if target_kind == 'tree-reference':
2970
revision = target_tree.get_reference_revision(file_id,
2972
tt.set_tree_reference(revision, trans_id)
2973
elif target_kind == 'symlink':
2974
tt.create_symlink(target_tree.get_symlink_target(file_id),
2976
elif target_kind == 'file':
2977
deferred_files.append((file_id, (trans_id, mode_id)))
2978
if basis_tree is None:
2979
basis_tree = working_tree.basis_tree()
2980
basis_tree.lock_read()
2981
new_sha1 = target_tree.get_file_sha1(file_id)
2982
if (basis_tree.has_id(file_id) and
2983
new_sha1 == basis_tree.get_file_sha1(file_id)):
2984
if file_id in merge_modified:
2985
del merge_modified[file_id]
2987
merge_modified[file_id] = new_sha1
2989
# preserve the execute bit when backing up
2990
if keep_content and wt_executable == target_executable:
2991
tt.set_executability(target_executable, trans_id)
2992
elif target_kind is not None:
2993
raise AssertionError(target_kind)
2994
if not wt_versioned and target_versioned:
2995
tt.version_file(file_id, trans_id)
2996
if wt_versioned and not target_versioned:
2997
tt.unversion_file(trans_id)
2998
if (target_name is not None and
2999
(wt_name != target_name or wt_parent != target_parent)):
3000
if target_name == '' and target_parent is None:
3001
parent_trans = ROOT_PARENT
3003
parent_trans = tt.trans_id_file_id(target_parent)
3004
if wt_parent is None and wt_versioned:
3005
tt.adjust_root_path(target_name, parent_trans)
3007
tt.adjust_path(target_name, parent_trans, trans_id)
3008
if wt_executable != target_executable and target_kind == "file":
3009
tt.set_executability(target_executable, trans_id)
3010
if working_tree.supports_content_filtering():
3011
for index, ((trans_id, mode_id), bytes) in enumerate(
3012
target_tree.iter_files_bytes(deferred_files)):
3013
file_id = deferred_files[index][0]
3014
# We're reverting a tree to the target tree so using the
3015
# target tree to find the file path seems the best choice
3016
# here IMO - Ian C 27/Oct/2009
3017
filter_tree_path = target_tree.id2path(file_id)
3018
filters = working_tree._content_filter_stack(filter_tree_path)
3019
bytes = filtered_output_bytes(bytes, filters,
3020
ContentFilterContext(filter_tree_path, working_tree))
3021
tt.create_file(bytes, trans_id, mode_id)
3023
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
3025
tt.create_file(bytes, trans_id, mode_id)
3026
tt.fixup_new_roots()
3028
if basis_tree is not None:
3030
return merge_modified
3033
def resolve_conflicts(tt, pb=None, pass_func=None):
1162
def resolve_conflicts(tt, pb=DummyProgress()):
3034
1163
"""Make many conflict-resolution attempts, but die if they fail"""
3035
if pass_func is None:
3036
pass_func = conflict_pass
3037
1164
new_conflicts = set()
3038
pb = ui.ui_factory.nested_progress_bar()
3040
1166
for n in range(10):
3041
1167
pb.update('Resolution pass', n+1, 10)
3042
1168
conflicts = tt.find_conflicts()
3043
1169
if len(conflicts) == 0:
3044
1170
return new_conflicts
3045
new_conflicts.update(pass_func(tt, conflicts))
1171
new_conflicts.update(conflict_pass(tt, conflicts))
3046
1172
raise MalformedTransform(conflicts=conflicts)
3051
def conflict_pass(tt, conflicts, path_tree=None):
3052
"""Resolve some classes of conflicts.
3054
:param tt: The transform to resolve conflicts in
3055
:param conflicts: The conflicts to resolve
3056
:param path_tree: A Tree to get supplemental paths from
1177
def conflict_pass(tt, conflicts):
1178
"""Resolve some classes of conflicts."""
3058
1179
new_conflicts = set()
3059
1180
for c_type, conflict in ((c[0], c) for c in conflicts):
3060
1181
if c_type == 'duplicate id':
added
removed
bzrlib/transform.py
