~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Aaron Bentley
  • Date: 2007-07-17 13:27:14 UTC
  • mfrom: (2624 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070717132714-tmzx9khmg9501k51
Merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""MutableTree object.
18
18
 
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
25
import os
26
 
import re
27
26
 
28
27
from bzrlib import (
29
28
    add,
30
29
    bzrdir,
 
30
    )
 
31
from bzrlib.osutils import dirname
 
32
from bzrlib.trace import mutter, warning
 
33
""")
 
34
 
 
35
from bzrlib import (
31
36
    errors,
32
 
    hooks,
33
37
    osutils,
34
 
    revisiontree,
35
 
    symbol_versioning,
36
 
    trace,
37
38
    tree,
38
39
    )
39
 
""")
40
 
 
41
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
41
from bzrlib.osutils import splitpath
 
42
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
42
43
 
43
44
 
44
45
def needs_tree_write_lock(unbound):
66
67
    entirely in memory.
67
68
 
68
69
    For now, we are not treating MutableTree as an interface to provide
69
 
    conformance tests for - rather we are testing MemoryTree specifically, and
 
70
    conformance tests for - rather we are testing MemoryTree specifically, and 
70
71
    interface testing implementations of WorkingTree.
71
72
 
72
73
    A mutable tree always has an associated Branch and BzrDir object - the
73
74
    branch and bzrdir attributes.
74
75
    """
75
 
    def __init__(self, *args, **kw):
76
 
        super(MutableTree, self).__init__(*args, **kw)
77
 
        # Is this tree on a case-insensitive or case-preserving file-system?
78
 
        # Sub-classes may initialize to False if they detect they are being
79
 
        # used on media which doesn't differentiate the case of names.
80
 
        self.case_sensitive = True
81
76
 
82
77
    @needs_tree_write_lock
83
78
    def add(self, files, ids=None, kinds=None):
99
94
        TODO: Perhaps callback with the ids and paths as they're added.
100
95
        """
101
96
        if isinstance(files, basestring):
102
 
            # XXX: Passing a single string is inconsistent and should be
103
 
            # deprecated.
104
 
            if not (ids is None or isinstance(ids, basestring)):
105
 
                raise AssertionError()
106
 
            if not (kinds is None or isinstance(kinds, basestring)):
107
 
                raise AssertionError()
 
97
            assert(ids is None or isinstance(ids, basestring))
 
98
            assert(kinds is None or isinstance(kinds, basestring))
108
99
            files = [files]
109
100
            if ids is not None:
110
101
                ids = [ids]
116
107
        if ids is None:
117
108
            ids = [None] * len(files)
118
109
        else:
119
 
            if not (len(ids) == len(files)):
120
 
                raise AssertionError()
 
110
            assert(len(ids) == len(files))
 
111
            ids = [osutils.safe_file_id(file_id) for file_id in ids]
 
112
 
121
113
        if kinds is None:
122
114
            kinds = [None] * len(files)
123
 
        elif not len(kinds) == len(files):
124
 
            raise AssertionError()
 
115
        else:
 
116
            assert(len(kinds) == len(files))
125
117
        for f in files:
126
118
            # generic constraint checks:
127
119
            if self.is_control_filename(f):
128
120
                raise errors.ForbiddenControlFileError(filename=f)
129
 
            fp = osutils.splitpath(f)
130
 
        # fill out file kinds for all files [not needed when we stop
 
121
            fp = splitpath(f)
 
122
        # fill out file kinds for all files [not needed when we stop 
131
123
        # caring about the instantaneous file kind within a uncommmitted tree
132
124
        #
133
125
        self._gather_kinds(files, kinds)
167
159
    def apply_inventory_delta(self, changes):
168
160
        """Apply changes to the inventory as an atomic operation.
169
161
 
170
 
        :param changes: An inventory delta to apply to the working tree's
171
 
            inventory.
172
 
        :return None:
173
 
        :seealso Inventory.apply_delta: For details on the changes parameter.
 
162
        The argument is a set of changes to apply.  It must describe a
 
163
        valid result, but the order is not important.  Specifically,
 
164
        intermediate stages *may* be invalid, such as when two files
 
165
        swap names.
 
166
 
 
167
        The changes should be structured as a list of tuples, of the form
 
168
        (old_path, new_path, file_id, new_entry).  For creation, old_path
 
169
        must be None.  For deletion, new_path and new_entry must be None.
 
170
        file_id is always non-None.  For renames and other mutations, all
 
171
        values must be non-None.
 
172
 
 
173
        If the new_entry is a directory, its children should be an empty
 
174
        dict.  Children are handled by apply_inventory_delta itself.
 
175
 
 
176
        :param changes: A list of tuples for the change to apply:
 
177
            [(old_path, new_path, file_id, new_inventory_entry), ...]
174
178
        """
