/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
19
17
import os
20
18
import errno
21
19
from stat import S_ISREG, S_IEXEC
22
20
import time
23
21
 
24
 
from . import (
25
 
    config as _mod_config,
26
 
    errors,
27
 
    lazy_import,
28
 
    registry,
29
 
    trace,
30
 
    tree,
31
 
    )
32
 
lazy_import.lazy_import(globals(), """
33
 
from breezy import (
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
from bzrlib import (
34
25
    annotate,
35
26
    bencode,
36
 
    controldir,
37
 
    commit,
38
 
    conflicts,
 
27
    bzrdir,
39
28
    delta,
40
 
    lock,
 
29
    errors,
 
30
    inventory,
41
31
    multiparent,
42
32
    osutils,
43
33
    revision as _mod_revision,
44
34
    ui,
45
 
    urlutils,
46
 
    )
47
 
from breezy.bzr import (
48
 
    inventory,
49
 
    inventorytree,
50
 
    )
51
 
from breezy.i18n import gettext
 
35
    )
52
36
""")
53
 
from .errors import (DuplicateKey, MalformedTransform,
54
 
                     ReusingTransform, CantMoveRoot,
55
 
                     ImmortalLimbo, NoFinalPath,
56
 
                     UnableCreateSymlink)
57
 
from .filters import filtered_output_bytes, ContentFilterContext
58
 
from .mutabletree import MutableTree
59
 
from .osutils import (
 
37
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
 
38
                           ReusingTransform, CantMoveRoot,
 
39
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
 
40
                           UnableCreateSymlink)
 
41
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
 
42
from bzrlib.inventory import InventoryEntry
 
43
from bzrlib.osutils import (
60
44
    delete_any,
61
45
    file_kind,
62
46
    has_symlinks,
 
47
    lexists,
63
48
    pathjoin,
64
49
    sha_file,
65
50
    splitpath,
66
 
    )
67
 
from .progress import ProgressPhase
68
 
from .sixish import (
69
 
    text_type,
70
 
    viewitems,
71
 
    viewvalues,
72
 
    )
73
 
from .tree import (
74
 
    find_previous_path,
75
 
    )
 
51
    supports_executable,
 
52
)
 
53
from bzrlib.progress import ProgressPhase
 
54
from bzrlib.symbol_versioning import (
 
55
        deprecated_function,
 
56
        deprecated_in,
 
57
        )
 
58
from bzrlib.trace import mutter, warning
 
59
from bzrlib import tree
 
60
import bzrlib.ui
 
61
import bzrlib.urlutils as urlutils
76
62
 
77
63
 
78
64
ROOT_PARENT = "root-parent"
79
65
 
 
66
 
80
67
def unique_add(map, key, value):
81
68
    if key in map:
82
69
        raise DuplicateKey(key=key)
83
70
    map[key] = value
84
71
 
85
72
 
86
 
 
87
73
class _TransformResults(object):
88
74
    def __init__(self, modified_paths, rename_count):
89
75
        object.__init__(self)
94
80
class TreeTransformBase(object):
95
81
    """The base class for TreeTransform and its kin."""
96
82
 
97
 
    def __init__(self, tree, pb=None, case_sensitive=True):
 
83
    def __init__(self, tree, pb=None,
 
84
                 case_sensitive=True):
98
85
        """Constructor.
99
86
 
100
87
        :param tree: The tree that will be transformed, but not necessarily
112
99
        self._new_parent = {}
113
100
        # mapping of trans_id with new contents -> new file_kind
114
101
        self._new_contents = {}
115
 
        # mapping of trans_id => (sha1 of content, stat_value)
116
 
        self._observed_sha1s = {}
117
102
        # Set of trans_ids whose contents will be removed
118
103
        self._removed_contents = set()
119
104
        # Mapping of trans_id -> new execute-bit value
133
118
        # Mapping trans_id -> path in old tree
134
119
        self._tree_id_paths = {}
135
120
        # The trans_id that will be used as the tree root
136
 
        if tree.is_versioned(''):
137
 
            self._new_root = self.trans_id_tree_path('')
 
121
        root_id = tree.get_root_id()
 
122
        if root_id is not None:
 
123
            self._new_root = self.trans_id_tree_file_id(root_id)
138
124
        else:
139
125
            self._new_root = None
140
 
        # Indicator of whether the transform has been applied
 
126
        # Indictor of whether the transform has been applied
141
127
        self._done = False
142
128
        # A progress bar
143
129
        self._pb = pb
146
132
        # A counter of how many files have been renamed
147
133
        self.rename_count = 0
148
134
 
149
 
    def __enter__(self):
150
 
        """Support Context Manager API."""
151
 
        return self
152
 
 
153
 
    def __exit__(self, exc_type, exc_val, exc_tb):
154
 
        """Support Context Manager API."""
155
 
        self.finalize()
156
 
 
157
135
    def finalize(self):
158
136
        """Release the working tree lock, if held.
159
137
 
162
140
        """
163
141
        if self._tree is None:
164
142
            return
165
 
        for hook in MutableTree.hooks['post_transform']:
166
 
            hook(self._tree, self)
167
143
        self._tree.unlock()
168
144
        self._tree = None
169
145
 
218
194
        # the physical root needs a new transaction id
219
195
        self._tree_path_ids.pop("")
220
196
        self._tree_id_paths.pop(old_root)
221
 
        self._new_root = self.trans_id_tree_path('')
 
197
        self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
222
198
        if parent == old_root:
223
199
            parent = self._new_root
224
200
        self.adjust_path(name, parent, old_root)
236
212
        This means that the old root trans-id becomes obsolete, so it is
237
213
        recommended only to invoke this after the root trans-id has become
238
214
        irrelevant.
239
 
 
240
215
        """
241
 
        new_roots = [k for k, v in viewitems(self._new_parent)
242
 
                     if v == ROOT_PARENT]
 
216
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
 
217
                     ROOT_PARENT]
243
218
        if len(new_roots) < 1:
244
219
            return
245
220
        if len(new_roots) != 1:
248
223
            self._new_root = new_roots[0]
249
224
            return
250
225
        old_new_root = new_roots[0]
 
226
        # TODO: What to do if a old_new_root is present, but self._new_root is
 
227
        #       not listed as being removed? This code explicitly unversions
 
228
        #       the old root and versions it with the new file_id. Though that
 
229
        #       seems like an incomplete delta
 
230
 
251
231
        # unversion the new root's directory.
252
 
        if self.final_kind(self._new_root) is None:
253
 
            file_id = self.final_file_id(old_new_root)
254
 
        else:
255
 
            file_id = self.final_file_id(self._new_root)
 
232
        file_id = self.final_file_id(old_new_root)
256
233
        if old_new_root in self._new_id:
257
234
            self.cancel_versioning(old_new_root)
258
235
        else:
262
239
        if (self.tree_file_id(self._new_root) is not None and
263
240
            self._new_root not in self._removed_id):
264
241
            self.unversion_file(self._new_root)
265
 
        if file_id is not None:
266
 
            self.version_file(file_id, self._new_root)
 
242
        self.version_file(file_id, self._new_root)
267
243
 
268
244
        # Now move children of new root into old root directory.
269
245
        # Ensure all children are registered with the transaction, but don't
287
263
        del self._new_parent[old_new_root]
288
264
        del self._new_name[old_new_root]
289
265
 
 
266
    def trans_id_tree_file_id(self, inventory_id):
 
267
        """Determine the transaction id of a working tree file.
 
268
 
 
269
        This reflects only files that already exist, not ones that will be
 
270
        added by transactions.
 
271
        """
 
272
        if inventory_id is None:
 
273
            raise ValueError('None is not a valid file id')
 
274
        path = self._tree.id2path(inventory_id)
 
275
        return self.trans_id_tree_path(path)
 
276
 
290
277
    def trans_id_file_id(self, file_id):
291
278
        """Determine or set the transaction id associated with a file ID.
292
279
        A new id is only created for file_ids that were never present.  If
299
286
            return self._r_new_id[file_id]
300
287
        else:
301
288
            try:
302
 
                path = self._tree.id2path(file_id)
303
 
            except errors.NoSuchId:
 
289
                self._tree.iter_entries_by_dir([file_id]).next()
 
290
            except StopIteration:
304
291
                if file_id in self._non_present_ids:
305
292
                    return self._non_present_ids[file_id]
306
293
                else:
308
295
                    self._non_present_ids[file_id] = trans_id
309
296
                    return trans_id
310
297
            else:
311
 
                return self.trans_id_tree_path(path)
 
298
                return self.trans_id_tree_file_id(file_id)
312
299
 
313
300
    def trans_id_tree_path(self, path):
314
301
        """Determine (and maybe set) the transaction ID for a tree path."""
327
314
 
328
315
    def delete_contents(self, trans_id):
329
316
        """Schedule the contents of a path entry for deletion"""
330
 
        kind = self.tree_kind(trans_id)
331
 
        if kind is not None:
332
 
            self._removed_contents.add(trans_id)
 
317
        # Ensure that the object exists in the WorkingTree, this will raise an
 
318
        # exception if there is a problem
 
319
        self.tree_kind(trans_id)
 
320
        self._removed_contents.add(trans_id)
333
321
 
334
322
    def cancel_deletion(self, trans_id):
335
323
        """Cancel a scheduled deletion"""
392
380
        return sorted(FinalPaths(self).get_paths(new_ids))
393
381
 
394
382
    def _inventory_altered(self):
395
 
        """Determine which trans_ids need new Inventory entries.
396
 
 
397
 
        An new entry is needed when anything that would be reflected by an
398
 
        inventory entry changes, including file name, file_id, parent file_id,
399
 
        file kind, and the execute bit.
400
 
 
401
 
        Some care is taken to return entries with real changes, not cases
402
 
        where the value is deleted and then restored to its original value,
403
 
        but some actually unchanged values may be returned.
404
 
 
405
 
        :returns: A list of (path, trans_id) for all items requiring an
406
 
            inventory change. Ordered by path.
407
 
        """
408
 
        changed_ids = set()
409
 
        # Find entries whose file_ids are new (or changed).
410
 
        new_file_id = set(t for t in self._new_id
411
 
                          if self._new_id[t] != self.tree_file_id(t))
412
 
        for id_set in [self._new_name, self._new_parent, new_file_id,
 
383
        """Get the trans_ids and paths of files needing new inv entries."""
 
384
        new_ids = set()
 
385
        for id_set in [self._new_name, self._new_parent, self._new_id,
413
386
                       self._new_executability]:
414
 
            changed_ids.update(id_set)
415
 
        # removing implies a kind change
 
387
            new_ids.update(id_set)
416
388
        changed_kind = set(self._removed_contents)
417
 
        # so does adding
418
389
        changed_kind.intersection_update(self._new_contents)
419
 
        # Ignore entries that are already known to have changed.
420
 
        changed_kind.difference_update(changed_ids)
421
 
        #  to keep only the truly changed ones
422
 
        changed_kind = (t for t in changed_kind
423
 
                        if self.tree_kind(t) != self.final_kind(t))
424
 
        # all kind changes will alter the inventory
425
 
        changed_ids.update(changed_kind)
426
 
        # To find entries with changed parent_ids, find parents which existed,
427
 
        # but changed file_id.
428
 
        changed_file_id = set(t for t in new_file_id if t in self._removed_id)
429
 
        # Now add all their children to the set.
430
 
        for parent_trans_id in new_file_id:
431
 
            changed_ids.update(self.iter_tree_children(parent_trans_id))
432
 
        return sorted(FinalPaths(self).get_paths(changed_ids))
 
390
        changed_kind.difference_update(new_ids)
 
391
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
 
392
                        self.final_kind(t))
 
393
        new_ids.update(changed_kind)
 
394
        return sorted(FinalPaths(self).get_paths(new_ids))
433
395
 
434
396
    def final_kind(self, trans_id):
435
397
        """Determine the final file kind, after any changes applied.
436
398
 
437
 
        :return: None if the file does not exist/has no contents.  (It is
438
 
            conceivable that a path would be created without the corresponding
439
 
            contents insertion command)
 
399
        Raises NoSuchFile if the file does not exist/has no contents.
 
400
        (It is conceivable that a path would be created without the
 
401
        corresponding contents insertion command)
440
402
        """
441
403
        if trans_id in self._new_contents:
442
404
            return self._new_contents[trans_id]
443
405
        elif trans_id in self._removed_contents:
444
 
            return None
 
406
            raise NoSuchFile(None)
445
407
        else:
446
408
            return self.tree_kind(trans_id)
447
409
 
448
 
    def tree_path(self, trans_id):
449
 
        """Determine the tree path associated with the trans_id."""
450
 
        return self._tree_id_paths.get(trans_id)
451
 
 
452
410
    def tree_file_id(self, trans_id):
453
411
        """Determine the file id associated with the trans_id in the tree"""
454
 
        path = self.tree_path(trans_id)
455
 
        if path is None:
 
412
        try:
 
413
            path = self._tree_id_paths[trans_id]
 
414
        except KeyError:
 
415
            # the file is a new, unversioned file, or invalid trans_id
456
416
            return None
457
417
        # the file is old; the old id is still valid
458
418
        if self._new_root == trans_id:
480
440
        file_id = self.tree_file_id(trans_id)
481
441
        if file_id is not None:
482
442
            return file_id
483
 
        for key, value in viewitems(self._non_present_ids):
 
443
        for key, value in self._non_present_ids.iteritems():
484
444
            if value == trans_id:
485
445
                return key
486
446
 
510
470
        Only new paths and parents of tree files with assigned ids are used.
511
471
        """
512
472
        by_parent = {}
513
 
        items = list(viewitems(self._new_parent))
514
 
        items.extend((t, self.final_parent(t))
515
 
            for t in list(self._tree_id_paths))
 
473
        items = list(self._new_parent.iteritems())
 
474
        items.extend((t, self.final_parent(t)) for t in
 
475
                      self._tree_id_paths.keys())
516
476
        for trans_id, parent_id in items:
517
477
            if parent_id not in by_parent:
518
478
                by_parent[parent_id] = set()
556
516
        Active parents are those which gain children, and those which are
557
517
        removed.  This is a necessary first step in detecting conflicts.
558
518
        """
559
 
        parents = list(self.by_parent())
 
519
        parents = self.by_parent().keys()
560
520
        parents.extend([t for t in self._removed_contents if
561
521
                        self.tree_kind(t) == 'directory'])
562
522
        for trans_id in self._removed_id:
563
 
            path = self.tree_path(trans_id)
564
 
            if path is not None:
565
 
                if self._tree.stored_kind(path) == 'directory':
 
523
            file_id = self.tree_file_id(trans_id)
 
524
            if file_id is not None:
 
525
                if self._tree.inventory[file_id].kind == 'directory':
566
526
                    parents.append(trans_id)
567
527
            elif self.tree_kind(trans_id) == 'directory':
568
528
                parents.append(trans_id)
571
531
            # ensure that all children are registered with the transaction
572
532
            list(self.iter_tree_children(parent_id))
573
533
 
574
 
    def _has_named_child(self, name, parent_id, known_children):
575
 
        """Does a parent already have a name child.
576
 
 
577
 
        :param name: The searched for name.
