/brz/remove-bazaar

# Copyright (C) 2006-2011 Canonical Ltd

#

# 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

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

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

import contextlib

import os

import errno

from stat import S_ISREG, S_IEXEC

import time

from . import (

    config as _mod_config,

    controldir,

    errors,

    lazy_import,

    lock,

    osutils,

    registry,

    trace,

    )

lazy_import.lazy_import(globals(), """

from breezy import (

    conflicts,

    multiparent,

    revision as _mod_revision,

    ui,

    urlutils,

    )

from breezy.i18n import gettext

""")

from .errors import (DuplicateKey,

                     BzrError, InternalBzrError)

from .filters import filtered_output_bytes, ContentFilterContext

from .mutabletree import MutableTree

from .osutils import (

    delete_any,

    file_kind,

    pathjoin,

    sha_file,

    splitpath,

    supports_symlinks,

    )

from .progress import ProgressPhase

from .tree import (

    InterTree,

    TreeChange,

    find_previous_path,

    )

ROOT_PARENT = "root-parent"

class NoFinalPath(BzrError):

    _fmt = ("No final name for trans_id %(trans_id)r\n"

            "file-id: %(file_id)r\n"

            "root trans-id: %(root_trans_id)r\n")

    def __init__(self, trans_id, transform):

        self.trans_id = trans_id

        self.file_id = transform.final_file_id(trans_id)

        self.root_trans_id = transform.root

class ReusingTransform(BzrError):

    _fmt = "Attempt to reuse a transform that has already been applied."

class MalformedTransform(InternalBzrError):

    _fmt = "Tree transform is malformed %(conflicts)r"

class CantMoveRoot(BzrError):

    _fmt = "Moving the root directory is not supported at this time"