175
179
        self.flush()
176
180
        inv = self.inventory
177
 
        inv.apply_delta(changes)
 
181
        children = {}
 
182
        for old_path, file_id in sorted(((op, f) for op, np, f, e in changes
 
183
                                        if op is not None), reverse=True):
 
184
            if file_id not in inv:
 
185
                continue
 
186
            children[file_id] = getattr(inv[file_id], 'children', {})
 
187
            inv.remove_recursive_id(file_id)
 
188
        for new_path, new_entry in sorted((np, e) for op, np, f, e in
 
189
                                          changes if np is not None):
 
190
            if getattr(new_entry, 'children', None) is not None:
 
191
                new_entry.children = children.get(new_entry.file_id, {})
 
192
            inv.add(new_entry)
178
193
        self._write_inventory(inv)
179
194
 
180
195
    @needs_write_lock
184
199
        from bzrlib import commit
185
200
        if revprops is None:
186
201
            revprops = {}
187
 
        possible_master_transports=[]
188
202
        if not 'branch-nick' in revprops:
189
 
            revprops['branch-nick'] = self.branch._get_nick(
190
 
                kwargs.get('local', False),
191
 
                possible_master_transports)
192
 
        authors = kwargs.pop('authors', None)
193
 
        author = kwargs.pop('author', None)
194
 
        if authors is not None:
195
 
            if author is not None:
196
 
                raise AssertionError('Specifying both author and authors '
197
 
                        'is not allowed. Specify just authors instead')
198
 
            if 'author' in revprops or 'authors' in revprops:
199
 
                # XXX: maybe we should just accept one of them?
200
 
                raise AssertionError('author property given twice')
201
 
            if authors:
202
 
                for individual in authors:
203
 
                    if '\n' in individual:
204
 
                        raise AssertionError('\\n is not a valid character '
205
 
                                'in an author identity')
206
 
                revprops['authors'] = '\n'.join(authors)
207
 
        if author is not None:
208
 
            symbol_versioning.warn('The parameter author was deprecated'
209
 
                   ' in version 1.13. Use authors instead',
210
 
                   DeprecationWarning)
211
 
            if 'author' in revprops or 'authors' in revprops:
212
 
                # XXX: maybe we should just accept one of them?
213
 
                raise AssertionError('author property given twice')
214
 
            if '\n' in author:
215
 
                raise AssertionError('\\n is not a valid character '
216
 
                        'in an author identity')
217
 
            revprops['authors'] = author
 
203
            revprops['branch-nick'] = self.branch.nick
218
204
        # args for wt.commit start at message from the Commit.commit method,
219
205
        args = (message, ) + args
220
 
        for hook in MutableTree.hooks['start_commit']:
221
 
            hook(self)
222
206
        committed_id = commit.Commit().commit(working_tree=self,
223
 
            revprops=revprops,
224
 
            possible_master_transports=possible_master_transports,
225
 
            *args, **kwargs)
226
 
        post_hook_params = PostCommitHookParams(self)
227
 
        for hook in MutableTree.hooks['post_commit']:
228
 
            hook(post_hook_params)
 
207
            revprops=revprops, *args, **kwargs)
229
208
        return committed_id
230
209
 
231
210
    def _gather_kinds(self, files, kinds):
233
212
        raise NotImplementedError(self._gather_kinds)
234
213
 
235
214
    @needs_read_lock
236
 
    def has_changes(self, _from_tree=None):
237
 
        """Quickly check that the tree contains at least one commitable change.
238
 
 
239
 
        :param _from_tree: tree to compare against to find changes (default to
240
 
            the basis tree and is intended to be used by tests).
241
 
 
242
 
        :return: True if a change is found. False otherwise
243
 
        """
244
 
        # Check pending merges
245
 
        if len(self.get_parent_ids()) > 1:
246
 
            return True
247
 
        if _from_tree is None:
248
 
            _from_tree = self.basis_tree()
249
 
        changes = self.iter_changes(_from_tree)
250
 
        try:
251
 
            change = changes.next()
252
 
            # Exclude root (talk about black magic... --vila 20090629)
253
 
            if change[4] == (None, None):
254
 
                change = changes.next()
255
 
            return True
256
 
        except StopIteration:
257
 
            # No changes
258
 
            return False
259
 
 
260
 
    @needs_read_lock
261
215
    def last_revision(self):
