~bzr-pqm/bzr/bzr.dev

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

 

"""DirState objects record the state of a directory and its bzr metadata.

 

'a' is an absent entry: In that tree the id is not present at this path.

'd' is a directory entry: This path in this tree is a directory with the

    current file id. There is no fingerprint for directories.

'l' is a symlink entry: As for directory, but a symlink. The fingerprint is the

    link target.

't' is a reference to a nested subtree; the fingerprint is the referenced

the file on disk, and then immediately discard, the overhead of object creation

becomes a significant cost.

 

microseconds, whereas creating a object which is subclassed from tuple was

0.500 microseconds, and creating an object with 3 elements and slots was 3

microseconds long. 0.1 milliseconds is 100 microseconds, and ideally we'll get

import bisect

import binascii

import errno

import os

from stat import S_IEXEC

import stat

        # return '%X.%X' % (int(st.st_mtime), st.st_mode)

 

 

class DirState(object):

    """Record directory and metadata state for fast access.

 

    HEADER_FORMAT_2 = '#bazaar dirstate flat format 2\n'

    HEADER_FORMAT_3 = '#bazaar dirstate flat format 3\n'

 

        """Create a  DirState object.

 

        :param path: The path at which the dirstate file on disk should live.

        """

        # _header_state and _dirblock_state represent the current state

        # of the dirstate metadata and the per-row data respectiely.

        self._cutoff_time = None

        self._split_path_cache = {}

        self._bisect_page_size = DirState.BISECT_PAGE_SIZE

        if 'hashcache' in debug.debug_flags:

            self._sha1_file = self._sha1_file_and_mutter

        else:

        # These two attributes provide a simple cache for lookups into the

        # dirstate in-memory vectors. By probing respectively for the last

        # block, and for the next entry, we save nearly 2 bisections per path

        :param kind: The kind of the path, as a string like 'file',

            'directory', etc.

        :param stat: The output of os.lstat for the path.

            or the target of a symlink,

            or the referenced revision id for tree-references,

            or '' for directories.

        return entry_index, present

 

    @staticmethod

        """Create a dirstate from a bzr Tree.

 

        :param tree: The tree which should provide parent information and

            inventory ids.

        :return: a DirState object which is currently locked for writing.

            (it was locked by DirState.initialize)

        """

        try:

            tree.lock_read()

            try:

    def update_by_delta(self, delta):

        """Apply an inventory delta to the dirstate for tree 0

 

        :param delta: An inventory delta.  See Inventory.apply_delta for

            details.

        """

        self._read_dirblocks_if_needed()

        insertions = {}

        removals = {}

            if (file_id in insertions) or (file_id in removals):

            if old_path is not None:

                old_path = old_path.encode('utf-8')

                removals[file_id] = old_path

            if new_path is not None:

                new_path = new_path.encode('utf-8')

                minikind = DirState._kind_to_minikind[inv_entry.kind]

                if minikind == 't':

                else:

                    fingerprint = ''

                insertions[file_id] = (key, minikind, inv_entry.executable,

                    minikind = child[1][0][0]

                    fingerprint = child[1][0][4]

                    executable = child[1][0][3]

                    removals[child[0][2]] = old_child_path

                    child_suffix = child_dirname[len(old_path):]

                    new_child_dirname = (new_path + child_suffix)

                    key = (new_child_dirname, child_basename, child[0][2])

                    insertions[child[0][2]] = (key, minikind, executable,

                                               fingerprint, new_child_path)

 

    def _apply_removals(self, removals):

            dirname, basename = osutils.split(path)

            block_i, entry_i, d_present, f_present = \

                self._get_block_entry_index(dirname, basename, 0)

            self._make_absent(entry)

            # See if we have a malformed delta: deleting a directory must not

            # leave crud behind. This increases the number of bisects needed

                # be due to it being in a parent tree, or a corrupt delta.

                for child_entry in self._dirblocks[block_i][1]:

                    if child_entry[1][0][0] not in ('r', 'a'):

                        raise errors.InconsistentDelta(path, entry[0][2],

                            "The file id was deleted but its children were "

                            "not deleted.")

 

    def _apply_insertions(self, adds):

 

    def update_basis_by_delta(self, delta, new_revid):

        """Update the parents of this tree after a commit.

        # At the same time, to reduce interface friction we convert the input

        # inventory entries to dirstate.

        root_only = ('', '')

        for old_path, new_path, file_id, inv_entry in delta:

            if old_path is None:

                adds.append((None, encode(new_path), file_id,

                    inv_to_entry(inv_entry), True))

            elif new_path is None:

                deletes.append((encode(old_path), None, file_id, None, True))

            elif (old_path, new_path) != root_only:

                # for 'r' items on every pass.

                self._update_basis_apply_deletes(deletes)

                deletes = []

                # Split into an add/delete pair recursively.

                adds.append((None, new_path_utf8, file_id,

                    inv_to_entry(inv_entry), False))

                # of everything.

                changes.append((encode(old_path), encode(new_path), file_id,

                    inv_to_entry(inv_entry)))

 

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        self._header_state = DirState.IN_MEMORY_MODIFIED

        self._id_index = None

        return

 

    def _update_basis_apply_adds(self, adds):

        """Apply a sequence of adds to tree 1 during update_basis_by_delta.

 

        null = DirState.NULL_PARENT_DETAILS

        for old_path, new_path, file_id, _, real_delete in deletes:

            if real_delete != (new_path is None):

                raise AssertionError("bad delete delta")

            # the entry for this file_id must be in tree 1.

            dirname, basename = osutils.split(old_path)

                    # it is being resurrected here, so blank it out temporarily.

                    self._dirblocks[block_index][1][entry_index][1][1] = null

 

    def _observed_sha1(self, entry, sha1, stat_value,

        _stat_to_minikind=_stat_to_minikind, _pack_stat=pack_stat):

        """Note the sha1 of a file.

        # when -Dhashcache is turned on, this is monkey-patched in to log

        # file reads

        trace.mutter("dirstate sha1 " + abspath)

 

    def _is_executable(self, mode, old_executable):

        """Is this file executable?"""

        self._read_dirblocks_if_needed()

        if path_utf8 is not None:

            if type(path_utf8) is not str:

                    % (type(path_utf8), path_utf8))

            # path lookups are faster

            dirname, basename = osutils.split(path_utf8)

                entry_index, present = self._find_entry_index(key, block)

                if present:

                    entry = self._dirblocks[block_index][1][entry_index]

                    if entry[1][tree_index][0] in 'fdlt':

                        # this is the result we are looking for: the

                        # real home of this file_id in this tree.

            return None, None

 

    @classmethod

        """Create a new dirstate on path.

 

        The new dirstate will be an empty tree - that is it has no parents,

        and only a root node - which has id ROOT_ID.

 

        :param path: The name of the file for the dirstate.

        :return: A write-locked DirState object.

        """

        # This constructs a new DirState object on a path, sets the _state_file

        # stock empty dirstate information - a root with ROOT_ID, no children,

        # and no parents. Finally it calls save() to ensure that this data will

        # persist.

        # root dir and root dir contents with no children.

        empty_tree_dirblocks = [('', []), ('', [])]

        # a new root directory, with a NULLSTAT.

        return len(self._parents) - len(self._ghosts)

 

    @staticmethod

 

        :return: An unlocked DirState object, associated with the given path.

        """

        return result

 

    def _read_dirblocks_if_needed(self):

        self.update_minimal(('', '', new_id), 'd',

            path_utf8='', packed_stat=entry[1][0][4])

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

 

    def set_parent_trees(self, trees, ghosts):

        """Set the parent trees for the dirstate.

        if 'evil' in debug.debug_flags:

            trace.mutter_callsite(1,

                "set_state_from_inventory called; please mutate the tree instead")

        self._read_dirblocks_if_needed()

        # sketch:

        # Two iterators: current data and new data, both in dirblock order.

        new_iterator = new_inv.iter_entries_by_dir()

        # we will be modifying the dirstate, so we need a stable iterator. In

        # future we might write one, for now we just clone the state into a

        old_iterator = iter(list(self._iter_entries()))

        # both must have roots so this is safe:

        current_new = new_iterator.next()

            # we make both end conditions explicit

            if not current_old:

                # old is finished: insert current_new into the state.

                self.update_minimal(new_entry_key, current_new_minikind,

                    executable=current_new[1].executable,

                current_new = advance(new_iterator)

            elif not current_new:

                # new is finished

                self._make_absent(current_old)

                current_old = advance(old_iterator)

            elif new_entry_key == current_old[0]:

                # kind has changed.

                if (current_old[1][0][3] != current_new[1].executable or

                    current_old[1][0][0] != current_new_minikind):

                    self.update_minimal(current_old[0], current_new_minikind,

                        executable=current_new[1].executable,

                # both sides are dealt with, move on

                current_old = advance(old_iterator)

                current_new = advance(new_iterator)

                      and new_entry_key[1:] < current_old[0][1:])):

                # new comes before:

                # add a entry for this and advance new

                self.update_minimal(new_entry_key, current_new_minikind,

                    executable=current_new[1].executable,

                current_new = advance(new_iterator)

            else:

                # we've advanced past the place where the old key would be,

                # without seeing it in the new list.  so it must be gone.

                self._make_absent(current_old)

                current_old = advance(old_iterator)

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        self._id_index = None

        self._packed_stat_index = None

 

    def _make_absent(self, current_old):

        """Mark current_old - an entry - as absent for tree 0.

        return last_reference

 

    def update_minimal(self, key, minikind, executable=False, fingerprint='',

        """Update an entry to the state in tree 0.

 

        This will either create a new entry at 'key' or update an existing one.

        :param minikind: The type for the entry ('f' == 'file', 'd' ==

                'directory'), etc.

        :param executable: Should the executable bit be set?

        :param packed_stat: Packed stat value for new entry.

        :param size: Size information for new entry

        :param path_utf8: key[0] + '/' + key[1], just passed in to avoid doing

                extra computation.

 

        If packed_stat and fingerprint are not given, they're invalidated in

        the entry.

        new_details = (minikind, fingerprint, size, executable, packed_stat)

        id_index = self._get_id_index()

        if not present:

            # new entry, synthesis cross reference here,

            existing_keys = id_index.setdefault(key[2], set())

            if not existing_keys:

                # grab one of them and use it to generate parent

                # relocation/absent entries.

                new_entry = key, [new_details]

                    # change the record at other to be a pointer to this new

                    # record. The loop looks similar to the change to

                    # relocations when updating an existing record but its not:

                    # the test for existing kinds is different: this can be

                    # factored out to a helper though.

                    if path_utf8 is None:

                        raise AssertionError('no path')

 

                num_present_parents = self._num_present_parents()

                for lookup_index in xrange(1, num_present_parents + 1):

                    # grab any one entry, use it to find the right path.

                    # TODO: optimise this to reduce memory use in highly

                    update_entry_index, present = \

                        self._find_entry_index(other_key, self._dirblocks[update_block_index][1])

                    if not present:

                    update_details = self._dirblocks[update_block_index][1][update_entry_index][1][lookup_index]

                    if update_details[0] in 'ar': # relocated, absent

                        # its a pointer or absent in lookup_index's tree, use

 

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

 

    def _validate(self):

        """Check that invariants on the dirblock are correct.

 

            if absent_positions == tree_count:

                raise AssertionError(

                    "entry %r has no data for any tree." % (entry,))

 

    def _wipe_state(self):

        """Forget all state information about the dirstate."""

            and stat_value.st_ctime < state._cutoff_time

            and len(entry[1]) > 1

            and entry[1][1][0] != 'a'):

            link_or_sha1 = state._sha1_file(abspath)

            entry[1][0] = ('f', link_or_sha1, stat_value.st_size,

                           executable, packed_stat)

                           False, DirState.NULLSTAT)

    state._dirblock_state = DirState.IN_MEMORY_MODIFIED

    return link_or_sha1

 

 