578
 
 
579
 
        :param parent_id: The parent for which the check is made.
580
 
 
581
 
        :param known_children: The already known children. This should have
582
 
            been recently obtained from `self.by_parent.get(parent_id)`
583
 
            (or will be if None is passed).
584
 
        """
585
 
        if known_children is None:
586
 
            known_children = self.by_parent().get(parent_id, [])
587
 
        for child in known_children:
 
534
    def has_named_child(self, by_parent, parent_id, name):
 
535
        try:
 
536
            children = by_parent[parent_id]
 
537
        except KeyError:
 
538
            children = []
 
539
        for child in children:
588
540
            if self.final_name(child) == name:
589
541
                return True
590
 
        parent_path = self._tree_id_paths.get(parent_id, None)
591
 
        if parent_path is None:
592
 
            # No parent... no children
 
542
        try:
 
543
            path = self._tree_id_paths[parent_id]
 
544
        except KeyError:
593
545
            return False
594
 
        child_path = joinpath(parent_path, name)
595
 
        child_id = self._tree_path_ids.get(child_path, None)
 
546
        childpath = joinpath(path, name)
 
547
        child_id = self._tree_path_ids.get(childpath)
596
548
        if child_id is None:
597
 
            # Not known by the tree transform yet, check the filesystem
598
 
            return osutils.lexists(self._tree.abspath(child_path))
 
549
            return lexists(self._tree.abspath(childpath))
599
550
        else:
600
 
            raise AssertionError('child_id is missing: %s, %s, %s'
601
 
                                 % (name, parent_id, child_id))
602
 
 
603
 
    def _available_backup_name(self, name, target_id):
604
 
        """Find an available backup name.
605
 
 
606
 
        :param name: The basename of the file.
607
 
 
608
 
        :param target_id: The directory trans_id where the backup should 
609
 
            be placed.
610
 
        """
611
 
        known_children = self.by_parent().get(target_id, [])
612
 
        return osutils.available_backup_name(
613
 
            name,
614
 
            lambda base: self._has_named_child(
615
 
                base, target_id, known_children))
 
551
            if self.final_parent(child_id) != parent_id:
 
552
                return False
 
553
            if child_id in self._removed_contents:
 
554
                # XXX What about dangling file-ids?
 
555
                return False
 
556
            else:
 
557
                return True
616
558
 
617
559
    def _parent_loops(self):
618
560
        """No entry should be its own ancestor"""
620
562
        for trans_id in self._new_parent:
621
563
            seen = set()
622
564
            parent_id = trans_id
623
 
            while parent_id != ROOT_PARENT:
 
565
            while parent_id is not ROOT_PARENT:
624
566
                seen.add(parent_id)
625
567
                try:
626
568
                    parent_id = self.final_parent(parent_id)
635
577
    def _unversioned_parents(self, by_parent):
636
578
        """If parent directories are versioned, children must be versioned."""
637
579
        conflicts = []
638
 
        for parent_id, children in viewitems(by_parent):
639
 
            if parent_id == ROOT_PARENT:
 
580
        for parent_id, children in by_parent.iteritems():
 
581
            if parent_id is ROOT_PARENT:
640
582
                continue
641
583
            if self.final_file_id(parent_id) is not None:
642
584
                continue
652
594
        However, existing entries with no contents are okay.
653
595
        """
654
596
        conflicts = []
655
 
        for trans_id in self._new_id:
656
 
            kind = self.final_kind(trans_id)
657
 
            if kind is None:
 
597
        for trans_id in self._new_id.iterkeys():
 
598
            try:
 
599
                kind = self.final_kind(trans_id)
 
600
            except NoSuchFile:
658
601
                conflicts.append(('versioning no contents', trans_id))
659
602
                continue
660
 
            if not self._tree.versionable_kind(kind):
 
603
            if not InventoryEntry.versionable_kind(kind):
661
604
                conflicts.append(('versioning bad kind', trans_id, kind))
662
605
        return conflicts
663
606
 
674
617
            if self.final_file_id(trans_id) is None:
675
618
                conflicts.append(('unversioned executability', trans_id))
676
619
            else:
677
 
                if self.final_kind(trans_id) != "file":
 
620
                try:
 
621
                    non_file = self.final_kind(trans_id) != "file"
 
622
                except NoSuchFile:
 
623
                    non_file = True
 
624
                if non_file is True:
678
625
                    conflicts.append(('non-file executability', trans_id))
679
626
        return conflicts
680
627
 
682
629
        """Check for overwrites (not permitted on Win32)"""
683
630
        conflicts = []
684
631
        for trans_id in self._new_contents:
685
 
            if self.tree_kind(trans_id) is None:
 
632
            try:
 
633
                self.tree_kind(trans_id)
 
634
            except NoSuchFile:
686
635
                continue
687
636
            if trans_id not in self._removed_contents:
688
637
                conflicts.append(('overwrite', trans_id,
694
643
        conflicts = []
695
644
        if (self._new_name, self._new_parent) == ({}, {}):
696
645
            return conflicts
697
 
        for children in viewvalues(by_parent):
698
 
            name_ids = []
699
 
            for child_tid in children:
700
 
                name = self.final_name(child_tid)
701
 
                if name is not None:
702
 
                    # Keep children only if they still exist in the end
703
 
                    if not self._case_sensitive_target:
704
 
                        name = name.lower()
705
 
                    name_ids.append((name, child_tid))
 
646
        for children in by_parent.itervalues():
 
647
            name_ids = [(self.final_name(t), t) for t in children]
 
648
            if not self._case_sensitive_target:
 
649
                name_ids = [(n.lower(), t) for n, t in name_ids]
706
650
            name_ids.sort()
707
651
            last_name = None
708
652
            last_trans_id = None
709
653
            for name, trans_id in name_ids:
710
 
                kind = self.final_kind(trans_id)
 
654
                try:
 
655
                    kind = self.final_kind(trans_id)
 
656
                except NoSuchFile:
 
657
                    kind = None
711
658
                file_id = self.final_file_id(trans_id)
712
659
                if kind is None and file_id is None:
713
660
                    continue
725
672
                                self._removed_id))
726
673
        all_ids = self._tree.all_file_ids()
727
674
        active_tree_ids = all_ids.difference(removed_tree_ids)
728
 
        for trans_id, file_id in viewitems(self._new_id):
 
675
        for trans_id, file_id in self._new_id.iteritems():
729
676
            if file_id in active_tree_ids:
730
 
                path = self._tree.id2path(file_id)
731
 
                old_trans_id = self.trans_id_tree_path(path)
 
677
                old_trans_id = self.trans_id_tree_file_id(file_id)
732
678
                conflicts.append(('duplicate id', old_trans_id, trans_id))
733
679
        return conflicts
734
680
 
735
681
    def _parent_type_conflicts(self, by_parent):
736
 
        """Children must have a directory parent"""
 
682
        """parents must have directory 'contents'."""
737
683
        conflicts = []
738
 
        for parent_id, children in viewitems(by_parent):
739
 
            if parent_id == ROOT_PARENT:
740
 
                continue
741
 
            no_children = True
742
 
            for child_id in children:
743
 
                if self.final_kind(child_id) is not None:
744
 
                    no_children = False
745
 
                    break
746
 
            if no_children:
747
 
                continue
748
 
            # There is at least a child, so we need an existing directory to
749
 
            # contain it.
750
 
            kind = self.final_kind(parent_id)
 
684
        for parent_id, children in by_parent.iteritems():
 
685
            if parent_id is ROOT_PARENT:
 
686
                continue
 
687
            if not self._any_contents(children):
 
688
                continue
 
689
            for child in children:
 
690
                try:
 
691
                    self.final_kind(child)
 
692
                except NoSuchFile:
 
693
                    continue
 
694
            try:
 
695
                kind = self.final_kind(parent_id)
 
696
            except NoSuchFile:
 
697
                kind = None
751
698
            if kind is None:
752
 
                # The directory will be deleted
753
699
                conflicts.append(('missing parent', parent_id))
754
700
            elif kind != "directory":
755
 
                # Meh, we need a *directory* to put something in it
756
701
                conflicts.append(('non-directory parent', parent_id))
757
702
        return conflicts
758
703
 
 
704
    def _any_contents(self, trans_ids):
 
705
        """Return true if any of the trans_ids, will have contents."""
 
706
        for trans_id in trans_ids:
 
707
            try:
 
708
                kind = self.final_kind(trans_id)
 
709
            except NoSuchFile:
 
710
                continue
 
711
            return True
 
712
        return False
 
713
 
759
714
    def _set_executability(self, path, trans_id):
760
715
        """Set the executability of versioned files """
761
 
        if self._tree._supports_executable():
 
716
        if supports_executable():
762
717
            new_executability = self._new_executability[trans_id]
763
718
            abspath = self._tree.abspath(path)
764
719
            current_mode = os.stat(abspath).st_mode
765
720
            if new_executability:
766
721
                umask = os.umask(0)
767
722
                os.umask(umask)
768
 
                to_mode = current_mode | (0o100 & ~umask)
 
723
                to_mode = current_mode | (0100 & ~umask)
769
724
                # Enable x-bit for others only if they can read it.
770
 
                if current_mode & 0o004:
771
 
                    to_mode |= 0o001 & ~umask
772
 
                if current_mode & 0o040:
773
 
                    to_mode |= 0o010 & ~umask
 
725
                if current_mode & 0004:
 
726
                    to_mode |= 0001 & ~umask
 
727
                if current_mode & 0040:
 
728
                    to_mode |= 0010 & ~umask
774
729
            else:
775
 
                to_mode = current_mode & ~0o111
776
 
            osutils.chmod_if_possible(abspath, to_mode)
 
730
                to_mode = current_mode & ~0111
 
731
            os.chmod(abspath, to_mode)
777
732
 
778
733
    def _new_entry(self, name, parent_id, file_id):
779
734
        """Helper function to create a new filesystem entry."""
783
738
        return trans_id
784
739
 
785
740
    def new_file(self, name, parent_id, contents, file_id=None,
786
 
                 executable=None, sha1=None):
 
741
                 executable=None):
787
742
        """Convenience method to create files.
788
743
 
789
744
        name is the name of the file to create.
796
751
        trans_id = self._new_entry(name, parent_id, file_id)
797
752
        # TODO: rather than scheduling a set_executable call,
798
753
        # have create_file create the file with the right mode.
799
 
        self.create_file(contents, trans_id, sha1=sha1)
 
754
        self.create_file(contents, trans_id)
800
755
        if executable is not None:
801
756
            self.set_executability(executable, trans_id)
802
757
        return trans_id
825
780
        self.create_symlink(target, trans_id)
826
781
        return trans_id
827
782
 
828
 
    def new_orphan(self, trans_id, parent_id):
829
 
        """Schedule an item to be orphaned.
830
 
 
831
 
        When a directory is about to be removed, its children, if they are not
832
 
        versioned are moved out of the way: they don't have a parent anymore.
833
 
 
834
 
        :param trans_id: The trans_id of the existing item.
835
 
        :param parent_id: The parent trans_id of the item.
836
 
        """
837
 
        raise NotImplementedError(self.new_orphan)
838
 
 
839
 
    def _get_potential_orphans(self, dir_id):
840
 
        """Find the potential orphans in a directory.
841
 
 
842
 
        A directory can't be safely deleted if there are versioned files in it.
843
 
        If all the contained files are unversioned then they can be orphaned.
844
 
 
845
 
        The 'None' return value means that the directory contains at least one
846
 
        versioned file and should not be deleted.
847
 
 
848
 
        :param dir_id: The directory trans id.
849
 
 
850
 
        :return: A list of the orphan trans ids or None if at least one
851
 
             versioned file is present.
852
 
        """
853
 
        orphans = []
854
 
        # Find the potential orphans, stop if one item should be kept
855
 
        for child_tid in self.by_parent()[dir_id]:
856
 
            if child_tid in self._removed_contents:
857
 
                # The child is removed as part of the transform. Since it was
858
 
                # versioned before, it's not an orphan
859
 
                continue
860
 
            elif self.final_file_id(child_tid) is None:
861
 
                # The child is not versioned
862
 
                orphans.append(child_tid)
863
 
            else:
864
 
                # We have a versioned file here, searching for orphans is
865
 
                # meaningless.
866
 
                orphans = None
867
 
                break
868
 
        return orphans
869
 
 
870
783
    def _affected_ids(self):
871
784
        """Return the set of transform ids affected by the transform"""
872
785
        trans_ids = set(self._removed_id)
873
 
        trans_ids.update(self._new_id)
 
786
        trans_ids.update(self._new_id.keys())
874
787
        trans_ids.update(self._removed_contents)
875
 
        trans_ids.update(self._new_contents)
876
 
        trans_ids.update(self._new_executability)
877
 
        trans_ids.update(self._new_name)
878
 
        trans_ids.update(self._new_parent)
 
788
        trans_ids.update(self._new_contents.keys())
 
789
        trans_ids.update(self._new_executability.keys())
 
790
        trans_ids.update(self._new_name.keys())
 
791
        trans_ids.update(self._new_parent.keys())
879
792
        return trans_ids
880
793
 
881
794
    def _get_file_id_maps(self):
894
807
                to_trans_ids[to_file_id] = trans_id
895
808
        return from_trans_ids, to_trans_ids
896
809
 
897
 
    def _from_file_data(self, from_trans_id, from_versioned, from_path):
 
810
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
898
811
        """Get data about a file in the from (tree) state
899
812
 
900
813
        Return a (name, parent, kind, executable) tuple
902
815
        from_path = self._tree_id_paths.get(from_trans_id)
903
816
        if from_versioned:
904
817
            # get data from working tree if versioned
905
 
            from_entry = next(self._tree.iter_entries_by_dir(
906
 
                    specific_files=[from_path]))[1]
 
818
            from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
907
819
            from_name = from_entry.name
908
820
            from_parent = from_entry.parent_id
909
821
        else:
932
844
        Return a (name, parent, kind, executable) tuple
933
845
        """
934
846
        to_name = self.final_name(to_trans_id)
935
 
        to_kind = self.final_kind(to_trans_id)
 
847
        try:
 
848
            to_kind = self.final_kind(to_trans_id)
 
849
        except NoSuchFile:
 
850
            to_kind = None
936
851
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
937
852
        if to_trans_id in self._new_executability:
938
853
            to_executable = self._new_executability[to_trans_id]
956
871
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
957
872
        results = []
958
873
        # Now iterate through all active file_ids
959
 
        for file_id in set(from_trans_ids).union(to_trans_ids):
 
874
        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
960
875
            modified = False
961
876
            from_trans_id = from_trans_ids.get(file_id)
962
877
            # find file ids, and determine versioning state
972
887
            else:
973
888
                to_versioned = True
974
889
 
 
890
            from_name, from_parent, from_kind, from_executable = \
 
891
                self._from_file_data(from_trans_id, from_versioned, file_id)
 
892
 
 
893
            to_name, to_parent, to_kind, to_executable = \
 
894
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
895
 
975
896
            if not from_versioned:
976
897
                from_path = None
977
898
            else:
980
901
                to_path = None
981
902
            else:
982
903
                to_path = final_paths.get_path(to_trans_id)
983
 
 
984
 
            from_name, from_parent, from_kind, from_executable = \
985
 
                self._from_file_data(from_trans_id, from_versioned, from_path)
986
 
 
987
 
            to_name, to_parent, to_kind, to_executable = \
988
 
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
989
 
 
990
904
            if from_kind != to_kind:
991
905
                modified = True
992
906
            elif to_kind in ('file', 'symlink') and (
1013
927
        """