262
216
        """Return the revision id of the last commit performed in this tree.
263
217
 
264
218
        In early tree formats the result of last_revision is the same as the
265
219
        branch last_revision, but that is no longer the case for modern tree
266
220
        formats.
267
 
 
 
221
        
268
222
        last_revision returns the left most parent id, or None if there are no
269
223
        parents.
270
224
 
287
241
    def lock_write(self):
288
242
        """Lock the tree and its branch. This allows mutating calls to be made.
289
243
 
290
 
        Some mutating methods will take out implicit write locks, but in
 
244
        Some mutating methods will take out implicit write locks, but in 
291
245
        general you should always obtain a write lock before calling mutating
292
246
        methods on a tree.
293
247
        """
303
257
        """
304
258
        raise NotImplementedError(self.mkdir)
305
259
 
306
 
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
307
 
        """Tell the tree we have observed a paths sha1.
308
 
 
309
 
        The intent of this function is to allow trees that have a hashcache to
310
 
        update the hashcache during commit. If the observed file is too new
311
 
        (based on the stat_value) to be safely hash-cached the tree will ignore
312
 
        it.
313
 
 
314
 
        The default implementation does nothing.
315
 
 
316
 
        :param file_id: The file id
317
 
        :param path: The file path
318
 
        :param sha1: The sha 1 that was observed.
319
 
        :param stat_value: A stat result for the file the sha1 was read from.
320
 
        :return: None
321
 
        """
322
 
 
323
 
    def _fix_case_of_inventory_path(self, path):
324
 
        """If our tree isn't case sensitive, return the canonical path"""
325
 
        if not self.case_sensitive:
326
 
            path = self.get_canonical_inventory_path(path)
327
 
        return path
328
 
 
329
 
    @needs_write_lock
330
 
    def put_file_bytes_non_atomic(self, file_id, bytes):
331
 
        """Update the content of a file in the tree.
332
 
 
333
 
        Note that the file is written in-place rather than being
334
 
        written to a temporary location and renamed. As a consequence,
335
 
        readers can potentially see the file half-written.
336
 
 
337
 
        :param file_id: file-id of the file
338
 
        :param bytes: the new file contents
339
 
        """
340
 
        raise NotImplementedError(self.put_file_bytes_non_atomic)
341
 
 
342
260
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
343
261
        """Set the parents ids of the working tree.
344
262
 
349
267
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
350
268
        """Set the parents of the working tree.
351
269
 
352
 
        :param parents_list: A list of (revision_id, tree) tuples.
 
270
        :param parents_list: A list of (revision_id, tree) tuples. 
353
271
            If tree is None, then that element is treated as an unreachable
354
272
            parent tree - i.e. a ghost.