class ProcessEntryPython(object):

 

        "last_source_parent", "last_target_parent", "include_unchanged",

 

    def __init__(self, include_unchanged, use_filesystem_for_exec,

        search_specific_files, state, source_index, target_index,

        want_unversioned, tree):

        self.old_dirname_to_file_id = {}

        self.new_dirname_to_file_id = {}

        # Using a list so that we can access the values and change them in

        # nested scope. Each one is [path, file_id, entry]

        self.last_source_parent = [None, None]

        self.use_filesystem_for_exec = use_filesystem_for_exec

        self.utf8_decode = cache_utf8._utf8_decode

        # for all search_indexs in each path at or under each element of

        self.searched_specific_files = set()

        self.search_specific_files = search_specific_files

        self.state = state

        self.source_index = source_index

        self.target_index = target_index

        self.want_unversioned = want_unversioned

        self.tree = tree

 

        """Compare an entry and real disk to generate delta information.

 

        :param path_info: top_relpath, basename, kind, lstat, abspath for

            Basename is returned as a utf8 string because we expect this

            tuple will be ignored, and don't want to take the time to

            decode.

        """

        if self.source_index is None:

            source_details = DirState.NULL_PARENT_DETAILS

                    if source_minikind != 'f':

                        content_change = True

                    else: