/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/workingtree.py

  • Committer: Jelmer Vernooij
  • Date: 2011-05-03 23:54:46 UTC
  • mto: This revision was merged to the branch mainline in revision 5830.
  • Revision ID: jelmer@samba.org-20110503235446-1rsduyaabkjz8hha
Move WorkingTree3 to bzrlib.workingtree_3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
78
78
from bzrlib import symbol_versioning
79
79
from bzrlib.decorators import needs_read_lock, needs_write_lock
80
80
from bzrlib.lock import LogicalLockResult
81
 
from bzrlib.lockable_files import LockableFiles
82
 
from bzrlib.lockdir import LockDir
83
81
import bzrlib.mutabletree
84
82
from bzrlib.mutabletree import needs_tree_write_lock
85
83
from bzrlib import osutils
94
92
    supports_executable,
95
93
    )
96
94
from bzrlib.trace import mutter, note
97
 
from bzrlib.transport.local import LocalTransport
98
95
from bzrlib.revision import CURRENT_REVISION
99
96
from bzrlib.symbol_versioning import (
100
97
    deprecated_passed,
2020
2017
        inventory.revision_id = revision_id
2021
2018
        return xml7.serializer_v7.write_inventory_to_string(inventory)
2022
2019
 
 
2020
    @needs_tree_write_lock
 
2021
    def set_conflicts(self, conflicts):
 
2022
        self._put_rio('conflicts', conflicts.to_stanzas(),
 
2023
                      CONFLICT_HEADER_1)
 
2024
 
 
2025
    @needs_tree_write_lock
 
2026
    def add_conflicts(self, new_conflicts):
 
2027
        conflict_set = set(self.conflicts())
 
2028
        conflict_set.update(set(list(new_conflicts)))
 
2029
        self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
 
2030
                                       key=_mod_conflicts.Conflict.sort_key)))
 
2031
 
 
2032
    @needs_read_lock
 
2033
    def conflicts(self):
 
2034
        try:
 
2035
            confile = self._transport.get('conflicts')
 
2036
        except errors.NoSuchFile:
 
2037
            return _mod_conflicts.ConflictList()
 
2038
        try:
 
2039
            try:
 
2040
                if confile.next() != CONFLICT_HEADER_1 + '\n':
 
2041
                    raise errors.ConflictFormatError()
 
2042
            except StopIteration:
 
2043
                raise errors.ConflictFormatError()
 
2044
            reader = _mod_rio.RioReader(confile)
 
2045
            return _mod_conflicts.ConflictList.from_stanzas(reader)
 
2046
        finally:
 
2047
            confile.close()
 
2048
 
2023
2049
    def read_basis_inventory(self):
2024
2050
        """Read the cached basis inventory."""
2025
2051
        path = self._basis_inventory_name()
2888
2914
                    pending.append(dir)
2889
2915
 
2890
2916
 
2891
 
class WorkingTree3(InventoryWorkingTree):
2892
 
    """This is the Format 3 working tree.
2893
 
 
2894
 
    This differs from the base WorkingTree by:
2895
 
     - having its own file lock
2896
 
     - having its own last-revision property.
2897
 
 
2898
 
    This is new in bzr 0.8
2899
 
    """
2900
 
 
2901
 
    @needs_read_lock
2902
 
    def _last_revision(self):
2903
 
        """See Mutable.last_revision."""
2904
 
        try:
2905
 
            return self._transport.get_bytes('last-revision')
2906
 
        except errors.NoSuchFile:
2907
 
            return _mod_revision.NULL_REVISION
2908
 
 
2909
 
    def _change_last_revision(self, revision_id):
2910
 
        """See WorkingTree._change_last_revision."""
2911
 
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2912
 
            try:
2913
 
                self._transport.delete('last-revision')
2914
 
            except errors.NoSuchFile:
2915
 
                pass
2916
 
            return False
2917
 
        else:
2918
 
            self._transport.put_bytes('last-revision', revision_id,
2919
 
                mode=self.bzrdir._get_file_mode())
2920
 
            return True
2921
 
 
2922
 
    def _get_check_refs(self):
2923
 
        """Return the references needed to perform a check of this tree."""
2924
 
        return [('trees', self.last_revision())]
