/brz/remove-bazaar

# Copyright (C) 2006-2010 Canonical Ltd

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

'f' is a file entry: As for directory, but it's a file. The fingerprint is the

    sha1 value of the file's canonical form, i.e. after any read filters have

    been applied to the convenience form stored in the working tree.

    WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target,

format did not accommodate.

   i.e.

     root_entrie = (direntry for root, [parent_direntries_for_root]),

      single vector, rather each individual, which tends to be limited to a

      manageable number. Will scale badly on trees with 10K entries in a

      we should have a net win regardless of optimality. So we are going to

Figures: Creating a tuple from 3 elements was profiled at 0.0625

import operator

class SHA1Provider(object):

    """An interface for getting sha1s of a file."""

 

    def sha1(self, abspath):

        """Return the sha1 of a file given its absolute path.

 

        :param abspath:  May be a filesystem encoded absolute path

             or a unicode path.

        """

        raise NotImplementedError(self.sha1)

 

    def stat_and_sha1(self, abspath):

        """Return the stat and sha1 of a file given its absolute path.

        

        :param abspath:  May be a filesystem encoded absolute path

             or a unicode path.

 

        Note: the stat should be the stat of the physical file

        while the sha may be the sha of its canonical content.

        """

        raise NotImplementedError(self.stat_and_sha1)

 

 

