← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2010-07-04 06:22:11 UTC
  • mto: This revision was merged to the branch mainline in revision 5332.
  • Revision ID: robertc@robertcollins.net-20100704062211-tk9hw6bnsn5x47fm
``bzrlib.lsprof.profile`` will no longer silently generate bad threaded
profiles when concurrent profile requests are made. Instead the profile
requests will be serialised. Reentrant requests will now deadlock.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
61
61
    revisiontree,
62
62
    trace,
63
63
    transform,
 
64
    transport,
64
65
    ui,
65
66
    views,
66
67
    xml5,
67
68
    xml7,
68
69
    )
69
 
import bzrlib.branch
70
 
from bzrlib.transport import get_transport
71
70
from bzrlib.workingtree_4 import (
72
71
    WorkingTreeFormat4,
73
72
    WorkingTreeFormat5,
77
76
 
78
77
from bzrlib import symbol_versioning
79
78
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
79
from bzrlib.lock import LogicalLockResult
80
80
from bzrlib.lockable_files import LockableFiles
81
81
from bzrlib.lockdir import LockDir
82
82
import bzrlib.mutabletree
368
368
                return True, None
369
369
            else:
370
370
                return True, tree
371
 
        transport = get_transport(location)
372
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
371
        t = transport.get_transport(location)
 
372
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
373
373
                                              list_current=list_current)
374
 
        return [t for t in iterator if t is not None]
 
374
        return [tr for tr in iterator if tr is not None]
375
375
 
376
376
    # should be deprecated - this is slow and in any case treating them as a
377
377
    # container is (we now know) bad style -- mbp 20070302
462
462
        return (file_obj, stat_value)
463
463
 
464
464
    def get_file_text(self, file_id, path=None, filtered=True):
465
 
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
465
        my_file = self.get_file(file_id, path=path, filtered=filtered)
 
466
        try:
 
467
            return my_file.read()
 
468
        finally:
 
469
            my_file.close()
466
470
 
467
471
    def get_file_byname(self, filename, filtered=True):
468
472
        path = self.abspath(filename)
522
526
 
523
527
        # Now we have the parents of this content
524
528
        annotator = self.branch.repository.texts.get_annotator()
525
 
        text = self.get_file(file_id).read()
 
529
        text = self.get_file_text(file_id)
526
530
        this_key =(file_id, default_revision)
527
531
        annotator.add_special_text(this_key, file_parent_keys, text)
528
532
        annotations = [(key[-1], line)
1798
1802
            raise errors.ObjectNotLocked(self)
1799
1803
 
1800
1804
    def lock_read(self):
1801
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1805
        """Lock the tree for reading.
 
1806
 
 
1807
        This also locks the branch, and can be unlocked via self.unlock().
 
1808
 
 
1809
        :return: A bzrlib.lock.LogicalLockResult.
 
1810
        """
1802
1811
        if not self.is_locked():
1803
1812
            self._reset_data()
1804
1813
        self.branch.lock_read()
1805
1814
        try:
1806
 
            return self._control_files.lock_read()
 
1815
            self._control_files.lock_read()
 
1816
            return LogicalLockResult(self.unlock)
1807
1817
        except:
1808
1818
            self.branch.unlock()
1809
1819
            raise
1810
1820
 
1811
1821
    def lock_tree_write(self):
1812
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
1822
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
1823
 
 
1824
        :return: A bzrlib.lock.LogicalLockResult.
 
1825
        """
1813
1826
        if not self.is_locked():
1814
1827
            self._reset_data()
1815
1828
        self.branch.lock_read()
1816
1829
        try:
1817
 
            return self._control_files.lock_write()
 
1830
            self._control_files.lock_write()
 
1831
            return LogicalLockResult(self.unlock)
1818
1832
        except:
1819
1833
            self.branch.unlock()
1820
1834
            raise
1821
1835
 
1822
1836
    def lock_write(self):
1823
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1837
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1838
 
 
1839
        :return: A bzrlib.lock.LogicalLockResult.
 
1840
        """
1824
1841
        if not self.is_locked():
1825
1842
            self._reset_data()
1826
1843
        self.branch.lock_write()
1827
1844
        try:
1828
 
            return self._control_files.lock_write()
 
1845
            self._control_files.lock_write()
 
1846
            return LogicalLockResult(self.unlock)
1829
1847
        except:
1830
1848
            self.branch.unlock()
1831
1849
            raise
1956
1974
        def recurse_directory_to_add_files(directory):
1957
1975
            # Recurse directory and add all files
1958
1976
            # so we can check if they have changed.
1959
 
            for parent_info, file_infos in\
1960
 
                self.walkdirs(directory):
 
1977
            for parent_info, file_infos in self.walkdirs(directory):
1961
1978
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1962
1979
                    # Is it versioned or ignored?
1963
1980
                    if self.path2id(relpath) or self.is_ignored(relpath):
1998
2015
                            # ... but not ignored
1999
2016
                            has_changed_files = True
2000
2017
                            break
2001
 
                    elif content_change and (kind[1] is not None):
2002
 
                        # Versioned and changed, but not deleted
 
2018
                    elif (content_change and (kind[1] is not None) and
 
2019
                            osutils.is_inside_any(files, path[1])):
 
2020
                        # Versioned and changed, but not deleted, and still
 
2021
                        # in one of the dirs to be deleted.
2003
2022
                        has_changed_files = True
2004
2023
                        break
2005
2024
 
2636
2655
 
2637
2656
        In Format2 WorkingTrees we have a single lock for the branch and tree
2638
2657
        so lock_tree_write() degrades to lock_write().
 
2658
 
 
2659
        :return: An object with an unlock method which will release the lock
 
2660
            obtained.
2639
2661
        """
2640
2662
        self.branch.lock_write()
2641
2663
        try:
2642
 
            return self._control_files.lock_write()
 
2664
            self._control_files.lock_write()
 
2665
            return self
2643
2666
        except:
2644
2667
            self.branch.unlock()
2645
2668
            raise