1014
928
        return _PreviewTree(self)
1015
929
 
1016
 
    def commit(self, branch, message, merge_parents=None, strict=False,
1017
 
               timestamp=None, timezone=None, committer=None, authors=None,
1018
 
               revprops=None, revision_id=None):
 
930
    def commit(self, branch, message, merge_parents=None, strict=False):
1019
931
        """Commit the result of this TreeTransform to a branch.
1020
932
 
1021
933
        :param branch: The branch to commit to.
1022
934
        :param message: The message to attach to the commit.
1023
 
        :param merge_parents: Additional parent revision-ids specified by
1024
 
            pending merges.
1025
 
        :param strict: If True, abort the commit if there are unversioned
1026
 
            files.
1027
 
        :param timestamp: if not None, seconds-since-epoch for the time and
1028
 
            date.  (May be a float.)
1029
 
        :param timezone: Optional timezone for timestamp, as an offset in
1030
 
            seconds.
1031
 
        :param committer: Optional committer in email-id format.
1032
 
            (e.g. "J Random Hacker <jrandom@example.com>")
1033
 
        :param authors: Optional list of authors in email-id format.
1034
 
        :param revprops: Optional dictionary of revision properties.
1035
 
        :param revision_id: Optional revision id.  (Specifying a revision-id
1036
 
            may reduce performance for some non-native formats.)
 
935
        :param merge_parents: Additional parents specified by pending merges.
1037
936
        :return: The revision_id of the revision committed.
1038
937
        """
1039
938
        self._check_malformed()
1056
955
        if self._tree.get_revision_id() != last_rev_id:
1057
956
            raise ValueError('TreeTransform not based on branch basis: %s' %
1058
957
                             self._tree.get_revision_id())
1059
 
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
1060
 
        builder = branch.get_commit_builder(parent_ids,
1061
 
                                            timestamp=timestamp,
1062
 
                                            timezone=timezone,
1063
 
                                            committer=committer,
1064
 
                                            revprops=revprops,
1065
 
                                            revision_id=revision_id)
 
958
        builder = branch.get_commit_builder(parent_ids)
1066
959
        preview = self.get_preview_tree()
1067
960
        list(builder.record_iter_changes(preview, last_rev_id,
1068
961
                                         self.iter_changes()))
1072
965
        return revision_id
1073
966
 
1074
967
    def _text_parent(self, trans_id):
1075
 
        path = self.tree_path(trans_id)
 
968
        file_id = self.tree_file_id(trans_id)
1076
969
        try:
1077
 
            if path is None or self._tree.kind(path) != 'file':
 
970
            if file_id is None or self._tree.kind(file_id) != 'file':
1078
971
                return None
1079
972
        except errors.NoSuchFile:
1080
973
            return None
1081
 
        return path
 
974
        return file_id
1082
975
 
1083
976
    def _get_parents_texts(self, trans_id):
1084
977
        """Get texts for compression parents of this file."""
1085
 
        path = self._text_parent(trans_id)
1086
 
        if path is None:
 
978
        file_id = self._text_parent(trans_id)
 
979
        if file_id is None:
1087
980
            return ()
1088
 
        return (self._tree.get_file_text(path),)
 
981
        return (self._tree.get_file_text(file_id),)
1089
982
 
1090
983
    def _get_parents_lines(self, trans_id):
1091
984
        """Get lines for compression parents of this file."""
1092
 
        path = self._text_parent(trans_id)
1093
 
        if path is None:
 
985
        file_id = self._text_parent(trans_id)
 
986
        if file_id is None:
1094
987
            return ()
1095
 
        return (self._tree.get_file_lines(path),)
 
988
        return (self._tree.get_file_lines(file_id),)
1096
989
 
1097
990
    def serialize(self, serializer):
1098
991
        """Serialize this TreeTransform.
1100
993
        :param serializer: A Serialiser like pack.ContainerSerializer.
1101
994
        """
1102
995
        new_name = dict((k, v.encode('utf-8')) for k, v in
1103
 
                        viewitems(self._new_name))
 
996
                        self._new_name.items())
1104
997
        new_executability = dict((k, int(v)) for k, v in
1105
 
                                 viewitems(self._new_executability))
 
998
                                 self._new_executability.items())
1106
999
        tree_path_ids = dict((k.encode('utf-8'), v)
1107
 
                             for k, v in viewitems(self._tree_path_ids))
 
1000
                             for k, v in self._tree_path_ids.items())
1108
1001
        attribs = {
1109
 
            b'_id_number': self._id_number,
1110
 
            b'_new_name': new_name,
1111
 
            b'_new_parent': self._new_parent,
1112
 
            b'_new_executability': new_executability,
1113
 
            b'_new_id': self._new_id,
1114
 
            b'_tree_path_ids': tree_path_ids,
1115
 
            b'_removed_id': list(self._removed_id),
1116
 
            b'_removed_contents': list(self._removed_contents),
1117
 
            b'_non_present_ids': self._non_present_ids,
 
1002
            '_id_number': self._id_number,
 
1003
            '_new_name': new_name,
 
1004
            '_new_parent': self._new_parent,
 
1005
            '_new_executability': new_executability,
 
1006
            '_new_id': self._new_id,
 
1007
            '_tree_path_ids': tree_path_ids,
 
1008
            '_removed_id': list(self._removed_id),
 
1009
            '_removed_contents': list(self._removed_contents),
 
1010
            '_non_present_ids': self._non_present_ids,
1118
1011
            }
1119
1012
        yield serializer.bytes_record(bencode.bencode(attribs),
1120
 
                                      ((b'attribs',),))
1121
 
        for trans_id, kind in viewitems(self._new_contents):
 
1013
                                      (('attribs',),))
 
1014
        for trans_id, kind in self._new_contents.items():
1122
1015
            if kind == 'file':
1123
 
                with open(self._limbo_name(trans_id), 'rb') as cur_file:
1124
 
                    lines = cur_file.readlines()
 
1016
                lines = osutils.chunks_to_lines(
 
1017
                    self._read_file_chunks(trans_id))
1125
1018
                parents = self._get_parents_lines(trans_id)
1126
1019
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
1127
 
                content = b''.join(mpdiff.to_patch())
 
1020
                content = ''.join(mpdiff.to_patch())
1128
1021
            if kind == 'directory':
1129
 
                content = b''
 
1022
                content = ''
1130
1023
            if kind == 'symlink':
1131
1024
                content = self._read_symlink_target(trans_id)
1132
1025
            yield serializer.bytes_record(content, ((trans_id, kind),))
1137
1030
        :param records: An iterable of (names, content) tuples, as per
1138
1031
            pack.ContainerPushParser.
1139
1032
        """
1140
 
        names, content = next(records)
 
1033
        names, content = records.next()
1141
1034
        attribs = bencode.bdecode(content)
1142
 
        self._id_number = attribs[b'_id_number']
 
1035
        self._id_number = attribs['_id_number']
1143
1036
        self._new_name = dict((k, v.decode('utf-8'))
1144
 
                              for k, v in viewitems(attribs[b'_new_name']))
1145
 
        self._new_parent = attribs[b'_new_parent']
1146
 
        self._new_executability = dict((k, bool(v))
1147
 
            for k, v in viewitems(attribs[b'_new_executability']))
1148
 
        self._new_id = attribs[b'_new_id']
1149
 
        self._r_new_id = dict((v, k) for k, v in viewitems(self._new_id))
 
1037
                            for k, v in attribs['_new_name'].items())
 
1038
        self._new_parent = attribs['_new_parent']
 
1039
        self._new_executability = dict((k, bool(v)) for k, v in
 
1040
            attribs['_new_executability'].items())
 
1041
        self._new_id = attribs['_new_id']
 
1042
        self._r_new_id = dict((v, k) for k, v in self._new_id.items())
1150
1043
        self._tree_path_ids = {}
1151
1044
        self._tree_id_paths = {}
1152
 
        for bytepath, trans_id in viewitems(attribs[b'_tree_path_ids']):
 
1045
        for bytepath, trans_id in attribs['_tree_path_ids'].items():
1153
1046
            path = bytepath.decode('utf-8')
1154
1047
            self._tree_path_ids[path] = trans_id
1155
1048
            self._tree_id_paths[trans_id] = path
1156
 
        self._removed_id = set(attribs[b'_removed_id'])
1157
 
        self._removed_contents = set(attribs[b'_removed_contents'])
1158
 
        self._non_present_ids = attribs[b'_non_present_ids']
 
1049
        self._removed_id = set(attribs['_removed_id'])
 
1050
        self._removed_contents = set(attribs['_removed_contents'])
 
1051
        self._non_present_ids = attribs['_non_present_ids']
1159
1052
        for ((trans_id, kind),), content in records:
1160
1053
            if kind == 'file':
1161
1054
                mpdiff = multiparent.MultiParent.from_patch(content)
1186
1079
        self._deletiondir = None
1187
1080
        # A mapping of transform ids to their limbo filename
1188
1081
        self._limbo_files = {}
1189
 
        self._possibly_stale_limbo_files = set()
1190
1082
        # A mapping of transform ids to a set of the transform ids of children
1191
1083
        # that their limbo directory has
1192
1084
        self._limbo_children = {}
1205
1097
        if self._tree is None:
1206
1098
            return
1207
1099
        try:
1208
 
            limbo_paths = list(viewvalues(self._limbo_files))
1209
 
            limbo_paths.extend(self._possibly_stale_limbo_files)
1210
 
            limbo_paths.sort(reverse=True)
1211
 
            for path in limbo_paths:
1212
 
                try:
1213
 
                    delete_any(path)
1214
 
                except OSError as e:
1215
 
                    if e.errno != errno.ENOENT:
1216
 
                        raise
1217
 
                    # XXX: warn? perhaps we just got interrupted at an
1218
 
                    # inconvenient moment, but perhaps files are disappearing
1219
 
                    # from under us?
 
1100
            entries = [(self._limbo_name(t), t, k) for t, k in
 
1101
                       self._new_contents.iteritems()]
 
1102
            entries.sort(reverse=True)
 
1103
            for path, trans_id, kind in entries:
 
1104
                delete_any(path)
1220
1105
            try:
1221
1106
                delete_any(self._limbodir)
1222
1107
            except OSError:
1230
1115
        finally:
1231
1116
            TreeTransformBase.finalize(self)
1232
1117
 
1233
 
    def _limbo_supports_executable(self):
1234
 
        """Check if the limbo path supports the executable bit."""
1235
 
        # FIXME: Check actual file system capabilities of limbodir
1236
 
        return osutils.supports_executable()
1237
 
 
1238
1118
    def _limbo_name(self, trans_id):
1239
1119
        """Generate the limbo name of a file"""
1240
1120
        limbo_name = self._limbo_files.get(trans_id)
1276
1156
        entries from _limbo_files, because they are now stale.
1277
1157
        """
1278
1158
        for trans_id in trans_ids:
1279
 
            old_path = self._limbo_files[trans_id]
1280
 
            self._possibly_stale_limbo_files.add(old_path)
1281
 
            del self._limbo_files[trans_id]
 
1159
            old_path = self._limbo_files.pop(trans_id)
1282
1160
            if trans_id not in self._new_contents:
1283
1161
                continue
1284
1162
            new_path = self._limbo_name(trans_id)
1285
 
            os.rename(old_path, new_path)
1286
 
            self._possibly_stale_limbo_files.remove(old_path)
 
1163
            osutils.rename(old_path, new_path)
1287
1164
            for descendant in self._limbo_descendants(trans_id):
1288
1165
                desc_path = self._limbo_files[descendant]
1289
1166
                desc_path = new_path + desc_path[len(old_path):]
1296
1173
            descendants.update(self._limbo_descendants(descendant))
1297
1174
        return descendants
1298
1175
 
1299
 
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
 
1176
    def create_file(self, contents, trans_id, mode_id=None):
1300
1177
        """Schedule creation of a new file.
1301
1178
 
1302
 
        :seealso: new_file.
1303
 
 
1304
 
        :param contents: an iterator of strings, all of which will be written
1305
 
            to the target destination.
1306
 
        :param trans_id: TreeTransform handle
1307
 
        :param mode_id: If not None, force the mode of the target file to match
1308
 
            the mode of the object referenced by mode_id.
1309
 
            Otherwise, we will try to preserve mode bits of an existing file.
1310
 
        :param sha1: If the sha1 of this content is already known, pass it in.
1311
 
            We can use it to prevent future sha1 computations.
 
1179
        See also new_file.
 
1180
 
 
1181
        Contents is an iterator of strings, all of which will be written
 
1182
        to the target destination.
 
1183
 
 
1184
        New file takes the permissions of any existing file with that id,
 
1185
        unless mode_id is specified.
1312
1186
        """
1313
1187
        name = self._limbo_name(trans_id)
1314
 
        with open(name, 'wb') as f:
1315
 
            unique_add(self._new_contents, trans_id, 'file')
 
1188
        f = open(name, 'wb')
 
1189
        try:
 
1190
            try:
 
1191
                unique_add(self._new_contents, trans_id, 'file')
 
1192
            except:
 
1193
                # Clean up the file, it never got registered so
 
1194
                # TreeTransform.finalize() won't clean it up.
 
1195
                f.close()
 
1196
                os.unlink(name)
 
1197
                raise
 
1198
 
1316
1199
            f.writelines(contents)
 
1200
        finally:
 
1201
            f.close()
1317
1202
        self._set_mtime(name)
1318
1203
        self._set_mode(trans_id, mode_id, S_ISREG)
1319
 
        # It is unfortunate we have to use lstat instead of fstat, but we just
1320
 
        # used utime and chmod on the file, so we need the accurate final
1321
 
        # details.
1322
 
        if sha1 is not None:
1323
 
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
 
1204
 
 
1205
    def _read_file_chunks(self, trans_id):
 
1206
        cur_file = open(self._limbo_name(trans_id), 'rb')
 
1207
        try:
 
1208
            return cur_file.readlines()
 
1209
        finally:
 
1210
            cur_file.close()
1324
1211
 
1325
1212
    def _read_symlink_target(self, trans_id):
1326
1213
        return os.readlink(self._limbo_name(trans_id))
1339
1226
        name = self._limbo_name(trans_id)
1340
1227
        try:
1341
1228
            os.link(path, name)
1342
 
        except OSError as e:
 
1229
        except OSError, e:
1343
1230
            if e.errno != errno.EPERM:
1344
1231
                raise
1345
1232
            raise errors.HardLinkNotSupported(path)
1378
1265
    def cancel_creation(self, trans_id):
1379
1266
        """Cancel the creation of new file contents."""
1380
1267
        del self._new_contents[trans_id]
1381
 
        if trans_id in self._observed_sha1s:
1382
 
            del self._observed_sha1s[trans_id]