class DefaultSHA1Provider(SHA1Provider):

    """A SHA1Provider that reads directly from the filesystem."""

 

    def sha1(self, abspath):

        """Return the sha1 of a file given its absolute path."""

        return osutils.sha_file_by_name(abspath)

 

    def stat_and_sha1(self, abspath):

        """Return the stat and sha1 of a file given its absolute path."""

        file_obj = file(abspath, 'rb')

        try:

            statvalue = os.fstat(file_obj.fileno())

            sha1 = osutils.sha_file(file_obj)

        finally:

            file_obj.close()

        return statvalue, sha1

 

 

    def __init__(self, path, sha1_provider):

        :param sha1_provider: an object meeting the SHA1Provider interface.

        #   of what is on disk.

        # If true, an error has been detected while updating the dirstate, and

        self._sha1_provider = sha1_provider

            self._sha1_file = self._sha1_provider.sha1

            path foo within the root, 'foo/bar' is the path bar within foo

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

        :param fingerprint: The sha value of the file's canonical form (i.e.

            after any read filters have been applied),

        # find the block its in.

        # now that we've normalised, we need the correct utf8 path and

        rename_from = None

        file_id_entry = self._get_entry(0, fileid_utf8=file_id, include_deleted=True)

            if file_id_entry[1][0][0] == 'a':

                if file_id_entry[0] != (dirname, basename, file_id):

                    # set the old name's current operation to rename

                    self.update_minimal(file_id_entry[0],

                        'r',

                        path_utf8='',

                        packed_stat='',

                        fingerprint=utf8path

                    )

                    rename_from = file_id_entry[0][0:2]

            else:

                path = osutils.pathjoin(file_id_entry[0][0], file_id_entry[0][1])

                kind = DirState._minikind_to_kind[file_id_entry[1][0][0]]

                info = '%s:%s' % (kind, path)

                raise errors.DuplicateFileId(file_id, info)

            while (entry_index < len(block) and

        if rename_from is not None:

            if rename_from[0]:

                old_path_utf8 = '%s/%s' % rename_from

            else:

                old_path_utf8 = rename_from[1]

            parent_info[0] = ('r', old_path_utf8, 0, False, '')

 

            ## In future, when doing partial parsing, this should load and

        # The two blocks here are deliberate: the root block and the

        # root-contents, and for '', we get 2 back, so this is

    def from_tree(tree, dir_state_filename, sha1_provider=None):

        :param sha1_provider: an object meeting the SHA1Provider interface.

            If None, a DefaultSHA1Provider is used.

        result = DirState.initialize(dir_state_filename,

            sha1_provider=sha1_provider)

        This is the workhorse for apply_inventory_delta in dirstate based

        trees.

 

        encode = cache_utf8.encode

        # Accumulate parent references (path_utf8, id), to check for parentless

        # items or items placed under files/links/tree-references. We get

        # references from every item in the delta that is not a deletion and

        # is not itself the root.

        parents = set()

        # Added ids must not be in the dirstate already. This set holds those

        # ids.

        new_ids = set()

        # This loop transforms the delta to single atomic operations that can

        # be executed and validated.

        for old_path, new_path, file_id, inv_entry in sorted(

            inventory._check_delta_unique_old_paths(

            inventory._check_delta_unique_new_paths(

            inventory._check_delta_ids_match_entry(

            inventory._check_delta_ids_are_valid(

            inventory._check_delta_new_path_entry_both_or_None(delta))))),

            reverse=True):

                raise errors.InconsistentDelta(old_path or new_path, file_id,

                    "repeated file_id")

            else:

                new_ids.add(file_id)

                if inv_entry is None:

                    raise errors.InconsistentDelta(new_path, file_id,

                        "new_path with no entry")

                dirname_utf8, basename = osutils.split(new_path)

                if basename:

                    parents.add((dirname_utf8, inv_entry.parent_id))

                key = (dirname_utf8, basename, file_id)

                    fingerprint = inv_entry.reference_revision or ''

                    old_child_path = osutils.pathjoin(child_dirname,

                                                      child_basename)

                    new_child_path = osutils.pathjoin(new_child_dirname,

                                                      child_basename)

        self._check_delta_ids_absent(new_ids, delta, 0)

        try:

            self._apply_removals(removals.iteritems())

            self._apply_insertions(insertions.values())

            # Validate parents

            self._after_delta_check_parents(parents, 0)

        except errors.BzrError, e:

            self._changes_aborted = True

            if 'integrity error' not in str(e):

                raise

            # _get_entry raises BzrError when a request is inconsistent; we

            # want such errors to be shown as InconsistentDelta - and that 

            # fits the behaviour we trigger.

            raise errors.InconsistentDeltaDelta(delta, "error from _get_entry.")

        for file_id, path in sorted(removals, reverse=True,

            key=operator.itemgetter(1)):

            try:

                entry = self._dirblocks[block_i][1][entry_i]

            except IndexError:

                self._changes_aborted = True

                raise errors.InconsistentDelta(path, file_id,

                    "Wrong path for old path.")

            if not f_present or entry[1][0][0] in 'ar':

                self._changes_aborted = True

                raise errors.InconsistentDelta(path, file_id,

                    "Wrong path for old path.")

            if file_id != entry[0][2]:

                self._changes_aborted = True

                raise errors.InconsistentDelta(path, file_id,

                    "Attempt to remove path has wrong id - found %r."

                    % entry[0][2])

                        self._changes_aborted = True

        try:

            for key, minikind, executable, fingerprint, path_utf8 in sorted(adds):

                self.update_minimal(key, minikind, executable, fingerprint,

                                    path_utf8=path_utf8)

        except errors.NotVersionedError:

            self._changes_aborted = True

            raise errors.InconsistentDelta(path_utf8.decode('utf8'), key[2],

                "Missing parent")

        # Accumulate parent references (path_utf8, id), to check for parentless

        # items or items placed under files/links/tree-references. We get

        # references from every item in the delta that is not a deletion and

        # is not itself the root.

        parents = set()

        # Added ids must not be in the dirstate already. This set holds those

        # ids.

        new_ids = set()

            if inv_entry is not None and file_id != inv_entry.file_id:

                raise errors.InconsistentDelta(new_path, file_id,

                    "mismatched entry file_id %r" % inv_entry)

            if new_path is not None:

                if inv_entry is None:

                    raise errors.InconsistentDelta(new_path, file_id,

                        "new_path with no entry")

                new_path_utf8 = encode(new_path)

                # note the parent for validation

                dirname_utf8, basename_utf8 = osutils.split(new_path_utf8)

                if basename_utf8:

                    parents.add((dirname_utf8, inv_entry.parent_id))

                new_ids.add(file_id)

        self._check_delta_ids_absent(new_ids, delta, 1)

        try:

            # Finish expunging deletes/first half of renames.

            self._update_basis_apply_deletes(deletes)

            # Reinstate second half of renames and new paths.

            self._update_basis_apply_adds(adds)

            # Apply in-situ changes.

            self._update_basis_apply_changes(changes)

            # Validate parents

            self._after_delta_check_parents(parents, 1)

        except errors.BzrError, e:

            self._changes_aborted = True

            if 'integrity error' not in str(e):

                raise

            # _get_entry raises BzrError when a request is inconsistent; we

            # want such errors to be shown as InconsistentDelta - and that 

            # fits the behaviour we trigger. Partof this is driven by dirstate

            # only supporting deltas that turn the basis into a closer fit to

            # the active tree.

            raise errors.InconsistentDeltaDelta(delta, "error from _get_entry.")

    def _check_delta_ids_absent(self, new_ids, delta, tree_index):

        """Check that none of the file_ids in new_ids are present in a tree."""

        if not new_ids:

            return

        id_index = self._get_id_index()

        for file_id in new_ids:

            for key in id_index.get(file_id, []):

                block_i, entry_i, d_present, f_present = \

                    self._get_block_entry_index(key[0], key[1], tree_index)

                if not f_present:

                    # In a different tree

                    continue

                entry = self._dirblocks[block_i][1][entry_i]

                if entry[0][2] != file_id:

                    # Different file_id, so not what we want.

                    continue

                # NB: No changes made before this helper is called, so no need

                # to set the _changes_aborted flag.

                raise errors.InconsistentDelta(

                    ("%s/%s" % key[0:2]).decode('utf8'), file_id,

                    "This file_id is new in the delta but already present in "

                    "the target")

 

                self._changes_aborted = True

    def _after_delta_check_parents(self, parents, index):

        """Check that parents required by the delta are all intact.

        

        :param parents: An iterable of (path_utf8, file_id) tuples which are

            required to be present in tree 'index' at path_utf8 with id file_id

            and be a directory.

        :param index: The column in the dirstate to check for parents in.

        """

        for dirname_utf8, file_id in parents:

            # Get the entry - the ensures that file_id, dirname_utf8 exists and

            # has the right file id.

            entry = self._get_entry(index, file_id, dirname_utf8)

            if entry[1] is None:

                self._changes_aborted = True

                raise errors.InconsistentDelta(dirname_utf8.decode('utf8'),

                    file_id, "This parent is not present.")

            # Parents of things must be directories

            if entry[1][index][0] != 'd':

                self._changes_aborted = True

                raise errors.InconsistentDelta(dirname_utf8.decode('utf8'),

                    file_id, "This parent is not a directory.")

 

    def _observed_sha1(self, entry, sha1, stat_value,

        _stat_to_minikind=_stat_to_minikind, _pack_stat=pack_stat):

        """Note the sha1 of a file.

 

        :param entry: The entry the sha1 is for.

        :param sha1: The observed sha1.

        :param stat_value: The os.lstat for the file.

        """

        try:

            minikind = _stat_to_minikind[stat_value.st_mode & 0170000]

        except KeyError:

            # Unhandled kind

            return None

        packed_stat = _pack_stat(stat_value)

        if minikind == 'f':

            if self._cutoff_time is None:

                self._sha_cutoff_time()

            if (stat_value.st_mtime < self._cutoff_time

                and stat_value.st_ctime < self._cutoff_time):

                entry[1][0] = ('f', sha1, entry[1][0][2], entry[1][0][3],

                    packed_stat)

                self._dirblock_state = DirState.IN_MEMORY_MODIFIED

 

        return self._sha1_provider.sha1(abspath)

        fs_encoding = osutils._fs_enc

        if isinstance(abspath, unicode):

            # abspath is defined as the path to pass to lstat. readlink is

            # buggy in python < 2.6 (it doesn't encode unicode path into FS

            # encoding), so we need to encode ourselves knowing that unicode

            # paths are produced by UnicodeDirReader on purpose.

            abspath = abspath.encode(fs_encoding)

        target = os.readlink(abspath)

        if fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):

            # Change encoding if needed

            target = target.decode(fs_encoding).encode('UTF-8')

        return target

    def _get_entry(self, tree_index, fileid_utf8=None, path_utf8=None, include_deleted=False):

        :param include_deleted: If True, and performing a lookup via

            fileid_utf8 rather than path_utf8, return an entry for deleted

            (absent) paths.

                raise errors.BzrError('path_utf8 is not a str: %s %r'

                    # TODO: We might want to assert that entry[0][2] ==

                    #       fileid_utf8.

                        # this is the result we are looking for: the

                        if include_deleted:

                            return entry

    def initialize(cls, path, sha1_provider=None):

        :param sha1_provider: an object meeting the SHA1Provider interface.

            If None, a DefaultSHA1Provider is used.

        if sha1_provider is None:

            sha1_provider = DefaultSHA1Provider()

        result = cls(path, sha1_provider)

            if inv_entry.symlink_target is None:

                fingerprint = ''

            else:

                fingerprint = inv_entry.symlink_target.encode('utf8')

        This only returns entries that are present (not in 'a', 'r') in

 

    def on_file(path, sha1_provider=None):

        """Construct a DirState on the file at path "path".

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

        :param sha1_provider: an object meeting the SHA1Provider interface.

            If None, a DefaultSHA1Provider is used.

        if sha1_provider is None:

            sha1_provider = DefaultSHA1Provider()

        result = DirState(path, sha1_provider)

 

            tree. Each tuple contains the directory path and a list of entries

            even if the revision_id refers to a ghost: supply an empty tree in

        """

        # TODO: generate a list of parent indexes to preserve to save

        # for now:

        # sketch: loop over all entries in the dirstate, cherry picking

        # - find other keys containing a path

        # We accumulate each entry via this dictionary, including the root

 

        # how many trees do we end up with