« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 5691
- compare with another revision
- download diff
- download tarball
- view history from revision 5691
- Committer: Canonical.com Patch Queue Manager
- Date: 2011-02-28 21:14:27 UTC
- mfrom: (5689.1.1 format_gc_chk_sha1_record_725051)
- Revision ID: pqm@pqm.ubuntu.com-20110228211427-bwkkhj6817rkk9ym
(gz) Fix test failure on alpha by correcting format string for
gc_chk_sha1_record (Martin [gz])
gc_chk_sha1_record (Martin [gz])
- 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,
61
registry,
60
62
revision as _mod_revision,
61
63
revisiontree,
62
rio as _mod_rio,
64
trace,
63
65
transform,
64
66
transport,
65
67
ui,
67
69
xml5,
68
70
xml7,
69
71
)
72
from bzrlib.workingtree_4 import (
73
WorkingTreeFormat4,
74
WorkingTreeFormat5,
75
WorkingTreeFormat6,
76
)
70
77
""")
71
78
72
79
from bzrlib import symbol_versioning
73
80
from bzrlib.decorators import needs_read_lock, needs_write_lock
74
from bzrlib.i18n import gettext
75
81
from bzrlib.lock import LogicalLockResult
82
from bzrlib.lockable_files import LockableFiles
83
from bzrlib.lockdir import LockDir
76
84
import bzrlib.mutabletree
77
85
from bzrlib.mutabletree import needs_tree_write_lock
78
86
from bzrlib import osutils
86
94
splitpath,
87
95
supports_executable,
88
96
)
97
from bzrlib.filters import filtered_input_file
89
98
from bzrlib.trace import mutter, note
99
from bzrlib.transport.local import LocalTransport
90
100
from bzrlib.revision import CURRENT_REVISION
101
from bzrlib.rio import RioReader, rio_file, Stanza
91
102
from bzrlib.symbol_versioning import (
92
103
deprecated_passed,
93
104
DEPRECATED_PARAMETER,
162
173
controldir.ControlComponent):
163
174
"""Working copy tree.
164
175
176
The inventory is held in the `Branch` working-inventory, and the
177
files are in a directory on disk.
178
179
It is possible for a `WorkingTree` to have a filename which is
180
not listed in the Inventory and vice versa.
181
165
182
:ivar basedir: The root of the tree on disk. This is a unicode path object
166
183
(as opposed to a URL).
167
184
"""
172
189
173
190
def __init__(self, basedir='.',
174
191
branch=DEPRECATED_PARAMETER,
192
_inventory=None,
175
193
_control_files=None,
176
194
_internal=False,
177
195
_format=None,
194
212
self.basedir = realpath(basedir)
195
213
self._control_files = _control_files
196
214
self._transport = self._control_files._transport
215
# update the whole cache up front and write to disk if anything changed;
216
# in the future we might want to do this more selectively
217
# two possible ways offer themselves : in self._unlock, write the cache
218
# if needed, or, when the cache sees a change, append it to the hash
219
# cache file, and have the parser take the most recent entry for a
220
# given path only.
221
wt_trans = self.bzrdir.get_workingtree_transport(None)
222
cache_filename = wt_trans.local_abspath('stat-cache')
223
self._hashcache = hashcache.HashCache(basedir, cache_filename,
224
self.bzrdir._get_file_mode(),
225
self._content_filter_stack_provider())
226
hc = self._hashcache
227
hc.read()
228
# is this scan needed ? it makes things kinda slow.
229
#hc.scan()
230
231
if hc.needs_write:
232
mutter("write hc")
233
hc.write()
234
235
if _inventory is None:
236
# This will be acquired on lock_read() or lock_write()
237
self._inventory_is_modified = False
238
self._inventory = None
239
else:
240
# the caller of __init__ has provided an inventory,
241
# we assume they know what they are doing - as its only
242
# the Format factory and creation methods that are
243
# permitted to do this.
244
self._set_inventory(_inventory, dirty=False)
245
self._detect_case_handling()
197
246
self._rules_searcher = None
198
247
self.views = self._make_views()
199
248
205
254
def control_transport(self):
206
255
return self._transport
207
256
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)
257
def _detect_case_handling(self):
258
wt_trans = self.bzrdir.get_workingtree_transport(None)
259
try:
260
wt_trans.stat(self._format.case_sensitive_filename)
261
except errors.NoSuchFile:
262
self.case_sensitive = True
263
else:
264
self.case_sensitive = False
265
266
self._setup_directory_is_tree_reference()
219
267
220
268
branch = property(
221
269
fget=lambda self: self._branch,
225
273
the working tree has been constructed from.
226
274
""")
227
275
228
def has_versioned_directories(self):
229
"""See `Tree.has_versioned_directories`."""
230
return self._format.supports_versioned_directories
231
232
276
def break_lock(self):
233
277
"""Break a lock if one is present from another instance.
234
278
240
284
self._control_files.break_lock()
241
285
self.branch.break_lock()
242
286
287
def _get_check_refs(self):
288
"""Return the references needed to perform a check of this tree.
289
290
The default implementation returns no refs, and is only suitable for
291
trees that have no local caching and can commit on ghosts at any time.
292
293
:seealso: bzrlib.check for details about check_refs.
294
"""
295
return []
296
243
297
def requires_rich_root(self):
244
298
return self._format.requires_rich_root
245
299
252
306
def supports_views(self):
253
307
return self.views.supports_views()
254
308
309
def _set_inventory(self, inv, dirty):
310
"""Set the internal cached inventory.
311
312
:param inv: The inventory to set.
313
:param dirty: A boolean indicating whether the inventory is the same
314
logical inventory as whats on disk. If True the inventory is not
315
the same and should be written to disk or data will be lost, if
316
False then the inventory is the same as that on disk and any
317
serialisation would be unneeded overhead.
318
"""
319
self._inventory = inv
320
self._inventory_is_modified = dirty
321
255
322
@staticmethod
256
323
def open(path=None, _unsupported=False):
257
324
"""Open an existing working tree at path.
303
370
if view_files:
304
371
file_list = view_files
305
372
view_str = views.view_display_str(view_files)
306
note(gettext("Ignoring files outside view. View is %s") % view_str)
373
note("Ignoring files outside view. View is %s" % view_str)
307
374
return tree, file_list
308
375
if default_directory == u'.':
309
376
seed = file_list[0]
370
437
list_current=list_current)
371
438
return [tr for tr in iterator if tr is not None]
372
439
440
# should be deprecated - this is slow and in any case treating them as a
441
# container is (we now know) bad style -- mbp 20070302
442
## @deprecated_method(zero_fifteen)
443
def __iter__(self):
444
"""Iterate through file_ids for this tree.
445
446
file_ids are in a WorkingTree if they are in the working inventory
447
and the working file exists.
448
"""
449
inv = self._inventory
450
for path, ie in inv.iter_entries():
451
if osutils.lexists(self.abspath(path)):
452
yield ie.file_id
453
373
454
def all_file_ids(self):
374
455
"""See Tree.iter_all_file_ids"""
375
raise NotImplementedError(self.all_file_ids)
456
return set(self.inventory)
376
457
377
458
def __repr__(self):
378
459
return "<%s of %s>" % (self.__class__.__name__,
433
514
return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
434
515
435
516
def get_file_with_stat(self, file_id, path=None, filtered=True,
436
_fstat=osutils.fstat):
517
_fstat=os.fstat):
437
518
"""See Tree.get_file_with_stat."""
438
519
if path is None:
439
520
path = self.id2path(file_id)
441
522
stat_value = _fstat(file_obj.fileno())
442
523
if filtered and self.supports_content_filtering():
443
524
filters = self._content_filter_stack(path)
444
file_obj = _mod_filters.filtered_input_file(file_obj, filters)
525
file_obj = filtered_input_file(file_obj, filters)
445
526
return (file_obj, stat_value)
446
527
447
528
def get_file_text(self, file_id, path=None, filtered=True):
456
537
f = file(path, 'rb')
457
538
if filtered and self.supports_content_filtering():
458
539
filters = self._content_filter_stack(filename)
459
return _mod_filters.filtered_input_file(f, filters)
540
return filtered_input_file(f, filters)
460
541
else:
461
542
return f
462
543
468
549
finally:
469
550
file.close()
470
551
552
@needs_read_lock
553
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
554
"""See Tree.annotate_iter
555
556
This implementation will use the basis tree implementation if possible.
557
Lines not in the basis are attributed to CURRENT_REVISION
558
559
If there are pending merges, lines added by those merges will be
560
incorrectly attributed to CURRENT_REVISION (but after committing, the
561
attribution will be correct).
562
"""
563
maybe_file_parent_keys = []
564
for parent_id in self.get_parent_ids():
565
try:
566
parent_tree = self.revision_tree(parent_id)
567
except errors.NoSuchRevisionInTree:
568
parent_tree = self.branch.repository.revision_tree(parent_id)
569
parent_tree.lock_read()
570
try:
571
if file_id not in parent_tree:
572
continue
573
ie = parent_tree.inventory[file_id]
574
if ie.kind != 'file':
575
# Note: this is slightly unnecessary, because symlinks and
576
# directories have a "text" which is the empty text, and we
577
# know that won't mess up annotations. But it seems cleaner
578
continue
579
parent_text_key = (file_id, ie.revision)
580
if parent_text_key not in maybe_file_parent_keys:
581
maybe_file_parent_keys.append(parent_text_key)
582
finally:
583
parent_tree.unlock()
584
graph = _mod_graph.Graph(self.branch.repository.texts)
585
heads = graph.heads(maybe_file_parent_keys)
586
file_parent_keys = []
587
for key in maybe_file_parent_keys:
588
if key in heads:
589
file_parent_keys.append(key)
590
591
# Now we have the parents of this content
592
annotator = self.branch.repository.texts.get_annotator()
593
text = self.get_file_text(file_id)
594
this_key =(file_id, default_revision)
595
annotator.add_special_text(this_key, file_parent_keys, text)
596
annotations = [(key[-1], line)
597
for key, line in annotator.annotate_flat(this_key)]
598
return annotations
599
600
def _get_ancestors(self, default_revision):
601
ancestors = set([default_revision])
602
for parent_id in self.get_parent_ids():
603
ancestors.update(self.branch.repository.get_ancestry(
604
parent_id, topo_sorted=False))
605
return ancestors
606
471
607
def get_parent_ids(self):
472
608
"""See Tree.get_parent_ids.
473
609
489
625
parents.append(revision_id)
490
626
return parents
491
627
628
@needs_read_lock
492
629
def get_root_id(self):
493
630
"""Return the id of this trees root"""
494
raise NotImplementedError(self.get_root_id)
631
return self._inventory.root.file_id
632
633
def _get_store_filename(self, file_id):
634
## XXX: badly named; this is not in the store at all
635
return self.abspath(self.id2path(file_id))
495
636
496
637
@needs_read_lock
497
638
def clone(self, to_bzrdir, revision_id=None):
527
668
def id2abspath(self, file_id):
528
669
return self.abspath(self.id2path(file_id))
529
670
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)
671
def has_id(self, file_id):
672
# files that have been deleted are excluded
673
inv = self.inventory
674
if not inv.has_id(file_id):
675
return False
676
path = inv.id2path(file_id)
677
return osutils.lexists(self.abspath(path))
678
679
def has_or_had_id(self, file_id):
680
if file_id == self.inventory.root.file_id:
681
return True
682
return self.inventory.has_id(file_id)
683
684
__contains__ = has_id
557
685
558
686
def get_file_size(self, file_id):
559
687
"""See Tree.get_file_size"""
567
695
else:
568
696
return None
569
697
698
@needs_read_lock
699
def get_file_sha1(self, file_id, path=None, stat_value=None):
700
if not path:
701
path = self._inventory.id2path(file_id)
702
return self._hashcache.get_sha1(path, stat_value)
703
704
def get_file_mtime(self, file_id, path=None):
705
if not path:
706
path = self.inventory.id2path(file_id)
707
return os.lstat(self.abspath(path)).st_mtime
708
709
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
710
file_id = self.path2id(path)
711
if file_id is None:
712
# For unversioned files on win32, we just assume they are not
713
# executable
714
return False
715
return self._inventory[file_id].executable
716
717
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
718
mode = stat_result.st_mode
719
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
720
721
if not supports_executable():
722
def is_executable(self, file_id, path=None):
723
return self._inventory[file_id].executable
724
725
_is_executable_from_path_and_stat = \
726
_is_executable_from_path_and_stat_from_basis
727
else:
728
def is_executable(self, file_id, path=None):
729
if not path:
730
path = self.id2path(file_id)
731
mode = os.lstat(self.abspath(path)).st_mode
732
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
733
734
_is_executable_from_path_and_stat = \
735
_is_executable_from_path_and_stat_from_stat
736
737
@needs_tree_write_lock
738
def _add(self, files, ids, kinds):
739
"""See MutableTree._add."""
740
# TODO: Re-adding a file that is removed in the working copy
741
# should probably put it back with the previous ID.
742
# the read and write working inventory should not occur in this
743
# function - they should be part of lock_write and unlock.
744
inv = self.inventory
745
for f, file_id, kind in zip(files, ids, kinds):
746
if file_id is None:
747
inv.add_path(f, kind=kind)
748
else:
749
inv.add_path(f, kind=kind, file_id=file_id)
750
self._inventory_is_modified = True
751
570
752
@needs_tree_write_lock
571
753
def _gather_kinds(self, files, kinds):
572
754
"""See MutableTree._gather_kinds."""
587
769
and setting the list to its value plus revision_id.
588
770
589
771
: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.
772
be a ghost revision as long as its not the first parent to be added,
773
or the allow_leftmost_as_ghost parameter is set True.
592
774
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
593
775
"""
594
776
parents = self.get_parent_ids() + [revision_id]
697
879
if revision_id in heads and revision_id not in new_revision_ids:
698
880
new_revision_ids.append(revision_id)
699
881
if new_revision_ids != revision_ids:
700
mutter('requested to set revision_ids = %s,'
882
trace.mutter('requested to set revision_ids = %s,'
701
883
' but filtered to %s', revision_ids, new_revision_ids)
702
884
return new_revision_ids
703
885
729
911
self._set_merges_from_parent_ids(revision_ids)
730
912
731
913
@needs_tree_write_lock
914
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
915
"""See MutableTree.set_parent_trees."""
916
parent_ids = [rev for (rev, tree) in parents_list]
917
for revision_id in parent_ids:
918
_mod_revision.check_not_reserved_id(revision_id)
919
920
self._check_parents_for_ghosts(parent_ids,
921
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
922
923
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
924
925
if len(parent_ids) == 0:
926
leftmost_parent_id = _mod_revision.NULL_REVISION
927
leftmost_parent_tree = None
928
else:
929
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
930
931
if self._change_last_revision(leftmost_parent_id):
932
if leftmost_parent_tree is None:
933
# If we don't have a tree, fall back to reading the
934
# parent tree from the repository.
935
self._cache_basis_inventory(leftmost_parent_id)
936
else:
937
inv = leftmost_parent_tree.inventory
938
xml = self._create_basis_xml_from_inventory(
939
leftmost_parent_id, inv)
940
self._write_basis_inventory(xml)
941
self._set_merges_from_parent_ids(parent_ids)
942
943
@needs_tree_write_lock
732
944
def set_pending_merges(self, rev_list):
733
945
parents = self.get_parent_ids()
734
946
leftmost = parents[:1]
739
951
def set_merge_modified(self, modified_hashes):
740
952
def iter_stanzas():
741
953
for file_id, hash in modified_hashes.iteritems():
742
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
743
hash=hash)
954
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
744
955
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
745
956
746
957
def _sha_from_stat(self, path, stat_result):
755
966
756
967
def _put_rio(self, filename, stanzas, header):
757
968
self._must_be_locked()
758
my_file = _mod_rio.rio_file(stanzas, header)
969
my_file = rio_file(stanzas, header)
759
970
self._transport.put_file(filename, my_file,
760
971
mode=self.bzrdir._get_file_mode())
761
972
803
1014
merger.set_pending()
804
1015
return conflicts
805
1016
1017
@needs_read_lock
806
1018
def merge_modified(self):
807
1019
"""Return a dictionary of files modified by a merge.
808
1020
813
1025
This returns a map of file_id->sha1, containing only files which are
814
1026
still in the working inventory and have that text hash.
815
1027
"""
816
raise NotImplementedError(self.merge_modified)
1028
try:
1029
hashfile = self._transport.get('merge-hashes')
1030
except errors.NoSuchFile:
1031
return {}
1032
try:
1033
merge_hashes = {}
1034
try:
1035
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
1036
raise errors.MergeModifiedFormatError()
1037
except StopIteration:
1038
raise errors.MergeModifiedFormatError()
1039
for s in RioReader(hashfile):
1040
# RioReader reads in Unicode, so convert file_ids back to utf8
1041
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
1042
if file_id not in self.inventory:
1043
continue
1044
text_hash = s.get("hash")
1045
if text_hash == self.get_file_sha1(file_id):
1046
merge_hashes[file_id] = text_hash
1047
return merge_hashes
1048
finally:
1049
hashfile.close()
817
1050
818
1051
@needs_write_lock
819
1052
def mkdir(self, path, file_id=None):
824
1057
self.add(path, file_id, 'directory')
825
1058
return file_id
826
1059
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)
1060
def get_symlink_target(self, file_id):
1061
abspath = self.id2abspath(file_id)
832
1062
target = osutils.readlink(abspath)
833
1063
return target
834
1064
1065
@needs_write_lock
835
1066
def subsume(self, other_tree):
836
raise NotImplementedError(self.subsume)
1067
def add_children(inventory, entry):
1068
for child_entry in entry.children.values():
1069
inventory._byid[child_entry.file_id] = child_entry
1070
if child_entry.kind == 'directory':
1071
add_children(inventory, child_entry)
1072
if other_tree.get_root_id() == self.get_root_id():
1073
raise errors.BadSubsumeSource(self, other_tree,
1074
'Trees have the same root')
1075
try:
1076
other_tree_path = self.relpath(other_tree.basedir)
1077
except errors.PathNotChild:
1078
raise errors.BadSubsumeSource(self, other_tree,
1079
'Tree is not contained by the other')
1080
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
1081
if new_root_parent is None:
1082
raise errors.BadSubsumeSource(self, other_tree,
1083
'Parent directory is not versioned.')
1084
# We need to ensure that the result of a fetch will have a
1085
# versionedfile for the other_tree root, and only fetching into
1086
# RepositoryKnit2 guarantees that.
1087
if not self.branch.repository.supports_rich_root():
1088
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
1089
other_tree.lock_tree_write()
1090
try:
1091
new_parents = other_tree.get_parent_ids()
1092
other_root = other_tree.inventory.root
1093
other_root.parent_id = new_root_parent
1094
other_root.name = osutils.basename(other_tree_path)
1095
self.inventory.add(other_root)
1096
add_children(self.inventory, other_root)
1097
self._write_inventory(self.inventory)
1098
# normally we don't want to fetch whole repositories, but i think
1099
# here we really do want to consolidate the whole thing.
1100
for parent_id in other_tree.get_parent_ids():
1101
self.branch.fetch(other_tree.branch, parent_id)
1102
self.add_parent_tree_id(parent_id)
1103
finally:
1104
other_tree.unlock()
1105
other_tree.bzrdir.retire_bzrdir()
837
1106
838
1107
def _setup_directory_is_tree_reference(self):
839
1108
if self._branch.repository._format.supports_tree_reference:
861
1130
# checkout in a subdirectory. This can be avoided by not adding
862
1131
# it. mbp 20070306
863
1132
1133
@needs_tree_write_lock
864
1134
def extract(self, file_id, format=None):
865
1135
"""Extract a subtree from this tree.
866
1136
867
1137
A new branch will be created, relative to the path for this tree.
868
1138
"""
869
raise NotImplementedError(self.extract)
1139
self.flush()
1140
def mkdirs(path):
1141
segments = osutils.splitpath(path)
1142
transport = self.branch.bzrdir.root_transport
1143
for name in segments:
1144
transport = transport.clone(name)
1145
transport.ensure_base()
1146
return transport
1147
1148
sub_path = self.id2path(file_id)
1149
branch_transport = mkdirs(sub_path)
1150
if format is None:
1151
format = self.bzrdir.cloning_metadir()
1152
branch_transport.ensure_base()
1153
branch_bzrdir = format.initialize_on_transport(branch_transport)
1154
try:
1155
repo = branch_bzrdir.find_repository()
1156
except errors.NoRepositoryPresent:
1157
repo = branch_bzrdir.create_repository()
1158
if not repo.supports_rich_root():
1159
raise errors.RootNotRich()
1160
new_branch = branch_bzrdir.create_branch()
1161
new_branch.pull(self.branch)
1162
for parent_id in self.get_parent_ids():
1163
new_branch.fetch(self.branch, parent_id)
1164
tree_transport = self.bzrdir.root_transport.clone(sub_path)
1165
if tree_transport.base != branch_transport.base:
1166
tree_bzrdir = format.initialize_on_transport(tree_transport)
1167
branch.BranchReferenceFormat().initialize(tree_bzrdir,
1168
target_branch=new_branch)
1169
else:
1170
tree_bzrdir = branch_bzrdir
1171
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1172
wt.set_parent_ids(self.get_parent_ids())
1173
my_inv = self.inventory
1174
child_inv = inventory.Inventory(root_id=None)
1175
new_root = my_inv[file_id]
1176
my_inv.remove_recursive_id(file_id)
1177
new_root.parent_id = None
1178
child_inv.add(new_root)
1179
self._write_inventory(my_inv)
1180
wt._write_inventory(child_inv)
1181
return wt
1182
1183
def _serialize(self, inventory, out_file):
1184
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1185
working=True)
1186
1187
def _deserialize(selt, in_file):
1188
return xml5.serializer_v5.read_inventory(in_file)
870
1189
871
1190
def flush(self):
872
"""Write the in memory meta data to disk."""
873
raise NotImplementedError(self.flush)
1191
"""Write the in memory inventory to disk."""
1192
# TODO: Maybe this should only write on dirty ?
1193
if self._control_files._lock_mode != 'w':
1194
raise errors.NotWriteLocked(self)
1195
sio = StringIO()
1196
self._serialize(self._inventory, sio)
1197
sio.seek(0)
1198
self._transport.put_file('inventory', sio,
1199
mode=self.bzrdir._get_file_mode())
1200
self._inventory_is_modified = False
874
1201
875
1202
def _kind(self, relpath):
876
1203
return osutils.file_kind(self.abspath(relpath))
886
1213
:param from_dir: start from this directory or None for the root
887
1214
:param recursive: whether to recurse into subdirectories or not
888
1215
"""
889
raise NotImplementedError(self.list_files)
890
1216
# list_files is an iterator, so @needs_read_lock doesn't work properly
1217
# with it. So callers should be careful to always read_lock the tree.
1218
if not self.is_locked():
1219
raise errors.ObjectNotLocked(self)
1220
1221
inv = self.inventory
1222
if from_dir is None and include_root is True:
1223
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1224
# Convert these into local objects to save lookup times
1225
pathjoin = osutils.pathjoin
1226
file_kind = self._kind
1227
1228
# transport.base ends in a slash, we want the piece
1229
# between the last two slashes
1230
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
1231
1232
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1233
1234
# directory file_id, relative path, absolute path, reverse sorted children
1235
if from_dir is not None:
1236
from_dir_id = inv.path2id(from_dir)
1237
if from_dir_id is None:
1238
# Directory not versioned
1239
return
1240
from_dir_abspath = pathjoin(self.basedir, from_dir)
1241
else:
1242
from_dir_id = inv.root.file_id
1243
from_dir_abspath = self.basedir
1244
children = os.listdir(from_dir_abspath)
1245
children.sort()
1246
# jam 20060527 The kernel sized tree seems equivalent whether we
1247
# use a deque and popleft to keep them sorted, or if we use a plain
1248
# list and just reverse() them.
1249
children = collections.deque(children)
1250
stack = [(from_dir_id, u'', from_dir_abspath, children)]
1251
while stack:
1252
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1253
1254
while children:
1255
f = children.popleft()
1256
## TODO: If we find a subdirectory with its own .bzr
1257
## directory, then that is a separate tree and we
1258
## should exclude it.
1259
1260
# the bzrdir for this tree
1261
if transport_base_dir == f:
1262
continue
1263
1264
# we know that from_dir_relpath and from_dir_abspath never end in a slash
1265
# and 'f' doesn't begin with one, we can do a string op, rather
1266
# than the checks of pathjoin(), all relative paths will have an extra slash
1267
# at the beginning
1268
fp = from_dir_relpath + '/' + f
1269
1270
# absolute path
1271
fap = from_dir_abspath + '/' + f
1272
1273
dir_ie = inv[from_dir_id]
1274
if dir_ie.kind == 'directory':
1275
f_ie = dir_ie.children.get(f)
1276
else:
1277
f_ie = None
1278
if f_ie:
1279
c = 'V'
1280
elif self.is_ignored(fp[1:]):
1281
c = 'I'
1282
else:
1283
# we may not have found this file, because of a unicode
1284
# issue, or because the directory was actually a symlink.
1285
f_norm, can_access = osutils.normalized_filename(f)
1286
if f == f_norm or not can_access:
1287
# No change, so treat this file normally
1288
c = '?'
1289
else:
1290
# this file can be accessed by a normalized path
1291
# check again if it is versioned
1292
# these lines are repeated here for performance
1293
f = f_norm
1294
fp = from_dir_relpath + '/' + f
1295
fap = from_dir_abspath + '/' + f
1296
f_ie = inv.get_child(from_dir_id, f)
1297
if f_ie:
1298
c = 'V'
1299
elif self.is_ignored(fp[1:]):
1300
c = 'I'
1301
else:
1302
c = '?'
1303
1304
fk = file_kind(fap)
1305
1306
# make a last minute entry
1307
if f_ie:
1308
yield fp[1:], c, fk, f_ie.file_id, f_ie
1309
else:
1310
try:
1311
yield fp[1:], c, fk, None, fk_entries[fk]()
1312
except KeyError:
1313
yield fp[1:], c, fk, None, TreeEntry()
1314
continue
1315
1316
if fk != 'directory':
1317
continue
1318
1319
# But do this child first if recursing down
1320
if recursive:
1321
new_children = os.listdir(fap)
1322
new_children.sort()
1323
new_children = collections.deque(new_children)
1324
stack.append((f_ie.file_id, fp, fap, new_children))
1325
# Break out of inner loop,
1326
# so that we start outer loop with child
1327
break
1328
else:
1329
# if we finished all children, pop it off the stack
1330
stack.pop()
1331
1332
@needs_tree_write_lock
891
1333
def move(self, from_paths, to_dir=None, after=False):
892
1334
"""Rename files.
893
1335
894
to_dir must be known to the working tree.
1336
to_dir must exist in the inventory.
895
1337
896
1338
If to_dir exists and is a directory, the files are moved into
897
1339
it, keeping their old names.
903
1345
independently.
904
1346
905
1347
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.
1348
inventory. The second mode only updates the inventory without
1349
touching the file on the filesystem. This is the new mode introduced
1350
in version 0.15.
908
1351
909
1352
move uses the second mode if 'after == True' and the target is not
910
1353
versioned but present in the working tree.
922
1365
This returns a list of (from_path, to_path) pairs for each
923
1366
entry that is moved.
924
1367
"""
925
raise NotImplementedError(self.move)
1368
rename_entries = []
1369
rename_tuples = []
1370
1371
# check for deprecated use of signature
1372
if to_dir is None:
1373
raise TypeError('You must supply a target directory')
1374
# check destination directory
1375
if isinstance(from_paths, basestring):
1376
raise ValueError()
1377
inv = self.inventory
1378
to_abs = self.abspath(to_dir)
1379
if not isdir(to_abs):
1380
raise errors.BzrMoveFailedError('',to_dir,
1381
errors.NotADirectory(to_abs))
1382
if not self.has_filename(to_dir):
1383
raise errors.BzrMoveFailedError('',to_dir,
1384
errors.NotInWorkingDirectory(to_dir))
1385
to_dir_id = inv.path2id(to_dir)
1386
if to_dir_id is None:
1387
raise errors.BzrMoveFailedError('',to_dir,
1388
errors.NotVersionedError(path=to_dir))
1389
1390
to_dir_ie = inv[to_dir_id]
1391
if to_dir_ie.kind != 'directory':
1392
raise errors.BzrMoveFailedError('',to_dir,
1393
errors.NotADirectory(to_abs))
1394
1395
# create rename entries and tuples
1396
for from_rel in from_paths:
1397
from_tail = splitpath(from_rel)[-1]
1398
from_id = inv.path2id(from_rel)
1399
if from_id is None:
1400
raise errors.BzrMoveFailedError(from_rel,to_dir,
1401
errors.NotVersionedError(path=from_rel))
1402
1403
from_entry = inv[from_id]
1404
from_parent_id = from_entry.parent_id
1405
to_rel = pathjoin(to_dir, from_tail)
1406
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1407
from_id=from_id,
1408
from_tail=from_tail,
1409
from_parent_id=from_parent_id,
1410
to_rel=to_rel, to_tail=from_tail,
1411
to_parent_id=to_dir_id)
1412
rename_entries.append(rename_entry)
1413
rename_tuples.append((from_rel, to_rel))
1414
1415
# determine which move mode to use. checks also for movability
1416
rename_entries = self._determine_mv_mode(rename_entries, after)
1417
1418
original_modified = self._inventory_is_modified
1419
try:
1420
if len(from_paths):
1421
self._inventory_is_modified = True
1422
self._move(rename_entries)
1423
except:
1424
# restore the inventory on error
1425
self._inventory_is_modified = original_modified
1426
raise
1427
self._write_inventory(inv)
1428
return rename_tuples
1429
1430
def _determine_mv_mode(self, rename_entries, after=False):
1431
"""Determines for each from-to pair if both inventory and working tree
1432
or only the inventory has to be changed.
1433
1434
Also does basic plausability tests.
1435
"""
1436
inv = self.inventory
1437
1438
for rename_entry in rename_entries:
1439
# store to local variables for easier reference
1440
from_rel = rename_entry.from_rel
1441
from_id = rename_entry.from_id
1442
to_rel = rename_entry.to_rel
1443
to_id = inv.path2id(to_rel)
1444
only_change_inv = False
1445
1446
# check the inventory for source and destination
1447
if from_id is None:
1448
raise errors.BzrMoveFailedError(from_rel,to_rel,
1449
errors.NotVersionedError(path=from_rel))
1450
if to_id is not None:
1451
raise errors.BzrMoveFailedError(from_rel,to_rel,
1452
errors.AlreadyVersionedError(path=to_rel))
1453
1454
# try to determine the mode for rename (only change inv or change
1455
# inv and file system)
1456
if after:
1457
if not self.has_filename(to_rel):
1458
raise errors.BzrMoveFailedError(from_id,to_rel,
1459
errors.NoSuchFile(path=to_rel,
1460
extra="New file has not been created yet"))
1461
only_change_inv = True
1462
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1463
only_change_inv = True
1464
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1465
only_change_inv = False
1466
elif (not self.case_sensitive
1467
and from_rel.lower() == to_rel.lower()
1468
and self.has_filename(from_rel)):
1469
only_change_inv = False
1470
else:
1471
# something is wrong, so lets determine what exactly
1472
if not self.has_filename(from_rel) and \
1473
not self.has_filename(to_rel):
1474
raise errors.BzrRenameFailedError(from_rel,to_rel,
1475
errors.PathsDoNotExist(paths=(str(from_rel),
1476
str(to_rel))))
1477
else:
1478
raise errors.RenameFailedFilesExist(from_rel, to_rel)
1479
rename_entry.only_change_inv = only_change_inv
1480
return rename_entries
1481
1482
def _move(self, rename_entries):
1483
"""Moves a list of files.
1484
1485
Depending on the value of the flag 'only_change_inv', the
1486
file will be moved on the file system or not.
1487
"""
1488
inv = self.inventory
1489
moved = []
1490
1491
for entry in rename_entries:
1492
try:
1493
self._move_entry(entry)
1494
except:
1495
self._rollback_move(moved)
1496
raise
1497
moved.append(entry)
1498
1499
def _rollback_move(self, moved):
1500
"""Try to rollback a previous move in case of an filesystem error."""
1501
inv = self.inventory
1502
for entry in moved:
1503
try:
1504
self._move_entry(WorkingTree._RenameEntry(
1505
entry.to_rel, entry.from_id,
1506
entry.to_tail, entry.to_parent_id, entry.from_rel,
1507
entry.from_tail, entry.from_parent_id,
1508
entry.only_change_inv))
1509
except errors.BzrMoveFailedError, e:
1510
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1511
" The working tree is in an inconsistent state."
1512
" Please consider doing a 'bzr revert'."
1513
" Error message is: %s" % e)
1514
1515
def _move_entry(self, entry):
1516
inv = self.inventory
1517
from_rel_abs = self.abspath(entry.from_rel)
1518
to_rel_abs = self.abspath(entry.to_rel)
1519
if from_rel_abs == to_rel_abs:
1520
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1521
"Source and target are identical.")
1522
1523
if not entry.only_change_inv:
1524
try:
1525
osutils.rename(from_rel_abs, to_rel_abs)
1526
except OSError, e:
1527
raise errors.BzrMoveFailedError(entry.from_rel,
1528
entry.to_rel, e[1])
1529
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
926
1530
927
1531
@needs_tree_write_lock
928
1532
def rename_one(self, from_rel, to_rel, after=False):
932
1536
933
1537
rename_one has several 'modes' to work. First, it can rename a physical
934
1538
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.
1539
only change the file_id without touching any physical file. This is
1540
the new mode introduced in version 0.15.
936
1541
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.
1542
rename_one uses the second mode if 'after == True' and 'to_rel' is not
1543
versioned but present in the working tree.
939
1544
940
1545
rename_one uses the second mode if 'after == False' and 'from_rel' is
941
1546
versioned but no longer in the working tree, and 'to_rel' is not
947
1552
948
1553
Everything else results in an error.
949
1554
"""
950
raise NotImplementedError(self.rename_one)
1555
inv = self.inventory
1556
rename_entries = []
1557
1558
# create rename entries and tuples
1559
from_tail = splitpath(from_rel)[-1]
1560
from_id = inv.path2id(from_rel)
1561
if from_id is None:
1562
# if file is missing in the inventory maybe it's in the basis_tree
1563
basis_tree = self.branch.basis_tree()
1564
from_id = basis_tree.path2id(from_rel)
1565
if from_id is None:
1566
raise errors.BzrRenameFailedError(from_rel,to_rel,
1567
errors.NotVersionedError(path=from_rel))
1568
# put entry back in the inventory so we can rename it
1569
from_entry = basis_tree.inventory[from_id].copy()
1570
inv.add(from_entry)
1571
else:
1572
from_entry = inv[from_id]
1573
from_parent_id = from_entry.parent_id
1574
to_dir, to_tail = os.path.split(to_rel)
1575
to_dir_id = inv.path2id(to_dir)
1576
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1577
from_id=from_id,
1578
from_tail=from_tail,
1579
from_parent_id=from_parent_id,
1580
to_rel=to_rel, to_tail=to_tail,
1581
to_parent_id=to_dir_id)
1582
rename_entries.append(rename_entry)
1583
1584
# determine which move mode to use. checks also for movability
1585
rename_entries = self._determine_mv_mode(rename_entries, after)
1586
1587
# check if the target changed directory and if the target directory is
1588
# versioned
1589
if to_dir_id is None:
1590
raise errors.BzrMoveFailedError(from_rel,to_rel,
1591
errors.NotVersionedError(path=to_dir))
1592
1593
# all checks done. now we can continue with our actual work
1594
mutter('rename_one:\n'
1595
' from_id {%s}\n'
1596
' from_rel: %r\n'
1597
' to_rel: %r\n'
1598
' to_dir %r\n'
1599
' to_dir_id {%s}\n',
1600
from_id, from_rel, to_rel, to_dir, to_dir_id)
1601
1602
self._move(rename_entries)
1603
self._write_inventory(inv)
1604
1605
class _RenameEntry(object):
1606
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1607
to_rel, to_tail, to_parent_id, only_change_inv=False):
1608
self.from_rel = from_rel
1609
self.from_id = from_id
1610
self.from_tail = from_tail
1611
self.from_parent_id = from_parent_id
1612
self.to_rel = to_rel
1613
self.to_tail = to_tail
1614
self.to_parent_id = to_parent_id
1615
self.only_change_inv = only_change_inv
951
1616
952
1617
@needs_read_lock
953
1618
def unknowns(self):
961
1626
return iter(
962
1627
[subp for subp in self.extras() if not self.is_ignored(subp)])
963
1628
1629
@needs_tree_write_lock
964
1630
def unversion(self, file_ids):
965
1631
"""Remove the file ids in file_ids from the current versioned set.
966
1632
970
1636
:param file_ids: The file ids to stop versioning.
971
1637
:raises: NoSuchId if any fileid is not currently versioned.
972
1638
"""
973
raise NotImplementedError(self.unversion)
1639
for file_id in file_ids:
1640
if file_id not in self._inventory:
1641
raise errors.NoSuchId(self, file_id)
1642
for file_id in file_ids:
1643
if self._inventory.has_id(file_id):
1644
self._inventory.remove_recursive_id(file_id)
1645
if len(file_ids):
1646
# in the future this should just set a dirty bit to wait for the
1647
# final unlock. However, until all methods of workingtree start
1648
# with the current in -memory inventory rather than triggering
1649
# a read, it is more complex - we need to teach read_inventory
1650
# to know when to read, and when to not read first... and possibly
1651
# to save first when the in memory one may be corrupted.
1652
# so for now, we just only write it if it is indeed dirty.
1653
# - RBC 20060907
1654
self._write_inventory(self._inventory)
1655
1656
def _iter_conflicts(self):
1657
conflicted = set()
1658
for info in self.list_files():
1659
path = info[0]
1660
stem = get_conflicted_stem(path)
1661
if stem is None:
1662
continue
1663
if stem not in conflicted:
1664
conflicted.add(stem)
1665
yield stem
974
1666
975
1667
@needs_write_lock
976
1668
def pull(self, source, overwrite=False, stop_revision=None,
986
1678
new_revision_info = self.branch.last_revision_info()
987
1679
if new_revision_info != old_revision_info:
988
1680
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
1681
basis_tree.lock_read()
995
1682
try:
996
1683
new_basis_tree = self.branch.basis_tree()
1034
1721
stream.write(bytes)
1035
1722
finally:
1036
1723
stream.close()
1724
# TODO: update the hashcache here ?
1037
1725
1038
1726
def extras(self):
1039
1727
"""Yield all unversioned files in this WorkingTree.
1045
1733
Currently returned depth-first, sorted by name within directories.
1046
1734
This is the same order used by 'osutils.walkdirs'.
1047
1735
"""
1048
raise NotImplementedError(self.extras)
1736
## TODO: Work from given directory downwards
1737
for path, dir_entry in self.inventory.directories():
1738
# mutter("search for unknowns in %r", path)
1739
dirabs = self.abspath(path)
1740
if not isdir(dirabs):
1741
# e.g. directory deleted
1742
continue
1743
1744
fl = []
1745
for subf in os.listdir(dirabs):
1746
if self.bzrdir.is_control_filename(subf):
1747
continue
1748
if subf not in dir_entry.children:
1749
try:
1750
(subf_norm,
1751
can_access) = osutils.normalized_filename(subf)
1752
except UnicodeDecodeError:
1753
path_os_enc = path.encode(osutils._fs_enc)
1754
relpath = path_os_enc + '/' + subf
1755
raise errors.BadFilenameEncoding(relpath,
1756
osutils._fs_enc)
1757
if subf_norm != subf and can_access:
1758
if subf_norm not in dir_entry.children:
1759
fl.append(subf_norm)
1760
else:
1761
fl.append(subf)
1762
1763
fl.sort()
1764
for subf in fl:
1765
subp = pathjoin(path, subf)
1766
yield subp
1049
1767
1050
1768
def ignored_files(self):
1051
1769
"""Yield list of PATH, IGNORE_PATTERN"""
1100
1818
1101
1819
def stored_kind(self, file_id):
1102
1820
"""See Tree.stored_kind"""
1103
raise NotImplementedError(self.stored_kind)
1821
return self.inventory[file_id].kind
1104
1822
1105
1823
def _comparison_data(self, entry, path):
1106
1824
abspath = self.abspath(path)
1197
1915
def get_physical_lock_status(self):
1198
1916
return self._control_files.get_physical_lock_status()
1199
1917
1918
def _basis_inventory_name(self):
1919
return 'basis-inventory-cache'
1920
1200
1921
def _reset_data(self):
1201
1922
"""Reset transient data that cannot be revalidated."""
1202
raise NotImplementedError(self._reset_data)
1923
self._inventory_is_modified = False
1924
f = self._transport.get('inventory')
1925
try:
1926
result = self._deserialize(f)
1927
finally:
1928
f.close()
1929
self._set_inventory(result, dirty=False)
1203
1930
1931
@needs_tree_write_lock
1204
1932
def set_last_revision(self, new_revision):
1205
1933
"""Change the last revision in the working tree."""
1206
raise NotImplementedError(self.set_last_revision)
1934
if self._change_last_revision(new_revision):
1935
self._cache_basis_inventory(new_revision)
1207
1936
1208
1937
def _change_last_revision(self, new_revision):
1209
1938
"""Template method part of set_last_revision to perform the change.
1212
1941
when their last revision is set.
1213
1942
"""
1214
1943
if _mod_revision.is_null(new_revision):
1215
self.branch.set_last_revision_info(0, new_revision)
1944
self.branch.set_revision_history([])
1216
1945
return False
1217
_mod_revision.check_not_reserved_id(new_revision)
1218
1946
try:
1219
1947
self.branch.generate_revision_history(new_revision)
1220
1948
except errors.NoSuchRevision:
1221
1949
# not present in the repo - dont try to set it deeper than the tip
1222
self.branch._set_revision_history([new_revision])
1950
self.branch.set_revision_history([new_revision])
1223
1951
return True
1224
1952
1953
def _write_basis_inventory(self, xml):
1954
"""Write the basis inventory XML to the basis-inventory file"""
1955
path = self._basis_inventory_name()
1956
sio = StringIO(xml)
1957
self._transport.put_file(path, sio,
1958
mode=self.bzrdir._get_file_mode())
1959
1960
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1961
"""Create the text that will be saved in basis-inventory"""
1962
inventory.revision_id = revision_id
1963
return xml7.serializer_v7.write_inventory_to_string(inventory)
1964
1965
def _cache_basis_inventory(self, new_revision):
1966
"""Cache new_revision as the basis inventory."""
1967
# TODO: this should allow the ready-to-use inventory to be passed in,
1968
# as commit already has that ready-to-use [while the format is the
1969
# same, that is].
1970
try:
1971
# this double handles the inventory - unpack and repack -
1972
# but is easier to understand. We can/should put a conditional
1973
# in here based on whether the inventory is in the latest format
1974
# - perhaps we should repack all inventories on a repository
1975
# upgrade ?
1976
# the fast path is to copy the raw xml from the repository. If the
1977
# xml contains 'revision_id="', then we assume the right
1978
# revision_id is set. We must check for this full string, because a
1979
# root node id can legitimately look like 'revision_id' but cannot
1980
# contain a '"'.
1981
xml = self.branch.repository._get_inventory_xml(new_revision)
1982
firstline = xml.split('\n', 1)[0]
1983
if (not 'revision_id="' in firstline or
1984
'format="7"' not in firstline):
1985
inv = self.branch.repository._serializer.read_inventory_from_string(
1986
xml, new_revision)
1987
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1988
self._write_basis_inventory(xml)
1989
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1990
pass
1991
1992
def read_basis_inventory(self):
1993
"""Read the cached basis inventory."""
1994
path = self._basis_inventory_name()
1995
return self._transport.get_bytes(path)
1996
1997
@needs_read_lock
1998
def read_working_inventory(self):
1999
"""Read the working inventory.
2000
2001
:raises errors.InventoryModified: read_working_inventory will fail
2002
when the current in memory inventory has been modified.
2003
"""
2004
# conceptually this should be an implementation detail of the tree.
2005
# XXX: Deprecate this.
2006
# ElementTree does its own conversion from UTF-8, so open in
2007
# binary.
2008
if self._inventory_is_modified:
2009
raise errors.InventoryModified(self)
2010
f = self._transport.get('inventory')
2011
try:
2012
result = self._deserialize(f)
2013
finally:
2014
f.close()
2015
self._set_inventory(result, dirty=False)
2016
return result
2017
1225
2018
@needs_tree_write_lock
1226
2019
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1227
2020
force=False):
1228
"""Remove nominated files from the working tree metadata.
2021
"""Remove nominated files from the working inventory.
1229
2022
1230
2023
:files: File paths relative to the basedir.
1231
2024
:keep_files: If true, the files will also be kept.
1296
2089
backup_name)
1297
2090
1298
2091
# Build inv_delta and delete files where applicable,
1299
# do this before any modifications to meta data.
2092
# do this before any modifications to inventory.
1300
2093
for f in files:
1301
2094
fid = self.path2id(f)
1302
2095
message = None
1345
2138
def revert(self, filenames=None, old_tree=None, backups=True,
1346
2139
pb=None, report_changes=False):
1347
2140
from bzrlib.conflicts import resolve
2141
if filenames == []:
2142
filenames = None
2143
symbol_versioning.warn('Using [] to revert all files is deprecated'
2144
' as of bzr 0.91. Please use None (the default) instead.',
2145
DeprecationWarning, stacklevel=2)
1348
2146
if old_tree is None:
1349
2147
basis_tree = self.basis_tree()
1350
2148
basis_tree.lock_read()
1377
2175
WorkingTree can supply revision_trees for the basis revision only
1378
2176
because there is only one cached inventory in the bzr directory.
1379
2177
"""
1380
raise NotImplementedError(self.revision_tree)
2178
if revision_id == self.last_revision():
2179
try:
2180
xml = self.read_basis_inventory()
2181
except errors.NoSuchFile:
2182
pass
2183
else:
2184
try:
2185
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2186
# dont use the repository revision_tree api because we want
2187
# to supply the inventory.
2188
if inv.revision_id == revision_id:
2189
return revisiontree.RevisionTree(self.branch.repository,
2190
inv, revision_id)
2191
except errors.BadInventoryFormat:
2192
pass
2193
# raise if there was no inventory, or if we read the wrong inventory.
2194
raise errors.NoSuchRevisionInTree(self, revision_id)
2195
2196
# XXX: This method should be deprecated in favour of taking in a proper
2197
# new Inventory object.
2198
@needs_tree_write_lock
2199
def set_inventory(self, new_inventory_list):
2200
from bzrlib.inventory import (Inventory,
2201
InventoryDirectory,
2202
InventoryFile,
2203
InventoryLink)
2204
inv = Inventory(self.get_root_id())
2205
for path, file_id, parent, kind in new_inventory_list:
2206
name = os.path.basename(path)
2207
if name == "":
2208
continue
2209
# fixme, there should be a factory function inv,add_??
2210
if kind == 'directory':
2211
inv.add(InventoryDirectory(file_id, name, parent))
2212
elif kind == 'file':
2213
inv.add(InventoryFile(file_id, name, parent))
2214
elif kind == 'symlink':
2215
inv.add(InventoryLink(file_id, name, parent))
2216
else:
2217
raise errors.BzrError("unknown kind %r" % kind)
2218
self._write_inventory(inv)
1381
2219
1382
2220
@needs_tree_write_lock
1383
2221
def set_root_id(self, file_id):
1396
2234
present in the current inventory or an error will occur. It must
1397
2235
not be None, but rather a valid file id.
1398
2236
"""
1399
raise NotImplementedError(self._set_root_id)
2237
inv = self._inventory
2238
orig_root_id = inv.root.file_id
2239
# TODO: it might be nice to exit early if there was nothing
2240
# to do, saving us from trigger a sync on unlock.
2241
self._inventory_is_modified = True
2242
# we preserve the root inventory entry object, but
2243
# unlinkit from the byid index
2244
del inv._byid[inv.root.file_id]
2245
inv.root.file_id = file_id
2246
# and link it into the index with the new changed id.
2247
inv._byid[inv.root.file_id] = inv.root
2248
# and finally update all children to reference the new id.
2249
# XXX: this should be safe to just look at the root.children
2250
# list, not the WHOLE INVENTORY.
2251
for fid in inv:
2252
entry = inv[fid]
2253
if entry.parent_id == orig_root_id:
2254
entry.parent_id = inv.root.file_id
1400
2255
1401
2256
def unlock(self):
1402
2257
"""See Branch.unlock.
1433
2288
- Restore the wt.basis->wt.state changes.
1434
2289
1435
2290
There isn't a single operation at the moment to do that, so we:
1436
1437
2291
- Merge current state -> basis tree of the master w.r.t. the old tree
1438
2292
basis.
1439
2293
- Do a 'normal' merge of the old branch basis if it is relevant.
1499
2353
show_base=show_base)
1500
2354
if nb_conflicts:
1501
2355
self.add_parent_tree((old_tip, other_tree))
1502
note(gettext('Rerun update after fixing the conflicts.'))
2356
trace.note('Rerun update after fixing the conflicts.')
1503
2357
return nb_conflicts
1504
2358
1505
2359
if last_rev != _mod_revision.ensure_null(revision):
1511
2365
basis = self.basis_tree()
1512
2366
basis.lock_read()
1513
2367
try:
1514
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2368
if (basis.inventory.root is None
2369
or basis.inventory.root.file_id != to_root_id):
1515
2370
self.set_root_id(to_root_id)
1516
2371
self.flush()
1517
2372
finally:
1547
2402
last_rev = parent_trees[0][0]
1548
2403
return nb_conflicts
1549
2404
2405
def _write_hashcache_if_dirty(self):
2406
"""Write out the hashcache if it is dirty."""
2407
if self._hashcache.needs_write:
2408
try:
2409
self._hashcache.write()
2410
except OSError, e:
2411
if e.errno not in (errno.EPERM, errno.EACCES):
2412
raise
2413
# TODO: jam 20061219 Should this be a warning? A single line
2414
# warning might be sufficient to let the user know what
2415
# is going on.
2416
mutter('Could not write hashcache for %s\nError: %s',
2417
self._hashcache.cache_file_name(), e)
2418
2419
@needs_tree_write_lock
2420
def _write_inventory(self, inv):
2421
"""Write inventory as the current inventory."""
2422
self._set_inventory(inv, dirty=True)
2423
self.flush()
2424
1550
2425
def set_conflicts(self, arg):
1551
2426
raise errors.UnsupportedOperation(self.set_conflicts, self)
1552
2427
1553
2428
def add_conflicts(self, arg):
1554
2429
raise errors.UnsupportedOperation(self.add_conflicts, self)
1555
2430
2431
@needs_read_lock
1556
2432
def conflicts(self):
1557
raise NotImplementedError(self.conflicts)
2433
conflicts = _mod_conflicts.ConflictList()
2434
for conflicted in self._iter_conflicts():
2435
text = True
2436
try:
2437
if file_kind(self.abspath(conflicted)) != "file":
2438
text = False
2439
except errors.NoSuchFile:
2440
text = False
2441
if text is True:
2442
for suffix in ('.THIS', '.OTHER'):
2443
try:
2444
kind = file_kind(self.abspath(conflicted+suffix))
2445
if kind != "file":
2446
text = False
2447
except errors.NoSuchFile:
2448
text = False
2449
if text == False:
2450
break
2451
ctype = {True: 'text conflict', False: 'contents conflict'}[text]
2452
conflicts.append(_mod_conflicts.Conflict.factory(ctype,
2453
path=conflicted,
2454
file_id=self.path2id(conflicted)))
2455
return conflicts
1558
2456
1559
2457
def walkdirs(self, prefix=""):
1560
2458
"""Walk the directories of this tree.
1680
2578
def _walkdirs(self, prefix=""):
1681
2579
"""Walk the directories of this tree.
1682
2580
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), ... ])
2581
:prefix: is used as the directrory to start with.
2582
returns a generator which yields items in the form:
2583
((curren_directory_path, fileid),
2584
[(file1_path, file1_name, file1_kind, None, file1_id,
2585
file1_kind), ... ])
1689
2586
"""
1690
raise NotImplementedError(self._walkdirs)
2587
_directory = 'directory'
2588
# get the root in the inventory
2589
inv = self.inventory
2590
top_id = inv.path2id(prefix)
2591
if top_id is None:
2592
pending = []
2593
else:
2594
pending = [(prefix, '', _directory, None, top_id, None)]
2595
while pending:
2596
dirblock = []
2597
currentdir = pending.pop()
2598
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2599
top_id = currentdir[4]
2600
if currentdir[0]:
2601
relroot = currentdir[0] + '/'
2602
else:
2603
relroot = ""
2604
# FIXME: stash the node in pending
2605
entry = inv[top_id]
2606
if entry.kind == 'directory':
2607
for name, child in entry.sorted_children():
2608
dirblock.append((relroot + name, name, child.kind, None,
2609
child.file_id, child.kind
2610
))
2611
yield (currentdir[0], entry.file_id), dirblock
2612
# push the user specified dirs from dirblock
2613
for dir in reversed(dirblock):
2614
if dir[2] == _directory:
2615
pending.append(dir)
1691
2616
1692
2617
@needs_tree_write_lock
1693
2618
def auto_resolve(self):
1697
2622
are considered 'resolved', because bzr always puts conflict markers
1698
2623
into files that have text conflicts. The corresponding .THIS .BASE and
1699
2624
.OTHER files are deleted, as per 'resolve'.
1700
1701
2625
:return: a tuple of ConflictLists: (un_resolved, resolved).
1702
2626
"""
1703
2627
un_resolved = _mod_conflicts.ConflictList()
1722
2646
self.set_conflicts(un_resolved)
1723
2647
return un_resolved, resolved
1724
2648
2649
@needs_read_lock
2650
def _check(self, references):
2651
"""Check the tree for consistency.
2652
2653
:param references: A dict with keys matching the items returned by
2654
self._get_check_refs(), and values from looking those keys up in
2655
the repository.
2656
"""
2657
tree_basis = self.basis_tree()
2658
tree_basis.lock_read()
2659
try:
2660
repo_basis = references[('trees', self.last_revision())]
2661
if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2662
raise errors.BzrCheckError(
2663
"Mismatched basis inventory content.")
2664
self._validate()
2665
finally:
2666
tree_basis.unlock()
2667
1725
2668
def _validate(self):
1726
2669
"""Validate internal structures.
1727
2670
1733
2676
"""
1734
2677
return
1735
2678
2679
@needs_read_lock
1736
2680
def check_state(self):
1737
2681
"""Check that the working state is/isn't valid."""
1738
raise NotImplementedError(self.check_state)
2682
check_refs = self._get_check_refs()
2683
refs = {}
2684
for ref in check_refs:
2685
kind, value = ref
2686
if kind == 'trees':
2687
refs[ref] = self.branch.repository.revision_tree(value)
2688
self._check(refs)
1739
2689
2690
@needs_tree_write_lock
1740
2691
def reset_state(self, revision_ids=None):
1741
2692
"""Reset the state of the working tree.
1742
2693
1743
2694
This does a hard-reset to a last-known-good state. This is a way to
1744
2695
fix if something got corrupted (like the .bzr/checkout/dirstate file)
1745
2696
"""
1746
raise NotImplementedError(self.reset_state)
2697
if revision_ids is None:
2698
revision_ids = self.get_parent_ids()
2699
if not revision_ids:
2700
rt = self.branch.repository.revision_tree(
2701
_mod_revision.NULL_REVISION)
2702
else:
2703
rt = self.branch.repository.revision_tree(revision_ids[0])
2704
self._write_inventory(rt.inventory)
2705
self.set_parent_ids(revision_ids)
1747
2706
1748
2707
def _get_rules_searcher(self, default_searcher):
1749
2708
"""See Tree._get_rules_searcher."""
1758
2717
return ShelfManager(self, self._transport)
1759
2718
1760
2719
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)
2720
class WorkingTree2(WorkingTree):
2721
"""This is the Format 2 working tree.
2722
2723
This was the first weave based working tree.
2724
- uses os locks for locking.
2725
- uses the branch last-revision.
2726
"""
2727
2728
def __init__(self, *args, **kwargs):
2729
super(WorkingTree2, self).__init__(*args, **kwargs)
2730
# WorkingTree2 has more of a constraint that self._inventory must
2731
# exist. Because this is an older format, we don't mind the overhead
2732
# caused by the extra computation here.
2733
2734
# Newer WorkingTree's should only have self._inventory set when they
2735
# have a read lock.
2736
if self._inventory is None:
2737
self.read_working_inventory()
2738
2739
def _get_check_refs(self):
2740
"""Return the references needed to perform a check of this tree."""
2741
return [('trees', self.last_revision())]
2742
2743
def lock_tree_write(self):
2744
"""See WorkingTree.lock_tree_write().
2745
2746
In Format2 WorkingTrees we have a single lock for the branch and tree
2747
so lock_tree_write() degrades to lock_write().
2748
2749
:return: An object with an unlock method which will release the lock
2750
obtained.
2751
"""
2752
self.branch.lock_write()
2753
try:
2754
self._control_files.lock_write()
2755
return self
2756
except:
2757
self.branch.unlock()
2758
raise
2759
2760
def unlock(self):
2761
# do non-implementation specific cleanup
2762
self._cleanup()
2763
2764
# we share control files:
2765
if self._control_files._lock_count == 3:
2766
# _inventory_is_modified is always False during a read lock.
2767
if self._inventory_is_modified:
2768
self.flush()
2769
self._write_hashcache_if_dirty()
2770
2771
# reverse order of locking.
2772
try:
2773
return self._control_files.unlock()
2774
finally:
2775
self.branch.unlock()
2776
2777
2778
class WorkingTree3(WorkingTree):
2779
"""This is the Format 3 working tree.
2780
2781
This differs from the base WorkingTree by:
2782
- having its own file lock
2783
- having its own last-revision property.
2784
2785
This is new in bzr 0.8
2786
"""
2787
2788
@needs_read_lock
2789
def _last_revision(self):
2790
"""See Mutable.last_revision."""
2791
try:
2792
return self._transport.get_bytes('last-revision')
1817
2793
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)
2794
return _mod_revision.NULL_REVISION
2795
2796
def _change_last_revision(self, revision_id):
2797
"""See WorkingTree._change_last_revision."""
2798
if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2799
try:
2800
self._transport.delete('last-revision')
2801
except errors.NoSuchFile:
2802
pass
2803
return False
2804
else:
2805
self._transport.put_bytes('last-revision', revision_id,
2806
mode=self.bzrdir._get_file_mode())
2807
return True
2808
2809
def _get_check_refs(self):
2810
"""Return the references needed to perform a check of this tree."""
2811
return [('trees', self.last_revision())]
1972
2812
1973
2813
@needs_tree_write_lock
1974
2814
def set_conflicts(self, conflicts):
1994
2834
raise errors.ConflictFormatError()
1995
2835
except StopIteration:
1996
2836
raise errors.ConflictFormatError()
1997
reader = _mod_rio.RioReader(confile)
1998
return _mod_conflicts.ConflictList.from_stanzas(reader)
2837
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
1999
2838
finally:
2000
2839
confile.close()
2001
2840
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)
2841
def unlock(self):
2842
# do non-implementation specific cleanup
2843
self._cleanup()
2844
if self._control_files._lock_count == 1:
2845
# _inventory_is_modified is always False during a read lock.
2846
if self._inventory_is_modified:
2847
self.flush()
2848
self._write_hashcache_if_dirty()
2849
# reverse order of locking.
2850
try:
2851
return self._control_files.unlock()
2852
finally:
2853
self.branch.unlock()
2854
2855
2856
def get_conflicted_stem(path):
2857
for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
2858
if path.endswith(suffix):
2859
return path[:-len(suffix)]
2922
2860
2923
2861
2924
2862
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2927
2865
def __init__(self, other_registry=None):
2928
2866
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2929
2867
self._default_format = None
2930
self._default_format_key = None
2931
2868
2932
2869
def get_default(self):
2933
2870
"""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
2871
return self._default_format
2938
2872
2939
2873
def set_default(self, format):
2940
"""Set the default format."""
2941
2874
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
2875
2949
2876
2950
2877
format_registry = WorkingTreeFormatRegistry()
2979
2906
missing_parent_conflicts = False
2980
2907
"""If this format supports missing parent conflicts."""
2981
2908
2982
supports_versioned_directories = None
2983
2984
@classmethod
2985
def find_format_string(klass, a_bzrdir):
2986
"""Return format name for the working tree object in a_bzrdir."""
2987
try:
2988
transport = a_bzrdir.get_workingtree_transport(None)
2989
return transport.get_bytes("format")
2990
except errors.NoSuchFile:
2991
raise errors.NoWorkingTree(base=transport.base)
2992
2993
2909
@classmethod
2994
2910
def find_format(klass, a_bzrdir):
2995
2911
"""Return the format for the working tree object in a_bzrdir."""
2996
2912
try:
2997
format_string = klass.find_format_string(a_bzrdir)
2913
transport = a_bzrdir.get_workingtree_transport(None)
2914
format_string = transport.get_bytes("format")
2998
2915
return format_registry.get(format_string)
2916
except errors.NoSuchFile:
2917
raise errors.NoWorkingTree(base=transport.base)
2999
2918
except KeyError:
3000
2919
raise errors.UnknownFormatError(format=format_string,
3001
2920
kind="working tree")
3091
3010
def unregister_format(klass, format):
3092
3011
format_registry.remove(format)
3093
3012
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
3013
3014
class WorkingTreeFormat2(WorkingTreeFormat):
3015
"""The second working tree format.
3016
3017
This format modified the hash cache from the format 1 hash cache.
3018
"""
3019
3020
upgrade_recommended = True
3021
3022
requires_normalized_unicode_filenames = True
3023
3024
case_sensitive_filename = "Branch-FoRMaT"
3025
3026
missing_parent_conflicts = False
3027
3028
def get_format_description(self):
3029
"""See WorkingTreeFormat.get_format_description()."""
3030
return "Working tree format 2"
3031
3032
def _stub_initialize_on_transport(self, transport, file_mode):
3033
"""Workaround: create control files for a remote working tree.
3034
3035
This ensures that it can later be updated and dealt with locally,
3036
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
3037
no working tree. (See bug #43064).
3038
"""
3039
sio = StringIO()
3040
inv = inventory.Inventory()
3041
xml5.serializer_v5.write_inventory(inv, sio, working=True)
3042
sio.seek(0)
3043
transport.put_file('inventory', sio, file_mode)
3044
transport.put_bytes('pending-merges', '', file_mode)
3045
3046
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3047
accelerator_tree=None, hardlink=False):
3048
"""See WorkingTreeFormat.initialize()."""
3049
if not isinstance(a_bzrdir.transport, LocalTransport):
3050
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3051
if from_branch is not None:
3052
branch = from_branch
3053
else:
3054
branch = a_bzrdir.open_branch()
3055
if revision_id is None:
3056
revision_id = _mod_revision.ensure_null(branch.last_revision())
3057
branch.lock_write()
3058
try:
3059
branch.generate_revision_history(revision_id)
3060
finally:
3061
branch.unlock()
3062
inv = inventory.Inventory()
3063
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
3064
branch,
3065
inv,
3066
_internal=True,
3067
_format=self,
3068
_bzrdir=a_bzrdir,
3069
_control_files=branch.control_files)
3070
basis_tree = branch.repository.revision_tree(revision_id)
3071
if basis_tree.inventory.root is not None:
3072
wt.set_root_id(basis_tree.get_root_id())
3073
# set the parent list and cache the basis tree.
3074
if _mod_revision.is_null(revision_id):
3075
parent_trees = []
3076
else:
3077
parent_trees = [(revision_id, basis_tree)]
3078
wt.set_parent_trees(parent_trees)
3079
transform.build_tree(basis_tree, wt)
3080
return wt
3081
3082
def __init__(self):
3083
super(WorkingTreeFormat2, self).__init__()
3084
self._matchingbzrdir = bzrdir.BzrDirFormat6()
3085
3086
def open(self, a_bzrdir, _found=False):
3087
"""Return the WorkingTree object for a_bzrdir
3088
3089
_found is a private parameter, do not use it. It is used to indicate
3090
if format probing has already been done.
3091
"""
3092
if not _found:
3093
# we are being called directly and must probe.
3094
raise NotImplementedError
3095
if not isinstance(a_bzrdir.transport, LocalTransport):
3096
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3097
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
3098
_internal=True,
3099
_format=self,
3100
_bzrdir=a_bzrdir,
3101
_control_files=a_bzrdir.open_branch().control_files)
3102
return wt
3103
3104
class WorkingTreeFormat3(WorkingTreeFormat):
3105
"""The second working tree format updated to record a format marker.
3106
3107
This format:
3108
- exists within a metadir controlling .bzr
3109
- includes an explicit version marker for the workingtree control
3110
files, separate from the BzrDir format
3111
- modifies the hash cache format
3112
- is new in bzr 0.8
3113
- uses a LockDir to guard access for writes.
3114
"""
3115
3116
upgrade_recommended = True
3117
3118
missing_parent_conflicts = True
3119
3120
def get_format_string(self):
3121
"""See WorkingTreeFormat.get_format_string()."""
3122
return "Bazaar-NG Working Tree format 3"
3123
3124
def get_format_description(self):
3125
"""See WorkingTreeFormat.get_format_description()."""
3126
return "Working tree format 3"
3127
3128
_lock_file_name = 'lock'
3129
_lock_class = LockDir
3130
3131
_tree_class = WorkingTree3
3132
3133
def __get_matchingbzrdir(self):
3134
return bzrdir.BzrDirMetaFormat1()
3135
3136
_matchingbzrdir = property(__get_matchingbzrdir)
3137
3138
def _open_control_files(self, a_bzrdir):
3139
transport = a_bzrdir.get_workingtree_transport(None)
3140
return LockableFiles(transport, self._lock_file_name,
3141
self._lock_class)
3142
3143
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3144
accelerator_tree=None, hardlink=False):
3145
"""See WorkingTreeFormat.initialize().
3146
3147
:param revision_id: if supplied, create a working tree at a different
3148
revision than the branch is at.
3149
:param accelerator_tree: A tree which can be used for retrieving file
3150
contents more quickly than the revision tree, i.e. a workingtree.
3151
The revision tree will be used for cases where accelerator_tree's
3152
content is different.
3153
:param hardlink: If true, hard-link files from accelerator_tree,
3154
where possible.
3155
"""
3156
if not isinstance(a_bzrdir.transport, LocalTransport):
3157
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3158
transport = a_bzrdir.get_workingtree_transport(self)
3159
control_files = self._open_control_files(a_bzrdir)
3160
control_files.create_lock()
3161
control_files.lock_write()
3162
transport.put_bytes('format', self.get_format_string(),
3163
mode=a_bzrdir._get_file_mode())
3164
if from_branch is not None:
3165
branch = from_branch
3166
else:
3167
branch = a_bzrdir.open_branch()
3168
if revision_id is None:
3169
revision_id = _mod_revision.ensure_null(branch.last_revision())
3170
# WorkingTree3 can handle an inventory which has a unique root id.
3171
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
3172
# those trees. And because there isn't a format bump inbetween, we
3173
# are maintaining compatibility with older clients.
3174
# inv = Inventory(root_id=gen_root_id())
3175
inv = self._initial_inventory()
3176
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3177
branch,
3178
inv,
3179
_internal=True,
3180
_format=self,
3181
_bzrdir=a_bzrdir,
3182
_control_files=control_files)
3183
wt.lock_tree_write()
3184
try:
3185
basis_tree = branch.repository.revision_tree(revision_id)
3186
# only set an explicit root id if there is one to set.
3187
if basis_tree.inventory.root is not None:
3188
wt.set_root_id(basis_tree.get_root_id())
3189
if revision_id == _mod_revision.NULL_REVISION:
3190
wt.set_parent_trees([])
3191
else:
3192
wt.set_parent_trees([(revision_id, basis_tree)])
3193
transform.build_tree(basis_tree, wt)
3194
finally:
3195
# Unlock in this order so that the unlock-triggers-flush in
3196
# WorkingTree is given a chance to fire.
3197
control_files.unlock()
3198
wt.unlock()
3199
return wt
3200
3201
def _initial_inventory(self):
3202
return inventory.Inventory()
3203
3204
def __init__(self):
3205
super(WorkingTreeFormat3, self).__init__()
3206
3207
def open(self, a_bzrdir, _found=False):
3208
"""Return the WorkingTree object for a_bzrdir
3209
3210
_found is a private parameter, do not use it. It is used to indicate
3211
if format probing has already been done.
3212
"""
3213
if not _found:
3214
# we are being called directly and must probe.
3215
raise NotImplementedError
3216
if not isinstance(a_bzrdir.transport, LocalTransport):
3217
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3218
wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3219
return wt
3220
3221
def _open(self, a_bzrdir, control_files):
3222
"""Open the tree itself.
3223
3224
:param a_bzrdir: the dir for the tree.
3225
:param control_files: the control files for the tree.
3226
"""
3227
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3228
_internal=True,
3229
_format=self,
3230
_bzrdir=a_bzrdir,
3231
_control_files=control_files)
3232
3233
def __str__(self):
3234
return self.get_format_string()
3235
3236
3237
__default_format = WorkingTreeFormat6()
3103
3238
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3104
3239
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3105
3240
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3106
3241
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3107
3242
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3108
3243
"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")
3244
format_registry.register(WorkingTreeFormat3())
3245
format_registry.set_default(__default_format)
3246
# Register extra formats which have no format string are not discoverable
3247
# and not independently creatable. They are implicitly created as part of
3248
# e.g. older Bazaar formats or foreign formats.
3249
format_registry.register_extra(WorkingTreeFormat2())
Loggerhead is a web-based interface for Breezy
Version: 2.0.1