class ImmortalLimbo(BzrError):

    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.

    Please examine %(limbo_dir)s to see if it contains any files you wish to

    keep, and delete it when you are done."""

    def __init__(self, limbo_dir):

        BzrError.__init__(self)

        self.limbo_dir = limbo_dir

class TransformRenameFailed(BzrError):

    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"

    def __init__(self, from_path, to_path, why, errno):

        self.from_path = from_path

        self.to_path = to_path

        self.why = why

        self.errno = errno

def unique_add(map, key, value):

    if key in map:

        raise DuplicateKey(key=key)

    map[key] = value

class _TransformResults(object):

    def __init__(self, modified_paths, rename_count):

        object.__init__(self)

        self.modified_paths = modified_paths

        self.rename_count = rename_count

class TreeTransform(object):

    """Represent a tree transformation.

    This object is designed to support incremental generation of the transform,

    in any order.

    However, it gives optimum performance when parent directories are created

    before their contents.  The transform is then able to put child files

    directly in their parent directory, avoiding later renames.

    It is easy to produce malformed transforms, but they are generally

    harmless.  Attempting to apply a malformed transform will cause an

    exception to be raised before any modifications are made to the tree.

    Many kinds of malformed transforms can be corrected with the

    resolve_conflicts function.  The remaining ones indicate programming error,

    such as trying to create a file with no path.

    Two sets of file creation methods are supplied.  Convenience methods are:

     * new_file

     * new_directory

     * new_symlink

    These are composed of the low-level methods:

     * create_path

     * create_file or create_directory or create_symlink

     * version_file

     * set_executability

    Transform/Transaction ids

    -------------------------

    trans_ids are temporary ids assigned to all files involved in a transform.

    It's possible, even common, that not all files in the Tree have trans_ids.

    trans_ids are only valid for the TreeTransform that generated them.

    """

    def __init__(self, tree, pb=None):

        self._tree = tree

        # A progress bar

        self._pb = pb

        self._id_number = 0

        # Mapping of path in old tree -> trans_id

        self._tree_path_ids = {}

        # Mapping trans_id -> path in old tree

        self._tree_id_paths = {}

        # mapping of trans_id -> new basename

        self._new_name = {}

        # mapping of trans_id -> new parent trans_id

        self._new_parent = {}

        # mapping of trans_id with new contents -> new file_kind

        self._new_contents = {}

        # Set of trans_ids whose contents will be removed

        self._removed_contents = set()

        # Mapping of trans_id -> new execute-bit value

        self._new_executability = {}

        # Mapping of trans_id -> new tree-reference value

        self._new_reference_revision = {}

        # Set of trans_ids that will be removed

        self._removed_id = set()

        # Indicator of whether the transform has been applied

        self._done = False

    def __enter__(self):

        """Support Context Manager API."""

        return self

    def __exit__(self, exc_type, exc_val, exc_tb):

        """Support Context Manager API."""

        self.finalize()

    def iter_tree_children(self, trans_id):

        """Iterate through the entry's tree children, if any.

        :param trans_id: trans id to iterate

        :returns: Iterator over paths

        """

        raise NotImplementedError(self.iter_tree_children)

    def canonical_path(self, path):

        return path

    def tree_kind(self, trans_id):

        raise NotImplementedError(self.tree_kind)

    def by_parent(self):

        """Return a map of parent: children for known parents.

        Only new paths and parents of tree files with assigned ids are used.

        """

        by_parent = {}

        items = list(self._new_parent.items())

        items.extend((t, self.final_parent(t))

                     for t in list(self._tree_id_paths))

        for trans_id, parent_id in items:

            if parent_id not in by_parent:

                by_parent[parent_id] = set()

            by_parent[parent_id].add(trans_id)

        return by_parent

    def finalize(self):

        """Release the working tree lock, if held.

        This is required if apply has not been invoked, but can be invoked

        even after apply.

        """

        raise NotImplementedError(self.finalize)

    def create_path(self, name, parent):

        """Assign a transaction id to a new path"""

        trans_id = self._assign_id()

        unique_add(self._new_name, trans_id, name)

        unique_add(self._new_parent, trans_id, parent)

        return trans_id

    def adjust_path(self, name, parent, trans_id):

        """Change the path that is assigned to a transaction id."""

        if parent is None:

            raise ValueError("Parent trans-id may not be None")

        if trans_id == self._new_root:

            raise CantMoveRoot

        self._new_name[trans_id] = name

        self._new_parent[trans_id] = parent

    def adjust_root_path(self, name, parent):

        """Emulate moving the root by moving all children, instead.

        We do this by undoing the association of root's transaction id with the

        current tree.  This allows us to create a new directory with that

        transaction id.  We unversion the root directory and version the

        physically new directory, and hope someone versions the tree root

        later.

        """

        raise NotImplementedError(self.adjust_root_path)

    def fixup_new_roots(self):

        """Reinterpret requests to change the root directory

        Instead of creating a root directory, or moving an existing directory,

        all the attributes and children of the new root are applied to the

        existing root directory.

        This means that the old root trans-id becomes obsolete, so it is

        recommended only to invoke this after the root trans-id has become

        irrelevant.

        """

        raise NotImplementedError(self.fixup_new_roots)

    def _assign_id(self):

        """Produce a new tranform id"""

        new_id = "new-%s" % self._id_number

        self._id_number += 1

        return new_id

    def trans_id_tree_path(self, path):

        """Determine (and maybe set) the transaction ID for a tree path."""

        path = self.canonical_path(path)

        if path not in self._tree_path_ids:

            self._tree_path_ids[path] = self._assign_id()

            self._tree_id_paths[self._tree_path_ids[path]] = path

        return self._tree_path_ids[path]

    def get_tree_parent(self, trans_id):

        """Determine id of the parent in the tree."""

        path = self._tree_id_paths[trans_id]

        if path == "":

            return ROOT_PARENT

        return self.trans_id_tree_path(os.path.dirname(path))

    def delete_contents(self, trans_id):

        """Schedule the contents of a path entry for deletion"""

        kind = self.tree_kind(trans_id)

        if kind is not None:

            self._removed_contents.add(trans_id)

    def cancel_deletion(self, trans_id):

        """Cancel a scheduled deletion"""

        self._removed_contents.remove(trans_id)

    def delete_versioned(self, trans_id):

        """Delete and unversion a versioned file"""

        self.delete_contents(trans_id)

        self.unversion_file(trans_id)

    def set_executability(self, executability, trans_id):

        """Schedule setting of the 'execute' bit

        To unschedule, set to None

        """

        if executability is None:

            del self._new_executability[trans_id]

        else:

            unique_add(self._new_executability, trans_id, executability)

    def set_tree_reference(self, revision_id, trans_id):

        """Set the reference associated with a directory"""

        unique_add(self._new_reference_revision, trans_id, revision_id)

    def version_file(self, trans_id, file_id=None):

        """Schedule a file to become versioned."""

        raise NotImplementedError(self.version_file)

    def cancel_versioning(self, trans_id):

        """Undo a previous versioning of a file"""

        raise NotImplementedError(self.cancel_versioning)

    def unversion_file(self, trans_id):

        """Schedule a path entry to become unversioned"""

        self._removed_id.add(trans_id)

    def new_paths(self, filesystem_only=False):

        """Determine the paths of all new and changed files.

        :param filesystem_only: if True, only calculate values for files

            that require renames or execute bit changes.

        """

        raise NotImplementedError(self.new_paths)

    def final_kind(self, trans_id):

        """Determine the final file kind, after any changes applied.

        :return: None if the file does not exist/has no contents.  (It is

            conceivable that a path would be created without the corresponding

            contents insertion command)

        """

        if trans_id in self._new_contents:

            return self._new_contents[trans_id]

        elif trans_id in self._removed_contents:

            return None

        else:

            return self.tree_kind(trans_id)

    def tree_path(self, trans_id):

        """Determine the tree path associated with the trans_id."""

        return self._tree_id_paths.get(trans_id)

    def final_is_versioned(self, trans_id):

        raise NotImplementedError(self.final_is_versioned)

    def final_parent(self, trans_id):

        """Determine the parent file_id, after any changes are applied.

        ROOT_PARENT is returned for the tree root.

        """

        try:

            return self._new_parent[trans_id]

        except KeyError:

            return self.get_tree_parent(trans_id)

    def final_name(self, trans_id):

        """Determine the final filename, after all changes are applied."""

        try:

            return self._new_name[trans_id]

        except KeyError:

            try:

                return os.path.basename(self._tree_id_paths[trans_id])

            except KeyError:

                raise NoFinalPath(trans_id, self)

    def path_changed(self, trans_id):

        """Return True if a trans_id's path has changed."""

        return (trans_id in self._new_name) or (trans_id in self._new_parent)

    def new_contents(self, trans_id):

        return (trans_id in self._new_contents)

    def find_conflicts(self):

        """Find any violations of inventory or filesystem invariants"""

        raise NotImplementedError(self.find_conflicts)

    def new_file(self, name, parent_id, contents, file_id=None,

                 executable=None, sha1=None):

        """Convenience method to create files.

        name is the name of the file to create.

        parent_id is the transaction id of the parent directory of the file.

        contents is an iterator of bytestrings, which will be used to produce

        the file.

        :param file_id: The inventory ID of the file, if it is to be versioned.

        :param executable: Only valid when a file_id has been supplied.

        """

        raise NotImplementedError(self.new_file)

    def new_directory(self, name, parent_id, file_id=None):

        """Convenience method to create directories.

        name is the name of the directory to create.

        parent_id is the transaction id of the parent directory of the

        directory.

        file_id is the inventory ID of the directory, if it is to be versioned.

        """

        raise NotImplementedError(self.new_directory)

    def new_symlink(self, name, parent_id, target, file_id=None):

        """Convenience method to create symbolic link.

        name is the name of the symlink to create.

        parent_id is the transaction id of the parent directory of the symlink.

        target is a bytestring of the target of the symlink.

        file_id is the inventory ID of the file, if it is to be versioned.

        """

        raise NotImplementedError(self.new_symlink)

    def new_orphan(self, trans_id, parent_id):

        """Schedule an item to be orphaned.

        When a directory is about to be removed, its children, if they are not

        versioned are moved out of the way: they don't have a parent anymore.

        :param trans_id: The trans_id of the existing item.

        :param parent_id: The parent trans_id of the item.

        """

        raise NotImplementedError(self.new_orphan)

    def iter_changes(self):

        """Produce output in the same format as Tree.iter_changes.

        Will produce nonsensical results if invoked while inventory/filesystem

        conflicts (as reported by TreeTransform.find_conflicts()) are present.

        This reads the Transform, but only reproduces changes involving a

        file_id.  Files that are not versioned in either of the FROM or TO

        states are not reflected.

        """

        raise NotImplementedError(self.iter_changes)

    def get_preview_tree(self):

        """Return a tree representing the result of the transform.

        The tree is a snapshot, and altering the TreeTransform will invalidate

        it.

        """

        raise NotImplementedError(self.get_preview_tree)

    def commit(self, branch, message, merge_parents=None, strict=False,

               timestamp=None, timezone=None, committer=None, authors=None,

               revprops=None, revision_id=None):

        """Commit the result of this TreeTransform to a branch.

        :param branch: The branch to commit to.

        :param message: The message to attach to the commit.

        :param merge_parents: Additional parent revision-ids specified by

            pending merges.

        :param strict: If True, abort the commit if there are unversioned

            files.

        :param timestamp: if not None, seconds-since-epoch for the time and

            date.  (May be a float.)

        :param timezone: Optional timezone for timestamp, as an offset in

            seconds.

        :param committer: Optional committer in email-id format.

            (e.g. "J Random Hacker <jrandom@example.com>")

        :param authors: Optional list of authors in email-id format.

        :param revprops: Optional dictionary of revision properties.

        :param revision_id: Optional revision id.  (Specifying a revision-id

            may reduce performance for some non-native formats.)

        :return: The revision_id of the revision committed.

        """

        raise NotImplementedError(self.commit)

    def create_file(self, contents, trans_id, mode_id=None, sha1=None):

        """Schedule creation of a new file.

        :seealso: new_file.

        :param contents: an iterator of strings, all of which will be written

            to the target destination.

        :param trans_id: TreeTransform handle

        :param mode_id: If not None, force the mode of the target file to match

            the mode of the object referenced by mode_id.

            Otherwise, we will try to preserve mode bits of an existing file.

        :param sha1: If the sha1 of this content is already known, pass it in.

            We can use it to prevent future sha1 computations.

        """

        raise NotImplementedError(self.create_file)

    def create_directory(self, trans_id):

        """Schedule creation of a new directory.

        See also new_directory.

        """

        raise NotImplementedError(self.create_directory)

    def create_symlink(self, target, trans_id):

        """Schedule creation of a new symbolic link.

        target is a bytestring.

        See also new_symlink.

        """

        raise NotImplementedError(self.create_symlink)

    def create_hardlink(self, path, trans_id):

        """Schedule creation of a hard link"""

        raise NotImplementedError(self.create_hardlink)

    def cancel_creation(self, trans_id):

        """Cancel the creation of new file contents."""

        raise NotImplementedError(self.cancel_creation)