2925
 
 
2926
 
    @needs_tree_write_lock
2927
 
    def set_conflicts(self, conflicts):
2928
 
        self._put_rio('conflicts', conflicts.to_stanzas(),
2929
 
                      CONFLICT_HEADER_1)
2930
 
 
2931
 
    @needs_tree_write_lock
2932
 
    def add_conflicts(self, new_conflicts):
2933
 
        conflict_set = set(self.conflicts())
2934
 
        conflict_set.update(set(list(new_conflicts)))
2935
 
        self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
2936
 
                                       key=_mod_conflicts.Conflict.sort_key)))
2937
 
 
2938
 
    @needs_read_lock
2939
 
    def conflicts(self):
2940
 
        try:
2941
 
            confile = self._transport.get('conflicts')
2942
 
        except errors.NoSuchFile:
2943
 
            return _mod_conflicts.ConflictList()
2944
 
        try:
2945
 
            try:
2946
 
                if confile.next() != CONFLICT_HEADER_1 + '\n':
2947
 
                    raise errors.ConflictFormatError()
2948
 
            except StopIteration:
2949
 
                raise errors.ConflictFormatError()
2950
 
            reader = _mod_rio.RioReader(confile)
2951
 
            return _mod_conflicts.ConflictList.from_stanzas(reader)
2952
 
        finally:
2953
 
            confile.close()
2954
 
 
2955
 
    def unlock(self):
2956
 
        # do non-implementation specific cleanup
2957
 
        self._cleanup()
2958
 
        if self._control_files._lock_count == 1:
2959
 
            # _inventory_is_modified is always False during a read lock.
2960
 
            if self._inventory_is_modified:
2961
 
                self.flush()
2962
 
            self._write_hashcache_if_dirty()
2963
 
        # reverse order of locking.
2964
 
        try:
2965
 
            return self._control_files.unlock()
2966
 
        finally:
2967
 
            self.branch.unlock()
2968
 
 
2969
 
 
2970
2917
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2971
2918
    """Registry for working tree formats."""
2972
2919
 
3119
3066
        format_registry.remove(format)
3120
3067
 
3121
3068
 
3122
 
class WorkingTreeFormat3(WorkingTreeFormat):
3123
 
    """The second working tree format updated to record a format marker.
3124
 
 
3125
 
    This format:
3126
 
        - exists within a metadir controlling .bzr
3127
 
        - includes an explicit version marker for the workingtree control
3128
 
          files, separate from the BzrDir format
3129
 
        - modifies the hash cache format
3130
 
        - is new in bzr 0.8
3131
 
        - uses a LockDir to guard access for writes.
3132
 
    """
3133
 
 
3134
 
    upgrade_recommended = True
3135
 
 
3136
 
    missing_parent_conflicts = True
3137
 
 
3138
 
    def get_format_string(self):
3139
 
        """See WorkingTreeFormat.get_format_string()."""
3140
 
        return "Bazaar-NG Working Tree format 3"
3141
 
 
3142
 
    def get_format_description(self):
3143
 
        """See WorkingTreeFormat.get_format_description()."""
3144
 
        return "Working tree format 3"
3145
 
 
3146
 
    _lock_file_name = 'lock'
3147
 
    _lock_class = LockDir
3148
 
 
3149
 
    _tree_class = WorkingTree3
3150
 
 
3151
 
    def __get_matchingbzrdir(self):
3152
 
        return bzrdir.BzrDirMetaFormat1()
3153
 
 
3154
 
    _matchingbzrdir = property(__get_matchingbzrdir)
3155
 
 
3156
 
    def _open_control_files(self, a_bzrdir):
3157
 
        transport = a_bzrdir.get_workingtree_transport(None)
3158
 
        return LockableFiles(transport, self._lock_file_name,
3159
 
                             self._lock_class)
3160
 
 
3161
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3162
 
                   accelerator_tree=None, hardlink=False):
3163
 
        """See WorkingTreeFormat.initialize().
3164
 
 
3165
 
        :param revision_id: if supplied, create a working tree at a different
3166
 
            revision than the branch is at.
3167
 
        :param accelerator_tree: A tree which can be used for retrieving file
3168
 
            contents more quickly than the revision tree, i.e. a workingtree.
3169
 
            The revision tree will be used for cases where accelerator_tree's
3170
 
            content is different.
3171
 
        :param hardlink: If true, hard-link files from accelerator_tree,
3172
 
            where possible.
3173
 
        """
