758
750
self._set_merges_from_parent_ids(revision_ids)
760
752
@needs_tree_write_lock
761
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
762
"""See MutableTree.set_parent_trees."""
763
parent_ids = [rev for (rev, tree) in parents_list]
764
for revision_id in parent_ids:
765
_mod_revision.check_not_reserved_id(revision_id)
767
self._check_parents_for_ghosts(parent_ids,
768
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
770
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
772
if len(parent_ids) == 0:
773
leftmost_parent_id = _mod_revision.NULL_REVISION
774
leftmost_parent_tree = None
776
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
778
if self._change_last_revision(leftmost_parent_id):
779
if leftmost_parent_tree is None:
780
# If we don't have a tree, fall back to reading the
781
# parent tree from the repository.
782
self._cache_basis_inventory(leftmost_parent_id)
784
inv = leftmost_parent_tree.inventory
785
xml = self._create_basis_xml_from_inventory(
786
leftmost_parent_id, inv)
787
self._write_basis_inventory(xml)
788
self._set_merges_from_parent_ids(parent_ids)
790
@needs_tree_write_lock
791
753
def set_pending_merges(self, rev_list):
792
754
parents = self.get_parent_ids()
793
755
leftmost = parents[:1]
1985
1947
"""See Tree.iter_all_file_ids"""
1986
1948
return set(self.inventory)
1950
@needs_tree_write_lock
1951
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1952
"""See MutableTree.set_parent_trees."""
1953
parent_ids = [rev for (rev, tree) in parents_list]
1954
for revision_id in parent_ids:
1955
_mod_revision.check_not_reserved_id(revision_id)
1957
self._check_parents_for_ghosts(parent_ids,
1958
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
1960
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
1962
if len(parent_ids) == 0:
1963
leftmost_parent_id = _mod_revision.NULL_REVISION
1964
leftmost_parent_tree = None
1966
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
1968
if self._change_last_revision(leftmost_parent_id):
1969
if leftmost_parent_tree is None:
1970
# If we don't have a tree, fall back to reading the
1971
# parent tree from the repository.
1972
self._cache_basis_inventory(leftmost_parent_id)
1974
inv = leftmost_parent_tree.inventory
1975
xml = self._create_basis_xml_from_inventory(
1976
leftmost_parent_id, inv)
1977
self._write_basis_inventory(xml)
1978
self._set_merges_from_parent_ids(parent_ids)
1988
1980
def _cache_basis_inventory(self, new_revision):
1989
1981
"""Cache new_revision as the basis inventory."""
1990
1982
# TODO: this should allow the ready-to-use inventory to be passed in,
2020
2012
inventory.revision_id = revision_id
2021
2013
return xml7.serializer_v7.write_inventory_to_string(inventory)
2015
@needs_tree_write_lock
2016
def set_conflicts(self, conflicts):
2017
self._put_rio('conflicts', conflicts.to_stanzas(),
2020
@needs_tree_write_lock
2021
def add_conflicts(self, new_conflicts):
2022
conflict_set = set(self.conflicts())
2023
conflict_set.update(set(list(new_conflicts)))
2024
self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
2025
key=_mod_conflicts.Conflict.sort_key)))
2028
def conflicts(self):
2030
confile = self._transport.get('conflicts')
2031
except errors.NoSuchFile:
2032
return _mod_conflicts.ConflictList()
2035
if confile.next() != CONFLICT_HEADER_1 + '\n':
2036
raise errors.ConflictFormatError()
2037
except StopIteration:
2038
raise errors.ConflictFormatError()
2039
reader = _mod_rio.RioReader(confile)
2040
return _mod_conflicts.ConflictList.from_stanzas(reader)
2023
2044
def read_basis_inventory(self):
2024
2045
"""Read the cached basis inventory."""
2025
2046
path = self._basis_inventory_name()
2888
2909
pending.append(dir)
2891
class WorkingTree3(InventoryWorkingTree):
2892
"""This is the Format 3 working tree.
2894
This differs from the base WorkingTree by:
2895
- having its own file lock
2896
- having its own last-revision property.
2898
This is new in bzr 0.8
2902
def _last_revision(self):
2903
"""See Mutable.last_revision."""
2905
return self._transport.get_bytes('last-revision')
2906
except errors.NoSuchFile:
2907
return _mod_revision.NULL_REVISION
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:
2913
self._transport.delete('last-revision')
2914
except errors.NoSuchFile:
2918
self._transport.put_bytes('last-revision', revision_id,
2919
mode=self.bzrdir._get_file_mode())
2922
def _get_check_refs(self):
2923
"""Return the references needed to perform a check of this tree."""
2924
return [('trees', self.last_revision())]
2926
@needs_tree_write_lock
2927
def set_conflicts(self, conflicts):
2928
self._put_rio('conflicts', conflicts.to_stanzas(),
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)))
2939
def conflicts(self):
2941
confile = self._transport.get('conflicts')
2942
except errors.NoSuchFile:
2943
return _mod_conflicts.ConflictList()
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)
2956
# do non-implementation specific 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:
2962
self._write_hashcache_if_dirty()
2963
# reverse order of locking.
2965
return self._control_files.unlock()
2967
self.branch.unlock()
2970
2912
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2971
2913
"""Registry for working tree formats."""
2973
2915
def __init__(self, other_registry=None):
2974
2916
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2975
2917
self._default_format = None
2918
self._default_format_key = None
2977
2920
def get_default(self):
2978
2921
"""Return the current default format."""
2922
if (self._default_format_key is not None and
2923
self._default_format is None):
2924
self._default_format = self.get(self._default_format_key)
2979
2925
return self._default_format
2981
2927
def set_default(self, format):
2928
"""Set the default format."""
2982
2929
self._default_format = format
2930
self._default_format_key = None
2932
def set_default_key(self, format_string):
2933
"""Set the default format by its format string."""
2934
self._default_format_key = format_string
2935
self._default_format = None
2985
2938
format_registry = WorkingTreeFormatRegistry()
3119
3078
format_registry.remove(format)
3122
class WorkingTreeFormat3(WorkingTreeFormat):
3123
"""The second working tree format updated to record a format marker.
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
3131
- uses a LockDir to guard access for writes.
3134
upgrade_recommended = True
3136
missing_parent_conflicts = True
3138
def get_format_string(self):
3139
"""See WorkingTreeFormat.get_format_string()."""
3140
return "Bazaar-NG Working Tree format 3"
3142
def get_format_description(self):
3143
"""See WorkingTreeFormat.get_format_description()."""
3144
return "Working tree format 3"
3146
_lock_file_name = 'lock'
3147
_lock_class = LockDir
3149
_tree_class = WorkingTree3
3151
def __get_matchingbzrdir(self):
3152
return bzrdir.BzrDirMetaFormat1()
3154
_matchingbzrdir = property(__get_matchingbzrdir)
3156
def _open_control_files(self, a_bzrdir):
3157
transport = a_bzrdir.get_workingtree_transport(None)
3158
return LockableFiles(transport, self._lock_file_name,
3161
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3162
accelerator_tree=None, hardlink=False):
3163
"""See WorkingTreeFormat.initialize().
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,
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
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('.'),
3200
_control_files=control_files)
3201
wt.lock_tree_write()
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([])
3210
wt.set_parent_trees([(revision_id, basis_tree)])
3211
transform.build_tree(basis_tree, wt)
3213
# Unlock in this order so that the unlock-triggers-flush in
3214
# WorkingTree is given a chance to fire.
3215
control_files.unlock()
3219
def _initial_inventory(self):
3220
return inventory.Inventory()
3223
super(WorkingTreeFormat3, self).__init__()
3225
def open(self, a_bzrdir, _found=False):
3226
"""Return the WorkingTree object for a_bzrdir
3228
_found is a private parameter, do not use it. It is used to indicate
3229
if format probing has already been done.
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))
3239
def _open(self, a_bzrdir, control_files):
3240
"""Open the tree itself.
3242
:param a_bzrdir: the dir for the tree.
3243
:param control_files: the control files for the tree.
3245
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3249
_control_files=control_files)
3252
return self.get_format_string()
3255
__default_format = WorkingTreeFormat6()
3256
3081
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3257
3082
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3258
3083
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3259
3084
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3260
3085
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3261
3086
"bzrlib.workingtree_4", "WorkingTreeFormat6")
3262
format_registry.register(WorkingTreeFormat3())
3263
format_registry.set_default(__default_format)
3087
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
3088
"bzrlib.workingtree_3", "WorkingTreeFormat3")
3089
format_registry.set_default_key("Bazaar Working Tree Format 6 (bzr 1.14)\n")
added
removed
bzrlib/workingtree.py