1383
1268
        children = self._limbo_children.get(trans_id)
1384
1269
        # if this is a limbo directory with children, move them before removing
1385
1270
        # the directory
1389
1274
            del self._limbo_children_names[trans_id]
1390
1275
        delete_any(self._limbo_name(trans_id))
1391
1276
 
1392
 
    def new_orphan(self, trans_id, parent_id):
1393
 
        conf = self._tree.get_config_stack()
1394
 
        handle_orphan = conf.get('transform.orphan_policy')
1395
 
        handle_orphan(self, trans_id, parent_id)
1396
 
 
1397
 
 
1398
 
class OrphaningError(errors.BzrError):
1399
 
 
1400
 
    # Only bugs could lead to such exception being seen by the user
1401
 
    internal_error = True
1402
 
    _fmt = "Error while orphaning %s in %s directory"
1403
 
 
1404
 
    def __init__(self, orphan, parent):
1405
 
        errors.BzrError.__init__(self)
1406
 
        self.orphan = orphan
1407
 
        self.parent = parent
1408
 
 
1409
 
 
1410
 
class OrphaningForbidden(OrphaningError):
1411
 
 
1412
 
    _fmt = "Policy: %s doesn't allow creating orphans."
1413
 
 
1414
 
    def __init__(self, policy):
1415
 
        errors.BzrError.__init__(self)
1416
 
        self.policy = policy
1417
 
 
1418
 
 
1419
 
def move_orphan(tt, orphan_id, parent_id):
1420
 
    """See TreeTransformBase.new_orphan.
1421
 
 
1422
 
    This creates a new orphan in the `brz-orphans` dir at the root of the
1423
 
    `TreeTransform`.
1424
 
 
1425
 
    :param tt: The TreeTransform orphaning `trans_id`.
1426
 
 
1427
 
    :param orphan_id: The trans id that should be orphaned.
1428
 
 
1429
 
    :param parent_id: The orphan parent trans id.
1430
 
    """
1431
 
    # Add the orphan dir if it doesn't exist
1432
 
    orphan_dir_basename = 'brz-orphans'
1433
 
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
1434
 
    if tt.final_kind(od_id) is None:
1435
 
        tt.create_directory(od_id)
1436
 
    parent_path = tt._tree_id_paths[parent_id]
1437
 
    # Find a name that doesn't exist yet in the orphan dir
1438
 
    actual_name = tt.final_name(orphan_id)
1439
 
    new_name = tt._available_backup_name(actual_name, od_id)
1440
 
    tt.adjust_path(new_name, od_id, orphan_id)
1441
 
    trace.warning('%s has been orphaned in %s'
1442
 
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
1443
 
 
1444
 
 
1445
 
def refuse_orphan(tt, orphan_id, parent_id):
1446
 
    """See TreeTransformBase.new_orphan.
1447
 
 
1448
 
    This refuses to create orphan, letting the caller handle the conflict.
1449
 
    """
1450
 
    raise OrphaningForbidden('never')
1451
 
 
1452
 
 
1453
 
orphaning_registry = registry.Registry()
1454
 
orphaning_registry.register(
1455
 
    u'conflict', refuse_orphan,
1456
 
    'Leave orphans in place and create a conflict on the directory.')
1457
 
orphaning_registry.register(
1458
 
    u'move', move_orphan,
1459
 
    'Move orphans into the brz-orphans directory.')
1460
 
orphaning_registry._set_default_key(u'conflict')
1461
 
 
1462
 
 
1463
 
opt_transform_orphan = _mod_config.RegistryOption(
1464
 
    'transform.orphan_policy', orphaning_registry,
1465
 
    help='Policy for orphaned files during transform operations.',
1466
 
    invalid='warning')
1467
 
 
1468
1277
 
1469
1278
class TreeTransform(DiskTreeTransform):
1470
1279
    """Represent a tree transformation.
1538
1347
        TreeTransform.apply() called).
1539
1348
        """
1540
1349
        tree.lock_tree_write()
 
1350
 
1541
1351
        try:
1542
1352
            limbodir = urlutils.local_path_from_url(
1543
1353
                tree._transport.abspath('limbo'))
1544
 
            osutils.ensure_empty_directory_exists(
1545
 
                limbodir,
1546
 
                errors.ExistingLimbo)
 
1354
            try:
 
1355
                os.mkdir(limbodir)
 
1356
            except OSError, e:
 
1357
                if e.errno == errno.EEXIST:
 
1358
                    raise ExistingLimbo(limbodir)
1547
1359
            deletiondir = urlutils.local_path_from_url(
1548
1360
                tree._transport.abspath('pending-deletion'))
1549
 
            osutils.ensure_empty_directory_exists(
1550
 
                deletiondir,
1551
 
                errors.ExistingPendingDeletion)
 
1361
            try:
 
1362
                os.mkdir(deletiondir)
 
1363
            except OSError, e:
 
1364
                if e.errno == errno.EEXIST:
 
1365
                    raise errors.ExistingPendingDeletion(deletiondir)
1552
1366
        except:
1553
1367
            tree.unlock()
1554
1368
            raise
1583
1397
    def tree_kind(self, trans_id):
1584
1398
        """Determine the file kind in the working tree.
1585
1399
 
1586
 
        :returns: The file kind or None if the file does not exist
 
1400
        Raises NoSuchFile if the file does not exist
1587
1401
        """
1588
1402
        path = self._tree_id_paths.get(trans_id)
1589
1403
        if path is None:
1590
 
            return None
 
1404
            raise NoSuchFile(None)
1591
1405
        try:
1592
1406
            return file_kind(self._tree.abspath(path))
1593
 
        except errors.NoSuchFile:
1594
 
            return None
 
1407
        except OSError, e:
 
1408
            if e.errno != errno.ENOENT:
 
1409
                raise
 
1410
            else:
 
1411
                raise NoSuchFile(path)
1595
1412
 
1596
1413
    def _set_mode(self, trans_id, mode_id, typefunc):
1597
1414
        """Set the mode of new file contents.
1607
1424
            return
1608
1425
        try:
1609
1426
            mode = os.stat(self._tree.abspath(old_path)).st_mode
1610
 
        except OSError as e:
 
1427
        except OSError, e:
1611
1428
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
1612
1429
                # Either old_path doesn't exist, or the parent of the
1613
1430
                # target is not a directory (but will be one eventually)
1617
1434
            else:
1618
1435
                raise
1619
1436
        if typefunc(mode):
1620
 
            osutils.chmod_if_possible(self._limbo_name(trans_id), mode)
 
1437
            os.chmod(self._limbo_name(trans_id), mode)
1621
1438
 
1622
1439
    def iter_tree_children(self, parent_id):
1623
1440
        """Iterate through the entry's tree children, if any"""
1627
1444
            return
1628
1445
        try:
1629
1446
            children = os.listdir(self._tree.abspath(path))
1630
 
        except OSError as e:
 
1447
        except OSError, e:
1631
1448
            if not (osutils._is_error_enotdir(e)
1632
1449
                    or e.errno in (errno.ENOENT, errno.ESRCH)):
1633
1450
                raise
1669
1486
                        in (trans_id, None)):
1670
1487
                        use_direct_path = True
1671
1488
                else:
1672
 
                    for l_filename, l_trans_id in viewitems(
1673
 
                            self._limbo_children_names[parent]):
 
1489
                    for l_filename, l_trans_id in\
 
1490
                        self._limbo_children_names[parent].iteritems():
1674
1491
                        if l_trans_id == trans_id:
1675
1492
                            continue
1676
1493
                        if l_filename.lower() == filename.lower():
1701
1518
            calculating one.
1702
1519
        :param _mover: Supply an alternate FileMover, for testing
1703
1520
        """
1704
 
        for hook in MutableTree.hooks['pre_transform']:
1705
 
            hook(self._tree, self)
1706
1521
        if not no_conflicts:
1707
1522
            self._check_malformed()
1708
 
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1523
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1524
        try:
1709
1525
            if precomputed_delta is None:
1710
 
                child_pb.update(gettext('Apply phase'), 0, 2)
 
1526
                child_pb.update('Apply phase', 0, 2)
1711
1527
                inventory_delta = self._generate_inventory_delta()
1712
1528
                offset = 1
1713
1529
            else:
1718
1534
            else:
1719
1535
                mover = _mover
1720
1536
            try:
1721
 
                child_pb.update(gettext('Apply phase'), 0 + offset, 2 + offset)
 
1537
                child_pb.update('Apply phase', 0 + offset, 2 + offset)
1722
1538
                self._apply_removals(mover)
1723
 
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
 
1539
                child_pb.update('Apply phase', 1 + offset, 2 + offset)
1724
1540
                modified_paths = self._apply_insertions(mover)
1725
1541
            except:
1726
1542
                mover.rollback()
1727
1543
                raise
1728
1544
            else:
1729
1545
                mover.apply_deletions()
1730
 
        if self.final_file_id(self.root) is None:
1731
 
            inventory_delta = [e for e in inventory_delta if e[0] != '']
 
1546
        finally:
 
1547
            child_pb.finished()
1732
1548
        self._tree.apply_inventory_delta(inventory_delta)
1733
 
        self._apply_observed_sha1s()
1734
1549
        self._done = True
1735
1550
        self.finalize()
1736
1551
        return _TransformResults(modified_paths, self.rename_count)
1738
1553
    def _generate_inventory_delta(self):
1739
1554
        """Generate an inventory delta for the current transform."""
1740
1555
        inventory_delta = []
 
1556
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1741
1557
        new_paths = self._inventory_altered()
1742
1558
        total_entries = len(new_paths) + len(self._removed_id)
1743
 
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1559
        try:
1744
1560
            for num, trans_id in enumerate(self._removed_id):
1745
1561
                if (num % 10) == 0:
1746
 
                    child_pb.update(gettext('removing file'), num, total_entries)
 
1562
                    child_pb.update('removing file', num, total_entries)
1747
1563
                if trans_id == self._new_root:
1748
1564
                    file_id = self._tree.get_root_id()
1749
1565
                else:
1755
1571
                inventory_delta.append((path, None, file_id, None))
1756
1572
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1757
1573
                                     new_paths)
 
1574
            entries = self._tree.iter_entries_by_dir(
 
1575
                new_path_file_ids.values())
 
1576
            old_paths = dict((e.file_id, p) for p, e in entries)
1758
1577
            final_kinds = {}
1759
1578
            for num, (path, trans_id) in enumerate(new_paths):
1760
1579
                if (num % 10) == 0:
1761
 
                    child_pb.update(gettext('adding file'),
 
1580
                    child_pb.update('adding file',
1762
1581
                                    num + len(self._removed_id), total_entries)
1763
1582
                file_id = new_path_file_ids[trans_id]
1764
1583
                if file_id is None:
1765
1584
                    continue
1766
1585
                needs_entry = False
1767
 
                kind = self.final_kind(trans_id)
1768
 
                if kind is None:
1769
 
                    kind = self._tree.stored_kind(
1770
 
                            self._tree.id2path(file_id), file_id)
 
1586
                try:
 
1587
                    kind = self.final_kind(trans_id)
 
1588
                except NoSuchFile:
 
1589
                    kind = self._tree.stored_kind(file_id)
1771
1590
                parent_trans_id = self.final_parent(trans_id)
1772
1591
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1773
1592
                if parent_file_id is None:
1782
1601
                    new_entry = inventory.make_entry(kind,
1783
1602
                        self.final_name(trans_id),
1784
1603
                        parent_file_id, file_id)
1785
 
                try:
1786
 
                    old_path = self._tree.id2path(new_entry.file_id)
1787
 
                except errors.NoSuchId:
1788
 
                    old_path = None
 
1604
                old_path = old_paths.get(new_entry.file_id)
1789
1605
                new_executability = self._new_executability.get(trans_id)
1790
1606
                if new_executability is not None:
1791
1607
                    new_entry.executable = new_executability
1792
1608
                inventory_delta.append(
1793
1609
                    (old_path, path, new_entry.file_id, new_entry))
 
1610
        finally:
 
1611
            child_pb.finished()
1794
1612
        return inventory_delta
1795
1613
 
1796
1614
    def _apply_removals(self, mover):
1802
1620
 
1803
1621
        If inventory_delta is None, no inventory delta generation is performed.
1804
1622
        """
1805
 
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
1806
 
        with ui.ui_factory.nested_progress_bar() as child_pb:
1807
 
            for num, (path, trans_id) in enumerate(tree_paths):
1808
 
                # do not attempt to move root into a subdirectory of itself.
1809
 
                if path == '':
1810
 
                    continue
1811
 
                child_pb.update(gettext('removing file'), num, len(tree_paths))
 
1623
        tree_paths = list(self._tree_path_ids.iteritems())
 
1624
        tree_paths.sort(reverse=True)
 
1625
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1626
        try:
 
1627
            for num, data in enumerate(tree_paths):
 
1628
                path, trans_id = data
 
1629
                child_pb.update('removing file', num, len(tree_paths))
1812
1630
                full_path = self._tree.abspath(path)
1813
1631
                if trans_id in self._removed_contents:
1814
1632
                    delete_path = os.path.join(self._deletiondir, trans_id)
1817
1635
                      or trans_id in self._new_parent):
1818
1636
                    try:
1819
1637
                        mover.rename(full_path, self._limbo_name(trans_id))
1820
 
                    except errors.TransformRenameFailed as e:
 
1638
                    except OSError, e:
1821
1639
                        if e.errno != errno.ENOENT:
1822
1640
                            raise
1823
1641
                    else:
1824
1642
                        self.rename_count += 1
 
1643
        finally:
 
1644
            child_pb.finished()
1825
1645
 
1826
1646
    def _apply_insertions(self, mover):
1827
1647
        """Perform tree operations that insert directory/inventory names.
1837
1657
        modified_paths = []
1838
1658
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1839
1659
                                 new_paths)
1840
 
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1660
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1661
        try:
1841
1662
            for num, (path, trans_id) in enumerate(new_paths):
1842
1663
                if (num % 10) == 0:
1843
 
                    child_pb.update(gettext('adding file'), num, len(new_paths))
 
1664
                    child_pb.update('adding file', num, len(new_paths))
1844
1665
                full_path = self._tree.abspath(path)
1845
1666
                if trans_id in self._needs_rename:
1846
1667
                    try:
1847
1668
                        mover.rename(self._limbo_name(trans_id), full_path)
1848
 
                    except errors.TransformRenameFailed as e:
 
1669
                    except OSError, e:
1849
1670
                        # We may be renaming a dangling inventory id
1850
1671
                        if e.errno != errno.ENOENT:
1851
1672
                            raise
1852
1673
                    else:
1853
1674
                        self.rename_count += 1
1854
 
                    # TODO: if trans_id in self._observed_sha1s, we should
1855
 
                    #       re-stat the final target, since ctime will be
1856
 
                    #       updated by the change.
1857
1675
                if (trans_id in self._new_contents or
1858
1676
                    self.path_changed(trans_id)):
1859
1677
                    if trans_id in self._new_contents:
1860
1678
                        modified_paths.append(full_path)
1861
1679
                if trans_id in self._new_executability:
1862
1680
                    self._set_executability(path, trans_id)
1863
 
                if trans_id in self._observed_sha1s:
1864
 
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
1865
 
                    st = osutils.lstat(full_path)
1866
 
                    self._observed_sha1s[trans_id] = (o_sha1, st)
1867
 
        for path, trans_id in new_paths:
1868
 
            # new_paths includes stuff like workingtree conflicts. Only the
1869
 
            # stuff in new_contents actually comes from limbo.
1870
 
            if trans_id in self._limbo_files:
1871
 
                del self._limbo_files[trans_id]
 
1681
        finally:
 
1682
            child_pb.finished()
1872
1683
        self._new_contents.clear()
1873
1684
        return modified_paths
1874
1685
 
1875
 
    def _apply_observed_sha1s(self):
1876
 
        """After we have finished renaming everything, update observed sha1s