355
273
        """
363
281
        For the specific behaviour see the help for cmd_add().
364
282
 
365
283
        :param action: A reporter to be called with the inventory, parent_ie,
366
 
            path and kind of the path being added. It may return a file_id if
 
284
            path and kind of the path being added. It may return a file_id if 
367
285
            a specific one should be used.
368
286
        :param save: Save the inventory after completing the adds. If False
369
287
            this provides dry-run functionality by doing the add and not saving
375
293
        # not in an inner loop; and we want to remove direct use of this,
376
294
        # so here as a reminder for now. RBC 20070703
377
295
        from bzrlib.inventory import InventoryEntry
 
296
        assert isinstance(recurse, bool)
378
297
        if action is None:
379
298
            action = add.AddAction()
380
 
 
 
299
        
381
300
        if not file_list:
382
301
            # no paths supplied: add the entire tree.
383
302
            file_list = [u'.']
388
307
        dirs_to_add = []
389
308
        user_dirs = set()
390
309
 
391
 
        # validate user file paths and convert all paths to tree
 
310
        # validate user file paths and convert all paths to tree 
392
311
        # relative : it's cheaper to make a tree relative path an abspath
393
 
        # than to convert an abspath to tree relative, and it's cheaper to
394
 
        # perform the canonicalization in bulk.
395
 
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
396
 
            rf = _FastPath(filepath)
397
 
            # validate user parameters. Our recursive code avoids adding new
398
 
            # files that need such validation
 
312
        # than to convert an abspath to tree relative.
 
313
        for filepath in file_list:
 
314
            rf = _FastPath(self.relpath(filepath))
 
315
            # validate user parameters. Our recursive code avoids adding new files
 
316
            # that need such validation 
399
317
            if self.is_control_filename(rf.raw_path):
400
318
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
401
 
 
 
319
            
402
320
            abspath = self.abspath(rf.raw_path)
403
321
            kind = osutils.file_kind(abspath)
404
322
            if kind == 'directory':
407
325
            else:
408
326
                if not InventoryEntry.versionable_kind(kind):
409
327
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
410
 
            # ensure the named path is added, so that ignore rules in the later
411
 
            # directory walk dont skip it.
412
 
            # we dont have a parent ie known yet.: use the relatively slower
413
 
            # inventory probing method
 
328
            # ensure the named path is added, so that ignore rules in the later directory
 
329
            # walk dont skip it.
 
330
            # we dont have a parent ie known yet.: use the relatively slower inventory 
 
331
            # probing method
414
332
            versioned = inv.has_filename(rf.raw_path)
415
333
            if versioned:
416
334
                continue
432
350
                dirs_to_add.append((path, None))
433
351
            prev_dir = path.raw_path
434
352
 
435
 
        illegalpath_re = re.compile(r'[\r\n]')
436
353
        # dirs_to_add is initialised to a list of directories, but as we scan
437
354
        # directories we append files to it.
438
355
        # XXX: We should determine kind of files when we scan them rather than
447
364
            kind = osutils.file_kind(abspath)
448
365
 
449
366
            if not InventoryEntry.versionable_kind(kind):
450
 
                trace.warning("skipping %s (can't add file of kind '%s')",
451
 
                              abspath, kind)
452
 
                continue
453
 
            if illegalpath_re.search(directory.raw_path):
454
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
 
367
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
455
368
                continue
456
369
 
457
370
            if parent_ie is not None:
458
371
                versioned = directory.base_path in parent_ie.children
459
372
            else:
460
 
                # without the parent ie, use the relatively slower inventory
 
373
                # without the parent ie, use the relatively slower inventory 
461
374
                # probing method
462
 
                versioned = inv.has_filename(
463
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
375
                versioned = inv.has_filename(directory.raw_path)
464
376
 
465
377
            if kind == 'directory':
466
378
                try:
480
392
                pass
481
393
                # mutter("%r is already versioned", abspath)
482
394
            elif sub_tree:
483
 
                # XXX: This is wrong; people *might* reasonably be trying to
484
 
                # add subtrees as subtrees.  This should probably only be done
485
 
                # in formats which can represent subtrees, and even then
486
 
                # perhaps only when the user asked to add subtrees.  At the
487
 
                # moment you can add them specially through 'join --reference',
488
 
                # which is perhaps reasonable: adding a new reference is a
489
 
                # special operation and can have a special behaviour.  mbp
490
 
                # 20070306
491
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
395
                # XXX: This is wrong; people *might* reasonably be trying to add
 
396
                # subtrees as subtrees.  This should probably only be done in formats 
 
397
                # which can represent subtrees, and even then perhaps only when
 
398
                # the user asked to add subtrees.  At the moment you can add them
 
399
                # specially through 'join --reference', which is perhaps
 
400
                # reasonable: adding a new reference is a special operation and
 
401
                # can have a special behaviour.  mbp 20070306
 
402
                mutter("%r is a nested bzr tree", abspath)
492
403
            else:
493
404
                _add_one(self, inv, parent_ie, directory, kind, action)
494
405
                added.append(directory.raw_path)
498
409
                    # must be present:
499
410
                    this_ie = parent_ie.children[directory.base_path]
500
411
                else:
501
 
                    # without the parent ie, use the relatively slower inventory
 
412
                    # without the parent ie, use the relatively slower inventory 
502
413
                    # probing method
503
 
                    this_id = inv.path2id(
504
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
414
                    this_id = inv.path2id(directory.raw_path)
505
415
                    if this_id is None:
506
416
                        this_ie = None
507
417
                    else:
508
418
                        this_ie = inv[this_id]
509
419
 
510
420
                for subf in sorted(os.listdir(abspath)):
511
 
                    # here we could use TreeDirectory rather than
 
421
                    # here we could use TreeDirectory rather than 
512
422
                    # string concatenation.
513
423
                    subp = osutils.pathjoin(directory.raw_path, subf)
514
 
                    # TODO: is_control_filename is very slow. Make it faster.
515
 
                    # TreeDirectory.is_control_filename could also make this
516
 
                    # faster - its impossible for a non root dir to have a
 
424
                    # TODO: is_control_filename is very slow. Make it faster. 
 
425
                    # TreeDirectory.is_control_filename could also make this 
 
426
                    # faster - its impossible for a non root dir to have a 
517
427
                    # control file.
518
428
                    if self.is_control_filename(subp):
519
 
                        trace.mutter("skip control directory %r", subp)
 
429
                        mutter("skip control directory %r", subp)
520
430
                    elif subf in this_ie.children:
521
431
                        # recurse into this already versioned subdir.
522
432
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
539
449
                self.read_working_inventory()
540
450
        return added, ignored
541
451
 
542
 
    def update_basis_by_delta(self, new_revid, delta):
543
 
        """Update the parents of this tree after a commit.
