~abentley/bzrtools/bzrtools.dev

 

import errno

 

from bzrlib.errors import BzrError

from bzrlib.errors import NotBranchError, BzrCommandError, NoSuchRevision

from bzrlib.clone import copy_branch

from bzrlib.commit import Commit, NullCommitReporter

from bzrlib.option import _global_option

from bzrlib.workingtree import WorkingTree

    from pybaz import NameParser as NameParser

from fai import iter_new_merges, direct_merges

class ImportCommitReporter(NullCommitReporter):

    def __init__(self, pb):

        self.pb = pb

 

    def escaped(self, escape_count, message):

        self.pb.clear()

        bzrlib.trace.warning("replaced %d control characters in message" %

                             escape_count)

 

saved_dir = None

 

    global saved_dir

    saved_dir = os.getcwdu()

    os.chdir(saved_dir)

    except StopIteration:

        return ()

        print version

            " an Arch revision (%s)" % (branch.base, last_patch))

 

def do_branch(br_from, to_location, revision_id):

    """Derived from branch in builtins."""

    br_from.lock_read()

    try:

        try:

            os.mkdir(to_location)

        except OSError, e:

            if e.errno == errno.EEXIST:

                raise UserError('Target directory "%s" already'

                                      ' exists.' % to_location)

            if e.errno == errno.ENOENT:

                raise UserError('Parent of "%s" does not exist.' %

                                      to_location)

            else:

                raise

        try:

            copy_branch(br_from, to_location, revision_id, None)

        except NoSuchRevision:

            rmtree(to_location)

            msg = "The branch %s has no revision %s." % (from_location, revision_id)

            raise UserError(msg)

    finally:

        br_from.unlock()

 

def get_remaining_revisions(output_dir, version, reuse_history_from=[]):

    output_exists = os.path.exists(output_dir)

    if output_exists:

        branch = Branch.open(output_dir)

        if not output_exists and reuse_history_from != []:

            for ancestor in reversed(ancestors):

                if last_patch is not None:

                    # found something to copy

                    break

                # try to grab a copy of ancestor

                # note that is not optimised: we could look for namespace

                # transitions and only look for the past after the 

                # transition.

                for history_root in reuse_history_from:

                    possible_source = os.path.join(history_root,

                        map_namespace(ancestor.version))

                    try:

                        source = Branch.open(possible_source)

                        rev_id = revision_id(ancestor)

                        if rev_id in source.revision_history():

                            do_branch(source, output_dir, rev_id)

                            last_patch = ancestor

                            break

                    except NotBranchError:

                        pass

        raise UserError(str(e))

        old_revno = Branch.open(output_dir).revno()

 

###class Importer(object):

###    """An importer.

###    

###    Currently this is used as a parameter object, though more behaviour is

###    possible later.

###    """

###

###    def __init__(self, output_dir, version, printer, fancy=True, fast=False,

###                 verbose=False, dry_run=False, max_count=None, 

###                   reuse_history_from=[]):

###        self.output_dir = output_dir

###        self.version = version

###        self.

 

 

