1
# Copyright (C) 2006-2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
from stat import S_ISREG, S_IEXEC
29
lazy_import.lazy_import(globals(), """
40
revision as _mod_revision,
45
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
46
ReusingTransform, CantMoveRoot,
47
ExistingLimbo, ImmortalLimbo, NoFinalPath,
49
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
50
from bzrlib.osutils import (
59
from bzrlib.progress import ProgressPhase
60
from bzrlib.symbol_versioning import (
67
ROOT_PARENT = "root-parent"
69
def unique_add(map, key, value):
71
raise DuplicateKey(key=key)
76
class _TransformResults(object):
77
def __init__(self, modified_paths, rename_count):
79
self.modified_paths = modified_paths
80
self.rename_count = rename_count
83
class TreeTransformBase(object):
84
"""The base class for TreeTransform and its kin."""
86
def __init__(self, tree, pb=None,
90
:param tree: The tree that will be transformed, but not necessarily
93
:param case_sensitive: If True, the target of the transform is
94
case sensitive, not just case preserving.
99
# mapping of trans_id -> new basename
101
# mapping of trans_id -> new parent trans_id
102
self._new_parent = {}
103
# mapping of trans_id with new contents -> new file_kind
104
self._new_contents = {}
105
# mapping of trans_id => (sha1 of content, stat_value)
106
self._observed_sha1s = {}
107
# Set of trans_ids whose contents will be removed
108
self._removed_contents = set()
109
# Mapping of trans_id -> new execute-bit value
110
self._new_executability = {}
111
# Mapping of trans_id -> new tree-reference value
112
self._new_reference_revision = {}
113
# Mapping of trans_id -> new file_id
115
# Mapping of old file-id -> trans_id
116
self._non_present_ids = {}
117
# Mapping of new file_id -> trans_id
119
# Set of trans_ids that will be removed
120
self._removed_id = set()
121
# Mapping of path in old tree -> trans_id
122
self._tree_path_ids = {}
123
# Mapping trans_id -> path in old tree
124
self._tree_id_paths = {}
125
# The trans_id that will be used as the tree root
126
root_id = tree.get_root_id()
127
if root_id is not None:
128
self._new_root = self.trans_id_tree_file_id(root_id)
130
self._new_root = None
131
# Indicator of whether the transform has been applied
135
# Whether the target is case sensitive
136
self._case_sensitive_target = case_sensitive
137
# A counter of how many files have been renamed
138
self.rename_count = 0
141
"""Release the working tree lock, if held.
143
This is required if apply has not been invoked, but can be invoked
146
if self._tree is None:
151
def __get_root(self):
152
return self._new_root
154
root = property(__get_root)
156
def _assign_id(self):
157
"""Produce a new tranform id"""
158
new_id = "new-%s" % self._id_number
162
def create_path(self, name, parent):
163
"""Assign a transaction id to a new path"""
164
trans_id = self._assign_id()
165
unique_add(self._new_name, trans_id, name)
166
unique_add(self._new_parent, trans_id, parent)
169
def adjust_path(self, name, parent, trans_id):
170
"""Change the path that is assigned to a transaction id."""
172
raise ValueError("Parent trans-id may not be None")
173
if trans_id == self._new_root:
175
self._new_name[trans_id] = name
176
self._new_parent[trans_id] = parent
178
def adjust_root_path(self, name, parent):
179
"""Emulate moving the root by moving all children, instead.
181
We do this by undoing the association of root's transaction id with the
182
current tree. This allows us to create a new directory with that
183
transaction id. We unversion the root directory and version the
184
physically new directory, and hope someone versions the tree root
187
old_root = self._new_root
188
old_root_file_id = self.final_file_id(old_root)
189
# force moving all children of root
190
for child_id in self.iter_tree_children(old_root):
191
if child_id != parent:
192
self.adjust_path(self.final_name(child_id),
193
self.final_parent(child_id), child_id)
194
file_id = self.final_file_id(child_id)
195
if file_id is not None:
196
self.unversion_file(child_id)
197
self.version_file(file_id, child_id)
199
# the physical root needs a new transaction id
200
self._tree_path_ids.pop("")
201
self._tree_id_paths.pop(old_root)
202
self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
203
if parent == old_root:
204
parent = self._new_root
205
self.adjust_path(name, parent, old_root)
206
self.create_directory(old_root)
207
self.version_file(old_root_file_id, old_root)
208
self.unversion_file(self._new_root)
210
def fixup_new_roots(self):
211
"""Reinterpret requests to change the root directory
213
Instead of creating a root directory, or moving an existing directory,
214
all the attributes and children of the new root are applied to the
215
existing root directory.
217
This means that the old root trans-id becomes obsolete, so it is
218
recommended only to invoke this after the root trans-id has become
221
new_roots = [k for k, v in self._new_parent.iteritems() if v is
223
if len(new_roots) < 1:
225
if len(new_roots) != 1:
226
raise ValueError('A tree cannot have two roots!')
227
if self._new_root is None:
228
self._new_root = new_roots[0]
230
old_new_root = new_roots[0]
231
# TODO: What to do if a old_new_root is present, but self._new_root is
232
# not listed as being removed? This code explicitly unversions
233
# the old root and versions it with the new file_id. Though that
234
# seems like an incomplete delta
236
# unversion the new root's directory.
237
file_id = self.final_file_id(old_new_root)
238
if old_new_root in self._new_id:
239
self.cancel_versioning(old_new_root)
241
self.unversion_file(old_new_root)
242
# if, at this stage, root still has an old file_id, zap it so we can
243
# stick a new one in.
244
if (self.tree_file_id(self._new_root) is not None and
245
self._new_root not in self._removed_id):
246
self.unversion_file(self._new_root)
247
self.version_file(file_id, self._new_root)
249
# Now move children of new root into old root directory.
250
# Ensure all children are registered with the transaction, but don't
251
# use directly-- some tree children have new parents
252
list(self.iter_tree_children(old_new_root))
253
# Move all children of new root into old root directory.
254
for child in self.by_parent().get(old_new_root, []):
255
self.adjust_path(self.final_name(child), self._new_root, child)
257
# Ensure old_new_root has no directory.
258
if old_new_root in self._new_contents:
259
self.cancel_creation(old_new_root)
261
self.delete_contents(old_new_root)
263
# prevent deletion of root directory.
264
if self._new_root in self._removed_contents:
265
self.cancel_deletion(self._new_root)
267
# destroy path info for old_new_root.
268
del self._new_parent[old_new_root]
269
del self._new_name[old_new_root]
271
def trans_id_tree_file_id(self, inventory_id):
272
"""Determine the transaction id of a working tree file.
274
This reflects only files that already exist, not ones that will be
275
added by transactions.
277
if inventory_id is None:
278
raise ValueError('None is not a valid file id')
279
path = self._tree.id2path(inventory_id)
280
return self.trans_id_tree_path(path)
282
def trans_id_file_id(self, file_id):
283
"""Determine or set the transaction id associated with a file ID.
284
A new id is only created for file_ids that were never present. If
285
a transaction has been unversioned, it is deliberately still returned.
286
(this will likely lead to an unversioned parent conflict.)
289
raise ValueError('None is not a valid file id')
290
if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
291
return self._r_new_id[file_id]
294
self._tree.iter_entries_by_dir([file_id]).next()
295
except StopIteration:
296
if file_id in self._non_present_ids:
297
return self._non_present_ids[file_id]
299
trans_id = self._assign_id()
300
self._non_present_ids[file_id] = trans_id
303
return self.trans_id_tree_file_id(file_id)
305
def trans_id_tree_path(self, path):
306
"""Determine (and maybe set) the transaction ID for a tree path."""
307
path = self.canonical_path(path)
308
if path not in self._tree_path_ids:
309
self._tree_path_ids[path] = self._assign_id()
310
self._tree_id_paths[self._tree_path_ids[path]] = path
311
return self._tree_path_ids[path]
313
def get_tree_parent(self, trans_id):
314
"""Determine id of the parent in the tree."""
315
path = self._tree_id_paths[trans_id]
318
return self.trans_id_tree_path(os.path.dirname(path))
320
def delete_contents(self, trans_id):
321
"""Schedule the contents of a path entry for deletion"""
322
kind = self.tree_kind(trans_id)
324
self._removed_contents.add(trans_id)
326
def cancel_deletion(self, trans_id):
327
"""Cancel a scheduled deletion"""
328
self._removed_contents.remove(trans_id)
330
def unversion_file(self, trans_id):
331
"""Schedule a path entry to become unversioned"""
332
self._removed_id.add(trans_id)
334
def delete_versioned(self, trans_id):
335
"""Delete and unversion a versioned file"""
336
self.delete_contents(trans_id)
337
self.unversion_file(trans_id)
339
def set_executability(self, executability, trans_id):
340
"""Schedule setting of the 'execute' bit
341
To unschedule, set to None
343
if executability is None:
344
del self._new_executability[trans_id]
346
unique_add(self._new_executability, trans_id, executability)
348
def set_tree_reference(self, revision_id, trans_id):
349
"""Set the reference associated with a directory"""
350
unique_add(self._new_reference_revision, trans_id, revision_id)
352
def version_file(self, file_id, trans_id):
353
"""Schedule a file to become versioned."""
356
unique_add(self._new_id, trans_id, file_id)
357
unique_add(self._r_new_id, file_id, trans_id)
359
def cancel_versioning(self, trans_id):
360
"""Undo a previous versioning of a file"""
361
file_id = self._new_id[trans_id]
362
del self._new_id[trans_id]
363
del self._r_new_id[file_id]
365
def new_paths(self, filesystem_only=False):
366
"""Determine the paths of all new and changed files.
368
:param filesystem_only: if True, only calculate values for files
369
that require renames or execute bit changes.
373
stale_ids = self._needs_rename.difference(self._new_name)
374
stale_ids.difference_update(self._new_parent)
375
stale_ids.difference_update(self._new_contents)
376
stale_ids.difference_update(self._new_id)
377
needs_rename = self._needs_rename.difference(stale_ids)
378
id_sets = (needs_rename, self._new_executability)
380
id_sets = (self._new_name, self._new_parent, self._new_contents,
381
self._new_id, self._new_executability)
382
for id_set in id_sets:
383
new_ids.update(id_set)
384
return sorted(FinalPaths(self).get_paths(new_ids))
386
def _inventory_altered(self):
387
"""Get the trans_ids and paths of files needing new inv entries."""
389
for id_set in [self._new_name, self._new_parent, self._new_id,
390
self._new_executability]:
391
new_ids.update(id_set)
392
changed_kind = set(self._removed_contents)
393
changed_kind.intersection_update(self._new_contents)
394
changed_kind.difference_update(new_ids)
395
changed_kind = (t for t in changed_kind
396
if self.tree_kind(t) != self.final_kind(t))
397
new_ids.update(changed_kind)
398
return sorted(FinalPaths(self).get_paths(new_ids))
400
def final_kind(self, trans_id):
401
"""Determine the final file kind, after any changes applied.
403
:return: None if the file does not exist/has no contents. (It is
404
conceivable that a path would be created without the corresponding
405
contents insertion command)
407
if trans_id in self._new_contents:
408
return self._new_contents[trans_id]
409
elif trans_id in self._removed_contents:
412
return self.tree_kind(trans_id)
414
def tree_file_id(self, trans_id):
415
"""Determine the file id associated with the trans_id in the tree"""
417
path = self._tree_id_paths[trans_id]
419
# the file is a new, unversioned file, or invalid trans_id
421
# the file is old; the old id is still valid
422
if self._new_root == trans_id:
423
return self._tree.get_root_id()
424
return self._tree.path2id(path)
426
def final_file_id(self, trans_id):
427
"""Determine the file id after any changes are applied, or None.
429
None indicates that the file will not be versioned after changes are
433
return self._new_id[trans_id]
435
if trans_id in self._removed_id:
437
return self.tree_file_id(trans_id)
439
def inactive_file_id(self, trans_id):
440
"""Return the inactive file_id associated with a transaction id.
441
That is, the one in the tree or in non_present_ids.
442
The file_id may actually be active, too.
444
file_id = self.tree_file_id(trans_id)
445
if file_id is not None:
447
for key, value in self._non_present_ids.iteritems():
448
if value == trans_id:
451
def final_parent(self, trans_id):
452
"""Determine the parent file_id, after any changes are applied.
454
ROOT_PARENT is returned for the tree root.
457
return self._new_parent[trans_id]
459
return self.get_tree_parent(trans_id)
461
def final_name(self, trans_id):
462
"""Determine the final filename, after all changes are applied."""
464
return self._new_name[trans_id]
467
return os.path.basename(self._tree_id_paths[trans_id])
469
raise NoFinalPath(trans_id, self)
472
"""Return a map of parent: children for known parents.
474
Only new paths and parents of tree files with assigned ids are used.
477
items = list(self._new_parent.iteritems())
478
items.extend((t, self.final_parent(t)) for t in
479
self._tree_id_paths.keys())
480
for trans_id, parent_id in items:
481
if parent_id not in by_parent:
482
by_parent[parent_id] = set()
483
by_parent[parent_id].add(trans_id)
486
def path_changed(self, trans_id):
487
"""Return True if a trans_id's path has changed."""
488
return (trans_id in self._new_name) or (trans_id in self._new_parent)
490
def new_contents(self, trans_id):
491
return (trans_id in self._new_contents)
493
def find_conflicts(self):
494
"""Find any violations of inventory or filesystem invariants"""
495
if self._done is True:
496
raise ReusingTransform()
498
# ensure all children of all existent parents are known
499
# all children of non-existent parents are known, by definition.
500
self._add_tree_children()
501
by_parent = self.by_parent()
502
conflicts.extend(self._unversioned_parents(by_parent))
503
conflicts.extend(self._parent_loops())
504
conflicts.extend(self._duplicate_entries(by_parent))
505
conflicts.extend(self._duplicate_ids())
506
conflicts.extend(self._parent_type_conflicts(by_parent))
507
conflicts.extend(self._improper_versioning())
508
conflicts.extend(self._executability_conflicts())
509
conflicts.extend(self._overwrite_conflicts())
512
def _check_malformed(self):
513
conflicts = self.find_conflicts()
514
if len(conflicts) != 0:
515
raise MalformedTransform(conflicts=conflicts)
517
def _add_tree_children(self):
518
"""Add all the children of all active parents to the known paths.
520
Active parents are those which gain children, and those which are
521
removed. This is a necessary first step in detecting conflicts.
523
parents = self.by_parent().keys()
524
parents.extend([t for t in self._removed_contents if
525
self.tree_kind(t) == 'directory'])
526
for trans_id in self._removed_id:
527
file_id = self.tree_file_id(trans_id)
528
if file_id is not None:
529
# XXX: This seems like something that should go via a different
531
if self._tree.inventory[file_id].kind == 'directory':
532
parents.append(trans_id)
533
elif self.tree_kind(trans_id) == 'directory':
534
parents.append(trans_id)
536
for parent_id in parents:
537
# ensure that all children are registered with the transaction
538
list(self.iter_tree_children(parent_id))
540
@deprecated_method(deprecated_in((2, 3, 0)))
541
def has_named_child(self, by_parent, parent_id, name):
542
return self._has_named_child(
543
name, parent_id, known_children=by_parent.get(parent_id, []))
545
def _has_named_child(self, name, parent_id, known_children):
546
"""Does a parent already have a name child.
548
:param name: The searched for name.
550
:param parent_id: The parent for which the check is made.
552
:param known_children: The already known children. This should have
553
been recently obtained from `self.by_parent.get(parent_id)`
554
(or will be if None is passed).
556
if known_children is None:
557
known_children = self.by_parent().get(parent_id, [])
558
for child in known_children:
559
if self.final_name(child) == name:
561
parent_path = self._tree_id_paths.get(parent_id, None)
562
if parent_path is None:
563
# No parent... no children
565
child_path = joinpath(parent_path, name)
566
child_id = self._tree_path_ids.get(child_path, None)
568
# Not known by the tree transform yet, check the filesystem
569
return osutils.lexists(self._tree.abspath(child_path))
571
raise AssertionError('child_id is missing: %s, %s, %s'
572
% (name, parent_id, child_id))
574
def _available_backup_name(self, name, target_id):
575
"""Find an available backup name.
577
:param name: The basename of the file.
579
:param target_id: The directory trans_id where the backup should
582
known_children = self.by_parent().get(target_id, [])
583
return osutils.available_backup_name(
585
lambda base: self._has_named_child(
586
base, target_id, known_children))
588
def _parent_loops(self):
589
"""No entry should be its own ancestor"""
591
for trans_id in self._new_parent:
594
while parent_id is not ROOT_PARENT:
597
parent_id = self.final_parent(parent_id)
600
if parent_id == trans_id:
601
conflicts.append(('parent loop', trans_id))
602
if parent_id in seen:
606
def _unversioned_parents(self, by_parent):
607
"""If parent directories are versioned, children must be versioned."""
609
for parent_id, children in by_parent.iteritems():
610
if parent_id is ROOT_PARENT:
612
if self.final_file_id(parent_id) is not None:
614
for child_id in children:
615
if self.final_file_id(child_id) is not None:
616
conflicts.append(('unversioned parent', parent_id))
620
def _improper_versioning(self):
621
"""Cannot version a file with no contents, or a bad type.
623
However, existing entries with no contents are okay.
626
for trans_id in self._new_id.iterkeys():
627
kind = self.final_kind(trans_id)
629
conflicts.append(('versioning no contents', trans_id))
631
if not inventory.InventoryEntry.versionable_kind(kind):
632
conflicts.append(('versioning bad kind', trans_id, kind))
635
def _executability_conflicts(self):
636
"""Check for bad executability changes.
638
Only versioned files may have their executability set, because
639
1. only versioned entries can have executability under windows
640
2. only files can be executable. (The execute bit on a directory
641
does not indicate searchability)
644
for trans_id in self._new_executability:
645
if self.final_file_id(trans_id) is None:
646
conflicts.append(('unversioned executability', trans_id))
648
if self.final_kind(trans_id) != "file":
649
conflicts.append(('non-file executability', trans_id))
652
def _overwrite_conflicts(self):
653
"""Check for overwrites (not permitted on Win32)"""
655
for trans_id in self._new_contents:
656
if self.tree_kind(trans_id) is None:
658
if trans_id not in self._removed_contents:
659
conflicts.append(('overwrite', trans_id,
660
self.final_name(trans_id)))
663
def _duplicate_entries(self, by_parent):
664
"""No directory may have two entries with the same name."""
666
if (self._new_name, self._new_parent) == ({}, {}):
668
for children in by_parent.itervalues():
670
for child_tid in children:
671
name = self.final_name(child_tid)
673
# Keep children only if they still exist in the end
674
if not self._case_sensitive_target:
676
name_ids.append((name, child_tid))
680
for name, trans_id in name_ids:
681
kind = self.final_kind(trans_id)
682
file_id = self.final_file_id(trans_id)
683
if kind is None and file_id is None:
685
if name == last_name:
686
conflicts.append(('duplicate', last_trans_id, trans_id,
689
last_trans_id = trans_id
692
def _duplicate_ids(self):
693
"""Each inventory id may only be used once"""
695
removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
697
all_ids = self._tree.all_file_ids()
698
active_tree_ids = all_ids.difference(removed_tree_ids)
699
for trans_id, file_id in self._new_id.iteritems():
700
if file_id in active_tree_ids:
701
old_trans_id = self.trans_id_tree_file_id(file_id)
702
conflicts.append(('duplicate id', old_trans_id, trans_id))
705
def _parent_type_conflicts(self, by_parent):
706
"""Children must have a directory parent"""
708
for parent_id, children in by_parent.iteritems():
709
if parent_id is ROOT_PARENT:
712
for child_id in children:
713
if self.final_kind(child_id) is not None:
718
# There is at least a child, so we need an existing directory to
720
kind = self.final_kind(parent_id)
722
# The directory will be deleted
723
conflicts.append(('missing parent', parent_id))
724
elif kind != "directory":
725
# Meh, we need a *directory* to put something in it
726
conflicts.append(('non-directory parent', parent_id))
729
def _set_executability(self, path, trans_id):
730
"""Set the executability of versioned files """
731
if supports_executable():
732
new_executability = self._new_executability[trans_id]
733
abspath = self._tree.abspath(path)
734
current_mode = os.stat(abspath).st_mode
735
if new_executability:
738
to_mode = current_mode | (0100 & ~umask)
739
# Enable x-bit for others only if they can read it.
740
if current_mode & 0004:
741
to_mode |= 0001 & ~umask
742
if current_mode & 0040:
743
to_mode |= 0010 & ~umask
745
to_mode = current_mode & ~0111
746
os.chmod(abspath, to_mode)
748
def _new_entry(self, name, parent_id, file_id):
749
"""Helper function to create a new filesystem entry."""
750
trans_id = self.create_path(name, parent_id)
751
if file_id is not None:
752
self.version_file(file_id, trans_id)
755
def new_file(self, name, parent_id, contents, file_id=None,
756
executable=None, sha1=None):
757
"""Convenience method to create files.
759
name is the name of the file to create.
760
parent_id is the transaction id of the parent directory of the file.
761
contents is an iterator of bytestrings, which will be used to produce
763
:param file_id: The inventory ID of the file, if it is to be versioned.
764
:param executable: Only valid when a file_id has been supplied.
766
trans_id = self._new_entry(name, parent_id, file_id)
767
# TODO: rather than scheduling a set_executable call,
768
# have create_file create the file with the right mode.
769
self.create_file(contents, trans_id, sha1=sha1)
770
if executable is not None:
771
self.set_executability(executable, trans_id)
774
def new_directory(self, name, parent_id, file_id=None):
775
"""Convenience method to create directories.
777
name is the name of the directory to create.
778
parent_id is the transaction id of the parent directory of the
780
file_id is the inventory ID of the directory, if it is to be versioned.
782
trans_id = self._new_entry(name, parent_id, file_id)
783
self.create_directory(trans_id)
786
def new_symlink(self, name, parent_id, target, file_id=None):
787
"""Convenience method to create symbolic link.
789
name is the name of the symlink to create.
790
parent_id is the transaction id of the parent directory of the symlink.
791
target is a bytestring of the target of the symlink.
792
file_id is the inventory ID of the file, if it is to be versioned.
794
trans_id = self._new_entry(name, parent_id, file_id)
795
self.create_symlink(target, trans_id)
798
def new_orphan(self, trans_id, parent_id):
799
"""Schedule an item to be orphaned.
801
When a directory is about to be removed, its children, if they are not
802
versioned are moved out of the way: they don't have a parent anymore.
804
:param trans_id: The trans_id of the existing item.
805
:param parent_id: The parent trans_id of the item.
807
raise NotImplementedError(self.new_orphan)
809
def _get_potential_orphans(self, dir_id):
810
"""Find the potential orphans in a directory.
812
A directory can't be safely deleted if there are versioned files in it.
813
If all the contained files are unversioned then they can be orphaned.
815
The 'None' return value means that the directory contains at least one
816
versioned file and should not be deleted.
818
:param dir_id: The directory trans id.
820
:return: A list of the orphan trans ids or None if at least one
821
versioned file is present.
824
# Find the potential orphans, stop if one item should be kept
825
for child_tid in self.by_parent()[dir_id]:
826
if child_tid in self._removed_contents:
827
# The child is removed as part of the transform. Since it was
828
# versioned before, it's not an orphan
830
elif self.final_file_id(child_tid) is None:
831
# The child is not versioned
832
orphans.append(child_tid)
834
# We have a versioned file here, searching for orphans is
840
def _affected_ids(self):
841
"""Return the set of transform ids affected by the transform"""
842
trans_ids = set(self._removed_id)
843
trans_ids.update(self._new_id.keys())
844
trans_ids.update(self._removed_contents)
845
trans_ids.update(self._new_contents.keys())
846
trans_ids.update(self._new_executability.keys())
847
trans_ids.update(self._new_name.keys())
848
trans_ids.update(self._new_parent.keys())
851
def _get_file_id_maps(self):
852
"""Return mapping of file_ids to trans_ids in the to and from states"""
853
trans_ids = self._affected_ids()
856
# Build up two dicts: trans_ids associated with file ids in the
857
# FROM state, vs the TO state.
858
for trans_id in trans_ids:
859
from_file_id = self.tree_file_id(trans_id)
860
if from_file_id is not None:
861
from_trans_ids[from_file_id] = trans_id
862
to_file_id = self.final_file_id(trans_id)
863
if to_file_id is not None:
864
to_trans_ids[to_file_id] = trans_id
865
return from_trans_ids, to_trans_ids
867
def _from_file_data(self, from_trans_id, from_versioned, file_id):
868
"""Get data about a file in the from (tree) state
870
Return a (name, parent, kind, executable) tuple
872
from_path = self._tree_id_paths.get(from_trans_id)
874
# get data from working tree if versioned
875
from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
876
from_name = from_entry.name
877
from_parent = from_entry.parent_id
880
if from_path is None:
881
# File does not exist in FROM state
885
# File exists, but is not versioned. Have to use path-
887
from_name = os.path.basename(from_path)
888
tree_parent = self.get_tree_parent(from_trans_id)
889
from_parent = self.tree_file_id(tree_parent)
890
if from_path is not None:
891
from_kind, from_executable, from_stats = \
892
self._tree._comparison_data(from_entry, from_path)
895
from_executable = False
896
return from_name, from_parent, from_kind, from_executable
898
def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
899
"""Get data about a file in the to (target) state
901
Return a (name, parent, kind, executable) tuple
903
to_name = self.final_name(to_trans_id)
904
to_kind = self.final_kind(to_trans_id)
905
to_parent = self.final_file_id(self.final_parent(to_trans_id))
906
if to_trans_id in self._new_executability:
907
to_executable = self._new_executability[to_trans_id]
908
elif to_trans_id == from_trans_id:
909
to_executable = from_executable
911
to_executable = False
912
return to_name, to_parent, to_kind, to_executable
914
def iter_changes(self):
915
"""Produce output in the same format as Tree.iter_changes.
917
Will produce nonsensical results if invoked while inventory/filesystem
918
conflicts (as reported by TreeTransform.find_conflicts()) are present.
920
This reads the Transform, but only reproduces changes involving a
921
file_id. Files that are not versioned in either of the FROM or TO
922
states are not reflected.
924
final_paths = FinalPaths(self)
925
from_trans_ids, to_trans_ids = self._get_file_id_maps()
927
# Now iterate through all active file_ids
928
for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
930
from_trans_id = from_trans_ids.get(file_id)
931
# find file ids, and determine versioning state
932
if from_trans_id is None:
933
from_versioned = False
934
from_trans_id = to_trans_ids[file_id]
936
from_versioned = True
937
to_trans_id = to_trans_ids.get(file_id)
938
if to_trans_id is None:
940
to_trans_id = from_trans_id
944
from_name, from_parent, from_kind, from_executable = \
945
self._from_file_data(from_trans_id, from_versioned, file_id)
947
to_name, to_parent, to_kind, to_executable = \
948
self._to_file_data(to_trans_id, from_trans_id, from_executable)
950
if not from_versioned:
953
from_path = self._tree_id_paths.get(from_trans_id)
957
to_path = final_paths.get_path(to_trans_id)
958
if from_kind != to_kind:
960
elif to_kind in ('file', 'symlink') and (
961
to_trans_id != from_trans_id or
962
to_trans_id in self._new_contents):
964
if (not modified and from_versioned == to_versioned and
965
from_parent==to_parent and from_name == to_name and
966
from_executable == to_executable):
968
results.append((file_id, (from_path, to_path), modified,
969
(from_versioned, to_versioned),
970
(from_parent, to_parent),
971
(from_name, to_name),
972
(from_kind, to_kind),
973
(from_executable, to_executable)))
974
return iter(sorted(results, key=lambda x:x[1]))
976
def get_preview_tree(self):
977
"""Return a tree representing the result of the transform.
979
The tree is a snapshot, and altering the TreeTransform will invalidate
982
return _PreviewTree(self)
984
def commit(self, branch, message, merge_parents=None, strict=False,
985
timestamp=None, timezone=None, committer=None, authors=None,
986
revprops=None, revision_id=None):
987
"""Commit the result of this TreeTransform to a branch.
989
:param branch: The branch to commit to.
990
:param message: The message to attach to the commit.
991
:param merge_parents: Additional parent revision-ids specified by
993
:param strict: If True, abort the commit if there are unversioned
995
:param timestamp: if not None, seconds-since-epoch for the time and
996
date. (May be a float.)
997
:param timezone: Optional timezone for timestamp, as an offset in
999
:param committer: Optional committer in email-id format.
1000
(e.g. "J Random Hacker <jrandom@example.com>")
1001
:param authors: Optional list of authors in email-id format.
1002
:param revprops: Optional dictionary of revision properties.
1003
:param revision_id: Optional revision id. (Specifying a revision-id
1004
may reduce performance for some non-native formats.)
1005
:return: The revision_id of the revision committed.
1007
self._check_malformed()
1009
unversioned = set(self._new_contents).difference(set(self._new_id))
1010
for trans_id in unversioned:
1011
if self.final_file_id(trans_id) is None:
1012
raise errors.StrictCommitFailed()
1014
revno, last_rev_id = branch.last_revision_info()
1015
if last_rev_id == _mod_revision.NULL_REVISION:
1016
if merge_parents is not None:
1017
raise ValueError('Cannot supply merge parents for first'
1021
parent_ids = [last_rev_id]
1022
if merge_parents is not None:
1023
parent_ids.extend(merge_parents)
1024
if self._tree.get_revision_id() != last_rev_id:
1025
raise ValueError('TreeTransform not based on branch basis: %s' %
1026
self._tree.get_revision_id())
1027
revprops = commit.Commit.update_revprops(revprops, branch, authors)
1028
builder = branch.get_commit_builder(parent_ids,
1029
timestamp=timestamp,
1031
committer=committer,
1033
revision_id=revision_id)
1034
preview = self.get_preview_tree()
1035
list(builder.record_iter_changes(preview, last_rev_id,
1036
self.iter_changes()))
1037
builder.finish_inventory()
1038
revision_id = builder.commit(message)
1039
branch.set_last_revision_info(revno + 1, revision_id)
1042
def _text_parent(self, trans_id):
1043
file_id = self.tree_file_id(trans_id)
1045
if file_id is None or self._tree.kind(file_id) != 'file':
1047
except errors.NoSuchFile:
1051
def _get_parents_texts(self, trans_id):
1052
"""Get texts for compression parents of this file."""
1053
file_id = self._text_parent(trans_id)
1056
return (self._tree.get_file_text(file_id),)
1058
def _get_parents_lines(self, trans_id):
1059
"""Get lines for compression parents of this file."""
1060
file_id = self._text_parent(trans_id)
1063
return (self._tree.get_file_lines(file_id),)
1065
def serialize(self, serializer):
1066
"""Serialize this TreeTransform.
1068
:param serializer: A Serialiser like pack.ContainerSerializer.
1070
new_name = dict((k, v.encode('utf-8')) for k, v in
1071
self._new_name.items())
1072
new_executability = dict((k, int(v)) for k, v in
1073
self._new_executability.items())
1074
tree_path_ids = dict((k.encode('utf-8'), v)
1075
for k, v in self._tree_path_ids.items())
1077
'_id_number': self._id_number,
1078
'_new_name': new_name,
1079
'_new_parent': self._new_parent,
1080
'_new_executability': new_executability,
1081
'_new_id': self._new_id,
1082
'_tree_path_ids': tree_path_ids,
1083
'_removed_id': list(self._removed_id),
1084
'_removed_contents': list(self._removed_contents),
1085
'_non_present_ids': self._non_present_ids,
1087
yield serializer.bytes_record(bencode.bencode(attribs),
1089
for trans_id, kind in self._new_contents.items():
1091
lines = osutils.chunks_to_lines(
1092
self._read_file_chunks(trans_id))
1093
parents = self._get_parents_lines(trans_id)
1094
mpdiff = multiparent.MultiParent.from_lines(lines, parents)
1095
content = ''.join(mpdiff.to_patch())
1096
if kind == 'directory':
1098
if kind == 'symlink':
1099
content = self._read_symlink_target(trans_id)
1100
yield serializer.bytes_record(content, ((trans_id, kind),))
1102
def deserialize(self, records):
1103
"""Deserialize a stored TreeTransform.
1105
:param records: An iterable of (names, content) tuples, as per
1106
pack.ContainerPushParser.
1108
names, content = records.next()
1109
attribs = bencode.bdecode(content)
1110
self._id_number = attribs['_id_number']
1111
self._new_name = dict((k, v.decode('utf-8'))
1112
for k, v in attribs['_new_name'].items())
1113
self._new_parent = attribs['_new_parent']
1114
self._new_executability = dict((k, bool(v)) for k, v in
1115
attribs['_new_executability'].items())
1116
self._new_id = attribs['_new_id']
1117
self._r_new_id = dict((v, k) for k, v in self._new_id.items())
1118
self._tree_path_ids = {}
1119
self._tree_id_paths = {}
1120
for bytepath, trans_id in attribs['_tree_path_ids'].items():
1121
path = bytepath.decode('utf-8')
1122
self._tree_path_ids[path] = trans_id
1123
self._tree_id_paths[trans_id] = path
1124
self._removed_id = set(attribs['_removed_id'])
1125
self._removed_contents = set(attribs['_removed_contents'])
1126
self._non_present_ids = attribs['_non_present_ids']
1127
for ((trans_id, kind),), content in records:
1129
mpdiff = multiparent.MultiParent.from_patch(content)
1130
lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
1131
self.create_file(lines, trans_id)
1132
if kind == 'directory':
1133
self.create_directory(trans_id)
1134
if kind == 'symlink':
1135
self.create_symlink(content.decode('utf-8'), trans_id)
1138
class DiskTreeTransform(TreeTransformBase):
1139
"""Tree transform storing its contents on disk."""
1141
def __init__(self, tree, limbodir, pb=None,
1142
case_sensitive=True):
1144
:param tree: The tree that will be transformed, but not necessarily
1146
:param limbodir: A directory where new files can be stored until
1147
they are installed in their proper places
1149
:param case_sensitive: If True, the target of the transform is
1150
case sensitive, not just case preserving.
1152
TreeTransformBase.__init__(self, tree, pb, case_sensitive)
1153
self._limbodir = limbodir
1154
self._deletiondir = None
1155
# A mapping of transform ids to their limbo filename
1156
self._limbo_files = {}
1157
# A mapping of transform ids to a set of the transform ids of children
1158
# that their limbo directory has
1159
self._limbo_children = {}
1160
# Map transform ids to maps of child filename to child transform id
1161
self._limbo_children_names = {}
1162
# List of transform ids that need to be renamed from limbo into place
1163
self._needs_rename = set()
1164
self._creation_mtime = None
1167
"""Release the working tree lock, if held, clean up limbo dir.
1169
This is required if apply has not been invoked, but can be invoked
1172
if self._tree is None:
1175
entries = [(self._limbo_name(t), t, k) for t, k in
1176
self._new_contents.iteritems()]
1177
entries.sort(reverse=True)
1178
for path, trans_id, kind in entries:
1181
delete_any(self._limbodir)
1183
# We don't especially care *why* the dir is immortal.
1184
raise ImmortalLimbo(self._limbodir)
1186
if self._deletiondir is not None:
1187
delete_any(self._deletiondir)
1189
raise errors.ImmortalPendingDeletion(self._deletiondir)
1191
TreeTransformBase.finalize(self)
1193
def _limbo_name(self, trans_id):
1194
"""Generate the limbo name of a file"""
1195
limbo_name = self._limbo_files.get(trans_id)
1196
if limbo_name is None:
1197
limbo_name = self._generate_limbo_path(trans_id)
1198
self._limbo_files[trans_id] = limbo_name
1201
def _generate_limbo_path(self, trans_id):
1202
"""Generate a limbo path using the trans_id as the relative path.
1204
This is suitable as a fallback, and when the transform should not be
1205
sensitive to the path encoding of the limbo directory.
1207
self._needs_rename.add(trans_id)
1208
return pathjoin(self._limbodir, trans_id)
1210
def adjust_path(self, name, parent, trans_id):
1211
previous_parent = self._new_parent.get(trans_id)
1212
previous_name = self._new_name.get(trans_id)
1213
TreeTransformBase.adjust_path(self, name, parent, trans_id)
1214
if (trans_id in self._limbo_files and
1215
trans_id not in self._needs_rename):
1216
self._rename_in_limbo([trans_id])
1217
if previous_parent != parent:
1218
self._limbo_children[previous_parent].remove(trans_id)
1219
if previous_parent != parent or previous_name != name:
1220
del self._limbo_children_names[previous_parent][previous_name]
1222
def _rename_in_limbo(self, trans_ids):
1223
"""Fix limbo names so that the right final path is produced.
1225
This means we outsmarted ourselves-- we tried to avoid renaming
1226
these files later by creating them with their final names in their
1227
final parents. But now the previous name or parent is no longer
1228
suitable, so we have to rename them.
1230
Even for trans_ids that have no new contents, we must remove their
1231
entries from _limbo_files, because they are now stale.
1233
for trans_id in trans_ids:
1234
old_path = self._limbo_files.pop(trans_id)
1235
if trans_id not in self._new_contents:
1237
new_path = self._limbo_name(trans_id)
1238
os.rename(old_path, new_path)
1239
for descendant in self._limbo_descendants(trans_id):
1240
desc_path = self._limbo_files[descendant]
1241
desc_path = new_path + desc_path[len(old_path):]
1242
self._limbo_files[descendant] = desc_path
1244
def _limbo_descendants(self, trans_id):
1245
"""Return the set of trans_ids whose limbo paths descend from this."""
1246
descendants = set(self._limbo_children.get(trans_id, []))
1247
for descendant in list(descendants):
1248
descendants.update(self._limbo_descendants(descendant))
1251
def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1252
"""Schedule creation of a new file.
1256
:param contents: an iterator of strings, all of which will be written
1257
to the target destination.
1258
:param trans_id: TreeTransform handle
1259
:param mode_id: If not None, force the mode of the target file to match
1260
the mode of the object referenced by mode_id.
1261
Otherwise, we will try to preserve mode bits of an existing file.
1262
:param sha1: If the sha1 of this content is already known, pass it in.
1263
We can use it to prevent future sha1 computations.
1265
name = self._limbo_name(trans_id)
1266
f = open(name, 'wb')
1269
unique_add(self._new_contents, trans_id, 'file')
1271
# Clean up the file, it never got registered so
1272
# TreeTransform.finalize() won't clean it up.
1276
f.writelines(contents)
1279
self._set_mtime(name)
1280
self._set_mode(trans_id, mode_id, S_ISREG)
1281
# It is unfortunate we have to use lstat instead of fstat, but we just
1282
# used utime and chmod on the file, so we need the accurate final
1284
if sha1 is not None:
1285
self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1287
def _read_file_chunks(self, trans_id):
1288
cur_file = open(self._limbo_name(trans_id), 'rb')
1290
return cur_file.readlines()
1294
def _read_symlink_target(self, trans_id):
1295
return os.readlink(self._limbo_name(trans_id))
1297
def _set_mtime(self, path):
1298
"""All files that are created get the same mtime.
1300
This time is set by the first object to be created.
1302
if self._creation_mtime is None:
1303
self._creation_mtime = time.time()
1304
os.utime(path, (self._creation_mtime, self._creation_mtime))
1306
def create_hardlink(self, path, trans_id):
1307
"""Schedule creation of a hard link"""
1308
name = self._limbo_name(trans_id)
1312
if e.errno != errno.EPERM:
1314
raise errors.HardLinkNotSupported(path)
1316
unique_add(self._new_contents, trans_id, 'file')
1318
# Clean up the file, it never got registered so
1319
# TreeTransform.finalize() won't clean it up.
1323
def create_directory(self, trans_id):
1324
"""Schedule creation of a new directory.
1326
See also new_directory.
1328
os.mkdir(self._limbo_name(trans_id))
1329
unique_add(self._new_contents, trans_id, 'directory')
1331
def create_symlink(self, target, trans_id):
1332
"""Schedule creation of a new symbolic link.
1334
target is a bytestring.
1335
See also new_symlink.
1338
os.symlink(target, self._limbo_name(trans_id))
1339
unique_add(self._new_contents, trans_id, 'symlink')
1342
path = FinalPaths(self).get_path(trans_id)
1345
raise UnableCreateSymlink(path=path)
1347
def cancel_creation(self, trans_id):
1348
"""Cancel the creation of new file contents."""
1349
del self._new_contents[trans_id]
1350
if trans_id in self._observed_sha1s:
1351
del self._observed_sha1s[trans_id]
1352
children = self._limbo_children.get(trans_id)
1353
# if this is a limbo directory with children, move them before removing
1355
if children is not None:
1356
self._rename_in_limbo(children)
1357
del self._limbo_children[trans_id]
1358
del self._limbo_children_names[trans_id]
1359
delete_any(self._limbo_name(trans_id))
1361
def new_orphan(self, trans_id, parent_id):
1362
# FIXME: There is no tree config, so we use the branch one (it's weird
1363
# to define it this way as orphaning can only occur in a working tree,
1364
# but that's all we have (for now). It will find the option in
1365
# locations.conf or bazaar.conf though) -- vila 20100916
1366
conf = self._tree.branch.get_config()
1367
conf_var_name = 'bzr.transform.orphan_policy'
1368
orphan_policy = conf.get_user_option(conf_var_name)
1369
default_policy = orphaning_registry.default_key
1370
if orphan_policy is None:
1371
orphan_policy = default_policy
1372
if orphan_policy not in orphaning_registry:
1373
trace.warning('%s (from %s) is not a known policy, defaulting '
1374
'to %s' % (orphan_policy, conf_var_name, default_policy))
1375
orphan_policy = default_policy
1376
handle_orphan = orphaning_registry.get(orphan_policy)
1377
handle_orphan(self, trans_id, parent_id)
1380
class OrphaningError(errors.BzrError):
1382
# Only bugs could lead to such exception being seen by the user
1383
internal_error = True
1384
_fmt = "Error while orphaning %s in %s directory"
1386
def __init__(self, orphan, parent):
1387
errors.BzrError.__init__(self)
1388
self.orphan = orphan
1389
self.parent = parent
1392
class OrphaningForbidden(OrphaningError):
1394
_fmt = "Policy: %s doesn't allow creating orphans."
1396
def __init__(self, policy):
1397
errors.BzrError.__init__(self)
1398
self.policy = policy
1401
def move_orphan(tt, orphan_id, parent_id):
1402
"""See TreeTransformBase.new_orphan.
1404
This creates a new orphan in the `bzr-orphans` dir at the root of the
1407
:param tt: The TreeTransform orphaning `trans_id`.
1409
:param orphan_id: The trans id that should be orphaned.
1411
:param parent_id: The orphan parent trans id.
1413
# Add the orphan dir if it doesn't exist
1414
orphan_dir_basename = 'bzr-orphans'
1415
od_id = tt.trans_id_tree_path(orphan_dir_basename)
1416
if tt.final_kind(od_id) is None:
1417
tt.create_directory(od_id)
1418
parent_path = tt._tree_id_paths[parent_id]
1419
# Find a name that doesn't exist yet in the orphan dir
1420
actual_name = tt.final_name(orphan_id)
1421
new_name = tt._available_backup_name(actual_name, od_id)
1422
tt.adjust_path(new_name, od_id, orphan_id)
1423
trace.warning('%s has been orphaned in %s'
1424
% (joinpath(parent_path, actual_name), orphan_dir_basename))
1427
def refuse_orphan(tt, orphan_id, parent_id):
1428
"""See TreeTransformBase.new_orphan.
1430
This refuses to create orphan, letting the caller handle the conflict.
1432
raise OrphaningForbidden('never')
1435
orphaning_registry = registry.Registry()
1436
orphaning_registry.register(
1437
'conflict', refuse_orphan,
1438
'Leave orphans in place and create a conflict on the directory.')
1439
orphaning_registry.register(
1440
'move', move_orphan,
1441
'Move orphans into the bzr-orphans directory.')
1442
orphaning_registry._set_default_key('conflict')
1445
class TreeTransform(DiskTreeTransform):
1446
"""Represent a tree transformation.
1448
This object is designed to support incremental generation of the transform,
1451
However, it gives optimum performance when parent directories are created
1452
before their contents. The transform is then able to put child files
1453
directly in their parent directory, avoiding later renames.
1455
It is easy to produce malformed transforms, but they are generally
1456
harmless. Attempting to apply a malformed transform will cause an
1457
exception to be raised before any modifications are made to the tree.
1459
Many kinds of malformed transforms can be corrected with the
1460
resolve_conflicts function. The remaining ones indicate programming error,
1461
such as trying to create a file with no path.
1463
Two sets of file creation methods are supplied. Convenience methods are:
1468
These are composed of the low-level methods:
1470
* create_file or create_directory or create_symlink
1474
Transform/Transaction ids
1475
-------------------------
1476
trans_ids are temporary ids assigned to all files involved in a transform.
1477
It's possible, even common, that not all files in the Tree have trans_ids.
1479
trans_ids are used because filenames and file_ids are not good enough
1480
identifiers; filenames change, and not all files have file_ids. File-ids
1481
are also associated with trans-ids, so that moving a file moves its
1484
trans_ids are only valid for the TreeTransform that generated them.
1488
Limbo is a temporary directory use to hold new versions of files.
1489
Files are added to limbo by create_file, create_directory, create_symlink,
1490
and their convenience variants (new_*). Files may be removed from limbo
1491
using cancel_creation. Files are renamed from limbo into their final
1492
location as part of TreeTransform.apply
1494
Limbo must be cleaned up, by either calling TreeTransform.apply or
1495
calling TreeTransform.finalize.
1497
Files are placed into limbo inside their parent directories, where
1498
possible. This reduces subsequent renames, and makes operations involving
1499
lots of files faster. This optimization is only possible if the parent
1500
directory is created *before* creating any of its children, so avoid
1501
creating children before parents, where possible.
1505
This temporary directory is used by _FileMover for storing files that are
1506
about to be deleted. In case of rollback, the files will be restored.
1507
FileMover does not delete files until it is sure that a rollback will not
1510
def __init__(self, tree, pb=None):
1511
"""Note: a tree_write lock is taken on the tree.
1513
Use TreeTransform.finalize() to release the lock (can be omitted if
1514
TreeTransform.apply() called).
1516
tree.lock_tree_write()
1519
limbodir = urlutils.local_path_from_url(
1520
tree._transport.abspath('limbo'))
1524
if e.errno == errno.EEXIST:
1525
raise ExistingLimbo(limbodir)
1526
deletiondir = urlutils.local_path_from_url(
1527
tree._transport.abspath('pending-deletion'))
1529
os.mkdir(deletiondir)
1531
if e.errno == errno.EEXIST:
1532
raise errors.ExistingPendingDeletion(deletiondir)
1537
# Cache of realpath results, to speed up canonical_path
1538
self._realpaths = {}
1539
# Cache of relpath results, to speed up canonical_path
1541
DiskTreeTransform.__init__(self, tree, limbodir, pb,
1542
tree.case_sensitive)
1543
self._deletiondir = deletiondir
1545
def canonical_path(self, path):
1546
"""Get the canonical tree-relative path"""
1547
# don't follow final symlinks
1548
abs = self._tree.abspath(path)
1549
if abs in self._relpaths:
1550
return self._relpaths[abs]
1551
dirname, basename = os.path.split(abs)
1552
if dirname not in self._realpaths:
1553
self._realpaths[dirname] = os.path.realpath(dirname)
1554
dirname = self._realpaths[dirname]
1555
abs = pathjoin(dirname, basename)
1556
if dirname in self._relpaths:
1557
relpath = pathjoin(self._relpaths[dirname], basename)
1558
relpath = relpath.rstrip('/\\')
1560
relpath = self._tree.relpath(abs)
1561
self._relpaths[abs] = relpath
1564
def tree_kind(self, trans_id):
1565
"""Determine the file kind in the working tree.
1567
:returns: The file kind or None if the file does not exist
1569
path = self._tree_id_paths.get(trans_id)
1573
return file_kind(self._tree.abspath(path))
1574
except errors.NoSuchFile:
1577
def _set_mode(self, trans_id, mode_id, typefunc):
1578
"""Set the mode of new file contents.
1579
The mode_id is the existing file to get the mode from (often the same
1580
as trans_id). The operation is only performed if there's a mode match
1581
according to typefunc.
1586
old_path = self._tree_id_paths[mode_id]
1590
mode = os.stat(self._tree.abspath(old_path)).st_mode
1592
if e.errno in (errno.ENOENT, errno.ENOTDIR):
1593
# Either old_path doesn't exist, or the parent of the
1594
# target is not a directory (but will be one eventually)
1595
# Either way, we know it doesn't exist *right now*
1596
# See also bug #248448
1601
os.chmod(self._limbo_name(trans_id), mode)
1603
def iter_tree_children(self, parent_id):
1604
"""Iterate through the entry's tree children, if any"""
1606
path = self._tree_id_paths[parent_id]
1610
children = os.listdir(self._tree.abspath(path))
1612
if not (osutils._is_error_enotdir(e)
1613
or e.errno in (errno.ENOENT, errno.ESRCH)):
1617
for child in children:
1618
childpath = joinpath(path, child)
1619
if self._tree.is_control_filename(childpath):
1621
yield self.trans_id_tree_path(childpath)
1623
def _generate_limbo_path(self, trans_id):
1624
"""Generate a limbo path using the final path if possible.
1626
This optimizes the performance of applying the tree transform by
1627
avoiding renames. These renames can be avoided only when the parent
1628
directory is already scheduled for creation.
1630
If the final path cannot be used, falls back to using the trans_id as
1633
parent = self._new_parent.get(trans_id)
1634
# if the parent directory is already in limbo (e.g. when building a
1635
# tree), choose a limbo name inside the parent, to reduce further
1637
use_direct_path = False
1638
if self._new_contents.get(parent) == 'directory':
1639
filename = self._new_name.get(trans_id)
1640
if filename is not None:
1641
if parent not in self._limbo_children:
1642
self._limbo_children[parent] = set()
1643
self._limbo_children_names[parent] = {}
1644
use_direct_path = True
1645
# the direct path can only be used if no other file has
1646
# already taken this pathname, i.e. if the name is unused, or
1647
# if it is already associated with this trans_id.
1648
elif self._case_sensitive_target:
1649
if (self._limbo_children_names[parent].get(filename)
1650
in (trans_id, None)):
1651
use_direct_path = True
1653
for l_filename, l_trans_id in\
1654
self._limbo_children_names[parent].iteritems():
1655
if l_trans_id == trans_id:
1657
if l_filename.lower() == filename.lower():
1660
use_direct_path = True
1662
if not use_direct_path:
1663
return DiskTreeTransform._generate_limbo_path(self, trans_id)
1665
limbo_name = pathjoin(self._limbo_files[parent], filename)
1666
self._limbo_children[parent].add(trans_id)
1667
self._limbo_children_names[parent][filename] = trans_id
1671
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1672
"""Apply all changes to the inventory and filesystem.
1674
If filesystem or inventory conflicts are present, MalformedTransform
1677
If apply succeeds, finalize is not necessary.
1679
:param no_conflicts: if True, the caller guarantees there are no
1680
conflicts, so no check is made.
1681
:param precomputed_delta: An inventory delta to use instead of
1683
:param _mover: Supply an alternate FileMover, for testing
1685
if not no_conflicts:
1686
self._check_malformed()
1687
child_pb = ui.ui_factory.nested_progress_bar()
1689
if precomputed_delta is None:
1690
child_pb.update('Apply phase', 0, 2)
1691
inventory_delta = self._generate_inventory_delta()
1694
inventory_delta = precomputed_delta
1697
mover = _FileMover()
1701
child_pb.update('Apply phase', 0 + offset, 2 + offset)
1702
self._apply_removals(mover)
1703
child_pb.update('Apply phase', 1 + offset, 2 + offset)
1704
modified_paths = self._apply_insertions(mover)
1709
mover.apply_deletions()
1712
self._tree.apply_inventory_delta(inventory_delta)
1713
self._apply_observed_sha1s()
1716
return _TransformResults(modified_paths, self.rename_count)
1718
def _generate_inventory_delta(self):
1719
"""Generate an inventory delta for the current transform."""
1720
inventory_delta = []
1721
child_pb = ui.ui_factory.nested_progress_bar()
1722
new_paths = self._inventory_altered()
1723
total_entries = len(new_paths) + len(self._removed_id)
1725
for num, trans_id in enumerate(self._removed_id):
1727
child_pb.update('removing file', num, total_entries)
1728
if trans_id == self._new_root:
1729
file_id = self._tree.get_root_id()
1731
file_id = self.tree_file_id(trans_id)
1732
# File-id isn't really being deleted, just moved
1733
if file_id in self._r_new_id:
1735
path = self._tree_id_paths[trans_id]
1736
inventory_delta.append((path, None, file_id, None))
1737
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1739
entries = self._tree.iter_entries_by_dir(
1740
new_path_file_ids.values())
1741
old_paths = dict((e.file_id, p) for p, e in entries)
1743
for num, (path, trans_id) in enumerate(new_paths):
1745
child_pb.update('adding file',
1746
num + len(self._removed_id), total_entries)
1747
file_id = new_path_file_ids[trans_id]
1751
kind = self.final_kind(trans_id)
1753
kind = self._tree.stored_kind(file_id)
1754
parent_trans_id = self.final_parent(trans_id)
1755
parent_file_id = new_path_file_ids.get(parent_trans_id)
1756
if parent_file_id is None:
1757
parent_file_id = self.final_file_id(parent_trans_id)
1758
if trans_id in self._new_reference_revision:
1759
new_entry = inventory.TreeReference(
1761
self._new_name[trans_id],
1762
self.final_file_id(self._new_parent[trans_id]),
1763
None, self._new_reference_revision[trans_id])
1765
new_entry = inventory.make_entry(kind,
1766
self.final_name(trans_id),
1767
parent_file_id, file_id)
1768
old_path = old_paths.get(new_entry.file_id)
1769
new_executability = self._new_executability.get(trans_id)
1770
if new_executability is not None:
1771
new_entry.executable = new_executability
1772
inventory_delta.append(
1773
(old_path, path, new_entry.file_id, new_entry))
1776
return inventory_delta
1778
def _apply_removals(self, mover):
1779
"""Perform tree operations that remove directory/inventory names.
1781
That is, delete files that are to be deleted, and put any files that
1782
need renaming into limbo. This must be done in strict child-to-parent
1785
If inventory_delta is None, no inventory delta generation is performed.
1787
tree_paths = list(self._tree_path_ids.iteritems())
1788
tree_paths.sort(reverse=True)
1789
child_pb = ui.ui_factory.nested_progress_bar()
1791
for num, data in enumerate(tree_paths):
1792
path, trans_id = data
1793
child_pb.update('removing file', num, len(tree_paths))
1794
full_path = self._tree.abspath(path)
1795
if trans_id in self._removed_contents:
1796
delete_path = os.path.join(self._deletiondir, trans_id)
1797
mover.pre_delete(full_path, delete_path)
1798
elif (trans_id in self._new_name
1799
or trans_id in self._new_parent):
1801
mover.rename(full_path, self._limbo_name(trans_id))
1802
except errors.TransformRenameFailed, e:
1803
if e.errno != errno.ENOENT:
1806
self.rename_count += 1
1810
def _apply_insertions(self, mover):
1811
"""Perform tree operations that insert directory/inventory names.
1813
That is, create any files that need to be created, and restore from
1814
limbo any files that needed renaming. This must be done in strict
1815
parent-to-child order.
1817
If inventory_delta is None, no inventory delta is calculated, and
1818
no list of modified paths is returned.
1820
new_paths = self.new_paths(filesystem_only=True)
1822
new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1824
child_pb = ui.ui_factory.nested_progress_bar()
1826
for num, (path, trans_id) in enumerate(new_paths):
1828
child_pb.update('adding file', num, len(new_paths))
1829
full_path = self._tree.abspath(path)
1830
if trans_id in self._needs_rename:
1832
mover.rename(self._limbo_name(trans_id), full_path)
1833
except errors.TransformRenameFailed, e:
1834
# We may be renaming a dangling inventory id
1835
if e.errno != errno.ENOENT:
1838
self.rename_count += 1
1839
# TODO: if trans_id in self._observed_sha1s, we should
1840
# re-stat the final target, since ctime will be
1841
# updated by the change.
1842
if (trans_id in self._new_contents or
1843
self.path_changed(trans_id)):
1844
if trans_id in self._new_contents:
1845
modified_paths.append(full_path)
1846
if trans_id in self._new_executability:
1847
self._set_executability(path, trans_id)
1848
if trans_id in self._observed_sha1s:
1849
o_sha1, o_st_val = self._observed_sha1s[trans_id]
1850
st = osutils.lstat(full_path)
1851
self._observed_sha1s[trans_id] = (o_sha1, st)
1854
self._new_contents.clear()
1855
return modified_paths
1857
def _apply_observed_sha1s(self):
1858
"""After we have finished renaming everything, update observed sha1s
1860
This has to be done after self._tree.apply_inventory_delta, otherwise
1861
it doesn't know anything about the files we are updating. Also, we want
1862
to do this as late as possible, so that most entries end up cached.
1864
# TODO: this doesn't update the stat information for directories. So
1865
# the first 'bzr status' will still need to rewrite
1866
# .bzr/checkout/dirstate. However, we at least don't need to
1867
# re-read all of the files.
1868
# TODO: If the operation took a while, we could do a time.sleep(3) here
1869
# to allow the clock to tick over and ensure we won't have any
1870
# problems. (we could observe start time, and finish time, and if
1871
# it is less than eg 10% overhead, add a sleep call.)
1872
paths = FinalPaths(self)
1873
for trans_id, observed in self._observed_sha1s.iteritems():
1874
path = paths.get_path(trans_id)
1875
# We could get the file_id, but dirstate prefers to use the path
1876
# anyway, and it is 'cheaper' to determine.
1877
# file_id = self._new_id[trans_id]
1878
self._tree._observed_sha1(None, path, observed)
1881
class TransformPreview(DiskTreeTransform):
1882
"""A TreeTransform for generating preview trees.
1884
Unlike TreeTransform, this version works when the input tree is a
1885
RevisionTree, rather than a WorkingTree. As a result, it tends to ignore
1886
unversioned files in the input tree.
1889
def __init__(self, tree, pb=None, case_sensitive=True):
1891
limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1892
DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1894
def canonical_path(self, path):
1897
def tree_kind(self, trans_id):
1898
path = self._tree_id_paths.get(trans_id)
1901
kind = self._tree.path_content_summary(path)[0]
1902
if kind == 'missing':
1906
def _set_mode(self, trans_id, mode_id, typefunc):
1907
"""Set the mode of new file contents.
1908
The mode_id is the existing file to get the mode from (often the same
1909
as trans_id). The operation is only performed if there's a mode match
1910
according to typefunc.
1912
# is it ok to ignore this? probably
1915
def iter_tree_children(self, parent_id):
1916
"""Iterate through the entry's tree children, if any"""
1918
path = self._tree_id_paths[parent_id]
1921
file_id = self.tree_file_id(parent_id)
1924
entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1925
children = getattr(entry, 'children', {})
1926
for child in children:
1927
childpath = joinpath(path, child)
1928
yield self.trans_id_tree_path(childpath)
1930
def new_orphan(self, trans_id, parent_id):
1931
raise NotImplementedError(self.new_orphan)
1934
class _PreviewTree(tree.InventoryTree):
1935
"""Partial implementation of Tree to support show_diff_trees"""
1937
def __init__(self, transform):
1938
self._transform = transform
1939
self._final_paths = FinalPaths(transform)
1940
self.__by_parent = None
1941
self._parent_ids = []
1942
self._all_children_cache = {}
1943
self._path2trans_id_cache = {}
1944
self._final_name_cache = {}
1945
self._iter_changes_cache = dict((c[0], c) for c in
1946
self._transform.iter_changes())
1948
def _content_change(self, file_id):
1949
"""Return True if the content of this file changed"""
1950
changes = self._iter_changes_cache.get(file_id)
1951
# changes[2] is true if the file content changed. See
1952
# InterTree.iter_changes.
1953
return (changes is not None and changes[2])
1955
def _get_repository(self):
1956
repo = getattr(self._transform._tree, '_repository', None)
1958
repo = self._transform._tree.branch.repository
1961
def _iter_parent_trees(self):
1962
for revision_id in self.get_parent_ids():
1964
yield self.revision_tree(revision_id)
1965
except errors.NoSuchRevisionInTree:
1966
yield self._get_repository().revision_tree(revision_id)
1968
def _get_file_revision(self, file_id, vf, tree_revision):
1969
parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
1970
self._iter_parent_trees()]
1971
vf.add_lines((file_id, tree_revision), parent_keys,
1972
self.get_file_lines(file_id))
1973
repo = self._get_repository()
1974
base_vf = repo.texts
1975
if base_vf not in vf.fallback_versionedfiles:
1976
vf.fallback_versionedfiles.append(base_vf)
1977
return tree_revision
1979
def _stat_limbo_file(self, file_id=None, trans_id=None):
1980
if trans_id is None:
1981
trans_id = self._transform.trans_id_file_id(file_id)
1982
name = self._transform._limbo_name(trans_id)
1983
return os.lstat(name)
1986
def _by_parent(self):
1987
if self.__by_parent is None:
1988
self.__by_parent = self._transform.by_parent()
1989
return self.__by_parent
1991
def _comparison_data(self, entry, path):
1992
kind, size, executable, link_or_sha1 = self.path_content_summary(path)
1993
if kind == 'missing':
1997
file_id = self._transform.final_file_id(self._path2trans_id(path))
1998
executable = self.is_executable(file_id, path)
1999
return kind, executable, None
2001
def is_locked(self):
2004
def lock_read(self):
2005
# Perhaps in theory, this should lock the TreeTransform?
2012
def inventory(self):
2013
"""This Tree does not use inventory as its backing data."""
2014
raise NotImplementedError(_PreviewTree.inventory)
2016
def get_root_id(self):
2017
return self._transform.final_file_id(self._transform.root)
2019
def all_file_ids(self):
2020
tree_ids = set(self._transform._tree.all_file_ids())
2021
tree_ids.difference_update(self._transform.tree_file_id(t)
2022
for t in self._transform._removed_id)
2023
tree_ids.update(self._transform._new_id.values())
2027
return iter(self.all_file_ids())
2029
def _has_id(self, file_id, fallback_check):
2030
if file_id in self._transform._r_new_id:
2032
elif file_id in set([self._transform.tree_file_id(trans_id) for
2033
trans_id in self._transform._removed_id]):
2036
return fallback_check(file_id)
2038
def has_id(self, file_id):
2039
return self._has_id(file_id, self._transform._tree.has_id)
2041
def has_or_had_id(self, file_id):
2042
return self._has_id(file_id, self._transform._tree.has_or_had_id)
2044
def _path2trans_id(self, path):
2045
# We must not use None here, because that is a valid value to store.
2046
trans_id = self._path2trans_id_cache.get(path, object)
2047
if trans_id is not object:
2049
segments = splitpath(path)
2050
cur_parent = self._transform.root
2051
for cur_segment in segments:
2052
for child in self._all_children(cur_parent):
2053
final_name = self._final_name_cache.get(child)
2054
if final_name is None:
2055
final_name = self._transform.final_name(child)
2056
self._final_name_cache[child] = final_name
2057
if final_name == cur_segment:
2061
self._path2trans_id_cache[path] = None
2063
self._path2trans_id_cache[path] = cur_parent
2066
def path2id(self, path):
2067
return self._transform.final_file_id(self._path2trans_id(path))
2069
def id2path(self, file_id):
2070
trans_id = self._transform.trans_id_file_id(file_id)
2072
return self._final_paths._determine_path(trans_id)
2074
raise errors.NoSuchId(self, file_id)
2076
def _all_children(self, trans_id):
2077
children = self._all_children_cache.get(trans_id)
2078
if children is not None:
2080
children = set(self._transform.iter_tree_children(trans_id))
2081
# children in the _new_parent set are provided by _by_parent.
2082
children.difference_update(self._transform._new_parent.keys())
2083
children.update(self._by_parent.get(trans_id, []))
2084
self._all_children_cache[trans_id] = children
2087
def iter_children(self, file_id):
2088
trans_id = self._transform.trans_id_file_id(file_id)
2089
for child_trans_id in self._all_children(trans_id):
2090
yield self._transform.final_file_id(child_trans_id)
2093
possible_extras = set(self._transform.trans_id_tree_path(p) for p
2094
in self._transform._tree.extras())
2095
possible_extras.update(self._transform._new_contents)
2096
possible_extras.update(self._transform._removed_id)
2097
for trans_id in possible_extras:
2098
if self._transform.final_file_id(trans_id) is None:
2099
yield self._final_paths._determine_path(trans_id)
2101
def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
2102
yield_parents=False):
2103
for trans_id, parent_file_id in ordered_entries:
2104
file_id = self._transform.final_file_id(trans_id)
2107
if (specific_file_ids is not None
2108
and file_id not in specific_file_ids):
2110
kind = self._transform.final_kind(trans_id)
2112
kind = self._transform._tree.stored_kind(file_id)
2113
new_entry = inventory.make_entry(
2115
self._transform.final_name(trans_id),
2116
parent_file_id, file_id)
2117
yield new_entry, trans_id
2119
def _list_files_by_dir(self):
2120
todo = [ROOT_PARENT]
2122
while len(todo) > 0:
2124
parent_file_id = self._transform.final_file_id(parent)
2125
children = list(self._all_children(parent))
2126
paths = dict(zip(children, self._final_paths.get_paths(children)))
2127
children.sort(key=paths.get)
2128
todo.extend(reversed(children))
2129
for trans_id in children:
2130
ordered_ids.append((trans_id, parent_file_id))
2133
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
2134
# This may not be a maximally efficient implementation, but it is
2135
# reasonably straightforward. An implementation that grafts the
2136
# TreeTransform changes onto the tree's iter_entries_by_dir results
2137
# might be more efficient, but requires tricky inferences about stack
2139
ordered_ids = self._list_files_by_dir()
2140
for entry, trans_id in self._make_inv_entries(ordered_ids,
2141
specific_file_ids, yield_parents=yield_parents):
2142
yield unicode(self._final_paths.get_path(trans_id)), entry
2144
def _iter_entries_for_dir(self, dir_path):
2145
"""Return path, entry for items in a directory without recursing down."""
2146
dir_file_id = self.path2id(dir_path)
2148
for file_id in self.iter_children(dir_file_id):
2149
trans_id = self._transform.trans_id_file_id(file_id)
2150
ordered_ids.append((trans_id, file_id))
2151
for entry, trans_id in self._make_inv_entries(ordered_ids):
2152
yield unicode(self._final_paths.get_path(trans_id)), entry
2154
def list_files(self, include_root=False, from_dir=None, recursive=True):
2155
"""See WorkingTree.list_files."""
2156
# XXX This should behave like WorkingTree.list_files, but is really
2157
# more like RevisionTree.list_files.
2161
prefix = from_dir + '/'
2162
entries = self.iter_entries_by_dir()
2163
for path, entry in entries:
2164
if entry.name == '' and not include_root:
2167
if not path.startswith(prefix):
2169
path = path[len(prefix):]
2170
yield path, 'V', entry.kind, entry.file_id, entry
2172
if from_dir is None and include_root is True:
2173
root_entry = inventory.make_entry('directory', '',
2174
ROOT_PARENT, self.get_root_id())
2175
yield '', 'V', 'directory', root_entry.file_id, root_entry
2176
entries = self._iter_entries_for_dir(from_dir or '')
2177
for path, entry in entries:
2178
yield path, 'V', entry.kind, entry.file_id, entry
2180
def kind(self, file_id):
2181
trans_id = self._transform.trans_id_file_id(file_id)
2182
return self._transform.final_kind(trans_id)
2184
def stored_kind(self, file_id):
2185
trans_id = self._transform.trans_id_file_id(file_id)
2187
return self._transform._new_contents[trans_id]
2189
return self._transform._tree.stored_kind(file_id)
2191
def get_file_mtime(self, file_id, path=None):
2192
"""See Tree.get_file_mtime"""
2193
if not self._content_change(file_id):
2194
return self._transform._tree.get_file_mtime(file_id)
2195
return self._stat_limbo_file(file_id).st_mtime
2197
def _file_size(self, entry, stat_value):
2198
return self.get_file_size(entry.file_id)
2200
def get_file_size(self, file_id):
2201
"""See Tree.get_file_size"""
2202
trans_id = self._transform.trans_id_file_id(file_id)
2203
kind = self._transform.final_kind(trans_id)
2206
if trans_id in self._transform._new_contents:
2207
return self._stat_limbo_file(trans_id=trans_id).st_size
2208
if self.kind(file_id) == 'file':
2209
return self._transform._tree.get_file_size(file_id)
2213
def get_file_sha1(self, file_id, path=None, stat_value=None):
2214
trans_id = self._transform.trans_id_file_id(file_id)
2215
kind = self._transform._new_contents.get(trans_id)
2217
return self._transform._tree.get_file_sha1(file_id)
2219
fileobj = self.get_file(file_id)
2221
return sha_file(fileobj)
2225
def is_executable(self, file_id, path=None):
2228
trans_id = self._transform.trans_id_file_id(file_id)
2230
return self._transform._new_executability[trans_id]
2233
return self._transform._tree.is_executable(file_id, path)
2235
if e.errno == errno.ENOENT:
2238
except errors.NoSuchId:
2241
def has_filename(self, path):
2242
trans_id = self._path2trans_id(path)
2243
if trans_id in self._transform._new_contents:
2245
elif trans_id in self._transform._removed_contents:
2248
return self._transform._tree.has_filename(path)
2250
def path_content_summary(self, path):
2251
trans_id = self._path2trans_id(path)
2252
tt = self._transform
2253
tree_path = tt._tree_id_paths.get(trans_id)
2254
kind = tt._new_contents.get(trans_id)
2256
if tree_path is None or trans_id in tt._removed_contents:
2257
return 'missing', None, None, None
2258
summary = tt._tree.path_content_summary(tree_path)
2259
kind, size, executable, link_or_sha1 = summary
2262
limbo_name = tt._limbo_name(trans_id)
2263
if trans_id in tt._new_reference_revision:
2264
kind = 'tree-reference'
2266
statval = os.lstat(limbo_name)
2267
size = statval.st_size
2268
if not supports_executable():
2271
executable = statval.st_mode & S_IEXEC
2275
if kind == 'symlink':
2276
link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2277
executable = tt._new_executability.get(trans_id, executable)
2278
return kind, size, executable, link_or_sha1
2280
def iter_changes(self, from_tree, include_unchanged=False,
2281
specific_files=None, pb=None, extra_trees=None,
2282
require_versioned=True, want_unversioned=False):
2283
"""See InterTree.iter_changes.
2285
This has a fast path that is only used when the from_tree matches
2286
the transform tree, and no fancy options are supplied.
2288
if (from_tree is not self._transform._tree or include_unchanged or
2289
specific_files or want_unversioned):
2290
return tree.InterTree(from_tree, self).iter_changes(
2291
include_unchanged=include_unchanged,
2292
specific_files=specific_files,
2294
extra_trees=extra_trees,
2295
require_versioned=require_versioned,
2296
want_unversioned=want_unversioned)
2297
if want_unversioned:
2298
raise ValueError('want_unversioned is not supported')
2299
return self._transform.iter_changes()
2301
def get_file(self, file_id, path=None):
2302
"""See Tree.get_file"""
2303
if not self._content_change(file_id):
2304
return self._transform._tree.get_file(file_id, path)
2305
trans_id = self._transform.trans_id_file_id(file_id)
2306
name = self._transform._limbo_name(trans_id)
2307
return open(name, 'rb')
2309
def get_file_with_stat(self, file_id, path=None):
2310
return self.get_file(file_id, path), None
2312
def annotate_iter(self, file_id,
2313
default_revision=_mod_revision.CURRENT_REVISION):
2314
changes = self._iter_changes_cache.get(file_id)
2318
changed_content, versioned, kind = (changes[2], changes[3],
2322
get_old = (kind[0] == 'file' and versioned[0])
2324
old_annotation = self._transform._tree.annotate_iter(file_id,
2325
default_revision=default_revision)
2329
return old_annotation
2330
if not changed_content:
2331
return old_annotation
2332
# TODO: This is doing something similar to what WT.annotate_iter is
2333
# doing, however it fails slightly because it doesn't know what
2334
# the *other* revision_id is, so it doesn't know how to give the
2335
# other as the origin for some lines, they all get
2336
# 'default_revision'
2337
# It would be nice to be able to use the new Annotator based
2338
# approach, as well.
2339
return annotate.reannotate([old_annotation],
2340
self.get_file(file_id).readlines(),
2343
def get_symlink_target(self, file_id, path=None):
2344
"""See Tree.get_symlink_target"""
2345
if not self._content_change(file_id):
2346
return self._transform._tree.get_symlink_target(file_id)
2347
trans_id = self._transform.trans_id_file_id(file_id)
2348
name = self._transform._limbo_name(trans_id)
2349
return osutils.readlink(name)
2351
def walkdirs(self, prefix=''):
2352
pending = [self._transform.root]
2353
while len(pending) > 0:
2354
parent_id = pending.pop()
2357
prefix = prefix.rstrip('/')
2358
parent_path = self._final_paths.get_path(parent_id)
2359
parent_file_id = self._transform.final_file_id(parent_id)
2360
for child_id in self._all_children(parent_id):
2361
path_from_root = self._final_paths.get_path(child_id)
2362
basename = self._transform.final_name(child_id)
2363
file_id = self._transform.final_file_id(child_id)
2364
kind = self._transform.final_kind(child_id)
2365
if kind is not None:
2366
versioned_kind = kind
2369
versioned_kind = self._transform._tree.stored_kind(file_id)
2370
if versioned_kind == 'directory':
2371
subdirs.append(child_id)
2372
children.append((path_from_root, basename, kind, None,
2373
file_id, versioned_kind))
2375
if parent_path.startswith(prefix):
2376
yield (parent_path, parent_file_id), children
2377
pending.extend(sorted(subdirs, key=self._final_paths.get_path,
2380
def get_parent_ids(self):
2381
return self._parent_ids
2383
def set_parent_ids(self, parent_ids):
2384
self._parent_ids = parent_ids
2386
def get_revision_tree(self, revision_id):
2387
return self._transform._tree.get_revision_tree(revision_id)
2390
def joinpath(parent, child):
2391
"""Join tree-relative paths, handling the tree root specially"""
2392
if parent is None or parent == "":
2395
return pathjoin(parent, child)
2398
class FinalPaths(object):
2399
"""Make path calculation cheap by memoizing paths.
2401
The underlying tree must not be manipulated between calls, or else
2402
the results will likely be incorrect.
2404
def __init__(self, transform):
2405
object.__init__(self)
2406
self._known_paths = {}
2407
self.transform = transform
2409
def _determine_path(self, trans_id):
2410
if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
2412
name = self.transform.final_name(trans_id)
2413
parent_id = self.transform.final_parent(trans_id)
2414
if parent_id == self.transform.root:
2417
return pathjoin(self.get_path(parent_id), name)
2419
def get_path(self, trans_id):
2420
"""Find the final path associated with a trans_id"""
2421
if trans_id not in self._known_paths:
2422
self._known_paths[trans_id] = self._determine_path(trans_id)
2423
return self._known_paths[trans_id]
2425
def get_paths(self, trans_ids):
2426
return [(self.get_path(t), t) for t in trans_ids]
2430
def topology_sorted_ids(tree):
2431
"""Determine the topological order of the ids in a tree"""
2432
file_ids = list(tree)
2433
file_ids.sort(key=tree.id2path)
2437
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
2438
delta_from_tree=False):
2439
"""Create working tree for a branch, using a TreeTransform.
2441
This function should be used on empty trees, having a tree root at most.
2442
(see merge and revert functionality for working with existing trees)
2444
Existing files are handled like so:
2446
- Existing bzrdirs take precedence over creating new items. They are
2447
created as '%s.diverted' % name.
2448
- Otherwise, if the content on disk matches the content we are building,
2449
it is silently replaced.
2450
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
2452
:param tree: The tree to convert wt into a copy of
2453
:param wt: The working tree that files will be placed into
2454
:param accelerator_tree: A tree which can be used for retrieving file
2455
contents more quickly than tree itself, i.e. a workingtree. tree
2456
will be used for cases where accelerator_tree's content is different.
2457
:param hardlink: If true, hard-link files to accelerator_tree, where
2458
possible. accelerator_tree must implement abspath, i.e. be a
2460
:param delta_from_tree: If true, build_tree may use the input Tree to
2461
generate the inventory delta.
2463
wt.lock_tree_write()
2467
if accelerator_tree is not None:
2468
accelerator_tree.lock_read()
2470
return _build_tree(tree, wt, accelerator_tree, hardlink,
2473
if accelerator_tree is not None:
2474
accelerator_tree.unlock()
2481
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
2482
"""See build_tree."""
2483
for num, _unused in enumerate(wt.all_file_ids()):
2484
if num > 0: # more than just a root
2485
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
2487
top_pb = ui.ui_factory.nested_progress_bar()
2488
pp = ProgressPhase("Build phase", 2, top_pb)
2489
if tree.inventory.root is not None:
2490
# This is kind of a hack: we should be altering the root
2491
# as part of the regular tree shape diff logic.
2492
# The conditional test here is to avoid doing an
2493
# expensive operation (flush) every time the root id
2494
# is set within the tree, nor setting the root and thus
2495
# marking the tree as dirty, because we use two different
2496
# idioms here: tree interfaces and inventory interfaces.
2497
if wt.get_root_id() != tree.get_root_id():
2498
wt.set_root_id(tree.get_root_id())
2500
tt = TreeTransform(wt)
2504
file_trans_id[wt.get_root_id()] = \
2505
tt.trans_id_tree_file_id(wt.get_root_id())
2506
pb = ui.ui_factory.nested_progress_bar()
2508
deferred_contents = []
2510
total = len(tree.inventory)
2512
precomputed_delta = []
2514
precomputed_delta = None
2515
# Check if tree inventory has content. If so, we populate
2516
# existing_files with the directory content. If there are no
2517
# entries we skip populating existing_files as its not used.
2518
# This improves performance and unncessary work on large
2519
# directory trees. (#501307)
2521
existing_files = set()
2522
for dir, files in wt.walkdirs():
2523
existing_files.update(f[0] for f in files)
2524
for num, (tree_path, entry) in \
2525
enumerate(tree.inventory.iter_entries_by_dir()):
2526
pb.update("Building tree", num - len(deferred_contents), total)
2527
if entry.parent_id is None:
2530
file_id = entry.file_id
2532
precomputed_delta.append((None, tree_path, file_id, entry))
2533
if tree_path in existing_files:
2534
target_path = wt.abspath(tree_path)
2535
kind = file_kind(target_path)
2536
if kind == "directory":
2538
bzrdir.BzrDir.open(target_path)
2539
except errors.NotBranchError:
2543
if (file_id not in divert and
2544
_content_match(tree, entry, file_id, kind,
2546
tt.delete_contents(tt.trans_id_tree_path(tree_path))
2547
if kind == 'directory':
2549
parent_id = file_trans_id[entry.parent_id]
2550
if entry.kind == 'file':
2551
# We *almost* replicate new_by_entry, so that we can defer
2552
# getting the file text, and get them all at once.
2553
trans_id = tt.create_path(entry.name, parent_id)
2554
file_trans_id[file_id] = trans_id
2555
tt.version_file(file_id, trans_id)
2556
executable = tree.is_executable(file_id, tree_path)
2558
tt.set_executability(executable, trans_id)
2559
trans_data = (trans_id, tree_path, entry.text_sha1)
2560
deferred_contents.append((file_id, trans_data))
2562
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2565
new_trans_id = file_trans_id[file_id]
2566
old_parent = tt.trans_id_tree_path(tree_path)
2567
_reparent_children(tt, old_parent, new_trans_id)
2568
offset = num + 1 - len(deferred_contents)
2569
_create_files(tt, tree, deferred_contents, pb, offset,
2570
accelerator_tree, hardlink)
2574
divert_trans = set(file_trans_id[f] for f in divert)
2575
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
2576
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
2577
if len(raw_conflicts) > 0:
2578
precomputed_delta = None
2579
conflicts = cook_conflicts(raw_conflicts, tt)
2580
for conflict in conflicts:
2581
trace.warning(unicode(conflict))
2583
wt.add_conflicts(conflicts)
2584
except errors.UnsupportedOperation:
2586
result = tt.apply(no_conflicts=True,
2587
precomputed_delta=precomputed_delta)
2594
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
2596
total = len(desired_files) + offset
2598
if accelerator_tree is None:
2599
new_desired_files = desired_files
2601
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2602
unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2603
in iter if not (c or e[0] != e[1])]
2604
if accelerator_tree.supports_content_filtering():
2605
unchanged = [(f, p) for (f, p) in unchanged
2606
if not accelerator_tree.iter_search_rules([p]).next()]
2607
unchanged = dict(unchanged)
2608
new_desired_files = []
2610
for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2611
accelerator_path = unchanged.get(file_id)
2612
if accelerator_path is None:
2613
new_desired_files.append((file_id,
2614
(trans_id, tree_path, text_sha1)))
2616
pb.update('Adding file contents', count + offset, total)
2618
tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2621
contents = accelerator_tree.get_file(file_id, accelerator_path)
2622
if wt.supports_content_filtering():
2623
filters = wt._content_filter_stack(tree_path)
2624
contents = filtered_output_bytes(contents, filters,
2625
ContentFilterContext(tree_path, tree))
2627
tt.create_file(contents, trans_id, sha1=text_sha1)
2631
except AttributeError:
2632
# after filtering, contents may no longer be file-like
2636
for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2637
tree.iter_files_bytes(new_desired_files)):
2638
if wt.supports_content_filtering():
2639
filters = wt._content_filter_stack(tree_path)
2640
contents = filtered_output_bytes(contents, filters,
2641
ContentFilterContext(tree_path, tree))
2642
tt.create_file(contents, trans_id, sha1=text_sha1)
2643
pb.update('Adding file contents', count + offset, total)
2646
def _reparent_children(tt, old_parent, new_parent):
2647
for child in tt.iter_tree_children(old_parent):
2648
tt.adjust_path(tt.final_name(child), new_parent, child)
2651
def _reparent_transform_children(tt, old_parent, new_parent):
2652
by_parent = tt.by_parent()
2653
for child in by_parent[old_parent]:
2654
tt.adjust_path(tt.final_name(child), new_parent, child)
2655
return by_parent[old_parent]
2658
def _content_match(tree, entry, file_id, kind, target_path):
2659
if entry.kind != kind:
2661
if entry.kind == "directory":
2663
if entry.kind == "file":
2664
f = file(target_path, 'rb')
2666
if tree.get_file_text(file_id) == f.read():
2670
elif entry.kind == "symlink":
2671
if tree.get_symlink_target(file_id) == os.readlink(target_path):
2676
def resolve_checkout(tt, conflicts, divert):
2677
new_conflicts = set()
2678
for c_type, conflict in ((c[0], c) for c in conflicts):
2679
# Anything but a 'duplicate' would indicate programmer error
2680
if c_type != 'duplicate':
2681
raise AssertionError(c_type)
2682
# Now figure out which is new and which is old
2683
if tt.new_contents(conflict[1]):
2684
new_file = conflict[1]
2685
old_file = conflict[2]
2687
new_file = conflict[2]
2688
old_file = conflict[1]
2690
# We should only get here if the conflict wasn't completely
2692
final_parent = tt.final_parent(old_file)
2693
if new_file in divert:
2694
new_name = tt.final_name(old_file)+'.diverted'
2695
tt.adjust_path(new_name, final_parent, new_file)
2696
new_conflicts.add((c_type, 'Diverted to',
2697
new_file, old_file))
2699
new_name = tt.final_name(old_file)+'.moved'
2700
tt.adjust_path(new_name, final_parent, old_file)
2701
new_conflicts.add((c_type, 'Moved existing file to',
2702
old_file, new_file))
2703
return new_conflicts
2706
def new_by_entry(tt, entry, parent_id, tree):
2707
"""Create a new file according to its inventory entry"""
2711
contents = tree.get_file(entry.file_id).readlines()
2712
executable = tree.is_executable(entry.file_id)
2713
return tt.new_file(name, parent_id, contents, entry.file_id,
2715
elif kind in ('directory', 'tree-reference'):
2716
trans_id = tt.new_directory(name, parent_id, entry.file_id)
2717
if kind == 'tree-reference':
2718
tt.set_tree_reference(entry.reference_revision, trans_id)
2720
elif kind == 'symlink':
2721
target = tree.get_symlink_target(entry.file_id)
2722
return tt.new_symlink(name, parent_id, target, entry.file_id)
2724
raise errors.BadFileKindError(name, kind)
2727
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2728
filter_tree_path=None):
2729
"""Create new file contents according to tree contents.
2731
:param filter_tree_path: the tree path to use to lookup
2732
content filters to apply to the bytes output in the working tree.
2733
This only applies if the working tree supports content filtering.
2735
kind = tree.kind(file_id)
2736
if kind == 'directory':
2737
tt.create_directory(trans_id)
2738
elif kind == "file":
2740
tree_file = tree.get_file(file_id)
2742
bytes = tree_file.readlines()
2746
if wt.supports_content_filtering() and filter_tree_path is not None:
2747
filters = wt._content_filter_stack(filter_tree_path)
2748
bytes = filtered_output_bytes(bytes, filters,
2749
ContentFilterContext(filter_tree_path, tree))
2750
tt.create_file(bytes, trans_id)
2751
elif kind == "symlink":
2752
tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2754
raise AssertionError('Unknown kind %r' % kind)
2757
def create_entry_executability(tt, entry, trans_id):
2758
"""Set the executability of a trans_id according to an inventory entry"""
2759
if entry.kind == "file":
2760
tt.set_executability(entry.executable, trans_id)
2763
@deprecated_function(deprecated_in((2, 3, 0)))
2764
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2765
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2768
@deprecated_function(deprecated_in((2, 3, 0)))
2769
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2770
"""Produce a backup-style name that appears to be available"""
2774
yield "%s.~%d~" % (name, counter)
2776
for new_name in name_gen():
2777
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
2781
def _entry_changes(file_id, entry, working_tree):
2782
"""Determine in which ways the inventory entry has changed.
2784
Returns booleans: has_contents, content_mod, meta_mod
2785
has_contents means there are currently contents, but they differ
2786
contents_mod means contents need to be modified
2787
meta_mod means the metadata needs to be modified
2789
cur_entry = working_tree.inventory[file_id]
2791
working_kind = working_tree.kind(file_id)
2794
has_contents = False
2797
if has_contents is True:
2798
if entry.kind != working_kind:
2799
contents_mod, meta_mod = True, False
2801
cur_entry._read_tree_state(working_tree.id2path(file_id),
2803
contents_mod, meta_mod = entry.detect_changes(cur_entry)
2804
cur_entry._forget_tree_state()
2805
return has_contents, contents_mod, meta_mod
2808
def revert(working_tree, target_tree, filenames, backups=False,
2809
pb=None, change_reporter=None):
2810
"""Revert a working tree's contents to those of a target tree."""
2811
target_tree.lock_read()
2812
pb = ui.ui_factory.nested_progress_bar()
2813
tt = TreeTransform(working_tree, pb)
2815
pp = ProgressPhase("Revert phase", 3, pb)
2816
conflicts, merge_modified = _prepare_revert_transform(
2817
working_tree, target_tree, tt, filenames, backups, pp)
2819
change_reporter = delta._ChangeReporter(
2820
unversioned_filter=working_tree.is_ignored)
2821
delta.report_changes(tt.iter_changes(), change_reporter)
2822
for conflict in conflicts:
2823
trace.warning(unicode(conflict))
2826
working_tree.set_merge_modified(merge_modified)
2828
target_tree.unlock()
2834
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2835
backups, pp, basis_tree=None,
2836
merge_modified=None):
2837
child_pb = ui.ui_factory.nested_progress_bar()
2839
if merge_modified is None:
2840
merge_modified = working_tree.merge_modified()
2841
merge_modified = _alter_files(working_tree, target_tree, tt,
2842
child_pb, filenames, backups,
2843
merge_modified, basis_tree)
2846
child_pb = ui.ui_factory.nested_progress_bar()
2848
raw_conflicts = resolve_conflicts(tt, child_pb,
2849
lambda t, c: conflict_pass(t, c, target_tree))
2852
conflicts = cook_conflicts(raw_conflicts, tt)
2853
return conflicts, merge_modified
2856
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
2857
backups, merge_modified, basis_tree=None):
2858
if basis_tree is not None:
2859
basis_tree.lock_read()
2860
# We ask the working_tree for its changes relative to the target, rather
2861
# than the target changes relative to the working tree. Because WT4 has an
2862
# optimizer to compare itself to a target, but no optimizer for the
2864
change_list = working_tree.iter_changes(target_tree,
2865
specific_files=specific_files, pb=pb)
2866
if target_tree.get_root_id() is None:
2872
for id_num, (file_id, path, changed_content, versioned, parent, name,
2873
kind, executable) in enumerate(change_list):
2874
target_path, wt_path = path
2875
target_versioned, wt_versioned = versioned
2876
target_parent, wt_parent = parent
2877
target_name, wt_name = name
2878
target_kind, wt_kind = kind
2879
target_executable, wt_executable = executable
2880
if skip_root and wt_parent is None:
2882
trans_id = tt.trans_id_file_id(file_id)
2885
keep_content = False
2886
if wt_kind == 'file' and (backups or target_kind is None):
2887
wt_sha1 = working_tree.get_file_sha1(file_id)
2888
if merge_modified.get(file_id) != wt_sha1:
2889
# acquire the basis tree lazily to prevent the
2890
# expense of accessing it when it's not needed ?
2891
# (Guessing, RBC, 200702)
2892
if basis_tree is None:
2893
basis_tree = working_tree.basis_tree()
2894
basis_tree.lock_read()
2895
if file_id in basis_tree:
2896
if wt_sha1 != basis_tree.get_file_sha1(file_id):
2898
elif target_kind is None and not target_versioned:
2900
if wt_kind is not None:
2901
if not keep_content:
2902
tt.delete_contents(trans_id)
2903
elif target_kind is not None:
2904
parent_trans_id = tt.trans_id_file_id(wt_parent)
2905
backup_name = tt._available_backup_name(
2906
wt_name, parent_trans_id)
2907
tt.adjust_path(backup_name, parent_trans_id, trans_id)
2908
new_trans_id = tt.create_path(wt_name, parent_trans_id)
2909
if wt_versioned and target_versioned:
2910
tt.unversion_file(trans_id)
2911
tt.version_file(file_id, new_trans_id)
2912
# New contents should have the same unix perms as old
2915
trans_id = new_trans_id
2916
if target_kind in ('directory', 'tree-reference'):
2917
tt.create_directory(trans_id)
2918
if target_kind == 'tree-reference':
2919
revision = target_tree.get_reference_revision(file_id,
2921
tt.set_tree_reference(revision, trans_id)
2922
elif target_kind == 'symlink':
2923
tt.create_symlink(target_tree.get_symlink_target(file_id),
2925
elif target_kind == 'file':
2926
deferred_files.append((file_id, (trans_id, mode_id)))
2927
if basis_tree is None:
2928
basis_tree = working_tree.basis_tree()
2929
basis_tree.lock_read()
2930
new_sha1 = target_tree.get_file_sha1(file_id)
2931
if (file_id in basis_tree and new_sha1 ==
2932
basis_tree.get_file_sha1(file_id)):
2933
if file_id in merge_modified:
2934
del merge_modified[file_id]
2936
merge_modified[file_id] = new_sha1
2938
# preserve the execute bit when backing up
2939
if keep_content and wt_executable == target_executable:
2940
tt.set_executability(target_executable, trans_id)
2941
elif target_kind is not None:
2942
raise AssertionError(target_kind)
2943
if not wt_versioned and target_versioned:
2944
tt.version_file(file_id, trans_id)
2945
if wt_versioned and not target_versioned:
2946
tt.unversion_file(trans_id)
2947
if (target_name is not None and
2948
(wt_name != target_name or wt_parent != target_parent)):
2949
if target_name == '' and target_parent is None:
2950
parent_trans = ROOT_PARENT
2952
parent_trans = tt.trans_id_file_id(target_parent)
2953
if wt_parent is None and wt_versioned:
2954
tt.adjust_root_path(target_name, parent_trans)
2956
tt.adjust_path(target_name, parent_trans, trans_id)
2957
if wt_executable != target_executable and target_kind == "file":
2958
tt.set_executability(target_executable, trans_id)
2959
if working_tree.supports_content_filtering():
2960
for index, ((trans_id, mode_id), bytes) in enumerate(
2961
target_tree.iter_files_bytes(deferred_files)):
2962
file_id = deferred_files[index][0]
2963
# We're reverting a tree to the target tree so using the
2964
# target tree to find the file path seems the best choice
2965
# here IMO - Ian C 27/Oct/2009
2966
filter_tree_path = target_tree.id2path(file_id)
2967
filters = working_tree._content_filter_stack(filter_tree_path)
2968
bytes = filtered_output_bytes(bytes, filters,
2969
ContentFilterContext(filter_tree_path, working_tree))
2970
tt.create_file(bytes, trans_id, mode_id)
2972
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2974
tt.create_file(bytes, trans_id, mode_id)
2975
tt.fixup_new_roots()
2977
if basis_tree is not None:
2979
return merge_modified
2982
def resolve_conflicts(tt, pb=None, pass_func=None):
2983
"""Make many conflict-resolution attempts, but die if they fail"""
2984
if pass_func is None:
2985
pass_func = conflict_pass
2986
new_conflicts = set()
2987
pb = ui.ui_factory.nested_progress_bar()
2990
pb.update('Resolution pass', n+1, 10)
2991
conflicts = tt.find_conflicts()
2992
if len(conflicts) == 0:
2993
return new_conflicts
2994
new_conflicts.update(pass_func(tt, conflicts))
2995
raise MalformedTransform(conflicts=conflicts)
3000
def conflict_pass(tt, conflicts, path_tree=None):
3001
"""Resolve some classes of conflicts.
3003
:param tt: The transform to resolve conflicts in
3004
:param conflicts: The conflicts to resolve
3005
:param path_tree: A Tree to get supplemental paths from
3007
new_conflicts = set()
3008
for c_type, conflict in ((c[0], c) for c in conflicts):
3009
if c_type == 'duplicate id':
3010
tt.unversion_file(conflict[1])
3011
new_conflicts.add((c_type, 'Unversioned existing file',
3012
conflict[1], conflict[2], ))
3013
elif c_type == 'duplicate':
3014
# files that were renamed take precedence
3015
final_parent = tt.final_parent(conflict[1])
3016
if tt.path_changed(conflict[1]):
3017
existing_file, new_file = conflict[2], conflict[1]
3019
existing_file, new_file = conflict[1], conflict[2]
3020
new_name = tt.final_name(existing_file)+'.moved'
3021
tt.adjust_path(new_name, final_parent, existing_file)
3022
new_conflicts.add((c_type, 'Moved existing file to',
3023
existing_file, new_file))
3024
elif c_type == 'parent loop':
3025
# break the loop by undoing one of the ops that caused the loop
3027
while not tt.path_changed(cur):
3028
cur = tt.final_parent(cur)
3029
new_conflicts.add((c_type, 'Cancelled move', cur,
3030
tt.final_parent(cur),))
3031
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
3033
elif c_type == 'missing parent':
3034
trans_id = conflict[1]
3035
if trans_id in tt._removed_contents:
3036
cancel_deletion = True
3037
orphans = tt._get_potential_orphans(trans_id)
3039
cancel_deletion = False
3040
# All children are orphans
3043
tt.new_orphan(o, trans_id)
3044
except OrphaningError:
3045
# Something bad happened so we cancel the directory
3046
# deletion which will leave it in place with a
3047
# conflict. The user can deal with it from there.
3048
# Note that this also catch the case where we don't
3049
# want to create orphans and leave the directory in
3051
cancel_deletion = True
3054
# Cancel the directory deletion
3055
tt.cancel_deletion(trans_id)
3056
new_conflicts.add(('deleting parent', 'Not deleting',
3061
tt.final_name(trans_id)
3063
if path_tree is not None:
3064
file_id = tt.final_file_id(trans_id)
3066
file_id = tt.inactive_file_id(trans_id)
3067
_, entry = path_tree.iter_entries_by_dir(
3069
# special-case the other tree root (move its
3070
# children to current root)
3071
if entry.parent_id is None:
3073
moved = _reparent_transform_children(
3074
tt, trans_id, tt.root)
3076
new_conflicts.add((c_type, 'Moved to root',
3079
parent_trans_id = tt.trans_id_file_id(
3081
tt.adjust_path(entry.name, parent_trans_id,
3084
tt.create_directory(trans_id)
3085
new_conflicts.add((c_type, 'Created directory', trans_id))
3086
elif c_type == 'unversioned parent':
3087
file_id = tt.inactive_file_id(conflict[1])
3088
# special-case the other tree root (move its children instead)
3089
if path_tree and file_id in path_tree:
3090
if path_tree.path2id('') == file_id:
3091
# This is the root entry, skip it
3093
tt.version_file(file_id, conflict[1])
3094
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
3095
elif c_type == 'non-directory parent':
3096
parent_id = conflict[1]
3097
parent_parent = tt.final_parent(parent_id)
3098
parent_name = tt.final_name(parent_id)
3099
parent_file_id = tt.final_file_id(parent_id)
3100
new_parent_id = tt.new_directory(parent_name + '.new',
3101
parent_parent, parent_file_id)
3102
_reparent_transform_children(tt, parent_id, new_parent_id)
3103
if parent_file_id is not None:
3104
tt.unversion_file(parent_id)
3105
new_conflicts.add((c_type, 'Created directory', new_parent_id))
3106
elif c_type == 'versioning no contents':
3107
tt.cancel_versioning(conflict[1])
3108
return new_conflicts
3111
def cook_conflicts(raw_conflicts, tt):
3112
"""Generate a list of cooked conflicts, sorted by file path"""
3113
from bzrlib.conflicts import Conflict
3114
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
3115
return sorted(conflict_iter, key=Conflict.sort_key)
3118
def iter_cook_conflicts(raw_conflicts, tt):
3119
from bzrlib.conflicts import Conflict
3121
for conflict in raw_conflicts:
3122
c_type = conflict[0]
3123
action = conflict[1]
3124
modified_path = fp.get_path(conflict[2])
3125
modified_id = tt.final_file_id(conflict[2])
3126
if len(conflict) == 3:
3127
yield Conflict.factory(c_type, action=action, path=modified_path,
3128
file_id=modified_id)
3131
conflicting_path = fp.get_path(conflict[3])
3132
conflicting_id = tt.final_file_id(conflict[3])
3133
yield Conflict.factory(c_type, action=action, path=modified_path,
3134
file_id=modified_id,
3135
conflict_path=conflicting_path,
3136
conflict_file_id=conflicting_id)
3139
class _FileMover(object):
3140
"""Moves and deletes files for TreeTransform, tracking operations"""
3143
self.past_renames = []
3144
self.pending_deletions = []
3146
def rename(self, from_, to):
3147
"""Rename a file from one path to another."""
3149
os.rename(from_, to)
3151
if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
3152
raise errors.FileExists(to, str(e))
3153
# normal OSError doesn't include filenames so it's hard to see where
3154
# the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
3155
raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
3156
self.past_renames.append((from_, to))
3158
def pre_delete(self, from_, to):
3159
"""Rename a file out of the way and mark it for deletion.
3161
Unlike os.unlink, this works equally well for files and directories.
3162
:param from_: The current file path
3163
:param to: A temporary path for the file
3165
self.rename(from_, to)
3166
self.pending_deletions.append(to)
3169
"""Reverse all renames that have been performed"""
3170
for from_, to in reversed(self.past_renames):
3172
os.rename(to, from_)
3174
raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
3175
# after rollback, don't reuse _FileMover
3177
pending_deletions = None
3179
def apply_deletions(self):
3180
"""Apply all marked deletions"""
3181
for path in self.pending_deletions:
3183
# after apply_deletions, don't reuse _FileMover
3185
pending_deletions = None
added
removed
bzrlib/transform.py
