424
369
state = self.current_dirstate()
425
370
if stat_value is None:
427
stat_value = osutils.lstat(file_abspath)
372
stat_value = os.lstat(file_abspath)
429
374
if e.errno == errno.ENOENT:
433
378
link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
434
stat_value=stat_value)
435
if entry[1][0][0] == b'f':
379
stat_value=stat_value)
380
if entry[1][0][0] == 'f':
436
381
if link_or_sha1 is None:
437
file_obj, statvalue = self.get_file_with_stat(path)
382
file_obj, statvalue = self.get_file_with_stat(file_id, path)
439
384
sha1 = osutils.sha_file(file_obj)
442
self._observed_sha1(path, (sha1, statvalue))
387
self._observed_sha1(file_id, path, (sha1, statvalue))
445
390
return link_or_sha1
448
def _get_root_inventory(self):
393
def _get_inventory(self):
449
394
"""Get the inventory for the tree. This is only valid within a lock."""
450
395
if 'evil' in debug.debug_flags:
451
trace.mutter_callsite(
452
2, "accessing .inventory forces a size of tree translation.")
396
trace.mutter_callsite(2,
397
"accessing .inventory forces a size of tree translation.")
453
398
if self._inventory is not None:
454
399
return self._inventory
455
400
self._must_be_locked()
456
401
self._generate_inventory()
457
402
return self._inventory
459
root_inventory = property(_get_root_inventory,
460
"Root inventory of this tree")
404
inventory = property(_get_inventory,
405
doc="Inventory of this Tree")
462
408
def get_parent_ids(self):
463
409
"""See Tree.get_parent_ids.
465
411
This implementation requests the ids list from the dirstate file.
467
with self.lock_read():
468
return self.current_dirstate().get_parent_ids()
413
return self.current_dirstate().get_parent_ids()
470
def get_reference_revision(self, path):
415
def get_reference_revision(self, file_id, path=None):
471
416
# referenced tree's revision is whatever's currently there
472
return self.get_nested_tree(path).last_revision()
417
return self.get_nested_tree(file_id, path).last_revision()
474
def get_nested_tree(self, path):
419
def get_nested_tree(self, file_id, path=None):
421
path = self.id2path(file_id)
422
# else: check file_id is at path?
475
423
return WorkingTree.open(self.abspath(path))
477
def id2path(self, file_id, recurse='down'):
426
def get_root_id(self):
427
"""Return the id of this trees root"""
428
return self._get_entry(path='')[0][2]
430
def has_id(self, file_id):
431
state = self.current_dirstate()
432
row, parents = self._get_entry(file_id=file_id)
435
return osutils.lexists(pathjoin(
436
self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
438
def has_or_had_id(self, file_id):
439
state = self.current_dirstate()
440
row, parents = self._get_entry(file_id=file_id)
441
return row is not None
444
def id2path(self, file_id):
478
445
"Convert a file-id to a path."
479
with self.lock_read():
480
state = self.current_dirstate()
481
entry = self._get_entry(file_id=file_id)
482
if entry == (None, None):
483
if recurse == 'down':
484
if 'evil' in debug.debug_flags:
485
trace.mutter_callsite(
486
2, "Tree.id2path scans all nested trees.")
487
for nested_path in self.iter_references():
488
nested_tree = self.get_nested_tree(nested_path)
490
return osutils.pathjoin(
491
nested_path, nested_tree.id2path(file_id))
492
except errors.NoSuchId:
494
raise errors.NoSuchId(tree=self, file_id=file_id)
495
path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
496
return path_utf8.decode('utf8')
446
state = self.current_dirstate()
447
entry = self._get_entry(file_id=file_id)
448
if entry == (None, None):
449
raise errors.NoSuchId(tree=self, file_id=file_id)
450
path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
451
return path_utf8.decode('utf8')
498
453
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
499
454
entry = self._get_entry(path=path)
500
455
if entry == (None, None):
501
return False # Missing entries are not executable
502
return entry[1][0][3] # Executable?
504
def is_executable(self, path):
505
"""Test if a file is executable or not.
507
Note: The caller is expected to take a read-lock before calling this.
509
if not self._supports_executable():
510
entry = self._get_entry(path=path)
456
return False # Missing entries are not executable
457
return entry[1][0][3] # Executable?
459
if not osutils.supports_executable():
460
def is_executable(self, file_id, path=None):
461
"""Test if a file is executable or not.
463
Note: The caller is expected to take a read-lock before calling this.
465
entry = self._get_entry(file_id=file_id, path=path)
511
466
if entry == (None, None):
513
468
return entry[1][0][3]
470
_is_executable_from_path_and_stat = \
471
_is_executable_from_path_and_stat_from_basis
473
def is_executable(self, file_id, path=None):
474
"""Test if a file is executable or not.
476
Note: The caller is expected to take a read-lock before calling this.
515
478
self._must_be_locked()
516
mode = osutils.lstat(self.abspath(path)).st_mode
480
path = self.id2path(file_id)
481
mode = os.lstat(self.abspath(path)).st_mode
517
482
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
519
484
def all_file_ids(self):
521
486
self._must_be_locked()
523
488
for key, tree_details in self.current_dirstate()._iter_entries():
524
if tree_details[0][0] in (b'a', b'r'): # relocated
489
if tree_details[0][0] in ('a', 'r'): # relocated
526
491
result.add(key[2])
529
def all_versioned_paths(self):
530
self._must_be_locked()
531
return {path for path, entry in
532
self.root_inventory.iter_entries(recursive=True)}
534
495
def __iter__(self):
535
496
"""Iterate through file_ids for this tree.
537
498
file_ids are in a WorkingTree if they are in the working inventory
538
499
and the working file exists.
540
with self.lock_read():
542
for key, tree_details in self.current_dirstate()._iter_entries():
543
if tree_details[0][0] in (b'a', b'r'): # absent, relocated
544
# not relevant to the working tree
546
path = pathjoin(self.basedir, key[0].decode(
547
'utf8'), key[1].decode('utf8'))
548
if osutils.lexists(path):
549
result.append(key[2])
502
for key, tree_details in self.current_dirstate()._iter_entries():
503
if tree_details[0][0] in ('a', 'r'): # absent, relocated
504
# not relevant to the working tree
506
path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
507
if osutils.lexists(path):
508
result.append(key[2])
552
511
def iter_references(self):
553
512
if not self._repo_supports_tree_reference:
554
513
# When the repo doesn't support references, we will have nothing to
557
with self.lock_read():
558
for key, tree_details in self.current_dirstate()._iter_entries():
559
if tree_details[0][0] in (b'a', b'r'): # absent, relocated
560
# not relevant to the working tree
563
# the root is not a reference.
565
relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
567
if self.kind(relpath) == 'tree-reference':
569
except errors.NoSuchFile:
570
# path is missing on disk.
516
for key, tree_details in self.current_dirstate()._iter_entries():
517
if tree_details[0][0] in ('a', 'r'): # absent, relocated
518
# not relevant to the working tree
521
# the root is not a reference.
523
relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
525
if self._kind(relpath) == 'tree-reference':
526
yield relpath, key[2]
527
except errors.NoSuchFile:
528
# path is missing on disk.
573
def _observed_sha1(self, path, sha_and_stat):
531
def _observed_sha1(self, file_id, path, (sha1, statvalue)):
574
532
"""See MutableTree._observed_sha1."""
575
533
state = self.current_dirstate()
576
entry = self._get_entry(path=path)
577
state._observed_sha1(entry, *sha_and_stat)
579
def kind(self, relpath):
534
entry = self._get_entry(file_id=file_id, path=path)
535
state._observed_sha1(entry, sha1, statvalue)
537
def kind(self, file_id):
538
"""Return the kind of a file.
540
This is always the actual kind that's on disk, regardless of what it
543
Note: The caller is expected to take a read-lock before calling this.
545
relpath = self.id2path(file_id)
547
raise AssertionError(
548
"path for id {%s} is None!" % file_id)
549
return self._kind(relpath)
551
def _kind(self, relpath):
580
552
abspath = self.abspath(relpath)
581
553
kind = file_kind(abspath)
582
554
if (self._repo_supports_tree_reference and kind == 'directory'):
583
with self.lock_read():
584
entry = self._get_entry(path=relpath)
585
if entry[1] is not None:
586
if entry[1][0][0] == b't':
587
kind = 'tree-reference'
555
entry = self._get_entry(path=relpath)
556
if entry[1] is not None:
557
if entry[1][0][0] == 't':
558
kind = 'tree-reference'
590
562
def _last_revision(self):
591
563
"""See Mutable.last_revision."""
592
with self.lock_read():
593
parent_ids = self.current_dirstate().get_parent_ids()
597
return _mod_revision.NULL_REVISION
564
parent_ids = self.current_dirstate().get_parent_ids()
568
return _mod_revision.NULL_REVISION
599
570
def lock_read(self):
600
"""See Branch.lock_read, and WorkingTree.unlock.
602
:return: A breezy.lock.LogicalLockResult.
571
"""See Branch.lock_read, and WorkingTree.unlock."""
604
572
self.branch.lock_read()
606
574
self._control_files.lock_read()
634
601
self._repo_supports_tree_reference = getattr(
635
602
self.branch.repository._format, "supports_tree_reference",
637
except BaseException:
638
605
self._control_files.unlock()
640
except BaseException:
641
608
self.branch.unlock()
643
return LogicalLockResult(self.unlock)
645
611
def lock_tree_write(self):
646
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
648
:return: A breezy.lock.LogicalLockResult.
612
"""See MutableTree.lock_tree_write, and WorkingTree.unlock."""
650
613
self.branch.lock_read()
651
return self._lock_self_write()
614
self._lock_self_write()
653
616
def lock_write(self):
654
"""See MutableTree.lock_write, and WorkingTree.unlock.
656
:return: A breezy.lock.LogicalLockResult.
617
"""See MutableTree.lock_write, and WorkingTree.unlock."""
658
618
self.branch.lock_write()
659
return self._lock_self_write()
619
self._lock_self_write()
621
@needs_tree_write_lock
661
622
def move(self, from_paths, to_dir, after=False):
662
623
"""See WorkingTree.move()."""
664
625
if not from_paths:
666
with self.lock_tree_write():
667
state = self.current_dirstate()
668
if isinstance(from_paths, (str, bytes)):
670
to_dir_utf8 = to_dir.encode('utf8')
671
to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
672
# check destination directory
673
# get the details for it
674
(to_entry_block_index, to_entry_entry_index, dir_present,
675
entry_present) = state._get_block_entry_index(
676
to_entry_dirname, to_basename, 0)
677
if not entry_present:
678
raise errors.BzrMoveFailedError(
679
'', to_dir, errors.NotVersionedError(to_dir))
680
to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
681
# get a handle on the block itself.
682
to_block_index = state._ensure_block(
683
to_entry_block_index, to_entry_entry_index, to_dir_utf8)
684
to_block = state._dirblocks[to_block_index]
685
to_abs = self.abspath(to_dir)
686
if not isdir(to_abs):
687
raise errors.BzrMoveFailedError('', to_dir,
688
errors.NotADirectory(to_abs))
690
if to_entry[1][0][0] != b'd':
691
raise errors.BzrMoveFailedError('', to_dir,
692
errors.NotADirectory(to_abs))
694
if self._inventory is not None:
695
update_inventory = True
696
inv = self.root_inventory
697
to_dir_id = to_entry[0][2]
699
update_inventory = False
701
# GZ 2017-03-28: The rollbacks variable was shadowed in the loop below
702
# missing those added here, but there's also no test coverage for this.
703
rollbacks = cleanup.ExitStack()
705
def move_one(old_entry, from_path_utf8, minikind, executable,
706
fingerprint, packed_stat, size,
707
to_block, to_key, to_path_utf8):
708
state._make_absent(old_entry)
709
from_key = old_entry[0]
711
state.update_minimal,
714
executable=executable,
715
fingerprint=fingerprint,
716
packed_stat=packed_stat,
718
path_utf8=from_path_utf8)
719
state.update_minimal(to_key,
721
executable=executable,
722
fingerprint=fingerprint,
723
packed_stat=packed_stat,
725
path_utf8=to_path_utf8)
726
added_entry_index, _ = state._find_entry_index(
728
new_entry = to_block[1][added_entry_index]
729
rollbacks.callback(state._make_absent, new_entry)
731
for from_rel in from_paths:
732
# from_rel is 'pathinroot/foo/bar'
733
from_rel_utf8 = from_rel.encode('utf8')
734
from_dirname, from_tail = osutils.split(from_rel)
735
from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
736
from_entry = self._get_entry(path=from_rel)
737
if from_entry == (None, None):
738
raise errors.BzrMoveFailedError(
740
errors.NotVersionedError(path=from_rel))
742
from_id = from_entry[0][2]
743
to_rel = pathjoin(to_dir, from_tail)
744
to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
745
item_to_entry = self._get_entry(path=to_rel)
746
if item_to_entry != (None, None):
747
raise errors.BzrMoveFailedError(
748
from_rel, to_rel, "Target is already versioned.")
750
if from_rel == to_rel:
751
raise errors.BzrMoveFailedError(
752
from_rel, to_rel, "Source and target are identical.")
754
from_missing = not self.has_filename(from_rel)
755
to_missing = not self.has_filename(to_rel)
627
state = self.current_dirstate()
628
if isinstance(from_paths, basestring):
630
to_dir_utf8 = to_dir.encode('utf8')
631
to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
632
id_index = state._get_id_index()
633
# check destination directory
634
# get the details for it
635
to_entry_block_index, to_entry_entry_index, dir_present, entry_present = \
636
state._get_block_entry_index(to_entry_dirname, to_basename, 0)
637
if not entry_present:
638
raise errors.BzrMoveFailedError('', to_dir,
639
errors.NotVersionedError(to_dir))
640
to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
641
# get a handle on the block itself.
642
to_block_index = state._ensure_block(
643
to_entry_block_index, to_entry_entry_index, to_dir_utf8)
644
to_block = state._dirblocks[to_block_index]
645
to_abs = self.abspath(to_dir)
646
if not isdir(to_abs):
647
raise errors.BzrMoveFailedError('',to_dir,
648
errors.NotADirectory(to_abs))
650
if to_entry[1][0][0] != 'd':
651
raise errors.BzrMoveFailedError('',to_dir,
652
errors.NotADirectory(to_abs))
654
if self._inventory is not None:
655
update_inventory = True
657
to_dir_id = to_entry[0][2]
658
to_dir_ie = inv[to_dir_id]
660
update_inventory = False
663
def move_one(old_entry, from_path_utf8, minikind, executable,
664
fingerprint, packed_stat, size,
665
to_block, to_key, to_path_utf8):
666
state._make_absent(old_entry)
667
from_key = old_entry[0]
669
lambda:state.update_minimal(from_key,
671
executable=executable,
672
fingerprint=fingerprint,
673
packed_stat=packed_stat,
675
path_utf8=from_path_utf8))
676
state.update_minimal(to_key,
678
executable=executable,
679
fingerprint=fingerprint,
680
packed_stat=packed_stat,
682
path_utf8=to_path_utf8)
683
added_entry_index, _ = state._find_entry_index(to_key, to_block[1])
684
new_entry = to_block[1][added_entry_index]
685
rollbacks.append(lambda:state._make_absent(new_entry))
687
for from_rel in from_paths:
688
# from_rel is 'pathinroot/foo/bar'
689
from_rel_utf8 = from_rel.encode('utf8')
690
from_dirname, from_tail = osutils.split(from_rel)
691
from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
692
from_entry = self._get_entry(path=from_rel)
693
if from_entry == (None, None):
694
raise errors.BzrMoveFailedError(from_rel,to_dir,
695
errors.NotVersionedError(path=from_rel))
697
from_id = from_entry[0][2]
698
to_rel = pathjoin(to_dir, from_tail)
699
to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
700
item_to_entry = self._get_entry(path=to_rel)
701
if item_to_entry != (None, None):
702
raise errors.BzrMoveFailedError(from_rel, to_rel,
703
"Target is already versioned.")
705
if from_rel == to_rel:
706
raise errors.BzrMoveFailedError(from_rel, to_rel,
707
"Source and target are identical.")
709
from_missing = not self.has_filename(from_rel)
710
to_missing = not self.has_filename(to_rel)
717
raise errors.BzrMoveFailedError(from_rel, to_rel,
718
errors.NoSuchFile(path=to_rel,
719
extra="New file has not been created yet"))
721
# neither path exists
722
raise errors.BzrRenameFailedError(from_rel, to_rel,
723
errors.PathsDoNotExist(paths=(from_rel, to_rel)))
725
if from_missing: # implicitly just update our path mapping
757
726
move_file = False
762
raise errors.BzrMoveFailedError(
766
extra="New file has not been created yet"))
768
# neither path exists
769
raise errors.BzrRenameFailedError(
771
errors.PathsDoNotExist(paths=(from_rel, to_rel)))
773
if from_missing: # implicitly just update our path mapping
776
raise errors.RenameFailedFilesExist(from_rel, to_rel)
728
raise errors.RenameFailedFilesExist(from_rel, to_rel)
778
# perform the disk move first - its the most likely failure point.
780
from_rel_abs = self.abspath(from_rel)
781
to_rel_abs = self.abspath(to_rel)
731
def rollback_rename():
732
"""A single rename has failed, roll it back."""
733
# roll back everything, even if we encounter trouble doing one
736
# TODO: at least log the other exceptions rather than just
737
# losing them mbp 20070307
739
for rollback in reversed(rollbacks):
783
osutils.rename(from_rel_abs, to_rel_abs)
785
raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
787
osutils.rename, to_rel_abs, from_rel_abs)
743
exc_info = sys.exc_info()
745
raise exc_info[0], exc_info[1], exc_info[2]
747
# perform the disk move first - its the most likely failure point.
749
from_rel_abs = self.abspath(from_rel)
750
to_rel_abs = self.abspath(to_rel)
789
# perform the rename in the inventory next if needed: its easy
793
from_entry = inv.get_entry(from_id)
794
current_parent = from_entry.parent_id
795
inv.rename(from_id, to_dir_id, from_tail)
797
inv.rename, from_id, current_parent, from_tail)
798
# finally do the rename in the dirstate, which is a little
799
# tricky to rollback, but least likely to need it.
800
old_block_index, old_entry_index, dir_present, file_present = \
801
state._get_block_entry_index(
802
from_dirname, from_tail_utf8, 0)
803
old_block = state._dirblocks[old_block_index][1]
804
old_entry = old_block[old_entry_index]
805
from_key, old_entry_details = old_entry
806
cur_details = old_entry_details[0]
808
to_key = ((to_block[0],) + from_key[1:3])
809
minikind = cur_details[0]
810
move_one(old_entry, from_path_utf8=from_rel_utf8,
812
executable=cur_details[3],
813
fingerprint=cur_details[1],
814
packed_stat=cur_details[4],
818
to_path_utf8=to_rel_utf8)
821
def update_dirblock(from_dir, to_key, to_dir_utf8):
822
"""Recursively update all entries in this dirblock."""
824
raise AssertionError(
825
"renaming root not supported")
826
from_key = (from_dir, '')
827
from_block_idx, present = \
828
state._find_block_index_from_key(from_key)
830
# This is the old record, if it isn't present,
831
# then there is theoretically nothing to
832
# update. (Unless it isn't present because of
833
# lazy loading, but we don't do that yet)
835
from_block = state._dirblocks[from_block_idx]
836
to_block_index, to_entry_index, _, _ = \
837
state._get_block_entry_index(
838
to_key[0], to_key[1], 0)
839
to_block_index = state._ensure_block(
840
to_block_index, to_entry_index, to_dir_utf8)
841
to_block = state._dirblocks[to_block_index]
843
# Grab a copy since move_one may update the list.
844
for entry in from_block[1][:]:
845
if not (entry[0][0] == from_dir):
846
raise AssertionError()
847
cur_details = entry[1][0]
849
to_dir_utf8, entry[0][1], entry[0][2])
850
from_path_utf8 = osutils.pathjoin(
851
entry[0][0], entry[0][1])
852
to_path_utf8 = osutils.pathjoin(
853
to_dir_utf8, entry[0][1])
854
minikind = cur_details[0]
855
if minikind in (b'a', b'r'):
856
# Deleted children of a renamed directory
857
# Do not need to be updated. Children that
858
# have been renamed out of this directory
859
# should also not be updated
861
move_one(entry, from_path_utf8=from_path_utf8,
863
executable=cur_details[3],
864
fingerprint=cur_details[1],
865
packed_stat=cur_details[4],
869
to_path_utf8=to_path_utf8)
871
# We need to move all the children of this
873
update_dirblock(from_path_utf8, to_key,
875
update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
876
except BaseException:
879
result.append((from_rel, to_rel))
880
state._mark_modified()
881
self._make_dirty(reset_inventory=False)
752
osutils.rename(from_rel_abs, to_rel_abs)
754
raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
755
rollbacks.append(lambda: osutils.rename(to_rel_abs, from_rel_abs))
757
# perform the rename in the inventory next if needed: its easy
761
from_entry = inv[from_id]
762
current_parent = from_entry.parent_id
763
inv.rename(from_id, to_dir_id, from_tail)
765
lambda: inv.rename(from_id, current_parent, from_tail))
766
# finally do the rename in the dirstate, which is a little
767
# tricky to rollback, but least likely to need it.
768
old_block_index, old_entry_index, dir_present, file_present = \
769
state._get_block_entry_index(from_dirname, from_tail_utf8, 0)
770
old_block = state._dirblocks[old_block_index][1]
771
old_entry = old_block[old_entry_index]
772
from_key, old_entry_details = old_entry
773
cur_details = old_entry_details[0]
775
to_key = ((to_block[0],) + from_key[1:3])
776
minikind = cur_details[0]
777
move_one(old_entry, from_path_utf8=from_rel_utf8,
779
executable=cur_details[3],
780
fingerprint=cur_details[1],
781
packed_stat=cur_details[4],
785
to_path_utf8=to_rel_utf8)
788
def update_dirblock(from_dir, to_key, to_dir_utf8):
789
"""Recursively update all entries in this dirblock."""
791
raise AssertionError("renaming root not supported")
792
from_key = (from_dir, '')
793
from_block_idx, present = \
794
state._find_block_index_from_key(from_key)
796
# This is the old record, if it isn't present, then
797
# there is theoretically nothing to update.
798
# (Unless it isn't present because of lazy loading,
799
# but we don't do that yet)
801
from_block = state._dirblocks[from_block_idx]
802
to_block_index, to_entry_index, _, _ = \
803
state._get_block_entry_index(to_key[0], to_key[1], 0)
804
to_block_index = state._ensure_block(
805
to_block_index, to_entry_index, to_dir_utf8)
806
to_block = state._dirblocks[to_block_index]
808
# Grab a copy since move_one may update the list.
809
for entry in from_block[1][:]:
810
if not (entry[0][0] == from_dir):
811
raise AssertionError()
812
cur_details = entry[1][0]
813
to_key = (to_dir_utf8, entry[0][1], entry[0][2])
814
from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
815
to_path_utf8 = osutils.pathjoin(to_dir_utf8, entry[0][1])
816
minikind = cur_details[0]
818
# Deleted children of a renamed directory
819
# Do not need to be updated.
820
# Children that have been renamed out of this
821
# directory should also not be updated
823
move_one(entry, from_path_utf8=from_path_utf8,
825
executable=cur_details[3],
826
fingerprint=cur_details[1],
827
packed_stat=cur_details[4],
831
to_path_utf8=to_path_utf8)
833
# We need to move all the children of this
835
update_dirblock(from_path_utf8, to_key,
837
update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
841
result.append((from_rel, to_rel))
842
state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
843
self._make_dirty(reset_inventory=False)
885
847
def _must_be_locked(self):
886
848
if not self._control_files._lock_count:
1122
1072
If tree is None, then that element is treated as an unreachable
1123
1073
parent tree - i.e. a ghost.
1125
with self.lock_tree_write():
1126
dirstate = self.current_dirstate()
1127
if len(parents_list) > 0:
1128
if not allow_leftmost_as_ghost and parents_list[0][1] is None:
1129
raise errors.GhostRevisionUnusableHere(parents_list[0][0])
1133
parent_ids = [rev_id for rev_id, tree in parents_list]
1134
graph = self.branch.repository.get_graph()
1135
heads = graph.heads(parent_ids)
1136
accepted_revisions = set()
1138
# convert absent trees to the null tree, which we convert back to
1139
# missing on access.
1140
for rev_id, tree in parents_list:
1141
if len(accepted_revisions) > 0:
1142
# we always accept the first tree
1143
if rev_id in accepted_revisions or rev_id not in heads:
1144
# We have already included either this tree, or its
1145
# descendent, so we skip it.
1147
_mod_revision.check_not_reserved_id(rev_id)
1148
if tree is not None:
1149
real_trees.append((rev_id, tree))
1151
real_trees.append((rev_id,
1152
self.branch.repository.revision_tree(
1153
_mod_revision.NULL_REVISION)))
1154
ghosts.append(rev_id)
1155
accepted_revisions.add(rev_id)
1157
if (len(real_trees) == 1
1159
and self.branch.repository._format.fast_deltas
1160
and isinstance(real_trees[0][1], InventoryRevisionTree)
1161
and self.get_parent_ids()):
1162
rev_id, rev_tree = real_trees[0]
1163
basis_id = self.get_parent_ids()[0]
1164
# There are times when basis_tree won't be in
1165
# self.branch.repository, (switch, for example)
1167
basis_tree = self.branch.repository.revision_tree(basis_id)
1168
except errors.NoSuchRevision:
1169
# Fall back to the set_parent_trees(), since we can't use
1170
# _make_delta if we can't get the RevisionTree
1173
delta = rev_tree.root_inventory._make_delta(
1174
basis_tree.root_inventory)
1175
dirstate.update_basis_by_delta(delta, rev_id)
1178
dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1179
self._make_dirty(reset_inventory=False)
1075
dirstate = self.current_dirstate()
1076
if len(parents_list) > 0:
1077
if not allow_leftmost_as_ghost and parents_list[0][1] is None:
1078
raise errors.GhostRevisionUnusableHere(parents_list[0][0])
1082
parent_ids = [rev_id for rev_id, tree in parents_list]
1083
graph = self.branch.repository.get_graph()
1084
heads = graph.heads(parent_ids)
1085
accepted_revisions = set()
1087
# convert absent trees to the null tree, which we convert back to
1088
# missing on access.
1089
for rev_id, tree in parents_list:
1090
if len(accepted_revisions) > 0:
1091
# we always accept the first tree
1092
if rev_id in accepted_revisions or rev_id not in heads:
1093
# We have already included either this tree, or its
1094
# descendent, so we skip it.
1096
_mod_revision.check_not_reserved_id(rev_id)
1097
if tree is not None:
1098
real_trees.append((rev_id, tree))
1100
real_trees.append((rev_id,
1101
self.branch.repository.revision_tree(
1102
_mod_revision.NULL_REVISION)))
1103
ghosts.append(rev_id)
1104
accepted_revisions.add(rev_id)
1105
dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1106
self._make_dirty(reset_inventory=False)
1181
1108
def _set_root_id(self, file_id):
1182
1109
"""See WorkingTree.set_root_id."""
1183
1110
state = self.current_dirstate()
1184
state.set_path_id(b'', file_id)
1111
state.set_path_id('', file_id)
1185
1112
if state._dirblock_state == dirstate.DirState.IN_MEMORY_MODIFIED:
1186
1113
self._make_dirty(reset_inventory=True)
1226
1154
self.branch.unlock()
1228
def unversion(self, paths):
1229
"""Remove the file ids in paths from the current versioned set.
1156
@needs_tree_write_lock
1157
def unversion(self, file_ids):
1158
"""Remove the file ids in file_ids from the current versioned set.
1231
When a directory is unversioned, all of its children are automatically
1160
When a file_id is unversioned, all of its children are automatically
1234
:param paths: The file ids to stop versioning.
1163
:param file_ids: The file ids to stop versioning.
1235
1164
:raises: NoSuchId if any fileid is not currently versioned.
1237
with self.lock_tree_write():
1240
state = self.current_dirstate()
1241
state._read_dirblocks_if_needed()
1244
file_id = self.path2id(path)
1246
raise errors.NoSuchFile(self, path)
1247
file_ids.add(file_id)
1248
ids_to_unversion = set(file_ids)
1249
paths_to_unversion = set()
1251
# check if the root is to be unversioned, if so, assert for now.
1252
# walk the state marking unversioned things as absent.
1253
# if there are any un-unversioned ids at the end, raise
1254
for key, details in state._dirblocks[0][1]:
1255
if (details[0][0] not in (b'a', b'r') and # absent or relocated
1256
key[2] in ids_to_unversion):
1257
# I haven't written the code to unversion / yet - it should
1259
raise errors.BzrError(
1260
'Unversioning the / is not currently supported')
1262
while block_index < len(state._dirblocks):
1263
# process one directory at a time.
1264
block = state._dirblocks[block_index]
1265
# first check: is the path one to remove - it or its children
1266
delete_block = False
1267
for path in paths_to_unversion:
1268
if (block[0].startswith(path) and
1269
(len(block[0]) == len(path) or
1270
block[0][len(path)] == '/')):
1271
# this entire block should be deleted - its the block for a
1272
# path to unversion; or the child of one
1275
# TODO: trim paths_to_unversion as we pass by paths
1277
# this block is to be deleted: process it.
1278
# TODO: we can special case the no-parents case and
1279
# just forget the whole block.
1281
while entry_index < len(block[1]):
1282
entry = block[1][entry_index]
1283
if entry[1][0][0] in (b'a', b'r'):
1284
# don't remove absent or renamed entries
1287
# Mark this file id as having been removed
1288
ids_to_unversion.discard(entry[0][2])
1289
if not state._make_absent(entry):
1290
# The block has not shrunk.
1292
# go to the next block. (At the moment we dont delete empty
1168
state = self.current_dirstate()
1169
state._read_dirblocks_if_needed()
1170
ids_to_unversion = set(file_ids)
1171
paths_to_unversion = set()
1173
# check if the root is to be unversioned, if so, assert for now.
1174
# walk the state marking unversioned things as absent.
1175
# if there are any un-unversioned ids at the end, raise
1176
for key, details in state._dirblocks[0][1]:
1177
if (details[0][0] not in ('a', 'r') and # absent or relocated
1178
key[2] in ids_to_unversion):
1179
# I haven't written the code to unversion / yet - it should be
1181
raise errors.BzrError('Unversioning the / is not currently supported')
1183
while block_index < len(state._dirblocks):
1184
# process one directory at a time.
1185
block = state._dirblocks[block_index]
1186
# first check: is the path one to remove - it or its children
1187
delete_block = False
1188
for path in paths_to_unversion:
1189
if (block[0].startswith(path) and
1190
(len(block[0]) == len(path) or
1191
block[0][len(path)] == '/')):
1192
# this entire block should be deleted - its the block for a
1193
# path to unversion; or the child of one
1196
# TODO: trim paths_to_unversion as we pass by paths
1198
# this block is to be deleted: process it.
1199
# TODO: we can special case the no-parents case and
1200
# just forget the whole block.
1296
1201
entry_index = 0
1297
1202
while entry_index < len(block[1]):
1298
1203
entry = block[1][entry_index]
1299
if (entry[1][0][0] in (b'a', b'r') or # absent, relocated
1300
# ^ some parent row.
1301
entry[0][2] not in ids_to_unversion):
1302
# ^ not an id to unversion
1305
if entry[1][0][0] == b'd':
1306
paths_to_unversion.add(
1307
pathjoin(entry[0][0], entry[0][1]))
1308
if not state._make_absent(entry):
1310
# we have unversioned this id
1311
ids_to_unversion.remove(entry[0][2])
1204
if entry[1][0][0] in 'ar':
1205
# don't remove absent or renamed entries
1208
# Mark this file id as having been removed
1209
ids_to_unversion.discard(entry[0][2])
1210
if not state._make_absent(entry):
1211
# The block has not shrunk.
1213
# go to the next block. (At the moment we dont delete empty
1312
1215
block_index += 1
1313
if ids_to_unversion:
1314
raise errors.NoSuchId(self, next(iter(ids_to_unversion)))
1315
self._make_dirty(reset_inventory=False)
1316
# have to change the legacy inventory too.
1317
if self._inventory is not None:
1318
for file_id in file_ids:
1319
if self._inventory.has_id(file_id):
1320
self._inventory.remove_recursive_id(file_id)
1218
while entry_index < len(block[1]):
1219
entry = block[1][entry_index]
1220
if (entry[1][0][0] in ('a', 'r') or # absent, relocated
1221
# ^ some parent row.
1222
entry[0][2] not in ids_to_unversion):
1223
# ^ not an id to unversion
1226
if entry[1][0][0] == 'd':
1227
paths_to_unversion.add(pathjoin(entry[0][0], entry[0][1]))
1228
if not state._make_absent(entry):
1230
# we have unversioned this id
1231
ids_to_unversion.remove(entry[0][2])
1233
if ids_to_unversion:
1234
raise errors.NoSuchId(self, iter(ids_to_unversion).next())
1235
self._make_dirty(reset_inventory=False)
1236
# have to change the legacy inventory too.
1237
if self._inventory is not None:
1238
for file_id in file_ids:
1239
self._inventory.remove_recursive_id(file_id)
1241
@needs_tree_write_lock
1322
1242
def rename_one(self, from_rel, to_rel, after=False):
1323
1243
"""See WorkingTree.rename_one"""
1324
with self.lock_tree_write():
1326
super(DirStateWorkingTree, self).rename_one(
1327
from_rel, to_rel, after)
1245
WorkingTree.rename_one(self, from_rel, to_rel, after)
1247
@needs_tree_write_lock
1329
1248
def apply_inventory_delta(self, changes):
1330
1249
"""See MutableTree.apply_inventory_delta"""
1331
with self.lock_tree_write():
1332
state = self.current_dirstate()
1333
state.update_by_delta(changes)
1334
self._make_dirty(reset_inventory=True)
1250
state = self.current_dirstate()
1251
state.update_by_delta(changes)
1252
self._make_dirty(reset_inventory=True)
1336
1254
def update_basis_by_delta(self, new_revid, delta):
1337
1255
"""See MutableTree.update_basis_by_delta."""
1896
1723
inv_entry.text_size = size
1897
1724
inv_entry.text_sha1 = fingerprint
1898
1725
elif kind == 'directory':
1899
parent_ies[(dirname + b'/' + name).strip(b'/')] = inv_entry
1726
parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
1900
1727
elif kind == 'symlink':
1728
inv_entry.executable = False
1729
inv_entry.text_size = None
1901
1730
inv_entry.symlink_target = utf8_decode(fingerprint)[0]
1902
1731
elif kind == 'tree-reference':
1903
1732
inv_entry.reference_revision = fingerprint or None
1905
raise AssertionError(
1906
"cannot convert entry %r into an InventoryEntry"
1734
raise AssertionError("cannot convert entry %r into an InventoryEntry"
1908
1736
# These checks cost us around 40ms on a 55k entry tree
1909
1737
if file_id in inv_byid:
1910
raise AssertionError(
1911
'file_id %s already in'
1738
raise AssertionError('file_id %s already in'
1912
1739
' inventory as %s' % (file_id, inv_byid[file_id]))
1913
1740
if name_unicode in parent_ie.children:
1914
1741
raise AssertionError('name %r already in parent'
1916
1743
inv_byid[file_id] = inv_entry
1917
1744
parent_ie.children[name_unicode] = inv_entry
1918
1745
self._inventory = inv
1920
def get_file_mtime(self, path):
1747
def get_file_mtime(self, file_id, path=None):
1921
1748
"""Return the modification time for this record.
1923
1750
We return the timestamp of the last-changed revision.
1925
1752
# Make sure the file exists
1926
entry = self._get_entry(path=path)
1753
entry = self._get_entry(file_id, path=path)
1927
1754
if entry == (None, None): # do we raise?
1928
raise errors.NoSuchFile(path)
1929
1756
parent_index = self._get_parent_index()
1930
1757
last_changed_revision = entry[1][parent_index][4]
1932
1759
rev = self._repository.get_revision(last_changed_revision)
1933
1760
except errors.NoSuchRevision:
1934
raise FileTimestampUnavailable(path)
1761
raise errors.FileTimestampUnavailable(self.id2path(file_id))
1935
1762
return rev.timestamp
1937
def get_file_sha1(self, path, stat_value=None):
1938
entry = self._get_entry(path=path)
1764
def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
entry = self._get_entry(file_id=file_id, path=path)
1939
1766
parent_index = self._get_parent_index()
1940
1767
parent_details = entry[1][parent_index]
1941
if parent_details[0] == b'f':
1768
if parent_details[0] == 'f':
1942
1769
return parent_details[1]
1945
def get_file_revision(self, path):
1946
with self.lock_read():
1947
inv, inv_file_id = self._path2inv_file_id(path)
1948
return inv.get_entry(inv_file_id).revision
1950
def get_file(self, path):
1951
return BytesIO(self.get_file_text(path))
1953
def get_file_size(self, path):
1772
def get_file(self, file_id, path=None):
1773
return StringIO(self.get_file_text(file_id))
1775
def get_file_size(self, file_id):
1954
1776
"""See Tree.get_file_size"""
1955
inv, inv_file_id = self._path2inv_file_id(path)
1956
return inv.get_entry(inv_file_id).text_size
1958
def get_file_text(self, path):
1960
for _, content_iter in self.iter_files_bytes([(path, None)]):
1961
if content is not None:
1962
raise AssertionError('iter_files_bytes returned'
1963
' too many entries')
1964
# For each entry returned by iter_files_bytes, we must consume the
1965
# content_iter before we step the files iterator.
1966
content = b''.join(content_iter)
1968
raise AssertionError('iter_files_bytes did not return'
1969
' the requested data')
1972
def get_reference_revision(self, path):
1973
inv, inv_file_id = self._path2inv_file_id(path)
1974
return inv.get_entry(inv_file_id).reference_revision
1777
return self.inventory[file_id].text_size
1779
def get_file_text(self, file_id, path=None):
1780
_, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1781
return ''.join(content)
1783
def get_reference_revision(self, file_id, path=None):
1784
return self.inventory[file_id].reference_revision
1976
1786
def iter_files_bytes(self, desired_files):
1977
1787
"""See Tree.iter_files_bytes.
2046
1853
return (kind, None, None, None)
2048
def is_executable(self, path):
2049
inv, inv_file_id = self._path2inv_file_id(path)
2050
if inv_file_id is None:
2051
raise errors.NoSuchFile(path)
2052
ie = inv.get_entry(inv_file_id)
1855
def is_executable(self, file_id, path=None):
1856
ie = self.inventory[file_id]
2053
1857
if ie.kind != "file":
2055
1859
return ie.executable
2057
def is_locked(self):
2060
def list_files(self, include_root=False, from_dir=None, recursive=True,
2061
recurse_nested=False):
2062
# The only files returned by this are those from the version
1861
def list_files(self, include_root=False, from_dir=None, recursive=True):
1862
# We use a standard implementation, because DirStateRevisionTree is
1863
# dealing with one of the parents of the current state
1864
inv = self._get_inventory()
2063
1865
if from_dir is None:
2064
1866
from_dir_id = None
2065
inv = self.root_inventory
2067
inv, from_dir_id = self._path2inv_file_id(from_dir)
1868
from_dir_id = inv.path2id(from_dir)
2068
1869
if from_dir_id is None:
2069
1870
# Directory not versioned
2071
def iter_entries(inv):
2072
entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
2073
if inv.root is not None and not include_root and from_dir is None:
2074
# skip the root for compatibility with the current apis.
2076
for path, entry in entries:
2077
if entry.kind == 'tree-reference' and recurse_nested:
2078
subtree = self._get_nested_tree(
2079
path, entry.file_id, entry.reference_revision)
2080
for subpath, status, kind, entry in subtree.list_files(
2081
include_root=True, recursive=recursive,
2082
recurse_nested=recurse_nested):
2084
full_subpath = osutils.pathjoin(path, subpath)
2087
yield full_subpath, status, kind, entry
2089
yield path, 'V', entry.kind, entry
2090
return iter_entries(inv)
1872
entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1873
if inv.root is not None and not include_root and from_dir is None:
1875
for path, entry in entries:
1876
yield path, 'V', entry.kind, entry.file_id, entry
2092
1878
def lock_read(self):
2093
"""Lock the tree for a set of operations.
2095
:return: A breezy.lock.LogicalLockResult.
1879
"""Lock the tree for a set of operations."""
2097
1880
if not self._locked:
2098
1881
self._repository.lock_read()
2099
1882
if self._dirstate._lock_token is None:
2100
1883
self._dirstate.lock_read()
2101
1884
self._dirstate_locked = True
2102
1885
self._locked += 1
2103
return LogicalLockResult(self.unlock)
2105
1887
def _must_be_locked(self):
2106
1888
if not self._locked:
2107
1889
raise errors.ObjectNotLocked(self)
2109
1892
def path2id(self, path):
2110
1893
"""Return the id for path in this tree."""
2111
1894
# lookup by path: faster than splitting and walking the ivnentory.
2112
if isinstance(path, list):
2115
path = osutils.pathjoin(*path)
2116
with self.lock_read():
2117
entry = self._get_entry(path=path)
2118
if entry == (None, None):
2119
nested_tree, subpath = self.get_containing_nested_tree(path)
2120
if nested_tree is not None:
2121
return nested_tree.path2id(subpath)
1895
entry = self._get_entry(path=path)
1896
if entry == (None, None):
2125
1900
def unlock(self):
2126
1901
"""Unlock, freeing any cache memory used during the lock."""
2127
1902
# outside of a lock, the inventory is suspect: release it.
2129
1904
if not self._locked:
2130
1905
self._inventory = None
2131
1906
self._locked = 0
added
removed
bzrlib/workingtree_4.py