class OrphaningError(errors.BzrError):

    # Only bugs could lead to such exception being seen by the user

    internal_error = True

    _fmt = "Error while orphaning %s in %s directory"

    def __init__(self, orphan, parent):

        errors.BzrError.__init__(self)

        self.orphan = orphan

        self.parent = parent

class OrphaningForbidden(OrphaningError):

    _fmt = "Policy: %s doesn't allow creating orphans."

    def __init__(self, policy):

        errors.BzrError.__init__(self)

        self.policy = policy

def move_orphan(tt, orphan_id, parent_id):

    """See TreeTransformBase.new_orphan.

    This creates a new orphan in the `brz-orphans` dir at the root of the

    `TreeTransform`.

    :param tt: The TreeTransform orphaning `trans_id`.

    :param orphan_id: The trans id that should be orphaned.

    :param parent_id: The orphan parent trans id.

    """

    # Add the orphan dir if it doesn't exist

    orphan_dir_basename = 'brz-orphans'

    od_id = tt.trans_id_tree_path(orphan_dir_basename)

    if tt.final_kind(od_id) is None:

        tt.create_directory(od_id)

    parent_path = tt._tree_id_paths[parent_id]

    # Find a name that doesn't exist yet in the orphan dir

    actual_name = tt.final_name(orphan_id)

    new_name = tt._available_backup_name(actual_name, od_id)

    tt.adjust_path(new_name, od_id, orphan_id)

    trace.warning('%s has been orphaned in %s'

                  % (joinpath(parent_path, actual_name), orphan_dir_basename))

def refuse_orphan(tt, orphan_id, parent_id):

    """See TreeTransformBase.new_orphan.

    This refuses to create orphan, letting the caller handle the conflict.

    """

    raise OrphaningForbidden('never')

orphaning_registry = registry.Registry()

orphaning_registry.register(

    u'conflict', refuse_orphan,

    'Leave orphans in place and create a conflict on the directory.')

orphaning_registry.register(

    u'move', move_orphan,

    'Move orphans into the brz-orphans directory.')

orphaning_registry._set_default_key(u'conflict')

opt_transform_orphan = _mod_config.RegistryOption(

    'transform.orphan_policy', orphaning_registry,

    help='Policy for orphaned files during transform operations.',

    invalid='warning')

def joinpath(parent, child):

    """Join tree-relative paths, handling the tree root specially"""

    if parent is None or parent == "":

        return child

    else:

        return pathjoin(parent, child)

class FinalPaths(object):

    """Make path calculation cheap by memoizing paths.

    The underlying tree must not be manipulated between calls, or else

    the results will likely be incorrect.

    """

    def __init__(self, transform):

        object.__init__(self)

        self._known_paths = {}

        self.transform = transform

    def _determine_path(self, trans_id):

        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):

            return u""

        name = self.transform.final_name(trans_id)

        parent_id = self.transform.final_parent(trans_id)

        if parent_id == self.transform.root:

            return name

        else:

            return pathjoin(self.get_path(parent_id), name)

    def get_path(self, trans_id):

        """Find the final path associated with a trans_id"""

        if trans_id not in self._known_paths:

            self._known_paths[trans_id] = self._determine_path(trans_id)

        return self._known_paths[trans_id]

    def get_paths(self, trans_ids):

        return [(self.get_path(t), t) for t in trans_ids]