1877
 
 
1878
 
        This has to be done after self._tree.apply_inventory_delta, otherwise
1879
 
        it doesn't know anything about the files we are updating. Also, we want
1880
 
        to do this as late as possible, so that most entries end up cached.
1881
 
        """
1882
 
        # TODO: this doesn't update the stat information for directories. So
1883
 
        #       the first 'bzr status' will still need to rewrite
1884
 
        #       .bzr/checkout/dirstate. However, we at least don't need to
1885
 
        #       re-read all of the files.
1886
 
        # TODO: If the operation took a while, we could do a time.sleep(3) here
1887
 
        #       to allow the clock to tick over and ensure we won't have any
1888
 
        #       problems. (we could observe start time, and finish time, and if
1889
 
        #       it is less than eg 10% overhead, add a sleep call.)
1890
 
        paths = FinalPaths(self)
1891
 
        for trans_id, observed in viewitems(self._observed_sha1s):
1892
 
            path = paths.get_path(trans_id)
1893
 
            # We could get the file_id, but dirstate prefers to use the path
1894
 
            # anyway, and it is 'cheaper' to determine.
1895
 
            # file_id = self._new_id[trans_id]
1896
 
            self._tree._observed_sha1(None, path, observed)
1897
 
 
1898
1686
 
1899
1687
class TransformPreview(DiskTreeTransform):
1900
1688
    """A TreeTransform for generating preview trees.
1915
1703
    def tree_kind(self, trans_id):
1916
1704
        path = self._tree_id_paths.get(trans_id)
1917
1705
        if path is None:
1918
 
            return None
1919
 
        kind = self._tree.path_content_summary(path)[0]
1920
 
        if kind == 'missing':
1921
 
            kind = None
1922
 
        return kind
 
1706
            raise NoSuchFile(None)
 
1707
        file_id = self._tree.path2id(path)
 
1708
        return self._tree.kind(file_id)
1923
1709
 
1924
1710
    def _set_mode(self, trans_id, mode_id, typefunc):
1925
1711
        """Set the mode of new file contents.
1936
1722
            path = self._tree_id_paths[parent_id]
1937
1723
        except KeyError:
1938
1724
            return
1939
 
        entry = next(self._tree.iter_entries_by_dir(
1940
 
                specific_files=[path]))[1]
 
1725
        file_id = self.tree_file_id(parent_id)
 
1726
        if file_id is None:
 
1727
            return
 
1728
        entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1941
1729
        children = getattr(entry, 'children', {})
1942
1730
        for child in children:
1943
1731
            childpath = joinpath(path, child)
1944
1732
            yield self.trans_id_tree_path(childpath)
1945
1733
 
1946
 
    def new_orphan(self, trans_id, parent_id):
1947
 
        raise NotImplementedError(self.new_orphan)
1948
 
 
1949
 
 
1950
 
class _PreviewTree(inventorytree.InventoryTree):
 
1734
 
 
1735
class _PreviewTree(tree.Tree):
1951
1736
    """Partial implementation of Tree to support show_diff_trees"""
1952
1737
 
1953
1738
    def __init__(self, transform):
1981
1766
            except errors.NoSuchRevisionInTree:
1982
1767
                yield self._get_repository().revision_tree(revision_id)
1983
1768
 
1984
 
    def _get_file_revision(self, path, file_id, vf, tree_revision):
1985
 
        parent_keys = [
1986
 
                (file_id, t.get_file_revision(t.id2path(file_id), file_id))
1987
 
                for t in self._iter_parent_trees()]
 
1769
    def _get_file_revision(self, file_id, vf, tree_revision):
 
1770
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
1771
                       self._iter_parent_trees()]
1988
1772
        vf.add_lines((file_id, tree_revision), parent_keys,
1989
 
                     self.get_file_lines(path, file_id))
 
1773
                     self.get_file(file_id).readlines())
1990
1774
        repo = self._get_repository()
1991
1775
        base_vf = repo.texts
1992
1776
        if base_vf not in vf.fallback_versionedfiles:
1993
1777
            vf.fallback_versionedfiles.append(base_vf)
1994
1778
        return tree_revision
1995
1779
 
1996
 
    def _stat_limbo_file(self, trans_id):
 
1780
    def _stat_limbo_file(self, file_id):
 
1781
        trans_id = self._transform.trans_id_file_id(file_id)
1997
1782
        name = self._transform._limbo_name(trans_id)
1998
1783
        return os.lstat(name)
1999
1784
 
2010
1795
            executable = False
2011
1796
        else:
2012
1797
            file_id = self._transform.final_file_id(self._path2trans_id(path))
2013
 
            executable = self.is_executable(path, file_id)
 
1798
            executable = self.is_executable(file_id, path)
2014
1799
        return kind, executable, None
2015
1800
 
2016
 
    def is_locked(self):
2017
 
        return False
2018
 
 
2019
1801
    def lock_read(self):
2020
1802
        # Perhaps in theory, this should lock the TreeTransform?
2021
 
        return lock.LogicalLockResult(self.unlock)
 
1803
        pass
2022
1804
 
2023
1805
    def unlock(self):
2024
1806
        pass
2025
1807
 
2026
1808
    @property
2027
 
    def root_inventory(self):
 
1809
    def inventory(self):
2028
1810
        """This Tree does not use inventory as its backing data."""
2029
 
        raise NotImplementedError(_PreviewTree.root_inventory)
 
1811
        raise NotImplementedError(_PreviewTree.inventory)
2030
1812
 
2031
1813
    def get_root_id(self):
2032
1814
        return self._transform.final_file_id(self._transform.root)
2035
1817
        tree_ids = set(self._transform._tree.all_file_ids())
2036
1818
        tree_ids.difference_update(self._transform.tree_file_id(t)
2037
1819
                                   for t in self._transform._removed_id)
2038
 
        tree_ids.update(viewvalues(self._transform._new_id))
 
1820
        tree_ids.update(self._transform._new_id.values())
2039
1821
        return tree_ids
2040
1822
 
2041
 
    def all_versioned_paths(self):
2042
 
        return {self.id2path(fid) for fid in self.all_file_ids()}
 
1823
    def __iter__(self):
 
1824
        return iter(self.all_file_ids())
2043
1825
 
2044
1826
    def _has_id(self, file_id, fallback_check):
2045
1827
        if file_id in self._transform._r_new_id:
2046
1828
            return True
2047
 
        elif file_id in {self._transform.tree_file_id(trans_id) for
2048
 
            trans_id in self._transform._removed_id}:
 
1829
        elif file_id in set([self._transform.tree_file_id(trans_id) for
 
1830
            trans_id in self._transform._removed_id]):
2049
1831
            return False
2050
1832
        else:
2051
1833
            return fallback_check(file_id)
2079
1861
        return cur_parent
2080
1862
 
2081
1863
    def path2id(self, path):
2082
 
        if isinstance(path, list):
2083
 
            if path == []:
2084
 
                path = [""]
2085
 
            path = osutils.pathjoin(*path)
2086
1864
        return self._transform.final_file_id(self._path2trans_id(path))
2087
1865
 
2088
1866
    def id2path(self, file_id):
2098
1876
            return children
2099
1877
        children = set(self._transform.iter_tree_children(trans_id))
2100
1878
        # children in the _new_parent set are provided by _by_parent.
2101
 
        children.difference_update(self._transform._new_parent)
 
1879
        children.difference_update(self._transform._new_parent.keys())
2102
1880
        children.update(self._by_parent.get(trans_id, []))
2103
1881
        self._all_children_cache[trans_id] = children
2104
1882
        return children
2105
1883
 
2106
 
    def _iter_children(self, file_id):
 
1884
    def iter_children(self, file_id):
2107
1885
        trans_id = self._transform.trans_id_file_id(file_id)
2108
1886
        for child_trans_id in self._all_children(trans_id):
2109
1887
            yield self._transform.final_file_id(child_trans_id)
2117
1895
            if self._transform.final_file_id(trans_id) is None:
2118
1896
                yield self._final_paths._determine_path(trans_id)
2119
1897
 
2120
 
    def _make_inv_entries(self, ordered_entries, specific_files=None):
 
1898
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
 
1899
        yield_parents=False):
2121
1900
        for trans_id, parent_file_id in ordered_entries:
2122
1901
            file_id = self._transform.final_file_id(trans_id)
2123
1902
            if file_id is None:
2124
1903
                continue
2125
 
            if (specific_files is not None and
2126
 
                self._final_paths.get_path(trans_id) not in specific_files):
 
1904
            if (specific_file_ids is not None
 
1905
                and file_id not in specific_file_ids):
2127
1906
                continue
2128
 
            kind = self._transform.final_kind(trans_id)
2129
 
            if kind is None:
2130
 
                kind = self._transform._tree.stored_kind(
2131
 
                    self._transform._tree.id2path(file_id),
2132
 
                    file_id)
 
1907
            try:
 
1908
                kind = self._transform.final_kind(trans_id)
 
1909
            except NoSuchFile:
 
1910
                kind = self._transform._tree.stored_kind(file_id)
2133
1911
            new_entry = inventory.make_entry(
2134
1912
                kind,
2135
1913
                self._transform.final_name(trans_id),
2150
1928
                ordered_ids.append((trans_id, parent_file_id))
2151
1929
        return ordered_ids
2152
1930
 
2153
 
    def iter_child_entries(self, path, file_id=None):
2154
 
        trans_id = self._path2trans_id(path)
2155
 
        if trans_id is None:
2156
 
            raise errors.NoSuchFile(path)
2157
 
        todo = [(child_trans_id, trans_id) for child_trans_id in
2158
 
                self._all_children(trans_id)]
2159
 
        for entry, trans_id in self._make_inv_entries(todo):
2160
 
            yield entry
2161
 
 
2162
 
    def iter_entries_by_dir(self, specific_files=None):
 
1931
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
2163
1932
        # This may not be a maximally efficient implementation, but it is
2164
1933
        # reasonably straightforward.  An implementation that grafts the
2165
1934
        # TreeTransform changes onto the tree's iter_entries_by_dir results
2167
1936
        # position.
2168
1937
        ordered_ids = self._list_files_by_dir()
2169
1938
        for entry, trans_id in self._make_inv_entries(ordered_ids,
2170
 
            specific_files):
2171
 
            yield self._final_paths.get_path(trans_id), entry
 
1939
            specific_file_ids, yield_parents=yield_parents):
 
1940
            yield unicode(self._final_paths.get_path(trans_id)), entry
2172
1941
 
2173
1942
    def _iter_entries_for_dir(self, dir_path):
2174
1943
        """Return path, entry for items in a directory without recursing down."""
 
1944
        dir_file_id = self.path2id(dir_path)
2175
1945
        ordered_ids = []
2176
 
        dir_trans_id = self._path2trans_id(dir_path)
2177
 
        dir_id = self._transform.final_file_id(dir_trans_id)
2178
 
        for child_trans_id in self._all_children(dir_trans_id):
2179
 
            ordered_ids.append((child_trans_id, dir_id))
2180
 
        path_entries = []
 
1946
        for file_id in self.iter_children(dir_file_id):
 
1947
            trans_id = self._transform.trans_id_file_id(file_id)
 
1948
            ordered_ids.append((trans_id, file_id))
2181
1949
        for entry, trans_id in self._make_inv_entries(ordered_ids):
2182
 
            path_entries.append((self._final_paths.get_path(trans_id), entry))
2183
 
        path_entries.sort()
2184
 
        return path_entries
 
1950
            yield unicode(self._final_paths.get_path(trans_id)), entry
2185
1951
 
2186
1952
    def list_files(self, include_root=False, from_dir=None, recursive=True):
2187
1953
        """See WorkingTree.list_files."""
2209
1975
            for path, entry in entries:
2210
1976
                yield path, 'V', entry.kind, entry.file_id, entry
2211
1977
 
2212
 
    def kind(self, path, file_id=None):
2213
 
        trans_id = self._path2trans_id(path)
2214
 
        if trans_id is None:
2215
 
            raise errors.NoSuchFile(path)
 
1978
    def kind(self, file_id):
 
1979
        trans_id = self._transform.trans_id_file_id(file_id)
2216
1980
        return self._transform.final_kind(trans_id)
2217
1981
 
2218
 
    def stored_kind(self, path, file_id=None):
2219
 
        trans_id = self._path2trans_id(path)
2220
 
        if trans_id is None:
2221
 
            raise errors.NoSuchFile(path)
 
1982
    def stored_kind(self, file_id):
 
1983
        trans_id = self._transform.trans_id_file_id(file_id)
2222
1984
        try:
2223
1985
            return self._transform._new_contents[trans_id]
2224
1986
        except KeyError:
2225
 
            return self._transform._tree.stored_kind(path, file_id)
 
1987
            return self._transform._tree.stored_kind(file_id)
2226
1988
 
2227
 
    def get_file_mtime(self, path, file_id=None):
 
1989
    def get_file_mtime(self, file_id, path=None):
2228
1990
        """See Tree.get_file_mtime"""
2229
 
        if file_id is None:
2230
 
            file_id = self.path2id(path)
2231
 
        if file_id is None:
2232
 
            raise errors.NoSuchFile(path)
2233
1991
        if not self._content_change(file_id):
2234
 
            return self._transform._tree.get_file_mtime(
2235
 
                    self._transform._tree.id2path(file_id), file_id)
2236
 
        trans_id = self._path2trans_id(path)
2237
 
        return self._stat_limbo_file(trans_id).st_mtime
2238
 
 
2239
 
    def get_file_size(self, path, file_id=None):
 
1992
            return self._transform._tree.get_file_mtime(file_id)
 
1993
        return self._stat_limbo_file(file_id).st_mtime
 
1994
 
 
1995
    def _file_size(self, entry, stat_value):
 
1996
        return self.get_file_size(entry.file_id)
 
1997
 
 
1998
    def get_file_size(self, file_id):
2240
1999
        """See Tree.get_file_size"""
2241
 
        trans_id = self._path2trans_id(path)
2242
 
        if trans_id is None:
2243
 
            raise errors.NoSuchFile(path)
2244
 
        kind = self._transform.final_kind(trans_id)
2245
 
        if kind != 'file':
2246
 
            return None
2247
 
        if trans_id in self._transform._new_contents:
2248
 
            return self._stat_limbo_file(trans_id).st_size
2249
 
        if self.kind(path, file_id) == 'file':
2250
 
            return self._transform._tree.get_file_size(path, file_id)
 
2000
        if self.kind(file_id) == 'file':
 
2001
            return self._transform._tree.get_file_size(file_id)
2251
2002
        else:
2252
2003
            return None
2253
2004
 
2254
 
    def get_file_verifier(self, path, file_id=None, stat_value=None):
2255
 
        trans_id = self._path2trans_id(path)
2256
 
        if trans_id is None:
2257
 
            raise errors.NoSuchFile(path)
2258
 
        kind = self._transform._new_contents.get(trans_id)
2259
 
        if kind is None:
2260
 
            return self._transform._tree.get_file_verifier(path, file_id)
2261
 
        if kind == 'file':
2262
 
            with self.get_file(path, file_id) as fileobj:
2263
 
                return ("SHA1", sha_file(fileobj))
2264
 
 
2265
 
    def get_file_sha1(self, path, file_id=None, stat_value=None):
2266
 
        trans_id = self._path2trans_id(path)
2267
 
        if trans_id is None:
2268
 
            raise errors.NoSuchFile(path)
2269
 
        kind = self._transform._new_contents.get(trans_id)
2270
 
        if kind is None:
2271
 
            return self._transform._tree.get_file_sha1(path, file_id)
2272
 
        if kind == 'file':
2273
 
            with self.get_file(path, file_id) as fileobj:
 
2005
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
2006
        trans_id = self._transform.trans_id_file_id(file_id)
 
2007
        kind = self._transform._new_contents.get(trans_id)
 
2008
        if kind is None:
 
2009
            return self._transform._tree.get_file_sha1(file_id)
 
2010
        if kind == 'file':
 
2011
            fileobj = self.get_file(file_id)
 
2012
            try:
2274
2013
                return sha_file(fileobj)
 
2014
            finally:
 
2015
                fileobj.close()
2275
2016
 
2276
 
    def is_executable(self, path, file_id=None):
2277
 
        trans_id = self._path2trans_id(path)
2278
 
        if trans_id is None:
 
2017
    def is_executable(self, file_id, path=None):
 
2018
        if file_id is None:
2279
2019
            return False
 
2020
        trans_id = self._transform.trans_id_file_id(file_id)
2280
2021
        try:
2281
2022
            return self._transform._new_executability[trans_id]
2282
2023
        except KeyError:
2283
2024
            try:
2284
 
                return self._transform._tree.is_executable(path, file_id)
2285
 
            except OSError as e:
 
2025
                return self._transform._tree.is_executable(file_id, path)
 
2026
            except OSError, e:
2286
2027
                if e.errno == errno.ENOENT:
2287
2028
                    return False
2288
2029
                raise
2289
 
            except errors.NoSuchFile:
 
2030
            except errors.NoSuchId:
2290
2031
                return False
2291
2032
 
2292
 
    def has_filename(self, path):
2293
 
        trans_id = self._path2trans_id(path)
2294
 
        if trans_id in self._transform._new_contents:
2295
 
            return True
2296
 
        elif trans_id in self._transform._removed_contents:
2297
 
            return False
2298
 
        else:
2299
 
            return self._transform._tree.has_filename(path)
2300
 
 
2301
2033
    def path_content_summary(self, path):
2302
2034
        trans_id = self._path2trans_id(path)
2303
2035
        tt = self._transform
2316
2048
            if kind == 'file':
2317
2049
                statval = os.lstat(limbo_name)
2318
2050
                size = statval.st_size
2319
 
                if not tt._limbo_supports_executable():
 
2051
                if not supports_executable():
2320
2052
                    executable = False
2321
2053
                else:
2322
2054
                    executable = statval.st_mode & S_IEXEC
2349
2081
            raise ValueError('want_unversioned is not supported')
2350
2082
        return self._transform.iter_changes()
2351
2083
 
2352
 
    def get_file(self, path, file_id=None):
 
2084
    def get_file(self, file_id, path=None):
2353
2085
        """See Tree.get_file"""
2354
 
        if file_id is None:
2355
 
            file_id = self.path2id(path)
2356
2086
        if not self._content_change(file_id):
2357
 
            return self._transform._tree.get_file(path, file_id)
2358
 
        trans_id = self._path2trans_id(path)
 
2087
            return self._transform._tree.get_file(file_id, path)
 
2088
        trans_id = self._transform.trans_id_file_id(file_id)
2359
2089
        name = self._transform._limbo_name(trans_id)
2360
2090
        return open(name, 'rb')
2361
2091
 
2362
 
    def get_file_with_stat(self, path, file_id=None):
2363
 
        return self.get_file(path, file_id), None
 
2092
    def get_file_with_stat(self, file_id, path=None):
 
2093
        return self.get_file(file_id, path), None
2364
2094
 
2365
 
    def annotate_iter(self, path, file_id=None,
 
2095
    def annotate_iter(self, file_id,
2366
2096
                      default_revision=_mod_revision.CURRENT_REVISION):
2367
 
        if file_id is None:
2368
 
            file_id = self.path2id(path)
2369
2097
        changes = self._iter_changes_cache.get(file_id)
2370
2098
        if changes is None:
2371
2099
            get_old = True
2376
2104
                return None
2377
2105
            get_old = (kind[0] == 'file' and versioned[0])
2378
2106
        if get_old:
2379
 
            old_annotation = self._transform._tree.annotate_iter(
2380
 
                    path, file_id=file_id, default_revision=default_revision)
 
2107
            old_annotation = self._transform._tree.annotate_iter(file_id,
 
2108
                default_revision=default_revision)
2381
2109
        else:
2382
2110
            old_annotation = []
2383
2111
        if changes is None:
2392
2120
        #       It would be nice to be able to use the new Annotator based
2393
2121
        #       approach, as well.
2394
2122
        return annotate.reannotate([old_annotation],
2395
 
                                   self.get_file(path, file_id).readlines(),
 
2123
                                   self.get_file(file_id).readlines(),
2396
2124
                                   default_revision)
2397
2125
 
2398
 
    def get_symlink_target(self, path, file_id=None):
 
2126
    def get_symlink_target(self, file_id):
2399
2127
        """See Tree.get_symlink_target"""
2400
 
        if file_id is None:
2401
 
            file_id = self.path2id(path)
2402
2128
        if not self._content_change(file_id):
2403
 
            return self._transform._tree.get_symlink_target(path)
2404
 
        trans_id = self._path2trans_id(path)
 
2129
            return self._transform._tree.get_symlink_target(file_id)
 
2130
        trans_id = self._transform.trans_id_file_id(file_id)
2405
2131
        name = self._transform._limbo_name(trans_id)
2406
2132
        return osutils.readlink(name)
2407
2133
 
2418
2144
                path_from_root = self._final_paths.get_path(child_id)
2419
2145
                basename = self._transform.final_name(child_id)
2420
2146
                file_id = self._transform.final_file_id(child_id)
2421
 
                kind  = self._transform.final_kind(child_id)
2422
 
                if kind is not None:
 
2147
                try:
 
2148
                    kind = self._transform.final_kind(child_id)
2423
2149
                    versioned_kind = kind
2424
 
                else:
 
2150
                except NoSuchFile:
2425
2151
                    kind = 'unknown'
2426
 
                    versioned_kind = self._transform._tree.stored_kind(
2427
 
                            self._transform._tree.id2path(file_id),
2428
 
                            file_id)
 
2152
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2429
2153
                if versioned_kind == 'directory':
2430
2154
                    subdirs.append(child_id)
2431
2155
                children.append((path_from_root, basename, kind, None,
2467
2191
 
2468
2192
    def _determine_path(self, trans_id):
2469
2193
        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
2470
 
            return u""
 
2194
            return ""
2471
2195
        name = self.transform.final_name(trans_id)
2472
2196
        parent_id = self.transform.final_parent(trans_id)
2473
2197
        if parent_id == self.transform.root:
2519
2243
    :param delta_from_tree: If true, build_tree may use the input Tree to
2520
2244
        generate the inventory delta.
2521
2245
    """
