~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Aaron Bentley
  • Date: 2007-08-16 00:54:00 UTC
  • mto: This revision was merged to the branch mainline in revision 2711.
  • Revision ID: aaron.bentley@utoronto.ca-20070816005400-oxxtqiy310wx10h9
Fix typo

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
 
27
27
from bzrlib import (
28
28
    add,
29
29
    bzrdir,
30
 
    hooks,
31
 
    symbol_versioning,
32
30
    )
33
31
from bzrlib.osutils import dirname
34
 
from bzrlib.revisiontree import RevisionTree
35
32
from bzrlib.trace import mutter, warning
36
33
""")
37
34
 
42
39
    )
43
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
44
41
from bzrlib.osutils import splitpath
 
42
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
45
43
 
46
44
 
47
45
def needs_tree_write_lock(unbound):
69
67
    entirely in memory.
70
68
 
71
69
    For now, we are not treating MutableTree as an interface to provide
72
 
    conformance tests for - rather we are testing MemoryTree specifically, and
 
70
    conformance tests for - rather we are testing MemoryTree specifically, and 
73
71
    interface testing implementations of WorkingTree.
74
72
 
75
73
    A mutable tree always has an associated Branch and BzrDir object - the
76
74
    branch and bzrdir attributes.
77
75
    """
78
 
    def __init__(self, *args, **kw):
79
 
        super(MutableTree, self).__init__(*args, **kw)
80
 
        # Is this tree on a case-insensitive or case-preserving file-system?
81
 
        # Sub-classes may initialize to False if they detect they are being
82
 
        # used on media which doesn't differentiate the case of names.
83
 
        self.case_sensitive = True
84
76
 
85
77
    @needs_tree_write_lock
86
78
    def add(self, files, ids=None, kinds=None):
102
94
        TODO: Perhaps callback with the ids and paths as they're added.
103
95
        """
104
96
        if isinstance(files, basestring):
105
 
            # XXX: Passing a single string is inconsistent and should be
106
 
            # deprecated.
107
 
            if not (ids is None or isinstance(ids, basestring)):
108
 
                raise AssertionError()
109
 
            if not (kinds is None or isinstance(kinds, basestring)):
110
 
                raise AssertionError()
 
97
            assert(ids is None or isinstance(ids, basestring))
 
98
            assert(kinds is None or isinstance(kinds, basestring))
111
99
            files = [files]
112
100
            if ids is not None:
113
101
                ids = [ids]
119
107
        if ids is None:
120
108
            ids = [None] * len(files)
121
109
        else:
122
 
            if not (len(ids) == len(files)):
123
 
                raise AssertionError()
 
110
            assert(len(ids) == len(files))
 
111
            ids = [osutils.safe_file_id(file_id) for file_id in ids]
 
112
 
124
113
        if kinds is None:
125
114
            kinds = [None] * len(files)
126
 
        elif not len(kinds) == len(files):
127
 
            raise AssertionError()
 
115
        else:
 
116
            assert(len(kinds) == len(files))
128
117
        for f in files:
129
118
            # generic constraint checks:
130
119
            if self.is_control_filename(f):
131
120
                raise errors.ForbiddenControlFileError(filename=f)
132
121
            fp = splitpath(f)
133
 
        # fill out file kinds for all files [not needed when we stop
 
122
        # fill out file kinds for all files [not needed when we stop 
134
123
        # caring about the instantaneous file kind within a uncommmitted tree
135
124
        #
136
125
        self._gather_kinds(files, kinds)
170
159
    def apply_inventory_delta(self, changes):
171
160
        """Apply changes to the inventory as an atomic operation.
172
161
 
173
 
        :param changes: An inventory delta to apply to the working tree's
174
 
            inventory.
175
 
        :return None:
176
 
        :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), ...]