def build_tree(tree, wt, accelerator_tree=None, hardlink=False,

               delta_from_tree=False):

    """Create working tree for a branch, using a TreeTransform.

    This function should be used on empty trees, having a tree root at most.

    (see merge and revert functionality for working with existing trees)

    Existing files are handled like so:

    - Existing bzrdirs take precedence over creating new items.  They are

      created as '%s.diverted' % name.

    - Otherwise, if the content on disk matches the content we are building,

      it is silently replaced.

    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.

    :param tree: The tree to convert wt into a copy of

    :param wt: The working tree that files will be placed into

    :param accelerator_tree: A tree which can be used for retrieving file

        contents more quickly than tree itself, i.e. a workingtree.  tree

        will be used for cases where accelerator_tree's content is different.

    :param hardlink: If true, hard-link files to accelerator_tree, where

        possible.  accelerator_tree must implement abspath, i.e. be a

        working tree.

    :param delta_from_tree: If true, build_tree may use the input Tree to

        generate the inventory delta.

    """

    with contextlib.ExitStack() as exit_stack:

        exit_stack.enter_context(wt.lock_tree_write())

        exit_stack.enter_context(tree.lock_read())

        if accelerator_tree is not None:

            exit_stack.enter_context(accelerator_tree.lock_read())

        return _build_tree(tree, wt, accelerator_tree, hardlink,

                           delta_from_tree)

def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):

    """See build_tree."""

    for num, _unused in enumerate(wt.all_versioned_paths()):

        if num > 0:  # more than just a root

            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)

    file_trans_id = {}

    top_pb = ui.ui_factory.nested_progress_bar()

    pp = ProgressPhase("Build phase", 2, top_pb)

    if tree.path2id('') is not None:

        # This is kind of a hack: we should be altering the root

        # as part of the regular tree shape diff logic.

        # The conditional test here is to avoid doing an

        # expensive operation (flush) every time the root id

        # is set within the tree, nor setting the root and thus

        # marking the tree as dirty, because we use two different

        # idioms here: tree interfaces and inventory interfaces.

        if wt.path2id('') != tree.path2id(''):

            wt.set_root_id(tree.path2id(''))

            wt.flush()

    tt = wt.transform()

    divert = set()

    try:

        pp.next_phase()

        file_trans_id[find_previous_path(wt, tree, '')] = tt.trans_id_tree_path('')

        with ui.ui_factory.nested_progress_bar() as pb:

            deferred_contents = []

            num = 0

            total = len(tree.all_versioned_paths())

            if delta_from_tree:

                precomputed_delta = []

            else:

                precomputed_delta = None

            # Check if tree inventory has content. If so, we populate

            # existing_files with the directory content. If there are no

            # entries we skip populating existing_files as its not used.

            # This improves performance and unncessary work on large

            # directory trees. (#501307)

            if total > 0:

                existing_files = set()

                for dir, files in wt.walkdirs():

                    existing_files.update(f[0] for f in files)

            for num, (tree_path, entry) in \

                    enumerate(tree.iter_entries_by_dir()):

                pb.update(gettext("Building tree"), num

                          - len(deferred_contents), total)

                if entry.parent_id is None:

                    continue

                reparent = False

                file_id = entry.file_id

                if delta_from_tree:

                    precomputed_delta.append((None, tree_path, file_id, entry))

                if tree_path in existing_files:

                    target_path = wt.abspath(tree_path)

                    kind = file_kind(target_path)

                    if kind == "directory":

                        try:

                            controldir.ControlDir.open(target_path)

                        except errors.NotBranchError:

                            pass

                        else:

                            divert.add(tree_path)

                    if (tree_path not in divert

                        and _content_match(