1
# Copyright (C) 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
from stat import S_ISREG
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
30
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
31
ReusingTransform, NotVersionedError, CantMoveRoot,
32
ExistingLimbo, ImmortalLimbo, NoFinalPath)
33
from bzrlib.inventory import InventoryEntry
34
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
36
from bzrlib.progress import DummyProgress, ProgressPhase
37
from bzrlib.symbol_versioning import (
42
from bzrlib.trace import mutter, warning
43
from bzrlib import tree
45
import bzrlib.urlutils as urlutils
48
ROOT_PARENT = "root-parent"
51
def unique_add(map, key, value):
53
raise DuplicateKey(key=key)
57
class _TransformResults(object):
58
def __init__(self, modified_paths, rename_count):
60
self.modified_paths = modified_paths
61
self.rename_count = rename_count
64
class TreeTransform(object):
65
"""Represent a tree transformation.
67
This object is designed to support incremental generation of the transform,
70
However, it gives optimum performance when parent directories are created
71
before their contents. The transform is then able to put child files
72
directly in their parent directory, avoiding later renames.
74
It is easy to produce malformed transforms, but they are generally
75
harmless. Attempting to apply a malformed transform will cause an
76
exception to be raised before any modifications are made to the tree.
78
Many kinds of malformed transforms can be corrected with the
79
resolve_conflicts function. The remaining ones indicate programming error,
80
such as trying to create a file with no path.
82
Two sets of file creation methods are supplied. Convenience methods are:
87
These are composed of the low-level methods:
89
* create_file or create_directory or create_symlink
93
def __init__(self, tree, pb=DummyProgress()):
94
"""Note: a tree_write lock is taken on the tree.
96
Use TreeTransform.finalize() to release the lock (can be omitted if
97
TreeTransform.apply() called).
101
self._tree.lock_tree_write()
103
control_files = self._tree._control_files
104
self._limbodir = urlutils.local_path_from_url(
105
control_files.controlfilename('limbo'))
107
os.mkdir(self._limbodir)
109
if e.errno == errno.EEXIST:
110
raise ExistingLimbo(self._limbodir)
117
self._new_parent = {}
118
self._new_contents = {}
119
# A mapping of transform ids to their limbo filename
120
self._limbo_files = {}
121
# A mapping of transform ids to a set of the transform ids of children
122
# that their limbo directory has
123
self._limbo_children = {}
124
# Map transform ids to maps of child filename to child transform id
125
self._limbo_children_names = {}
126
# List of transform ids that need to be renamed from limbo into place
127
self._needs_rename = set()
128
self._removed_contents = set()
129
self._new_executability = {}
130
self._new_reference_revision = {}
132
self._non_present_ids = {}
134
self._removed_id = set()
135
self._tree_path_ids = {}
136
self._tree_id_paths = {}
137
# Cache of realpath results, to speed up canonical_path
139
# Cache of relpath results, to speed up canonical_path
141
self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
144
self.rename_count = 0
146
def __get_root(self):
147
return self._new_root
149
root = property(__get_root)
152
"""Release the working tree lock, if held, clean up limbo dir.
154
This is required if apply has not been invoked, but can be invoked
157
if self._tree is None:
160
entries = [(self._limbo_name(t), t, k) for t, k in
161
self._new_contents.iteritems()]
162
entries.sort(reverse=True)
163
for path, trans_id, kind in entries:
164
if kind == "directory":
169
os.rmdir(self._limbodir)
171
# We don't especially care *why* the dir is immortal.
172
raise ImmortalLimbo(self._limbodir)
177
def _assign_id(self):
178
"""Produce a new tranform id"""
179
new_id = "new-%s" % self._id_number
183
def create_path(self, name, parent):
184
"""Assign a transaction id to a new path"""
185
trans_id = self._assign_id()
186
unique_add(self._new_name, trans_id, name)
187
unique_add(self._new_parent, trans_id, parent)
190
def adjust_path(self, name, parent, trans_id):
191
"""Change the path that is assigned to a transaction id."""
192
if trans_id == self._new_root:
194
previous_parent = self._new_parent.get(trans_id)
195
previous_name = self._new_name.get(trans_id)
196
self._new_name[trans_id] = name
197
self._new_parent[trans_id] = parent
198
if (trans_id in self._limbo_files and
199
trans_id not in self._needs_rename):
200
self._rename_in_limbo([trans_id])
201
self._limbo_children[previous_parent].remove(trans_id)
202
del self._limbo_children_names[previous_parent][previous_name]
204
def _rename_in_limbo(self, trans_ids):
205
"""Fix limbo names so that the right final path is produced.
207
This means we outsmarted ourselves-- we tried to avoid renaming
208
these files later by creating them with their final names in their
209
final parents. But now the previous name or parent is no longer
210
suitable, so we have to rename them.
212
Even for trans_ids that have no new contents, we must remove their
213
entries from _limbo_files, because they are now stale.
215
for trans_id in trans_ids:
216
old_path = self._limbo_files.pop(trans_id)
217
if trans_id not in self._new_contents:
219
new_path = self._limbo_name(trans_id)
220
os.rename(old_path, new_path)
222
def adjust_root_path(self, name, parent):
223
"""Emulate moving the root by moving all children, instead.
225
We do this by undoing the association of root's transaction id with the
226
current tree. This allows us to create a new directory with that
227
transaction id. We unversion the root directory and version the
228
physically new directory, and hope someone versions the tree root
231
old_root = self._new_root
232
old_root_file_id = self.final_file_id(old_root)
233
# force moving all children of root
234
for child_id in self.iter_tree_children(old_root):
235
if child_id != parent:
236
self.adjust_path(self.final_name(child_id),
237
self.final_parent(child_id), child_id)
238
file_id = self.final_file_id(child_id)
239
if file_id is not None:
240
self.unversion_file(child_id)
241
self.version_file(file_id, child_id)
243
# the physical root needs a new transaction id
244
self._tree_path_ids.pop("")
245
self._tree_id_paths.pop(old_root)
246
self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
247
if parent == old_root:
248
parent = self._new_root
249
self.adjust_path(name, parent, old_root)
250
self.create_directory(old_root)
251
self.version_file(old_root_file_id, old_root)
252
self.unversion_file(self._new_root)
254
def trans_id_tree_file_id(self, inventory_id):
255
"""Determine the transaction id of a working tree file.
257
This reflects only files that already exist, not ones that will be
258
added by transactions.
260
path = self._tree.inventory.id2path(inventory_id)
261
return self.trans_id_tree_path(path)
263
def trans_id_file_id(self, file_id):
264
"""Determine or set the transaction id associated with a file ID.
265
A new id is only created for file_ids that were never present. If
266
a transaction has been unversioned, it is deliberately still returned.
267
(this will likely lead to an unversioned parent conflict.)
269
if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
270
return self._r_new_id[file_id]
271
elif file_id in self._tree.inventory:
272
return self.trans_id_tree_file_id(file_id)
273
elif file_id in self._non_present_ids:
274
return self._non_present_ids[file_id]
276
trans_id = self._assign_id()
277
self._non_present_ids[file_id] = trans_id
280
def canonical_path(self, path):
281
"""Get the canonical tree-relative path"""
282
# don't follow final symlinks
283
abs = self._tree.abspath(path)
284
if abs in self._relpaths:
285
return self._relpaths[abs]
286
dirname, basename = os.path.split(abs)
287
if dirname not in self._realpaths:
288
self._realpaths[dirname] = os.path.realpath(dirname)
289
dirname = self._realpaths[dirname]
290
abs = pathjoin(dirname, basename)
291
if dirname in self._relpaths:
292
relpath = pathjoin(self._relpaths[dirname], basename)
293
relpath = relpath.rstrip('/\\')
295
relpath = self._tree.relpath(abs)
296
self._relpaths[abs] = relpath
299
def trans_id_tree_path(self, path):
300
"""Determine (and maybe set) the transaction ID for a tree path."""
301
path = self.canonical_path(path)
302
if path not in self._tree_path_ids:
303
self._tree_path_ids[path] = self._assign_id()
304
self._tree_id_paths[self._tree_path_ids[path]] = path
305
return self._tree_path_ids[path]
307
def get_tree_parent(self, trans_id):
308
"""Determine id of the parent in the tree."""
309
path = self._tree_id_paths[trans_id]
312
return self.trans_id_tree_path(os.path.dirname(path))
314
def create_file(self, contents, trans_id, mode_id=None):
315
"""Schedule creation of a new file.
319
Contents is an iterator of strings, all of which will be written
320
to the target destination.
322
New file takes the permissions of any existing file with that id,
323
unless mode_id is specified.
325
name = self._limbo_name(trans_id)
329
unique_add(self._new_contents, trans_id, 'file')
331
# Clean up the file, it never got registered so
332
# TreeTransform.finalize() won't clean it up.
337
f.writelines(contents)
340
self._set_mode(trans_id, mode_id, S_ISREG)
342
def _set_mode(self, trans_id, mode_id, typefunc):
343
"""Set the mode of new file contents.
344
The mode_id is the existing file to get the mode from (often the same
345
as trans_id). The operation is only performed if there's a mode match
346
according to typefunc.
351
old_path = self._tree_id_paths[mode_id]
355
mode = os.stat(self._tree.abspath(old_path)).st_mode
357
if e.errno == errno.ENOENT:
362
os.chmod(self._limbo_name(trans_id), mode)
364
def create_directory(self, trans_id):
365
"""Schedule creation of a new directory.
367
See also new_directory.
369
os.mkdir(self._limbo_name(trans_id))
370
unique_add(self._new_contents, trans_id, 'directory')
372
def create_symlink(self, target, trans_id):
373
"""Schedule creation of a new symbolic link.
375
target is a bytestring.
376
See also new_symlink.
378
os.symlink(target, self._limbo_name(trans_id))
379
unique_add(self._new_contents, trans_id, 'symlink')
381
def cancel_creation(self, trans_id):
382
"""Cancel the creation of new file contents."""
383
del self._new_contents[trans_id]
384
children = self._limbo_children.get(trans_id)
385
# if this is a limbo directory with children, move them before removing
387
if children is not None:
388
self._rename_in_limbo(children)
389
del self._limbo_children[trans_id]
390
del self._limbo_children_names[trans_id]
391
delete_any(self._limbo_name(trans_id))
393
def delete_contents(self, trans_id):
394
"""Schedule the contents of a path entry for deletion"""
395
self.tree_kind(trans_id)
396
self._removed_contents.add(trans_id)
398
def cancel_deletion(self, trans_id):
399
"""Cancel a scheduled deletion"""
400
self._removed_contents.remove(trans_id)
402
def unversion_file(self, trans_id):
403
"""Schedule a path entry to become unversioned"""
404
self._removed_id.add(trans_id)
406
def delete_versioned(self, trans_id):
407
"""Delete and unversion a versioned file"""
408
self.delete_contents(trans_id)
409
self.unversion_file(trans_id)
411
def set_executability(self, executability, trans_id):
412
"""Schedule setting of the 'execute' bit
413
To unschedule, set to None
415
if executability is None:
416
del self._new_executability[trans_id]
418
unique_add(self._new_executability, trans_id, executability)
420
def set_tree_reference(self, revision_id, trans_id):
421
"""Set the reference associated with a directory"""
422
unique_add(self._new_reference_revision, trans_id, revision_id)
424
def version_file(self, file_id, trans_id):
425
"""Schedule a file to become versioned."""
426
assert file_id is not None
427
unique_add(self._new_id, trans_id, file_id)
428
unique_add(self._r_new_id, file_id, trans_id)
430
def cancel_versioning(self, trans_id):
431
"""Undo a previous versioning of a file"""
432
file_id = self._new_id[trans_id]
433
del self._new_id[trans_id]
434
del self._r_new_id[file_id]
437
"""Determine the paths of all new and changed files"""
439
fp = FinalPaths(self)
440
for id_set in (self._new_name, self._new_parent, self._new_contents,
441
self._new_id, self._new_executability):
442
new_ids.update(id_set)
443
new_paths = [(fp.get_path(t), t) for t in new_ids]
447
def tree_kind(self, trans_id):
448
"""Determine the file kind in the working tree.
450
Raises NoSuchFile if the file does not exist
452
path = self._tree_id_paths.get(trans_id)
454
raise NoSuchFile(None)
456
return file_kind(self._tree.abspath(path))
458
if e.errno != errno.ENOENT:
461
raise NoSuchFile(path)
463
def final_kind(self, trans_id):
464
"""Determine the final file kind, after any changes applied.
466
Raises NoSuchFile if the file does not exist/has no contents.
467
(It is conceivable that a path would be created without the
468
corresponding contents insertion command)
470
if trans_id in self._new_contents:
471
return self._new_contents[trans_id]
472
elif trans_id in self._removed_contents:
473
raise NoSuchFile(None)
475
return self.tree_kind(trans_id)
477
def tree_file_id(self, trans_id):
478
"""Determine the file id associated with the trans_id in the tree"""
480
path = self._tree_id_paths[trans_id]
482
# the file is a new, unversioned file, or invalid trans_id
484
# the file is old; the old id is still valid
485
if self._new_root == trans_id:
486
return self._tree.inventory.root.file_id
487
return self._tree.inventory.path2id(path)
489
def final_file_id(self, trans_id):
490
"""Determine the file id after any changes are applied, or None.
492
None indicates that the file will not be versioned after changes are
496
# there is a new id for this file
497
assert self._new_id[trans_id] is not None
498
return self._new_id[trans_id]
500
if trans_id in self._removed_id:
502
return self.tree_file_id(trans_id)
504
def inactive_file_id(self, trans_id):
505
"""Return the inactive file_id associated with a transaction id.
506
That is, the one in the tree or in non_present_ids.
507
The file_id may actually be active, too.
509
file_id = self.tree_file_id(trans_id)
510
if file_id is not None:
512
for key, value in self._non_present_ids.iteritems():
513
if value == trans_id:
516
def final_parent(self, trans_id):
517
"""Determine the parent file_id, after any changes are applied.
519
ROOT_PARENT is returned for the tree root.
522
return self._new_parent[trans_id]
524
return self.get_tree_parent(trans_id)
526
def final_name(self, trans_id):
527
"""Determine the final filename, after all changes are applied."""
529
return self._new_name[trans_id]
532
return os.path.basename(self._tree_id_paths[trans_id])
534
raise NoFinalPath(trans_id, self)
537
"""Return a map of parent: children for known parents.
539
Only new paths and parents of tree files with assigned ids are used.
542
items = list(self._new_parent.iteritems())
543
items.extend((t, self.final_parent(t)) for t in
544
self._tree_id_paths.keys())
545
for trans_id, parent_id in items:
546
if parent_id not in by_parent:
547
by_parent[parent_id] = set()
548
by_parent[parent_id].add(trans_id)
551
def path_changed(self, trans_id):
552
"""Return True if a trans_id's path has changed."""
553
return (trans_id in self._new_name) or (trans_id in self._new_parent)
555
def new_contents(self, trans_id):
556
return (trans_id in self._new_contents)
558
def find_conflicts(self):
559
"""Find any violations of inventory or filesystem invariants"""
560
if self.__done is True:
561
raise ReusingTransform()
563
# ensure all children of all existent parents are known
564
# all children of non-existent parents are known, by definition.
565
self._add_tree_children()
566
by_parent = self.by_parent()
567
conflicts.extend(self._unversioned_parents(by_parent))
568
conflicts.extend(self._parent_loops())
569
conflicts.extend(self._duplicate_entries(by_parent))
570
conflicts.extend(self._duplicate_ids())
571
conflicts.extend(self._parent_type_conflicts(by_parent))
572
conflicts.extend(self._improper_versioning())
573
conflicts.extend(self._executability_conflicts())
574
conflicts.extend(self._overwrite_conflicts())
577
def _add_tree_children(self):
578
"""Add all the children of all active parents to the known paths.
580
Active parents are those which gain children, and those which are
581
removed. This is a necessary first step in detecting conflicts.
583
parents = self.by_parent().keys()
584
parents.extend([t for t in self._removed_contents if
585
self.tree_kind(t) == 'directory'])
586
for trans_id in self._removed_id:
587
file_id = self.tree_file_id(trans_id)
588
if self._tree.inventory[file_id].kind == 'directory':
589
parents.append(trans_id)
591
for parent_id in parents:
592
# ensure that all children are registered with the transaction
593
list(self.iter_tree_children(parent_id))
595
def iter_tree_children(self, parent_id):
596
"""Iterate through the entry's tree children, if any"""
598
path = self._tree_id_paths[parent_id]
602
children = os.listdir(self._tree.abspath(path))
604
if e.errno != errno.ENOENT and e.errno != errno.ESRCH:
608
for child in children:
609
childpath = joinpath(path, child)
610
if self._tree.is_control_filename(childpath):
612
yield self.trans_id_tree_path(childpath)
614
def has_named_child(self, by_parent, parent_id, name):
616
children = by_parent[parent_id]
619
for child in children:
620
if self.final_name(child) == name:
623
path = self._tree_id_paths[parent_id]
626
childpath = joinpath(path, name)
627
child_id = self._tree_path_ids.get(childpath)
629
return lexists(self._tree.abspath(childpath))
631
if self.final_parent(child_id) != parent_id:
633
if child_id in self._removed_contents:
634
# XXX What about dangling file-ids?
639
def _parent_loops(self):
640
"""No entry should be its own ancestor"""
642
for trans_id in self._new_parent:
645
while parent_id is not ROOT_PARENT:
648
parent_id = self.final_parent(parent_id)
651
if parent_id == trans_id:
652
conflicts.append(('parent loop', trans_id))
653
if parent_id in seen:
657
def _unversioned_parents(self, by_parent):
658
"""If parent directories are versioned, children must be versioned."""
660
for parent_id, children in by_parent.iteritems():
661
if parent_id is ROOT_PARENT:
663
if self.final_file_id(parent_id) is not None:
665
for child_id in children:
666
if self.final_file_id(child_id) is not None:
667
conflicts.append(('unversioned parent', parent_id))
671
def _improper_versioning(self):
672
"""Cannot version a file with no contents, or a bad type.
674
However, existing entries with no contents are okay.
677
for trans_id in self._new_id.iterkeys():
679
kind = self.final_kind(trans_id)
681
conflicts.append(('versioning no contents', trans_id))
683
if not InventoryEntry.versionable_kind(kind):
684
conflicts.append(('versioning bad kind', trans_id, kind))
687
def _executability_conflicts(self):
688
"""Check for bad executability changes.
690
Only versioned files may have their executability set, because
691
1. only versioned entries can have executability under windows
692
2. only files can be executable. (The execute bit on a directory
693
does not indicate searchability)
696
for trans_id in self._new_executability:
697
if self.final_file_id(trans_id) is None:
698
conflicts.append(('unversioned executability', trans_id))
701
non_file = self.final_kind(trans_id) != "file"
705
conflicts.append(('non-file executability', trans_id))
708
def _overwrite_conflicts(self):
709
"""Check for overwrites (not permitted on Win32)"""
711
for trans_id in self._new_contents:
713
self.tree_kind(trans_id)
716
if trans_id not in self._removed_contents:
717
conflicts.append(('overwrite', trans_id,
718
self.final_name(trans_id)))
721
def _duplicate_entries(self, by_parent):
722
"""No directory may have two entries with the same name."""
724
if (self._new_name, self._new_parent) == ({}, {}):
726
for children in by_parent.itervalues():
727
name_ids = [(self.final_name(t), t) for t in children]
731
for name, trans_id in name_ids:
733
kind = self.final_kind(trans_id)
736
file_id = self.final_file_id(trans_id)
737
if kind is None and file_id is None:
739
if name == last_name:
740
conflicts.append(('duplicate', last_trans_id, trans_id,
743
last_trans_id = trans_id
746
def _duplicate_ids(self):
747
"""Each inventory id may only be used once"""
749
removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
751
active_tree_ids = set((f for f in self._tree.inventory if
752
f not in removed_tree_ids))
753
for trans_id, file_id in self._new_id.iteritems():
754
if file_id in active_tree_ids:
755
old_trans_id = self.trans_id_tree_file_id(file_id)
756
conflicts.append(('duplicate id', old_trans_id, trans_id))
759
def _parent_type_conflicts(self, by_parent):
760
"""parents must have directory 'contents'."""
762
for parent_id, children in by_parent.iteritems():
763
if parent_id is ROOT_PARENT:
765
if not self._any_contents(children):
767
for child in children:
769
self.final_kind(child)
773
kind = self.final_kind(parent_id)
777
conflicts.append(('missing parent', parent_id))
778
elif kind != "directory":
779
conflicts.append(('non-directory parent', parent_id))
782
def _any_contents(self, trans_ids):
783
"""Return true if any of the trans_ids, will have contents."""
784
for trans_id in trans_ids:
786
kind = self.final_kind(trans_id)
792
def apply(self, no_conflicts=False):
793
"""Apply all changes to the inventory and filesystem.
795
If filesystem or inventory conflicts are present, MalformedTransform
798
If apply succeeds, finalize is not necessary.
800
:param no_conflicts: if True, the caller guarantees there are no
801
conflicts, so no check is made.
804
conflicts = self.find_conflicts()
805
if len(conflicts) != 0:
806
raise MalformedTransform(conflicts=conflicts)
807
inv = self._tree.inventory
809
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
811
child_pb.update('Apply phase', 0, 2)
812
self._apply_removals(inv, inventory_delta)
813
child_pb.update('Apply phase', 1, 2)
814
modified_paths = self._apply_insertions(inv, inventory_delta)
817
self._tree.apply_inventory_delta(inventory_delta)
820
return _TransformResults(modified_paths, self.rename_count)
822
def _limbo_name(self, trans_id):
823
"""Generate the limbo name of a file"""
824
limbo_name = self._limbo_files.get(trans_id)
825
if limbo_name is not None:
827
parent = self._new_parent.get(trans_id)
828
# if the parent directory is already in limbo (e.g. when building a
829
# tree), choose a limbo name inside the parent, to reduce further
831
use_direct_path = False
832
if self._new_contents.get(parent) == 'directory':
833
filename = self._new_name.get(trans_id)
834
if filename is not None:
835
if parent not in self._limbo_children:
836
self._limbo_children[parent] = set()
837
self._limbo_children_names[parent] = {}
838
use_direct_path = True
839
# the direct path can only be used if no other file has
840
# already taken this pathname, i.e. if the name is unused, or
841
# if it is already associated with this trans_id.
842
elif (self._limbo_children_names[parent].get(filename)
843
in (trans_id, None)):
844
use_direct_path = True
846
limbo_name = pathjoin(self._limbo_files[parent], filename)
847
self._limbo_children[parent].add(trans_id)
848
self._limbo_children_names[parent][filename] = trans_id
850
limbo_name = pathjoin(self._limbodir, trans_id)
851
self._needs_rename.add(trans_id)
852
self._limbo_files[trans_id] = limbo_name
855
def _apply_removals(self, inv, inventory_delta):
856
"""Perform tree operations that remove directory/inventory names.
858
That is, delete files that are to be deleted, and put any files that
859
need renaming into limbo. This must be done in strict child-to-parent
862
tree_paths = list(self._tree_path_ids.iteritems())
863
tree_paths.sort(reverse=True)
864
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
866
for num, data in enumerate(tree_paths):
867
path, trans_id = data
868
child_pb.update('removing file', num, len(tree_paths))
869
full_path = self._tree.abspath(path)
870
if trans_id in self._removed_contents:
871
delete_any(full_path)
872
elif trans_id in self._new_name or trans_id in \
875
os.rename(full_path, self._limbo_name(trans_id))
877
if e.errno != errno.ENOENT:
880
self.rename_count += 1
881
if trans_id in self._removed_id:
882
if trans_id == self._new_root:
883
file_id = self._tree.inventory.root.file_id
885
file_id = self.tree_file_id(trans_id)
886
assert file_id is not None
887
inventory_delta.append((path, None, file_id, None))
891
def _apply_insertions(self, inv, inventory_delta):
892
"""Perform tree operations that insert directory/inventory names.
894
That is, create any files that need to be created, and restore from
895
limbo any files that needed renaming. This must be done in strict
896
parent-to-child order.
898
new_paths = self.new_paths()
900
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
902
for num, (path, trans_id) in enumerate(new_paths):
904
child_pb.update('adding file', num, len(new_paths))
906
kind = self._new_contents[trans_id]
908
kind = contents = None
909
if trans_id in self._new_contents or \
910
self.path_changed(trans_id):
911
full_path = self._tree.abspath(path)
912
if trans_id in self._needs_rename:
914
os.rename(self._limbo_name(trans_id), full_path)
916
# We may be renaming a dangling inventory id
917
if e.errno != errno.ENOENT:
920
self.rename_count += 1
921
if trans_id in self._new_contents:
922
modified_paths.append(full_path)
923
del self._new_contents[trans_id]
925
if trans_id in self._new_id:
927
kind = file_kind(self._tree.abspath(path))
928
if trans_id in self._new_reference_revision:
929
new_entry = inventory.TreeReference(
930
self._new_id[trans_id],
931
self._new_name[trans_id],
932
self.final_file_id(self._new_parent[trans_id]),
933
None, self._new_reference_revision[trans_id])
935
new_entry = inventory.make_entry(kind,
936
self.final_name(trans_id),
937
self.final_file_id(self.final_parent(trans_id)),
938
self._new_id[trans_id])
940
if trans_id in self._new_name or trans_id in\
942
trans_id in self._new_executability:
943
file_id = self.final_file_id(trans_id)
944
if file_id is not None:
946
new_entry = entry.copy()
948
if trans_id in self._new_name or trans_id in\
950
if new_entry is not None:
951
new_entry.name = self.final_name(trans_id)
952
parent = self.final_parent(trans_id)
953
parent_id = self.final_file_id(parent)
954
new_entry.parent_id = parent_id
956
if trans_id in self._new_executability:
957
self._set_executability(path, new_entry, trans_id)
958
if new_entry is not None:
959
if new_entry.file_id in inv:
960
old_path = inv.id2path(new_entry.file_id)
963
inventory_delta.append((old_path, path,
968
return modified_paths
970
def _set_executability(self, path, entry, trans_id):
971
"""Set the executability of versioned files """
972
new_executability = self._new_executability[trans_id]
973
entry.executable = new_executability
974
if supports_executable():
975
abspath = self._tree.abspath(path)
976
current_mode = os.stat(abspath).st_mode
977
if new_executability:
980
to_mode = current_mode | (0100 & ~umask)
981
# Enable x-bit for others only if they can read it.
982
if current_mode & 0004:
983
to_mode |= 0001 & ~umask
984
if current_mode & 0040:
985
to_mode |= 0010 & ~umask
987
to_mode = current_mode & ~0111
988
os.chmod(abspath, to_mode)
990
def _new_entry(self, name, parent_id, file_id):
991
"""Helper function to create a new filesystem entry."""
992
trans_id = self.create_path(name, parent_id)
993
if file_id is not None:
994
self.version_file(file_id, trans_id)
997
def new_file(self, name, parent_id, contents, file_id=None,
999
"""Convenience method to create files.
1001
name is the name of the file to create.
1002
parent_id is the transaction id of the parent directory of the file.
1003
contents is an iterator of bytestrings, which will be used to produce
1005
:param file_id: The inventory ID of the file, if it is to be versioned.
1006
:param executable: Only valid when a file_id has been supplied.
1008
trans_id = self._new_entry(name, parent_id, file_id)
1009
# TODO: rather than scheduling a set_executable call,
1010
# have create_file create the file with the right mode.
1011
self.create_file(contents, trans_id)
1012
if executable is not None:
1013
self.set_executability(executable, trans_id)
1016
def new_directory(self, name, parent_id, file_id=None):
1017
"""Convenience method to create directories.
1019
name is the name of the directory to create.
1020
parent_id is the transaction id of the parent directory of the
1022
file_id is the inventory ID of the directory, if it is to be versioned.
1024
trans_id = self._new_entry(name, parent_id, file_id)
1025
self.create_directory(trans_id)
1028
def new_symlink(self, name, parent_id, target, file_id=None):
1029
"""Convenience method to create symbolic link.
1031
name is the name of the symlink to create.
1032
parent_id is the transaction id of the parent directory of the symlink.
1033
target is a bytestring of the target of the symlink.
1034
file_id is the inventory ID of the file, if it is to be versioned.
1036
trans_id = self._new_entry(name, parent_id, file_id)
1037
self.create_symlink(target, trans_id)
1040
def _affected_ids(self):
1041
"""Return the set of transform ids affected by the transform"""
1042
trans_ids = set(self._removed_id)
1043
trans_ids.update(self._new_id.keys())
1044
trans_ids.update(self._removed_contents)
1045
trans_ids.update(self._new_contents.keys())
1046
trans_ids.update(self._new_executability.keys())
1047
trans_ids.update(self._new_name.keys())
1048
trans_ids.update(self._new_parent.keys())
1051
def _get_file_id_maps(self):
1052
"""Return mapping of file_ids to trans_ids in the to and from states"""
1053
trans_ids = self._affected_ids()
1056
# Build up two dicts: trans_ids associated with file ids in the
1057
# FROM state, vs the TO state.
1058
for trans_id in trans_ids:
1059
from_file_id = self.tree_file_id(trans_id)
1060
if from_file_id is not None:
1061
from_trans_ids[from_file_id] = trans_id
1062
to_file_id = self.final_file_id(trans_id)
1063
if to_file_id is not None:
1064
to_trans_ids[to_file_id] = trans_id
1065
return from_trans_ids, to_trans_ids
1067
def _from_file_data(self, from_trans_id, from_versioned, file_id):
1068
"""Get data about a file in the from (tree) state
1070
Return a (name, parent, kind, executable) tuple
1072
from_path = self._tree_id_paths.get(from_trans_id)
1074
# get data from working tree if versioned
1075
from_entry = self._tree.inventory[file_id]
1076
from_name = from_entry.name
1077
from_parent = from_entry.parent_id
1080
if from_path is None:
1081
# File does not exist in FROM state
1085
# File exists, but is not versioned. Have to use path-
1087
from_name = os.path.basename(from_path)
1088
tree_parent = self.get_tree_parent(from_trans_id)
1089
from_parent = self.tree_file_id(tree_parent)
1090
if from_path is not None:
1091
from_kind, from_executable, from_stats = \
1092
self._tree._comparison_data(from_entry, from_path)
1095
from_executable = False
1096
return from_name, from_parent, from_kind, from_executable
1098
def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
1099
"""Get data about a file in the to (target) state
1101
Return a (name, parent, kind, executable) tuple
1103
to_name = self.final_name(to_trans_id)
1105
to_kind = self.final_kind(to_trans_id)
1108
to_parent = self.final_file_id(self.final_parent(to_trans_id))
1109
if to_trans_id in self._new_executability:
1110
to_executable = self._new_executability[to_trans_id]
1111
elif to_trans_id == from_trans_id:
1112
to_executable = from_executable
1114
to_executable = False
1115
return to_name, to_parent, to_kind, to_executable
1117
def _iter_changes(self):
1118
"""Produce output in the same format as Tree._iter_changes.
1120
Will produce nonsensical results if invoked while inventory/filesystem
1121
conflicts (as reported by TreeTransform.find_conflicts()) are present.
1123
This reads the Transform, but only reproduces changes involving a
1124
file_id. Files that are not versioned in either of the FROM or TO
1125
states are not reflected.
1127
final_paths = FinalPaths(self)
1128
from_trans_ids, to_trans_ids = self._get_file_id_maps()
1130
# Now iterate through all active file_ids
1131
for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
1133
from_trans_id = from_trans_ids.get(file_id)
1134
# find file ids, and determine versioning state
1135
if from_trans_id is None:
1136
from_versioned = False
1137
from_trans_id = to_trans_ids[file_id]
1139
from_versioned = True
1140
to_trans_id = to_trans_ids.get(file_id)
1141
if to_trans_id is None:
1142
to_versioned = False
1143
to_trans_id = from_trans_id
1147
from_name, from_parent, from_kind, from_executable = \
1148
self._from_file_data(from_trans_id, from_versioned, file_id)
1150
to_name, to_parent, to_kind, to_executable = \
1151
self._to_file_data(to_trans_id, from_trans_id, from_executable)
1153
if not from_versioned:
1156
from_path = self._tree_id_paths.get(from_trans_id)
1157
if not to_versioned:
1160
to_path = final_paths.get_path(to_trans_id)
1161
if from_kind != to_kind:
1163
elif to_kind in ('file', 'symlink') and (
1164
to_trans_id != from_trans_id or
1165
to_trans_id in self._new_contents):
1167
if (not modified and from_versioned == to_versioned and
1168
from_parent==to_parent and from_name == to_name and
1169
from_executable == to_executable):
1171
results.append((file_id, (from_path, to_path), modified,
1172
(from_versioned, to_versioned),
1173
(from_parent, to_parent),
1174
(from_name, to_name),
1175
(from_kind, to_kind),
1176
(from_executable, to_executable)))
1177
return iter(sorted(results, key=lambda x:x[1]))
1180
def joinpath(parent, child):
1181
"""Join tree-relative paths, handling the tree root specially"""
1182
if parent is None or parent == "":
1185
return pathjoin(parent, child)
1188
class FinalPaths(object):
1189
"""Make path calculation cheap by memoizing paths.
1191
The underlying tree must not be manipulated between calls, or else
1192
the results will likely be incorrect.
1194
def __init__(self, transform):
1195
object.__init__(self)
1196
self._known_paths = {}
1197
self.transform = transform
1199
def _determine_path(self, trans_id):
1200
if trans_id == self.transform.root:
1202
name = self.transform.final_name(trans_id)
1203
parent_id = self.transform.final_parent(trans_id)
1204
if parent_id == self.transform.root:
1207
return pathjoin(self.get_path(parent_id), name)
1209
def get_path(self, trans_id):
1210
"""Find the final path associated with a trans_id"""
1211
if trans_id not in self._known_paths:
1212
self._known_paths[trans_id] = self._determine_path(trans_id)
1213
return self._known_paths[trans_id]
1215
def topology_sorted_ids(tree):
1216
"""Determine the topological order of the ids in a tree"""
1217
file_ids = list(tree)
1218
file_ids.sort(key=tree.id2path)
1222
def build_tree(tree, wt):
1223
"""Create working tree for a branch, using a TreeTransform.
1225
This function should be used on empty trees, having a tree root at most.
1226
(see merge and revert functionality for working with existing trees)
1228
Existing files are handled like so:
1230
- Existing bzrdirs take precedence over creating new items. They are
1231
created as '%s.diverted' % name.
1232
- Otherwise, if the content on disk matches the content we are building,
1233
it is silently replaced.
1234
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
1236
wt.lock_tree_write()
1240
return _build_tree(tree, wt)
1246
def _build_tree(tree, wt):
1247
"""See build_tree."""
1248
if len(wt.inventory) > 1: # more than just a root
1249
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
1251
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1252
pp = ProgressPhase("Build phase", 2, top_pb)
1253
if tree.inventory.root is not None:
1254
# This is kind of a hack: we should be altering the root
1255
# as part of the regular tree shape diff logic.
1256
# The conditional test here is to avoid doing an
1257
# expensive operation (flush) every time the root id
1258
# is set within the tree, nor setting the root and thus
1259
# marking the tree as dirty, because we use two different
1260
# idioms here: tree interfaces and inventory interfaces.
1261
if wt.path2id('') != tree.inventory.root.file_id:
1262
wt.set_root_id(tree.inventory.root.file_id)
1264
tt = TreeTransform(wt)
1268
file_trans_id[wt.get_root_id()] = \
1269
tt.trans_id_tree_file_id(wt.get_root_id())
1270
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1272
deferred_contents = []
1273
for num, (tree_path, entry) in \
1274
enumerate(tree.inventory.iter_entries_by_dir()):
1275
pb.update("Building tree", num - len(deferred_contents),
1276
len(tree.inventory))
1277
if entry.parent_id is None:
1280
file_id = entry.file_id
1281
target_path = wt.abspath(tree_path)
1283
kind = file_kind(target_path)
1287
if kind == "directory":
1289
bzrdir.BzrDir.open(target_path)
1290
except errors.NotBranchError:
1294
if (file_id not in divert and
1295
_content_match(tree, entry, file_id, kind,
1297
tt.delete_contents(tt.trans_id_tree_path(tree_path))
1298
if kind == 'directory':
1300
if entry.parent_id not in file_trans_id:
1301
raise AssertionError(
1302
'entry %s parent id %r is not in file_trans_id %r'
1303
% (entry, entry.parent_id, file_trans_id))
1304
parent_id = file_trans_id[entry.parent_id]
1305
if entry.kind == 'file':
1306
# We *almost* replicate new_by_entry, so that we can defer
1307
# getting the file text, and get them all at once.
1308
trans_id = tt.create_path(entry.name, parent_id)
1309
file_trans_id[file_id] = trans_id
1310
tt.version_file(entry.file_id, trans_id)
1311
executable = tree.is_executable(entry.file_id, tree_path)
1312
if executable is not None:
1313
tt.set_executability(executable, trans_id)
1314
deferred_contents.append((entry.file_id, trans_id))
1316
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1319
new_trans_id = file_trans_id[file_id]
1320
old_parent = tt.trans_id_tree_path(tree_path)
1321
_reparent_children(tt, old_parent, new_trans_id)
1322
for num, (trans_id, bytes) in enumerate(
1323
tree.iter_files_bytes(deferred_contents)):
1324
tt.create_file(bytes, trans_id)
1325
pb.update('Adding file contents',
1326
(num + len(tree.inventory) - len(deferred_contents)),
1327
len(tree.inventory))
1331
divert_trans = set(file_trans_id[f] for f in divert)
1332
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1333
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
1334
conflicts = cook_conflicts(raw_conflicts, tt)
1335
for conflict in conflicts:
1338
wt.add_conflicts(conflicts)
1339
except errors.UnsupportedOperation:
1348
def _reparent_children(tt, old_parent, new_parent):
1349
for child in tt.iter_tree_children(old_parent):
1350
tt.adjust_path(tt.final_name(child), new_parent, child)
1353
def _content_match(tree, entry, file_id, kind, target_path):
1354
if entry.kind != kind:
1356
if entry.kind == "directory":
1358
if entry.kind == "file":
1359
if tree.get_file(file_id).read() == file(target_path, 'rb').read():
1361
elif entry.kind == "symlink":
1362
if tree.get_symlink_target(file_id) == os.readlink(target_path):
1367
def resolve_checkout(tt, conflicts, divert):
1368
new_conflicts = set()
1369
for c_type, conflict in ((c[0], c) for c in conflicts):
1370
# Anything but a 'duplicate' would indicate programmer error
1371
assert c_type == 'duplicate', c_type
1372
# Now figure out which is new and which is old
1373
if tt.new_contents(conflict[1]):
1374
new_file = conflict[1]
1375
old_file = conflict[2]
1377
new_file = conflict[2]
1378
old_file = conflict[1]
1380
# We should only get here if the conflict wasn't completely
1382
final_parent = tt.final_parent(old_file)
1383
if new_file in divert:
1384
new_name = tt.final_name(old_file)+'.diverted'
1385
tt.adjust_path(new_name, final_parent, new_file)
1386
new_conflicts.add((c_type, 'Diverted to',
1387
new_file, old_file))
1389
new_name = tt.final_name(old_file)+'.moved'
1390
tt.adjust_path(new_name, final_parent, old_file)
1391
new_conflicts.add((c_type, 'Moved existing file to',
1392
old_file, new_file))
1393
return new_conflicts
1396
def new_by_entry(tt, entry, parent_id, tree):
1397
"""Create a new file according to its inventory entry"""
1401
contents = tree.get_file(entry.file_id).readlines()
1402
executable = tree.is_executable(entry.file_id)
1403
return tt.new_file(name, parent_id, contents, entry.file_id,
1405
elif kind in ('directory', 'tree-reference'):
1406
trans_id = tt.new_directory(name, parent_id, entry.file_id)
1407
if kind == 'tree-reference':
1408
tt.set_tree_reference(entry.reference_revision, trans_id)
1410
elif kind == 'symlink':
1411
target = tree.get_symlink_target(entry.file_id)
1412
return tt.new_symlink(name, parent_id, target, entry.file_id)
1414
raise errors.BadFileKindError(name, kind)
1416
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1417
"""Create new file contents according to an inventory entry."""
1418
if entry.kind == "file":
1420
lines = tree.get_file(entry.file_id).readlines()
1421
tt.create_file(lines, trans_id, mode_id=mode_id)
1422
elif entry.kind == "symlink":
1423
tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
1424
elif entry.kind == "directory":
1425
tt.create_directory(trans_id)
1427
def create_entry_executability(tt, entry, trans_id):
1428
"""Set the executability of a trans_id according to an inventory entry"""
1429
if entry.kind == "file":
1430
tt.set_executability(entry.executable, trans_id)
1433
@deprecated_function(zero_fifteen)
1434
def find_interesting(working_tree, target_tree, filenames):
1435
"""Find the ids corresponding to specified filenames.
1437
Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
1439
working_tree.lock_read()
1441
target_tree.lock_read()
1443
return working_tree.paths2ids(filenames, [target_tree])
1445
target_tree.unlock()
1447
working_tree.unlock()
1450
@deprecated_function(zero_ninety)
1451
def change_entry(tt, file_id, working_tree, target_tree,
1452
trans_id_file_id, backups, trans_id, by_parent):
1453
"""Replace a file_id's contents with those from a target tree."""
1454
if file_id is None and target_tree is None:
1455
# skip the logic altogether in the deprecation test
1457
e_trans_id = trans_id_file_id(file_id)
1458
entry = target_tree.inventory[file_id]
1459
has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry,
1462
mode_id = e_trans_id
1465
tt.delete_contents(e_trans_id)
1467
parent_trans_id = trans_id_file_id(entry.parent_id)
1468
backup_name = get_backup_name(entry, by_parent,
1469
parent_trans_id, tt)
1470
tt.adjust_path(backup_name, parent_trans_id, e_trans_id)
1471
tt.unversion_file(e_trans_id)
1472
e_trans_id = tt.create_path(entry.name, parent_trans_id)
1473
tt.version_file(file_id, e_trans_id)
1474
trans_id[file_id] = e_trans_id
1475
create_by_entry(tt, entry, target_tree, e_trans_id, mode_id=mode_id)
1476
create_entry_executability(tt, entry, e_trans_id)
1479
tt.set_executability(entry.executable, e_trans_id)
1480
if tt.final_name(e_trans_id) != entry.name:
1483
parent_id = tt.final_parent(e_trans_id)
1484
parent_file_id = tt.final_file_id(parent_id)
1485
if parent_file_id != entry.parent_id:
1490
parent_trans_id = trans_id_file_id(entry.parent_id)
1491
tt.adjust_path(entry.name, parent_trans_id, e_trans_id)
1494
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1495
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1498
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1499
"""Produce a backup-style name that appears to be available"""
1503
yield "%s.~%d~" % (name, counter)
1505
for new_name in name_gen():
1506
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
1510
def _entry_changes(file_id, entry, working_tree):
1511
"""Determine in which ways the inventory entry has changed.
1513
Returns booleans: has_contents, content_mod, meta_mod
1514
has_contents means there are currently contents, but they differ
1515
contents_mod means contents need to be modified
1516
meta_mod means the metadata needs to be modified
1518
cur_entry = working_tree.inventory[file_id]
1520
working_kind = working_tree.kind(file_id)
1523
has_contents = False
1526
if has_contents is True:
1527
if entry.kind != working_kind:
1528
contents_mod, meta_mod = True, False
1530
cur_entry._read_tree_state(working_tree.id2path(file_id),
1532
contents_mod, meta_mod = entry.detect_changes(cur_entry)
1533
cur_entry._forget_tree_state()
1534
return has_contents, contents_mod, meta_mod
1537
def revert(working_tree, target_tree, filenames, backups=False,
1538
pb=DummyProgress(), change_reporter=None):
1539
"""Revert a working tree's contents to those of a target tree."""
1540
target_tree.lock_read()
1541
tt = TreeTransform(working_tree, pb)
1543
pp = ProgressPhase("Revert phase", 3, pb)
1545
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1547
merge_modified = _alter_files(working_tree, target_tree, tt,
1548
child_pb, filenames, backups)
1552
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1554
raw_conflicts = resolve_conflicts(tt, child_pb)
1557
conflicts = cook_conflicts(raw_conflicts, tt)
1559
change_reporter = delta._ChangeReporter(
1560
unversioned_filter=working_tree.is_ignored)
1561
delta.report_changes(tt._iter_changes(), change_reporter)
1562
for conflict in conflicts:
1566
working_tree.set_merge_modified(merge_modified)
1568
target_tree.unlock()
1574
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1576
merge_modified = working_tree.merge_modified()
1577
change_list = target_tree._iter_changes(working_tree,
1578
specific_files=specific_files, pb=pb)
1579
if target_tree.inventory.root is None:
1586
for id_num, (file_id, path, changed_content, versioned, parent, name,
1587
kind, executable) in enumerate(change_list):
1588
if skip_root and file_id[0] is not None and parent[0] is None:
1590
trans_id = tt.trans_id_file_id(file_id)
1593
keep_content = False
1594
if kind[0] == 'file' and (backups or kind[1] is None):
1595
wt_sha1 = working_tree.get_file_sha1(file_id)
1596
if merge_modified.get(file_id) != wt_sha1:
1597
# acquire the basis tree lazily to prevent the
1598
# expense of accessing it when it's not needed ?
1599
# (Guessing, RBC, 200702)
1600
if basis_tree is None:
1601
basis_tree = working_tree.basis_tree()
1602
basis_tree.lock_read()
1603
if file_id in basis_tree:
1604
if wt_sha1 != basis_tree.get_file_sha1(file_id):
1606
elif kind[1] is None and not versioned[1]:
1608
if kind[0] is not None:
1609
if not keep_content:
1610
tt.delete_contents(trans_id)
1611
elif kind[1] is not None:
1612
parent_trans_id = tt.trans_id_file_id(parent[0])
1613
by_parent = tt.by_parent()
1614
backup_name = _get_backup_name(name[0], by_parent,
1615
parent_trans_id, tt)
1616
tt.adjust_path(backup_name, parent_trans_id, trans_id)
1617
new_trans_id = tt.create_path(name[0], parent_trans_id)
1618
if versioned == (True, True):
1619
tt.unversion_file(trans_id)
1620
tt.version_file(file_id, new_trans_id)
1621
# New contents should have the same unix perms as old
1624
trans_id = new_trans_id
1625
if kind[1] == 'directory':
1626
tt.create_directory(trans_id)
1627
elif kind[1] == 'symlink':
1628
tt.create_symlink(target_tree.get_symlink_target(file_id),
1630
elif kind[1] == 'file':
1631
deferred_files.append((file_id, (trans_id, mode_id)))
1632
if basis_tree is None:
1633
basis_tree = working_tree.basis_tree()
1634
basis_tree.lock_read()
1635
new_sha1 = target_tree.get_file_sha1(file_id)
1636
if (file_id in basis_tree and new_sha1 ==
1637
basis_tree.get_file_sha1(file_id)):
1638
if file_id in merge_modified:
1639
del merge_modified[file_id]
1641
merge_modified[file_id] = new_sha1
1643
# preserve the execute bit when backing up
1644
if keep_content and executable[0] == executable[1]:
1645
tt.set_executability(executable[1], trans_id)
1647
assert kind[1] is None
1648
if versioned == (False, True):
1649
tt.version_file(file_id, trans_id)
1650
if versioned == (True, False):
1651
tt.unversion_file(trans_id)
1652
if (name[1] is not None and
1653
(name[0] != name[1] or parent[0] != parent[1])):
1655
name[1], tt.trans_id_file_id(parent[1]), trans_id)
1656
if executable[0] != executable[1] and kind[1] == "file":
1657
tt.set_executability(executable[1], trans_id)
1658
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
1660
tt.create_file(bytes, trans_id, mode_id)
1662
if basis_tree is not None:
1664
return merge_modified
1667
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1668
"""Make many conflict-resolution attempts, but die if they fail"""
1669
if pass_func is None:
1670
pass_func = conflict_pass
1671
new_conflicts = set()
1674
pb.update('Resolution pass', n+1, 10)
1675
conflicts = tt.find_conflicts()
1676
if len(conflicts) == 0:
1677
return new_conflicts
1678
new_conflicts.update(pass_func(tt, conflicts))
1679
raise MalformedTransform(conflicts=conflicts)
1684
def conflict_pass(tt, conflicts, path_tree=None):
1685
"""Resolve some classes of conflicts.
1687
:param tt: The transform to resolve conflicts in
1688
:param conflicts: The conflicts to resolve
1689
:param path_tree: A Tree to get supplemental paths from
1691
new_conflicts = set()
1692
for c_type, conflict in ((c[0], c) for c in conflicts):
1693
if c_type == 'duplicate id':
1694
tt.unversion_file(conflict[1])
1695
new_conflicts.add((c_type, 'Unversioned existing file',
1696
conflict[1], conflict[2], ))
1697
elif c_type == 'duplicate':
1698
# files that were renamed take precedence
1699
new_name = tt.final_name(conflict[1])+'.moved'
1700
final_parent = tt.final_parent(conflict[1])
1701
if tt.path_changed(conflict[1]):
1702
tt.adjust_path(new_name, final_parent, conflict[2])
1703
new_conflicts.add((c_type, 'Moved existing file to',
1704
conflict[2], conflict[1]))
1706
tt.adjust_path(new_name, final_parent, conflict[1])
1707
new_conflicts.add((c_type, 'Moved existing file to',
1708
conflict[1], conflict[2]))
1709
elif c_type == 'parent loop':
1710
# break the loop by undoing one of the ops that caused the loop
1712
while not tt.path_changed(cur):
1713
cur = tt.final_parent(cur)
1714
new_conflicts.add((c_type, 'Cancelled move', cur,
1715
tt.final_parent(cur),))
1716
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
1718
elif c_type == 'missing parent':
1719
trans_id = conflict[1]
1721
tt.cancel_deletion(trans_id)
1722
new_conflicts.add(('deleting parent', 'Not deleting',
1725
tt.create_directory(trans_id)
1726
new_conflicts.add((c_type, 'Created directory', trans_id))
1728
tt.final_name(trans_id)
1730
file_id = tt.final_file_id(trans_id)
1731
entry = path_tree.inventory[file_id]
1732
parent_trans_id = tt.trans_id_file_id(entry.parent_id)
1733
tt.adjust_path(entry.name, parent_trans_id, trans_id)
1734
elif c_type == 'unversioned parent':
1735
tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1736
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1737
return new_conflicts
1740
def cook_conflicts(raw_conflicts, tt):
1741
"""Generate a list of cooked conflicts, sorted by file path"""
1742
from bzrlib.conflicts import Conflict
1743
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
1744
return sorted(conflict_iter, key=Conflict.sort_key)
1747
def iter_cook_conflicts(raw_conflicts, tt):
1748
from bzrlib.conflicts import Conflict
1750
for conflict in raw_conflicts:
1751
c_type = conflict[0]
1752
action = conflict[1]
1753
modified_path = fp.get_path(conflict[2])
1754
modified_id = tt.final_file_id(conflict[2])
1755
if len(conflict) == 3:
1756
yield Conflict.factory(c_type, action=action, path=modified_path,
1757
file_id=modified_id)
1760
conflicting_path = fp.get_path(conflict[3])
1761
conflicting_id = tt.final_file_id(conflict[3])
1762
yield Conflict.factory(c_type, action=action, path=modified_path,
1763
file_id=modified_id,
1764
conflict_path=conflicting_path,
1765
conflict_file_id=conflicting_id)
added
removed
bzrlib/transform.py