3174
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
3175
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
3176
 
        transport = a_bzrdir.get_workingtree_transport(self)
3177
 
        control_files = self._open_control_files(a_bzrdir)
3178
 
        control_files.create_lock()
3179
 
        control_files.lock_write()
3180
 
        transport.put_bytes('format', self.get_format_string(),
3181
 
            mode=a_bzrdir._get_file_mode())
3182
 
        if from_branch is not None:
3183
 
            branch = from_branch
3184
 
        else:
3185
 
            branch = a_bzrdir.open_branch()
3186
 
        if revision_id is None:
3187
 
            revision_id = _mod_revision.ensure_null(branch.last_revision())
3188
 
        # WorkingTree3 can handle an inventory which has a unique root id.
3189
 
        # as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
3190
 
        # those trees. And because there isn't a format bump inbetween, we
3191
 
        # are maintaining compatibility with older clients.
3192
 
        # inv = Inventory(root_id=gen_root_id())
3193
 
        inv = self._initial_inventory()
3194
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3195
 
                         branch,
3196
 
                         inv,
3197
 
                         _internal=True,
3198
 
                         _format=self,
3199
 
                         _bzrdir=a_bzrdir,
3200
 
                         _control_files=control_files)
3201
 
        wt.lock_tree_write()
3202
 
        try:
3203
 
            basis_tree = branch.repository.revision_tree(revision_id)
3204
 
            # only set an explicit root id if there is one to set.
3205
 
            if basis_tree.inventory.root is not None:
3206
 
                wt.set_root_id(basis_tree.get_root_id())
3207
 
            if revision_id == _mod_revision.NULL_REVISION:
3208
 
                wt.set_parent_trees([])
3209
 
            else:
3210
 
                wt.set_parent_trees([(revision_id, basis_tree)])
3211
 
            transform.build_tree(basis_tree, wt)
3212
 
        finally:
3213
 
            # Unlock in this order so that the unlock-triggers-flush in
3214
 
            # WorkingTree is given a chance to fire.
3215
 
            control_files.unlock()
3216
 
            wt.unlock()
3217
 
        return wt
3218
 
 
3219
 
    def _initial_inventory(self):
3220
 
        return inventory.Inventory()
3221
 
 
3222
 
    def __init__(self):
3223
 
        super(WorkingTreeFormat3, self).__init__()
3224
 
 
3225
 
    def open(self, a_bzrdir, _found=False):
3226
 
        """Return the WorkingTree object for a_bzrdir
3227
 
 
3228
 
        _found is a private parameter, do not use it. It is used to indicate
3229
 
               if format probing has already been done.
3230
 
        """
3231
 
        if not _found:
3232
 
            # we are being called directly and must probe.
3233
 
            raise NotImplementedError
3234
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
3235
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
3236
 
        wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3237
 
        return wt
3238
 
 
3239
 
    def _open(self, a_bzrdir, control_files):
3240
 
        """Open the tree itself.
3241
 
 
3242
 
        :param a_bzrdir: the dir for the tree.
3243
 
        :param control_files: the control files for the tree.
3244
 
        """
3245
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3246
 
                                _internal=True,
3247
 
                                _format=self,
3248
 
                                _bzrdir=a_bzrdir,
3249
 
                                _control_files=control_files)
3250
 
 
3251
 
    def __str__(self):
3252
 
        return self.get_format_string()
3253
 
 
3254
 
 
3255
3069
__default_format = WorkingTreeFormat6()
3256
3070
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3257
3071
    "bzrlib.workingtree_4", "WorkingTreeFormat4")
3259
3073
    "bzrlib.workingtree_4", "WorkingTreeFormat5")
3260
3074
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3261
3075
    "bzrlib.workingtree_4", "WorkingTreeFormat6")
3262
 
format_registry.register(WorkingTreeFormat3())
 
3076
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
 
3077
    "bzrlib.workingtree_3", "WorkingTreeFormat3")
3263
3078
format_registry.set_default(__default_format)