2522
 
    with wt.lock_tree_write(), tree.lock_read():
2523
 
        if accelerator_tree is not None:
2524
 
            accelerator_tree.lock_read()
 
2246
    wt.lock_tree_write()
 
2247
    try:
 
2248
        tree.lock_read()
2525
2249
        try:
2526
 
            return _build_tree(tree, wt, accelerator_tree, hardlink,
2527
 
                               delta_from_tree)
2528
 
        finally:
2529
2250
            if accelerator_tree is not None:
2530
 
                accelerator_tree.unlock()
 
2251
                accelerator_tree.lock_read()
 
2252
            try:
 
2253
                return _build_tree(tree, wt, accelerator_tree, hardlink,
 
2254
                                   delta_from_tree)
 
2255
            finally:
 
2256
                if accelerator_tree is not None:
 
2257
                    accelerator_tree.unlock()
 
2258
        finally:
 
2259
            tree.unlock()
 
2260
    finally:
 
2261
        wt.unlock()
2531
2262
 
2532
2263
 
2533
2264
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
2534
2265
    """See build_tree."""
2535
 
    for num, _unused in enumerate(wt.all_versioned_paths()):
 
2266
    for num, _unused in enumerate(wt.all_file_ids()):
2536
2267
        if num > 0:  # more than just a root
2537
2268
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2269
    existing_files = set()
 
2270
    for dir, files in wt.walkdirs():
 
2271
        existing_files.update(f[0] for f in files)
2538
2272
    file_trans_id = {}
2539
 
    top_pb = ui.ui_factory.nested_progress_bar()
 
2273
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2540
2274
    pp = ProgressPhase("Build phase", 2, top_pb)
2541
 
    if tree.get_root_id() is not None:
 
2275
    if tree.inventory.root is not None:
2542
2276
        # This is kind of a hack: we should be altering the root
2543
2277
        # as part of the regular tree shape diff logic.
2544
2278
        # The conditional test here is to avoid doing an
2553
2287
    divert = set()
2554
2288
    try:
2555
2289
        pp.next_phase()
2556
 
        file_trans_id[wt.get_root_id()] = tt.trans_id_tree_path('')
2557
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
2290
        file_trans_id[wt.get_root_id()] = \
 
2291
            tt.trans_id_tree_file_id(wt.get_root_id())
 
2292
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2293
        try:
2558
2294
            deferred_contents = []
2559
2295
            num = 0
2560
 
            total = len(tree.all_versioned_paths())
 
2296
            total = len(tree.inventory)
2561
2297
            if delta_from_tree:
2562
2298
                precomputed_delta = []
2563
2299
            else:
2564
2300
                precomputed_delta = None
2565
 
            # Check if tree inventory has content. If so, we populate
2566
 
            # existing_files with the directory content. If there are no
2567
 
            # entries we skip populating existing_files as its not used.
2568
 
            # This improves performance and unncessary work on large
2569
 
            # directory trees. (#501307)
2570
 
            if total > 0:
2571
 
                existing_files = set()
2572
 
                for dir, files in wt.walkdirs():
2573
 
                    existing_files.update(f[0] for f in files)
2574
2301
            for num, (tree_path, entry) in \
2575
 
                enumerate(tree.iter_entries_by_dir()):
2576
 
                pb.update(gettext("Building tree"), num - len(deferred_contents), total)
 
2302
                enumerate(tree.inventory.iter_entries_by_dir()):
 
2303
                pb.update("Building tree", num - len(deferred_contents), total)
2577
2304
                if entry.parent_id is None:
2578
2305
                    continue
2579
2306
                reparent = False
2585
2312
                    kind = file_kind(target_path)
2586
2313
                    if kind == "directory":
2587
2314
                        try:
2588
 
                            controldir.ControlDir.open(target_path)
 
2315
                            bzrdir.BzrDir.open(target_path)
2589
2316
                        except errors.NotBranchError:
2590
2317
                            pass
2591
2318
                        else:
2592
2319
                            divert.add(file_id)
2593
2320
                    if (file_id not in divert and
2594
 
                        _content_match(tree, entry, tree_path, file_id, kind,
 
2321
                        _content_match(tree, entry, file_id, kind,
2595
2322
                        target_path)):
2596
2323
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
2597
2324
                        if kind == 'directory':
2603
2330
                    trans_id = tt.create_path(entry.name, parent_id)
2604
2331
                    file_trans_id[file_id] = trans_id
2605
2332
                    tt.version_file(file_id, trans_id)
2606
 
                    executable = tree.is_executable(tree_path, file_id)
 
2333
                    executable = tree.is_executable(file_id, tree_path)
2607
2334
                    if executable:
2608
2335
                        tt.set_executability(executable, trans_id)
2609
 
                    trans_data = (trans_id, file_id, tree_path, entry.text_sha1)
2610
 
                    deferred_contents.append((tree_path, trans_data))
 
2336
                    trans_data = (trans_id, tree_path)
 
2337
                    deferred_contents.append((file_id, trans_data))
2611
2338
                else:
2612
 
                    file_trans_id[file_id] = new_by_entry(
2613
 
                            tree_path, tt, entry, parent_id, tree)
 
2339
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
 
2340
                                                          tree)
2614
2341
                if reparent:
2615
2342
                    new_trans_id = file_trans_id[file_id]
2616
2343
                    old_parent = tt.trans_id_tree_path(tree_path)
2618
2345
            offset = num + 1 - len(deferred_contents)
2619
2346
            _create_files(tt, tree, deferred_contents, pb, offset,
2620
2347
                          accelerator_tree, hardlink)
 
2348
        finally:
 
2349
            pb.finished()
2621
2350
        pp.next_phase()
2622
2351
        divert_trans = set(file_trans_id[f] for f in divert)
2623
2352
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
2626
2355
            precomputed_delta = None
2627
2356
        conflicts = cook_conflicts(raw_conflicts, tt)
2628
2357
        for conflict in conflicts:
2629
 
            trace.warning(text_type(conflict))
 
2358
            warning(conflict)
2630
2359
        try:
2631
2360
            wt.add_conflicts(conflicts)
2632
2361
        except errors.UnsupportedOperation:
2647
2376
        new_desired_files = desired_files
2648
2377
    else:
2649
2378
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2650
 
        unchanged = [(p[0], p[1]) for (f, p, c, v, d, n, k, e)
 
2379
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2651
2380
                     in iter if not (c or e[0] != e[1])]
2652
2381
        if accelerator_tree.supports_content_filtering():
2653
 
            unchanged = [(tp, ap) for (tp, ap) in unchanged
2654
 
                         if not next(accelerator_tree.iter_search_rules([ap]))]
 
2382
            unchanged = [(f, p) for (f, p) in unchanged
 
2383
                         if not accelerator_tree.iter_search_rules([p]).next()]
2655
2384
        unchanged = dict(unchanged)
2656
2385
        new_desired_files = []
2657
2386
        count = 0
2658
 
        for unused_tree_path, (trans_id, file_id, tree_path, text_sha1) in desired_files:
2659
 
            accelerator_path = unchanged.get(tree_path)
 
2387
        for file_id, (trans_id, tree_path) in desired_files:
 
2388
            accelerator_path = unchanged.get(file_id)
2660
2389
            if accelerator_path is None:
2661
 
                new_desired_files.append((tree_path,
2662
 
                    (trans_id, file_id, tree_path, text_sha1)))
 