177
178
        """
178
179
        self.flush()
179
180
        inv = self.inventory
180
 
        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)
181
193
        self._write_inventory(inv)
182
194
 
183
195
    @needs_write_lock
187
199
        from bzrlib import commit
188
200
        if revprops is None:
189
201
            revprops = {}
190
 
        possible_master_transports=[]
191
202
        if not 'branch-nick' in revprops:
192
 
            revprops['branch-nick'] = self.branch._get_nick(
193
 
                kwargs.get('local', False),
194
 
                possible_master_transports)
195
 
        authors = kwargs.pop('authors', None)
196
 
        author = kwargs.pop('author', None)
197
 
        if authors is not None:
198
 
            if author is not None:
199
 
                raise AssertionError('Specifying both author and authors '
200
 
                        'is not allowed. Specify just authors instead')
201
 
            if 'author' in revprops or 'authors' in revprops:
202
 
                # XXX: maybe we should just accept one of them?
203
 
                raise AssertionError('author property given twice')
204
 
            if authors:
205
 
                for individual in authors:
206
 
                    if '\n' in individual:
207
 
                        raise AssertionError('\\n is not a valid character '
208
 
                                'in an author identity')
209
 
                revprops['authors'] = '\n'.join(authors)
210
 
        if author is not None:
211
 
            symbol_versioning.warn('The parameter author was deprecated'
212
 
                   ' in version 1.13. Use authors instead',
213
 
                   DeprecationWarning)
214
 
            if 'author' in revprops or 'authors' in revprops:
215
 
                # XXX: maybe we should just accept one of them?
216
 
                raise AssertionError('author property given twice')
217
 
            if '\n' in author:
218
 
                raise AssertionError('\\n is not a valid character '
219
 
                        'in an author identity')
220
 
            revprops['authors'] = author
 
203
            revprops['branch-nick'] = self.branch.nick
221
204
        # args for wt.commit start at message from the Commit.commit method,
222
205
        args = (message, ) + args
223
 
        for hook in MutableTree.hooks['start_commit']:
224
 
            hook(self)
225
206
        committed_id = commit.Commit().commit(working_tree=self,
226
 
            revprops=revprops,
227
 
            possible_master_transports=possible_master_transports,
228
 
            *args, **kwargs)
 
207
            revprops=revprops, *args, **kwargs)
229
208
        return committed_id
230
209
 
231
210
    def _gather_kinds(self, files, kinds):
239
218
        In early tree formats the result of last_revision is the same as the
240
219
        branch last_revision, but that is no longer the case for modern tree
241
220
        formats.
242
 
 
 
221
        
243
222
        last_revision returns the left most parent id, or None if there are no
244
223
        parents.
245
224
 
262
241
    def lock_write(self):
263
242
        """Lock the tree and its branch. This allows mutating calls to be made.
264
243
 
265
 
        Some mutating methods will take out implicit write locks, but in
 
244
        Some mutating methods will take out implicit write locks, but in 
266
245
        general you should always obtain a write lock before calling mutating
267
246
        methods on a tree.
268
247
        """
278
257
        """
279
258
        raise NotImplementedError(self.mkdir)
280
259
 
281
 
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
282
 
        """Tell the tree we have observed a paths sha1.
283
 
 
284
 
        The intent of this function is to allow trees that have a hashcache to
285
 
        update the hashcache during commit. If the observed file is too new
286
 
        (based on the stat_value) to be safely hash-cached the tree will ignore
287
 
        it.
288
 
 
289
 
        The default implementation does nothing.
290
 
 
291
 
        :param file_id: The file id
292
 
        :param path: The file path
293
 
        :param sha1: The sha 1 that was observed.
294
 
        :param stat_value: A stat result for the file the sha1 was read from.
295
 
        :return: None
296
 
        """
297
 
 
298
 
    def _fix_case_of_inventory_path(self, path):
299
 
        """If our tree isn't case sensitive, return the canonical path"""
300
 
        if not self.case_sensitive:
301
 
            path = self.get_canonical_inventory_path(path)
302
 
        return path
303
 
 
304
 
    @needs_write_lock
305
 
    def put_file_bytes_non_atomic(self, file_id, bytes):
306
 
        """Update the content of a file in the tree.
307
 
 
308
 
        Note that the file is written in-place rather than being
309
 
        written to a temporary location and renamed. As a consequence,
310
 
        readers can potentially see the file half-written.
311
 
 
312
 
        :param file_id: file-id of the file
313
 
        :param bytes: the new file contents
314
 
        """
