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 calulate values for files
457
that require renames or execute bit setting.
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 _mover: Supply an alternate FileMover, for testing
1188
if not no_conflicts:
1189
conflicts = self.find_conflicts()
1190
if len(conflicts) != 0:
1191
raise MalformedTransform(conflicts=conflicts)
1192
if precomputed_delta is None:
1193
new_inventory_delta = []
1194
inventory_delta = new_inventory_delta
1196
new_inventory_delta = None
1197
inventory_delta = precomputed_delta
1198
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1201
mover = _FileMover()
1205
child_pb.update('Apply phase', 0, 2)
1206
self._apply_removals(new_inventory_delta, mover)
1207
child_pb.update('Apply phase', 1, 2)
1208
modified_paths = self._apply_insertions(new_inventory_delta,
1214
mover.apply_deletions()
1217
self._tree.apply_inventory_delta(inventory_delta)
1220
return _TransformResults(modified_paths, self.rename_count)
1222
def _apply_removals(self, inventory_delta, mover):
1223
"""Perform tree operations that remove directory/inventory names.
1225
That is, delete files that are to be deleted, and put any files that
1226
need renaming into limbo. This must be done in strict child-to-parent
1229
tree_paths = list(self._tree_path_ids.iteritems())
1230
tree_paths.sort(reverse=True)
1231
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1233
for num, data in enumerate(tree_paths):
1234
path, trans_id = data
1235
child_pb.update('removing file', num, len(tree_paths))
1236
full_path = self._tree.abspath(path)
1237
if trans_id in self._removed_contents:
1238
mover.pre_delete(full_path, os.path.join(self._deletiondir,
1240
elif trans_id in self._new_name or trans_id in \
1243
mover.rename(full_path, self._limbo_name(trans_id))
1245
if e.errno != errno.ENOENT:
1248
self.rename_count += 1
1249
if trans_id in self._removed_id:
1250
if trans_id == self._new_root:
1251
file_id = self._tree.get_root_id()
1253
file_id = self.tree_file_id(trans_id)
1254
# File-id isn't really being deleted, just moved
1255
if file_id in self._r_new_id:
1257
if inventory_delta is not None:
1258
inventory_delta.append((path, None, file_id, None))
1262
def _apply_insertions(self, inventory_delta, mover):
1263
"""Perform tree operations that insert directory/inventory names.
1265
That is, create any files that need to be created, and restore from
1266
limbo any files that needed renaming. This must be done in strict
1267
parent-to-child order.
1269
If inventory_delta is None, no inventory delta is calculated, and
1270
no list of modified paths is returned.
1272
new_paths = self.new_paths(filesystem_only=(inventory_delta is None))
1275
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1277
entries = self._tree.iter_entries_by_dir(new_path_file_ids.values())
1278
old_paths = dict((e.file_id, p) for p, e in entries)
1279
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1281
for num, (path, trans_id) in enumerate(new_paths):
1284
child_pb.update('adding file', num, len(new_paths))
1285
full_path = self._tree.abspath(path)
1286
if trans_id in self._needs_rename:
1288
mover.rename(self._limbo_name(trans_id), full_path)
1290
# We may be renaming a dangling inventory id
1291
if e.errno != errno.ENOENT:
1294
self.rename_count += 1
1295
if inventory_delta is not None:
1296
if (trans_id in self._new_contents or
1297
self.path_changed(trans_id)):
1298
if trans_id in self._new_contents:
1299
modified_paths.append(full_path)
1300
completed_new.append(trans_id)
1301
file_id = new_path_file_ids[trans_id]
1302
if file_id is not None and (trans_id in self._new_id or
1303
trans_id in self._new_name or trans_id in self._new_parent
1304
or trans_id in self._new_executability):
1306
kind = self.final_kind(trans_id)
1308
kind = self._tree.stored_kind(file_id)
1309
parent_trans_id = self.final_parent(trans_id)
1310
parent_file_id = new_path_file_ids.get(parent_trans_id)
1311
if parent_file_id is None:
1312
parent_file_id = self.final_file_id(parent_trans_id)
1313
if trans_id in self._new_reference_revision:
1314
new_entry = inventory.TreeReference(
1316
self._new_name[trans_id],
1317
self.final_file_id(self._new_parent[trans_id]),
1318
None, self._new_reference_revision[trans_id])
1320
new_entry = inventory.make_entry(kind,
1321
self.final_name(trans_id),
1322
parent_file_id, file_id)
1323
old_path = old_paths.get(new_entry.file_id)
1324
inventory_delta.append(
1325
(old_path, path, new_entry.file_id, new_entry))
1327
if trans_id in self._new_executability:
1328
self._set_executability(path, new_entry, trans_id)
1331
if inventory_delta is None:
1332
self._new_contents.clear()
1334
for trans_id in completed_new:
1335
del self._new_contents[trans_id]
1336
return modified_paths
1339
class TransformPreview(TreeTransformBase):
1340
"""A TreeTransform for generating preview trees.
1342
Unlike TreeTransform, this version works when the input tree is a
1343
RevisionTree, rather than a WorkingTree. As a result, it tends to ignore
1344
unversioned files in the input tree.
1347
def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1349
limbodir = tempfile.mkdtemp(prefix='bzr-limbo-')
1350
TreeTransformBase.__init__(self, tree, limbodir, pb, case_sensitive)
1352
def canonical_path(self, path):
1355
def tree_kind(self, trans_id):
1356
path = self._tree_id_paths.get(trans_id)
1358
raise NoSuchFile(None)
1359
file_id = self._tree.path2id(path)
1360
return self._tree.kind(file_id)
1362
def _set_mode(self, trans_id, mode_id, typefunc):
1363
"""Set the mode of new file contents.
1364
The mode_id is the existing file to get the mode from (often the same
1365
as trans_id). The operation is only performed if there's a mode match
1366
according to typefunc.
1368
# is it ok to ignore this? probably
1371
def iter_tree_children(self, parent_id):
1372
"""Iterate through the entry's tree children, if any"""
1374
path = self._tree_id_paths[parent_id]
1377
file_id = self.tree_file_id(parent_id)
1378
for child in self._tree.inventory[file_id].children.iterkeys():
1379
childpath = joinpath(path, child)
1380
yield self.trans_id_tree_path(childpath)
1383
class _PreviewTree(tree.Tree):
1384
"""Partial implementation of Tree to support show_diff_trees"""
1386
def __init__(self, transform):
1387
self._transform = transform
1388
self._final_paths = FinalPaths(transform)
1390
def _changes(self, file_id):
1391
for changes in self._transform.iter_changes():
1392
if changes[0] == file_id:
1395
def _content_change(self, file_id):
1396
"""Return True if the content of this file changed"""
1397
changes = self._changes(file_id)
1398
# changes[2] is true if the file content changed. See
1399
# InterTree.iter_changes.
1400
return (changes is not None and changes[2])
1402
def _get_file_revision(self, file_id, vf, tree_revision):
1403
return self._transform._tree._get_file_revision(file_id, vf,
1406
def _stat_limbo_file(self, file_id):
1407
trans_id = self._transform.trans_id_file_id(file_id)
1408
name = self._transform._limbo_name(trans_id)
1409
return os.lstat(name)
1411
def lock_read(self):
1412
# Perhaps in theory, this should lock the TreeTransform?
1419
def inventory(self):
1420
"""This Tree does not use inventory as its backing data."""
1421
raise NotImplementedError(_PreviewTree.inventory)
1423
def get_root_id(self):
1424
return self._transform.final_file_id(self._transform.root)
1426
def all_file_ids(self):
1427
return self._transform._tree.all_file_ids()
1430
return iter(self.all_file_ids())
1432
def paths2ids(self, specific_files, trees=None, require_versioned=False):
1433
"""See Tree.paths2ids"""
1434
to_find = set(specific_files)
1436
for (file_id, paths, changed, versioned, parent, name, kind,
1437
executable) in self._transform.iter_changes():
1438
if paths[1] in to_find:
1439
result.append(file_id)
1440
to_find.remove(paths[1])
1441
result.update(self._transform._tree.paths2ids(to_find,
1442
trees=[], require_versioned=require_versioned))
1445
def path2id(self, path):
1446
return self._transform._tree.path2id(path)
1448
def id2path(self, file_id):
1449
trans_id = self._transform.trans_id_file_id(file_id)
1451
return self._final_paths._determine_path(trans_id)
1453
raise errors.NoSuchId(self, file_id)
1455
def iter_entries_by_dir(self, specific_file_ids=None):
1456
return self._transform._tree.iter_entries_by_dir(specific_file_ids)
1458
def kind(self, file_id):
1459
trans_id = self._transform.trans_id_file_id(file_id)
1460
return self._transform.final_kind(trans_id)
1462
def stored_kind(self, file_id):
1463
return self._transform._tree.stored_kind(file_id)
1465
def get_file_mtime(self, file_id, path=None):
1466
"""See Tree.get_file_mtime"""
1467
if not self._content_change(file_id):
1468
return self._transform._tree.get_file_mtime(file_id, path)
1469
return self._stat_limbo_file(file_id).st_mtime
1471
def get_file_size(self, file_id):
1472
"""See Tree.get_file_size"""
1473
if self.kind(file_id) == 'file':
1474
return self._transform._tree.get_file_size(file_id)
1478
def get_file_sha1(self, file_id, path=None, stat_value=None):
1479
return self._transform._tree.get_file_sha1(file_id)
1481
def is_executable(self, file_id, path=None):
1482
return self._transform._tree.is_executable(file_id, path)
1484
def path_content_summary(self, path):
1485
return self._transform._tree.path_content_summary(path)
1487
def iter_changes(self, from_tree, include_unchanged=False,
1488
specific_files=None, pb=None, extra_trees=None,
1489
require_versioned=True, want_unversioned=False):
1490
"""See InterTree.iter_changes.
1492
This implementation does not support include_unchanged, specific_files,
1493
or want_unversioned. extra_trees, require_versioned, and pb are
1496
if from_tree is not self._transform._tree:
1497
raise ValueError('from_tree must be transform source tree.')
1498
if include_unchanged:
1499
raise ValueError('include_unchanged is not supported')
1500
if specific_files is not None:
1501
raise ValueError('specific_files is not supported')
1502
if want_unversioned:
1503
raise ValueError('want_unversioned is not supported')
1504
return self._transform.iter_changes()
1506
def get_file(self, file_id, path=None):
1507
"""See Tree.get_file"""
1508
if not self._content_change(file_id):
1509
return self._transform._tree.get_file(file_id, path)
1510
trans_id = self._transform.trans_id_file_id(file_id)
1511
name = self._transform._limbo_name(trans_id)
1512
return open(name, 'rb')
1514
def get_file_text(self, file_id):
1515
text_file = self.get_file(file_id)
1517
return text_file.read()
1521
def annotate_iter(self, file_id,
1522
default_revision=_mod_revision.CURRENT_REVISION):
1523
return self._transform._tree.annotate_iter(file_id,
1524
default_revision=default_revision)
1526
def get_symlink_target(self, file_id):
1527
"""See Tree.get_symlink_target"""
1528
if not self._content_change(file_id):
1529
return self._transform._tree.get_symlink_target(file_id)
1530
trans_id = self._transform.trans_id_file_id(file_id)
1531
name = self._transform._limbo_name(trans_id)
1532
return os.readlink(name)
1534
def list_files(self, include_root=False):
1535
return self._transform._tree.list_files(include_root)
1537
def walkdirs(self, prefix=""):
1538
return self._transform._tree.walkdirs(prefix)
1540
def get_parent_ids(self):
1541
return self._transform._tree.get_parent_ids()
1543
def get_revision_tree(self, revision_id):
1544
return self._transform._tree.get_revision_tree(revision_id)
1547
def joinpath(parent, child):
1548
"""Join tree-relative paths, handling the tree root specially"""
1549
if parent is None or parent == "":
1552
return pathjoin(parent, child)
1555
class FinalPaths(object):
1556
"""Make path calculation cheap by memoizing paths.
1558
The underlying tree must not be manipulated between calls, or else
1559
the results will likely be incorrect.
1561
def __init__(self, transform):
1562
object.__init__(self)
1563
self._known_paths = {}
1564
self.transform = transform
1566
def _determine_path(self, trans_id):
1567
if trans_id == self.transform.root:
1569
name = self.transform.final_name(trans_id)
1570
parent_id = self.transform.final_parent(trans_id)
1571
if parent_id == self.transform.root:
1574
return pathjoin(self.get_path(parent_id), name)
1576
def get_path(self, trans_id):
1577
"""Find the final path associated with a trans_id"""
1578
if trans_id not in self._known_paths:
1579
self._known_paths[trans_id] = self._determine_path(trans_id)
1580
return self._known_paths[trans_id]
1582
def get_paths(self, trans_ids):
1583
return [(self.get_path(t), t) for t in trans_ids]
1587
def topology_sorted_ids(tree):
1588
"""Determine the topological order of the ids in a tree"""
1589
file_ids = list(tree)
1590
file_ids.sort(key=tree.id2path)
1594
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
1595
delta_from_tree=False):
1596
"""Create working tree for a branch, using a TreeTransform.
1598
This function should be used on empty trees, having a tree root at most.
1599
(see merge and revert functionality for working with existing trees)
1601
Existing files are handled like so:
1603
- Existing bzrdirs take precedence over creating new items. They are
1604
created as '%s.diverted' % name.
1605
- Otherwise, if the content on disk matches the content we are building,
1606
it is silently replaced.
1607
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
1609
:param tree: The tree to convert wt into a copy of
1610
:param wt: The working tree that files will be placed into
1611
:param accelerator_tree: A tree which can be used for retrieving file
1612
contents more quickly than tree itself, i.e. a workingtree. tree
1613
will be used for cases where accelerator_tree's content is different.
1614
:param hardlink: If true, hard-link files to accelerator_tree, where
1615
possible. accelerator_tree must implement abspath, i.e. be a
1617
:param delta_from_tree: If true, build_tree may use the input Tree to
1618
generate the inventory delta.
1620
wt.lock_tree_write()
1624
if accelerator_tree is not None:
1625
accelerator_tree.lock_read()
1627
return _build_tree(tree, wt, accelerator_tree, hardlink,
1630
if accelerator_tree is not None:
1631
accelerator_tree.unlock()
1638
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
1639
"""See build_tree."""
1640
for num, _unused in enumerate(wt.all_file_ids()):
1641
if num > 0: # more than just a root
1642
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
1643
existing_files = set()
1644
for dir, files in wt.walkdirs():
1645
existing_files.update(f[0] for f in files)
1647
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1648
pp = ProgressPhase("Build phase", 2, top_pb)
1649
if tree.inventory.root is not None:
1650
# This is kind of a hack: we should be altering the root
1651
# as part of the regular tree shape diff logic.
1652
# The conditional test here is to avoid doing an
1653
# expensive operation (flush) every time the root id
1654
# is set within the tree, nor setting the root and thus
1655
# marking the tree as dirty, because we use two different
1656
# idioms here: tree interfaces and inventory interfaces.
1657
if wt.get_root_id() != tree.get_root_id():
1658
wt.set_root_id(tree.get_root_id())
1660
tt = TreeTransform(wt)
1664
file_trans_id[wt.get_root_id()] = \
1665
tt.trans_id_tree_file_id(wt.get_root_id())
1666
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1668
deferred_contents = []
1671
precomputed_delta = []
1673
precomputed_delta = None
1674
for num, (tree_path, entry) in \
1675
enumerate(tree.inventory.iter_entries_by_dir()):
1676
pb.update("Building tree", num - len(deferred_contents),
1677
len(tree.inventory))
1678
if entry.parent_id is None:
1681
file_id = entry.file_id
1683
precomputed_delta.append((None, tree_path, file_id, entry))
1684
if tree_path in existing_files:
1685
target_path = wt.abspath(tree_path)
1686
kind = file_kind(target_path)
1687
if kind == "directory":
1689
bzrdir.BzrDir.open(target_path)
1690
except errors.NotBranchError:
1694
if (file_id not in divert and
1695
_content_match(tree, entry, file_id, kind,
1697
tt.delete_contents(tt.trans_id_tree_path(tree_path))
1698
if kind == 'directory':
1700
if entry.parent_id not in file_trans_id:
1701
raise AssertionError(
1702
'entry %s parent id %r is not in file_trans_id %r'
1703
% (entry, entry.parent_id, file_trans_id))
1704
parent_id = file_trans_id[entry.parent_id]
1705
if entry.kind == 'file':
1706
# We *almost* replicate new_by_entry, so that we can defer
1707
# getting the file text, and get them all at once.
1708
trans_id = tt.create_path(entry.name, parent_id)
1709
file_trans_id[file_id] = trans_id
1710
tt.version_file(entry.file_id, trans_id)
1711
executable = tree.is_executable(entry.file_id, tree_path)
1713
tt.set_executability(executable, trans_id)
1714
deferred_contents.append((entry.file_id, trans_id))
1716
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1719
new_trans_id = file_trans_id[file_id]
1720
old_parent = tt.trans_id_tree_path(tree_path)
1721
_reparent_children(tt, old_parent, new_trans_id)
1722
offset = num + 1 - len(deferred_contents)
1723
_create_files(tt, tree, deferred_contents, pb, offset,
1724
accelerator_tree, hardlink)
1728
divert_trans = set(file_trans_id[f] for f in divert)
1729
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1730
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
1731
if len(raw_conflicts) > 0:
1732
precomputed_delta = None
1733
conflicts = cook_conflicts(raw_conflicts, tt)
1734
for conflict in conflicts:
1737
wt.add_conflicts(conflicts)
1738
except errors.UnsupportedOperation:
1740
result = tt.apply(no_conflicts=True,
1741
precomputed_delta=precomputed_delta)
1748
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
1750
total = len(desired_files) + offset
1751
if accelerator_tree is None:
1752
new_desired_files = desired_files
1754
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
1755
unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
1756
in iter if not (c or e[0] != e[1]))
1757
new_desired_files = []
1759
for file_id, trans_id in desired_files:
1760
accelerator_path = unchanged.get(file_id)
1761
if accelerator_path is None:
1762
new_desired_files.append((file_id, trans_id))
1764
pb.update('Adding file contents', count + offset, total)
1766
tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
1769
contents = accelerator_tree.get_file(file_id, accelerator_path)
1771
tt.create_file(contents, trans_id)
1776
for count, (trans_id, contents) in enumerate(tree.iter_files_bytes(
1777
new_desired_files)):
1778
tt.create_file(contents, trans_id)
1779
pb.update('Adding file contents', count + offset, total)
1782
def _reparent_children(tt, old_parent, new_parent):
1783
for child in tt.iter_tree_children(old_parent):
1784
tt.adjust_path(tt.final_name(child), new_parent, child)
1786
def _reparent_transform_children(tt, old_parent, new_parent):
1787
by_parent = tt.by_parent()
1788
for child in by_parent[old_parent]:
1789
tt.adjust_path(tt.final_name(child), new_parent, child)
1790
return by_parent[old_parent]
1792
def _content_match(tree, entry, file_id, kind, target_path):
1793
if entry.kind != kind:
1795
if entry.kind == "directory":
1797
if entry.kind == "file":
1798
if tree.get_file(file_id).read() == file(target_path, 'rb').read():
1800
elif entry.kind == "symlink":
1801
if tree.get_symlink_target(file_id) == os.readlink(target_path):
1806
def resolve_checkout(tt, conflicts, divert):
1807
new_conflicts = set()
1808
for c_type, conflict in ((c[0], c) for c in conflicts):
1809
# Anything but a 'duplicate' would indicate programmer error
1810
if c_type != 'duplicate':
1811
raise AssertionError(c_type)
1812
# Now figure out which is new and which is old
1813
if tt.new_contents(conflict[1]):
1814
new_file = conflict[1]
1815
old_file = conflict[2]
1817
new_file = conflict[2]
1818
old_file = conflict[1]
1820
# We should only get here if the conflict wasn't completely
1822
final_parent = tt.final_parent(old_file)
1823
if new_file in divert:
1824
new_name = tt.final_name(old_file)+'.diverted'
1825
tt.adjust_path(new_name, final_parent, new_file)
1826
new_conflicts.add((c_type, 'Diverted to',
1827
new_file, old_file))
1829
new_name = tt.final_name(old_file)+'.moved'
1830
tt.adjust_path(new_name, final_parent, old_file)
1831
new_conflicts.add((c_type, 'Moved existing file to',
1832
old_file, new_file))
1833
return new_conflicts
1836
def new_by_entry(tt, entry, parent_id, tree):
1837
"""Create a new file according to its inventory entry"""
1841
contents = tree.get_file(entry.file_id).readlines()
1842
executable = tree.is_executable(entry.file_id)
1843
return tt.new_file(name, parent_id, contents, entry.file_id,
1845
elif kind in ('directory', 'tree-reference'):
1846
trans_id = tt.new_directory(name, parent_id, entry.file_id)
1847
if kind == 'tree-reference':
1848
tt.set_tree_reference(entry.reference_revision, trans_id)
1850
elif kind == 'symlink':
1851
target = tree.get_symlink_target(entry.file_id)
1852
return tt.new_symlink(name, parent_id, target, entry.file_id)
1854
raise errors.BadFileKindError(name, kind)
1857
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1858
"""Create new file contents according to an inventory entry."""
1859
if entry.kind == "file":
1861
lines = tree.get_file(entry.file_id).readlines()
1862
tt.create_file(lines, trans_id, mode_id=mode_id)
1863
elif entry.kind == "symlink":
1864
tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
1865
elif entry.kind == "directory":
1866
tt.create_directory(trans_id)
1869
def create_entry_executability(tt, entry, trans_id):
1870
"""Set the executability of a trans_id according to an inventory entry"""
1871
if entry.kind == "file":
1872
tt.set_executability(entry.executable, trans_id)
1875
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1876
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1879
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1880
"""Produce a backup-style name that appears to be available"""
1884
yield "%s.~%d~" % (name, counter)
1886
for new_name in name_gen():
1887
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
1891
def _entry_changes(file_id, entry, working_tree):
1892
"""Determine in which ways the inventory entry has changed.
1894
Returns booleans: has_contents, content_mod, meta_mod
1895
has_contents means there are currently contents, but they differ
1896
contents_mod means contents need to be modified
1897
meta_mod means the metadata needs to be modified
1899
cur_entry = working_tree.inventory[file_id]
1901
working_kind = working_tree.kind(file_id)
1904
has_contents = False
1907
if has_contents is True:
1908
if entry.kind != working_kind:
1909
contents_mod, meta_mod = True, False
1911
cur_entry._read_tree_state(working_tree.id2path(file_id),
1913
contents_mod, meta_mod = entry.detect_changes(cur_entry)
1914
cur_entry._forget_tree_state()
1915
return has_contents, contents_mod, meta_mod
1918
def revert(working_tree, target_tree, filenames, backups=False,
1919
pb=DummyProgress(), change_reporter=None):
1920
"""Revert a working tree's contents to those of a target tree."""
1921
target_tree.lock_read()
1922
tt = TreeTransform(working_tree, pb)
1924
pp = ProgressPhase("Revert phase", 3, pb)
1926
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1928
merge_modified = _alter_files(working_tree, target_tree, tt,
1929
child_pb, filenames, backups)
1933
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1935
raw_conflicts = resolve_conflicts(tt, child_pb,
1936
lambda t, c: conflict_pass(t, c, target_tree))
1939
conflicts = cook_conflicts(raw_conflicts, tt)
1941
change_reporter = delta._ChangeReporter(
1942
unversioned_filter=working_tree.is_ignored)
1943
delta.report_changes(tt.iter_changes(), change_reporter)
1944
for conflict in conflicts:
1948
working_tree.set_merge_modified(merge_modified)
1950
target_tree.unlock()
1956
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1958
merge_modified = working_tree.merge_modified()
1959
change_list = target_tree.iter_changes(working_tree,
1960
specific_files=specific_files, pb=pb)
1961
if target_tree.inventory.root is None:
1968
for id_num, (file_id, path, changed_content, versioned, parent, name,
1969
kind, executable) in enumerate(change_list):
1970
if skip_root and file_id[0] is not None and parent[0] is None:
1972
trans_id = tt.trans_id_file_id(file_id)
1975
keep_content = False
1976
if kind[0] == 'file' and (backups or kind[1] is None):
1977
wt_sha1 = working_tree.get_file_sha1(file_id)
1978
if merge_modified.get(file_id) != wt_sha1:
1979
# acquire the basis tree lazily to prevent the
1980
# expense of accessing it when it's not needed ?
1981
# (Guessing, RBC, 200702)
1982
if basis_tree is None:
1983
basis_tree = working_tree.basis_tree()
1984
basis_tree.lock_read()
1985
if file_id in basis_tree:
1986
if wt_sha1 != basis_tree.get_file_sha1(file_id):
1988
elif kind[1] is None and not versioned[1]:
1990
if kind[0] is not None:
1991
if not keep_content:
1992
tt.delete_contents(trans_id)
1993
elif kind[1] is not None:
1994
parent_trans_id = tt.trans_id_file_id(parent[0])
1995
by_parent = tt.by_parent()
1996
backup_name = _get_backup_name(name[0], by_parent,
1997
parent_trans_id, tt)
1998
tt.adjust_path(backup_name, parent_trans_id, trans_id)
1999
new_trans_id = tt.create_path(name[0], parent_trans_id)
2000
if versioned == (True, True):
2001
tt.unversion_file(trans_id)
2002
tt.version_file(file_id, new_trans_id)
2003
# New contents should have the same unix perms as old
2006
trans_id = new_trans_id
2007
if kind[1] == 'directory':
2008
tt.create_directory(trans_id)
2009
elif kind[1] == 'symlink':
2010
tt.create_symlink(target_tree.get_symlink_target(file_id),
2012
elif kind[1] == 'file':
2013
deferred_files.append((file_id, (trans_id, mode_id)))
2014
if basis_tree is None:
2015
basis_tree = working_tree.basis_tree()
2016
basis_tree.lock_read()
2017
new_sha1 = target_tree.get_file_sha1(file_id)
2018
if (file_id in basis_tree and new_sha1 ==
2019
basis_tree.get_file_sha1(file_id)):
2020
if file_id in merge_modified:
2021
del merge_modified[file_id]
2023
merge_modified[file_id] = new_sha1
2025
# preserve the execute bit when backing up
2026
if keep_content and executable[0] == executable[1]:
2027
tt.set_executability(executable[1], trans_id)
2028
elif kind[1] is not None:
2029
raise AssertionError(kind[1])
2030
if versioned == (False, True):
2031
tt.version_file(file_id, trans_id)
2032
if versioned == (True, False):
2033
tt.unversion_file(trans_id)
2034
if (name[1] is not None and
2035
(name[0] != name[1] or parent[0] != parent[1])):
2037
name[1], tt.trans_id_file_id(parent[1]), trans_id)
2038
if executable[0] != executable[1] and kind[1] == "file":
2039
tt.set_executability(executable[1], trans_id)
2040
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2042
tt.create_file(bytes, trans_id, mode_id)
2044
if basis_tree is not None:
2046
return merge_modified
2049
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2050
"""Make many conflict-resolution attempts, but die if they fail"""
2051
if pass_func is None:
2052
pass_func = conflict_pass
2053
new_conflicts = set()
2056
pb.update('Resolution pass', n+1, 10)
2057
conflicts = tt.find_conflicts()
2058
if len(conflicts) == 0:
2059
return new_conflicts
2060
new_conflicts.update(pass_func(tt, conflicts))
2061
raise MalformedTransform(conflicts=conflicts)
2066
def conflict_pass(tt, conflicts, path_tree=None):
2067
"""Resolve some classes of conflicts.
2069
:param tt: The transform to resolve conflicts in
2070
:param conflicts: The conflicts to resolve
2071
:param path_tree: A Tree to get supplemental paths from
2073
new_conflicts = set()
2074
for c_type, conflict in ((c[0], c) for c in conflicts):
2075
if c_type == 'duplicate id':
2076
tt.unversion_file(conflict[1])
2077
new_conflicts.add((c_type, 'Unversioned existing file',
2078
conflict[1], conflict[2], ))
2079
elif c_type == 'duplicate':
2080
# files that were renamed take precedence
2081
final_parent = tt.final_parent(conflict[1])
2082
if tt.path_changed(conflict[1]):
2083
existing_file, new_file = conflict[2], conflict[1]
2085
existing_file, new_file = conflict[1], conflict[2]
2086
new_name = tt.final_name(existing_file)+'.moved'
2087
tt.adjust_path(new_name, final_parent, existing_file)
2088
new_conflicts.add((c_type, 'Moved existing file to',
2089
existing_file, new_file))
2090
elif c_type == 'parent loop':
2091
# break the loop by undoing one of the ops that caused the loop
2093
while not tt.path_changed(cur):
2094
cur = tt.final_parent(cur)
2095
new_conflicts.add((c_type, 'Cancelled move', cur,
2096
tt.final_parent(cur),))
2097
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
2099
elif c_type == 'missing parent':
2100
trans_id = conflict[1]
2102
tt.cancel_deletion(trans_id)
2103
new_conflicts.add(('deleting parent', 'Not deleting',
2108
tt.final_name(trans_id)
2110
if path_tree is not None:
2111
file_id = tt.final_file_id(trans_id)
2113
file_id = tt.inactive_file_id(trans_id)
2114
entry = path_tree.inventory[file_id]
2115
# special-case the other tree root (move its
2116
# children to current root)
2117
if entry.parent_id is None:
2119
moved = _reparent_transform_children(
2120
tt, trans_id, tt.root)
2122
new_conflicts.add((c_type, 'Moved to root',
2125
parent_trans_id = tt.trans_id_file_id(
2127
tt.adjust_path(entry.name, parent_trans_id,
2130
tt.create_directory(trans_id)
2131
new_conflicts.add((c_type, 'Created directory', trans_id))
2132
elif c_type == 'unversioned parent':
2133
file_id = tt.inactive_file_id(conflict[1])
2134
# special-case the other tree root (move its children instead)
2135
if path_tree and file_id in path_tree:
2136
if path_tree.inventory[file_id].parent_id is None:
2138
tt.version_file(file_id, conflict[1])
2139
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2140
elif c_type == 'non-directory parent':
2141
parent_id = conflict[1]
2142
parent_parent = tt.final_parent(parent_id)
2143
parent_name = tt.final_name(parent_id)
2144
parent_file_id = tt.final_file_id(parent_id)
2145
new_parent_id = tt.new_directory(parent_name + '.new',
2146
parent_parent, parent_file_id)
2147
_reparent_transform_children(tt, parent_id, new_parent_id)
2148
if parent_file_id is not None:
2149
tt.unversion_file(parent_id)
2150
new_conflicts.add((c_type, 'Created directory', new_parent_id))
2151
return new_conflicts
2154
def cook_conflicts(raw_conflicts, tt):
2155
"""Generate a list of cooked conflicts, sorted by file path"""
2156
from bzrlib.conflicts import Conflict
2157
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
2158
return sorted(conflict_iter, key=Conflict.sort_key)
2161
def iter_cook_conflicts(raw_conflicts, tt):
2162
from bzrlib.conflicts import Conflict
2164
for conflict in raw_conflicts:
2165
c_type = conflict[0]
2166
action = conflict[1]
2167
modified_path = fp.get_path(conflict[2])
2168
modified_id = tt.final_file_id(conflict[2])
2169
if len(conflict) == 3:
2170
yield Conflict.factory(c_type, action=action, path=modified_path,
2171
file_id=modified_id)
2174
conflicting_path = fp.get_path(conflict[3])
2175
conflicting_id = tt.final_file_id(conflict[3])
2176
yield Conflict.factory(c_type, action=action, path=modified_path,
2177
file_id=modified_id,
2178
conflict_path=conflicting_path,
2179
conflict_file_id=conflicting_id)
2182
class _FileMover(object):
2183
"""Moves and deletes files for TreeTransform, tracking operations"""
2186
self.past_renames = []
2187
self.pending_deletions = []
2189
def rename(self, from_, to):
2190
"""Rename a file from one path to another. Functions like os.rename"""
2192
os.rename(from_, to)
2194
if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2195
raise errors.FileExists(to, str(e))
2197
self.past_renames.append((from_, to))
2199
def pre_delete(self, from_, to):
2200
"""Rename a file out of the way and mark it for deletion.
2202
Unlike os.unlink, this works equally well for files and directories.
2203
:param from_: The current file path
2204
:param to: A temporary path for the file
2206
self.rename(from_, to)
2207
self.pending_deletions.append(to)
2210
"""Reverse all renames that have been performed"""
2211
for from_, to in reversed(self.past_renames):
2212
os.rename(to, from_)
2213
# after rollback, don't reuse _FileMover
2215
pending_deletions = None
2217
def apply_deletions(self):
2218
"""Apply all marked deletions"""
2219
for path in self.pending_deletions:
2221
# after apply_deletions, don't reuse _FileMover
2223
pending_deletions = None
added
removed
bzrlib/transform.py
