« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 5652.1.6
- compare with another revision
- download diff
- download tarball
- view history from revision 5652.1.6
- Committer: Vincent Ladeuil
- Date: 2011-02-10 12:37:27 UTC
- mto: This revision was merged to the branch mainline in revision 5661.
- Revision ID: v.ladeuil+lp@free.fr-20110210123727-8e0pu4wtlt6fj7nf
thread is already a python module, avoid confusion and use cethread instead.
- files added:
- bzrlib/deprecated_graph.py
- files removed:
- bzrlib/estimate_compressed_size.py
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/weave_fmt
- bzrlib/plugins/weave_fmt/tests
- bzrlib/tests/per_repository_vf
- po
- files renamed:
- bzrlib/plugins/weave_fmt/repository.py => bzrlib/repofmt/weaverepo.py
- bzrlib/commit_signature_commands.py => bzrlib/sign_my_commits.py
- bzrlib/tests/per_repository_vf/helpers.py => bzrlib/tests/per_repository/helpers.py
- bzrlib/tests/per_repository_vf/test__generate_text_key_index.py => bzrlib/tests/per_repository/test__generate_text_key_index.py
- bzrlib/tests/per_repository_vf/test_add_inventory_by_delta.py => bzrlib/tests/per_repository/test_add_inventory_by_delta.py
- bzrlib/tests/per_repository_vf/test_check_reconcile.py => bzrlib/tests/per_repository/test_check_reconcile.py
- bzrlib/tests/per_repository_vf/test_find_text_key_references.py => bzrlib/tests/per_repository/test_find_text_key_references.py
- bzrlib/tests/per_repository/test_locking.py => bzrlib/tests/per_repository/test_is_write_locked.py
- bzrlib/tests/per_repository_vf/test_merge_directive.py => bzrlib/tests/per_repository/test_merge_directive.py
- bzrlib/plugins/weave_fmt/xml4.py => bzrlib/xml4.py
- files modified:
- Makefile
added
removed
bzrlib/workingtree.py
44
44
import stat
45
45
import re
46
46
47
import bzrlib
47
48
from bzrlib import (
48
49
branch,
49
50
bzrdir,
50
51
conflicts as _mod_conflicts,
51
52
controldir,
52
53
errors,
53
filters as _mod_filters,
54
54
generate_ids,
55
55
globbing,
56
56
graph as _mod_graph,
57
hashcache,
57
58
ignores,
58
59
inventory,
59
60
merge,
60
61
revision as _mod_revision,
61
62
revisiontree,
62
rio as _mod_rio,
63
trace,
63
64
transform,
64
65
transport,
65
66
ui,
67
68
xml5,
68
69
xml7,
69
70
)
71
from bzrlib.workingtree_4 import (
72
WorkingTreeFormat4,
73
WorkingTreeFormat5,
74
WorkingTreeFormat6,
75
)
70
76
""")
71
77
72
78
from bzrlib import symbol_versioning
73
79
from bzrlib.decorators import needs_read_lock, needs_write_lock
74
from bzrlib.i18n import gettext
75
80
from bzrlib.lock import LogicalLockResult
81
from bzrlib.lockable_files import LockableFiles
82
from bzrlib.lockdir import LockDir
76
83
import bzrlib.mutabletree
77
84
from bzrlib.mutabletree import needs_tree_write_lock
78
85
from bzrlib import osutils
86
93
splitpath,
87
94
supports_executable,
88
95
)
96
from bzrlib.filters import filtered_input_file
89
97
from bzrlib.trace import mutter, note
98
from bzrlib.transport.local import LocalTransport
90
99
from bzrlib.revision import CURRENT_REVISION
100
from bzrlib.rio import RioReader, rio_file, Stanza
91
101
from bzrlib.symbol_versioning import (
92
102
deprecated_passed,
93
103
DEPRECATED_PARAMETER,
162
172
controldir.ControlComponent):
163
173
"""Working copy tree.
164
174
175
The inventory is held in the `Branch` working-inventory, and the
176
files are in a directory on disk.
177
178
It is possible for a `WorkingTree` to have a filename which is
179
not listed in the Inventory and vice versa.
180
165
181
:ivar basedir: The root of the tree on disk. This is a unicode path object
166
182
(as opposed to a URL).
167
183
"""
172
188
173
189
def __init__(self, basedir='.',
174
190
branch=DEPRECATED_PARAMETER,
191
_inventory=None,
175
192
_control_files=None,
176
193
_internal=False,
177
194
_format=None,
194
211
self.basedir = realpath(basedir)
195
212
self._control_files = _control_files
196
213
self._transport = self._control_files._transport
214
# update the whole cache up front and write to disk if anything changed;
215
# in the future we might want to do this more selectively
216
# two possible ways offer themselves : in self._unlock, write the cache
217
# if needed, or, when the cache sees a change, append it to the hash
218
# cache file, and have the parser take the most recent entry for a
219
# given path only.
220
wt_trans = self.bzrdir.get_workingtree_transport(None)
221
cache_filename = wt_trans.local_abspath('stat-cache')
222
self._hashcache = hashcache.HashCache(basedir, cache_filename,
223
self.bzrdir._get_file_mode(),
224
self._content_filter_stack_provider())
225
hc = self._hashcache
226
hc.read()
227
# is this scan needed ? it makes things kinda slow.
228
#hc.scan()
229
230
if hc.needs_write:
231
mutter("write hc")
232
hc.write()
233
234
if _inventory is None:
235
# This will be acquired on lock_read() or lock_write()
236
self._inventory_is_modified = False
237
self._inventory = None
238
else:
239
# the caller of __init__ has provided an inventory,
240
# we assume they know what they are doing - as its only
241
# the Format factory and creation methods that are
242
# permitted to do this.
243
self._set_inventory(_inventory, dirty=False)
244
self._detect_case_handling()
197
245
self._rules_searcher = None
198
246
self.views = self._make_views()
199
247
205
253
def control_transport(self):
206
254
return self._transport
207
255
208
def is_control_filename(self, filename):
209
"""True if filename is the name of a control file in this tree.
210
211
:param filename: A filename within the tree. This is a relative path
212
from the root of this tree.
213
214
This is true IF and ONLY IF the filename is part of the meta data
215
that bzr controls in this tree. I.E. a random .bzr directory placed
216
on disk will not be a control file for this tree.
217
"""
218
return self.bzrdir.is_control_filename(filename)
256
def _detect_case_handling(self):
257
wt_trans = self.bzrdir.get_workingtree_transport(None)
258
try:
259
wt_trans.stat(self._format.case_sensitive_filename)
260
except errors.NoSuchFile:
261
self.case_sensitive = True
262
else:
263
self.case_sensitive = False
264
265
self._setup_directory_is_tree_reference()
219
266
220
267
branch = property(
221
268
fget=lambda self: self._branch,
225
272
the working tree has been constructed from.
226
273
""")
227
274
228
def has_versioned_directories(self):
229
"""See `Tree.has_versioned_directories`."""
230
return self._format.supports_versioned_directories
231
232
275
def break_lock(self):
233
276
"""Break a lock if one is present from another instance.
234
277
240
283
self._control_files.break_lock()
241
284
self.branch.break_lock()
242
285
286
def _get_check_refs(self):
287
"""Return the references needed to perform a check of this tree.
288
289
The default implementation returns no refs, and is only suitable for
290
trees that have no local caching and can commit on ghosts at any time.
291
292
:seealso: bzrlib.check for details about check_refs.
293
"""
294
return []
295
243
296
def requires_rich_root(self):
244
297
return self._format.requires_rich_root
245
298
252
305
def supports_views(self):
253
306
return self.views.supports_views()
254
307
308
def _set_inventory(self, inv, dirty):
309
"""Set the internal cached inventory.
310
311
:param inv: The inventory to set.
312
:param dirty: A boolean indicating whether the inventory is the same
313
logical inventory as whats on disk. If True the inventory is not
314
the same and should be written to disk or data will be lost, if
315
False then the inventory is the same as that on disk and any
316
serialisation would be unneeded overhead.
317
"""
318
self._inventory = inv
319
self._inventory_is_modified = dirty
320
255
321
@staticmethod
256
322
def open(path=None, _unsupported=False):
257
323
"""Open an existing working tree at path.
303
369
if view_files:
304
370
file_list = view_files
305
371
view_str = views.view_display_str(view_files)
306
note(gettext("Ignoring files outside view. View is %s") % view_str)
372
note("Ignoring files outside view. View is %s" % view_str)
307
373
return tree, file_list
308
374
if default_directory == u'.':
309
375
seed = file_list[0]
370
436
list_current=list_current)
371
437
return [tr for tr in iterator if tr is not None]
372
438
439
# should be deprecated - this is slow and in any case treating them as a
440
# container is (we now know) bad style -- mbp 20070302
441
## @deprecated_method(zero_fifteen)
442
def __iter__(self):
443
"""Iterate through file_ids for this tree.
444
445
file_ids are in a WorkingTree if they are in the working inventory
446
and the working file exists.
447
"""
448
inv = self._inventory
449
for path, ie in inv.iter_entries():
450
if osutils.lexists(self.abspath(path)):
451
yield ie.file_id
452
373
453
def all_file_ids(self):
374
454
"""See Tree.iter_all_file_ids"""
375
raise NotImplementedError(self.all_file_ids)
455
return set(self.inventory)
376
456
377
457
def __repr__(self):
378
458
return "<%s of %s>" % (self.__class__.__name__,
433
513
return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
434
514
435
515
def get_file_with_stat(self, file_id, path=None, filtered=True,
436
_fstat=osutils.fstat):
516
_fstat=os.fstat):
437
517
"""See Tree.get_file_with_stat."""
438
518
if path is None:
439
519
path = self.id2path(file_id)
441
521
stat_value = _fstat(file_obj.fileno())
442
522
if filtered and self.supports_content_filtering():
443
523
filters = self._content_filter_stack(path)
444
file_obj = _mod_filters.filtered_input_file(file_obj, filters)
524
file_obj = filtered_input_file(file_obj, filters)
445
525
return (file_obj, stat_value)
446
526
447
527
def get_file_text(self, file_id, path=None, filtered=True):
456
536
f = file(path, 'rb')
457
537
if filtered and self.supports_content_filtering():
458
538
filters = self._content_filter_stack(filename)
459
return _mod_filters.filtered_input_file(f, filters)
539
return filtered_input_file(f, filters)
460
540
else:
461
541
return f
462
542
468
548
finally:
469
549
file.close()
470
550
551
@needs_read_lock
552
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
553
"""See Tree.annotate_iter
554
555
This implementation will use the basis tree implementation if possible.
556
Lines not in the basis are attributed to CURRENT_REVISION
557
558
If there are pending merges, lines added by those merges will be
559
incorrectly attributed to CURRENT_REVISION (but after committing, the
560
attribution will be correct).
561
"""
562
maybe_file_parent_keys = []
563
for parent_id in self.get_parent_ids():
564
try:
565
parent_tree = self.revision_tree(parent_id)
566
except errors.NoSuchRevisionInTree:
567
parent_tree = self.branch.repository.revision_tree(parent_id)
568
parent_tree.lock_read()
569
try:
570
if file_id not in parent_tree:
571
continue
572
ie = parent_tree.inventory[file_id]
573
if ie.kind != 'file':
574
# Note: this is slightly unnecessary, because symlinks and
575
# directories have a "text" which is the empty text, and we
576
# know that won't mess up annotations. But it seems cleaner
577
continue
578
parent_text_key = (file_id, ie.revision)
579
if parent_text_key not in maybe_file_parent_keys:
580
maybe_file_parent_keys.append(parent_text_key)
581
finally:
582
parent_tree.unlock()
583
graph = _mod_graph.Graph(self.branch.repository.texts)
584
heads = graph.heads(maybe_file_parent_keys)
585
file_parent_keys = []
586
for key in maybe_file_parent_keys:
587
if key in heads:
588
file_parent_keys.append(key)
589
590
# Now we have the parents of this content
591
annotator = self.branch.repository.texts.get_annotator()
592
text = self.get_file_text(file_id)
593
this_key =(file_id, default_revision)
594
annotator.add_special_text(this_key, file_parent_keys, text)
595
annotations = [(key[-1], line)
596
for key, line in annotator.annotate_flat(this_key)]
597
return annotations
598
599
def _get_ancestors(self, default_revision):
600
ancestors = set([default_revision])
601
for parent_id in self.get_parent_ids():
602
ancestors.update(self.branch.repository.get_ancestry(
603
parent_id, topo_sorted=False))
604
return ancestors
605
471
606
def get_parent_ids(self):
472
607
"""See Tree.get_parent_ids.
473
608
489
624
parents.append(revision_id)
490
625
return parents
491
626
627
@needs_read_lock
492
628
def get_root_id(self):
493
629
"""Return the id of this trees root"""
494
raise NotImplementedError(self.get_root_id)
630
return self._inventory.root.file_id
631
632
def _get_store_filename(self, file_id):
633
## XXX: badly named; this is not in the store at all
634
return self.abspath(self.id2path(file_id))
495
635
496
636
@needs_read_lock
497
637
def clone(self, to_bzrdir, revision_id=None):
527
667
def id2abspath(self, file_id):
528
668
return self.abspath(self.id2path(file_id))
529
669
530
def _check_for_tree_references(self, iterator):
531
"""See if directories have become tree-references."""
532
blocked_parent_ids = set()
533
for path, ie in iterator:
534
if ie.parent_id in blocked_parent_ids:
535
# This entry was pruned because one of its parents became a
536
# TreeReference. If this is a directory, mark it as blocked.
537
if ie.kind == 'directory':
538
blocked_parent_ids.add(ie.file_id)
539
continue
540
if ie.kind == 'directory' and self._directory_is_tree_reference(path):
541
# This InventoryDirectory needs to be a TreeReference
542
ie = inventory.TreeReference(ie.file_id, ie.name, ie.parent_id)
543
blocked_parent_ids.add(ie.file_id)
544
yield path, ie
545
546
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
547
"""See Tree.iter_entries_by_dir()"""
548
# The only trick here is that if we supports_tree_reference then we
549
# need to detect if a directory becomes a tree-reference.
550
iterator = super(WorkingTree, self).iter_entries_by_dir(
551
specific_file_ids=specific_file_ids,
552
yield_parents=yield_parents)
553
if not self.supports_tree_reference():
554
return iterator
555
else:
556
return self._check_for_tree_references(iterator)
670
def has_id(self, file_id):
671
# files that have been deleted are excluded
672
inv = self.inventory
673
if not inv.has_id(file_id):
674
return False
675
path = inv.id2path(file_id)
676
return osutils.lexists(self.abspath(path))
677
678
def has_or_had_id(self, file_id):
679
if file_id == self.inventory.root.file_id:
680
return True
681
return self.inventory.has_id(file_id)
682
683
__contains__ = has_id
557
684
558
685
def get_file_size(self, file_id):
559
686
"""See Tree.get_file_size"""
567
694
else:
568
695
return None
569
696
697
@needs_read_lock
698
def get_file_sha1(self, file_id, path=None, stat_value=None):
699
if not path:
700
path = self._inventory.id2path(file_id)
701
return self._hashcache.get_sha1(path, stat_value)
702
703
def get_file_mtime(self, file_id, path=None):
704
if not path:
705
path = self.inventory.id2path(file_id)
706
return os.lstat(self.abspath(path)).st_mtime
707
708
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
709
file_id = self.path2id(path)
710
if file_id is None:
711
# For unversioned files on win32, we just assume they are not
712
# executable
713
return False
714
return self._inventory[file_id].executable
715
716
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
717
mode = stat_result.st_mode
718
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
719
720
if not supports_executable():
721
def is_executable(self, file_id, path=None):
722
return self._inventory[file_id].executable
723
724
_is_executable_from_path_and_stat = \
725
_is_executable_from_path_and_stat_from_basis
726
else:
727
def is_executable(self, file_id, path=None):
728
if not path:
729
path = self.id2path(file_id)
730
mode = os.lstat(self.abspath(path)).st_mode
731
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
732
733
_is_executable_from_path_and_stat = \
734
_is_executable_from_path_and_stat_from_stat
735
736
@needs_tree_write_lock
737
def _add(self, files, ids, kinds):
738
"""See MutableTree._add."""
739
# TODO: Re-adding a file that is removed in the working copy
740
# should probably put it back with the previous ID.
741
# the read and write working inventory should not occur in this
742
# function - they should be part of lock_write and unlock.
743
inv = self.inventory
744
for f, file_id, kind in zip(files, ids, kinds):
745
if file_id is None:
746
inv.add_path(f, kind=kind)
747
else:
748
inv.add_path(f, kind=kind, file_id=file_id)
749
self._inventory_is_modified = True
750
570
751
@needs_tree_write_lock
571
752
def _gather_kinds(self, files, kinds):
572
753
"""See MutableTree._gather_kinds."""
587
768
and setting the list to its value plus revision_id.
588
769
589
770
:param revision_id: The revision id to add to the parent list. It may
590
be a ghost revision as long as its not the first parent to be
591
added, or the allow_leftmost_as_ghost parameter is set True.
771
be a ghost revision as long as its not the first parent to be added,
772
or the allow_leftmost_as_ghost parameter is set True.
592
773
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
593
774
"""
594
775
parents = self.get_parent_ids() + [revision_id]
697
878
if revision_id in heads and revision_id not in new_revision_ids:
698
879
new_revision_ids.append(revision_id)
699
880
if new_revision_ids != revision_ids:
700
mutter('requested to set revision_ids = %s,'
881
trace.mutter('requested to set revision_ids = %s,'
701
882
' but filtered to %s', revision_ids, new_revision_ids)
702
883
return new_revision_ids
703
884
729
910
self._set_merges_from_parent_ids(revision_ids)
730
911
731
912
@needs_tree_write_lock
913
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
914
"""See MutableTree.set_parent_trees."""
915
parent_ids = [rev for (rev, tree) in parents_list]
916
for revision_id in parent_ids:
917
_mod_revision.check_not_reserved_id(revision_id)
918
919
self._check_parents_for_ghosts(parent_ids,
920
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
921
922
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
923
924
if len(parent_ids) == 0:
925
leftmost_parent_id = _mod_revision.NULL_REVISION
926
leftmost_parent_tree = None
927
else:
928
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
929
930
if self._change_last_revision(leftmost_parent_id):
931
if leftmost_parent_tree is None:
932
# If we don't have a tree, fall back to reading the
933
# parent tree from the repository.
934
self._cache_basis_inventory(leftmost_parent_id)
935
else:
936
inv = leftmost_parent_tree.inventory
937
xml = self._create_basis_xml_from_inventory(
938
leftmost_parent_id, inv)
939
self._write_basis_inventory(xml)
940
self._set_merges_from_parent_ids(parent_ids)
941
942
@needs_tree_write_lock
732
943
def set_pending_merges(self, rev_list):
733
944
parents = self.get_parent_ids()
734
945
leftmost = parents[:1]
739
950
def set_merge_modified(self, modified_hashes):
740
951
def iter_stanzas():
741
952
for file_id, hash in modified_hashes.iteritems():
742
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
743
hash=hash)
953
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
744
954
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
745
955
746
956
def _sha_from_stat(self, path, stat_result):
755
965
756
966
def _put_rio(self, filename, stanzas, header):
757
967
self._must_be_locked()
758
my_file = _mod_rio.rio_file(stanzas, header)
968
my_file = rio_file(stanzas, header)
759
969
self._transport.put_file(filename, my_file,
760
970
mode=self.bzrdir._get_file_mode())
761
971
803
1013
merger.set_pending()
804
1014
return conflicts
805
1015
1016
@needs_read_lock
806
1017
def merge_modified(self):
807
1018
"""Return a dictionary of files modified by a merge.
808
1019
813
1024
This returns a map of file_id->sha1, containing only files which are
814
1025
still in the working inventory and have that text hash.
815
1026
"""
816
raise NotImplementedError(self.merge_modified)
1027
try:
1028
hashfile = self._transport.get('merge-hashes')
1029
except errors.NoSuchFile:
1030
return {}
1031
try:
1032
merge_hashes = {}
1033
try:
1034
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
1035
raise errors.MergeModifiedFormatError()
1036
except StopIteration:
1037
raise errors.MergeModifiedFormatError()
1038
for s in RioReader(hashfile):
1039
# RioReader reads in Unicode, so convert file_ids back to utf8
1040
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
1041
if file_id not in self.inventory:
1042
continue
1043
text_hash = s.get("hash")
1044
if text_hash == self.get_file_sha1(file_id):
1045
merge_hashes[file_id] = text_hash
1046
return merge_hashes
1047
finally:
1048
hashfile.close()
817
1049
818
1050
@needs_write_lock
819
1051
def mkdir(self, path, file_id=None):
824
1056
self.add(path, file_id, 'directory')
825
1057
return file_id
826
1058
827
def get_symlink_target(self, file_id, path=None):
828
if path is not None:
829
abspath = self.abspath(path)
830
else:
831
abspath = self.id2abspath(file_id)
1059
def get_symlink_target(self, file_id):
1060
abspath = self.id2abspath(file_id)
832
1061
target = osutils.readlink(abspath)
833
1062
return target
834
1063
1064
@needs_write_lock
835
1065
def subsume(self, other_tree):
836
raise NotImplementedError(self.subsume)
1066
def add_children(inventory, entry):
1067
for child_entry in entry.children.values():
1068
inventory._byid[child_entry.file_id] = child_entry
1069
if child_entry.kind == 'directory':
1070
add_children(inventory, child_entry)
1071
if other_tree.get_root_id() == self.get_root_id():
1072
raise errors.BadSubsumeSource(self, other_tree,
1073
'Trees have the same root')
1074
try:
1075
other_tree_path = self.relpath(other_tree.basedir)
1076
except errors.PathNotChild:
1077
raise errors.BadSubsumeSource(self, other_tree,
1078
'Tree is not contained by the other')
1079
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
1080
if new_root_parent is None:
1081
raise errors.BadSubsumeSource(self, other_tree,
1082
'Parent directory is not versioned.')
1083
# We need to ensure that the result of a fetch will have a
1084
# versionedfile for the other_tree root, and only fetching into
1085
# RepositoryKnit2 guarantees that.
1086
if not self.branch.repository.supports_rich_root():
1087
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
1088
other_tree.lock_tree_write()
1089
try:
1090
new_parents = other_tree.get_parent_ids()
1091
other_root = other_tree.inventory.root
1092
other_root.parent_id = new_root_parent
1093
other_root.name = osutils.basename(other_tree_path)
1094
self.inventory.add(other_root)
1095
add_children(self.inventory, other_root)
1096
self._write_inventory(self.inventory)
1097
# normally we don't want to fetch whole repositories, but i think
1098
# here we really do want to consolidate the whole thing.
1099
for parent_id in other_tree.get_parent_ids():
1100
self.branch.fetch(other_tree.branch, parent_id)
1101
self.add_parent_tree_id(parent_id)
1102
finally:
1103
other_tree.unlock()
1104
other_tree.bzrdir.retire_bzrdir()
837
1105
838
1106
def _setup_directory_is_tree_reference(self):
839
1107
if self._branch.repository._format.supports_tree_reference:
861
1129
# checkout in a subdirectory. This can be avoided by not adding
862
1130
# it. mbp 20070306
863
1131
1132
@needs_tree_write_lock
864
1133
def extract(self, file_id, format=None):
865
1134
"""Extract a subtree from this tree.
866
1135
867
1136
A new branch will be created, relative to the path for this tree.
868
1137
"""
869
raise NotImplementedError(self.extract)
1138
self.flush()
1139
def mkdirs(path):
1140
segments = osutils.splitpath(path)
1141
transport = self.branch.bzrdir.root_transport
1142
for name in segments:
1143
transport = transport.clone(name)
1144
transport.ensure_base()
1145
return transport
1146
1147
sub_path = self.id2path(file_id)
1148
branch_transport = mkdirs(sub_path)
1149
if format is None:
1150
format = self.bzrdir.cloning_metadir()
1151
branch_transport.ensure_base()
1152
branch_bzrdir = format.initialize_on_transport(branch_transport)
1153
try:
1154
repo = branch_bzrdir.find_repository()
1155
except errors.NoRepositoryPresent:
1156
repo = branch_bzrdir.create_repository()
1157
if not repo.supports_rich_root():
1158
raise errors.RootNotRich()
1159
new_branch = branch_bzrdir.create_branch()
1160
new_branch.pull(self.branch)
1161
for parent_id in self.get_parent_ids():
1162
new_branch.fetch(self.branch, parent_id)
1163
tree_transport = self.bzrdir.root_transport.clone(sub_path)
1164
if tree_transport.base != branch_transport.base:
1165
tree_bzrdir = format.initialize_on_transport(tree_transport)
1166
branch.BranchReferenceFormat().initialize(tree_bzrdir,
1167
target_branch=new_branch)
1168
else:
1169
tree_bzrdir = branch_bzrdir
1170
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1171
wt.set_parent_ids(self.get_parent_ids())
1172
my_inv = self.inventory
1173
child_inv = inventory.Inventory(root_id=None)
1174
new_root = my_inv[file_id]
1175
my_inv.remove_recursive_id(file_id)
1176
new_root.parent_id = None
1177
child_inv.add(new_root)
1178
self._write_inventory(my_inv)
1179
wt._write_inventory(child_inv)
1180
return wt
1181
1182
def _serialize(self, inventory, out_file):
1183
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1184
working=True)
1185
1186
def _deserialize(selt, in_file):
1187
return xml5.serializer_v5.read_inventory(in_file)
870
1188
871
1189
def flush(self):
872
"""Write the in memory meta data to disk."""
873
raise NotImplementedError(self.flush)
1190
"""Write the in memory inventory to disk."""
1191
# TODO: Maybe this should only write on dirty ?
1192
if self._control_files._lock_mode != 'w':
1193
raise errors.NotWriteLocked(self)
1194
sio = StringIO()
1195
self._serialize(self._inventory, sio)
1196
sio.seek(0)
1197
self._transport.put_file('inventory', sio,
1198
mode=self.bzrdir._get_file_mode())
1199
self._inventory_is_modified = False
874
1200
875
1201
def _kind(self, relpath):
876
1202
return osutils.file_kind(self.abspath(relpath))
886
1212
:param from_dir: start from this directory or None for the root
887
1213
:param recursive: whether to recurse into subdirectories or not
888
1214
"""
889
raise NotImplementedError(self.list_files)
890
1215
# list_files is an iterator, so @needs_read_lock doesn't work properly
1216
# with it. So callers should be careful to always read_lock the tree.
1217
if not self.is_locked():
1218
raise errors.ObjectNotLocked(self)
1219
1220
inv = self.inventory
1221
if from_dir is None and include_root is True:
1222
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1223
# Convert these into local objects to save lookup times
1224
pathjoin = osutils.pathjoin
1225
file_kind = self._kind
1226
1227
# transport.base ends in a slash, we want the piece
1228
# between the last two slashes
1229
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
1230
1231
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1232
1233
# directory file_id, relative path, absolute path, reverse sorted children
1234
if from_dir is not None:
1235
from_dir_id = inv.path2id(from_dir)
1236
if from_dir_id is None:
1237
# Directory not versioned
1238
return
1239
from_dir_abspath = pathjoin(self.basedir, from_dir)
1240
else:
1241
from_dir_id = inv.root.file_id
1242
from_dir_abspath = self.basedir
1243
children = os.listdir(from_dir_abspath)
1244
children.sort()
1245
# jam 20060527 The kernel sized tree seems equivalent whether we
1246
# use a deque and popleft to keep them sorted, or if we use a plain
1247
# list and just reverse() them.
1248
children = collections.deque(children)
1249
stack = [(from_dir_id, u'', from_dir_abspath, children)]
1250
while stack:
1251
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1252
1253
while children:
1254
f = children.popleft()
1255
## TODO: If we find a subdirectory with its own .bzr
1256
## directory, then that is a separate tree and we
1257
## should exclude it.
1258
1259
# the bzrdir for this tree
1260
if transport_base_dir == f:
1261
continue
1262
1263
# we know that from_dir_relpath and from_dir_abspath never end in a slash
1264
# and 'f' doesn't begin with one, we can do a string op, rather
1265
# than the checks of pathjoin(), all relative paths will have an extra slash
1266
# at the beginning
1267
fp = from_dir_relpath + '/' + f
1268
1269
# absolute path
1270
fap = from_dir_abspath + '/' + f
1271
1272
dir_ie = inv[from_dir_id]
1273
if dir_ie.kind == 'directory':
1274
f_ie = dir_ie.children.get(f)
1275
else:
1276
f_ie = None
1277
if f_ie:
1278
c = 'V'
1279
elif self.is_ignored(fp[1:]):
1280
c = 'I'
1281
else:
1282
# we may not have found this file, because of a unicode
1283
# issue, or because the directory was actually a symlink.
1284
f_norm, can_access = osutils.normalized_filename(f)
1285
if f == f_norm or not can_access:
1286
# No change, so treat this file normally
1287
c = '?'
1288
else:
1289
# this file can be accessed by a normalized path
1290
# check again if it is versioned
1291
# these lines are repeated here for performance
1292
f = f_norm
1293
fp = from_dir_relpath + '/' + f
1294
fap = from_dir_abspath + '/' + f
1295
f_ie = inv.get_child(from_dir_id, f)
1296
if f_ie:
1297
c = 'V'
1298
elif self.is_ignored(fp[1:]):
1299
c = 'I'
1300
else:
1301
c = '?'
1302
1303
fk = file_kind(fap)
1304
1305
# make a last minute entry
1306
if f_ie:
1307
yield fp[1:], c, fk, f_ie.file_id, f_ie
1308
else:
1309
try:
1310
yield fp[1:], c, fk, None, fk_entries[fk]()
1311
except KeyError:
1312
yield fp[1:], c, fk, None, TreeEntry()
1313
continue
1314
1315
if fk != 'directory':
1316
continue
1317
1318
# But do this child first if recursing down
1319
if recursive:
1320
new_children = os.listdir(fap)
1321
new_children.sort()
1322
new_children = collections.deque(new_children)
1323
stack.append((f_ie.file_id, fp, fap, new_children))
1324
# Break out of inner loop,
1325
# so that we start outer loop with child
1326
break
1327
else:
1328
# if we finished all children, pop it off the stack
1329
stack.pop()
1330
1331
@needs_tree_write_lock
891
1332
def move(self, from_paths, to_dir=None, after=False):
892
1333
"""Rename files.
893
1334
894
to_dir must be known to the working tree.
1335
to_dir must exist in the inventory.
895
1336
896
1337
If to_dir exists and is a directory, the files are moved into
897
1338
it, keeping their old names.
903
1344
independently.
904
1345
905
1346
The first mode moves the file in the filesystem and updates the
906
working tree metadata. The second mode only updates the working tree
907
metadata without touching the file on the filesystem.
1347
inventory. The second mode only updates the inventory without
1348
touching the file on the filesystem. This is the new mode introduced
1349
in version 0.15.
908
1350
909
1351
move uses the second mode if 'after == True' and the target is not
910
1352
versioned but present in the working tree.
922
1364
This returns a list of (from_path, to_path) pairs for each
923
1365
entry that is moved.
924
1366
"""
925
raise NotImplementedError(self.move)
1367
rename_entries = []
1368
rename_tuples = []
1369
1370
# check for deprecated use of signature
1371
if to_dir is None:
1372
raise TypeError('You must supply a target directory')
1373
# check destination directory
1374
if isinstance(from_paths, basestring):
1375
raise ValueError()
1376
inv = self.inventory
1377
to_abs = self.abspath(to_dir)
1378
if not isdir(to_abs):
1379
raise errors.BzrMoveFailedError('',to_dir,
1380
errors.NotADirectory(to_abs))
1381
if not self.has_filename(to_dir):
1382
raise errors.BzrMoveFailedError('',to_dir,
1383
errors.NotInWorkingDirectory(to_dir))
1384
to_dir_id = inv.path2id(to_dir)
1385
if to_dir_id is None:
1386
raise errors.BzrMoveFailedError('',to_dir,
1387
errors.NotVersionedError(path=to_dir))
1388
1389
to_dir_ie = inv[to_dir_id]
1390
if to_dir_ie.kind != 'directory':
1391
raise errors.BzrMoveFailedError('',to_dir,
1392
errors.NotADirectory(to_abs))
1393
1394
# create rename entries and tuples
1395
for from_rel in from_paths:
1396
from_tail = splitpath(from_rel)[-1]
1397
from_id = inv.path2id(from_rel)
1398
if from_id is None:
1399
raise errors.BzrMoveFailedError(from_rel,to_dir,
1400
errors.NotVersionedError(path=from_rel))
1401
1402
from_entry = inv[from_id]
1403
from_parent_id = from_entry.parent_id
1404
to_rel = pathjoin(to_dir, from_tail)
1405
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1406
from_id=from_id,
1407
from_tail=from_tail,
1408
from_parent_id=from_parent_id,
1409
to_rel=to_rel, to_tail=from_tail,
1410
to_parent_id=to_dir_id)
1411
rename_entries.append(rename_entry)
1412
rename_tuples.append((from_rel, to_rel))
1413
1414
# determine which move mode to use. checks also for movability
1415
rename_entries = self._determine_mv_mode(rename_entries, after)
1416
1417
original_modified = self._inventory_is_modified
1418
try:
1419
if len(from_paths):
1420
self._inventory_is_modified = True
1421
self._move(rename_entries)
1422
except:
1423
# restore the inventory on error
1424
self._inventory_is_modified = original_modified
1425
raise
1426
self._write_inventory(inv)
1427
return rename_tuples
1428
1429
def _determine_mv_mode(self, rename_entries, after=False):
1430
"""Determines for each from-to pair if both inventory and working tree
1431
or only the inventory has to be changed.
1432
1433
Also does basic plausability tests.
1434
"""
1435
inv = self.inventory
1436
1437
for rename_entry in rename_entries:
1438
# store to local variables for easier reference
1439
from_rel = rename_entry.from_rel
1440
from_id = rename_entry.from_id
1441
to_rel = rename_entry.to_rel
1442
to_id = inv.path2id(to_rel)
1443
only_change_inv = False
1444
1445
# check the inventory for source and destination
1446
if from_id is None:
1447
raise errors.BzrMoveFailedError(from_rel,to_rel,
1448
errors.NotVersionedError(path=from_rel))
1449
if to_id is not None:
1450
raise errors.BzrMoveFailedError(from_rel,to_rel,
1451
errors.AlreadyVersionedError(path=to_rel))
1452
1453
# try to determine the mode for rename (only change inv or change
1454
# inv and file system)
1455
if after:
1456
if not self.has_filename(to_rel):
1457
raise errors.BzrMoveFailedError(from_id,to_rel,
1458
errors.NoSuchFile(path=to_rel,
1459
extra="New file has not been created yet"))
1460
only_change_inv = True
1461
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1462
only_change_inv = True
1463
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1464
only_change_inv = False
1465
elif (not self.case_sensitive
1466
and from_rel.lower() == to_rel.lower()
1467
and self.has_filename(from_rel)):
1468
only_change_inv = False
1469
else:
1470
# something is wrong, so lets determine what exactly
1471
if not self.has_filename(from_rel) and \
1472
not self.has_filename(to_rel):
1473
raise errors.BzrRenameFailedError(from_rel,to_rel,
1474
errors.PathsDoNotExist(paths=(str(from_rel),
1475
str(to_rel))))
1476
else:
1477
raise errors.RenameFailedFilesExist(from_rel, to_rel)
1478
rename_entry.only_change_inv = only_change_inv
1479
return rename_entries
1480
1481
def _move(self, rename_entries):
1482
"""Moves a list of files.
1483
1484
Depending on the value of the flag 'only_change_inv', the
1485
file will be moved on the file system or not.
1486
"""
1487
inv = self.inventory
1488
moved = []
1489
1490
for entry in rename_entries:
1491
try:
1492
self._move_entry(entry)
1493
except:
1494
self._rollback_move(moved)
1495
raise
1496
moved.append(entry)
1497
1498
def _rollback_move(self, moved):
1499
"""Try to rollback a previous move in case of an filesystem error."""
1500
inv = self.inventory
1501
for entry in moved:
1502
try:
1503
self._move_entry(WorkingTree._RenameEntry(
1504
entry.to_rel, entry.from_id,
1505
entry.to_tail, entry.to_parent_id, entry.from_rel,
1506
entry.from_tail, entry.from_parent_id,
1507
entry.only_change_inv))
1508
except errors.BzrMoveFailedError, e:
1509
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1510
" The working tree is in an inconsistent state."
1511
" Please consider doing a 'bzr revert'."
1512
" Error message is: %s" % e)
1513
1514
def _move_entry(self, entry):
1515
inv = self.inventory
1516
from_rel_abs = self.abspath(entry.from_rel)
1517
to_rel_abs = self.abspath(entry.to_rel)
1518
if from_rel_abs == to_rel_abs:
1519
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1520
"Source and target are identical.")
1521
1522
if not entry.only_change_inv:
1523
try:
1524
osutils.rename(from_rel_abs, to_rel_abs)
1525
except OSError, e:
1526
raise errors.BzrMoveFailedError(entry.from_rel,
1527
entry.to_rel, e[1])
1528
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
926
1529
927
1530
@needs_tree_write_lock
928
1531
def rename_one(self, from_rel, to_rel, after=False):
932
1535
933
1536
rename_one has several 'modes' to work. First, it can rename a physical
934
1537
file and change the file_id. That is the normal mode. Second, it can
935
only change the file_id without touching any physical file.
1538
only change the file_id without touching any physical file. This is
1539
the new mode introduced in version 0.15.
936
1540
937
rename_one uses the second mode if 'after == True' and 'to_rel' is
938
either not versioned or newly added, and present in the working tree.
1541
rename_one uses the second mode if 'after == True' and 'to_rel' is not
1542
versioned but present in the working tree.
939
1543
940
1544
rename_one uses the second mode if 'after == False' and 'from_rel' is
941
1545
versioned but no longer in the working tree, and 'to_rel' is not
947
1551
948
1552
Everything else results in an error.
949
1553
"""
950
raise NotImplementedError(self.rename_one)
1554
inv = self.inventory
1555
rename_entries = []
1556
1557
# create rename entries and tuples
1558
from_tail = splitpath(from_rel)[-1]
1559
from_id = inv.path2id(from_rel)
1560
if from_id is None:
1561
# if file is missing in the inventory maybe it's in the basis_tree
1562
basis_tree = self.branch.basis_tree()
1563
from_id = basis_tree.path2id(from_rel)
1564
if from_id is None:
1565
raise errors.BzrRenameFailedError(from_rel,to_rel,
1566
errors.NotVersionedError(path=from_rel))
1567
# put entry back in the inventory so we can rename it
1568
from_entry = basis_tree.inventory[from_id].copy()
1569
inv.add(from_entry)
1570
else:
1571
from_entry = inv[from_id]
1572
from_parent_id = from_entry.parent_id
1573
to_dir, to_tail = os.path.split(to_rel)
1574
to_dir_id = inv.path2id(to_dir)
1575
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1576
from_id=from_id,
1577
from_tail=from_tail,
1578
from_parent_id=from_parent_id,
1579
to_rel=to_rel, to_tail=to_tail,
1580
to_parent_id=to_dir_id)
1581
rename_entries.append(rename_entry)
1582
1583
# determine which move mode to use. checks also for movability
1584
rename_entries = self._determine_mv_mode(rename_entries, after)
1585
1586
# check if the target changed directory and if the target directory is
1587
# versioned
1588
if to_dir_id is None:
1589
raise errors.BzrMoveFailedError(from_rel,to_rel,
1590
errors.NotVersionedError(path=to_dir))
1591
1592
# all checks done. now we can continue with our actual work
1593
mutter('rename_one:\n'
1594
' from_id {%s}\n'
1595
' from_rel: %r\n'
1596
' to_rel: %r\n'
1597
' to_dir %r\n'
1598
' to_dir_id {%s}\n',
1599
from_id, from_rel, to_rel, to_dir, to_dir_id)
1600
1601
self._move(rename_entries)
1602
self._write_inventory(inv)
1603
1604
class _RenameEntry(object):
1605
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1606
to_rel, to_tail, to_parent_id, only_change_inv=False):
1607
self.from_rel = from_rel
1608
self.from_id = from_id
1609
self.from_tail = from_tail
1610
self.from_parent_id = from_parent_id
1611
self.to_rel = to_rel
1612
self.to_tail = to_tail
1613
self.to_parent_id = to_parent_id
1614
self.only_change_inv = only_change_inv
951
1615
952
1616
@needs_read_lock
953
1617
def unknowns(self):
961
1625
return iter(
962
1626
[subp for subp in self.extras() if not self.is_ignored(subp)])
963
1627
1628
@needs_tree_write_lock
964
1629
def unversion(self, file_ids):
965
1630
"""Remove the file ids in file_ids from the current versioned set.
966
1631
970
1635
:param file_ids: The file ids to stop versioning.
971
1636
:raises: NoSuchId if any fileid is not currently versioned.
972
1637
"""
973
raise NotImplementedError(self.unversion)
1638
for file_id in file_ids:
1639
if file_id not in self._inventory:
1640
raise errors.NoSuchId(self, file_id)
1641
for file_id in file_ids:
1642
if self._inventory.has_id(file_id):
1643
self._inventory.remove_recursive_id(file_id)
1644
if len(file_ids):
1645
# in the future this should just set a dirty bit to wait for the
1646
# final unlock. However, until all methods of workingtree start
1647
# with the current in -memory inventory rather than triggering
1648
# a read, it is more complex - we need to teach read_inventory
1649
# to know when to read, and when to not read first... and possibly
1650
# to save first when the in memory one may be corrupted.
1651
# so for now, we just only write it if it is indeed dirty.
1652
# - RBC 20060907
1653
self._write_inventory(self._inventory)
1654
1655
def _iter_conflicts(self):
1656
conflicted = set()
1657
for info in self.list_files():
1658
path = info[0]
1659
stem = get_conflicted_stem(path)
1660
if stem is None:
1661
continue
1662
if stem not in conflicted:
1663
conflicted.add(stem)
1664
yield stem
974
1665
975
1666
@needs_write_lock
976
1667
def pull(self, source, overwrite=False, stop_revision=None,
986
1677
new_revision_info = self.branch.last_revision_info()
987
1678
if new_revision_info != old_revision_info:
988
1679
repository = self.branch.repository
989
if repository._format.fast_deltas:
990
parent_ids = self.get_parent_ids()
991
if parent_ids:
992
basis_id = parent_ids[0]
993
basis_tree = repository.revision_tree(basis_id)
994
1680
basis_tree.lock_read()
995
1681
try:
996
1682
new_basis_tree = self.branch.basis_tree()
1034
1720
stream.write(bytes)
1035
1721
finally:
1036
1722
stream.close()
1723
# TODO: update the hashcache here ?
1037
1724
1038
1725
def extras(self):
1039
1726
"""Yield all unversioned files in this WorkingTree.
1045
1732
Currently returned depth-first, sorted by name within directories.
1046
1733
This is the same order used by 'osutils.walkdirs'.
1047
1734
"""
1048
raise NotImplementedError(self.extras)
1735
## TODO: Work from given directory downwards
1736
for path, dir_entry in self.inventory.directories():
1737
# mutter("search for unknowns in %r", path)
1738
dirabs = self.abspath(path)
1739
if not isdir(dirabs):
1740
# e.g. directory deleted
1741
continue
1742
1743
fl = []
1744
for subf in os.listdir(dirabs):
1745
if self.bzrdir.is_control_filename(subf):
1746
continue
1747
if subf not in dir_entry.children:
1748
try:
1749
(subf_norm,
1750
can_access) = osutils.normalized_filename(subf)
1751
except UnicodeDecodeError:
1752
path_os_enc = path.encode(osutils._fs_enc)
1753
relpath = path_os_enc + '/' + subf
1754
raise errors.BadFilenameEncoding(relpath,
1755
osutils._fs_enc)
1756
if subf_norm != subf and can_access:
1757
if subf_norm not in dir_entry.children:
1758
fl.append(subf_norm)
1759
else:
1760
fl.append(subf)
1761
1762
fl.sort()
1763
for subf in fl:
1764
subp = pathjoin(path, subf)
1765
yield subp
1049
1766
1050
1767
def ignored_files(self):
1051
1768
"""Yield list of PATH, IGNORE_PATTERN"""
1100
1817
1101
1818
def stored_kind(self, file_id):
1102
1819
"""See Tree.stored_kind"""
1103
raise NotImplementedError(self.stored_kind)
1820
return self.inventory[file_id].kind
1104
1821
1105
1822
def _comparison_data(self, entry, path):
1106
1823
abspath = self.abspath(path)
1197
1914
def get_physical_lock_status(self):
1198
1915
return self._control_files.get_physical_lock_status()
1199
1916
1917
def _basis_inventory_name(self):
1918
return 'basis-inventory-cache'
1919
1200
1920
def _reset_data(self):
1201
1921
"""Reset transient data that cannot be revalidated."""
1202
raise NotImplementedError(self._reset_data)
1922
self._inventory_is_modified = False
1923
f = self._transport.get('inventory')
1924
try:
1925
result = self._deserialize(f)
1926
finally:
1927
f.close()
1928
self._set_inventory(result, dirty=False)
1203
1929
1930
@needs_tree_write_lock
1204
1931
def set_last_revision(self, new_revision):
1205
1932
"""Change the last revision in the working tree."""
1206
raise NotImplementedError(self.set_last_revision)
1933
if self._change_last_revision(new_revision):
1934
self._cache_basis_inventory(new_revision)
1207
1935
1208
1936
def _change_last_revision(self, new_revision):
1209
1937
"""Template method part of set_last_revision to perform the change.
1212
1940
when their last revision is set.
1213
1941
"""
1214
1942
if _mod_revision.is_null(new_revision):
1215
self.branch.set_last_revision_info(0, new_revision)
1943
self.branch.set_revision_history([])
1216
1944
return False
1217
_mod_revision.check_not_reserved_id(new_revision)
1218
1945
try:
1219
1946
self.branch.generate_revision_history(new_revision)
1220
1947
except errors.NoSuchRevision:
1221
1948
# not present in the repo - dont try to set it deeper than the tip
1222
self.branch._set_revision_history([new_revision])
1949
self.branch.set_revision_history([new_revision])
1223
1950
return True
1224
1951
1952
def _write_basis_inventory(self, xml):
1953
"""Write the basis inventory XML to the basis-inventory file"""
1954
path = self._basis_inventory_name()
1955
sio = StringIO(xml)
1956
self._transport.put_file(path, sio,
1957
mode=self.bzrdir._get_file_mode())
1958
1959
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1960
"""Create the text that will be saved in basis-inventory"""
1961
inventory.revision_id = revision_id
1962
return xml7.serializer_v7.write_inventory_to_string(inventory)
1963
1964
def _cache_basis_inventory(self, new_revision):
1965
"""Cache new_revision as the basis inventory."""
1966
# TODO: this should allow the ready-to-use inventory to be passed in,
1967
# as commit already has that ready-to-use [while the format is the
1968
# same, that is].
1969
try:
1970
# this double handles the inventory - unpack and repack -
1971
# but is easier to understand. We can/should put a conditional
1972
# in here based on whether the inventory is in the latest format
1973
# - perhaps we should repack all inventories on a repository
1974
# upgrade ?
1975
# the fast path is to copy the raw xml from the repository. If the
1976
# xml contains 'revision_id="', then we assume the right
1977
# revision_id is set. We must check for this full string, because a
1978
# root node id can legitimately look like 'revision_id' but cannot
1979
# contain a '"'.
1980
xml = self.branch.repository._get_inventory_xml(new_revision)
1981
firstline = xml.split('\n', 1)[0]
1982
if (not 'revision_id="' in firstline or
1983
'format="7"' not in firstline):
1984
inv = self.branch.repository._serializer.read_inventory_from_string(
1985
xml, new_revision)
1986
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1987
self._write_basis_inventory(xml)
1988
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1989
pass
1990
1991
def read_basis_inventory(self):
1992
"""Read the cached basis inventory."""
1993
path = self._basis_inventory_name()
1994
return self._transport.get_bytes(path)
1995
1996
@needs_read_lock
1997
def read_working_inventory(self):
1998
"""Read the working inventory.
1999
2000
:raises errors.InventoryModified: read_working_inventory will fail
2001
when the current in memory inventory has been modified.
2002
"""
2003
# conceptually this should be an implementation detail of the tree.
2004
# XXX: Deprecate this.
2005
# ElementTree does its own conversion from UTF-8, so open in
2006
# binary.
2007
if self._inventory_is_modified:
2008
raise errors.InventoryModified(self)
2009
f = self._transport.get('inventory')
2010
try:
2011
result = self._deserialize(f)
2012
finally:
2013
f.close()
2014
self._set_inventory(result, dirty=False)
2015
return result
2016
1225
2017
@needs_tree_write_lock
1226
2018
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1227
2019
force=False):
1228
"""Remove nominated files from the working tree metadata.
2020
"""Remove nominated files from the working inventory.
1229
2021
1230
2022
:files: File paths relative to the basedir.
1231
2023
:keep_files: If true, the files will also be kept.
1296
2088
backup_name)
1297
2089
1298
2090
# Build inv_delta and delete files where applicable,
1299
# do this before any modifications to meta data.
2091
# do this before any modifications to inventory.
1300
2092
for f in files:
1301
2093
fid = self.path2id(f)
1302
2094
message = None
1345
2137
def revert(self, filenames=None, old_tree=None, backups=True,
1346
2138
pb=None, report_changes=False):
1347
2139
from bzrlib.conflicts import resolve
2140
if filenames == []:
2141
filenames = None
2142
symbol_versioning.warn('Using [] to revert all files is deprecated'
2143
' as of bzr 0.91. Please use None (the default) instead.',
2144
DeprecationWarning, stacklevel=2)
1348
2145
if old_tree is None:
1349
2146
basis_tree = self.basis_tree()
1350
2147
basis_tree.lock_read()
1377
2174
WorkingTree can supply revision_trees for the basis revision only
1378
2175
because there is only one cached inventory in the bzr directory.
1379
2176
"""
1380
raise NotImplementedError(self.revision_tree)
2177
if revision_id == self.last_revision():
2178
try:
2179
xml = self.read_basis_inventory()
2180
except errors.NoSuchFile:
2181
pass
2182
else:
2183
try:
2184
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2185
# dont use the repository revision_tree api because we want
2186
# to supply the inventory.
2187
if inv.revision_id == revision_id:
2188
return revisiontree.RevisionTree(self.branch.repository,
2189
inv, revision_id)
2190
except errors.BadInventoryFormat:
2191
pass
2192
# raise if there was no inventory, or if we read the wrong inventory.
2193
raise errors.NoSuchRevisionInTree(self, revision_id)
2194
2195
# XXX: This method should be deprecated in favour of taking in a proper
2196
# new Inventory object.
2197
@needs_tree_write_lock
2198
def set_inventory(self, new_inventory_list):
2199
from bzrlib.inventory import (Inventory,
2200
InventoryDirectory,
2201
InventoryFile,
2202
InventoryLink)
2203
inv = Inventory(self.get_root_id())
2204
for path, file_id, parent, kind in new_inventory_list:
2205
name = os.path.basename(path)
2206
if name == "":
2207
continue
2208
# fixme, there should be a factory function inv,add_??
2209
if kind == 'directory':
2210
inv.add(InventoryDirectory(file_id, name, parent))
2211
elif kind == 'file':
2212
inv.add(InventoryFile(file_id, name, parent))
2213
elif kind == 'symlink':
2214
inv.add(InventoryLink(file_id, name, parent))
2215
else:
2216
raise errors.BzrError("unknown kind %r" % kind)
2217
self._write_inventory(inv)
1381
2218
1382
2219
@needs_tree_write_lock
1383
2220
def set_root_id(self, file_id):
1396
2233
present in the current inventory or an error will occur. It must
1397
2234
not be None, but rather a valid file id.
1398
2235
"""
1399
raise NotImplementedError(self._set_root_id)
2236
inv = self._inventory
2237
orig_root_id = inv.root.file_id
2238
# TODO: it might be nice to exit early if there was nothing
2239
# to do, saving us from trigger a sync on unlock.
2240
self._inventory_is_modified = True
2241
# we preserve the root inventory entry object, but
2242
# unlinkit from the byid index
2243
del inv._byid[inv.root.file_id]
2244
inv.root.file_id = file_id
2245
# and link it into the index with the new changed id.
2246
inv._byid[inv.root.file_id] = inv.root
2247
# and finally update all children to reference the new id.
2248
# XXX: this should be safe to just look at the root.children
2249
# list, not the WHOLE INVENTORY.
2250
for fid in inv:
2251
entry = inv[fid]
2252
if entry.parent_id == orig_root_id:
2253
entry.parent_id = inv.root.file_id
1400
2254
1401
2255
def unlock(self):
1402
2256
"""See Branch.unlock.
1433
2287
- Restore the wt.basis->wt.state changes.
1434
2288
1435
2289
There isn't a single operation at the moment to do that, so we:
1436
1437
2290
- Merge current state -> basis tree of the master w.r.t. the old tree
1438
2291
basis.
1439
2292
- Do a 'normal' merge of the old branch basis if it is relevant.
1499
2352
show_base=show_base)
1500
2353
if nb_conflicts:
1501
2354
self.add_parent_tree((old_tip, other_tree))
1502
note(gettext('Rerun update after fixing the conflicts.'))
2355
trace.note('Rerun update after fixing the conflicts.')
1503
2356
return nb_conflicts
1504
2357
1505
2358
if last_rev != _mod_revision.ensure_null(revision):
1511
2364
basis = self.basis_tree()
1512
2365
basis.lock_read()
1513
2366
try:
1514
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2367
if (basis.inventory.root is None
2368
or basis.inventory.root.file_id != to_root_id):
1515
2369
self.set_root_id(to_root_id)
1516
2370
self.flush()
1517
2371
finally:
1547
2401
last_rev = parent_trees[0][0]
1548
2402
return nb_conflicts
1549
2403
2404
def _write_hashcache_if_dirty(self):
2405
"""Write out the hashcache if it is dirty."""
2406
if self._hashcache.needs_write:
2407
try:
2408
self._hashcache.write()
2409
except OSError, e:
2410
if e.errno not in (errno.EPERM, errno.EACCES):
2411
raise
2412
# TODO: jam 20061219 Should this be a warning? A single line
2413
# warning might be sufficient to let the user know what
2414
# is going on.
2415
mutter('Could not write hashcache for %s\nError: %s',
2416
self._hashcache.cache_file_name(), e)
2417
2418
@needs_tree_write_lock
2419
def _write_inventory(self, inv):
2420
"""Write inventory as the current inventory."""
2421
self._set_inventory(inv, dirty=True)
2422
self.flush()
2423
1550
2424
def set_conflicts(self, arg):
1551
2425
raise errors.UnsupportedOperation(self.set_conflicts, self)
1552
2426
1553
2427
def add_conflicts(self, arg):
1554
2428
raise errors.UnsupportedOperation(self.add_conflicts, self)
1555
2429
2430
@needs_read_lock
1556
2431
def conflicts(self):
1557
raise NotImplementedError(self.conflicts)
2432
conflicts = _mod_conflicts.ConflictList()
2433
for conflicted in self._iter_conflicts():
2434
text = True
2435
try:
2436
if file_kind(self.abspath(conflicted)) != "file":
2437
text = False
2438
except errors.NoSuchFile:
2439
text = False
2440
if text is True:
2441
for suffix in ('.THIS', '.OTHER'):
2442
try:
2443
kind = file_kind(self.abspath(conflicted+suffix))
2444
if kind != "file":
2445
text = False
2446
except errors.NoSuchFile:
2447
text = False
2448
if text == False:
2449
break
2450
ctype = {True: 'text conflict', False: 'contents conflict'}[text]
2451
conflicts.append(_mod_conflicts.Conflict.factory(ctype,
2452
path=conflicted,
2453
file_id=self.path2id(conflicted)))
2454
return conflicts
1558
2455
1559
2456
def walkdirs(self, prefix=""):
1560
2457
"""Walk the directories of this tree.
1680
2577
def _walkdirs(self, prefix=""):
1681
2578
"""Walk the directories of this tree.
1682
2579
1683
:param prefix: is used as the directrory to start with.
1684
:returns: a generator which yields items in the form::
1685
1686
((curren_directory_path, fileid),
1687
[(file1_path, file1_name, file1_kind, None, file1_id,
1688
file1_kind), ... ])
2580
:prefix: is used as the directrory to start with.
2581
returns a generator which yields items in the form:
2582
((curren_directory_path, fileid),
2583
[(file1_path, file1_name, file1_kind, None, file1_id,
2584
file1_kind), ... ])
1689
2585
"""
1690
raise NotImplementedError(self._walkdirs)
2586
_directory = 'directory'
2587
# get the root in the inventory
2588
inv = self.inventory
2589
top_id = inv.path2id(prefix)
2590
if top_id is None:
2591
pending = []
2592
else:
2593
pending = [(prefix, '', _directory, None, top_id, None)]
2594
while pending:
2595
dirblock = []
2596
currentdir = pending.pop()
2597
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2598
top_id = currentdir[4]
2599
if currentdir[0]:
2600
relroot = currentdir[0] + '/'
2601
else:
2602
relroot = ""
2603
# FIXME: stash the node in pending
2604
entry = inv[top_id]
2605
if entry.kind == 'directory':
2606
for name, child in entry.sorted_children():
2607
dirblock.append((relroot + name, name, child.kind, None,
2608
child.file_id, child.kind
2609
))
2610
yield (currentdir[0], entry.file_id), dirblock
2611
# push the user specified dirs from dirblock
2612
for dir in reversed(dirblock):
2613
if dir[2] == _directory:
2614
pending.append(dir)
1691
2615
1692
2616
@needs_tree_write_lock
1693
2617
def auto_resolve(self):
1697
2621
are considered 'resolved', because bzr always puts conflict markers
1698
2622
into files that have text conflicts. The corresponding .THIS .BASE and
1699
2623
.OTHER files are deleted, as per 'resolve'.
1700
1701
2624
:return: a tuple of ConflictLists: (un_resolved, resolved).
1702
2625
"""
1703
2626
un_resolved = _mod_conflicts.ConflictList()
1722
2645
self.set_conflicts(un_resolved)
1723
2646
return un_resolved, resolved
1724
2647
2648
@needs_read_lock
2649
def _check(self, references):
2650
"""Check the tree for consistency.
2651
2652
:param references: A dict with keys matching the items returned by
2653
self._get_check_refs(), and values from looking those keys up in
2654
the repository.
2655
"""
2656
tree_basis = self.basis_tree()
2657
tree_basis.lock_read()
2658
try:
2659
repo_basis = references[('trees', self.last_revision())]
2660
if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2661
raise errors.BzrCheckError(
2662
"Mismatched basis inventory content.")
2663
self._validate()
2664
finally:
2665
tree_basis.unlock()
2666
1725
2667
def _validate(self):
1726
2668
"""Validate internal structures.
1727
2669
1733
2675
"""
1734
2676
return
1735
2677
2678
@needs_read_lock
1736
2679
def check_state(self):
1737
2680
"""Check that the working state is/isn't valid."""
1738
raise NotImplementedError(self.check_state)
2681
check_refs = self._get_check_refs()
2682
refs = {}
2683
for ref in check_refs:
2684
kind, value = ref
2685
if kind == 'trees':
2686
refs[ref] = self.branch.repository.revision_tree(value)
2687
self._check(refs)
1739
2688
2689
@needs_tree_write_lock
1740
2690
def reset_state(self, revision_ids=None):
1741
2691
"""Reset the state of the working tree.
1742
2692
1743
2693
This does a hard-reset to a last-known-good state. This is a way to
1744
2694
fix if something got corrupted (like the .bzr/checkout/dirstate file)
1745
2695
"""
1746
raise NotImplementedError(self.reset_state)
2696
if revision_ids is None:
2697
revision_ids = self.get_parent_ids()
2698
if not revision_ids:
2699
rt = self.branch.repository.revision_tree(
2700
_mod_revision.NULL_REVISION)
2701
else:
2702
rt = self.branch.repository.revision_tree(revision_ids[0])
2703
self._write_inventory(rt.inventory)
2704
self.set_parent_ids(revision_ids)
1747
2705
1748
2706
def _get_rules_searcher(self, default_searcher):
1749
2707
"""See Tree._get_rules_searcher."""
1758
2716
return ShelfManager(self, self._transport)
1759
2717
1760
2718
1761
class InventoryWorkingTree(WorkingTree,
1762
bzrlib.mutabletree.MutableInventoryTree):
1763
"""Base class for working trees that are inventory-oriented.
1764
1765
The inventory is held in the `Branch` working-inventory, and the
1766
files are in a directory on disk.
1767
1768
It is possible for a `WorkingTree` to have a filename which is
1769
not listed in the Inventory and vice versa.
1770
"""
1771
1772
def __init__(self, basedir='.',
1773
branch=DEPRECATED_PARAMETER,
1774
_inventory=None,
1775
_control_files=None,
1776
_internal=False,
1777
_format=None,
1778
_bzrdir=None):
1779
"""Construct a InventoryWorkingTree instance. This is not a public API.
1780
1781
:param branch: A branch to override probing for the branch.
1782
"""
1783
super(InventoryWorkingTree, self).__init__(basedir=basedir,
1784
branch=branch, _control_files=_control_files, _internal=_internal,
1785
_format=_format, _bzrdir=_bzrdir)
1786
1787
self._detect_case_handling()
1788
1789
if _inventory is None:
1790
# This will be acquired on lock_read() or lock_write()
1791
self._inventory_is_modified = False
1792
self._inventory = None
1793
else:
1794
# the caller of __init__ has provided an inventory,
1795
# we assume they know what they are doing - as its only
1796
# the Format factory and creation methods that are
1797
# permitted to do this.
1798
self._set_inventory(_inventory, dirty=False)
1799
1800
def _set_inventory(self, inv, dirty):
1801
"""Set the internal cached inventory.
1802
1803
:param inv: The inventory to set.
1804
:param dirty: A boolean indicating whether the inventory is the same
1805
logical inventory as whats on disk. If True the inventory is not
1806
the same and should be written to disk or data will be lost, if
1807
False then the inventory is the same as that on disk and any
1808
serialisation would be unneeded overhead.
1809
"""
1810
self._inventory = inv
1811
self._inventory_is_modified = dirty
1812
1813
def _detect_case_handling(self):
1814
wt_trans = self.bzrdir.get_workingtree_transport(None)
1815
try:
1816
wt_trans.stat(self._format.case_sensitive_filename)
2719
class WorkingTree2(WorkingTree):
2720
"""This is the Format 2 working tree.
2721
2722
This was the first weave based working tree.
2723
- uses os locks for locking.
2724
- uses the branch last-revision.
2725
"""
2726
2727
def __init__(self, *args, **kwargs):
2728
super(WorkingTree2, self).__init__(*args, **kwargs)
2729
# WorkingTree2 has more of a constraint that self._inventory must
2730
# exist. Because this is an older format, we don't mind the overhead
2731
# caused by the extra computation here.
2732
2733
# Newer WorkingTree's should only have self._inventory set when they
2734
# have a read lock.
2735
if self._inventory is None:
2736
self.read_working_inventory()
2737
2738
def _get_check_refs(self):
2739
"""Return the references needed to perform a check of this tree."""
2740
return [('trees', self.last_revision())]
2741
2742
def lock_tree_write(self):
2743
"""See WorkingTree.lock_tree_write().
2744
2745
In Format2 WorkingTrees we have a single lock for the branch and tree
2746
so lock_tree_write() degrades to lock_write().
2747
2748
:return: An object with an unlock method which will release the lock
2749
obtained.
2750
"""
2751
self.branch.lock_write()
2752
try:
2753
self._control_files.lock_write()
2754
return self
2755
except:
2756
self.branch.unlock()
2757
raise
2758
2759
def unlock(self):
2760
# do non-implementation specific cleanup
2761
self._cleanup()
2762
2763
# we share control files:
2764
if self._control_files._lock_count == 3:
2765
# _inventory_is_modified is always False during a read lock.
2766
if self._inventory_is_modified:
2767
self.flush()
2768
self._write_hashcache_if_dirty()
2769
2770
# reverse order of locking.
2771
try:
2772
return self._control_files.unlock()
2773
finally:
2774
self.branch.unlock()
2775
2776
2777
class WorkingTree3(WorkingTree):
2778
"""This is the Format 3 working tree.
2779
2780
This differs from the base WorkingTree by:
2781
- having its own file lock
2782
- having its own last-revision property.
2783
2784
This is new in bzr 0.8
2785
"""
2786
2787
@needs_read_lock
2788
def _last_revision(self):
2789
"""See Mutable.last_revision."""
2790
try:
2791
return self._transport.get_bytes('last-revision')
1817
2792
except errors.NoSuchFile:
1818
self.case_sensitive = True
1819
else:
1820
self.case_sensitive = False
1821
1822
self._setup_directory_is_tree_reference()
1823
1824
def _serialize(self, inventory, out_file):
1825
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1826
working=True)
1827
1828
def _deserialize(selt, in_file):
1829
return xml5.serializer_v5.read_inventory(in_file)
1830
1831
@needs_tree_write_lock
1832
def _write_inventory(self, inv):
1833
"""Write inventory as the current inventory."""
1834
self._set_inventory(inv, dirty=True)
1835
self.flush()
1836
1837
# XXX: This method should be deprecated in favour of taking in a proper
1838
# new Inventory object.
1839
@needs_tree_write_lock
1840
def set_inventory(self, new_inventory_list):
1841
from bzrlib.inventory import (Inventory,
1842
InventoryDirectory,
1843
InventoryFile,
1844
InventoryLink)
1845
inv = Inventory(self.get_root_id())
1846
for path, file_id, parent, kind in new_inventory_list:
1847
name = os.path.basename(path)
1848
if name == "":
1849
continue
1850
# fixme, there should be a factory function inv,add_??
1851
if kind == 'directory':
1852
inv.add(InventoryDirectory(file_id, name, parent))
1853
elif kind == 'file':
1854
inv.add(InventoryFile(file_id, name, parent))
1855
elif kind == 'symlink':
1856
inv.add(InventoryLink(file_id, name, parent))
1857
else:
1858
raise errors.BzrError("unknown kind %r" % kind)
1859
self._write_inventory(inv)
1860
1861
def _write_basis_inventory(self, xml):
1862
"""Write the basis inventory XML to the basis-inventory file"""
1863
path = self._basis_inventory_name()
1864
sio = StringIO(xml)
1865
self._transport.put_file(path, sio,
1866
mode=self.bzrdir._get_file_mode())
1867
1868
def _reset_data(self):
1869
"""Reset transient data that cannot be revalidated."""
1870
self._inventory_is_modified = False
1871
f = self._transport.get('inventory')
1872
try:
1873
result = self._deserialize(f)
1874
finally:
1875
f.close()
1876
self._set_inventory(result, dirty=False)
1877
1878
def _set_root_id(self, file_id):
1879
"""Set the root id for this tree, in a format specific manner.
1880
1881
:param file_id: The file id to assign to the root. It must not be
1882
present in the current inventory or an error will occur. It must
1883
not be None, but rather a valid file id.
1884
"""
1885
inv = self._inventory
1886
orig_root_id = inv.root.file_id
1887
# TODO: it might be nice to exit early if there was nothing
1888
# to do, saving us from trigger a sync on unlock.
1889
self._inventory_is_modified = True
1890
# we preserve the root inventory entry object, but
1891
# unlinkit from the byid index
1892
del inv._byid[inv.root.file_id]
1893
inv.root.file_id = file_id
1894
# and link it into the index with the new changed id.
1895
inv._byid[inv.root.file_id] = inv.root
1896
# and finally update all children to reference the new id.
1897
# XXX: this should be safe to just look at the root.children
1898
# list, not the WHOLE INVENTORY.
1899
for fid in inv:
1900
entry = inv[fid]
1901
if entry.parent_id == orig_root_id:
1902
entry.parent_id = inv.root.file_id
1903
1904
def all_file_ids(self):
1905
"""See Tree.iter_all_file_ids"""
1906
return set(self.inventory)
1907
1908
@needs_tree_write_lock
1909
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1910
"""See MutableTree.set_parent_trees."""
1911
parent_ids = [rev for (rev, tree) in parents_list]
1912
for revision_id in parent_ids:
1913
_mod_revision.check_not_reserved_id(revision_id)
1914
1915
self._check_parents_for_ghosts(parent_ids,
1916
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
1917
1918
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
1919
1920
if len(parent_ids) == 0:
1921
leftmost_parent_id = _mod_revision.NULL_REVISION
1922
leftmost_parent_tree = None
1923
else:
1924
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
1925
1926
if self._change_last_revision(leftmost_parent_id):
1927
if leftmost_parent_tree is None:
1928
# If we don't have a tree, fall back to reading the
1929
# parent tree from the repository.
1930
self._cache_basis_inventory(leftmost_parent_id)
1931
else:
1932
inv = leftmost_parent_tree.inventory
1933
xml = self._create_basis_xml_from_inventory(
1934
leftmost_parent_id, inv)
1935
self._write_basis_inventory(xml)
1936
self._set_merges_from_parent_ids(parent_ids)
1937
1938
def _cache_basis_inventory(self, new_revision):
1939
"""Cache new_revision as the basis inventory."""
1940
# TODO: this should allow the ready-to-use inventory to be passed in,
1941
# as commit already has that ready-to-use [while the format is the
1942
# same, that is].
1943
try:
1944
# this double handles the inventory - unpack and repack -
1945
# but is easier to understand. We can/should put a conditional
1946
# in here based on whether the inventory is in the latest format
1947
# - perhaps we should repack all inventories on a repository
1948
# upgrade ?
1949
# the fast path is to copy the raw xml from the repository. If the
1950
# xml contains 'revision_id="', then we assume the right
1951
# revision_id is set. We must check for this full string, because a
1952
# root node id can legitimately look like 'revision_id' but cannot
1953
# contain a '"'.
1954
xml = self.branch.repository._get_inventory_xml(new_revision)
1955
firstline = xml.split('\n', 1)[0]
1956
if (not 'revision_id="' in firstline or
1957
'format="7"' not in firstline):
1958
inv = self.branch.repository._serializer.read_inventory_from_string(
1959
xml, new_revision)
1960
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1961
self._write_basis_inventory(xml)
1962
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1963
pass
1964
1965
def _basis_inventory_name(self):
1966
return 'basis-inventory-cache'
1967
1968
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1969
"""Create the text that will be saved in basis-inventory"""
1970
inventory.revision_id = revision_id
1971
return xml7.serializer_v7.write_inventory_to_string(inventory)
2793
return _mod_revision.NULL_REVISION
2794
2795
def _change_last_revision(self, revision_id):
2796
"""See WorkingTree._change_last_revision."""
2797
if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2798
try:
2799
self._transport.delete('last-revision')
2800
except errors.NoSuchFile:
2801
pass
2802
return False
2803
else:
2804
self._transport.put_bytes('last-revision', revision_id,
2805
mode=self.bzrdir._get_file_mode())
2806
return True
2807
2808
def _get_check_refs(self):
2809
"""Return the references needed to perform a check of this tree."""
2810
return [('trees', self.last_revision())]
1972
2811
1973
2812
@needs_tree_write_lock
1974
2813
def set_conflicts(self, conflicts):
1994
2833
raise errors.ConflictFormatError()
1995
2834
except StopIteration:
1996
2835
raise errors.ConflictFormatError()
1997
reader = _mod_rio.RioReader(confile)
1998
return _mod_conflicts.ConflictList.from_stanzas(reader)
2836
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
1999
2837
finally:
2000
2838
confile.close()
2001
2839
2002
def read_basis_inventory(self):
2003
"""Read the cached basis inventory."""
2004
path = self._basis_inventory_name()
2005
return self._transport.get_bytes(path)
2006
2007
@needs_read_lock
2008
def read_working_inventory(self):
2009
"""Read the working inventory.
2010
2011
:raises errors.InventoryModified: read_working_inventory will fail
2012
when the current in memory inventory has been modified.
2013
"""
2014
# conceptually this should be an implementation detail of the tree.
2015
# XXX: Deprecate this.
2016
# ElementTree does its own conversion from UTF-8, so open in
2017
# binary.
2018
if self._inventory_is_modified:
2019
raise errors.InventoryModified(self)
2020
f = self._transport.get('inventory')
2021
try:
2022
result = self._deserialize(f)
2023
finally:
2024
f.close()
2025
self._set_inventory(result, dirty=False)
2026
return result
2027
2028
@needs_read_lock
2029
def get_root_id(self):
2030
"""Return the id of this trees root"""
2031
return self._inventory.root.file_id
2032
2033
def has_id(self, file_id):
2034
# files that have been deleted are excluded
2035
inv = self.inventory
2036
if not inv.has_id(file_id):
2037
return False
2038
path = inv.id2path(file_id)
2039
return osutils.lexists(self.abspath(path))
2040
2041
def has_or_had_id(self, file_id):
2042
if file_id == self.inventory.root.file_id:
2043
return True
2044
return self.inventory.has_id(file_id)
2045
2046
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2047
def __iter__(self):
2048
"""Iterate through file_ids for this tree.
2049
2050
file_ids are in a WorkingTree if they are in the working inventory
2051
and the working file exists.
2052
"""
2053
inv = self._inventory
2054
for path, ie in inv.iter_entries():
2055
if osutils.lexists(self.abspath(path)):
2056
yield ie.file_id
2057
2058
@needs_tree_write_lock
2059
def set_last_revision(self, new_revision):
2060
"""Change the last revision in the working tree."""
2061
if self._change_last_revision(new_revision):
2062
self._cache_basis_inventory(new_revision)
2063
2064
def _get_check_refs(self):
2065
"""Return the references needed to perform a check of this tree.
2066
2067
The default implementation returns no refs, and is only suitable for
2068
trees that have no local caching and can commit on ghosts at any time.
2069
2070
:seealso: bzrlib.check for details about check_refs.
2071
"""
2072
return []
2073
2074
@needs_read_lock
2075
def _check(self, references):
2076
"""Check the tree for consistency.
2077
2078
:param references: A dict with keys matching the items returned by
2079
self._get_check_refs(), and values from looking those keys up in
2080
the repository.
2081
"""
2082
tree_basis = self.basis_tree()
2083
tree_basis.lock_read()
2084
try:
2085
repo_basis = references[('trees', self.last_revision())]
2086
if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2087
raise errors.BzrCheckError(
2088
"Mismatched basis inventory content.")
2089
self._validate()
2090
finally:
2091
tree_basis.unlock()
2092
2093
@needs_read_lock
2094
def check_state(self):
2095
"""Check that the working state is/isn't valid."""
2096
check_refs = self._get_check_refs()
2097
refs = {}
2098
for ref in check_refs:
2099
kind, value = ref
2100
if kind == 'trees':
2101
refs[ref] = self.branch.repository.revision_tree(value)
2102
self._check(refs)
2103
2104
@needs_tree_write_lock
2105
def reset_state(self, revision_ids=None):
2106
"""Reset the state of the working tree.
2107
2108
This does a hard-reset to a last-known-good state. This is a way to
2109
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2110
"""
2111
if revision_ids is None:
2112
revision_ids = self.get_parent_ids()
2113
if not revision_ids:
2114
rt = self.branch.repository.revision_tree(
2115
_mod_revision.NULL_REVISION)
2116
else:
2117
rt = self.branch.repository.revision_tree(revision_ids[0])
2118
self._write_inventory(rt.inventory)
2119
self.set_parent_ids(revision_ids)
2120
2121
def flush(self):
2122
"""Write the in memory inventory to disk."""
2123
# TODO: Maybe this should only write on dirty ?
2124
if self._control_files._lock_mode != 'w':
2125
raise errors.NotWriteLocked(self)
2126
sio = StringIO()
2127
self._serialize(self._inventory, sio)
2128
sio.seek(0)
2129
self._transport.put_file('inventory', sio,
2130
mode=self.bzrdir._get_file_mode())
2131
self._inventory_is_modified = False
2132
2133
def get_file_mtime(self, file_id, path=None):
2134
"""See Tree.get_file_mtime."""
2135
if not path:
2136
path = self.inventory.id2path(file_id)
2137
try:
2138
return os.lstat(self.abspath(path)).st_mtime
2139
except OSError, e:
2140
if e.errno == errno.ENOENT:
2141
raise errors.FileTimestampUnavailable(path)
2142
raise
2143
2144
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2145
file_id = self.path2id(path)
2146
if file_id is None:
2147
# For unversioned files on win32, we just assume they are not
2148
# executable
2149
return False
2150
return self._inventory[file_id].executable
2151
2152
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2153
mode = stat_result.st_mode
2154
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2155
2156
if not supports_executable():
2157
def is_executable(self, file_id, path=None):
2158
return self._inventory[file_id].executable
2159
2160
_is_executable_from_path_and_stat = \
2161
_is_executable_from_path_and_stat_from_basis
2162
else:
2163
def is_executable(self, file_id, path=None):
2164
if not path:
2165
path = self.id2path(file_id)
2166
mode = os.lstat(self.abspath(path)).st_mode
2167
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2168
2169
_is_executable_from_path_and_stat = \
2170
_is_executable_from_path_and_stat_from_stat
2171
2172
@needs_tree_write_lock
2173
def _add(self, files, ids, kinds):
2174
"""See MutableTree._add."""
2175
# TODO: Re-adding a file that is removed in the working copy
2176
# should probably put it back with the previous ID.
2177
# the read and write working inventory should not occur in this
2178
# function - they should be part of lock_write and unlock.
2179
inv = self.inventory
2180
for f, file_id, kind in zip(files, ids, kinds):
2181
if file_id is None:
2182
inv.add_path(f, kind=kind)
2183
else:
2184
inv.add_path(f, kind=kind, file_id=file_id)
2185
self._inventory_is_modified = True
2186
2187
def revision_tree(self, revision_id):
2188
"""See WorkingTree.revision_id."""
2189
if revision_id == self.last_revision():
2190
try:
2191
xml = self.read_basis_inventory()
2192
except errors.NoSuchFile:
2193
pass
2194
else:
2195
try:
2196
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2197
# dont use the repository revision_tree api because we want
2198
# to supply the inventory.
2199
if inv.revision_id == revision_id:
2200
return revisiontree.InventoryRevisionTree(
2201
self.branch.repository, inv, revision_id)
2202
except errors.BadInventoryFormat:
2203
pass
2204
# raise if there was no inventory, or if we read the wrong inventory.
2205
raise errors.NoSuchRevisionInTree(self, revision_id)
2206
2207
@needs_read_lock
2208
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2209
"""See Tree.annotate_iter
2210
2211
This implementation will use the basis tree implementation if possible.
2212
Lines not in the basis are attributed to CURRENT_REVISION
2213
2214
If there are pending merges, lines added by those merges will be
2215
incorrectly attributed to CURRENT_REVISION (but after committing, the
2216
attribution will be correct).
2217
"""
2218
maybe_file_parent_keys = []
2219
for parent_id in self.get_parent_ids():
2220
try:
2221
parent_tree = self.revision_tree(parent_id)
2222
except errors.NoSuchRevisionInTree:
2223
parent_tree = self.branch.repository.revision_tree(parent_id)
2224
parent_tree.lock_read()
2225
try:
2226
if not parent_tree.has_id(file_id):
2227
continue
2228
ie = parent_tree.inventory[file_id]
2229
if ie.kind != 'file':
2230
# Note: this is slightly unnecessary, because symlinks and
2231
# directories have a "text" which is the empty text, and we
2232
# know that won't mess up annotations. But it seems cleaner
2233
continue
2234
parent_text_key = (file_id, ie.revision)
2235
if parent_text_key not in maybe_file_parent_keys:
2236
maybe_file_parent_keys.append(parent_text_key)
2237
finally:
2238
parent_tree.unlock()
2239
graph = _mod_graph.Graph(self.branch.repository.texts)
2240
heads = graph.heads(maybe_file_parent_keys)
2241
file_parent_keys = []
2242
for key in maybe_file_parent_keys:
2243
if key in heads:
2244
file_parent_keys.append(key)
2245
2246
# Now we have the parents of this content
2247
annotator = self.branch.repository.texts.get_annotator()
2248
text = self.get_file_text(file_id)
2249
this_key =(file_id, default_revision)
2250
annotator.add_special_text(this_key, file_parent_keys, text)
2251
annotations = [(key[-1], line)
2252
for key, line in annotator.annotate_flat(this_key)]
2253
return annotations
2254
2255
@needs_read_lock
2256
def merge_modified(self):
2257
"""Return a dictionary of files modified by a merge.
2258
2259
The list is initialized by WorkingTree.set_merge_modified, which is
2260
typically called after we make some automatic updates to the tree
2261
because of a merge.
2262
2263
This returns a map of file_id->sha1, containing only files which are
2264
still in the working inventory and have that text hash.
2265
"""
2266
try:
2267
hashfile = self._transport.get('merge-hashes')
2268
except errors.NoSuchFile:
2269
return {}
2270
try:
2271
merge_hashes = {}
2272
try:
2273
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2274
raise errors.MergeModifiedFormatError()
2275
except StopIteration:
2276
raise errors.MergeModifiedFormatError()
2277
for s in _mod_rio.RioReader(hashfile):
2278
# RioReader reads in Unicode, so convert file_ids back to utf8
2279
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2280
if not self.inventory.has_id(file_id):
2281
continue
2282
text_hash = s.get("hash")
2283
if text_hash == self.get_file_sha1(file_id):
2284
merge_hashes[file_id] = text_hash
2285
return merge_hashes
2286
finally:
2287
hashfile.close()
2288
2289
@needs_write_lock
2290
def subsume(self, other_tree):
2291
def add_children(inventory, entry):
2292
for child_entry in entry.children.values():
2293
inventory._byid[child_entry.file_id] = child_entry
2294
if child_entry.kind == 'directory':
2295
add_children(inventory, child_entry)
2296
if other_tree.get_root_id() == self.get_root_id():
2297
raise errors.BadSubsumeSource(self, other_tree,
2298
'Trees have the same root')
2299
try:
2300
other_tree_path = self.relpath(other_tree.basedir)
2301
except errors.PathNotChild:
2302
raise errors.BadSubsumeSource(self, other_tree,
2303
'Tree is not contained by the other')
2304
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2305
if new_root_parent is None:
2306
raise errors.BadSubsumeSource(self, other_tree,
2307
'Parent directory is not versioned.')
2308
# We need to ensure that the result of a fetch will have a
2309
# versionedfile for the other_tree root, and only fetching into
2310
# RepositoryKnit2 guarantees that.
2311
if not self.branch.repository.supports_rich_root():
2312
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2313
other_tree.lock_tree_write()
2314
try:
2315
new_parents = other_tree.get_parent_ids()
2316
other_root = other_tree.inventory.root
2317
other_root.parent_id = new_root_parent
2318
other_root.name = osutils.basename(other_tree_path)
2319
self.inventory.add(other_root)
2320
add_children(self.inventory, other_root)
2321
self._write_inventory(self.inventory)
2322
# normally we don't want to fetch whole repositories, but i think
2323
# here we really do want to consolidate the whole thing.
2324
for parent_id in other_tree.get_parent_ids():
2325
self.branch.fetch(other_tree.branch, parent_id)
2326
self.add_parent_tree_id(parent_id)
2327
finally:
2328
other_tree.unlock()
2329
other_tree.bzrdir.retire_bzrdir()
2330
2331
@needs_tree_write_lock
2332
def extract(self, file_id, format=None):
2333
"""Extract a subtree from this tree.
2334
2335
A new branch will be created, relative to the path for this tree.
2336
"""
2337
self.flush()
2338
def mkdirs(path):
2339
segments = osutils.splitpath(path)
2340
transport = self.branch.bzrdir.root_transport
2341
for name in segments:
2342
transport = transport.clone(name)
2343
transport.ensure_base()
2344
return transport
2345
2346
sub_path = self.id2path(file_id)
2347
branch_transport = mkdirs(sub_path)
2348
if format is None:
2349
format = self.bzrdir.cloning_metadir()
2350
branch_transport.ensure_base()
2351
branch_bzrdir = format.initialize_on_transport(branch_transport)
2352
try:
2353
repo = branch_bzrdir.find_repository()
2354
except errors.NoRepositoryPresent:
2355
repo = branch_bzrdir.create_repository()
2356
if not repo.supports_rich_root():
2357
raise errors.RootNotRich()
2358
new_branch = branch_bzrdir.create_branch()
2359
new_branch.pull(self.branch)
2360
for parent_id in self.get_parent_ids():
2361
new_branch.fetch(self.branch, parent_id)
2362
tree_transport = self.bzrdir.root_transport.clone(sub_path)
2363
if tree_transport.base != branch_transport.base:
2364
tree_bzrdir = format.initialize_on_transport(tree_transport)
2365
branch.BranchReferenceFormat().initialize(tree_bzrdir,
2366
target_branch=new_branch)
2367
else:
2368
tree_bzrdir = branch_bzrdir
2369
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2370
wt.set_parent_ids(self.get_parent_ids())
2371
my_inv = self.inventory
2372
child_inv = inventory.Inventory(root_id=None)
2373
new_root = my_inv[file_id]
2374
my_inv.remove_recursive_id(file_id)
2375
new_root.parent_id = None
2376
child_inv.add(new_root)
2377
self._write_inventory(my_inv)
2378
wt._write_inventory(child_inv)
2379
return wt
2380
2381
def list_files(self, include_root=False, from_dir=None, recursive=True):
2382
"""List all files as (path, class, kind, id, entry).
2383
2384
Lists, but does not descend into unversioned directories.
2385
This does not include files that have been deleted in this
2386
tree. Skips the control directory.
2387
2388
:param include_root: if True, return an entry for the root
2389
:param from_dir: start from this directory or None for the root
2390
:param recursive: whether to recurse into subdirectories or not
2391
"""
2392
# list_files is an iterator, so @needs_read_lock doesn't work properly
2393
# with it. So callers should be careful to always read_lock the tree.
2394
if not self.is_locked():
2395
raise errors.ObjectNotLocked(self)
2396
2397
inv = self.inventory
2398
if from_dir is None and include_root is True:
2399
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2400
# Convert these into local objects to save lookup times
2401
pathjoin = osutils.pathjoin
2402
file_kind = self._kind
2403
2404
# transport.base ends in a slash, we want the piece
2405
# between the last two slashes
2406
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2407
2408
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2409
2410
# directory file_id, relative path, absolute path, reverse sorted children
2411
if from_dir is not None:
2412
from_dir_id = inv.path2id(from_dir)
2413
if from_dir_id is None:
2414
# Directory not versioned
2415
return
2416
from_dir_abspath = pathjoin(self.basedir, from_dir)
2417
else:
2418
from_dir_id = inv.root.file_id
2419
from_dir_abspath = self.basedir
2420
children = os.listdir(from_dir_abspath)
2421
children.sort()
2422
# jam 20060527 The kernel sized tree seems equivalent whether we
2423
# use a deque and popleft to keep them sorted, or if we use a plain
2424
# list and just reverse() them.
2425
children = collections.deque(children)
2426
stack = [(from_dir_id, u'', from_dir_abspath, children)]
2427
while stack:
2428
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2429
2430
while children:
2431
f = children.popleft()
2432
## TODO: If we find a subdirectory with its own .bzr
2433
## directory, then that is a separate tree and we
2434
## should exclude it.
2435
2436
# the bzrdir for this tree
2437
if transport_base_dir == f:
2438
continue
2439
2440
# we know that from_dir_relpath and from_dir_abspath never end in a slash
2441
# and 'f' doesn't begin with one, we can do a string op, rather
2442
# than the checks of pathjoin(), all relative paths will have an extra slash
2443
# at the beginning
2444
fp = from_dir_relpath + '/' + f
2445
2446
# absolute path
2447
fap = from_dir_abspath + '/' + f
2448
2449
dir_ie = inv[from_dir_id]
2450
if dir_ie.kind == 'directory':
2451
f_ie = dir_ie.children.get(f)
2452
else:
2453
f_ie = None
2454
if f_ie:
2455
c = 'V'
2456
elif self.is_ignored(fp[1:]):
2457
c = 'I'
2458
else:
2459
# we may not have found this file, because of a unicode
2460
# issue, or because the directory was actually a symlink.
2461
f_norm, can_access = osutils.normalized_filename(f)
2462
if f == f_norm or not can_access:
2463
# No change, so treat this file normally
2464
c = '?'
2465
else:
2466
# this file can be accessed by a normalized path
2467
# check again if it is versioned
2468
# these lines are repeated here for performance
2469
f = f_norm
2470
fp = from_dir_relpath + '/' + f
2471
fap = from_dir_abspath + '/' + f
2472
f_ie = inv.get_child(from_dir_id, f)
2473
if f_ie:
2474
c = 'V'
2475
elif self.is_ignored(fp[1:]):
2476
c = 'I'
2477
else:
2478
c = '?'
2479
2480
fk = file_kind(fap)
2481
2482
# make a last minute entry
2483
if f_ie:
2484
yield fp[1:], c, fk, f_ie.file_id, f_ie
2485
else:
2486
try:
2487
yield fp[1:], c, fk, None, fk_entries[fk]()
2488
except KeyError:
2489
yield fp[1:], c, fk, None, TreeEntry()
2490
continue
2491
2492
if fk != 'directory':
2493
continue
2494
2495
# But do this child first if recursing down
2496
if recursive:
2497
new_children = os.listdir(fap)
2498
new_children.sort()
2499
new_children = collections.deque(new_children)
2500
stack.append((f_ie.file_id, fp, fap, new_children))
2501
# Break out of inner loop,
2502
# so that we start outer loop with child
2503
break
2504
else:
2505
# if we finished all children, pop it off the stack
2506
stack.pop()
2507
2508
@needs_tree_write_lock
2509
def move(self, from_paths, to_dir=None, after=False):
2510
"""Rename files.
2511
2512
to_dir must exist in the inventory.
2513
2514
If to_dir exists and is a directory, the files are moved into
2515
it, keeping their old names.
2516
2517
Note that to_dir is only the last component of the new name;
2518
this doesn't change the directory.
2519
2520
For each entry in from_paths the move mode will be determined
2521
independently.
2522
2523
The first mode moves the file in the filesystem and updates the
2524
inventory. The second mode only updates the inventory without
2525
touching the file on the filesystem.
2526
2527
move uses the second mode if 'after == True' and the target is
2528
either not versioned or newly added, and present in the working tree.
2529
2530
move uses the second mode if 'after == False' and the source is
2531
versioned but no longer in the working tree, and the target is not
2532
versioned but present in the working tree.
2533
2534
move uses the first mode if 'after == False' and the source is
2535
versioned and present in the working tree, and the target is not
2536
versioned and not present in the working tree.
2537
2538
Everything else results in an error.
2539
2540
This returns a list of (from_path, to_path) pairs for each
2541
entry that is moved.
2542
"""
2543
rename_entries = []
2544
rename_tuples = []
2545
2546
# check for deprecated use of signature
2547
if to_dir is None:
2548
raise TypeError('You must supply a target directory')
2549
# check destination directory
2550
if isinstance(from_paths, basestring):
2551
raise ValueError()
2552
inv = self.inventory
2553
to_abs = self.abspath(to_dir)
2554
if not isdir(to_abs):
2555
raise errors.BzrMoveFailedError('',to_dir,
2556
errors.NotADirectory(to_abs))
2557
if not self.has_filename(to_dir):
2558
raise errors.BzrMoveFailedError('',to_dir,
2559
errors.NotInWorkingDirectory(to_dir))
2560
to_dir_id = inv.path2id(to_dir)
2561
if to_dir_id is None:
2562
raise errors.BzrMoveFailedError('',to_dir,
2563
errors.NotVersionedError(path=to_dir))
2564
2565
to_dir_ie = inv[to_dir_id]
2566
if to_dir_ie.kind != 'directory':
2567
raise errors.BzrMoveFailedError('',to_dir,
2568
errors.NotADirectory(to_abs))
2569
2570
# create rename entries and tuples
2571
for from_rel in from_paths:
2572
from_tail = splitpath(from_rel)[-1]
2573
from_id = inv.path2id(from_rel)
2574
if from_id is None:
2575
raise errors.BzrMoveFailedError(from_rel,to_dir,
2576
errors.NotVersionedError(path=from_rel))
2577
2578
from_entry = inv[from_id]
2579
from_parent_id = from_entry.parent_id
2580
to_rel = pathjoin(to_dir, from_tail)
2581
rename_entry = InventoryWorkingTree._RenameEntry(
2582
from_rel=from_rel,
2583
from_id=from_id,
2584
from_tail=from_tail,
2585
from_parent_id=from_parent_id,
2586
to_rel=to_rel, to_tail=from_tail,
2587
to_parent_id=to_dir_id)
2588
rename_entries.append(rename_entry)
2589
rename_tuples.append((from_rel, to_rel))
2590
2591
# determine which move mode to use. checks also for movability
2592
rename_entries = self._determine_mv_mode(rename_entries, after)
2593
2594
original_modified = self._inventory_is_modified
2595
try:
2596
if len(from_paths):
2597
self._inventory_is_modified = True
2598
self._move(rename_entries)
2599
except:
2600
# restore the inventory on error
2601
self._inventory_is_modified = original_modified
2602
raise
2603
self._write_inventory(inv)
2604
return rename_tuples
2605
2606
@needs_tree_write_lock
2607
def rename_one(self, from_rel, to_rel, after=False):
2608
"""Rename one file.
2609
2610
This can change the directory or the filename or both.
2611
2612
rename_one has several 'modes' to work. First, it can rename a physical
2613
file and change the file_id. That is the normal mode. Second, it can
2614
only change the file_id without touching any physical file.
2615
2616
rename_one uses the second mode if 'after == True' and 'to_rel' is not
2617
versioned but present in the working tree.
2618
2619
rename_one uses the second mode if 'after == False' and 'from_rel' is
2620
versioned but no longer in the working tree, and 'to_rel' is not
2621
versioned but present in the working tree.
2622
2623
rename_one uses the first mode if 'after == False' and 'from_rel' is
2624
versioned and present in the working tree, and 'to_rel' is not
2625
versioned and not present in the working tree.
2626
2627
Everything else results in an error.
2628
"""
2629
inv = self.inventory
2630
rename_entries = []
2631
2632
# create rename entries and tuples
2633
from_tail = splitpath(from_rel)[-1]
2634
from_id = inv.path2id(from_rel)
2635
if from_id is None:
2636
# if file is missing in the inventory maybe it's in the basis_tree
2637
basis_tree = self.branch.basis_tree()
2638
from_id = basis_tree.path2id(from_rel)
2639
if from_id is None:
2640
raise errors.BzrRenameFailedError(from_rel,to_rel,
2641
errors.NotVersionedError(path=from_rel))
2642
# put entry back in the inventory so we can rename it
2643
from_entry = basis_tree.inventory[from_id].copy()
2644
inv.add(from_entry)
2645
else:
2646
from_entry = inv[from_id]
2647
from_parent_id = from_entry.parent_id
2648
to_dir, to_tail = os.path.split(to_rel)
2649
to_dir_id = inv.path2id(to_dir)
2650
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2651
from_id=from_id,
2652
from_tail=from_tail,
2653
from_parent_id=from_parent_id,
2654
to_rel=to_rel, to_tail=to_tail,
2655
to_parent_id=to_dir_id)
2656
rename_entries.append(rename_entry)
2657
2658
# determine which move mode to use. checks also for movability
2659
rename_entries = self._determine_mv_mode(rename_entries, after)
2660
2661
# check if the target changed directory and if the target directory is
2662
# versioned
2663
if to_dir_id is None:
2664
raise errors.BzrMoveFailedError(from_rel,to_rel,
2665
errors.NotVersionedError(path=to_dir))
2666
2667
# all checks done. now we can continue with our actual work
2668
mutter('rename_one:\n'
2669
' from_id {%s}\n'
2670
' from_rel: %r\n'
2671
' to_rel: %r\n'
2672
' to_dir %r\n'
2673
' to_dir_id {%s}\n',
2674
from_id, from_rel, to_rel, to_dir, to_dir_id)
2675
2676
self._move(rename_entries)
2677
self._write_inventory(inv)
2678
2679
class _RenameEntry(object):
2680
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2681
to_rel, to_tail, to_parent_id, only_change_inv=False,
2682
change_id=False):
2683
self.from_rel = from_rel
2684
self.from_id = from_id
2685
self.from_tail = from_tail
2686
self.from_parent_id = from_parent_id
2687
self.to_rel = to_rel
2688
self.to_tail = to_tail
2689
self.to_parent_id = to_parent_id
2690
self.change_id = change_id
2691
self.only_change_inv = only_change_inv
2692
2693
def _determine_mv_mode(self, rename_entries, after=False):
2694
"""Determines for each from-to pair if both inventory and working tree
2695
or only the inventory has to be changed.
2696
2697
Also does basic plausability tests.
2698
"""
2699
inv = self.inventory
2700
2701
for rename_entry in rename_entries:
2702
# store to local variables for easier reference
2703
from_rel = rename_entry.from_rel
2704
from_id = rename_entry.from_id
2705
to_rel = rename_entry.to_rel
2706
to_id = inv.path2id(to_rel)
2707
only_change_inv = False
2708
change_id = False
2709
2710
# check the inventory for source and destination
2711
if from_id is None:
2712
raise errors.BzrMoveFailedError(from_rel,to_rel,
2713
errors.NotVersionedError(path=from_rel))
2714
if to_id is not None:
2715
allowed = False
2716
# allow it with --after but only if dest is newly added
2717
if after:
2718
basis = self.basis_tree()
2719
basis.lock_read()
2720
try:
2721
if not basis.has_id(to_id):
2722
rename_entry.change_id = True
2723
allowed = True
2724
finally:
2725
basis.unlock()
2726
if not allowed:
2727
raise errors.BzrMoveFailedError(from_rel,to_rel,
2728
errors.AlreadyVersionedError(path=to_rel))
2729
2730
# try to determine the mode for rename (only change inv or change
2731
# inv and file system)
2732
if after:
2733
if not self.has_filename(to_rel):
2734
raise errors.BzrMoveFailedError(from_id,to_rel,
2735
errors.NoSuchFile(path=to_rel,
2736
extra="New file has not been created yet"))
2737
only_change_inv = True
2738
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2739
only_change_inv = True
2740
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2741
only_change_inv = False
2742
elif (not self.case_sensitive
2743
and from_rel.lower() == to_rel.lower()
2744
and self.has_filename(from_rel)):
2745
only_change_inv = False
2746
else:
2747
# something is wrong, so lets determine what exactly
2748
if not self.has_filename(from_rel) and \
2749
not self.has_filename(to_rel):
2750
raise errors.BzrRenameFailedError(from_rel,to_rel,
2751
errors.PathsDoNotExist(paths=(str(from_rel),
2752
str(to_rel))))
2753
else:
2754
raise errors.RenameFailedFilesExist(from_rel, to_rel)
2755
rename_entry.only_change_inv = only_change_inv
2756
return rename_entries
2757
2758
def _move(self, rename_entries):
2759
"""Moves a list of files.
2760
2761
Depending on the value of the flag 'only_change_inv', the
2762
file will be moved on the file system or not.
2763
"""
2764
inv = self.inventory
2765
moved = []
2766
2767
for entry in rename_entries:
2768
try:
2769
self._move_entry(entry)
2770
except:
2771
self._rollback_move(moved)
2772
raise
2773
moved.append(entry)
2774
2775
def _rollback_move(self, moved):
2776
"""Try to rollback a previous move in case of an filesystem error."""
2777
inv = self.inventory
2778
for entry in moved:
2779
try:
2780
self._move_entry(WorkingTree._RenameEntry(
2781
entry.to_rel, entry.from_id,
2782
entry.to_tail, entry.to_parent_id, entry.from_rel,
2783
entry.from_tail, entry.from_parent_id,
2784
entry.only_change_inv))
2785
except errors.BzrMoveFailedError, e:
2786
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2787
" The working tree is in an inconsistent state."
2788
" Please consider doing a 'bzr revert'."
2789
" Error message is: %s" % e)
2790
2791
def _move_entry(self, entry):
2792
inv = self.inventory
2793
from_rel_abs = self.abspath(entry.from_rel)
2794
to_rel_abs = self.abspath(entry.to_rel)
2795
if from_rel_abs == to_rel_abs:
2796
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2797
"Source and target are identical.")
2798
2799
if not entry.only_change_inv:
2800
try:
2801
osutils.rename(from_rel_abs, to_rel_abs)
2802
except OSError, e:
2803
raise errors.BzrMoveFailedError(entry.from_rel,
2804
entry.to_rel, e[1])
2805
if entry.change_id:
2806
to_id = inv.path2id(entry.to_rel)
2807
inv.remove_recursive_id(to_id)
2808
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2809
2810
@needs_tree_write_lock
2811
def unversion(self, file_ids):
2812
"""Remove the file ids in file_ids from the current versioned set.
2813
2814
When a file_id is unversioned, all of its children are automatically
2815
unversioned.
2816
2817
:param file_ids: The file ids to stop versioning.
2818
:raises: NoSuchId if any fileid is not currently versioned.
2819
"""
2820
for file_id in file_ids:
2821
if not self._inventory.has_id(file_id):
2822
raise errors.NoSuchId(self, file_id)
2823
for file_id in file_ids:
2824
if self._inventory.has_id(file_id):
2825
self._inventory.remove_recursive_id(file_id)
2826
if len(file_ids):
2827
# in the future this should just set a dirty bit to wait for the
2828
# final unlock. However, until all methods of workingtree start
2829
# with the current in -memory inventory rather than triggering
2830
# a read, it is more complex - we need to teach read_inventory
2831
# to know when to read, and when to not read first... and possibly
2832
# to save first when the in memory one may be corrupted.
2833
# so for now, we just only write it if it is indeed dirty.
2834
# - RBC 20060907
2835
self._write_inventory(self._inventory)
2836
2837
def stored_kind(self, file_id):
2838
"""See Tree.stored_kind"""
2839
return self.inventory[file_id].kind
2840
2841
def extras(self):
2842
"""Yield all unversioned files in this WorkingTree.
2843
2844
If there are any unversioned directories then only the directory is
2845
returned, not all its children. But if there are unversioned files
2846
under a versioned subdirectory, they are returned.
2847
2848
Currently returned depth-first, sorted by name within directories.
2849
This is the same order used by 'osutils.walkdirs'.
2850
"""
2851
## TODO: Work from given directory downwards
2852
for path, dir_entry in self.inventory.directories():
2853
# mutter("search for unknowns in %r", path)
2854
dirabs = self.abspath(path)
2855
if not isdir(dirabs):
2856
# e.g. directory deleted
2857
continue
2858
2859
fl = []
2860
for subf in os.listdir(dirabs):
2861
if self.bzrdir.is_control_filename(subf):
2862
continue
2863
if subf not in dir_entry.children:
2864
try:
2865
(subf_norm,
2866
can_access) = osutils.normalized_filename(subf)
2867
except UnicodeDecodeError:
2868
path_os_enc = path.encode(osutils._fs_enc)
2869
relpath = path_os_enc + '/' + subf
2870
raise errors.BadFilenameEncoding(relpath,
2871
osutils._fs_enc)
2872
if subf_norm != subf and can_access:
2873
if subf_norm not in dir_entry.children:
2874
fl.append(subf_norm)
2875
else:
2876
fl.append(subf)
2877
2878
fl.sort()
2879
for subf in fl:
2880
subp = pathjoin(path, subf)
2881
yield subp
2882
2883
def _walkdirs(self, prefix=""):
2884
"""Walk the directories of this tree.
2885
2886
:param prefix: is used as the directrory to start with.
2887
:returns: a generator which yields items in the form::
2888
2889
((curren_directory_path, fileid),
2890
[(file1_path, file1_name, file1_kind, None, file1_id,
2891
file1_kind), ... ])
2892
"""
2893
_directory = 'directory'
2894
# get the root in the inventory
2895
inv = self.inventory
2896
top_id = inv.path2id(prefix)
2897
if top_id is None:
2898
pending = []
2899
else:
2900
pending = [(prefix, '', _directory, None, top_id, None)]
2901
while pending:
2902
dirblock = []
2903
currentdir = pending.pop()
2904
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2905
top_id = currentdir[4]
2906
if currentdir[0]:
2907
relroot = currentdir[0] + '/'
2908
else:
2909
relroot = ""
2910
# FIXME: stash the node in pending
2911
entry = inv[top_id]
2912
if entry.kind == 'directory':
2913
for name, child in entry.sorted_children():
2914
dirblock.append((relroot + name, name, child.kind, None,
2915
child.file_id, child.kind
2916
))
2917
yield (currentdir[0], entry.file_id), dirblock
2918
# push the user specified dirs from dirblock
2919
for dir in reversed(dirblock):
2920
if dir[2] == _directory:
2921
pending.append(dir)
2922
2923
2924
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2925
"""Registry for working tree formats."""
2926
2927
def __init__(self, other_registry=None):
2928
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2929
self._default_format = None
2930
self._default_format_key = None
2931
2932
def get_default(self):
2933
"""Return the current default format."""
2934
if (self._default_format_key is not None and
2935
self._default_format is None):
2936
self._default_format = self.get(self._default_format_key)
2937
return self._default_format
2938
2939
def set_default(self, format):
2940
"""Set the default format."""
2941
self._default_format = format
2942
self._default_format_key = None
2943
2944
def set_default_key(self, format_string):
2945
"""Set the default format by its format string."""
2946
self._default_format_key = format_string
2947
self._default_format = None
2948
2949
2950
format_registry = WorkingTreeFormatRegistry()
2951
2952
2953
class WorkingTreeFormat(controldir.ControlComponentFormat):
2840
def unlock(self):
2841
# do non-implementation specific cleanup
2842
self._cleanup()
2843
if self._control_files._lock_count == 1:
2844
# _inventory_is_modified is always False during a read lock.
2845
if self._inventory_is_modified:
2846
self.flush()
2847
self._write_hashcache_if_dirty()
2848
# reverse order of locking.
2849
try:
2850
return self._control_files.unlock()
2851
finally:
2852
self.branch.unlock()
2853
2854
2855
def get_conflicted_stem(path):
2856
for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
2857
if path.endswith(suffix):
2858
return path[:-len(suffix)]
2859
2860
2861
class WorkingTreeFormat(object):
2954
2862
"""An encapsulation of the initialization and open routines for a format.
2955
2863
2956
2864
Formats provide three things:
2968
2876
object will be created every time regardless.
2969
2877
"""
2970
2878
2879
_default_format = None
2880
"""The default format used for new trees."""
2881
2882
_formats = {}
2883
"""The known formats."""
2884
2885
_extra_formats = []
2886
"""Extra formats that can not be used in a metadir."""
2887
2971
2888
requires_rich_root = False
2972
2889
2973
2890
upgrade_recommended = False
2976
2893
2977
2894
case_sensitive_filename = "FoRMaT"
2978
2895
2979
missing_parent_conflicts = False
2980
"""If this format supports missing parent conflicts."""
2981
2982
supports_versioned_directories = None
2983
2984
2896
@classmethod
2985
def find_format_string(klass, a_bzrdir):
2986
"""Return format name for the working tree object in a_bzrdir."""
2897
def find_format(klass, a_bzrdir):
2898
"""Return the format for the working tree object in a_bzrdir."""
2987
2899
try:
2988
2900
transport = a_bzrdir.get_workingtree_transport(None)
2989
return transport.get_bytes("format")
2901
format_string = transport.get_bytes("format")
2902
return klass._formats[format_string]
2990
2903
except errors.NoSuchFile:
2991
2904
raise errors.NoWorkingTree(base=transport.base)
2992
2993
@classmethod
2994
def find_format(klass, a_bzrdir):
2995
"""Return the format for the working tree object in a_bzrdir."""
2996
try:
2997
format_string = klass.find_format_string(a_bzrdir)
2998
return format_registry.get(format_string)
2999
2905
except KeyError:
3000
2906
raise errors.UnknownFormatError(format=format_string,
3001
2907
kind="working tree")
3002
2908
3003
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3004
accelerator_tree=None, hardlink=False):
3005
"""Initialize a new working tree in a_bzrdir.
3006
3007
:param a_bzrdir: BzrDir to initialize the working tree in.
3008
:param revision_id: allows creating a working tree at a different
3009
revision than the branch is at.
3010
:param from_branch: Branch to checkout
3011
:param accelerator_tree: A tree which can be used for retrieving file
3012
contents more quickly than the revision tree, i.e. a workingtree.
3013
The revision tree will be used for cases where accelerator_tree's
3014
content is different.
3015
:param hardlink: If true, hard-link files from accelerator_tree,
3016
where possible.
3017
"""
3018
raise NotImplementedError(self.initialize)
3019
3020
2909
def __eq__(self, other):
3021
2910
return self.__class__ is other.__class__
3022
2911
3024
2913
return not (self == other)
3025
2914
3026
2915
@classmethod
3027
@symbol_versioning.deprecated_method(
3028
symbol_versioning.deprecated_in((2, 4, 0)))
3029
2916
def get_default_format(klass):
3030
2917
"""Return the current default format."""
3031
return format_registry.get_default()
2918
return klass._default_format
3032
2919
3033
2920
def get_format_string(self):
3034
2921
"""Return the ASCII format string that identifies this format."""
3056
2943
return False
3057
2944
3058
2945
@classmethod
3059
@symbol_versioning.deprecated_method(
3060
symbol_versioning.deprecated_in((2, 4, 0)))
3061
2946
def register_format(klass, format):
3062
format_registry.register(format)
2947
klass._formats[format.get_format_string()] = format
3063
2948
3064
2949
@classmethod
3065
@symbol_versioning.deprecated_method(
3066
symbol_versioning.deprecated_in((2, 4, 0)))
3067
2950
def register_extra_format(klass, format):
3068
format_registry.register_extra(format)
2951
klass._extra_formats.append(format)
3069
2952
3070
2953
@classmethod
3071
@symbol_versioning.deprecated_method(
3072
symbol_versioning.deprecated_in((2, 4, 0)))
3073
2954
def unregister_extra_format(klass, format):
3074
format_registry.unregister_extra(format)
2955
klass._extra_formats.remove(format)
3075
2956
3076
2957
@classmethod
3077
@symbol_versioning.deprecated_method(
3078
symbol_versioning.deprecated_in((2, 4, 0)))
3079
2958
def get_formats(klass):
3080
return format_registry._get_all()
2959
return klass._formats.values() + klass._extra_formats
3081
2960
3082
2961
@classmethod
3083
@symbol_versioning.deprecated_method(
3084
symbol_versioning.deprecated_in((2, 4, 0)))
3085
2962
def set_default_format(klass, format):
3086
format_registry.set_default(format)
2963
klass._default_format = format
3087
2964
3088
2965
@classmethod
3089
@symbol_versioning.deprecated_method(
3090
symbol_versioning.deprecated_in((2, 4, 0)))
3091
2966
def unregister_format(klass, format):
3092
format_registry.remove(format)
3093
3094
def get_controldir_for_branch(self):
3095
"""Get the control directory format for creating branches.
3096
3097
This is to support testing of working tree formats that can not exist
3098
in the same control directory as a branch.
3099
"""
3100
return self._matchingbzrdir
3101
3102
3103
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3104
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3105
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3106
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3107
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3108
"bzrlib.workingtree_4", "WorkingTreeFormat6")
3109
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
3110
"bzrlib.workingtree_3", "WorkingTreeFormat3")
3111
format_registry.set_default_key("Bazaar Working Tree Format 6 (bzr 1.14)\n")
2967
del klass._formats[format.get_format_string()]
2968
2969
2970
class WorkingTreeFormat2(WorkingTreeFormat):
2971
"""The second working tree format.
2972
2973
This format modified the hash cache from the format 1 hash cache.
2974
"""
2975
2976
upgrade_recommended = True
2977
2978
requires_normalized_unicode_filenames = True
2979
2980
case_sensitive_filename = "Branch-FoRMaT"
2981
2982
def get_format_description(self):
2983
"""See WorkingTreeFormat.get_format_description()."""
2984
return "Working tree format 2"
2985
2986
def _stub_initialize_on_transport(self, transport, file_mode):
2987
"""Workaround: create control files for a remote working tree.
2988
2989
This ensures that it can later be updated and dealt with locally,
2990
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2991
no working tree. (See bug #43064).
2992
"""
2993
sio = StringIO()
2994
inv = inventory.Inventory()
2995
xml5.serializer_v5.write_inventory(inv, sio, working=True)
2996
sio.seek(0)
2997
transport.put_file('inventory', sio, file_mode)
2998
transport.put_bytes('pending-merges', '', file_mode)
2999
3000
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3001
accelerator_tree=None, hardlink=False):
3002
"""See WorkingTreeFormat.initialize()."""
3003
if not isinstance(a_bzrdir.transport, LocalTransport):
3004
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3005
if from_branch is not None:
3006
branch = from_branch
3007
else:
3008
branch = a_bzrdir.open_branch()
3009
if revision_id is None:
3010
revision_id = _mod_revision.ensure_null(branch.last_revision())
3011
branch.lock_write()
3012
try:
3013
branch.generate_revision_history(revision_id)
3014
finally:
3015
branch.unlock()
3016
inv = inventory.Inventory()
3017
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
3018
branch,
3019
inv,
3020
_internal=True,
3021
_format=self,
3022
_bzrdir=a_bzrdir,
3023
_control_files=branch.control_files)
3024
basis_tree = branch.repository.revision_tree(revision_id)
3025
if basis_tree.inventory.root is not None:
3026
wt.set_root_id(basis_tree.get_root_id())
3027
# set the parent list and cache the basis tree.
3028
if _mod_revision.is_null(revision_id):
3029
parent_trees = []
3030
else:
3031
parent_trees = [(revision_id, basis_tree)]
3032
wt.set_parent_trees(parent_trees)
3033
transform.build_tree(basis_tree, wt)
3034
return wt
3035
3036
def __init__(self):
3037
super(WorkingTreeFormat2, self).__init__()
3038
self._matchingbzrdir = bzrdir.BzrDirFormat6()
3039
3040
def open(self, a_bzrdir, _found=False):
3041
"""Return the WorkingTree object for a_bzrdir
3042
3043
_found is a private parameter, do not use it. It is used to indicate
3044
if format probing has already been done.
3045
"""
3046
if not _found:
3047
# we are being called directly and must probe.
3048
raise NotImplementedError
3049
if not isinstance(a_bzrdir.transport, LocalTransport):
3050
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3051
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
3052
_internal=True,
3053
_format=self,
3054
_bzrdir=a_bzrdir,
3055
_control_files=a_bzrdir.open_branch().control_files)
3056
return wt
3057
3058
class WorkingTreeFormat3(WorkingTreeFormat):
3059
"""The second working tree format updated to record a format marker.
3060
3061
This format:
3062
- exists within a metadir controlling .bzr
3063
- includes an explicit version marker for the workingtree control
3064
files, separate from the BzrDir format
3065
- modifies the hash cache format
3066
- is new in bzr 0.8
3067
- uses a LockDir to guard access for writes.
3068
"""
3069
3070
upgrade_recommended = True
3071
3072
def get_format_string(self):
3073
"""See WorkingTreeFormat.get_format_string()."""
3074
return "Bazaar-NG Working Tree format 3"
3075
3076
def get_format_description(self):
3077
"""See WorkingTreeFormat.get_format_description()."""
3078
return "Working tree format 3"
3079
3080
_lock_file_name = 'lock'
3081
_lock_class = LockDir
3082
3083
_tree_class = WorkingTree3
3084
3085
def __get_matchingbzrdir(self):
3086
return bzrdir.BzrDirMetaFormat1()
3087
3088
_matchingbzrdir = property(__get_matchingbzrdir)
3089
3090
def _open_control_files(self, a_bzrdir):
3091
transport = a_bzrdir.get_workingtree_transport(None)
3092
return LockableFiles(transport, self._lock_file_name,
3093
self._lock_class)
3094
3095
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3096
accelerator_tree=None, hardlink=False):
3097
"""See WorkingTreeFormat.initialize().
3098
3099
:param revision_id: if supplied, create a working tree at a different
3100
revision than the branch is at.
3101
:param accelerator_tree: A tree which can be used for retrieving file
3102
contents more quickly than the revision tree, i.e. a workingtree.
3103
The revision tree will be used for cases where accelerator_tree's
3104
content is different.
3105
:param hardlink: If true, hard-link files from accelerator_tree,
3106
where possible.
3107
"""
3108
if not isinstance(a_bzrdir.transport, LocalTransport):
3109
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3110
transport = a_bzrdir.get_workingtree_transport(self)
3111
control_files = self._open_control_files(a_bzrdir)
3112
control_files.create_lock()
3113
control_files.lock_write()
3114
transport.put_bytes('format', self.get_format_string(),
3115
mode=a_bzrdir._get_file_mode())
3116
if from_branch is not None:
3117
branch = from_branch
3118
else:
3119
branch = a_bzrdir.open_branch()
3120
if revision_id is None:
3121
revision_id = _mod_revision.ensure_null(branch.last_revision())
3122
# WorkingTree3 can handle an inventory which has a unique root id.
3123
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
3124
# those trees. And because there isn't a format bump inbetween, we
3125
# are maintaining compatibility with older clients.
3126
# inv = Inventory(root_id=gen_root_id())
3127
inv = self._initial_inventory()
3128
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3129
branch,
3130
inv,
3131
_internal=True,
3132
_format=self,
3133
_bzrdir=a_bzrdir,
3134
_control_files=control_files)
3135
wt.lock_tree_write()
3136
try:
3137
basis_tree = branch.repository.revision_tree(revision_id)
3138
# only set an explicit root id if there is one to set.
3139
if basis_tree.inventory.root is not None:
3140
wt.set_root_id(basis_tree.get_root_id())
3141
if revision_id == _mod_revision.NULL_REVISION:
3142
wt.set_parent_trees([])
3143
else:
3144
wt.set_parent_trees([(revision_id, basis_tree)])
3145
transform.build_tree(basis_tree, wt)
3146
finally:
3147
# Unlock in this order so that the unlock-triggers-flush in
3148
# WorkingTree is given a chance to fire.
3149
control_files.unlock()
3150
wt.unlock()
3151
return wt
3152
3153
def _initial_inventory(self):
3154
return inventory.Inventory()
3155
3156
def __init__(self):
3157
super(WorkingTreeFormat3, self).__init__()
3158
3159
def open(self, a_bzrdir, _found=False):
3160
"""Return the WorkingTree object for a_bzrdir
3161
3162
_found is a private parameter, do not use it. It is used to indicate
3163
if format probing has already been done.
3164
"""
3165
if not _found:
3166
# we are being called directly and must probe.
3167
raise NotImplementedError
3168
if not isinstance(a_bzrdir.transport, LocalTransport):
3169
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3170
wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3171
return wt
3172
3173
def _open(self, a_bzrdir, control_files):
3174
"""Open the tree itself.
3175
3176
:param a_bzrdir: the dir for the tree.
3177
:param control_files: the control files for the tree.
3178
"""
3179
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3180
_internal=True,
3181
_format=self,
3182
_bzrdir=a_bzrdir,
3183
_control_files=control_files)
3184
3185
def __str__(self):
3186
return self.get_format_string()
3187
3188
3189
__default_format = WorkingTreeFormat6()
3190
WorkingTreeFormat.register_format(__default_format)
3191
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3192
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3193
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3194
WorkingTreeFormat.set_default_format(__default_format)
3195
# Register extra formats which have no format string are not discoverable
3196
# and not independently creatable. They are implicitly created as part of
3197
# e.g. older Bazaar formats or foreign formats.
3198
WorkingTreeFormat.register_extra_format(WorkingTreeFormat2())
Loggerhead is a web-based interface for Breezy
Version: 2.0.1