~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Martin Pool
  • Date: 2009-07-27 06:28:35 UTC
  • mto: This revision was merged to the branch mainline in revision 4587.
  • Revision ID: mbp@sourcefrog.net-20090727062835-o66p8it658tq1sma
Add CountedLock.get_physical_lock_status

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""MutableTree object.
18
18
 
28
28
    add,
29
29
    bzrdir,
30
30
    hooks,
 
31
    symbol_versioning,
31
32
    )
32
33
from bzrlib.osutils import dirname
33
34
from bzrlib.revisiontree import RevisionTree
41
42
    )
42
43
from bzrlib.decorators import needs_read_lock, needs_write_lock
43
44
from bzrlib.osutils import splitpath
44
 
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
45
45
 
46
46
 
47
47
def needs_tree_write_lock(unbound):
69
69
    entirely in memory.
70
70
 
71
71
    For now, we are not treating MutableTree as an interface to provide
72
 
    conformance tests for - rather we are testing MemoryTree specifically, and 
 
72
    conformance tests for - rather we are testing MemoryTree specifically, and
73
73
    interface testing implementations of WorkingTree.
74
74
 
75
75
    A mutable tree always has an associated Branch and BzrDir object - the
130
130
            if self.is_control_filename(f):
131
131
                raise errors.ForbiddenControlFileError(filename=f)
132
132
            fp = splitpath(f)
133
 
        # fill out file kinds for all files [not needed when we stop 
 
133
        # fill out file kinds for all files [not needed when we stop
134
134
        # caring about the instantaneous file kind within a uncommmitted tree
135
135
        #
136
136
        self._gather_kinds(files, kinds)
192
192
            revprops['branch-nick'] = self.branch._get_nick(
193
193
                kwargs.get('local', False),
194
194
                possible_master_transports)
 
195
        authors = kwargs.pop('authors', None)
195
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)
196
210
        if author is not None:
197
 
            if 'author' in revprops:
 
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:
198
215
                # XXX: maybe we should just accept one of them?
199
216
                raise AssertionError('author property given twice')
200
 
            revprops['author'] = author
 
217
            if '\n' in author:
 
218
                raise AssertionError('\\n is not a valid character '
 
219
                        'in an author identity')
 
220
            revprops['authors'] = author
201
221
        # args for wt.commit start at message from the Commit.commit method,
202
222
        args = (message, ) + args
203
223
        for hook in MutableTree.hooks['start_commit']:
212
232
        """Helper function for add - sets the entries of kinds."""
213
233
        raise NotImplementedError(self._gather_kinds)
214
234
 
215
 
    def get_file_with_stat(self, file_id, path=None):
216
 
        """Get a file handle and stat object for file_id.
217
 
 
218
 
        The default implementation returns (self.get_file, None) for backwards
219
 
        compatibility.
220
 
 
221
 
        :param file_id: The file id to read.
222
 
        :param path: The path of the file, if it is known.
223
 
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
224
 
            no stat facility, or need for a stat cache feedback during commit,
225
 
            it may return None for the second element of the tuple.
 
235
    @needs_read_lock
 
236
    def has_changes(self, from_tree):
 
237
        """Quickly check that the tree contains at least one change.
 
238
 
 
239
        :return: True if a change is found. False otherwise
226
240
        """
227
 
        return (self.get_file(file_id, path), None)
 
241
        changes = self.iter_changes(from_tree)
 
242
        try:
 
243
            change = changes.next()
 
244
            # Exclude root (talk about black magic... --vila 20090629)
 
245
            if change[4] == (None, None):
 
246
                change = changes.next()
 
247
            return True
 
248
        except StopIteration:
 
249
            # No changes
 
250
            return False
228
251
 
229
252
    @needs_read_lock
230
253
    def last_revision(self):
233
256
        In early tree formats the result of last_revision is the same as the
234
257
        branch last_revision, but that is no longer the case for modern tree
235
258
        formats.
236
 
        
 
259
 
237
260
        last_revision returns the left most parent id, or None if there are no
238
261
        parents.
239
262
 
256
279
    def lock_write(self):
257
280
        """Lock the tree and its branch. This allows mutating calls to be made.
258
281
 
259
 
        Some mutating methods will take out implicit write locks, but in 
 
282
        Some mutating methods will take out implicit write locks, but in
260
283
        general you should always obtain a write lock before calling mutating
261
284
        methods on a tree.
262
285
        """
278
301
        The intent of this function is to allow trees that have a hashcache to
279
302
        update the hashcache during commit. If the observed file is too new
280
303
        (based on the stat_value) to be safely hash-cached the tree will ignore
281
 
        it. 
 
304
        it.
282
305
 
283
306
        The default implementation does nothing.
284
307
 
298
321
    @needs_write_lock
299
322
    def put_file_bytes_non_atomic(self, file_id, bytes):
300
323
        """Update the content of a file in the tree.
301
 
        
 
324
 
302
325
        Note that the file is written in-place rather than being
303
326
        written to a temporary location and renamed. As a consequence,
304
327
        readers can potentially see the file half-written.
318
341
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
319
342
        """Set the parents of the working tree.
320
343
 
321
 
        :param parents_list: A list of (revision_id, tree) tuples. 
 
344
        :param parents_list: A list of (revision_id, tree) tuples.
322
345
            If tree is None, then that element is treated as an unreachable
323
346
            parent tree - i.e. a ghost.
324
347
        """
332
355
        For the specific behaviour see the help for cmd_add().
333
356
 
334
357
        :param action: A reporter to be called with the inventory, parent_ie,
335
 
            path and kind of the path being added. It may return a file_id if 
 
358
            path and kind of the path being added. It may return a file_id if
336
359
            a specific one should be used.
337
360
        :param save: Save the inventory after completing the adds. If False
338
361
            this provides dry-run functionality by doing the add and not saving
346
369
        from bzrlib.inventory import InventoryEntry
347
370
        if action is None:
348
371
            action = add.AddAction()
349
 
        
 
372
 
350
373
        if not file_list:
351
374
            # no paths supplied: add the entire tree.
352
375
            file_list = [u'.']
357
380
        dirs_to_add = []
358
381
        user_dirs = set()
359
382
 
360
 
        # validate user file paths and convert all paths to tree 
 
383
        # validate user file paths and convert all paths to tree
361
384
        # relative : it's cheaper to make a tree relative path an abspath
362
385
        # than to convert an abspath to tree relative, and it's cheaper to
363
386
        # perform the canonicalization in bulk.
364
387
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
365
388
            rf = _FastPath(filepath)
366
389
            # validate user parameters. Our recursive code avoids adding new files
367
 
            # that need such validation 
 
390
            # that need such validation
368
391
            if self.is_control_filename(rf.raw_path):
369
392
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
370
 
            
 
393
 
371
394
            abspath = self.abspath(rf.raw_path)
372
395
            kind = osutils.file_kind(abspath)
373
396
            if kind == 'directory':
378
401
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
379
402
            # ensure the named path is added, so that ignore rules in the later directory
380
403
            # walk dont skip it.
381
 
            # we dont have a parent ie known yet.: use the relatively slower inventory 
 
404
            # we dont have a parent ie known yet.: use the relatively slower inventory
382
405
            # probing method
383
406
            versioned = inv.has_filename(rf.raw_path)
384
407
            if versioned:
421
444
            if parent_ie is not None:
422
445
                versioned = directory.base_path in parent_ie.children
423
446
            else:
424
 
                # without the parent ie, use the relatively slower inventory 
 
447
                # without the parent ie, use the relatively slower inventory
425
448
                # probing method
426
449
                versioned = inv.has_filename(
427
450
                        self._fix_case_of_inventory_path(directory.raw_path))
445
468
                # mutter("%r is already versioned", abspath)
446
469
            elif sub_tree:
447
470
                # XXX: This is wrong; people *might* reasonably be trying to add
448
 
                # subtrees as subtrees.  This should probably only be done in formats 
 
471
                # subtrees as subtrees.  This should probably only be done in formats
449
472
                # which can represent subtrees, and even then perhaps only when
450
473
                # the user asked to add subtrees.  At the moment you can add them
451
474
                # specially through 'join --reference', which is perhaps
461
484
                    # must be present:
462
485
                    this_ie = parent_ie.children[directory.base_path]
463
486
                else:
464
 
                    # without the parent ie, use the relatively slower inventory 
 
487
                    # without the parent ie, use the relatively slower inventory
465
488
                    # probing method
466
489
                    this_id = inv.path2id(
467
490
                            self._fix_case_of_inventory_path(directory.raw_path))
471
494
                        this_ie = inv[this_id]
472
495
 
473
496
                for subf in sorted(os.listdir(abspath)):
474
 
                    # here we could use TreeDirectory rather than 
 
497
                    # here we could use TreeDirectory rather than
475
498
                    # string concatenation.
476
499
                    subp = osutils.pathjoin(directory.raw_path, subf)
477
 
                    # TODO: is_control_filename is very slow. Make it faster. 
478
 
                    # TreeDirectory.is_control_filename could also make this 
479
 
                    # faster - its impossible for a non root dir to have a 
 
500
                    # TODO: is_control_filename is very slow. Make it faster.
 
501
                    # TreeDirectory.is_control_filename could also make this
 
502
                    # faster - its impossible for a non root dir to have a
480
503
                    # control file.
481
504
                    if self.is_control_filename(subp):
482
505
                        mutter("skip control directory %r", subp)
517
540
        for commit which is not required to handle situations that do not arise
518
541
        outside of commit.
519
542
 
 
543
        See the inventory developers documentation for the theory behind
 
544
        inventory deltas.
 
545
 
520
546
        :param new_revid: The new revision id for the trees parent.
521
547
        :param delta: An inventory delta (see apply_inventory_delta) describing
522
548
            the changes from the current left most parent revision to new_revid.
532
558
        # WorkingTree classes for optimised versions for specific format trees.
533
559
        basis = self.basis_tree()
534
560
        basis.lock_read()
535
 
        inventory = basis.inventory
 
561
        # TODO: Consider re-evaluating the need for this with CHKInventory
 
562
        # we don't strictly need to mutate an inventory for this
 
563
        # it only makes sense when apply_delta is cheaper than get_inventory()
 
564
        inventory = basis.inventory._get_mutable_inventory()
536
565
        basis.unlock()
537
566
        inventory.apply_delta(delta)
538
567
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
540
569
 
541
570
 
542
571
class MutableTreeHooks(hooks.Hooks):
543
 
    """A dictionary mapping a hook name to a list of callables for mutabletree 
 
572
    """A dictionary mapping a hook name to a list of callables for mutabletree
544
573
    hooks.
545
574
    """
546
575
 
549
578
 
550
579
        """
551
580
        hooks.Hooks.__init__(self)
552
 
        # Invoked before a commit is done in a tree. New in 1.4
553
 
        self['start_commit'] = []
 
581
        self.create_hook(hooks.HookPoint('start_commit',
 
582
            "Called before a commit is performed on a tree. The start commit "
 
583
            "hook is able to change the tree before the commit takes place. "
 
584
            "start_commit is called with the bzrlib.tree.MutableTree that the "
 
585
            "commit is being performed on.", (1, 4), None))
554
586
 
555
587
 
556
588
# install the default hooks into the MutableTree class.