2390
                new_desired_files.append((file_id, (trans_id, tree_path)))
2663
2391
                continue
2664
 
            pb.update(gettext('Adding file contents'), count + offset, total)
 
2392
            pb.update('Adding file contents', count + offset, total)
2665
2393
            if hardlink:
2666
2394
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2667
2395
                                   trans_id)
2668
2396
            else:
2669
 
                with accelerator_tree.get_file(accelerator_path, file_id) as f:
2670
 
                    chunks = osutils.file_iterator(f)
2671
 
                    if wt.supports_content_filtering():
2672
 
                        filters = wt._content_filter_stack(tree_path)
2673
 
                        chunks = filtered_output_bytes(chunks, filters,
2674
 
                            ContentFilterContext(tree_path, tree))
2675
 
                    tt.create_file(chunks, trans_id, sha1=text_sha1)
 
2397
                contents = accelerator_tree.get_file(file_id, accelerator_path)
 
2398
                if wt.supports_content_filtering():
 
2399
                    filters = wt._content_filter_stack(tree_path)
 
2400
                    contents = filtered_output_bytes(contents, filters,
 
2401
                        ContentFilterContext(tree_path, tree))
 
2402
                try:
 
2403
                    tt.create_file(contents, trans_id)
 
2404
                finally:
 
2405
                    try:
 
2406
                        contents.close()
 
2407
                    except AttributeError:
 
2408
                        # after filtering, contents may no longer be file-like
 
2409
                        pass
2676
2410
            count += 1
2677
2411
        offset += count
2678
 
    for count, ((trans_id, file_id, tree_path, text_sha1), contents) in enumerate(
 
2412
    for count, ((trans_id, tree_path), contents) in enumerate(
2679
2413
            tree.iter_files_bytes(new_desired_files)):
2680
2414
        if wt.supports_content_filtering():
2681
2415
            filters = wt._content_filter_stack(tree_path)
2682
2416
            contents = filtered_output_bytes(contents, filters,
2683
2417
                ContentFilterContext(tree_path, tree))
2684
 
        tt.create_file(contents, trans_id, sha1=text_sha1)
2685
 
        pb.update(gettext('Adding file contents'), count + offset, total)
 
2418
        tt.create_file(contents, trans_id)
 
2419
        pb.update('Adding file contents', count + offset, total)
2686
2420
 
2687
2421
 
2688
2422
def _reparent_children(tt, old_parent, new_parent):
2689
2423
    for child in tt.iter_tree_children(old_parent):
2690
2424
        tt.adjust_path(tt.final_name(child), new_parent, child)
2691
2425
 
2692
 
 
2693
2426
def _reparent_transform_children(tt, old_parent, new_parent):
2694
2427
    by_parent = tt.by_parent()
2695
2428
    for child in by_parent[old_parent]:
2696
2429
        tt.adjust_path(tt.final_name(child), new_parent, child)
2697
2430
    return by_parent[old_parent]
2698
2431
 
2699
 
 
2700
 
def _content_match(tree, entry, tree_path, file_id, kind, target_path):
 
2432
def _content_match(tree, entry, file_id, kind, target_path):
2701
2433
    if entry.kind != kind:
2702
2434
        return False
2703
2435
    if entry.kind == "directory":
2704
2436
        return True
2705
2437
    if entry.kind == "file":
2706
 
        with open(target_path, 'rb') as f1, \
2707
 
             tree.get_file(tree_path, file_id) as f2:
2708
 
            if osutils.compare_files(f1, f2):
2709
 
                return True
 
2438
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
 
2439
            return True
2710
2440
    elif entry.kind == "symlink":
2711
 
        if tree.get_symlink_target(tree_path, file_id) == os.readlink(target_path):
 
2441
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2712
2442
            return True
2713
2443
    return False
2714
2444
 
2743
2473
    return new_conflicts
2744
2474
 
2745
2475
 
2746
 
def new_by_entry(path, tt, entry, parent_id, tree):
 
2476
def new_by_entry(tt, entry, parent_id, tree):
2747
2477
    """Create a new file according to its inventory entry"""
2748
2478
    name = entry.name
2749
2479
    kind = entry.kind
2750
2480
    if kind == 'file':
2751
 
        with tree.get_file(path, entry.file_id) as f:
2752
 
            executable = tree.is_executable(path, entry.file_id)
2753
 
            return tt.new_file(
2754
 
                    name, parent_id, osutils.file_iterator(f), entry.file_id,
2755
 
                    executable)
 
2481
        contents = tree.get_file(entry.file_id).readlines()
 
2482
        executable = tree.is_executable(entry.file_id)
 
2483
        return tt.new_file(name, parent_id, contents, entry.file_id,
 
2484
                           executable)
2756
2485
    elif kind in ('directory', 'tree-reference'):
2757
2486
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
2758
2487
        if kind == 'tree-reference':
2759
2488
            tt.set_tree_reference(entry.reference_revision, trans_id)
2760
2489
        return trans_id
2761
2490
    elif kind == 'symlink':
2762
 
        target = tree.get_symlink_target(path, entry.file_id)
 
2491
        target = tree.get_symlink_target(entry.file_id)
2763
2492
        return tt.new_symlink(name, parent_id, target, entry.file_id)
2764
2493
    else:
2765
2494
        raise errors.BadFileKindError(name, kind)
2766
2495
 
2767
2496
 
2768
 
def create_from_tree(tt, trans_id, tree, path, file_id=None, chunks=None,
 
2497
@deprecated_function(deprecated_in((1, 9, 0)))
 
2498
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
 
2499
    """Create new file contents according to an inventory entry.
 
2500
 
 
2501
    DEPRECATED.  Use create_from_tree instead.
 
2502
    """
 
2503
    if entry.kind == "file":
 
2504
        if lines is None:
 
2505
            lines = tree.get_file(entry.file_id).readlines()
 
2506
        tt.create_file(lines, trans_id, mode_id=mode_id)
 
2507
    elif entry.kind == "symlink":
 
2508
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
 
2509
    elif entry.kind == "directory":
 
2510
        tt.create_directory(trans_id)
 
2511
 
 
2512
 
 
2513
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2769
2514
    filter_tree_path=None):
2770
2515
    """Create new file contents according to tree contents.
2771
 
 
 
2516
    
2772
2517
    :param filter_tree_path: the tree path to use to lookup
2773
2518
      content filters to apply to the bytes output in the working tree.
2774
2519
      This only applies if the working tree supports content filtering.
2775
2520
    """
2776
 
    kind = tree.kind(path, file_id)
 
2521
    kind = tree.kind(file_id)
2777
2522
    if kind == 'directory':
2778
2523
        tt.create_directory(trans_id)
2779
2524
    elif kind == "file":
2780
 
        if chunks is None:
2781
 
            f = tree.get_file(path, file_id)
2782
 
            chunks = osutils.file_iterator(f)
2783
 
        else:
2784
 
            f = None
2785
 
        try:
2786
 
            wt = tt._tree
2787
 
            if wt.supports_content_filtering() and filter_tree_path is not None:
2788
 
                filters = wt._content_filter_stack(filter_tree_path)
2789
 
                chunks = filtered_output_bytes(chunks, filters,
2790
 
                    ContentFilterContext(filter_tree_path, tree))
2791
 
            tt.create_file(chunks, trans_id)
2792
 
        finally:
2793
 
            if f is not None:
2794
 
                f.close()
 
2525
        if bytes is None:
 
2526
            tree_file = tree.get_file(file_id)
 
2527
            try:
 
2528
                bytes = tree_file.readlines()
 
2529
            finally:
 
2530
                tree_file.close()
 
2531
        wt = tt._tree
 
2532
        if wt.supports_content_filtering() and filter_tree_path is not None:
 
2533
            filters = wt._content_filter_stack(filter_tree_path)
 
2534
            bytes = filtered_output_bytes(bytes, filters,
 
2535
                ContentFilterContext(filter_tree_path, tree))
 
2536
        tt.create_file(bytes, trans_id)
2795
2537
    elif kind == "symlink":
2796
 
        tt.create_symlink(tree.get_symlink_target(path, file_id), trans_id)
 
2538
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2797
2539
    else:
2798
2540
        raise AssertionError('Unknown kind %r' % kind)
2799
2541
 
2804
2546
        tt.set_executability(entry.executable, trans_id)
2805
2547
 
2806
2548
 
 
2549
def get_backup_name(entry, by_parent, parent_trans_id, tt):
 
2550
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
 
2551
 
 
2552
 
 
2553
def _get_backup_name(name, by_parent, parent_trans_id, tt):
 
2554
    """Produce a backup-style name that appears to be available"""
 
2555
    def name_gen():
 
2556
        counter = 1
 
2557
        while True:
 
2558
            yield "%s.~%d~" % (name, counter)
 
2559
            counter += 1
 
2560
    for new_name in name_gen():
 
2561
        if not tt.has_named_child(by_parent, parent_trans_id, new_name):
 
2562
            return new_name
 
2563
 
 
2564
 
 
2565
def _entry_changes(file_id, entry, working_tree):
 
2566
    """Determine in which ways the inventory entry has changed.
 
2567
 
 
2568
    Returns booleans: has_contents, content_mod, meta_mod
 
2569
    has_contents means there are currently contents, but they differ
 
2570
    contents_mod means contents need to be modified
 
2571
    meta_mod means the metadata needs to be modified
 
2572
    """
 
2573
    cur_entry = working_tree.inventory[file_id]
 
2574
    try:
 
2575
        working_kind = working_tree.kind(file_id)
 
2576
        has_contents = True
 
2577
    except NoSuchFile:
 
2578
        has_contents = False
 
2579
        contents_mod = True
 
2580
        meta_mod = False
 
2581
    if has_contents is True:
 
2582
        if entry.kind != working_kind:
 
2583
            contents_mod, meta_mod = True, False
 
2584
        else:
 
2585
            cur_entry._read_tree_state(working_tree.id2path(file_id),
 
2586
                                       working_tree)
 
2587
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
 
2588
            cur_entry._forget_tree_state()
 
2589
    return has_contents, contents_mod, meta_mod
 
2590
 
 
2591
 
2807
2592
def revert(working_tree, target_tree, filenames, backups=False,
2808
2593
           pb=None, change_reporter=None):
2809
2594
    """Revert a working tree's contents to those of a target tree."""
 
2595
    target_tree.lock_read()
2810
2596
    pb = ui.ui_factory.nested_progress_bar()
 
2597
    tt = TreeTransform(working_tree, pb)
2811
2598
    try:
2812
 
        with target_tree.lock_read(), TreeTransform(working_tree, pb) as tt:
2813
 
            pp = ProgressPhase("Revert phase", 3, pb)
2814
 
            conflicts, merge_modified = _prepare_revert_transform(
2815
 
                working_tree, target_tree, tt, filenames, backups, pp)
2816
 
            if change_reporter:
2817
 
                change_reporter = delta._ChangeReporter(
2818
 
                    unversioned_filter=working_tree.is_ignored)
2819
 
                delta.report_changes(tt.iter_changes(), change_reporter)
2820
 
            for conflict in conflicts:
2821
 
                trace.warning(text_type(conflict))
2822
 
            pp.next_phase()
2823
 
            tt.apply()
2824
 
            if working_tree.supports_merge_modified():
2825
 
                working_tree.set_merge_modified(merge_modified)
 
2599
        pp = ProgressPhase("Revert phase", 3, pb)
 
2600
        conflicts, merge_modified = _prepare_revert_transform(
 
2601
            working_tree, target_tree, tt, filenames, backups, pp)
 
2602
        if change_reporter:
 
2603
            change_reporter = delta._ChangeReporter(
 
2604
                unversioned_filter=working_tree.is_ignored)
 
2605
            delta.report_changes(tt.iter_changes(), change_reporter)
 
2606
        for conflict in conflicts:
 
2607
            warning(conflict)
 
2608
        pp.next_phase()
 
2609
        tt.apply()
 
2610
        working_tree.set_merge_modified(merge_modified)
2826
2611
    finally:
 
2612
        target_tree.unlock()
 
2613
        tt.finalize()
2827
2614
        pb.clear()
2828
2615
    return conflicts
2829
2616
 
2831
2618
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2832
2619
                              backups, pp, basis_tree=None,
2833
2620
                              merge_modified=None):
2834
 
    with ui.ui_factory.nested_progress_bar() as child_pb:
 
2621
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2622
    try:
2835
2623
        if merge_modified is None:
2836
2624
            merge_modified = working_tree.merge_modified()
2837
2625
        merge_modified = _alter_files(working_tree, target_tree, tt,
2838
2626
                                      child_pb, filenames, backups,
2839
2627
                                      merge_modified, basis_tree)
2840
 
    with ui.ui_factory.nested_progress_bar() as child_pb:
 
2628
    finally:
 
2629
        child_pb.finished()
 
2630
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2631
    try:
2841
2632
        raw_conflicts = resolve_conflicts(tt, child_pb,
2842
2633
            lambda t, c: conflict_pass(t, c, target_tree))
 
2634
    finally:
 
2635
        child_pb.finished()
2843
2636
    conflicts = cook_conflicts(raw_conflicts, tt)
2844
2637
    return conflicts, merge_modified
2845
2638
 
2848
2641
                 backups, merge_modified, basis_tree=None):
2849
2642
    if basis_tree is not None:
2850
2643
        basis_tree.lock_read()
2851
 
    # We ask the working_tree for its changes relative to the target, rather
2852
 
    # than the target changes relative to the working tree. Because WT4 has an
2853
 
    # optimizer to compare itself to a target, but no optimizer for the
2854
 
    # reverse.
2855
 
    change_list = working_tree.iter_changes(target_tree,
 
2644
    change_list = target_tree.iter_changes(working_tree,
2856
2645
        specific_files=specific_files, pb=pb)
2857
 
    if not target_tree.is_versioned(u''):
 
2646
    if target_tree.get_root_id() is None:
2858
2647
        skip_root = True
2859
2648
    else:
2860
2649
        skip_root = False
2862
2651
        deferred_files = []
2863
2652
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2864
2653
                kind, executable) in enumerate(change_list):
2865
 
            target_path, wt_path = path
2866
 
            target_versioned, wt_versioned = versioned
2867
 
            target_parent, wt_parent = parent
2868
 
            target_name, wt_name = name
2869
 
            target_kind, wt_kind = kind
2870
 
            target_executable, wt_executable = executable
2871
 
            if skip_root and wt_parent is None:
 
2654
            if skip_root and file_id[0] is not None and parent[0] is None:
2872
2655
                continue
2873
2656
            trans_id = tt.trans_id_file_id(file_id)
2874
2657
            mode_id = None
2875
2658
            if changed_content:
2876
2659
                keep_content = False
2877
 
                if wt_kind == 'file' and (backups or target_kind is None):
2878
 
                    wt_sha1 = working_tree.get_file_sha1(wt_path, file_id)
 
2660
                if kind[0] == 'file' and (backups or kind[1] is None):
 
2661
                    wt_sha1 = working_tree.get_file_sha1(file_id)
2879
2662
                    if merge_modified.get(file_id) != wt_sha1:
