1
# Copyright (C) 2006, 2007, 2008 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
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
29
revision as _mod_revision,
32
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
33
ReusingTransform, NotVersionedError, CantMoveRoot,
34
ExistingLimbo, ImmortalLimbo, NoFinalPath,
36
from bzrlib.inventory import InventoryEntry
37
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
38
delete_any, has_symlinks)
39
from bzrlib.progress import DummyProgress, ProgressPhase
40
from bzrlib.symbol_versioning import (
43
from bzrlib.trace import mutter, warning
44
from bzrlib import tree
46
import bzrlib.urlutils as urlutils
49
ROOT_PARENT = "root-parent"
52
def unique_add(map, key, value):
54
raise DuplicateKey(key=key)
58
class _TransformResults(object):
59
def __init__(self, modified_paths, rename_count):
61
self.modified_paths = modified_paths
62
self.rename_count = rename_count
65
class TreeTransformBase(object):
66
"""The base class for TreeTransform and TreeTransformBase"""
68
def __init__(self, tree, limbodir, pb=DummyProgress(),
72
:param tree: The tree that will be transformed, but not necessarily
74
:param limbodir: A directory where new files can be stored until
75
they are installed in their proper places
76
:param pb: A ProgressBar indicating how much progress is being made
77
:param case_sensitive: If True, the target of the transform is
78
case sensitive, not just case preserving.
82
self._limbodir = limbodir
83
self._deletiondir = None
85
# mapping of trans_id -> new basename
87
# mapping of trans_id -> new parent trans_id
89
# mapping of trans_id with new contents -> new file_kind
90
self._new_contents = {}
91
# A mapping of transform ids to their limbo filename
92
self._limbo_files = {}
93
# A mapping of transform ids to a set of the transform ids of children
94
# that their limbo directory has
95
self._limbo_children = {}
96
# Map transform ids to maps of child filename to child transform id
97
self._limbo_children_names = {}
98
# List of transform ids that need to be renamed from limbo into place
99
self._needs_rename = set()
100
# Set of trans_ids whose contents will be removed
101
self._removed_contents = set()
102
# Mapping of trans_id -> new execute-bit value
103
self._new_executability = {}
104
# Mapping of trans_id -> new tree-reference value
105
self._new_reference_revision = {}
106
# Mapping of trans_id -> new file_id
108
# Mapping of old file-id -> trans_id
109
self._non_present_ids = {}
110
# Mapping of new file_id -> trans_id
112
# Set of file_ids that will be removed
113
self._removed_id = set()
114
# Mapping of path in old tree -> trans_id
115
self._tree_path_ids = {}
116
# Mapping trans_id -> path in old tree
117
self._tree_id_paths = {}
118
# Cache of realpath results, to speed up canonical_path
120
# Cache of relpath results, to speed up canonical_path
122
# The trans_id that will be used as the tree root
123
self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
124
# Indictor of whether the transform has been applied
128
# Whether the target is case sensitive
129
self._case_sensitive_target = case_sensitive
130
# A counter of how many files have been renamed
131
self.rename_count = 0
133
def __get_root(self):
134
return self._new_root
136
root = property(__get_root)
139
"""Release the working tree lock, if held, clean up limbo dir.
141
This is required if apply has not been invoked, but can be invoked
144
if self._tree is None:
147
entries = [(self._limbo_name(t), t, k) for t, k in
148
self._new_contents.iteritems()]
149
entries.sort(reverse=True)
150
for path, trans_id, kind in entries:
151
if kind == "directory":
156
os.rmdir(self._limbodir)
158
# We don't especially care *why* the dir is immortal.
159
raise ImmortalLimbo(self._limbodir)
161
if self._deletiondir is not None:
162
os.rmdir(self._deletiondir)
164
raise errors.ImmortalPendingDeletion(self._deletiondir)
169
def _assign_id(self):
170
"""Produce a new tranform id"""
171
new_id = "new-%s" % self._id_number
175
def create_path(self, name, parent):
176
"""Assign a transaction id to a new path"""
177
trans_id = self._assign_id()
178
unique_add(self._new_name, trans_id, name)
179
unique_add(self._new_parent, trans_id, parent)
182
def adjust_path(self, name, parent, trans_id):
183
"""Change the path that is assigned to a transaction id."""
184
if trans_id == self._new_root:
186
previous_parent = self._new_parent.get(trans_id)
187
previous_name = self._new_name.get(trans_id)
188
self._new_name[trans_id] = name
189
self._new_parent[trans_id] = parent
190
if (trans_id in self._limbo_files and
191
trans_id not in self._needs_rename):
192
self._rename_in_limbo([trans_id])
193
self._limbo_children[previous_parent].remove(trans_id)
194
del self._limbo_children_names[previous_parent][previous_name]
196
def _rename_in_limbo(self, trans_ids):
197
"""Fix limbo names so that the right final path is produced.
199
This means we outsmarted ourselves-- we tried to avoid renaming
200
these files later by creating them with their final names in their
201
final parents. But now the previous name or parent is no longer
202
suitable, so we have to rename them.
204
Even for trans_ids that have no new contents, we must remove their
205
entries from _limbo_files, because they are now stale.
207
for trans_id in trans_ids:
208
old_path = self._limbo_files.pop(trans_id)
209
if trans_id not in self._new_contents:
211
new_path = self._limbo_name(trans_id)
212
os.rename(old_path, new_path)
214
def adjust_root_path(self, name, parent):
215
"""Emulate moving the root by moving all children, instead.
217
We do this by undoing the association of root's transaction id with the
218
current tree. This allows us to create a new directory with that
219
transaction id. We unversion the root directory and version the
220
physically new directory, and hope someone versions the tree root
223
old_root = self._new_root
224
old_root_file_id = self.final_file_id(old_root)
225
# force moving all children of root
226
for child_id in self.iter_tree_children(old_root):
227
if child_id != parent:
228
self.adjust_path(self.final_name(child_id),
229
self.final_parent(child_id), child_id)
230
file_id = self.final_file_id(child_id)
231
if file_id is not None:
232
self.unversion_file(child_id)
233
self.version_file(file_id, child_id)
235
# the physical root needs a new transaction id
236
self._tree_path_ids.pop("")
237
self._tree_id_paths.pop(old_root)
238
self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
239
if parent == old_root:
240
parent = self._new_root
241
self.adjust_path(name, parent, old_root)
242
self.create_directory(old_root)
243
self.version_file(old_root_file_id, old_root)
244
self.unversion_file(self._new_root)
246
def trans_id_tree_file_id(self, inventory_id):
247
"""Determine the transaction id of a working tree file.
249
This reflects only files that already exist, not ones that will be
250
added by transactions.
252
path = self._tree.id2path(inventory_id)
253
return self.trans_id_tree_path(path)
255
def trans_id_file_id(self, file_id):
256
"""Determine or set the transaction id associated with a file ID.
257
A new id is only created for file_ids that were never present. If
258
a transaction has been unversioned, it is deliberately still returned.
259
(this will likely lead to an unversioned parent conflict.)
261
if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
262
return self._r_new_id[file_id]
263
elif file_id in self._tree.inventory:
264
return self.trans_id_tree_file_id(file_id)
265
elif file_id in self._non_present_ids:
266
return self._non_present_ids[file_id]
268
trans_id = self._assign_id()
269
self._non_present_ids[file_id] = trans_id
272
def canonical_path(self, path):
273
"""Get the canonical tree-relative path"""
274
# don't follow final symlinks
275
abs = self._tree.abspath(path)
276
if abs in self._relpaths:
277
return self._relpaths[abs]
278
dirname, basename = os.path.split(abs)
279
if dirname not in self._realpaths:
280
self._realpaths[dirname] = os.path.realpath(dirname)
281
dirname = self._realpaths[dirname]
282
abs = pathjoin(dirname, basename)
283
if dirname in self._relpaths:
284
relpath = pathjoin(self._relpaths[dirname], basename)
285
relpath = relpath.rstrip('/\\')
287
relpath = self._tree.relpath(abs)
288
self._relpaths[abs] = relpath
291
def trans_id_tree_path(self, path):
292
"""Determine (and maybe set) the transaction ID for a tree path."""
293
path = self.canonical_path(path)
294
if path not in self._tree_path_ids:
295
self._tree_path_ids[path] = self._assign_id()
296
self._tree_id_paths[self._tree_path_ids[path]] = path
297
return self._tree_path_ids[path]
299
def get_tree_parent(self, trans_id):
300
"""Determine id of the parent in the tree."""
301
path = self._tree_id_paths[trans_id]
304
return self.trans_id_tree_path(os.path.dirname(path))
306
def create_file(self, contents, trans_id, mode_id=None):
307
"""Schedule creation of a new file.
311
Contents is an iterator of strings, all of which will be written
312
to the target destination.
314
New file takes the permissions of any existing file with that id,
315
unless mode_id is specified.
317
name = self._limbo_name(trans_id)
321
unique_add(self._new_contents, trans_id, 'file')
323
# Clean up the file, it never got registered so
324
# TreeTransform.finalize() won't clean it up.
329
f.writelines(contents)
332
self._set_mode(trans_id, mode_id, S_ISREG)
334
def _set_mode(self, trans_id, mode_id, typefunc):
335
"""Set the mode of new file contents.
336
The mode_id is the existing file to get the mode from (often the same
337
as trans_id). The operation is only performed if there's a mode match
338
according to typefunc.
343
old_path = self._tree_id_paths[mode_id]
347
mode = os.stat(self._tree.abspath(old_path)).st_mode
349
if e.errno == errno.ENOENT:
354
os.chmod(self._limbo_name(trans_id), mode)
356
def create_hardlink(self, path, trans_id):
357
"""Schedule creation of a hard link"""
358
name = self._limbo_name(trans_id)
362
if e.errno != errno.EPERM:
364
raise errors.HardLinkNotSupported(path)
366
unique_add(self._new_contents, trans_id, 'file')
368
# Clean up the file, it never got registered so
369
# TreeTransform.finalize() won't clean it up.
373
def create_directory(self, trans_id):
374
"""Schedule creation of a new directory.
376
See also new_directory.
378
os.mkdir(self._limbo_name(trans_id))
379
unique_add(self._new_contents, trans_id, 'directory')
381
def create_symlink(self, target, trans_id):
382
"""Schedule creation of a new symbolic link.
384
target is a bytestring.
385
See also new_symlink.
388
os.symlink(target, self._limbo_name(trans_id))
389
unique_add(self._new_contents, trans_id, 'symlink')
392
path = FinalPaths(self).get_path(trans_id)
395
raise UnableCreateSymlink(path=path)
397
def cancel_creation(self, trans_id):
398
"""Cancel the creation of new file contents."""
399
del self._new_contents[trans_id]
400
children = self._limbo_children.get(trans_id)
401
# if this is a limbo directory with children, move them before removing
403
if children is not None:
404
self._rename_in_limbo(children)
405
del self._limbo_children[trans_id]
406
del self._limbo_children_names[trans_id]
407
delete_any(self._limbo_name(trans_id))
409
def delete_contents(self, trans_id):
410
"""Schedule the contents of a path entry for deletion"""
411
self.tree_kind(trans_id)
412
self._removed_contents.add(trans_id)
414
def cancel_deletion(self, trans_id):
415
"""Cancel a scheduled deletion"""
416
self._removed_contents.remove(trans_id)
418
def unversion_file(self, trans_id):
419
"""Schedule a path entry to become unversioned"""
420
self._removed_id.add(trans_id)
422
def delete_versioned(self, trans_id):
423
"""Delete and unversion a versioned file"""
424
self.delete_contents(trans_id)
425
self.unversion_file(trans_id)
427
def set_executability(self, executability, trans_id):
428
"""Schedule setting of the 'execute' bit
429
To unschedule, set to None
431
if executability is None:
432
del self._new_executability[trans_id]
434
unique_add(self._new_executability, trans_id, executability)
436
def set_tree_reference(self, revision_id, trans_id):
437
"""Set the reference associated with a directory"""
438
unique_add(self._new_reference_revision, trans_id, revision_id)
440
def version_file(self, file_id, trans_id):
441
"""Schedule a file to become versioned."""
444
unique_add(self._new_id, trans_id, file_id)
445
unique_add(self._r_new_id, file_id, trans_id)
447
def cancel_versioning(self, trans_id):
448
"""Undo a previous versioning of a file"""
449
file_id = self._new_id[trans_id]
450
del self._new_id[trans_id]
451
del self._r_new_id[file_id]
453
def new_paths(self, filesystem_only=False):
454
"""Determine the paths of all new and changed files.
456
:param filesystem_only: if True, only calculate values for files
457
that require renames or execute bit changes.
461
id_sets = (self._needs_rename, self._new_executability)
463
id_sets = (self._new_name, self._new_parent, self._new_contents,
464
self._new_id, self._new_executability)
465
for id_set in id_sets:
466
new_ids.update(id_set)
467
return sorted(FinalPaths(self).get_paths(new_ids))
469
def tree_kind(self, trans_id):
470
"""Determine the file kind in the working tree.
472
Raises NoSuchFile if the file does not exist
474
path = self._tree_id_paths.get(trans_id)
476
raise NoSuchFile(None)
478
return file_kind(self._tree.abspath(path))
480
if e.errno != errno.ENOENT:
483
raise NoSuchFile(path)
485
def final_kind(self, trans_id):
486
"""Determine the final file kind, after any changes applied.
488
Raises NoSuchFile if the file does not exist/has no contents.
489
(It is conceivable that a path would be created without the
490
corresponding contents insertion command)
492
if trans_id in self._new_contents:
493
return self._new_contents[trans_id]
494
elif trans_id in self._removed_contents:
495
raise NoSuchFile(None)
497
return self.tree_kind(trans_id)
499
def tree_file_id(self, trans_id):
500
"""Determine the file id associated with the trans_id in the tree"""
502
path = self._tree_id_paths[trans_id]
504
# the file is a new, unversioned file, or invalid trans_id
506
# the file is old; the old id is still valid
507
if self._new_root == trans_id:
508
return self._tree.get_root_id()
509
return self._tree.inventory.path2id(path)
511
def final_file_id(self, trans_id):
512
"""Determine the file id after any changes are applied, or None.
514
None indicates that the file will not be versioned after changes are
518
return self._new_id[trans_id]
520
if trans_id in self._removed_id:
522
return self.tree_file_id(trans_id)
524
def inactive_file_id(self, trans_id):
525
"""Return the inactive file_id associated with a transaction id.
526
That is, the one in the tree or in non_present_ids.
527
The file_id may actually be active, too.
529
file_id = self.tree_file_id(trans_id)
530
if file_id is not None:
532
for key, value in self._non_present_ids.iteritems():
533
if value == trans_id:
536
def final_parent(self, trans_id):
537
"""Determine the parent file_id, after any changes are applied.
539
ROOT_PARENT is returned for the tree root.
542
return self._new_parent[trans_id]
544
return self.get_tree_parent(trans_id)
546
def final_name(self, trans_id):
547
"""Determine the final filename, after all changes are applied."""
549
return self._new_name[trans_id]
552
return os.path.basename(self._tree_id_paths[trans_id])
554
raise NoFinalPath(trans_id, self)
557
"""Return a map of parent: children for known parents.
559
Only new paths and parents of tree files with assigned ids are used.
562
items = list(self._new_parent.iteritems())
563
items.extend((t, self.final_parent(t)) for t in
564
self._tree_id_paths.keys())
565
for trans_id, parent_id in items:
566
if parent_id not in by_parent:
567
by_parent[parent_id] = set()
568
by_parent[parent_id].add(trans_id)
571
def path_changed(self, trans_id):
572
"""Return True if a trans_id's path has changed."""
573
return (trans_id in self._new_name) or (trans_id in self._new_parent)
575
def new_contents(self, trans_id):
576
return (trans_id in self._new_contents)
578
def find_conflicts(self):
579
"""Find any violations of inventory or filesystem invariants"""
580
if self._done is True:
581
raise ReusingTransform()
583
# ensure all children of all existent parents are known
584
# all children of non-existent parents are known, by definition.
585
self._add_tree_children()
586
by_parent = self.by_parent()
587
conflicts.extend(self._unversioned_parents(by_parent))
588
conflicts.extend(self._parent_loops())
589
conflicts.extend(self._duplicate_entries(by_parent))
590
conflicts.extend(self._duplicate_ids())
591
conflicts.extend(self._parent_type_conflicts(by_parent))
592
conflicts.extend(self._improper_versioning())
593
conflicts.extend(self._executability_conflicts())
594
conflicts.extend(self._overwrite_conflicts())
597
def _add_tree_children(self):
598
"""Add all the children of all active parents to the known paths.
600
Active parents are those which gain children, and those which are
601
removed. This is a necessary first step in detecting conflicts.
603
parents = self.by_parent().keys()
604
parents.extend([t for t in self._removed_contents if
605
self.tree_kind(t) == 'directory'])
606
for trans_id in self._removed_id:
607
file_id = self.tree_file_id(trans_id)
608
if file_id is not None:
609
if self._tree.inventory[file_id].kind == 'directory':
610
parents.append(trans_id)
611
elif self.tree_kind(trans_id) == 'directory':
612
parents.append(trans_id)
614
for parent_id in parents:
615
# ensure that all children are registered with the transaction
616
list(self.iter_tree_children(parent_id))
618
def iter_tree_children(self, parent_id):
619
"""Iterate through the entry's tree children, if any"""
621
path = self._tree_id_paths[parent_id]
625
children = os.listdir(self._tree.abspath(path))
627
if e.errno not in (errno.ENOENT, errno.ESRCH, errno.ENOTDIR):
631
for child in children:
632
childpath = joinpath(path, child)
633
if self._tree.is_control_filename(childpath):
635
yield self.trans_id_tree_path(childpath)
637
def has_named_child(self, by_parent, parent_id, name):
639
children = by_parent[parent_id]
642
for child in children:
643
if self.final_name(child) == name:
646
path = self._tree_id_paths[parent_id]
649
childpath = joinpath(path, name)
650
child_id = self._tree_path_ids.get(childpath)
652
return lexists(self._tree.abspath(childpath))
654
if self.final_parent(child_id) != parent_id:
656
if child_id in self._removed_contents:
657
# XXX What about dangling file-ids?
662
def _parent_loops(self):
663
"""No entry should be its own ancestor"""
665
for trans_id in self._new_parent:
668
while parent_id is not ROOT_PARENT:
671
parent_id = self.final_parent(parent_id)
674
if parent_id == trans_id:
675
conflicts.append(('parent loop', trans_id))
676
if parent_id in seen:
680
def _unversioned_parents(self, by_parent):
681
"""If parent directories are versioned, children must be versioned."""
683
for parent_id, children in by_parent.iteritems():
684
if parent_id is ROOT_PARENT:
686
if self.final_file_id(parent_id) is not None:
688
for child_id in children:
689
if self.final_file_id(child_id) is not None:
690
conflicts.append(('unversioned parent', parent_id))
694
def _improper_versioning(self):
695
"""Cannot version a file with no contents, or a bad type.
697
However, existing entries with no contents are okay.
700
for trans_id in self._new_id.iterkeys():
702
kind = self.final_kind(trans_id)
704
conflicts.append(('versioning no contents', trans_id))
706
if not InventoryEntry.versionable_kind(kind):
707
conflicts.append(('versioning bad kind', trans_id, kind))
710
def _executability_conflicts(self):
711
"""Check for bad executability changes.
713
Only versioned files may have their executability set, because
714
1. only versioned entries can have executability under windows
715
2. only files can be executable. (The execute bit on a directory
716
does not indicate searchability)
719
for trans_id in self._new_executability:
720
if self.final_file_id(trans_id) is None:
721
conflicts.append(('unversioned executability', trans_id))
724
non_file = self.final_kind(trans_id) != "file"
728
conflicts.append(('non-file executability', trans_id))
731
def _overwrite_conflicts(self):
732
"""Check for overwrites (not permitted on Win32)"""
734
for trans_id in self._new_contents:
736
self.tree_kind(trans_id)
739
if trans_id not in self._removed_contents:
740
conflicts.append(('overwrite', trans_id,
741
self.final_name(trans_id)))
744
def _duplicate_entries(self, by_parent):
745
"""No directory may have two entries with the same name."""
747
if (self._new_name, self._new_parent) == ({}, {}):
749
for children in by_parent.itervalues():
750
name_ids = [(self.final_name(t), t) for t in children]
751
if not self._case_sensitive_target:
752
name_ids = [(n.lower(), t) for n, t in name_ids]
756
for name, trans_id in name_ids:
758
kind = self.final_kind(trans_id)
761
file_id = self.final_file_id(trans_id)
762
if kind is None and file_id is None:
764
if name == last_name:
765
conflicts.append(('duplicate', last_trans_id, trans_id,
768
last_trans_id = trans_id
771
def _duplicate_ids(self):
772
"""Each inventory id may only be used once"""
774
removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
776
all_ids = self._tree.all_file_ids()
777
active_tree_ids = all_ids.difference(removed_tree_ids)
778
for trans_id, file_id in self._new_id.iteritems():
779
if file_id in active_tree_ids:
780
old_trans_id = self.trans_id_tree_file_id(file_id)
781
conflicts.append(('duplicate id', old_trans_id, trans_id))
784
def _parent_type_conflicts(self, by_parent):
785
"""parents must have directory 'contents'."""
787
for parent_id, children in by_parent.iteritems():
788
if parent_id is ROOT_PARENT:
790
if not self._any_contents(children):
792
for child in children:
794
self.final_kind(child)
798
kind = self.final_kind(parent_id)
802
conflicts.append(('missing parent', parent_id))
803
elif kind != "directory":
804
conflicts.append(('non-directory parent', parent_id))
807
def _any_contents(self, trans_ids):
808
"""Return true if any of the trans_ids, will have contents."""
809
for trans_id in trans_ids:
811
kind = self.final_kind(trans_id)
817
def _limbo_name(self, trans_id):
818
"""Generate the limbo name of a file"""
819
limbo_name = self._limbo_files.get(trans_id)
820
if limbo_name is not None:
822
parent = self._new_parent.get(trans_id)
823
# if the parent directory is already in limbo (e.g. when building a
824
# tree), choose a limbo name inside the parent, to reduce further
826
use_direct_path = False
827
if self._new_contents.get(parent) == 'directory':
828
filename = self._new_name.get(trans_id)
829
if filename is not None:
830
if parent not in self._limbo_children:
831
self._limbo_children[parent] = set()
832
self._limbo_children_names[parent] = {}
833
use_direct_path = True
834
# the direct path can only be used if no other file has
835
# already taken this pathname, i.e. if the name is unused, or
836
# if it is already associated with this trans_id.
837
elif self._case_sensitive_target:
838
if (self._limbo_children_names[parent].get(filename)
839
in (trans_id, None)):
840
use_direct_path = True
842
for l_filename, l_trans_id in\
843
self._limbo_children_names[parent].iteritems():
844
if l_trans_id == trans_id:
846
if l_filename.lower() == filename.lower():
849
use_direct_path = True
852
limbo_name = pathjoin(self._limbo_files[parent], filename)
853
self._limbo_children[parent].add(trans_id)
854
self._limbo_children_names[parent][filename] = trans_id
856
limbo_name = pathjoin(self._limbodir, trans_id)
857
self._needs_rename.add(trans_id)
858
self._limbo_files[trans_id] = limbo_name
861
def _set_executability(self, path, entry, trans_id):
862
"""Set the executability of versioned files """
863
new_executability = self._new_executability[trans_id]
864
if entry is not None:
865
entry.executable = new_executability
866
if supports_executable():
867
abspath = self._tree.abspath(path)
868
current_mode = os.stat(abspath).st_mode
869
if new_executability:
872
to_mode = current_mode | (0100 & ~umask)
873
# Enable x-bit for others only if they can read it.
874
if current_mode & 0004:
875
to_mode |= 0001 & ~umask
876
if current_mode & 0040:
877
to_mode |= 0010 & ~umask
879
to_mode = current_mode & ~0111
880
os.chmod(abspath, to_mode)
882
def _new_entry(self, name, parent_id, file_id):
883
"""Helper function to create a new filesystem entry."""
884
trans_id = self.create_path(name, parent_id)
885
if file_id is not None:
886
self.version_file(file_id, trans_id)
889
def new_file(self, name, parent_id, contents, file_id=None,
891
"""Convenience method to create files.
893
name is the name of the file to create.
894
parent_id is the transaction id of the parent directory of the file.
895
contents is an iterator of bytestrings, which will be used to produce
897
:param file_id: The inventory ID of the file, if it is to be versioned.
898
:param executable: Only valid when a file_id has been supplied.
900
trans_id = self._new_entry(name, parent_id, file_id)
901
# TODO: rather than scheduling a set_executable call,
902
# have create_file create the file with the right mode.
903
self.create_file(contents, trans_id)
904
if executable is not None:
905
self.set_executability(executable, trans_id)
908
def new_directory(self, name, parent_id, file_id=None):
909
"""Convenience method to create directories.
911
name is the name of the directory to create.
912
parent_id is the transaction id of the parent directory of the
914
file_id is the inventory ID of the directory, if it is to be versioned.
916
trans_id = self._new_entry(name, parent_id, file_id)
917
self.create_directory(trans_id)
920
def new_symlink(self, name, parent_id, target, file_id=None):
921
"""Convenience method to create symbolic link.
923
name is the name of the symlink to create.
924
parent_id is the transaction id of the parent directory of the symlink.
925
target is a bytestring of the target of the symlink.
926
file_id is the inventory ID of the file, if it is to be versioned.
928
trans_id = self._new_entry(name, parent_id, file_id)
929
self.create_symlink(target, trans_id)
932
def _affected_ids(self):
933
"""Return the set of transform ids affected by the transform"""
934
trans_ids = set(self._removed_id)
935
trans_ids.update(self._new_id.keys())
936
trans_ids.update(self._removed_contents)
937
trans_ids.update(self._new_contents.keys())
938
trans_ids.update(self._new_executability.keys())
939
trans_ids.update(self._new_name.keys())
940
trans_ids.update(self._new_parent.keys())
943
def _get_file_id_maps(self):
944
"""Return mapping of file_ids to trans_ids in the to and from states"""
945
trans_ids = self._affected_ids()
948
# Build up two dicts: trans_ids associated with file ids in the
949
# FROM state, vs the TO state.
950
for trans_id in trans_ids:
951
from_file_id = self.tree_file_id(trans_id)
952
if from_file_id is not None:
953
from_trans_ids[from_file_id] = trans_id
954
to_file_id = self.final_file_id(trans_id)
955
if to_file_id is not None:
956
to_trans_ids[to_file_id] = trans_id
957
return from_trans_ids, to_trans_ids
959
def _from_file_data(self, from_trans_id, from_versioned, file_id):
960
"""Get data about a file in the from (tree) state
962
Return a (name, parent, kind, executable) tuple
964
from_path = self._tree_id_paths.get(from_trans_id)
966
# get data from working tree if versioned
967
from_entry = self._tree.inventory[file_id]
968
from_name = from_entry.name
969
from_parent = from_entry.parent_id
972
if from_path is None:
973
# File does not exist in FROM state
977
# File exists, but is not versioned. Have to use path-
979
from_name = os.path.basename(from_path)
980
tree_parent = self.get_tree_parent(from_trans_id)
981
from_parent = self.tree_file_id(tree_parent)
982
if from_path is not None:
983
from_kind, from_executable, from_stats = \
984
self._tree._comparison_data(from_entry, from_path)
987
from_executable = False
988
return from_name, from_parent, from_kind, from_executable
990
def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
991
"""Get data about a file in the to (target) state
993
Return a (name, parent, kind, executable) tuple
995
to_name = self.final_name(to_trans_id)
997
to_kind = self.final_kind(to_trans_id)
1000
to_parent = self.final_file_id(self.final_parent(to_trans_id))
1001
if to_trans_id in self._new_executability:
1002
to_executable = self._new_executability[to_trans_id]
1003
elif to_trans_id == from_trans_id:
1004
to_executable = from_executable
1006
to_executable = False
1007
return to_name, to_parent, to_kind, to_executable
1009
def iter_changes(self):
1010
"""Produce output in the same format as Tree.iter_changes.
1012
Will produce nonsensical results if invoked while inventory/filesystem
1013
conflicts (as reported by TreeTransform.find_conflicts()) are present.
1015
This reads the Transform, but only reproduces changes involving a
1016
file_id. Files that are not versioned in either of the FROM or TO
1017
states are not reflected.
1019
final_paths = FinalPaths(self)
1020
from_trans_ids, to_trans_ids = self._get_file_id_maps()
1022
# Now iterate through all active file_ids
1023
for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
1025
from_trans_id = from_trans_ids.get(file_id)
1026
# find file ids, and determine versioning state
1027
if from_trans_id is None:
1028
from_versioned = False
1029
from_trans_id = to_trans_ids[file_id]
1031
from_versioned = True
1032
to_trans_id = to_trans_ids.get(file_id)
1033
if to_trans_id is None:
1034
to_versioned = False
1035
to_trans_id = from_trans_id
1039
from_name, from_parent, from_kind, from_executable = \
1040
self._from_file_data(from_trans_id, from_versioned, file_id)
1042
to_name, to_parent, to_kind, to_executable = \
1043
self._to_file_data(to_trans_id, from_trans_id, from_executable)
1045
if not from_versioned:
1048
from_path = self._tree_id_paths.get(from_trans_id)
1049
if not to_versioned:
1052
to_path = final_paths.get_path(to_trans_id)
1053
if from_kind != to_kind:
1055
elif to_kind in ('file', 'symlink') and (
1056
to_trans_id != from_trans_id or
1057
to_trans_id in self._new_contents):
1059
if (not modified and from_versioned == to_versioned and
1060
from_parent==to_parent and from_name == to_name and
1061
from_executable == to_executable):
1063
results.append((file_id, (from_path, to_path), modified,
1064
(from_versioned, to_versioned),
1065
(from_parent, to_parent),
1066
(from_name, to_name),
1067
(from_kind, to_kind),
1068
(from_executable, to_executable)))
1069
return iter(sorted(results, key=lambda x:x[1]))
1071
def get_preview_tree(self):
1072
"""Return a tree representing the result of the transform.
1074
This tree only supports the subset of Tree functionality required
1075
by show_diff_trees. It must only be compared to tt._tree.
1077
return _PreviewTree(self)
1080
class TreeTransform(TreeTransformBase):
1081
"""Represent a tree transformation.
1083
This object is designed to support incremental generation of the transform,
1086
However, it gives optimum performance when parent directories are created
1087
before their contents. The transform is then able to put child files
1088
directly in their parent directory, avoiding later renames.
1090
It is easy to produce malformed transforms, but they are generally
1091
harmless. Attempting to apply a malformed transform will cause an
1092
exception to be raised before any modifications are made to the tree.
1094
Many kinds of malformed transforms can be corrected with the
1095
resolve_conflicts function. The remaining ones indicate programming error,
1096
such as trying to create a file with no path.
1098
Two sets of file creation methods are supplied. Convenience methods are:
1103
These are composed of the low-level methods:
1105
* create_file or create_directory or create_symlink
1109
Transform/Transaction ids
1110
-------------------------
1111
trans_ids are temporary ids assigned to all files involved in a transform.
1112
It's possible, even common, that not all files in the Tree have trans_ids.
1114
trans_ids are used because filenames and file_ids are not good enough
1115
identifiers; filenames change, and not all files have file_ids. File-ids
1116
are also associated with trans-ids, so that moving a file moves its
1119
trans_ids are only valid for the TreeTransform that generated them.
1123
Limbo is a temporary directory use to hold new versions of files.
1124
Files are added to limbo by create_file, create_directory, create_symlink,
1125
and their convenience variants (new_*). Files may be removed from limbo
1126
using cancel_creation. Files are renamed from limbo into their final
1127
location as part of TreeTransform.apply
1129
Limbo must be cleaned up, by either calling TreeTransform.apply or
1130
calling TreeTransform.finalize.
1132
Files are placed into limbo inside their parent directories, where
1133
possible. This reduces subsequent renames, and makes operations involving
1134
lots of files faster. This optimization is only possible if the parent
1135
directory is created *before* creating any of its children, so avoid
1136
creating children before parents, where possible.
1140
This temporary directory is used by _FileMover for storing files that are
1141
about to be deleted. In case of rollback, the files will be restored.
1142
FileMover does not delete files until it is sure that a rollback will not
1145
def __init__(self, tree, pb=DummyProgress()):
1146
"""Note: a tree_write lock is taken on the tree.
1148
Use TreeTransform.finalize() to release the lock (can be omitted if
1149
TreeTransform.apply() called).
1151
tree.lock_tree_write()
1154
limbodir = urlutils.local_path_from_url(
1155
tree._transport.abspath('limbo'))
1159
if e.errno == errno.EEXIST:
1160
raise ExistingLimbo(limbodir)
1161
deletiondir = urlutils.local_path_from_url(
1162
tree._transport.abspath('pending-deletion'))
1164
os.mkdir(deletiondir)
1166
if e.errno == errno.EEXIST:
1167
raise errors.ExistingPendingDeletion(deletiondir)
1172
TreeTransformBase.__init__(self, tree, limbodir, pb,
1173
tree.case_sensitive)
1174
self._deletiondir = deletiondir
1176
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1177
"""Apply all changes to the inventory and filesystem.
1179
If filesystem or inventory conflicts are present, MalformedTransform
1182
If apply succeeds, finalize is not necessary.
1184
:param no_conflicts: if True, the caller guarantees there are no
1185
conflicts, so no check is made.
1186
:param precomputed_delta: An inventory delta to use instead of
1188
:param _mover: Supply an alternate FileMover, for testing
1190
if not no_conflicts:
1191
conflicts = self.find_conflicts()
1192
if len(conflicts) != 0:
1193
raise MalformedTransform(conflicts=conflicts)
1194
if precomputed_delta is None:
1195
new_inventory_delta = []
1196
inventory_delta = new_inventory_delta
1198
new_inventory_delta = None
1199
inventory_delta = precomputed_delta
1200
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1203
mover = _FileMover()
1207
child_pb.update('Apply phase', 0, 2)
1208
self._apply_removals(new_inventory_delta, mover)
1209
child_pb.update('Apply phase', 1, 2)
1210
modified_paths = self._apply_insertions(new_inventory_delta,
1216
mover.apply_deletions()
1219
self._tree.apply_inventory_delta(inventory_delta)
1222
return _TransformResults(modified_paths, self.rename_count)
1224
def _apply_removals(self, inventory_delta, mover):
1225
"""Perform tree operations that remove directory/inventory names.
1227
That is, delete files that are to be deleted, and put any files that
1228
need renaming into limbo. This must be done in strict child-to-parent
1231
If inventory_delta is None, no inventory delta generation is performed.
1233
tree_paths = list(self._tree_path_ids.iteritems())
1234
tree_paths.sort(reverse=True)
1235
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1237
for num, data in enumerate(tree_paths):
1238
path, trans_id = data
1239
child_pb.update('removing file', num, len(tree_paths))
1240
full_path = self._tree.abspath(path)
1241
if trans_id in self._removed_contents:
1242
mover.pre_delete(full_path, os.path.join(self._deletiondir,
1244
elif trans_id in self._new_name or trans_id in \
1247
mover.rename(full_path, self._limbo_name(trans_id))
1249
if e.errno != errno.ENOENT:
1252
self.rename_count += 1
1253
if (trans_id in self._removed_id
1254
and inventory_delta is not None):
1255
if trans_id == self._new_root:
1256
file_id = self._tree.get_root_id()
1258
file_id = self.tree_file_id(trans_id)
1259
# File-id isn't really being deleted, just moved
1260
if file_id in self._r_new_id:
1262
inventory_delta.append((path, None, file_id, None))
1266
def _apply_insertions(self, inventory_delta, mover):
1267
"""Perform tree operations that insert directory/inventory names.
1269
That is, create any files that need to be created, and restore from
1270
limbo any files that needed renaming. This must be done in strict
1271
parent-to-child order.
1273
If inventory_delta is None, no inventory delta is calculated, and
1274
no list of modified paths is returned.
1276
new_paths = self.new_paths(filesystem_only=(inventory_delta is None))
1279
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1281
if inventory_delta is not None:
1282
entries = self._tree.iter_entries_by_dir(
1283
new_path_file_ids.values())
1284
old_paths = dict((e.file_id, p) for p, e in entries)
1285
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1287
for num, (path, trans_id) in enumerate(new_paths):
1290
child_pb.update('adding file', num, len(new_paths))
1291
full_path = self._tree.abspath(path)
1292
if trans_id in self._needs_rename:
1294
mover.rename(self._limbo_name(trans_id), full_path)
1296
# We may be renaming a dangling inventory id
1297
if e.errno != errno.ENOENT:
1300
self.rename_count += 1
1301
if inventory_delta is not None:
1302
if (trans_id in self._new_contents or
1303
self.path_changed(trans_id)):
1304
if trans_id in self._new_contents:
1305
modified_paths.append(full_path)
1306
completed_new.append(trans_id)
1307
file_id = new_path_file_ids[trans_id]
1308
if file_id is not None and (trans_id in self._new_id or
1309
trans_id in self._new_name or
1310
trans_id in self._new_parent
1311
or trans_id in self._new_executability):
1313
kind = self.final_kind(trans_id)
1315
kind = self._tree.stored_kind(file_id)
1316
parent_trans_id = self.final_parent(trans_id)
1317
parent_file_id = new_path_file_ids.get(parent_trans_id)
1318
if parent_file_id is None:
1319
parent_file_id = self.final_file_id(
1321
if trans_id in self._new_reference_revision:
1322
new_entry = inventory.TreeReference(
1324
self._new_name[trans_id],
1325
self.final_file_id(self._new_parent[trans_id]),
1326
None, self._new_reference_revision[trans_id])
1328
new_entry = inventory.make_entry(kind,
1329
self.final_name(trans_id),
1330
parent_file_id, file_id)
1331
old_path = old_paths.get(new_entry.file_id)
1332
inventory_delta.append(
1333
(old_path, path, new_entry.file_id, new_entry))
1335
if trans_id in self._new_executability:
1336
self._set_executability(path, new_entry, trans_id)
1339
if inventory_delta is None:
1340
self._new_contents.clear()
1342
for trans_id in completed_new:
1343
del self._new_contents[trans_id]
1344
return modified_paths
1347
class TransformPreview(TreeTransformBase):
1348
"""A TreeTransform for generating preview trees.
1350
Unlike TreeTransform, this version works when the input tree is a
1351
RevisionTree, rather than a WorkingTree. As a result, it tends to ignore
1352
unversioned files in the input tree.
1355
def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1357
limbodir = tempfile.mkdtemp(prefix='bzr-limbo-')
1358
TreeTransformBase.__init__(self, tree, limbodir, pb, case_sensitive)
1360
def canonical_path(self, path):
1363
def tree_kind(self, trans_id):
1364
path = self._tree_id_paths.get(trans_id)
1366
raise NoSuchFile(None)
1367
file_id = self._tree.path2id(path)
1368
return self._tree.kind(file_id)
1370
def _set_mode(self, trans_id, mode_id, typefunc):
1371
"""Set the mode of new file contents.
1372
The mode_id is the existing file to get the mode from (often the same
1373
as trans_id). The operation is only performed if there's a mode match
1374
according to typefunc.
1376
# is it ok to ignore this? probably
1379
def iter_tree_children(self, parent_id):
1380
"""Iterate through the entry's tree children, if any"""
1382
path = self._tree_id_paths[parent_id]
1385
file_id = self.tree_file_id(parent_id)
1386
for child in self._tree.inventory[file_id].children.iterkeys():
1387
childpath = joinpath(path, child)
1388
yield self.trans_id_tree_path(childpath)
1391
class _PreviewTree(tree.Tree):
1392
"""Partial implementation of Tree to support show_diff_trees"""
1394
def __init__(self, transform):
1395
self._transform = transform
1396
self._final_paths = FinalPaths(transform)
1398
def _changes(self, file_id):
1399
for changes in self._transform.iter_changes():
1400
if changes[0] == file_id:
1403
def _content_change(self, file_id):
1404
"""Return True if the content of this file changed"""
1405
changes = self._changes(file_id)
1406
# changes[2] is true if the file content changed. See
1407
# InterTree.iter_changes.
1408
return (changes is not None and changes[2])
1410
def _get_file_revision(self, file_id, vf, tree_revision):
1411
return self._transform._tree._get_file_revision(file_id, vf,
1414
def _stat_limbo_file(self, file_id):
1415
trans_id = self._transform.trans_id_file_id(file_id)
1416
name = self._transform._limbo_name(trans_id)
1417
return os.lstat(name)
1419
def lock_read(self):
1420
# Perhaps in theory, this should lock the TreeTransform?
1427
def inventory(self):
1428
"""This Tree does not use inventory as its backing data."""
1429
raise NotImplementedError(_PreviewTree.inventory)
1431
def get_root_id(self):
1432
return self._transform.final_file_id(self._transform.root)
1434
def all_file_ids(self):
1435
return self._transform._tree.all_file_ids()
1438
return iter(self.all_file_ids())
1440
def paths2ids(self, specific_files, trees=None, require_versioned=False):
1441
"""See Tree.paths2ids"""
1442
to_find = set(specific_files)
1444
for (file_id, paths, changed, versioned, parent, name, kind,
1445
executable) in self._transform.iter_changes():
1446
if paths[1] in to_find:
1447
result.append(file_id)
1448
to_find.remove(paths[1])
1449
result.update(self._transform._tree.paths2ids(to_find,
1450
trees=[], require_versioned=require_versioned))
1453
def path2id(self, path):
1454
return self._transform._tree.path2id(path)
1456
def id2path(self, file_id):
1457
trans_id = self._transform.trans_id_file_id(file_id)
1459
return self._final_paths._determine_path(trans_id)
1461
raise errors.NoSuchId(self, file_id)
1463
def iter_entries_by_dir(self, specific_file_ids=None):
1464
return self._transform._tree.iter_entries_by_dir(specific_file_ids)
1466
def kind(self, file_id):
1467
trans_id = self._transform.trans_id_file_id(file_id)
1468
return self._transform.final_kind(trans_id)
1470
def stored_kind(self, file_id):
1471
return self._transform._tree.stored_kind(file_id)
1473
def get_file_mtime(self, file_id, path=None):
1474
"""See Tree.get_file_mtime"""
1475
if not self._content_change(file_id):
1476
return self._transform._tree.get_file_mtime(file_id, path)
1477
return self._stat_limbo_file(file_id).st_mtime
1479
def get_file_size(self, file_id):
1480
"""See Tree.get_file_size"""
1481
if self.kind(file_id) == 'file':
1482
return self._transform._tree.get_file_size(file_id)
1486
def get_file_sha1(self, file_id, path=None, stat_value=None):
1487
return self._transform._tree.get_file_sha1(file_id)
1489
def is_executable(self, file_id, path=None):
1490
return self._transform._tree.is_executable(file_id, path)
1492
def path_content_summary(self, path):
1493
return self._transform._tree.path_content_summary(path)
1495
def iter_changes(self, from_tree, include_unchanged=False,
1496
specific_files=None, pb=None, extra_trees=None,
1497
require_versioned=True, want_unversioned=False):
1498
"""See InterTree.iter_changes.
1500
This implementation does not support include_unchanged, specific_files,
1501
or want_unversioned. extra_trees, require_versioned, and pb are
1504
if from_tree is not self._transform._tree:
1505
raise ValueError('from_tree must be transform source tree.')
1506
if include_unchanged:
1507
raise ValueError('include_unchanged is not supported')
1508
if specific_files is not None:
1509
raise ValueError('specific_files is not supported')
1510
if want_unversioned:
1511
raise ValueError('want_unversioned is not supported')
1512
return self._transform.iter_changes()
1514
def get_file(self, file_id, path=None):
1515
"""See Tree.get_file"""
1516
if not self._content_change(file_id):
1517
return self._transform._tree.get_file(file_id, path)
1518
trans_id = self._transform.trans_id_file_id(file_id)
1519
name = self._transform._limbo_name(trans_id)
1520
return open(name, 'rb')
1522
def get_file_text(self, file_id):
1523
text_file = self.get_file(file_id)
1525
return text_file.read()
1529
def annotate_iter(self, file_id,
1530
default_revision=_mod_revision.CURRENT_REVISION):
1531
return self._transform._tree.annotate_iter(file_id,
1532
default_revision=default_revision)
1534
def get_symlink_target(self, file_id):
1535
"""See Tree.get_symlink_target"""
1536
if not self._content_change(file_id):
1537
return self._transform._tree.get_symlink_target(file_id)
1538
trans_id = self._transform.trans_id_file_id(file_id)
1539
name = self._transform._limbo_name(trans_id)
1540
return os.readlink(name)
1542
def list_files(self, include_root=False):
1543
return self._transform._tree.list_files(include_root)
1545
def walkdirs(self, prefix=""):
1546
return self._transform._tree.walkdirs(prefix)
1548
def get_parent_ids(self):
1549
return self._transform._tree.get_parent_ids()
1551
def get_revision_tree(self, revision_id):
1552
return self._transform._tree.get_revision_tree(revision_id)
1555
def joinpath(parent, child):
1556
"""Join tree-relative paths, handling the tree root specially"""
1557
if parent is None or parent == "":
1560
return pathjoin(parent, child)
1563
class FinalPaths(object):
1564
"""Make path calculation cheap by memoizing paths.
1566
The underlying tree must not be manipulated between calls, or else
1567
the results will likely be incorrect.
1569
def __init__(self, transform):
1570
object.__init__(self)
1571
self._known_paths = {}
1572
self.transform = transform
1574
def _determine_path(self, trans_id):
1575
if trans_id == self.transform.root:
1577
name = self.transform.final_name(trans_id)
1578
parent_id = self.transform.final_parent(trans_id)
1579
if parent_id == self.transform.root:
1582
return pathjoin(self.get_path(parent_id), name)
1584
def get_path(self, trans_id):
1585
"""Find the final path associated with a trans_id"""
1586
if trans_id not in self._known_paths:
1587
self._known_paths[trans_id] = self._determine_path(trans_id)
1588
return self._known_paths[trans_id]
1590
def get_paths(self, trans_ids):
1591
return [(self.get_path(t), t) for t in trans_ids]
1595
def topology_sorted_ids(tree):
1596
"""Determine the topological order of the ids in a tree"""
1597
file_ids = list(tree)
1598
file_ids.sort(key=tree.id2path)
1602
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
1603
delta_from_tree=False):
1604
"""Create working tree for a branch, using a TreeTransform.
1606
This function should be used on empty trees, having a tree root at most.
1607
(see merge and revert functionality for working with existing trees)
1609
Existing files are handled like so:
1611
- Existing bzrdirs take precedence over creating new items. They are
1612
created as '%s.diverted' % name.
1613
- Otherwise, if the content on disk matches the content we are building,
1614
it is silently replaced.
1615
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
1617
:param tree: The tree to convert wt into a copy of
1618
:param wt: The working tree that files will be placed into
1619
:param accelerator_tree: A tree which can be used for retrieving file
1620
contents more quickly than tree itself, i.e. a workingtree. tree
1621
will be used for cases where accelerator_tree's content is different.
1622
:param hardlink: If true, hard-link files to accelerator_tree, where
1623
possible. accelerator_tree must implement abspath, i.e. be a
1625
:param delta_from_tree: If true, build_tree may use the input Tree to
1626
generate the inventory delta.
1628
wt.lock_tree_write()
1632
if accelerator_tree is not None:
1633
accelerator_tree.lock_read()
1635
return _build_tree(tree, wt, accelerator_tree, hardlink,
1638
if accelerator_tree is not None:
1639
accelerator_tree.unlock()
1646
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
1647
"""See build_tree."""
1648
for num, _unused in enumerate(wt.all_file_ids()):
1649
if num > 0: # more than just a root
1650
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
1651
existing_files = set()
1652
for dir, files in wt.walkdirs():
1653
existing_files.update(f[0] for f in files)
1655
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1656
pp = ProgressPhase("Build phase", 2, top_pb)
1657
if tree.inventory.root is not None:
1658
# This is kind of a hack: we should be altering the root
1659
# as part of the regular tree shape diff logic.
1660
# The conditional test here is to avoid doing an
1661
# expensive operation (flush) every time the root id
1662
# is set within the tree, nor setting the root and thus
1663
# marking the tree as dirty, because we use two different
1664
# idioms here: tree interfaces and inventory interfaces.
1665
if wt.get_root_id() != tree.get_root_id():
1666
wt.set_root_id(tree.get_root_id())
1668
tt = TreeTransform(wt)
1672
file_trans_id[wt.get_root_id()] = \
1673
tt.trans_id_tree_file_id(wt.get_root_id())
1674
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1676
deferred_contents = []
1678
total = len(tree.inventory)
1680
precomputed_delta = []
1682
precomputed_delta = None
1683
for num, (tree_path, entry) in \
1684
enumerate(tree.inventory.iter_entries_by_dir()):
1685
pb.update("Building tree", num - len(deferred_contents), total)
1686
if entry.parent_id is None:
1689
file_id = entry.file_id
1691
precomputed_delta.append((None, tree_path, file_id, entry))
1692
if tree_path in existing_files:
1693
target_path = wt.abspath(tree_path)
1694
kind = file_kind(target_path)
1695
if kind == "directory":
1697
bzrdir.BzrDir.open(target_path)
1698
except errors.NotBranchError:
1702
if (file_id not in divert and
1703
_content_match(tree, entry, file_id, kind,
1705
tt.delete_contents(tt.trans_id_tree_path(tree_path))
1706
if kind == 'directory':
1708
parent_id = file_trans_id[entry.parent_id]
1709
if entry.kind == 'file':
1710
# We *almost* replicate new_by_entry, so that we can defer
1711
# getting the file text, and get them all at once.
1712
trans_id = tt.create_path(entry.name, parent_id)
1713
file_trans_id[file_id] = trans_id
1714
tt.version_file(file_id, trans_id)
1715
executable = tree.is_executable(file_id, tree_path)
1717
tt.set_executability(executable, trans_id)
1718
deferred_contents.append((file_id, trans_id))
1720
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1723
new_trans_id = file_trans_id[file_id]
1724
old_parent = tt.trans_id_tree_path(tree_path)
1725
_reparent_children(tt, old_parent, new_trans_id)
1726
offset = num + 1 - len(deferred_contents)
1727
_create_files(tt, tree, deferred_contents, pb, offset,
1728
accelerator_tree, hardlink)
1732
divert_trans = set(file_trans_id[f] for f in divert)
1733
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1734
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
1735
if len(raw_conflicts) > 0:
1736
precomputed_delta = None
1737
conflicts = cook_conflicts(raw_conflicts, tt)
1738
for conflict in conflicts:
1741
wt.add_conflicts(conflicts)
1742
except errors.UnsupportedOperation:
1744
result = tt.apply(no_conflicts=True,
1745
precomputed_delta=precomputed_delta)
1752
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
1754
total = len(desired_files) + offset
1755
if accelerator_tree is None:
1756
new_desired_files = desired_files
1758
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
1759
unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
1760
in iter if not (c or e[0] != e[1]))
1761
new_desired_files = []
1763
for file_id, trans_id in desired_files:
1764
accelerator_path = unchanged.get(file_id)
1765
if accelerator_path is None:
1766
new_desired_files.append((file_id, trans_id))
1768
pb.update('Adding file contents', count + offset, total)
1770
tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
1773
contents = accelerator_tree.get_file(file_id, accelerator_path)
1775
tt.create_file(contents, trans_id)
1780
for count, (trans_id, contents) in enumerate(tree.iter_files_bytes(
1781
new_desired_files)):
1782
tt.create_file(contents, trans_id)
1783
pb.update('Adding file contents', count + offset, total)
1786
def _reparent_children(tt, old_parent, new_parent):
1787
for child in tt.iter_tree_children(old_parent):
1788
tt.adjust_path(tt.final_name(child), new_parent, child)
1790
def _reparent_transform_children(tt, old_parent, new_parent):
1791
by_parent = tt.by_parent()
1792
for child in by_parent[old_parent]:
1793
tt.adjust_path(tt.final_name(child), new_parent, child)
1794
return by_parent[old_parent]
1796
def _content_match(tree, entry, file_id, kind, target_path):
1797
if entry.kind != kind:
1799
if entry.kind == "directory":
1801
if entry.kind == "file":
1802
if tree.get_file(file_id).read() == file(target_path, 'rb').read():
1804
elif entry.kind == "symlink":
1805
if tree.get_symlink_target(file_id) == os.readlink(target_path):
1810
def resolve_checkout(tt, conflicts, divert):
1811
new_conflicts = set()
1812
for c_type, conflict in ((c[0], c) for c in conflicts):
1813
# Anything but a 'duplicate' would indicate programmer error
1814
if c_type != 'duplicate':
1815
raise AssertionError(c_type)
1816
# Now figure out which is new and which is old
1817
if tt.new_contents(conflict[1]):
1818
new_file = conflict[1]
1819
old_file = conflict[2]
1821
new_file = conflict[2]
1822
old_file = conflict[1]
1824
# We should only get here if the conflict wasn't completely
1826
final_parent = tt.final_parent(old_file)
1827
if new_file in divert:
1828
new_name = tt.final_name(old_file)+'.diverted'
1829
tt.adjust_path(new_name, final_parent, new_file)
1830
new_conflicts.add((c_type, 'Diverted to',
1831
new_file, old_file))
1833
new_name = tt.final_name(old_file)+'.moved'
1834
tt.adjust_path(new_name, final_parent, old_file)
1835
new_conflicts.add((c_type, 'Moved existing file to',
1836
old_file, new_file))
1837
return new_conflicts
1840
def new_by_entry(tt, entry, parent_id, tree):
1841
"""Create a new file according to its inventory entry"""
1845
contents = tree.get_file(entry.file_id).readlines()
1846
executable = tree.is_executable(entry.file_id)
1847
return tt.new_file(name, parent_id, contents, entry.file_id,
1849
elif kind in ('directory', 'tree-reference'):
1850
trans_id = tt.new_directory(name, parent_id, entry.file_id)
1851
if kind == 'tree-reference':
1852
tt.set_tree_reference(entry.reference_revision, trans_id)
1854
elif kind == 'symlink':
1855
target = tree.get_symlink_target(entry.file_id)
1856
return tt.new_symlink(name, parent_id, target, entry.file_id)
1858
raise errors.BadFileKindError(name, kind)
1861
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1862
"""Create new file contents according to an inventory entry."""
1863
if entry.kind == "file":
1865
lines = tree.get_file(entry.file_id).readlines()
1866
tt.create_file(lines, trans_id, mode_id=mode_id)
1867
elif entry.kind == "symlink":
1868
tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
1869
elif entry.kind == "directory":
1870
tt.create_directory(trans_id)
1873
def create_entry_executability(tt, entry, trans_id):
1874
"""Set the executability of a trans_id according to an inventory entry"""
1875
if entry.kind == "file":
1876
tt.set_executability(entry.executable, trans_id)
1879
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1880
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1883
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1884
"""Produce a backup-style name that appears to be available"""
1888
yield "%s.~%d~" % (name, counter)
1890
for new_name in name_gen():
1891
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
1895
def _entry_changes(file_id, entry, working_tree):
1896
"""Determine in which ways the inventory entry has changed.
1898
Returns booleans: has_contents, content_mod, meta_mod
1899
has_contents means there are currently contents, but they differ
1900
contents_mod means contents need to be modified
1901
meta_mod means the metadata needs to be modified
1903
cur_entry = working_tree.inventory[file_id]
1905
working_kind = working_tree.kind(file_id)
1908
has_contents = False
1911
if has_contents is True:
1912
if entry.kind != working_kind:
1913
contents_mod, meta_mod = True, False
1915
cur_entry._read_tree_state(working_tree.id2path(file_id),
1917
contents_mod, meta_mod = entry.detect_changes(cur_entry)
1918
cur_entry._forget_tree_state()
1919
return has_contents, contents_mod, meta_mod
1922
def revert(working_tree, target_tree, filenames, backups=False,
1923
pb=DummyProgress(), change_reporter=None):
1924
"""Revert a working tree's contents to those of a target tree."""
1925
target_tree.lock_read()
1926
tt = TreeTransform(working_tree, pb)
1928
pp = ProgressPhase("Revert phase", 3, pb)
1930
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1932
merge_modified = _alter_files(working_tree, target_tree, tt,
1933
child_pb, filenames, backups)
1937
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1939
raw_conflicts = resolve_conflicts(tt, child_pb,
1940
lambda t, c: conflict_pass(t, c, target_tree))
1943
conflicts = cook_conflicts(raw_conflicts, tt)
1945
change_reporter = delta._ChangeReporter(
1946
unversioned_filter=working_tree.is_ignored)
1947
delta.report_changes(tt.iter_changes(), change_reporter)
1948
for conflict in conflicts:
1952
working_tree.set_merge_modified(merge_modified)
1954
target_tree.unlock()
1960
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1962
merge_modified = working_tree.merge_modified()
1963
change_list = target_tree.iter_changes(working_tree,
1964
specific_files=specific_files, pb=pb)
1965
if target_tree.inventory.root is None:
1972
for id_num, (file_id, path, changed_content, versioned, parent, name,
1973
kind, executable) in enumerate(change_list):
1974
if skip_root and file_id[0] is not None and parent[0] is None:
1976
trans_id = tt.trans_id_file_id(file_id)
1979
keep_content = False
1980
if kind[0] == 'file' and (backups or kind[1] is None):
1981
wt_sha1 = working_tree.get_file_sha1(file_id)
1982
if merge_modified.get(file_id) != wt_sha1:
1983
# acquire the basis tree lazily to prevent the
1984
# expense of accessing it when it's not needed ?
1985
# (Guessing, RBC, 200702)
1986
if basis_tree is None:
1987
basis_tree = working_tree.basis_tree()
1988
basis_tree.lock_read()
1989
if file_id in basis_tree:
1990
if wt_sha1 != basis_tree.get_file_sha1(file_id):
1992
elif kind[1] is None and not versioned[1]:
1994
if kind[0] is not None:
1995
if not keep_content:
1996
tt.delete_contents(trans_id)
1997
elif kind[1] is not None:
1998
parent_trans_id = tt.trans_id_file_id(parent[0])
1999
by_parent = tt.by_parent()
2000
backup_name = _get_backup_name(name[0], by_parent,
2001
parent_trans_id, tt)
2002
tt.adjust_path(backup_name, parent_trans_id, trans_id)
2003
new_trans_id = tt.create_path(name[0], parent_trans_id)
2004
if versioned == (True, True):
2005
tt.unversion_file(trans_id)
2006
tt.version_file(file_id, new_trans_id)
2007
# New contents should have the same unix perms as old
2010
trans_id = new_trans_id
2011
if kind[1] == 'directory':
2012
tt.create_directory(trans_id)
2013
elif kind[1] == 'symlink':
2014
tt.create_symlink(target_tree.get_symlink_target(file_id),
2016
elif kind[1] == 'file':
2017
deferred_files.append((file_id, (trans_id, mode_id)))
2018
if basis_tree is None:
2019
basis_tree = working_tree.basis_tree()
2020
basis_tree.lock_read()
2021
new_sha1 = target_tree.get_file_sha1(file_id)
2022
if (file_id in basis_tree and new_sha1 ==
2023
basis_tree.get_file_sha1(file_id)):
2024
if file_id in merge_modified:
2025
del merge_modified[file_id]
2027
merge_modified[file_id] = new_sha1
2029
# preserve the execute bit when backing up
2030
if keep_content and executable[0] == executable[1]:
2031
tt.set_executability(executable[1], trans_id)
2032
elif kind[1] is not None:
2033
raise AssertionError(kind[1])
2034
if versioned == (False, True):
2035
tt.version_file(file_id, trans_id)
2036
if versioned == (True, False):
2037
tt.unversion_file(trans_id)
2038
if (name[1] is not None and
2039
(name[0] != name[1] or parent[0] != parent[1])):
2041
name[1], tt.trans_id_file_id(parent[1]), trans_id)
2042
if executable[0] != executable[1] and kind[1] == "file":
2043
tt.set_executability(executable[1], trans_id)
2044
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2046
tt.create_file(bytes, trans_id, mode_id)
2048
if basis_tree is not None:
2050
return merge_modified
2053
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2054
"""Make many conflict-resolution attempts, but die if they fail"""
2055
if pass_func is None:
2056
pass_func = conflict_pass
2057
new_conflicts = set()
2060
pb.update('Resolution pass', n+1, 10)
2061
conflicts = tt.find_conflicts()
2062
if len(conflicts) == 0:
2063
return new_conflicts
2064
new_conflicts.update(pass_func(tt, conflicts))
2065
raise MalformedTransform(conflicts=conflicts)
2070
def conflict_pass(tt, conflicts, path_tree=None):
2071
"""Resolve some classes of conflicts.
2073
:param tt: The transform to resolve conflicts in
2074
:param conflicts: The conflicts to resolve
2075
:param path_tree: A Tree to get supplemental paths from
2077
new_conflicts = set()
2078
for c_type, conflict in ((c[0], c) for c in conflicts):
2079
if c_type == 'duplicate id':
2080
tt.unversion_file(conflict[1])
2081
new_conflicts.add((c_type, 'Unversioned existing file',
2082
conflict[1], conflict[2], ))
2083
elif c_type == 'duplicate':
2084
# files that were renamed take precedence
2085
final_parent = tt.final_parent(conflict[1])
2086
if tt.path_changed(conflict[1]):
2087
existing_file, new_file = conflict[2], conflict[1]
2089
existing_file, new_file = conflict[1], conflict[2]
2090
new_name = tt.final_name(existing_file)+'.moved'
2091
tt.adjust_path(new_name, final_parent, existing_file)
2092
new_conflicts.add((c_type, 'Moved existing file to',
2093
existing_file, new_file))
2094
elif c_type == 'parent loop':
2095
# break the loop by undoing one of the ops that caused the loop
2097
while not tt.path_changed(cur):
2098
cur = tt.final_parent(cur)
2099
new_conflicts.add((c_type, 'Cancelled move', cur,
2100
tt.final_parent(cur),))
2101
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
2103
elif c_type == 'missing parent':
2104
trans_id = conflict[1]
2106
tt.cancel_deletion(trans_id)
2107
new_conflicts.add(('deleting parent', 'Not deleting',
2112
tt.final_name(trans_id)
2114
if path_tree is not None:
2115
file_id = tt.final_file_id(trans_id)
2117
file_id = tt.inactive_file_id(trans_id)
2118
entry = path_tree.inventory[file_id]
2119
# special-case the other tree root (move its
2120
# children to current root)
2121
if entry.parent_id is None:
2123
moved = _reparent_transform_children(
2124
tt, trans_id, tt.root)
2126
new_conflicts.add((c_type, 'Moved to root',
2129
parent_trans_id = tt.trans_id_file_id(
2131
tt.adjust_path(entry.name, parent_trans_id,
2134
tt.create_directory(trans_id)
2135
new_conflicts.add((c_type, 'Created directory', trans_id))
2136
elif c_type == 'unversioned parent':
2137
file_id = tt.inactive_file_id(conflict[1])
2138
# special-case the other tree root (move its children instead)
2139
if path_tree and file_id in path_tree:
2140
if path_tree.inventory[file_id].parent_id is None:
2142
tt.version_file(file_id, conflict[1])
2143
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2144
elif c_type == 'non-directory parent':
2145
parent_id = conflict[1]
2146
parent_parent = tt.final_parent(parent_id)
2147
parent_name = tt.final_name(parent_id)
2148
parent_file_id = tt.final_file_id(parent_id)
2149
new_parent_id = tt.new_directory(parent_name + '.new',
2150
parent_parent, parent_file_id)
2151
_reparent_transform_children(tt, parent_id, new_parent_id)
2152
if parent_file_id is not None:
2153
tt.unversion_file(parent_id)
2154
new_conflicts.add((c_type, 'Created directory', new_parent_id))
2155
return new_conflicts
2158
def cook_conflicts(raw_conflicts, tt):
2159
"""Generate a list of cooked conflicts, sorted by file path"""
2160
from bzrlib.conflicts import Conflict
2161
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
2162
return sorted(conflict_iter, key=Conflict.sort_key)
2165
def iter_cook_conflicts(raw_conflicts, tt):
2166
from bzrlib.conflicts import Conflict
2168
for conflict in raw_conflicts:
2169
c_type = conflict[0]
2170
action = conflict[1]
2171
modified_path = fp.get_path(conflict[2])
2172
modified_id = tt.final_file_id(conflict[2])
2173
if len(conflict) == 3:
2174
yield Conflict.factory(c_type, action=action, path=modified_path,
2175
file_id=modified_id)
2178
conflicting_path = fp.get_path(conflict[3])
2179
conflicting_id = tt.final_file_id(conflict[3])
2180
yield Conflict.factory(c_type, action=action, path=modified_path,
2181
file_id=modified_id,
2182
conflict_path=conflicting_path,
2183
conflict_file_id=conflicting_id)
2186
class _FileMover(object):
2187
"""Moves and deletes files for TreeTransform, tracking operations"""
2190
self.past_renames = []
2191
self.pending_deletions = []
2193
def rename(self, from_, to):
2194
"""Rename a file from one path to another. Functions like os.rename"""
2196
os.rename(from_, to)
2198
if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2199
raise errors.FileExists(to, str(e))
2201
self.past_renames.append((from_, to))
2203
def pre_delete(self, from_, to):
2204
"""Rename a file out of the way and mark it for deletion.
2206
Unlike os.unlink, this works equally well for files and directories.
2207
:param from_: The current file path
2208
:param to: A temporary path for the file
2210
self.rename(from_, to)
2211
self.pending_deletions.append(to)
2214
"""Reverse all renames that have been performed"""
2215
for from_, to in reversed(self.past_renames):
2216
os.rename(to, from_)
2217
# after rollback, don't reuse _FileMover
2219
pending_deletions = None
2221
def apply_deletions(self):
2222
"""Apply all marked deletions"""
2223
for path in self.pending_deletions:
2225
# after apply_deletions, don't reuse _FileMover
2227
pending_deletions = None
added
removed
bzrlib/transform.py