315
 
        raise NotImplementedError(self.put_file_bytes_non_atomic)
316
 
 
317
260
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
318
261
        """Set the parents ids of the working tree.
319
262
 
324
267
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
325
268
        """Set the parents of the working tree.
326
269
 
327
 
        :param parents_list: A list of (revision_id, tree) tuples.
 
270
        :param parents_list: A list of (revision_id, tree) tuples. 
328
271
            If tree is None, then that element is treated as an unreachable
329
272
            parent tree - i.e. a ghost.
330
273
        """
338
281
        For the specific behaviour see the help for cmd_add().
339
282
 
340
283
        :param action: A reporter to be called with the inventory, parent_ie,
341
 
            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 
342
285
            a specific one should be used.
343
286
        :param save: Save the inventory after completing the adds. If False
344
287
            this provides dry-run functionality by doing the add and not saving
350
293
        # not in an inner loop; and we want to remove direct use of this,
351
294
        # so here as a reminder for now. RBC 20070703
352
295
        from bzrlib.inventory import InventoryEntry
 
296
        assert isinstance(recurse, bool)
353
297
        if action is None:
354
298
            action = add.AddAction()
355
 
 
 
299
        
356
300
        if not file_list:
357
301
            # no paths supplied: add the entire tree.
358
302
            file_list = [u'.']
363
307
        dirs_to_add = []
364
308
        user_dirs = set()
365
309
 
366
 
        # validate user file paths and convert all paths to tree
 
310
        # validate user file paths and convert all paths to tree 
367
311
        # relative : it's cheaper to make a tree relative path an abspath
368
 
        # than to convert an abspath to tree relative, and it's cheaper to
369
 
        # perform the canonicalization in bulk.
370
 
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
371
 
            rf = _FastPath(filepath)
 
312
        # than to convert an abspath to tree relative.
 
313
        for filepath in file_list:
 
314
            rf = _FastPath(self.relpath(filepath))
372
315
            # validate user parameters. Our recursive code avoids adding new files
373
 
            # that need such validation
 
316
            # that need such validation 
374
317
            if self.is_control_filename(rf.raw_path):
375
318
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
376
 
 
 
319
            
377
320
            abspath = self.abspath(rf.raw_path)
378
321
            kind = osutils.file_kind(abspath)
379
322
            if kind == 'directory':
384
327
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
385
328
            # ensure the named path is added, so that ignore rules in the later directory
386
329
            # walk dont skip it.
387
 
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
330
            # we dont have a parent ie known yet.: use the relatively slower inventory 
388
331
            # probing method
389
332
            versioned = inv.has_filename(rf.raw_path)
390
333
            if versioned:
427
370
            if parent_ie is not None:
428
371
                versioned = directory.base_path in parent_ie.children
429
372
            else:
430
 
                # without the parent ie, use the relatively slower inventory
 
373
                # without the parent ie, use the relatively slower inventory 
431
374
                # probing method
432
 
                versioned = inv.has_filename(
433
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
375
                versioned = inv.has_filename(directory.raw_path)
434
376
 
435
377
            if kind == 'directory':
436
378
                try:
451
393
                # mutter("%r is already versioned", abspath)
452
394
            elif sub_tree:
453
395
                # XXX: This is wrong; people *might* reasonably be trying to add
454
 
                # subtrees as subtrees.  This should probably only be done in formats
 
396
                # subtrees as subtrees.  This should probably only be done in formats 
455
397
                # which can represent subtrees, and even then perhaps only when
456
398
                # the user asked to add subtrees.  At the moment you can add them
457
399
                # specially through 'join --reference', which is perhaps
467
409
                    # must be present:
468
410
                    this_ie = parent_ie.children[directory.base_path]
469
411
                else:
470
 
                    # without the parent ie, use the relatively slower inventory
 
412
                    # without the parent ie, use the relatively slower inventory 
471
413
                    # probing method
472
 
                    this_id = inv.path2id(
473
 
                            self._fix_case_of_inventory_path(directory.raw_path))
 
414
                    this_id = inv.path2id(directory.raw_path)
474
415
                    if this_id is None:
475
416
                        this_ie = None
476
417
                    else:
477
418
                        this_ie = inv[this_id]
478
419
 
479
420
                for subf in sorted(os.listdir(abspath)):
480
 
                    # here we could use TreeDirectory rather than
 
421
                    # here we could use TreeDirectory rather than 
481
422
                    # string concatenation.
482
423
                    subp = osutils.pathjoin(directory.raw_path, subf)
483
 
                    # TODO: is_control_filename is very slow. Make it faster.
484
 
                    # TreeDirectory.is_control_filename could also make this
485
 
                    # 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 
486
427
                    # control file.
487
428
                    if self.is_control_filename(subp):
488
429
                        mutter("skip control directory %r", subp)
508
449
                self.read_working_inventory()
509
450
        return added, ignored
510
451
 
511
 
    def update_basis_by_delta(self, new_revid, delta):
512
 
        """Update the parents of this tree after a commit.