def import_version(output_dir, version, printer, fancy=True, fast=False,

                   verbose=False, dry_run=False, max_count=None,

                   reuse_history_from=[]):

    >>> def printer(message): print message

    >>> import_version('/', version, printer, fancy=False, dry_run=True)

    NotPreviousImport: / is not the location of a previous import.

    >>> import_version(result_path, version, printer, fancy=False, dry_run=True)

    >>> import_version(result_path, version, printer, fancy=False, dry_run=True)

    >>> import_version(result_path, version, printer, fancy=False)

    >>> import_version(result_path, version, printer, fancy=False)

    >>> import_version(result_path, version, printer, fancy=False)

        ancestors, old_revno = get_remaining_revisions(output_dir, version,

                                                       reuse_history_from)

    except NotBranchError, e:

    if old_revno is None and len(ancestors) == 0:

        print 'Version %s has no revisions.' % version

        return

        last_revision = get_last_revision(Branch.open(output_dir))

                    progress_bar, fast=fast, verbose=verbose, dry_run=dry_run,

                    max_count=max_count):

            revdir = os.path.join(tempdir, "rd")

            if os.path.exists(revdir):

                # actual imports were done

                tmp_bzr_dir = os.path.join(tempdir, '.bzr')

                

                bzr_dir = os.path.join(output_dir, '.bzr')

                new_bzr_dir = os.path.join(tempdir, "rd", '.bzr')

    

                os.rename(bzr_dir, tmp_bzr_dir) # Move the original bzr out of the way

                os.rename(new_bzr_dir, bzr_dir)

                try:

                    bzrlib.merge.merge((output_dir, -1), (output_dir, None), # old_revno), 

                                       check_clean=False, this_dir=output_dir, 

                                       ignore_zero=True)

                except:

                    # If something failed, move back the original bzr directory

                    os.rename(bzr_dir, new_bzr_dir)

                    os.rename(tmp_bzr_dir, bzr_dir)

                    raise

            else:

                # no imports - perhaps just append_revisions

                # should not fail:

                bzrlib.merge.merge((output_dir, -1), (output_dir, None), # old_revno), 

        printer('Cleaning up')

    printer("Import complete.")

    'Arch-1:you@example.com%cat--br--0--base-0'

    return "Arch-1:%s" % str(arch_revision).replace('/', '%')

    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0"))

    Traceback (most recent call last):

    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0 does not look like it came from Arch.

    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--base-5"))

    Traceback (most recent call last):

    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0--base-5 does not look like it came from Arch.

    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--patch-5"))

    if revision_id[:7] != 'Arch-1:':

def iter_import_version(output_dir, ancestors, tempdir, pb, fast=False,

                        verbose=False, dry_run=False, max_count=None):

    missing_ancestor = None

        rev_id = revision_id(revision)

        direct_merges = []

        if revdir is None and os.path.exists(output_dir):

            # check for imported revisions and if present just append immediately

            branch = Branch.open(output_dir)

            if branch.has_revision(rev_id):

                branch.append_revision(rev_id)

                continue

            try:

                tree, baz_inv, log = get_revision(revdir, revision)

            except pybaz.errors.ExecProblem, e:

                if ("%s" % e.args).find('could not connect') == -1:

                    raise

                missing_ancestor = revision

                revdir = None

                print ("unable to access ancestor %s, making into a merge."

                       % missing_ancestor)

                continue

                # RBC20051024 - yes, it would be a problem as we could not then

                # apply the corrupted revision.

                branch = Branch.open(revdir)

            baz_inv, log = apply_revision(tree, revision)

            branch = Branch.open(revdir)

        # cached so we can delete the log

        log_date = log.date

        log_summary = log.summary

        log_description = log.description

        is_continuation = log.continuation_of is not None

        log_creator = log.creator

        direct_merges = get_direct_merges(revdir, revision, log)

 

        timestamp = email.Utils.mktime_tz(log_date + (0,))

        if log_summary is None:

            log_summary = ""

        # log_descriptions of None and "" are ignored.

        if not is_continuation and log_description:

            log_message = "\n".join((log_summary, log_description))

        else:

            log_message = log_summary

        target_tree = WorkingTree(revdir ,branch=branch)

        target_tree.lock_write()

            if missing_ancestor:

                # if we want it to be in revision-history, do that here.

                target_tree.add_pending_merge(revision_id(missing_ancestor))

                missing_ancestor = None

            for merged_rev in direct_merges:

                target_tree.add_pending_merge(revision_id(merged_rev))

            target_tree.set_inventory(baz_inv)

            commitobj = Commit(reporter=ImportCommitReporter(pb))

            commitobj.commit(branch, log_message.decode('ascii', 'replace'), 

                             verbose=False, committer=log_creator,

                             timestamp=timestamp, timezone=0, rev_id=rev_id)

            target_tree.unlock()

def get_direct_merges(revdir, revision, log):

    continuation = log.continuation_of

    previous_version = revision.version

    if pybaz.WorkingTree(revdir).tree_version != previous_version:

        pybaz.WorkingTree(revdir).set_tree_version(previous_version)

    log_path = "%s/{arch}/%s/%s/%s/%s/patch-log/%s" % (revdir, 

        revision.category.nonarch, revision.branch.nonarch, 

        revision.version.nonarch, revision.archive, revision.patchlevel)

    temp_path = tempfile.mktemp(dir=os.path.dirname(revdir))

    os.rename(log_path, temp_path)

    merges = list(iter_new_merges(revdir, revision.version))

    direct = direct_merges(merges, [continuation])

    os.rename(temp_path, log_path)

    return direct

 

    log = pybaz.Patchlog(revision, tree=tree)

def get_revision(revdir, revision):

    tree = revision.get(revdir)

        return tree, bzr_inventory_data(tree), log 

def apply_revision(tree, revision):

        return bzr_inventory_data(tree), log

 

def bzr_inventory_data(tree):

        bzr_file_id = map_file_id(arch_id)

        if kind not in ("file", "directory", "symlink"):

_global_option('max-count', type = int)

class cmd_baz_import_branch(Command):

    takes_args = ['to_location', 'from_branch?', 'reuse_history*']

    takes_options = ['verbose', 'max-count']

 

    def printer(self, name):

        print name

 

    def run(self, to_location, from_branch=None, fast=False, max_count=None,

            verbose=False, dry_run=False, reuse_history_list=[]):

        if reuse_history_list is None:

            reuse_history_list = []

        import_version(to_location, from_branch, self.printer, 

                       max_count=max_count, 

                       reuse_history_from=reuse_history_list)

 

 

class NotInABranch(Exception):

    def __init__(self, path):

        Exception.__init__(self, "%s is not in a branch." % path)

        self.path = path

 

 

class cmd_baz_import(Command):

    """Import an Arch or Baz archive into bzr branches.

    

    reuse_history allows you to specify any previous imports you 

    have done of different archives, which this archive has branches

    tagged from. This will dramatically reduce the time to convert 

    the archive as it will not have to convert the history already

    converted in that other branch.

    """

    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']

    takes_options = ['verbose']

 

    def printer(self, name):

        print name

 

    def run(self, to_root_dir, from_archive, verbose=False,

            reuse_history_list=[]):

        if reuse_history_list is None:

            reuse_history_list = []

        to_root = str(os.path.realpath(to_root_dir))

        if not os.path.exists(to_root):

            os.mkdir(to_root)

        import_archive(to_root, from_archive, verbose, self.printer, 

                       reuse_history_list)

 

 

def import_archive(to_root, from_archive, verbose, printer,

                   reuse_history_from=[]):

    real_to = os.path.realpath(to_root)

    history_locations = [real_to] + reuse_history_from

    for version in pybaz.Archive(str(from_archive)).iter_versions():

        target = os.path.join(to_root, map_namespace(version))

        printer("importing %s into %s" % (version, target))

        if not os.path.exists(os.path.dirname(target)):

            os.makedirs(os.path.dirname(target))

        try:

            import_version(target, version, printer,

                           reuse_history_from=reuse_history_from)

        except pybaz.errors.ExecProblem,e:

            if str(e).find('The requested revision cannot be built.') != -1:

                printer("Skipping version %s as it cannot be built due"

                        " to a missing parent archive." % version)

            else:

                raise

        except UserError, e:

            if str(e).find('already exists, and the last revision ') != -1:

                printer("Skipping version %s as it has had commits made"

                        " since it was converted to bzr." % version)

            else:

                raise

 

 

def map_namespace(a_version):

    a_version = pybaz.Version("%s" % a_version)

    parser = NameParser(a_version)

    version = parser.get_version()

    branch = parser.get_branch()

    category = parser.get_category()

    if branch is None or branch == '':

        branch = "+trunk"

    if version == '0':

        return "%s/%s" % (category, branch)

    return "%s/%s/%s" % (category, version, branch)

 

def map_file_id(file_id):

    """Convert a baz file id to a bzr one."""

    return file_id.replace('%', '%25').replace('/', '%2f')