2880
2663
                        # acquire the basis tree lazily to prevent the
2881
2664
                        # expense of accessing it when it's not needed ?
2883
2666
                        if basis_tree is None:
2884
2667
                            basis_tree = working_tree.basis_tree()
2885
2668
                            basis_tree.lock_read()
2886
 
                        basis_path = find_previous_path(working_tree, basis_tree, wt_path)
2887
 
                        if basis_path is None:
2888
 
                            if target_kind is None and not target_versioned:
2889
 
                                keep_content = True
2890
 
                        else:
2891
 
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path, file_id):
2892
 
                                keep_content = True
2893
 
                if wt_kind is not None:
 
2669
                        if file_id in basis_tree:
 
2670
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
 
2671
                                keep_content = True
 
2672
                        elif kind[1] is None and not versioned[1]:
 
2673
                            keep_content = True
 
2674
                if kind[0] is not None:
2894
2675
                    if not keep_content:
2895
2676
                        tt.delete_contents(trans_id)
2896
 
                    elif target_kind is not None:
2897
 
                        parent_trans_id = tt.trans_id_file_id(wt_parent)
2898
 
                        backup_name = tt._available_backup_name(
2899
 
                            wt_name, parent_trans_id)
 
2677
                    elif kind[1] is not None:
 
2678
                        parent_trans_id = tt.trans_id_file_id(parent[0])
 
2679
                        by_parent = tt.by_parent()
 
2680
                        backup_name = _get_backup_name(name[0], by_parent,
 
2681
                                                       parent_trans_id, tt)
2900
2682
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2901
 
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
2902
 
                        if wt_versioned and target_versioned:
 
2683
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
 
2684
                        if versioned == (True, True):
2903
2685
                            tt.unversion_file(trans_id)
2904
2686
                            tt.version_file(file_id, new_trans_id)
2905
2687
                        # New contents should have the same unix perms as old
2906
2688
                        # contents
2907
2689
                        mode_id = trans_id
2908
2690
                        trans_id = new_trans_id
2909
 
                if target_kind in ('directory', 'tree-reference'):
 
2691
                if kind[1] in ('directory', 'tree-reference'):
2910
2692
                    tt.create_directory(trans_id)
2911
 
                    if target_kind == 'tree-reference':
2912
 
                        revision = target_tree.get_reference_revision(
2913
 
                                target_path, file_id)
 
2693
                    if kind[1] == 'tree-reference':
 
2694
                        revision = target_tree.get_reference_revision(file_id,
 
2695
                                                                      path[1])
2914
2696
                        tt.set_tree_reference(revision, trans_id)
2915
 
                elif target_kind == 'symlink':
2916
 
                    tt.create_symlink(target_tree.get_symlink_target(
2917
 
                            target_path, file_id), trans_id)
2918
 
                elif target_kind == 'file':
2919
 
                    deferred_files.append((target_path, (trans_id, mode_id, file_id)))
 
2697
                elif kind[1] == 'symlink':
 
2698
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
 
2699
                                      trans_id)
 
2700
                elif kind[1] == 'file':
 
2701
                    deferred_files.append((file_id, (trans_id, mode_id)))
2920
2702
                    if basis_tree is None:
2921
2703
                        basis_tree = working_tree.basis_tree()
2922
2704
                        basis_tree.lock_read()
2923
 
                    new_sha1 = target_tree.get_file_sha1(target_path, file_id)
2924
 
                    basis_path = find_previous_path(target_tree, basis_tree, target_path)
2925
 
                    if (basis_path is not None and
2926
 
                        new_sha1 == basis_tree.get_file_sha1(basis_path, file_id)):
 
2705
                    new_sha1 = target_tree.get_file_sha1(file_id)
 
2706
                    if (file_id in basis_tree and new_sha1 ==
 
2707
                        basis_tree.get_file_sha1(file_id)):
2927
2708
                        if file_id in merge_modified:
2928
2709
                            del merge_modified[file_id]
2929
2710
                    else:
2930
2711
                        merge_modified[file_id] = new_sha1
2931
2712
 
2932
2713
                    # preserve the execute bit when backing up
2933
 
                    if keep_content and wt_executable == target_executable:
2934
 
                        tt.set_executability(target_executable, trans_id)
2935
 
                elif target_kind is not None:
2936
 
                    raise AssertionError(target_kind)
2937
 
            if not wt_versioned and target_versioned:
 
2714
                    if keep_content and executable[0] == executable[1]:
 
2715
                        tt.set_executability(executable[1], trans_id)
 
2716
                elif kind[1] is not None:
 
2717
                    raise AssertionError(kind[1])
 
2718
            if versioned == (False, True):
2938
2719
                tt.version_file(file_id, trans_id)
2939
 
            if wt_versioned and not target_versioned:
 
2720
            if versioned == (True, False):
2940
2721
                tt.unversion_file(trans_id)
2941
 
            if (target_name is not None and
2942
 
                (wt_name != target_name or wt_parent != target_parent)):
2943
 
                if target_name == '' and target_parent is None:
 
2722
            if (name[1] is not None and
 
2723
                (name[0] != name[1] or parent[0] != parent[1])):
 
2724
                if name[1] == '' and parent[1] is None:
2944
2725
                    parent_trans = ROOT_PARENT
2945
2726
                else:
2946
 
                    parent_trans = tt.trans_id_file_id(target_parent)
2947
 
                if wt_parent is None and wt_versioned:
2948
 
                    tt.adjust_root_path(target_name, parent_trans)
 
2727
                    parent_trans = tt.trans_id_file_id(parent[1])
 
2728
                if parent[0] is None and versioned[0]:
 
2729
                    tt.adjust_root_path(name[1], parent_trans)
2949
2730
                else:
2950
 
                    tt.adjust_path(target_name, parent_trans, trans_id)
2951
 
            if wt_executable != target_executable and target_kind == "file":
2952
 
                tt.set_executability(target_executable, trans_id)
 
2731
                    tt.adjust_path(name[1], parent_trans, trans_id)
 
2732
            if executable[0] != executable[1] and kind[1] == "file":
 
2733
                tt.set_executability(executable[1], trans_id)
2953
2734
        if working_tree.supports_content_filtering():
2954
 
            for (trans_id, mode_id, file_id), bytes in (
 
2735
            for index, ((trans_id, mode_id), bytes) in enumerate(
2955
2736
                target_tree.iter_files_bytes(deferred_files)):
 
2737
                file_id = deferred_files[index][0]
2956
2738
                # We're reverting a tree to the target tree so using the
2957
2739
                # target tree to find the file path seems the best choice
2958
2740
                # here IMO - Ian C 27/Oct/2009
2962
2744
                    ContentFilterContext(filter_tree_path, working_tree))
2963
2745
                tt.create_file(bytes, trans_id, mode_id)
2964
2746
        else:
2965
 
            for (trans_id, mode_id, file_id), bytes in target_tree.iter_files_bytes(
 
2747
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2966
2748
                deferred_files):
2967
2749
                tt.create_file(bytes, trans_id, mode_id)
2968
2750
        tt.fixup_new_roots()
2977
2759
    if pass_func is None:
2978
2760
        pass_func = conflict_pass
2979
2761
    new_conflicts = set()
2980
 
    with ui.ui_factory.nested_progress_bar() as pb:
 
2762
    pb = ui.ui_factory.nested_progress_bar()
 
2763
    try:
2981
2764
        for n in range(10):
2982
 
            pb.update(gettext('Resolution pass'), n+1, 10)
 
2765
            pb.update('Resolution pass', n+1, 10)
2983
2766
            conflicts = tt.find_conflicts()
2984
2767
            if len(conflicts) == 0:
2985
2768
                return new_conflicts
2986
2769
            new_conflicts.update(pass_func(tt, conflicts))
2987
2770
        raise MalformedTransform(conflicts=conflicts)
 
2771
    finally:
 
2772
        pb.finished()
2988
2773
 
2989
2774
 
2990
2775
def conflict_pass(tt, conflicts, path_tree=None):
3007
2792
                existing_file, new_file = conflict[2], conflict[1]
3008
2793
            else:
3009
2794
                existing_file, new_file = conflict[1], conflict[2]
3010
 
            new_name = tt.final_name(existing_file) + '.moved'
 
2795
            new_name = tt.final_name(existing_file)+'.moved'
3011
2796
            tt.adjust_path(new_name, final_parent, existing_file)
3012
2797
            new_conflicts.add((c_type, 'Moved existing file to',
3013
2798
                               existing_file, new_file))
3022
2807
 
3023
2808
        elif c_type == 'missing parent':
3024
2809
            trans_id = conflict[1]
3025
 
            if trans_id in tt._removed_contents:
3026
 
                cancel_deletion = True
3027
 
                orphans = tt._get_potential_orphans(trans_id)
3028
 
                if orphans:
3029
 
                    cancel_deletion = False
3030
 
                    # All children are orphans
3031
 
                    for o in orphans:
3032
 
                        try:
3033
 
                            tt.new_orphan(o, trans_id)
3034
 
                        except OrphaningError:
3035
 
                            # Something bad happened so we cancel the directory
3036
 
                            # deletion which will leave it in place with a
3037
 
                            # conflict. The user can deal with it from there.
3038
 
                            # Note that this also catch the case where we don't
3039
 
                            # want to create orphans and leave the directory in
3040
 
                            # place.
3041
 
                            cancel_deletion = True
3042
 
                            break
3043
 
                if cancel_deletion:
3044
 
                    # Cancel the directory deletion
3045
 
                    tt.cancel_deletion(trans_id)
3046
 
                    new_conflicts.add(('deleting parent', 'Not deleting',
3047
 
                                       trans_id))
3048
 
            else:
 
2810
            try:
 
2811
                tt.cancel_deletion(trans_id)
 
2812
                new_conflicts.add(('deleting parent', 'Not deleting',
 
2813
                                   trans_id))
 
2814
            except KeyError:
3049
2815
                create = True
3050
2816
                try:
3051
2817
                    tt.final_name(trans_id)
3054
2820
                        file_id = tt.final_file_id(trans_id)
3055
2821
                        if file_id is None:
3056
2822
                            file_id = tt.inactive_file_id(trans_id)
3057
 
                        _, entry = next(path_tree.iter_entries_by_dir(
3058
 
                            specific_files=[path_tree.id2path(file_id)]))
 
2823
                        entry = path_tree.inventory[file_id]
3059
2824
                        # special-case the other tree root (move its
3060
2825
                        # children to current root)
3061
2826
                        if entry.parent_id is None:
3076
2841
        elif c_type == 'unversioned parent':
3077
2842
            file_id = tt.inactive_file_id(conflict[1])
3078
2843
            # special-case the other tree root (move its children instead)
3079
 
            if path_tree and path_tree.path2id('') == file_id:
3080
 
                    # This is the root entry, skip it
 
2844
            if path_tree and file_id in path_tree:
 
2845
                if path_tree.inventory[file_id].parent_id is None:
3081
2846
                    continue
3082
2847
            tt.version_file(file_id, conflict[1])
3083
2848
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
3099
2864
 
3100
2865
def cook_conflicts(raw_conflicts, tt):
3101
2866
    """Generate a list of cooked conflicts, sorted by file path"""
 
2867
    from bzrlib.conflicts import Conflict
3102
2868
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
3103
 
    return sorted(conflict_iter, key=conflicts.Conflict.sort_key)
 
2869
    return sorted(conflict_iter, key=Conflict.sort_key)
3104
2870
 
3105
2871
 
3106
2872
def iter_cook_conflicts(raw_conflicts, tt):
 
2873
    from bzrlib.conflicts import Conflict
3107
2874
    fp = FinalPaths(tt)
3108
2875
    for conflict in raw_conflicts:
3109
2876
        c_type = conflict[0]
3111
2878
        modified_path = fp.get_path(conflict[2])
3112
2879
        modified_id = tt.final_file_id(conflict[2])
3113
2880
        if len(conflict) == 3:
3114
 
            yield conflicts.Conflict.factory(
3115
 
                c_type, action=action, path=modified_path, file_id=modified_id)
 
2881
            yield Conflict.factory(c_type, action=action, path=modified_path,
 
2882
                                     file_id=modified_id)
3116
2883
 
3117
2884
        else:
3118
2885
            conflicting_path = fp.get_path(conflict[3])
3119
2886
            conflicting_id = tt.final_file_id(conflict[3])
3120
 
            yield conflicts.Conflict.factory(
3121
 
                c_type, action=action, path=modified_path,
3122
 
                file_id=modified_id,
3123
 
                conflict_path=conflicting_path,
3124
 
                conflict_file_id=conflicting_id)
 
2887
            yield Conflict.factory(c_type, action=action, path=modified_path,
 
2888
                                   file_id=modified_id,
 
2889
                                   conflict_path=conflicting_path,
 
2890
                                   conflict_file_id=conflicting_id)
3125
2891
 
3126
2892
 
3127
2893
class _FileMover(object):
3134
2900
    def rename(self, from_, to):
3135
2901
        """Rename a file from one path to another."""
3136
2902
        try:
3137
 
            os.rename(from_, to)
3138
 
        except OSError as e:
 
2903
            osutils.rename(from_, to)
 
2904
        except OSError, e:
3139
2905
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
3140
2906
                raise errors.FileExists(to, str(e))
3141
 
            # normal OSError doesn't include filenames so it's hard to see where
3142
 
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
3143
 
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
 
2907
            raise
3144
2908
        self.past_renames.append((from_, to))
3145
2909
 
3146
2910
    def pre_delete(self, from_, to):
3156
2920
    def rollback(self):
3157
2921
        """Reverse all renames that have been performed"""
3158
2922
        for from_, to in reversed(self.past_renames):
3159
 
            try:
3160
 
                os.rename(to, from_)
3161
 
            except OSError as e:
3162
 
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
 
2923
            osutils.rename(to, from_)
3163
2924
        # after rollback, don't reuse _FileMover
3164
2925
        past_renames = None
3165
2926
        pending_deletions = None
3171
2932
        # after apply_deletions, don't reuse _FileMover
3172
2933
        past_renames = None
3173
2934
        pending_deletions = None
3174
 
 
3175
 
 
3176
 
def link_tree(target_tree, source_tree):
3177
 
    """Where possible, hard-link files in a tree to those in another tree.
3178
 
 
3179
 
    :param target_tree: Tree to change
3180
 
    :param source_tree: Tree to hard-link from
3181
 
    """
3182
 
    tt = TreeTransform(target_tree)
3183
 
    try:
3184
 
        for (file_id, paths, changed_content, versioned, parent, name, kind,
3185
 
             executable) in target_tree.iter_changes(source_tree,
3186
 
             include_unchanged=True):
3187
 
            if changed_content:
3188
 
                continue
3189
 
            if kind != ('file', 'file'):
3190
 
                continue
3191
 
            if executable[0] != executable[1]:
3192
 
                continue
3193
 
            trans_id = tt.trans_id_tree_path(paths[1])
3194
 
            tt.delete_contents(trans_id)
3195
 
            tt.create_hardlink(source_tree.abspath(paths[0]), trans_id)
3196
 
        tt.apply()
3197
 
    finally:
3198
 
        tt.finalize()