544
 
 
545
 
        This gives the tree one parent, with revision id new_revid. The
546
 
        inventory delta is applied to the current basis tree to generate the
547
 
        inventory for the parent new_revid, and all other parent trees are
548
 
        discarded.
549
 
 
550
 
        All the changes in the delta should be changes synchronising the basis
551
 
        tree with some or all of the working tree, with a change to a directory
552
 
        requiring that its contents have been recursively included. That is,
553
 
        this is not a general purpose tree modification routine, but a helper
554
 
        for commit which is not required to handle situations that do not arise
555
 
        outside of commit.
556
 
 
557
 
        See the inventory developers documentation for the theory behind
558
 
        inventory deltas.
559
 
 
560
 
        :param new_revid: The new revision id for the trees parent.
561
 
        :param delta: An inventory delta (see apply_inventory_delta) describing
562
 
            the changes from the current left most parent revision to new_revid.
563
 
        """
564
 
        # if the tree is updated by a pull to the branch, as happens in
565
 
        # WorkingTree2, when there was no separation between branch and tree,
566
 
        # then just clear merges, efficiency is not a concern for now as this
567
 
        # is legacy environments only, and they are slow regardless.
568
 
        if self.last_revision() == new_revid:
569
 
            self.set_parent_ids([new_revid])
570
 
            return
571
 
        # generic implementation based on Inventory manipulation. See
572
 
        # WorkingTree classes for optimised versions for specific format trees.
573
 
        basis = self.basis_tree()
574
 
        basis.lock_read()
575
 
        # TODO: Consider re-evaluating the need for this with CHKInventory
576
 
        # we don't strictly need to mutate an inventory for this
577
 
        # it only makes sense when apply_delta is cheaper than get_inventory()
578
 
        inventory = basis.inventory._get_mutable_inventory()
579
 
        basis.unlock()
580
 
        inventory.apply_delta(delta)
581
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
582
 
                                             inventory, new_revid)
583
 
        self.set_parent_trees([(new_revid, rev_tree)])
584
 
 
585
 
 
586
 
class MutableTreeHooks(hooks.Hooks):
587
 
    """A dictionary mapping a hook name to a list of callables for mutabletree
588
 
    hooks.
589
 
    """
590
 
 
591
 
    def __init__(self):
592
 
        """Create the default hooks.
593
 
 
594
 
        """
595
 
        hooks.Hooks.__init__(self)
596
 
        self.create_hook(hooks.HookPoint('start_commit',
597
 
            "Called before a commit is performed on a tree. The start commit "
598
 
            "hook is able to change the tree before the commit takes place. "
599
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
600
 
            "that the commit is being performed on.", (1, 4), None))
601
 
        self.create_hook(hooks.HookPoint('post_commit',
602
 
            "Called after a commit is performed on a tree. The hook is "
603
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
604
 
            "The mutable tree the commit was performed on is available via "
605
 
            "the mutable_tree attribute of that object.", (2, 0), None))
606
 
 
607
 
 
608
 
# install the default hooks into the MutableTree class.
609
 
MutableTree.hooks = MutableTreeHooks()
610
 
 
611
 
 
612
 
class PostCommitHookParams(object):
613
 
    """Parameters for the post_commit hook.
614
 
 
615
 
    To access the parameters, use the following attributes:
616
 
 
617
 
    * mutable_tree - the MutableTree object
618
 
    """
619
 
 
620
 
    def __init__(self, mutable_tree):
621
 
        """Create the parameters for the post_commit hook."""
622
 
        self.mutable_tree = mutable_tree
623
 
 
624
452
 
625
453
class _FastPath(object):
626
454
    """A path object with fast accessors for things like basename."""
661
489
        added = []
662
490
    else:
663
491
        # slower but does not need parent_ie
664
 
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
 
492
        if inv.has_filename(path.raw_path):
665
493
            return []
666
494
        # its really not there : add the parent
667
495
        # note that the dirname use leads to some extra str copying etc but as
668
496
        # there are a limited number of dirs we can be nested under, it should
669
497
        # generally find it very fast and not recurse after that.
670
498
        added = _add_one_and_parent(tree, inv, None,
671
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
672
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
499
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
500
        parent_id = inv.path2id(dirname(path.raw_path))
673
501
        parent_ie = inv[parent_id]
674
502
    _add_one(tree, inv, parent_ie, path, kind, action)
675
503
    return added + [path.raw_path]