513
 
 
514
 
        This gives the tree one parent, with revision id new_revid. The
515
 
        inventory delta is applied to the current basis tree to generate the
516
 
        inventory for the parent new_revid, and all other parent trees are
517
 
        discarded.
518
 
 
519
 
        All the changes in the delta should be changes synchronising the basis
520
 
        tree with some or all of the working tree, with a change to a directory
521
 
        requiring that its contents have been recursively included. That is,
522
 
        this is not a general purpose tree modification routine, but a helper
523
 
        for commit which is not required to handle situations that do not arise
524
 
        outside of commit.
525
 
 
526
 
        :param new_revid: The new revision id for the trees parent.
527
 
        :param delta: An inventory delta (see apply_inventory_delta) describing
528
 
            the changes from the current left most parent revision to new_revid.
529
 
        """
530
 
        # if the tree is updated by a pull to the branch, as happens in
531
 
        # WorkingTree2, when there was no separation between branch and tree,
532
 
        # then just clear merges, efficiency is not a concern for now as this
533
 
        # is legacy environments only, and they are slow regardless.
534
 
        if self.last_revision() == new_revid:
535
 
            self.set_parent_ids([new_revid])
536
 
            return
537
 
        # generic implementation based on Inventory manipulation. See
538
 
        # WorkingTree classes for optimised versions for specific format trees.
539
 
        basis = self.basis_tree()
540
 
        basis.lock_read()
541
 
        # TODO: Consider re-evaluating the need for this with CHKInventory
542
 
        # we don't strictly need to mutate an inventory for this
543
 
        # it only makes sense when apply_delta is cheaper than get_inventory()
544
 
        inventory = basis.inventory._get_mutable_inventory()
545
 
        basis.unlock()
546
 
        inventory.apply_delta(delta)
547
 
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
548
 
        self.set_parent_trees([(new_revid, rev_tree)])
549
 
 
550
 
 
551
 
class MutableTreeHooks(hooks.Hooks):
552
 
    """A dictionary mapping a hook name to a list of callables for mutabletree
553
 
    hooks.
554
 
    """
555
 
 
556
 
    def __init__(self):
557
 
        """Create the default hooks.
558
 
 
559
 
        """
560
 
        hooks.Hooks.__init__(self)
561
 
        self.create_hook(hooks.HookPoint('start_commit',
562
 
            "Called before a commit is performed on a tree. The start commit "
563
 
            "hook is able to change the tree before the commit takes place. "
564
 
            "start_commit is called with the bzrlib.tree.MutableTree that the "
565
 
            "commit is being performed on.", (1, 4), None))
566
 
 
567
 
 
568
 
# install the default hooks into the MutableTree class.
569
 
MutableTree.hooks = MutableTreeHooks()
570
 
 
571
452
 
572
453
class _FastPath(object):
573
454
    """A path object with fast accessors for things like basename."""
608
489
        added = []
609
490
    else:
610
491
        # slower but does not need parent_ie
611
 
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
 
492
        if inv.has_filename(path.raw_path):
612
493
            return []
613
494
        # its really not there : add the parent
614
495
        # note that the dirname use leads to some extra str copying etc but as