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(tree.inventory))
1276
if entry.parent_id is None:
1279
file_id = entry.file_id
1280
target_path = wt.abspath(tree_path)
1282
kind = file_kind(target_path)
1286
if kind == "directory":
1288
bzrdir.BzrDir.open(target_path)
1289
except errors.NotBranchError:
1293
if (file_id not in divert and
1294
_content_match(tree, entry, file_id, kind,
1296
tt.delete_contents(tt.trans_id_tree_path(tree_path))
1297
if kind == 'directory':
1299
if entry.parent_id not in file_trans_id:
1300
raise AssertionError(
1301
'entry %s parent id %r is not in file_trans_id %r'
1302
% (entry, entry.parent_id, file_trans_id))
1303
parent_id = file_trans_id[entry.parent_id]
1304
if file_kind == 'file':
1305
# We *almost* replicate new_by_entry, so that we can defer
1306
# getting the file text, and get them all at once.
1307
trans_id = tt.create_path(entry.name, parent_id)
1308
self.version_file(entry.file_id, trans_id)
1309
executable = tree.is_executable(entry.file_id, tree_path)
1310
if executable is not None:
1311
tt.set_executability(executable)
1312
deferred_contents.append((entry.file_id, trans_id))
1314
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1317
new_trans_id = file_trans_id[file_id]
1318
old_parent = tt.trans_id_tree_path(tree_path)
1319
_reparent_children(tt, old_parent, new_trans_id)
1320
for trans_id, bytes in tree.iter_files_bytes(deferred_contents):
1321
tt.create_file(bytes, trans_id)
1325
divert_trans = set(file_trans_id[f] for f in divert)
1326
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1327
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
1328
conflicts = cook_conflicts(raw_conflicts, tt)
1329
for conflict in conflicts:
1332
wt.add_conflicts(conflicts)
1333
except errors.UnsupportedOperation:
1342
def _reparent_children(tt, old_parent, new_parent):
1343
for child in tt.iter_tree_children(old_parent):
1344
tt.adjust_path(tt.final_name(child), new_parent, child)
1347
def _content_match(tree, entry, file_id, kind, target_path):
1348
if entry.kind != kind:
1350
if entry.kind == "directory":
1352
if entry.kind == "file":
1353
if tree.get_file(file_id).read() == file(target_path, 'rb').read():
1355
elif entry.kind == "symlink":
1356
if tree.get_symlink_target(file_id) == os.readlink(target_path):
1361
def resolve_checkout(tt, conflicts, divert):
1362
new_conflicts = set()
1363
for c_type, conflict in ((c[0], c) for c in conflicts):
1364
# Anything but a 'duplicate' would indicate programmer error
1365
assert c_type == 'duplicate', c_type
1366
# Now figure out which is new and which is old
1367
if tt.new_contents(conflict[1]):
1368
new_file = conflict[1]
1369
old_file = conflict[2]
1371
new_file = conflict[2]
1372
old_file = conflict[1]
1374
# We should only get here if the conflict wasn't completely
1376
final_parent = tt.final_parent(old_file)
1377
if new_file in divert:
1378
new_name = tt.final_name(old_file)+'.diverted'
1379
tt.adjust_path(new_name, final_parent, new_file)
1380
new_conflicts.add((c_type, 'Diverted to',
1381
new_file, old_file))
1383
new_name = tt.final_name(old_file)+'.moved'
1384
tt.adjust_path(new_name, final_parent, old_file)
1385
new_conflicts.add((c_type, 'Moved existing file to',
1386
old_file, new_file))
1387
return new_conflicts
1390
def new_by_entry(tt, entry, parent_id, tree):
1391
"""Create a new file according to its inventory entry"""
1395
contents = tree.get_file(entry.file_id).readlines()
1396
executable = tree.is_executable(entry.file_id)
1397
return tt.new_file(name, parent_id, contents, entry.file_id,
1399
elif kind in ('directory', 'tree-reference'):
1400
trans_id = tt.new_directory(name, parent_id, entry.file_id)
1401
if kind == 'tree-reference':
1402
tt.set_tree_reference(entry.reference_revision, trans_id)
1404
elif kind == 'symlink':
1405
target = tree.get_symlink_target(entry.file_id)
1406
return tt.new_symlink(name, parent_id, target, entry.file_id)
1408
raise errors.BadFileKindError(name, kind)
1410
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1411
"""Create new file contents according to an inventory entry."""
1412
if entry.kind == "file":
1414
lines = tree.get_file(entry.file_id).readlines()
1415
tt.create_file(lines, trans_id, mode_id=mode_id)
1416
elif entry.kind == "symlink":
1417
tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
1418
elif entry.kind == "directory":
1419
tt.create_directory(trans_id)
1421
def create_entry_executability(tt, entry, trans_id):
1422
"""Set the executability of a trans_id according to an inventory entry"""
1423
if entry.kind == "file":
1424
tt.set_executability(entry.executable, trans_id)
1427
@deprecated_function(zero_fifteen)
1428
def find_interesting(working_tree, target_tree, filenames):
1429
"""Find the ids corresponding to specified filenames.
1431
Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
1433
working_tree.lock_read()
1435
target_tree.lock_read()
1437
return working_tree.paths2ids(filenames, [target_tree])
1439
target_tree.unlock()
1441
working_tree.unlock()
1444
@deprecated_function(zero_ninety)
1445
def change_entry(tt, file_id, working_tree, target_tree,
1446
trans_id_file_id, backups, trans_id, by_parent):
1447
"""Replace a file_id's contents with those from a target tree."""
1448
if file_id is None and target_tree is None:
1449
# skip the logic altogether in the deprecation test
1451
e_trans_id = trans_id_file_id(file_id)
1452
entry = target_tree.inventory[file_id]
1453
has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry,
1456
mode_id = e_trans_id
1459
tt.delete_contents(e_trans_id)
1461
parent_trans_id = trans_id_file_id(entry.parent_id)
1462
backup_name = get_backup_name(entry, by_parent,
1463
parent_trans_id, tt)
1464
tt.adjust_path(backup_name, parent_trans_id, e_trans_id)
1465
tt.unversion_file(e_trans_id)
1466
e_trans_id = tt.create_path(entry.name, parent_trans_id)
1467
tt.version_file(file_id, e_trans_id)
1468
trans_id[file_id] = e_trans_id
1469
create_by_entry(tt, entry, target_tree, e_trans_id, mode_id=mode_id)
1470
create_entry_executability(tt, entry, e_trans_id)
1473
tt.set_executability(entry.executable, e_trans_id)
1474
if tt.final_name(e_trans_id) != entry.name:
1477
parent_id = tt.final_parent(e_trans_id)
1478
parent_file_id = tt.final_file_id(parent_id)
1479
if parent_file_id != entry.parent_id:
1484
parent_trans_id = trans_id_file_id(entry.parent_id)
1485
tt.adjust_path(entry.name, parent_trans_id, e_trans_id)
1488
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1489
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1492
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1493
"""Produce a backup-style name that appears to be available"""
1497
yield "%s.~%d~" % (name, counter)
1499
for new_name in name_gen():
1500
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
1504
def _entry_changes(file_id, entry, working_tree):
1505
"""Determine in which ways the inventory entry has changed.
1507
Returns booleans: has_contents, content_mod, meta_mod
1508
has_contents means there are currently contents, but they differ
1509
contents_mod means contents need to be modified
1510
meta_mod means the metadata needs to be modified
1512
cur_entry = working_tree.inventory[file_id]
1514
working_kind = working_tree.kind(file_id)
1517
has_contents = False
1520
if has_contents is True:
1521
if entry.kind != working_kind:
1522
contents_mod, meta_mod = True, False
1524
cur_entry._read_tree_state(working_tree.id2path(file_id),
1526
contents_mod, meta_mod = entry.detect_changes(cur_entry)
1527
cur_entry._forget_tree_state()
1528
return has_contents, contents_mod, meta_mod
1531
def revert(working_tree, target_tree, filenames, backups=False,
1532
pb=DummyProgress(), change_reporter=None):
1533
"""Revert a working tree's contents to those of a target tree."""
1534
target_tree.lock_read()
1535
tt = TreeTransform(working_tree, pb)
1537
pp = ProgressPhase("Revert phase", 3, pb)
1539
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1541
merge_modified = _alter_files(working_tree, target_tree, tt,
1542
child_pb, filenames, backups)
1546
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1548
raw_conflicts = resolve_conflicts(tt, child_pb)
1551
conflicts = cook_conflicts(raw_conflicts, tt)
1553
change_reporter = delta._ChangeReporter(
1554
unversioned_filter=working_tree.is_ignored)
1555
delta.report_changes(tt._iter_changes(), change_reporter)
1556
for conflict in conflicts:
1560
working_tree.set_merge_modified(merge_modified)
1562
target_tree.unlock()
1568
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1570
merge_modified = working_tree.merge_modified()
1571
change_list = target_tree._iter_changes(working_tree,
1572
specific_files=specific_files, pb=pb)
1573
if target_tree.inventory.root is None:
1580
for id_num, (file_id, path, changed_content, versioned, parent, name,
1581
kind, executable) in enumerate(change_list):
1582
if skip_root and file_id[0] is not None and parent[0] is None:
1584
trans_id = tt.trans_id_file_id(file_id)
1587
keep_content = False
1588
if kind[0] == 'file' and (backups or kind[1] is None):
1589
wt_sha1 = working_tree.get_file_sha1(file_id)
1590
if merge_modified.get(file_id) != wt_sha1:
1591
# acquire the basis tree lazily to prevent the
1592
# expense of accessing it when it's not needed ?
1593
# (Guessing, RBC, 200702)
1594
if basis_tree is None:
1595
basis_tree = working_tree.basis_tree()
1596
basis_tree.lock_read()
1597
if file_id in basis_tree:
1598
if wt_sha1 != basis_tree.get_file_sha1(file_id):
1600
elif kind[1] is None and not versioned[1]:
1602
if kind[0] is not None:
1603
if not keep_content:
1604
tt.delete_contents(trans_id)
1605
elif kind[1] is not None:
1606
parent_trans_id = tt.trans_id_file_id(parent[0])
1607
by_parent = tt.by_parent()
1608
backup_name = _get_backup_name(name[0], by_parent,
1609
parent_trans_id, tt)
1610
tt.adjust_path(backup_name, parent_trans_id, trans_id)
1611
new_trans_id = tt.create_path(name[0], parent_trans_id)
1612
if versioned == (True, True):
1613
tt.unversion_file(trans_id)
1614
tt.version_file(file_id, new_trans_id)
1615
# New contents should have the same unix perms as old
1618
trans_id = new_trans_id
1619
if kind[1] == 'directory':
1620
tt.create_directory(trans_id)
1621
elif kind[1] == 'symlink':
1622
tt.create_symlink(target_tree.get_symlink_target(file_id),
1624
elif kind[1] == 'file':
1625
deferred_files.append((file_id, (trans_id, mode_id)))
1626
if basis_tree is None:
1627
basis_tree = working_tree.basis_tree()
1628
basis_tree.lock_read()
1629
new_sha1 = target_tree.get_file_sha1(file_id)
1630
if (file_id in basis_tree and new_sha1 ==
1631
basis_tree.get_file_sha1(file_id)):
1632
if file_id in merge_modified:
1633
del merge_modified[file_id]
1635
merge_modified[file_id] = new_sha1
1637
# preserve the execute bit when backing up
1638
if keep_content and executable[0] == executable[1]:
1639
tt.set_executability(executable[1], trans_id)
1641
assert kind[1] is None
1642
if versioned == (False, True):
1643
tt.version_file(file_id, trans_id)
1644
if versioned == (True, False):
1645
tt.unversion_file(trans_id)
1646
if (name[1] is not None and
1647
(name[0] != name[1] or parent[0] != parent[1])):
1649
name[1], tt.trans_id_file_id(parent[1]), trans_id)
1650
if executable[0] != executable[1] and kind[1] == "file":
1651
tt.set_executability(executable[1], trans_id)
1652
for (trans_id, mode_id), bytes in target_tree.extract_files_bytes(
1654
tt.create_file(bytes, trans_id, mode_id)
1656
if basis_tree is not None:
1658
return merge_modified
1661
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1662
"""Make many conflict-resolution attempts, but die if they fail"""
1663
if pass_func is None:
1664
pass_func = conflict_pass
1665
new_conflicts = set()
1668
pb.update('Resolution pass', n+1, 10)
1669
conflicts = tt.find_conflicts()
1670
if len(conflicts) == 0:
1671
return new_conflicts
1672
new_conflicts.update(pass_func(tt, conflicts))
1673
raise MalformedTransform(conflicts=conflicts)
1678
def conflict_pass(tt, conflicts, path_tree=None):
1679
"""Resolve some classes of conflicts.
1681
:param tt: The transform to resolve conflicts in
1682
:param conflicts: The conflicts to resolve
1683
:param path_tree: A Tree to get supplemental paths from
1685
new_conflicts = set()
1686
for c_type, conflict in ((c[0], c) for c in conflicts):
1687
if c_type == 'duplicate id':
1688
tt.unversion_file(conflict[1])
1689
new_conflicts.add((c_type, 'Unversioned existing file',
1690
conflict[1], conflict[2], ))
1691
elif c_type == 'duplicate':
1692
# files that were renamed take precedence
1693
new_name = tt.final_name(conflict[1])+'.moved'
1694
final_parent = tt.final_parent(conflict[1])
1695
if tt.path_changed(conflict[1]):
1696
tt.adjust_path(new_name, final_parent, conflict[2])
1697
new_conflicts.add((c_type, 'Moved existing file to',
1698
conflict[2], conflict[1]))
1700
tt.adjust_path(new_name, final_parent, conflict[1])
1701
new_conflicts.add((c_type, 'Moved existing file to',
1702
conflict[1], conflict[2]))
1703
elif c_type == 'parent loop':
1704
# break the loop by undoing one of the ops that caused the loop
1706
while not tt.path_changed(cur):
1707
cur = tt.final_parent(cur)
1708
new_conflicts.add((c_type, 'Cancelled move', cur,
1709
tt.final_parent(cur),))
1710
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
1712
elif c_type == 'missing parent':
1713
trans_id = conflict[1]
1715
tt.cancel_deletion(trans_id)
1716
new_conflicts.add(('deleting parent', 'Not deleting',
1719
tt.create_directory(trans_id)
1720
new_conflicts.add((c_type, 'Created directory', trans_id))
1722
tt.final_name(trans_id)
1724
file_id = tt.final_file_id(trans_id)
1725
entry = path_tree.inventory[file_id]
1726
parent_trans_id = tt.trans_id_file_id(entry.parent_id)
1727
tt.adjust_path(entry.name, parent_trans_id, trans_id)
1728
elif c_type == 'unversioned parent':
1729
tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1730
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1731
return new_conflicts
1734
def cook_conflicts(raw_conflicts, tt):
1735
"""Generate a list of cooked conflicts, sorted by file path"""
1736
from bzrlib.conflicts import Conflict
1737
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
1738
return sorted(conflict_iter, key=Conflict.sort_key)
1741
def iter_cook_conflicts(raw_conflicts, tt):
1742
from bzrlib.conflicts import Conflict
1744
for conflict in raw_conflicts:
1745
c_type = conflict[0]
1746
action = conflict[1]
1747
modified_path = fp.get_path(conflict[2])
1748
modified_id = tt.final_file_id(conflict[2])
1749
if len(conflict) == 3:
1750
yield Conflict.factory(c_type, action=action, path=modified_path,
1751
file_id=modified_id)
1754
conflicting_path = fp.get_path(conflict[3])
1755
conflicting_id = tt.final_file_id(conflict[3])
1756
yield Conflict.factory(c_type, action=action, path=modified_path,
1757
file_id=modified_id,
1758
conflict_path=conflicting_path,
1759
conflict_file_id=conflicting_id)
added
removed
bzrlib/transform.py
