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
file_id = self._tree.path2id(path)
1903
return self._tree.kind(file_id)
1904
except errors.NoSuchFile:
1907
def _set_mode(self, trans_id, mode_id, typefunc):
1908
"""Set the mode of new file contents.
1909
The mode_id is the existing file to get the mode from (often the same
1910
as trans_id). The operation is only performed if there's a mode match
1911
according to typefunc.
1913
# is it ok to ignore this? probably
1916
def iter_tree_children(self, parent_id):
1917
"""Iterate through the entry's tree children, if any"""
1919
path = self._tree_id_paths[parent_id]
1922
file_id = self.tree_file_id(parent_id)
1925
entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1926
children = getattr(entry, 'children', {})
1927
for child in children:
1928
childpath = joinpath(path, child)
1929
yield self.trans_id_tree_path(childpath)
1931
def new_orphan(self, trans_id, parent_id):
1932
raise NotImplementedError(self.new_orphan)
1935
class _PreviewTree(tree.InventoryTree):
1936
"""Partial implementation of Tree to support show_diff_trees"""
1938
def __init__(self, transform):
1939
self._transform = transform
1940
self._final_paths = FinalPaths(transform)
1941
self.__by_parent = None
1942
self._parent_ids = []
1943
self._all_children_cache = {}
1944
self._path2trans_id_cache = {}
1945
self._final_name_cache = {}
1946
self._iter_changes_cache = dict((c[0], c) for c in
1947
self._transform.iter_changes())
1949
def _content_change(self, file_id):
1950
"""Return True if the content of this file changed"""
1951
changes = self._iter_changes_cache.get(file_id)
1952
# changes[2] is true if the file content changed. See
1953
# InterTree.iter_changes.
1954
return (changes is not None and changes[2])
1956
def _get_repository(self):
1957
repo = getattr(self._transform._tree, '_repository', None)
1959
repo = self._transform._tree.branch.repository
1962
def _iter_parent_trees(self):
1963
for revision_id in self.get_parent_ids():
1965
yield self.revision_tree(revision_id)
1966
except errors.NoSuchRevisionInTree:
1967
yield self._get_repository().revision_tree(revision_id)
1969
def _get_file_revision(self, file_id, vf, tree_revision):
1970
parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
1971
self._iter_parent_trees()]
1972
vf.add_lines((file_id, tree_revision), parent_keys,
1973
self.get_file_lines(file_id))
1974
repo = self._get_repository()
1975
base_vf = repo.texts
1976
if base_vf not in vf.fallback_versionedfiles:
1977
vf.fallback_versionedfiles.append(base_vf)
1978
return tree_revision
1980
def _stat_limbo_file(self, file_id):
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
if self.kind(file_id) == 'file':
2203
return self._transform._tree.get_file_size(file_id)
2207
def get_file_sha1(self, file_id, path=None, stat_value=None):
2208
trans_id = self._transform.trans_id_file_id(file_id)
2209
kind = self._transform._new_contents.get(trans_id)
2211
return self._transform._tree.get_file_sha1(file_id)
2213
fileobj = self.get_file(file_id)
2215
return sha_file(fileobj)
2219
def is_executable(self, file_id, path=None):
2222
trans_id = self._transform.trans_id_file_id(file_id)
2224
return self._transform._new_executability[trans_id]
2227
return self._transform._tree.is_executable(file_id, path)
2229
if e.errno == errno.ENOENT:
2232
except errors.NoSuchId:
2235
def path_content_summary(self, path):
2236
trans_id = self._path2trans_id(path)
2237
tt = self._transform
2238
tree_path = tt._tree_id_paths.get(trans_id)
2239
kind = tt._new_contents.get(trans_id)
2241
if tree_path is None or trans_id in tt._removed_contents:
2242
return 'missing', None, None, None
2243
summary = tt._tree.path_content_summary(tree_path)
2244
kind, size, executable, link_or_sha1 = summary
2247
limbo_name = tt._limbo_name(trans_id)
2248
if trans_id in tt._new_reference_revision:
2249
kind = 'tree-reference'
2251
statval = os.lstat(limbo_name)
2252
size = statval.st_size
2253
if not supports_executable():
2256
executable = statval.st_mode & S_IEXEC
2260
if kind == 'symlink':
2261
link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2262
executable = tt._new_executability.get(trans_id, executable)
2263
return kind, size, executable, link_or_sha1
2265
def iter_changes(self, from_tree, include_unchanged=False,
2266
specific_files=None, pb=None, extra_trees=None,
2267
require_versioned=True, want_unversioned=False):
2268
"""See InterTree.iter_changes.
2270
This has a fast path that is only used when the from_tree matches
2271
the transform tree, and no fancy options are supplied.
2273
if (from_tree is not self._transform._tree or include_unchanged or
2274
specific_files or want_unversioned):
2275
return tree.InterTree(from_tree, self).iter_changes(
2276
include_unchanged=include_unchanged,
2277
specific_files=specific_files,
2279
extra_trees=extra_trees,
2280
require_versioned=require_versioned,
2281
want_unversioned=want_unversioned)
2282
if want_unversioned:
2283
raise ValueError('want_unversioned is not supported')
2284
return self._transform.iter_changes()
2286
def get_file(self, file_id, path=None):
2287
"""See Tree.get_file"""
2288
if not self._content_change(file_id):
2289
return self._transform._tree.get_file(file_id, path)
2290
trans_id = self._transform.trans_id_file_id(file_id)
2291
name = self._transform._limbo_name(trans_id)
2292
return open(name, 'rb')
2294
def get_file_with_stat(self, file_id, path=None):
2295
return self.get_file(file_id, path), None
2297
def annotate_iter(self, file_id,
2298
default_revision=_mod_revision.CURRENT_REVISION):
2299
changes = self._iter_changes_cache.get(file_id)
2303
changed_content, versioned, kind = (changes[2], changes[3],
2307
get_old = (kind[0] == 'file' and versioned[0])
2309
old_annotation = self._transform._tree.annotate_iter(file_id,
2310
default_revision=default_revision)
2314
return old_annotation
2315
if not changed_content:
2316
return old_annotation
2317
# TODO: This is doing something similar to what WT.annotate_iter is
2318
# doing, however it fails slightly because it doesn't know what
2319
# the *other* revision_id is, so it doesn't know how to give the
2320
# other as the origin for some lines, they all get
2321
# 'default_revision'
2322
# It would be nice to be able to use the new Annotator based
2323
# approach, as well.
2324
return annotate.reannotate([old_annotation],
2325
self.get_file(file_id).readlines(),
2328
def get_symlink_target(self, file_id):
2329
"""See Tree.get_symlink_target"""
2330
if not self._content_change(file_id):
2331
return self._transform._tree.get_symlink_target(file_id)
2332
trans_id = self._transform.trans_id_file_id(file_id)
2333
name = self._transform._limbo_name(trans_id)
2334
return osutils.readlink(name)
2336
def walkdirs(self, prefix=''):
2337
pending = [self._transform.root]
2338
while len(pending) > 0:
2339
parent_id = pending.pop()
2342
prefix = prefix.rstrip('/')
2343
parent_path = self._final_paths.get_path(parent_id)
2344
parent_file_id = self._transform.final_file_id(parent_id)
2345
for child_id in self._all_children(parent_id):
2346
path_from_root = self._final_paths.get_path(child_id)
2347
basename = self._transform.final_name(child_id)
2348
file_id = self._transform.final_file_id(child_id)
2349
kind = self._transform.final_kind(child_id)
2350
if kind is not None:
2351
versioned_kind = kind
2354
versioned_kind = self._transform._tree.stored_kind(file_id)
2355
if versioned_kind == 'directory':
2356
subdirs.append(child_id)
2357
children.append((path_from_root, basename, kind, None,
2358
file_id, versioned_kind))
2360
if parent_path.startswith(prefix):
2361
yield (parent_path, parent_file_id), children
2362
pending.extend(sorted(subdirs, key=self._final_paths.get_path,
2365
def get_parent_ids(self):
2366
return self._parent_ids
2368
def set_parent_ids(self, parent_ids):
2369
self._parent_ids = parent_ids
2371
def get_revision_tree(self, revision_id):
2372
return self._transform._tree.get_revision_tree(revision_id)
2375
def joinpath(parent, child):
2376
"""Join tree-relative paths, handling the tree root specially"""
2377
if parent is None or parent == "":
2380
return pathjoin(parent, child)
2383
class FinalPaths(object):
2384
"""Make path calculation cheap by memoizing paths.
2386
The underlying tree must not be manipulated between calls, or else
2387
the results will likely be incorrect.
2389
def __init__(self, transform):
2390
object.__init__(self)
2391
self._known_paths = {}
2392
self.transform = transform
2394
def _determine_path(self, trans_id):
2395
if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
2397
name = self.transform.final_name(trans_id)
2398
parent_id = self.transform.final_parent(trans_id)
2399
if parent_id == self.transform.root:
2402
return pathjoin(self.get_path(parent_id), name)
2404
def get_path(self, trans_id):
2405
"""Find the final path associated with a trans_id"""
2406
if trans_id not in self._known_paths:
2407
self._known_paths[trans_id] = self._determine_path(trans_id)
2408
return self._known_paths[trans_id]
2410
def get_paths(self, trans_ids):
2411
return [(self.get_path(t), t) for t in trans_ids]
2415
def topology_sorted_ids(tree):
2416
"""Determine the topological order of the ids in a tree"""
2417
file_ids = list(tree)
2418
file_ids.sort(key=tree.id2path)
2422
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
2423
delta_from_tree=False):
2424
"""Create working tree for a branch, using a TreeTransform.
2426
This function should be used on empty trees, having a tree root at most.
2427
(see merge and revert functionality for working with existing trees)
2429
Existing files are handled like so:
2431
- Existing bzrdirs take precedence over creating new items. They are
2432
created as '%s.diverted' % name.
2433
- Otherwise, if the content on disk matches the content we are building,
2434
it is silently replaced.
2435
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
2437
:param tree: The tree to convert wt into a copy of
2438
:param wt: The working tree that files will be placed into
2439
:param accelerator_tree: A tree which can be used for retrieving file
2440
contents more quickly than tree itself, i.e. a workingtree. tree
2441
will be used for cases where accelerator_tree's content is different.
2442
:param hardlink: If true, hard-link files to accelerator_tree, where
2443
possible. accelerator_tree must implement abspath, i.e. be a
2445
:param delta_from_tree: If true, build_tree may use the input Tree to
2446
generate the inventory delta.
2448
wt.lock_tree_write()
2452
if accelerator_tree is not None:
2453
accelerator_tree.lock_read()
2455
return _build_tree(tree, wt, accelerator_tree, hardlink,
2458
if accelerator_tree is not None:
2459
accelerator_tree.unlock()
2466
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
2467
"""See build_tree."""
2468
for num, _unused in enumerate(wt.all_file_ids()):
2469
if num > 0: # more than just a root
2470
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
2472
top_pb = ui.ui_factory.nested_progress_bar()
2473
pp = ProgressPhase("Build phase", 2, top_pb)
2474
if tree.inventory.root is not None:
2475
# This is kind of a hack: we should be altering the root
2476
# as part of the regular tree shape diff logic.
2477
# The conditional test here is to avoid doing an
2478
# expensive operation (flush) every time the root id
2479
# is set within the tree, nor setting the root and thus
2480
# marking the tree as dirty, because we use two different
2481
# idioms here: tree interfaces and inventory interfaces.
2482
if wt.get_root_id() != tree.get_root_id():
2483
wt.set_root_id(tree.get_root_id())
2485
tt = TreeTransform(wt)
2489
file_trans_id[wt.get_root_id()] = \
2490
tt.trans_id_tree_file_id(wt.get_root_id())
2491
pb = ui.ui_factory.nested_progress_bar()
2493
deferred_contents = []
2495
total = len(tree.inventory)
2497
precomputed_delta = []
2499
precomputed_delta = None
2500
# Check if tree inventory has content. If so, we populate
2501
# existing_files with the directory content. If there are no
2502
# entries we skip populating existing_files as its not used.
2503
# This improves performance and unncessary work on large
2504
# directory trees. (#501307)
2506
existing_files = set()
2507
for dir, files in wt.walkdirs():
2508
existing_files.update(f[0] for f in files)
2509
for num, (tree_path, entry) in \
2510
enumerate(tree.inventory.iter_entries_by_dir()):
2511
pb.update("Building tree", num - len(deferred_contents), total)
2512
if entry.parent_id is None:
2515
file_id = entry.file_id
2517
precomputed_delta.append((None, tree_path, file_id, entry))
2518
if tree_path in existing_files:
2519
target_path = wt.abspath(tree_path)
2520
kind = file_kind(target_path)
2521
if kind == "directory":
2523
bzrdir.BzrDir.open(target_path)
2524
except errors.NotBranchError:
2528
if (file_id not in divert and
2529
_content_match(tree, entry, file_id, kind,
2531
tt.delete_contents(tt.trans_id_tree_path(tree_path))
2532
if kind == 'directory':
2534
parent_id = file_trans_id[entry.parent_id]
2535
if entry.kind == 'file':
2536
# We *almost* replicate new_by_entry, so that we can defer
2537
# getting the file text, and get them all at once.
2538
trans_id = tt.create_path(entry.name, parent_id)
2539
file_trans_id[file_id] = trans_id
2540
tt.version_file(file_id, trans_id)
2541
executable = tree.is_executable(file_id, tree_path)
2543
tt.set_executability(executable, trans_id)
2544
trans_data = (trans_id, tree_path, entry.text_sha1)
2545
deferred_contents.append((file_id, trans_data))
2547
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2550
new_trans_id = file_trans_id[file_id]
2551
old_parent = tt.trans_id_tree_path(tree_path)
2552
_reparent_children(tt, old_parent, new_trans_id)
2553
offset = num + 1 - len(deferred_contents)
2554
_create_files(tt, tree, deferred_contents, pb, offset,
2555
accelerator_tree, hardlink)
2559
divert_trans = set(file_trans_id[f] for f in divert)
2560
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
2561
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
2562
if len(raw_conflicts) > 0:
2563
precomputed_delta = None
2564
conflicts = cook_conflicts(raw_conflicts, tt)
2565
for conflict in conflicts:
2566
trace.warning(conflict)
2568
wt.add_conflicts(conflicts)
2569
except errors.UnsupportedOperation:
2571
result = tt.apply(no_conflicts=True,
2572
precomputed_delta=precomputed_delta)
2579
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
2581
total = len(desired_files) + offset
2583
if accelerator_tree is None:
2584
new_desired_files = desired_files
2586
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2587
unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2588
in iter if not (c or e[0] != e[1])]
2589
if accelerator_tree.supports_content_filtering():
2590
unchanged = [(f, p) for (f, p) in unchanged
2591
if not accelerator_tree.iter_search_rules([p]).next()]
2592
unchanged = dict(unchanged)
2593
new_desired_files = []
2595
for file_id, (trans_id, tree_path, text_sha1) in desired_files:
2596
accelerator_path = unchanged.get(file_id)
2597
if accelerator_path is None:
2598
new_desired_files.append((file_id,
2599
(trans_id, tree_path, text_sha1)))
2601
pb.update('Adding file contents', count + offset, total)
2603
tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2606
contents = accelerator_tree.get_file(file_id, accelerator_path)
2607
if wt.supports_content_filtering():
2608
filters = wt._content_filter_stack(tree_path)
2609
contents = filtered_output_bytes(contents, filters,
2610
ContentFilterContext(tree_path, tree))
2612
tt.create_file(contents, trans_id, sha1=text_sha1)
2616
except AttributeError:
2617
# after filtering, contents may no longer be file-like
2621
for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
2622
tree.iter_files_bytes(new_desired_files)):
2623
if wt.supports_content_filtering():
2624
filters = wt._content_filter_stack(tree_path)
2625
contents = filtered_output_bytes(contents, filters,
2626
ContentFilterContext(tree_path, tree))
2627
tt.create_file(contents, trans_id, sha1=text_sha1)
2628
pb.update('Adding file contents', count + offset, total)
2631
def _reparent_children(tt, old_parent, new_parent):
2632
for child in tt.iter_tree_children(old_parent):
2633
tt.adjust_path(tt.final_name(child), new_parent, child)
2636
def _reparent_transform_children(tt, old_parent, new_parent):
2637
by_parent = tt.by_parent()
2638
for child in by_parent[old_parent]:
2639
tt.adjust_path(tt.final_name(child), new_parent, child)
2640
return by_parent[old_parent]
2643
def _content_match(tree, entry, file_id, kind, target_path):
2644
if entry.kind != kind:
2646
if entry.kind == "directory":
2648
if entry.kind == "file":
2649
f = file(target_path, 'rb')
2651
if tree.get_file_text(file_id) == f.read():
2655
elif entry.kind == "symlink":
2656
if tree.get_symlink_target(file_id) == os.readlink(target_path):
2661
def resolve_checkout(tt, conflicts, divert):
2662
new_conflicts = set()
2663
for c_type, conflict in ((c[0], c) for c in conflicts):
2664
# Anything but a 'duplicate' would indicate programmer error
2665
if c_type != 'duplicate':
2666
raise AssertionError(c_type)
2667
# Now figure out which is new and which is old
2668
if tt.new_contents(conflict[1]):
2669
new_file = conflict[1]
2670
old_file = conflict[2]
2672
new_file = conflict[2]
2673
old_file = conflict[1]
2675
# We should only get here if the conflict wasn't completely
2677
final_parent = tt.final_parent(old_file)
2678
if new_file in divert:
2679
new_name = tt.final_name(old_file)+'.diverted'
2680
tt.adjust_path(new_name, final_parent, new_file)
2681
new_conflicts.add((c_type, 'Diverted to',
2682
new_file, old_file))
2684
new_name = tt.final_name(old_file)+'.moved'
2685
tt.adjust_path(new_name, final_parent, old_file)
2686
new_conflicts.add((c_type, 'Moved existing file to',
2687
old_file, new_file))
2688
return new_conflicts
2691
def new_by_entry(tt, entry, parent_id, tree):
2692
"""Create a new file according to its inventory entry"""
2696
contents = tree.get_file(entry.file_id).readlines()
2697
executable = tree.is_executable(entry.file_id)
2698
return tt.new_file(name, parent_id, contents, entry.file_id,
2700
elif kind in ('directory', 'tree-reference'):
2701
trans_id = tt.new_directory(name, parent_id, entry.file_id)
2702
if kind == 'tree-reference':
2703
tt.set_tree_reference(entry.reference_revision, trans_id)
2705
elif kind == 'symlink':
2706
target = tree.get_symlink_target(entry.file_id)
2707
return tt.new_symlink(name, parent_id, target, entry.file_id)
2709
raise errors.BadFileKindError(name, kind)
2712
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2713
filter_tree_path=None):
2714
"""Create new file contents according to tree contents.
2716
:param filter_tree_path: the tree path to use to lookup
2717
content filters to apply to the bytes output in the working tree.
2718
This only applies if the working tree supports content filtering.
2720
kind = tree.kind(file_id)
2721
if kind == 'directory':
2722
tt.create_directory(trans_id)
2723
elif kind == "file":
2725
tree_file = tree.get_file(file_id)
2727
bytes = tree_file.readlines()
2731
if wt.supports_content_filtering() and filter_tree_path is not None:
2732
filters = wt._content_filter_stack(filter_tree_path)
2733
bytes = filtered_output_bytes(bytes, filters,
2734
ContentFilterContext(filter_tree_path, tree))
2735
tt.create_file(bytes, trans_id)
2736
elif kind == "symlink":
2737
tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2739
raise AssertionError('Unknown kind %r' % kind)
2742
def create_entry_executability(tt, entry, trans_id):
2743
"""Set the executability of a trans_id according to an inventory entry"""
2744
if entry.kind == "file":
2745
tt.set_executability(entry.executable, trans_id)
2748
@deprecated_function(deprecated_in((2, 3, 0)))
2749
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2750
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2753
@deprecated_function(deprecated_in((2, 3, 0)))
2754
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2755
"""Produce a backup-style name that appears to be available"""
2759
yield "%s.~%d~" % (name, counter)
2761
for new_name in name_gen():
2762
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
2766
def _entry_changes(file_id, entry, working_tree):
2767
"""Determine in which ways the inventory entry has changed.
2769
Returns booleans: has_contents, content_mod, meta_mod
2770
has_contents means there are currently contents, but they differ
2771
contents_mod means contents need to be modified
2772
meta_mod means the metadata needs to be modified
2774
cur_entry = working_tree.inventory[file_id]
2776
working_kind = working_tree.kind(file_id)
2779
has_contents = False
2782
if has_contents is True:
2783
if entry.kind != working_kind:
2784
contents_mod, meta_mod = True, False
2786
cur_entry._read_tree_state(working_tree.id2path(file_id),
2788
contents_mod, meta_mod = entry.detect_changes(cur_entry)
2789
cur_entry._forget_tree_state()
2790
return has_contents, contents_mod, meta_mod
2793
def revert(working_tree, target_tree, filenames, backups=False,
2794
pb=None, change_reporter=None):
2795
"""Revert a working tree's contents to those of a target tree."""
2796
target_tree.lock_read()
2797
pb = ui.ui_factory.nested_progress_bar()
2798
tt = TreeTransform(working_tree, pb)
2800
pp = ProgressPhase("Revert phase", 3, pb)
2801
conflicts, merge_modified = _prepare_revert_transform(
2802
working_tree, target_tree, tt, filenames, backups, pp)
2804
change_reporter = delta._ChangeReporter(
2805
unversioned_filter=working_tree.is_ignored)
2806
delta.report_changes(tt.iter_changes(), change_reporter)
2807
for conflict in conflicts:
2808
trace.warning(conflict)
2811
working_tree.set_merge_modified(merge_modified)
2813
target_tree.unlock()
2819
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2820
backups, pp, basis_tree=None,
2821
merge_modified=None):
2822
child_pb = ui.ui_factory.nested_progress_bar()
2824
if merge_modified is None:
2825
merge_modified = working_tree.merge_modified()
2826
merge_modified = _alter_files(working_tree, target_tree, tt,
2827
child_pb, filenames, backups,
2828
merge_modified, basis_tree)
2831
child_pb = ui.ui_factory.nested_progress_bar()
2833
raw_conflicts = resolve_conflicts(tt, child_pb,
2834
lambda t, c: conflict_pass(t, c, target_tree))
2837
conflicts = cook_conflicts(raw_conflicts, tt)
2838
return conflicts, merge_modified
2841
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
2842
backups, merge_modified, basis_tree=None):
2843
if basis_tree is not None:
2844
basis_tree.lock_read()
2845
change_list = target_tree.iter_changes(working_tree,
2846
specific_files=specific_files, pb=pb)
2847
if target_tree.get_root_id() is None:
2853
for id_num, (file_id, path, changed_content, versioned, parent, name,
2854
kind, executable) in enumerate(change_list):
2855
if skip_root and file_id[0] is not None and parent[0] is None:
2857
trans_id = tt.trans_id_file_id(file_id)
2860
keep_content = False
2861
if kind[0] == 'file' and (backups or kind[1] is None):
2862
wt_sha1 = working_tree.get_file_sha1(file_id)
2863
if merge_modified.get(file_id) != wt_sha1:
2864
# acquire the basis tree lazily to prevent the
2865
# expense of accessing it when it's not needed ?
2866
# (Guessing, RBC, 200702)
2867
if basis_tree is None:
2868
basis_tree = working_tree.basis_tree()
2869
basis_tree.lock_read()
2870
if file_id in basis_tree:
2871
if wt_sha1 != basis_tree.get_file_sha1(file_id):
2873
elif kind[1] is None and not versioned[1]:
2875
if kind[0] is not None:
2876
if not keep_content:
2877
tt.delete_contents(trans_id)
2878
elif kind[1] is not None:
2879
parent_trans_id = tt.trans_id_file_id(parent[0])
2880
backup_name = tt._available_backup_name(
2881
name[0], parent_trans_id)
2882
tt.adjust_path(backup_name, parent_trans_id, trans_id)
2883
new_trans_id = tt.create_path(name[0], parent_trans_id)
2884
if versioned == (True, True):
2885
tt.unversion_file(trans_id)
2886
tt.version_file(file_id, new_trans_id)
2887
# New contents should have the same unix perms as old
2890
trans_id = new_trans_id
2891
if kind[1] in ('directory', 'tree-reference'):
2892
tt.create_directory(trans_id)
2893
if kind[1] == 'tree-reference':
2894
revision = target_tree.get_reference_revision(file_id,
2896
tt.set_tree_reference(revision, trans_id)
2897
elif kind[1] == 'symlink':
2898
tt.create_symlink(target_tree.get_symlink_target(file_id),
2900
elif kind[1] == 'file':
2901
deferred_files.append((file_id, (trans_id, mode_id)))
2902
if basis_tree is None:
2903
basis_tree = working_tree.basis_tree()
2904
basis_tree.lock_read()
2905
new_sha1 = target_tree.get_file_sha1(file_id)
2906
if (file_id in basis_tree and new_sha1 ==
2907
basis_tree.get_file_sha1(file_id)):
2908
if file_id in merge_modified:
2909
del merge_modified[file_id]
2911
merge_modified[file_id] = new_sha1
2913
# preserve the execute bit when backing up
2914
if keep_content and executable[0] == executable[1]:
2915
tt.set_executability(executable[1], trans_id)
2916
elif kind[1] is not None:
2917
raise AssertionError(kind[1])
2918
if versioned == (False, True):
2919
tt.version_file(file_id, trans_id)
2920
if versioned == (True, False):
2921
tt.unversion_file(trans_id)
2922
if (name[1] is not None and
2923
(name[0] != name[1] or parent[0] != parent[1])):
2924
if name[1] == '' and parent[1] is None:
2925
parent_trans = ROOT_PARENT
2927
parent_trans = tt.trans_id_file_id(parent[1])
2928
if parent[0] is None and versioned[0]:
2929
tt.adjust_root_path(name[1], parent_trans)
2931
tt.adjust_path(name[1], parent_trans, trans_id)
2932
if executable[0] != executable[1] and kind[1] == "file":
2933
tt.set_executability(executable[1], trans_id)
2934
if working_tree.supports_content_filtering():
2935
for index, ((trans_id, mode_id), bytes) in enumerate(
2936
target_tree.iter_files_bytes(deferred_files)):
2937
file_id = deferred_files[index][0]
2938
# We're reverting a tree to the target tree so using the
2939
# target tree to find the file path seems the best choice
2940
# here IMO - Ian C 27/Oct/2009
2941
filter_tree_path = target_tree.id2path(file_id)
2942
filters = working_tree._content_filter_stack(filter_tree_path)
2943
bytes = filtered_output_bytes(bytes, filters,
2944
ContentFilterContext(filter_tree_path, working_tree))
2945
tt.create_file(bytes, trans_id, mode_id)
2947
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2949
tt.create_file(bytes, trans_id, mode_id)
2950
tt.fixup_new_roots()
2952
if basis_tree is not None:
2954
return merge_modified
2957
def resolve_conflicts(tt, pb=None, pass_func=None):
2958
"""Make many conflict-resolution attempts, but die if they fail"""
2959
if pass_func is None:
2960
pass_func = conflict_pass
2961
new_conflicts = set()
2962
pb = ui.ui_factory.nested_progress_bar()
2965
pb.update('Resolution pass', n+1, 10)
2966
conflicts = tt.find_conflicts()
2967
if len(conflicts) == 0:
2968
return new_conflicts
2969
new_conflicts.update(pass_func(tt, conflicts))
2970
raise MalformedTransform(conflicts=conflicts)
2975
def conflict_pass(tt, conflicts, path_tree=None):
2976
"""Resolve some classes of conflicts.
2978
:param tt: The transform to resolve conflicts in
2979
:param conflicts: The conflicts to resolve
2980
:param path_tree: A Tree to get supplemental paths from
2982
new_conflicts = set()
2983
for c_type, conflict in ((c[0], c) for c in conflicts):
2984
if c_type == 'duplicate id':
2985
tt.unversion_file(conflict[1])
2986
new_conflicts.add((c_type, 'Unversioned existing file',
2987
conflict[1], conflict[2], ))
2988
elif c_type == 'duplicate':
2989
# files that were renamed take precedence
2990
final_parent = tt.final_parent(conflict[1])
2991
if tt.path_changed(conflict[1]):
2992
existing_file, new_file = conflict[2], conflict[1]
2994
existing_file, new_file = conflict[1], conflict[2]
2995
new_name = tt.final_name(existing_file)+'.moved'
2996
tt.adjust_path(new_name, final_parent, existing_file)
2997
new_conflicts.add((c_type, 'Moved existing file to',
2998
existing_file, new_file))
2999
elif c_type == 'parent loop':
3000
# break the loop by undoing one of the ops that caused the loop
3002
while not tt.path_changed(cur):
3003
cur = tt.final_parent(cur)
3004
new_conflicts.add((c_type, 'Cancelled move', cur,
3005
tt.final_parent(cur),))
3006
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
3008
elif c_type == 'missing parent':
3009
trans_id = conflict[1]
3010
if trans_id in tt._removed_contents:
3011
cancel_deletion = True
3012
orphans = tt._get_potential_orphans(trans_id)
3014
cancel_deletion = False
3015
# All children are orphans
3018
tt.new_orphan(o, trans_id)
3019
except OrphaningError:
3020
# Something bad happened so we cancel the directory
3021
# deletion which will leave it in place with a
3022
# conflict. The user can deal with it from there.
3023
# Note that this also catch the case where we don't
3024
# want to create orphans and leave the directory in
3026
cancel_deletion = True
3029
# Cancel the directory deletion
3030
tt.cancel_deletion(trans_id)
3031
new_conflicts.add(('deleting parent', 'Not deleting',
3036
tt.final_name(trans_id)
3038
if path_tree is not None:
3039
file_id = tt.final_file_id(trans_id)
3041
file_id = tt.inactive_file_id(trans_id)
3042
_, entry = path_tree.iter_entries_by_dir(
3044
# special-case the other tree root (move its
3045
# children to current root)
3046
if entry.parent_id is None:
3048
moved = _reparent_transform_children(
3049
tt, trans_id, tt.root)
3051
new_conflicts.add((c_type, 'Moved to root',
3054
parent_trans_id = tt.trans_id_file_id(
3056
tt.adjust_path(entry.name, parent_trans_id,
3059
tt.create_directory(trans_id)
3060
new_conflicts.add((c_type, 'Created directory', trans_id))
3061
elif c_type == 'unversioned parent':
3062
file_id = tt.inactive_file_id(conflict[1])
3063
# special-case the other tree root (move its children instead)
3064
if path_tree and file_id in path_tree:
3065
if path_tree.path2id('') == file_id:
3066
# This is the root entry, skip it
3068
tt.version_file(file_id, conflict[1])
3069
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
3070
elif c_type == 'non-directory parent':
3071
parent_id = conflict[1]
3072
parent_parent = tt.final_parent(parent_id)
3073
parent_name = tt.final_name(parent_id)
3074
parent_file_id = tt.final_file_id(parent_id)
3075
new_parent_id = tt.new_directory(parent_name + '.new',
3076
parent_parent, parent_file_id)
3077
_reparent_transform_children(tt, parent_id, new_parent_id)
3078
if parent_file_id is not None:
3079
tt.unversion_file(parent_id)
3080
new_conflicts.add((c_type, 'Created directory', new_parent_id))
3081
elif c_type == 'versioning no contents':
3082
tt.cancel_versioning(conflict[1])
3083
return new_conflicts
3086
def cook_conflicts(raw_conflicts, tt):
3087
"""Generate a list of cooked conflicts, sorted by file path"""
3088
from bzrlib.conflicts import Conflict
3089
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
3090
return sorted(conflict_iter, key=Conflict.sort_key)
3093
def iter_cook_conflicts(raw_conflicts, tt):
3094
from bzrlib.conflicts import Conflict
3096
for conflict in raw_conflicts:
3097
c_type = conflict[0]
3098
action = conflict[1]
3099
modified_path = fp.get_path(conflict[2])
3100
modified_id = tt.final_file_id(conflict[2])
3101
if len(conflict) == 3:
3102
yield Conflict.factory(c_type, action=action, path=modified_path,
3103
file_id=modified_id)
3106
conflicting_path = fp.get_path(conflict[3])
3107
conflicting_id = tt.final_file_id(conflict[3])
3108
yield Conflict.factory(c_type, action=action, path=modified_path,
3109
file_id=modified_id,
3110
conflict_path=conflicting_path,
3111
conflict_file_id=conflicting_id)
3114
class _FileMover(object):
3115
"""Moves and deletes files for TreeTransform, tracking operations"""
3118
self.past_renames = []
3119
self.pending_deletions = []
3121
def rename(self, from_, to):
3122
"""Rename a file from one path to another."""
3124
os.rename(from_, to)
3126
if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
3127
raise errors.FileExists(to, str(e))
3128
# normal OSError doesn't include filenames so it's hard to see where
3129
# the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
3130
raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
3131
self.past_renames.append((from_, to))
3133
def pre_delete(self, from_, to):
3134
"""Rename a file out of the way and mark it for deletion.
3136
Unlike os.unlink, this works equally well for files and directories.
3137
:param from_: The current file path
3138
:param to: A temporary path for the file
3140
self.rename(from_, to)
3141
self.pending_deletions.append(to)
3144
"""Reverse all renames that have been performed"""
3145
for from_, to in reversed(self.past_renames):
3147
os.rename(to, from_)
3149
raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
3150
# after rollback, don't reuse _FileMover
3152
pending_deletions = None
3154
def apply_deletions(self):
3155
"""Apply all marked deletions"""
3156
for path in self.pending_deletions:
3158
# after apply_deletions, don't reuse _FileMover
3160
pending_deletions = None
added
removed
bzrlib/transform.py
