[PATCH v1 1/2] Remove 'git archimport'

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



No updates since 2010, and no tests.

Plus, foreign SCM tools should live out-of-tree anyway.

Cc: Eric Wong <normalperson@xxxxxxxx>
Cc: Martin Langhoff <martin@xxxxxxxxxx>
Signed-off-by: Felipe Contreras <felipe.contreras@xxxxxxxxx>
---
 .gitignore                       |    1 -
 Documentation/git-archimport.txt |  112 ----
 Makefile                         |    1 -
 command-list.txt                 |    1 -
 git-archimport.perl              | 1134 --------------------------------------
 git.spec.in                      |   10 +-
 6 files changed, 3 insertions(+), 1256 deletions(-)
 delete mode 100644 Documentation/git-archimport.txt
 delete mode 100755 git-archimport.perl

diff --git a/.gitignore b/.gitignore
index db5f15e..5bce1df 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,7 +14,6 @@
 /git-am
 /git-annotate
 /git-apply
-/git-archimport
 /git-archive
 /git-bisect
 /git-bisect--helper
diff --git a/Documentation/git-archimport.txt b/Documentation/git-archimport.txt
deleted file mode 100644
index 163b9f6..0000000
--- a/Documentation/git-archimport.txt
+++ /dev/null
@@ -1,112 +0,0 @@
-git-archimport(1)
-=================
-
-NAME
-----
-git-archimport - Import an Arch repository into Git
-
-
-SYNOPSIS
---------
-[verse]
-'git archimport' [-h] [-v] [-o] [-a] [-f] [-T] [-D depth] [-t tempdir]
-               <archive/branch>[:<git-branch>] ...
-
-DESCRIPTION
------------
-Imports a project from one or more Arch repositories. It will follow branches
-and repositories within the namespaces defined by the <archive/branch>
-parameters supplied. If it cannot find the remote branch a merge comes from
-it will just import it as a regular commit. If it can find it, it will mark it
-as a merge whenever possible (see discussion below).
-
-The script expects you to provide the key roots where it can start the import
-from an 'initial import' or 'tag' type of Arch commit. It will follow and
-import new branches within the provided roots.
-
-It expects to be dealing with one project only. If it sees
-branches that have different roots, it will refuse to run. In that case,
-edit your <archive/branch> parameters to define clearly the scope of the
-import.
-
-'git archimport' uses `tla` extensively in the background to access the
-Arch repository.
-Make sure you have a recent version of `tla` available in the path. `tla` must
-know about the repositories you pass to 'git archimport'.
-
-For the initial import, 'git archimport' expects to find itself in an empty
-directory. To follow the development of a project that uses Arch, rerun
-'git archimport' with the same parameters as the initial import to perform
-incremental imports.
-
-While 'git archimport' will try to create sensible branch names for the
-archives that it imports, it is also possible to specify Git branch names
-manually.  To do so, write a Git branch name after each <archive/branch>
-parameter, separated by a colon.  This way, you can shorten the Arch
-branch names and convert Arch jargon to Git jargon, for example mapping a
-"PROJECT{litdd}devo{litdd}VERSION" branch to "master".
-
-Associating multiple Arch branches to one Git branch is possible; the
-result will make the most sense only if no commits are made to the first
-branch, after the second branch is created.  Still, this is useful to
-convert Arch repositories that had been rotated periodically.
-
-
-MERGES
-------
-Patch merge data from Arch is used to mark merges in Git as well. Git
-does not care much about tracking patches, and only considers a merge when a
-branch incorporates all the commits since the point they forked. The end result
-is that Git will have a good idea of how far branches have diverged. So the
-import process does lose some patch-trading metadata.
-
-Fortunately, when you try and merge branches imported from Arch,
-Git will find a good merge base, and it has a good chance of identifying
-patches that have been traded out-of-sequence between the branches.
-
-OPTIONS
--------
-
--h::
-	Display usage.
-
--v::
-	Verbose output.
-
--T::
-	Many tags. Will create a tag for every commit, reflecting the commit
-	name in the Arch repository.
-
--f::
-	Use the fast patchset import strategy.  This can be significantly
-	faster for large trees, but cannot handle directory renames or
-	permissions changes.  The default strategy is slow and safe.
-
--o::
-	Use this for compatibility with old-style branch names used by
-	earlier versions of 'git archimport'.  Old-style branch names
-	were category{litdd}branch, whereas new-style branch names are
-	archive,category{litdd}branch{litdd}version.  In both cases, names given
-	on the command-line will override the automatically-generated
-	ones.
-
--D <depth>::
-	Follow merge ancestry and attempt to import trees that have been
-	merged from.  Specify a depth greater than 1 if patch logs have been
-	pruned.
-
--a::
-	Attempt to auto-register archives at http://mirrors.sourcecontrol.net
-	This is particularly useful with the -D option.
-
--t <tmpdir>::
-	Override the default tempdir.
-
-
-<archive/branch>::
-	Archive/branch identifier in a format that `tla log` understands.
-
-
-GIT
----
-Part of the linkgit:git[1] suite
diff --git a/Makefile b/Makefile
index 52bdc95..eed6635 100644
--- a/Makefile
+++ b/Makefile
@@ -473,7 +473,6 @@ SCRIPT_LIB += git-sh-i18n
 
 SCRIPT_PERL += git-add--interactive.perl
 SCRIPT_PERL += git-difftool.perl
-SCRIPT_PERL += git-archimport.perl
 SCRIPT_PERL += git-cvsexportcommit.perl
 SCRIPT_PERL += git-cvsimport.perl
 SCRIPT_PERL += git-cvsserver.perl
diff --git a/command-list.txt b/command-list.txt
index cf36c3d..c9a9766f 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -4,7 +4,6 @@ git-add                                 mainporcelain common
 git-am                                  mainporcelain
 git-annotate                            ancillaryinterrogators
 git-apply                               plumbingmanipulators
-git-archimport                          foreignscminterface
 git-archive                             mainporcelain
 git-bisect                              mainporcelain common
 git-blame                               ancillaryinterrogators
diff --git a/git-archimport.perl b/git-archimport.perl
deleted file mode 100755
index 9cb123a..0000000
--- a/git-archimport.perl
+++ /dev/null
@@ -1,1134 +0,0 @@
-#!/usr/bin/perl
-#
-# This tool is copyright (c) 2005, Martin Langhoff.
-# It is released under the Gnu Public License, version 2.
-#
-# The basic idea is to walk the output of tla abrowse,
-# fetch the changesets and apply them.
-#
-
-=head1 Invocation
-
-    git archimport [ -h ] [ -v ] [ -o ] [ -a ] [ -f ] [ -T ]
-	[ -D depth] [ -t tempdir ] <archive>/<branch> [ <archive>/<branch> ]
-
-Imports a project from one or more Arch repositories. It will follow branches
-and repositories within the namespaces defined by the <archive/branch>
-parameters supplied. If it cannot find the remote branch a merge comes from
-it will just import it as a regular commit. If it can find it, it will mark it
-as a merge whenever possible.
-
-See man (1) git-archimport for more details.
-
-=head1 TODO
-
- - create tag objects instead of ref tags
- - audit shell-escaping of filenames
- - hide our private tags somewhere smarter
- - find a way to make "cat *patches | patch" safe even when patchfiles are missing newlines
- - sort and apply patches by graphing ancestry relations instead of just
-   relying in dates supplied in the changeset itself.
-   tla ancestry-graph -m could be helpful here...
-
-=head1 Devel tricks
-
-Add print in front of the shell commands invoked via backticks.
-
-=head1 Devel Notes
-
-There are several places where Arch and git terminology are intermixed
-and potentially confused.
-
-The notion of a "branch" in git is approximately equivalent to
-a "archive/category--branch--version" in Arch.  Also, it should be noted
-that the "--branch" portion of "archive/category--branch--version" is really
-optional in Arch although not many people (nor tools!) seem to know this.
-This means that "archive/category--version" is also a valid "branch"
-in git terms.
-
-We always refer to Arch names by their fully qualified variant (which
-means the "archive" name is prefixed.
-
-For people unfamiliar with Arch, an "archive" is the term for "repository",
-and can contain multiple, unrelated branches.
-
-=cut
-
-use 5.008;
-use strict;
-use warnings;
-use Getopt::Std;
-use File::Temp qw(tempdir);
-use File::Path qw(mkpath rmtree);
-use File::Basename qw(basename dirname);
-use Data::Dumper qw/ Dumper /;
-use IPC::Open2;
-
-$SIG{'PIPE'}="IGNORE";
-$ENV{'TZ'}="UTC";
-
-my $git_dir = $ENV{"GIT_DIR"} || ".git";
-$ENV{"GIT_DIR"} = $git_dir;
-my $ptag_dir = "$git_dir/archimport/tags";
-
-our($opt_h,$opt_f,$opt_v,$opt_T,$opt_t,$opt_D,$opt_a,$opt_o);
-
-sub usage() {
-    print STDERR <<END;
-usage: git archimport     # fetch/update GIT from Arch
-       [ -h ] [ -v ] [ -o ] [ -a ] [ -f ] [ -T ] [ -D depth ] [ -t tempdir ]
-       repository/arch-branch [ repository/arch-branch] ...
-END
-    exit(1);
-}
-
-getopts("fThvat:D:") or usage();
-usage if $opt_h;
-
-@ARGV >= 1 or usage();
-# $arch_branches:
-# values associated with keys:
-#   =1 - Arch version / git 'branch' detected via abrowse on a limit
-#   >1 - Arch version / git 'branch' of an auxiliary branch we've merged
-my %arch_branches = map { my $branch = $_; $branch =~ s/:[^:]*$//; $branch => 1 } @ARGV;
-
-# $branch_name_map:
-# maps arch branches to git branch names
-my %branch_name_map = map { m/^(.*):([^:]*)$/; $1 => $2 } grep { m/:/ } @ARGV;
-
-$ENV{'TMPDIR'} = $opt_t if $opt_t; # $ENV{TMPDIR} will affect tempdir() calls:
-my $tmp = tempdir('git-archimport-XXXXXX', TMPDIR => 1, CLEANUP => 1);
-$opt_v && print "+ Using $tmp as temporary directory\n";
-
-unless (-d $git_dir) { # initial import needs empty directory
-    opendir DIR, '.' or die "Unable to open current directory: $!\n";
-    while (my $entry = readdir DIR) {
-        $entry =~ /^\.\.?$/ or
-            die "Initial import needs an empty current working directory.\n"
-    }
-    closedir DIR
-}
-
-my $default_archive;		# default Arch archive
-my %reachable = ();             # Arch repositories we can access
-my %unreachable = ();           # Arch repositories we can't access :<
-my @psets  = ();                # the collection
-my %psets  = ();                # the collection, by name
-my %stats  = (			# Track which strategy we used to import:
-	get_tag => 0, replay => 0, get_new => 0, get_delta => 0,
-        simple_changeset => 0, import_or_tag => 0
-);
-
-my %rptags = ();                # my reverse private tags
-                                # to map a SHA1 to a commitid
-my $TLA = $ENV{'ARCH_CLIENT'} || 'tla';
-
-sub do_abrowse {
-    my $stage = shift;
-    while (my ($limit, $level) = each %arch_branches) {
-        next unless $level == $stage;
-
-	open ABROWSE, "$TLA abrowse -fkD --merges $limit |"
-                                or die "Problems with tla abrowse: $!";
-
-        my %ps        = ();         # the current one
-        my $lastseen  = '';
-
-        while (<ABROWSE>) {
-            chomp;
-
-            # first record padded w 8 spaces
-            if (s/^\s{8}\b//) {
-                my ($id, $type) = split(m/\s+/, $_, 2);
-
-                my %last_ps;
-                # store the record we just captured
-                if (%ps && !exists $psets{ $ps{id} }) {
-                    %last_ps = %ps; # break references
-                    push (@psets, \%last_ps);
-                    $psets{ $last_ps{id} } = \%last_ps;
-                }
-
-                my $branch = extract_versionname($id);
-                %ps = ( id => $id, branch => $branch );
-                if (%last_ps && ($last_ps{branch} eq $branch)) {
-                    $ps{parent_id} = $last_ps{id};
-                }
-
-                $arch_branches{$branch} = 1;
-                $lastseen = 'id';
-
-                # deal with types (should work with baz or tla):
-                if ($type =~ m/\(.*changeset\)/) {
-                    $ps{type} = 's';
-                } elsif ($type =~ /\(.*import\)/) {
-                    $ps{type} = 'i';
-                } elsif ($type =~ m/\(tag.*?(\S+\@\S+).*?\)/) {
-                    $ps{type} = 't';
-                    # read which revision we've tagged when we parse the log
-                    $ps{tag}  = $1;
-                } else {
-                    warn "Unknown type $type";
-                }
-
-                $arch_branches{$branch} = 1;
-                $lastseen = 'id';
-            } elsif (s/^\s{10}//) {
-                # 10 leading spaces or more
-                # indicate commit metadata
-
-                # date
-                if ($lastseen eq 'id' && m/^(\d{4}-\d\d-\d\d \d\d:\d\d:\d\d)/){
-                    $ps{date}   = $1;
-                    $lastseen = 'date';
-                } elsif ($_ eq 'merges in:') {
-                    $ps{merges} = [];
-                    $lastseen = 'merges';
-                } elsif ($lastseen eq 'merges' && s/^\s{2}//) {
-                    my $id = $_;
-                    push (@{$ps{merges}}, $id);
-
-                    # aggressive branch finding:
-                    if ($opt_D) {
-                        my $branch = extract_versionname($id);
-                        my $repo = extract_reponame($branch);
-
-                        if (archive_reachable($repo) &&
-                                !defined $arch_branches{$branch}) {
-                            $arch_branches{$branch} = $stage + 1;
-                        }
-                    }
-                } else {
-                    warn "more metadata after merges!?: $_\n" unless /^\s*$/;
-                }
-            }
-        }
-
-        if (%ps && !exists $psets{ $ps{id} }) {
-            my %temp = %ps;         # break references
-            if (@psets && $psets[$#psets]{branch} eq $ps{branch}) {
-                $temp{parent_id} = $psets[$#psets]{id};
-            }
-            push (@psets, \%temp);
-            $psets{ $temp{id} } = \%temp;
-        }
-
-        close ABROWSE or die "$TLA abrowse failed on $limit\n";
-    }
-}                               # end foreach $root
-
-do_abrowse(1);
-my $depth = 2;
-$opt_D ||= 0;
-while ($depth <= $opt_D) {
-    do_abrowse($depth);
-    $depth++;
-}
-
-## Order patches by time
-# FIXME see if we can find a more optimal way to do this by graphing
-# the ancestry data and walking it, that way we won't have to rely on
-# client-supplied dates
-@psets = sort {$a->{date}.$b->{id} cmp $b->{date}.$b->{id}} @psets;
-
-#print Dumper \@psets;
-
-##
-## TODO cleanup irrelevant patches
-##      and put an initial import
-##      or a full tag
-my $import = 0;
-unless (-d $git_dir) { # initial import
-    if ($psets[0]{type} eq 'i' || $psets[0]{type} eq 't') {
-        print "Starting import from $psets[0]{id}\n";
-	`git-init`;
-	die $! if $?;
-	$import = 1;
-    } else {
-        die "Need to start from an import or a tag -- cannot use $psets[0]{id}";
-    }
-} else {    # progressing an import
-    # load the rptags
-    opendir(DIR, $ptag_dir)
-	|| die "can't opendir: $!";
-    while (my $file = readdir(DIR)) {
-        # skip non-interesting-files
-        next unless -f "$ptag_dir/$file";
-
-        # convert first '--' to '/' from old git-archimport to use
-        # as an archivename/c--b--v private tag
-        if ($file !~ m!,!) {
-            my $oldfile = $file;
-            $file =~ s!--!,!;
-            print STDERR "converting old tag $oldfile to $file\n";
-            rename("$ptag_dir/$oldfile", "$ptag_dir/$file") or die $!;
-        }
-	my $sha = ptag($file);
-	chomp $sha;
-	$rptags{$sha} = $file;
-    }
-    closedir DIR;
-}
-
-# process patchsets
-# extract the Arch repository name (Arch "archive" in Arch-speak)
-sub extract_reponame {
-    my $fq_cvbr = shift; # archivename/[[[[category]branch]version]revision]
-    return (split(/\//, $fq_cvbr))[0];
-}
-
-sub extract_versionname {
-    my $name = shift;
-    $name =~ s/--(?:patch|version(?:fix)?|base)-\d+$//;
-    return $name;
-}
-
-# convert a fully-qualified revision or version to a unique dirname:
-#   normalperson@xxxxxxxx-05/mpd--uclinux--1--patch-2
-# becomes: normalperson@xxxxxxxx-05,mpd--uclinux--1
-#
-# the git notion of a branch is closer to
-# archive/category--branch--version than archive/category--branch, so we
-# use this to convert to git branch names.
-# Also, keep archive names but replace '/' with ',' since it won't require
-# subdirectories, and is safer than swapping '--' which could confuse
-# reverse-mapping when dealing with bastard branches that
-# are just archive/category--version  (no --branch)
-sub tree_dirname {
-    my $revision = shift;
-    my $name = extract_versionname($revision);
-    $name =~ s#/#,#;
-    return $name;
-}
-
-# old versions of git-archimport just use the <category--branch> part:
-sub old_style_branchname {
-    my $id = shift;
-    my $ret = safe_pipe_capture($TLA,'parse-package-name','-p',$id);
-    chomp $ret;
-    return $ret;
-}
-
-*git_default_branchname = $opt_o ? *old_style_branchname : *tree_dirname;
-
-# retrieve default archive, since $branch_name_map keys might not include it
-sub get_default_archive {
-    if (!defined $default_archive) {
-        $default_archive = safe_pipe_capture($TLA,'my-default-archive');
-        chomp $default_archive;
-    }
-    return $default_archive;
-}
-
-sub git_branchname {
-    my $revision = shift;
-    my $name = extract_versionname($revision);
-
-    if (exists $branch_name_map{$name}) {
-	return $branch_name_map{$name};
-
-    } elsif ($name =~ m#^([^/]*)/(.*)$#
-	     && $1 eq get_default_archive()
-	     && exists $branch_name_map{$2}) {
-	# the names given in the command-line lacked the archive.
-	return $branch_name_map{$2};
-
-    } else {
-	return git_default_branchname($revision);
-    }
-}
-
-sub process_patchset_accurate {
-    my $ps = shift;
-
-    # switch to that branch if we're not already in that branch:
-    if (-e "$git_dir/refs/heads/$ps->{branch}") {
-       system('git-checkout','-f',$ps->{branch}) == 0 or die "$! $?\n";
-
-       # remove any old stuff that got leftover:
-       my $rm = safe_pipe_capture('git-ls-files','--others','-z');
-       rmtree(split(/\0/,$rm)) if $rm;
-    }
-
-    # Apply the import/changeset/merge into the working tree
-    my $dir = sync_to_ps($ps);
-    # read the new log entry:
-    my @commitlog = safe_pipe_capture($TLA,'cat-log','-d',$dir,$ps->{id});
-    die "Error in cat-log: $!" if $?;
-    chomp @commitlog;
-
-    # grab variables we want from the log, new fields get added to $ps:
-    # (author, date, email, summary, message body ...)
-    parselog($ps, \@commitlog);
-
-    if ($ps->{id} =~ /--base-0$/ && $ps->{id} ne $psets[0]{id}) {
-        # this should work when importing continuations
-        if ($ps->{tag} && (my $branchpoint = eval { ptag($ps->{tag}) })) {
-
-            # find where we are supposed to branch from
-	    if (! -e "$git_dir/refs/heads/$ps->{branch}") {
-		system('git-branch',$ps->{branch},$branchpoint) == 0 or die "$! $?\n";
-
-		# We trust Arch with the fact that this is just a tag,
-		# and it does not affect the state of the tree, so
-		# we just tag and move on.  If the user really wants us
-		# to consolidate more branches into one, don't tag because
-		# the tag name would be already taken.
-		tag($ps->{id}, $branchpoint);
-		ptag($ps->{id}, $branchpoint);
-		print " * Tagged $ps->{id} at $branchpoint\n";
-	    }
-	    system('git-checkout','-f',$ps->{branch}) == 0 or die "$! $?\n";
-
-            # remove any old stuff that got leftover:
-            my $rm = safe_pipe_capture('git-ls-files','--others','-z');
-            rmtree(split(/\0/,$rm)) if $rm;
-            return 0;
-        } else {
-            warn "Tagging from unknown id unsupported\n" if $ps->{tag};
-        }
-        # allow multiple bases/imports here since Arch supports cherry-picks
-        # from unrelated trees
-    }
-
-    # update the index with all the changes we got
-    system('git-diff-files --name-only -z | '.
-            'git-update-index --remove -z --stdin') == 0 or die "$! $?\n";
-    system('git-ls-files --others -z | '.
-            'git-update-index --add -z --stdin') == 0 or die "$! $?\n";
-    return 1;
-}
-
-# the native changeset processing strategy.  This is very fast, but
-# does not handle permissions or any renames involving directories
-sub process_patchset_fast {
-    my $ps = shift;
-    #
-    # create the branch if needed
-    #
-    if ($ps->{type} eq 'i' && !$import) {
-        die "Should not have more than one 'Initial import' per GIT import: $ps->{id}";
-    }
-
-    unless ($import) { # skip for import
-        if ( -e "$git_dir/refs/heads/$ps->{branch}") {
-            # we know about this branch
-            system('git-checkout',$ps->{branch});
-        } else {
-            # new branch! we need to verify a few things
-            die "Branch on a non-tag!" unless $ps->{type} eq 't';
-            my $branchpoint = ptag($ps->{tag});
-            die "Tagging from unknown id unsupported: $ps->{tag}"
-                unless $branchpoint;
-
-            # find where we are supposed to branch from
-	    if (! -e "$git_dir/refs/heads/$ps->{branch}") {
-		system('git-branch',$ps->{branch},$branchpoint) == 0 or die "$! $?\n";
-
-		# We trust Arch with the fact that this is just a tag,
-		# and it does not affect the state of the tree, so
-		# we just tag and move on.  If the user really wants us
-		# to consolidate more branches into one, don't tag because
-		# the tag name would be already taken.
-		tag($ps->{id}, $branchpoint);
-		ptag($ps->{id}, $branchpoint);
-		print " * Tagged $ps->{id} at $branchpoint\n";
-            }
-            system('git-checkout',$ps->{branch}) == 0 or die "$! $?\n";
-            return 0;
-        }
-        die $! if $?;
-    }
-
-    #
-    # Apply the import/changeset/merge into the working tree
-    #
-    if ($ps->{type} eq 'i' || $ps->{type} eq 't') {
-        apply_import($ps) or die $!;
-        $stats{import_or_tag}++;
-        $import=0;
-    } elsif ($ps->{type} eq 's') {
-        apply_cset($ps);
-        $stats{simple_changeset}++;
-    }
-
-    #
-    # prepare update git's index, based on what arch knows
-    # about the pset, resolve parents, etc
-    #
-
-    my @commitlog = safe_pipe_capture($TLA,'cat-archive-log',$ps->{id});
-    die "Error in cat-archive-log: $!" if $?;
-
-    parselog($ps,\@commitlog);
-
-    # imports don't give us good info
-    # on added files. Shame on them
-    if ($ps->{type} eq 'i' || $ps->{type} eq 't') {
-        system('git-ls-files --deleted -z | '.
-                'git-update-index --remove -z --stdin') == 0 or die "$! $?\n";
-        system('git-ls-files --others -z | '.
-                'git-update-index --add -z --stdin') == 0 or die "$! $?\n";
-    }
-
-    # TODO: handle removed_directories and renamed_directories:
-
-    if (my $del = $ps->{removed_files}) {
-        unlink @$del;
-        while (@$del) {
-            my @slice = splice(@$del, 0, 100);
-            system('git-update-index','--remove','--',@slice) == 0 or
-                            die "Error in git-update-index --remove: $! $?\n";
-        }
-    }
-
-    if (my $ren = $ps->{renamed_files}) {                # renamed
-        if (@$ren % 2) {
-            die "Odd number of entries in rename!?";
-        }
-
-        while (@$ren) {
-            my $from = shift @$ren;
-            my $to   = shift @$ren;
-
-            unless (-d dirname($to)) {
-                mkpath(dirname($to)); # will die on err
-            }
-            # print "moving $from $to";
-            rename($from, $to) or die "Error renaming '$from' '$to': $!\n";
-            system('git-update-index','--remove','--',$from) == 0 or
-                            die "Error in git-update-index --remove: $! $?\n";
-            system('git-update-index','--add','--',$to) == 0 or
-                            die "Error in git-update-index --add: $! $?\n";
-        }
-    }
-
-    if (my $add = $ps->{new_files}) {
-        while (@$add) {
-            my @slice = splice(@$add, 0, 100);
-            system('git-update-index','--add','--',@slice) == 0 or
-                            die "Error in git-update-index --add: $! $?\n";
-        }
-    }
-
-    if (my $mod = $ps->{modified_files}) {
-        while (@$mod) {
-            my @slice = splice(@$mod, 0, 100);
-            system('git-update-index','--',@slice) == 0 or
-                            die "Error in git-update-index: $! $?\n";
-        }
-    }
-    return 1; # we successfully applied the changeset
-}
-
-if ($opt_f) {
-    print "Will import patchsets using the fast strategy\n",
-            "Renamed directories and permission changes will be missed\n";
-    *process_patchset = *process_patchset_fast;
-} else {
-    print "Using the default (accurate) import strategy.\n",
-            "Things may be a bit slow\n";
-    *process_patchset = *process_patchset_accurate;
-}
-
-foreach my $ps (@psets) {
-    # process patchsets
-    $ps->{branch} = git_branchname($ps->{id});
-
-    #
-    # ensure we have a clean state
-    #
-    if (my $dirty = `git-diff-files`) {
-        die "Unclean tree when about to process $ps->{id} " .
-            " - did we fail to commit cleanly before?\n$dirty";
-    }
-    die $! if $?;
-
-    #
-    # skip commits already in repo
-    #
-    if (ptag($ps->{id})) {
-      $opt_v && print " * Skipping already imported: $ps->{id}\n";
-      next;
-    }
-
-    print " * Starting to work on $ps->{id}\n";
-
-    process_patchset($ps) or next;
-
-    # warn "errors when running git-update-index! $!";
-    my $tree = `git-write-tree`;
-    die "cannot write tree $!" if $?;
-    chomp $tree;
-
-    #
-    # Who's your daddy?
-    #
-    my @par;
-    if ( -e "$git_dir/refs/heads/$ps->{branch}") {
-        if (open HEAD, "<","$git_dir/refs/heads/$ps->{branch}") {
-            my $p = <HEAD>;
-            close HEAD;
-            chomp $p;
-            push @par, '-p', $p;
-        } else {
-            if ($ps->{type} eq 's') {
-                warn "Could not find the right head for the branch $ps->{branch}";
-            }
-        }
-    }
-
-    if ($ps->{merges}) {
-        push @par, find_parents($ps);
-    }
-
-    #
-    # Commit, tag and clean state
-    #
-    $ENV{TZ}                  = 'GMT';
-    $ENV{GIT_AUTHOR_NAME}     = $ps->{author};
-    $ENV{GIT_AUTHOR_EMAIL}    = $ps->{email};
-    $ENV{GIT_AUTHOR_DATE}     = $ps->{date};
-    $ENV{GIT_COMMITTER_NAME}  = $ps->{author};
-    $ENV{GIT_COMMITTER_EMAIL} = $ps->{email};
-    $ENV{GIT_COMMITTER_DATE}  = $ps->{date};
-
-    my $pid = open2(*READER, *WRITER,'git-commit-tree',$tree,@par)
-        or die $!;
-    print WRITER $ps->{summary},"\n\n";
-
-    # only print message if it's not empty, to avoid a spurious blank line;
-    # also append an extra newline, so there's a blank line before the
-    # following "git-archimport-id:" line.
-    print WRITER $ps->{message},"\n\n" if ($ps->{message} ne "");
-
-    # make it easy to backtrack and figure out which Arch revision this was:
-    print WRITER 'git-archimport-id: ',$ps->{id},"\n";
-
-    close WRITER;
-    my $commitid = <READER>;    # read
-    chomp $commitid;
-    close READER;
-    waitpid $pid,0;             # close;
-
-    if (length $commitid != 40) {
-        die "Something went wrong with the commit! $! $commitid";
-    }
-    #
-    # Update the branch
-    #
-    open  HEAD, ">","$git_dir/refs/heads/$ps->{branch}";
-    print HEAD $commitid;
-    close HEAD;
-    system('git-update-ref', 'HEAD', "$ps->{branch}");
-
-    # tag accordingly
-    ptag($ps->{id}, $commitid); # private tag
-    if ($opt_T || $ps->{type} eq 't' || $ps->{type} eq 'i') {
-        tag($ps->{id}, $commitid);
-    }
-    print " * Committed $ps->{id}\n";
-    print "   + tree   $tree\n";
-    print "   + commit $commitid\n";
-    $opt_v && print "   + commit date is  $ps->{date} \n";
-    $opt_v && print "   + parents:  ",join(' ',@par),"\n";
-}
-
-if ($opt_v) {
-    foreach (sort keys %stats) {
-        print" $_: $stats{$_}\n";
-    }
-}
-exit 0;
-
-# used by the accurate strategy:
-sub sync_to_ps {
-    my $ps = shift;
-    my $tree_dir = $tmp.'/'.tree_dirname($ps->{id});
-
-    $opt_v && print "sync_to_ps($ps->{id}) method: ";
-
-    if (-d $tree_dir) {
-        if ($ps->{type} eq 't') {
-	    $opt_v && print "get (tag)\n";
-            # looks like a tag-only or (worse,) a mixed tags/changeset branch,
-            # can't rely on replay to work correctly on these
-            rmtree($tree_dir);
-            safe_pipe_capture($TLA,'get','--no-pristine',$ps->{id},$tree_dir);
-            $stats{get_tag}++;
-        } else {
-                my $tree_id = arch_tree_id($tree_dir);
-                if ($ps->{parent_id} && ($ps->{parent_id} eq $tree_id)) {
-                    # the common case (hopefully)
-		    $opt_v && print "replay\n";
-                    safe_pipe_capture($TLA,'replay','-d',$tree_dir,$ps->{id});
-                    $stats{replay}++;
-                } else {
-                    # getting one tree is usually faster than getting two trees
-                    # and applying the delta ...
-                    rmtree($tree_dir);
-		    $opt_v && print "apply-delta\n";
-                    safe_pipe_capture($TLA,'get','--no-pristine',
-                                        $ps->{id},$tree_dir);
-                    $stats{get_delta}++;
-                }
-        }
-    } else {
-        # new branch work
-        $opt_v && print "get (new tree)\n";
-        safe_pipe_capture($TLA,'get','--no-pristine',$ps->{id},$tree_dir);
-        $stats{get_new}++;
-    }
-
-    # added -I flag to rsync since we're going to fast! AIEEEEE!!!!
-    system('rsync','-aI','--delete','--exclude',$git_dir,
-#               '--exclude','.arch-inventory',
-                '--exclude','.arch-ids','--exclude','{arch}',
-                '--exclude','+*','--exclude',',*',
-                "$tree_dir/",'./') == 0 or die "Cannot rsync $tree_dir: $! $?";
-    return $tree_dir;
-}
-
-sub apply_import {
-    my $ps = shift;
-    my $bname = git_branchname($ps->{id});
-
-    mkpath($tmp);
-
-    safe_pipe_capture($TLA,'get','-s','--no-pristine',$ps->{id},"$tmp/import");
-    die "Cannot get import: $!" if $?;
-    system('rsync','-aI','--delete', '--exclude',$git_dir,
-		'--exclude','.arch-ids','--exclude','{arch}',
-		"$tmp/import/", './');
-    die "Cannot rsync import:$!" if $?;
-
-    rmtree("$tmp/import");
-    die "Cannot remove tempdir: $!" if $?;
-
-
-    return 1;
-}
-
-sub apply_cset {
-    my $ps = shift;
-
-    mkpath($tmp);
-
-    # get the changeset
-    safe_pipe_capture($TLA,'get-changeset',$ps->{id},"$tmp/changeset");
-    die "Cannot get changeset: $!" if $?;
-
-    # apply patches
-    if (`find $tmp/changeset/patches -type f -name '*.patch'`) {
-        # this can be sped up considerably by doing
-        #    (find | xargs cat) | patch
-        # but that can get mucked up by patches
-        # with missing trailing newlines or the standard
-        # 'missing newline' flag in the patch - possibly
-        # produced with an old/buggy diff.
-        # slow and safe, we invoke patch once per patchfile
-        `find $tmp/changeset/patches -type f -name '*.patch' -print0 | grep -zv '{arch}' | xargs -iFILE -0 --no-run-if-empty patch -p1 --forward -iFILE`;
-        die "Problem applying patches! $!" if $?;
-    }
-
-    # apply changed binary files
-    if (my @modified = `find $tmp/changeset/patches -type f -name '*.modified'`) {
-        foreach my $mod (@modified) {
-            chomp $mod;
-            my $orig = $mod;
-            $orig =~ s/\.modified$//; # lazy
-            $orig =~ s!^\Q$tmp\E/changeset/patches/!!;
-            #print "rsync -p '$mod' '$orig'";
-            system('rsync','-p',$mod,"./$orig");
-            die "Problem applying binary changes! $!" if $?;
-        }
-    }
-
-    # bring in new files
-    system('rsync','-aI','--exclude',$git_dir,
-		'--exclude','.arch-ids',
-		'--exclude', '{arch}',
-		"$tmp/changeset/new-files-archive/",'./');
-
-    # deleted files are hinted from the commitlog processing
-
-    rmtree("$tmp/changeset");
-}
-
-
-# =for reference
-# notes: *-files/-directories keys cannot have spaces, they're always
-# pika-escaped.  Everything after the first newline
-# A log entry looks like:
-# Revision: moodle-org--moodle--1.3.3--patch-15
-# Archive: arch-eduforge@xxxxxxxxxxxxxxx--2004
-# Creator: Penny Leach <penny@xxxxxxxxxxxxxxx>
-# Date: Wed May 25 14:15:34 NZST 2005
-# Standard-date: 2005-05-25 02:15:34 GMT
-# New-files: lang/de/.arch-ids/block_glossary_random.php.id
-#     lang/de/.arch-ids/block_html.php.id
-# New-directories: lang/de/help/questionnaire
-#     lang/de/help/questionnaire/.arch-ids
-# Renamed-files: .arch-ids/db_sears.sql.id db/.arch-ids/db_sears.sql.id
-#    db_sears.sql db/db_sears.sql
-# Removed-files: lang/be/docs/.arch-ids/release.html.id
-#     lang/be/docs/.arch-ids/releaseold.html.id
-# Modified-files: admin/cron.php admin/delete.php
-#     admin/editor.html backup/lib.php backup/restore.php
-# New-patches: arch-eduforge@xxxxxxxxxxxxxxx--2004/moodle-org--moodle--1.3.3--patch-15
-# Summary: Updating to latest from MOODLE_14_STABLE (1.4.5+)
-#   summary can be multiline with a leading space just like the above fields
-# Keywords:
-#
-# Updating yadda tadda tadda madda
-sub parselog {
-    my ($ps, $log) = @_;
-    my $key = undef;
-
-    # headers we want that contain filenames:
-    my %want_headers = (
-        new_files => 1,
-        modified_files => 1,
-        renamed_files => 1,
-        renamed_directories => 1,
-        removed_files => 1,
-        removed_directories => 1,
-    );
-
-    chomp (@$log);
-    while ($_ = shift @$log) {
-        if (/^Continuation-of:\s*(.*)/) {
-            $ps->{tag} = $1;
-            $key = undef;
-        } elsif (/^Summary:\s*(.*)$/ ) {
-            # summary can be multiline as long as it has a leading space.
-	    # we squeeze it onto a single line, though.
-            $ps->{summary} = [ $1 ];
-            $key = 'summary';
-        } elsif (/^Creator: (.*)\s*<([^\>]+)>/) {
-            $ps->{author} = $1;
-            $ps->{email} = $2;
-            $key = undef;
-        # any *-files or *-directories can be read here:
-        } elsif (/^([A-Z][a-z\-]+):\s*(.*)$/) {
-            my $val = $2;
-            $key = lc $1;
-            $key =~ tr/-/_/; # too lazy to quote :P
-            if ($want_headers{$key}) {
-                push @{$ps->{$key}}, split(/\s+/, $val);
-            } else {
-                $key = undef;
-            }
-        } elsif (/^$/) {
-            last; # remainder of @$log that didn't get shifted off is message
-        } elsif ($key) {
-            if (/^\s+(.*)$/) {
-                if ($key eq 'summary') {
-                    push @{$ps->{$key}}, $1;
-                } else { # files/directories:
-                    push @{$ps->{$key}}, split(/\s+/, $1);
-                }
-            } else {
-                $key = undef;
-            }
-        }
-    }
-
-    # drop leading empty lines from the log message
-    while (@$log && $log->[0] eq '') {
-	shift @$log;
-    }
-    if (exists $ps->{summary} && @{$ps->{summary}}) {
-	$ps->{summary} = join(' ', @{$ps->{summary}});
-    }
-    elsif (@$log == 0) {
-	$ps->{summary} = 'empty commit message';
-    } else {
-	$ps->{summary} = $log->[0] . '...';
-    }
-    $ps->{message} = join("\n",@$log);
-
-    # skip Arch control files, unescape pika-escaped files
-    foreach my $k (keys %want_headers) {
-        next unless (defined $ps->{$k});
-        my @tmp = ();
-        foreach my $t (@{$ps->{$k}}) {
-           next unless length ($t);
-           next if $t =~ m!\{arch\}/!;
-           next if $t =~ m!\.arch-ids/!;
-           # should we skip this?
-           next if $t =~ m!\.arch-inventory$!;
-           # tla cat-archive-log will give us filenames with spaces as file\(sp)name - why?
-           # we can assume that any filename with \ indicates some pika escaping that we want to get rid of.
-           if ($t =~ /\\/ ){
-               $t = (safe_pipe_capture($TLA,'escape','--unescaped',$t))[0];
-           }
-           push @tmp, $t;
-        }
-        $ps->{$k} = \@tmp;
-    }
-}
-
-# write/read a tag
-sub tag {
-    my ($tag, $commit) = @_;
-
-    if ($opt_o) {
-        $tag =~ s|/|--|g;
-    } else {
-	my $patchname = $tag;
-	$patchname =~ s/.*--//;
-        $tag = git_branchname ($tag) . '--' . $patchname;
-    }
-
-    if ($commit) {
-        open(C,">","$git_dir/refs/tags/$tag")
-            or die "Cannot create tag $tag: $!\n";
-        print C "$commit\n"
-            or die "Cannot write tag $tag: $!\n";
-        close(C)
-            or die "Cannot write tag $tag: $!\n";
-        print " * Created tag '$tag' on '$commit'\n" if $opt_v;
-    } else {                    # read
-        open(C,"<","$git_dir/refs/tags/$tag")
-            or die "Cannot read tag $tag: $!\n";
-        $commit = <C>;
-        chomp $commit;
-        die "Error reading tag $tag: $!\n" unless length $commit == 40;
-        close(C)
-            or die "Cannot read tag $tag: $!\n";
-        return $commit;
-    }
-}
-
-# write/read a private tag
-# reads fail softly if the tag isn't there
-sub ptag {
-    my ($tag, $commit) = @_;
-
-    # don't use subdirs for tags yet, it could screw up other porcelains
-    $tag =~ s|/|,|g;
-
-    my $tag_file = "$ptag_dir/$tag";
-    my $tag_branch_dir = dirname($tag_file);
-    mkpath($tag_branch_dir) unless (-d $tag_branch_dir);
-
-    if ($commit) {              # write
-        open(C,">",$tag_file)
-            or die "Cannot create tag $tag: $!\n";
-        print C "$commit\n"
-            or die "Cannot write tag $tag: $!\n";
-        close(C)
-            or die "Cannot write tag $tag: $!\n";
-	$rptags{$commit} = $tag
-	    unless $tag =~ m/--base-0$/;
-    } else {                    # read
-        # if the tag isn't there, return 0
-        unless ( -s $tag_file) {
-            return 0;
-        }
-        open(C,"<",$tag_file)
-            or die "Cannot read tag $tag: $!\n";
-        $commit = <C>;
-        chomp $commit;
-        die "Error reading tag $tag: $!\n" unless length $commit == 40;
-        close(C)
-            or die "Cannot read tag $tag: $!\n";
-	unless (defined $rptags{$commit}) {
-	    $rptags{$commit} = $tag;
-	}
-        return $commit;
-    }
-}
-
-sub find_parents {
-    #
-    # Identify what branches are merging into me
-    # and whether we are fully merged
-    # git-merge-base <headsha> <headsha> should tell
-    # me what the base of the merge should be
-    #
-    my $ps = shift;
-
-    my %branches; # holds an arrayref per branch
-                  # the arrayref contains a list of
-                  # merged patches between the base
-                  # of the merge and the current head
-
-    my @parents;  # parents found for this commit
-
-    # simple loop to split the merges
-    # per branch
-    foreach my $merge (@{$ps->{merges}}) {
-	my $branch = git_branchname($merge);
-	unless (defined $branches{$branch} ){
-	    $branches{$branch} = [];
-	}
-	push @{$branches{$branch}}, $merge;
-    }
-
-    #
-    # foreach branch find a merge base and walk it to the
-    # head where we are, collecting the merged patchsets that
-    # Arch has recorded. Keep that in @have
-    # Compare that with the commits on the other branch
-    # between merge-base and the tip of the branch (@need)
-    # and see if we have a series of consecutive patches
-    # starting from the merge base. The tip of the series
-    # of consecutive patches merged is our new parent for
-    # that branch.
-    #
-    foreach my $branch (keys %branches) {
-
-	# check that we actually know about the branch
-	next unless -e "$git_dir/refs/heads/$branch";
-
-	my $mergebase = `git-merge-base $branch $ps->{branch}`;
-	if ($?) {
-	    # Don't die here, Arch supports one-way cherry-picking
-	    # between branches with no common base (or any relationship
-	    # at all beforehand)
-	    warn "Cannot find merge base for $branch and $ps->{branch}";
-	    next;
-	}
-	chomp $mergebase;
-
-	# now walk up to the mergepoint collecting what patches we have
-	my $branchtip = git_rev_parse($ps->{branch});
-	my @ancestors = `git-rev-list --topo-order $branchtip ^$mergebase`;
-	my %have; # collected merges this branch has
-	foreach my $merge (@{$ps->{merges}}) {
-	    $have{$merge} = 1;
-	}
-	my %ancestorshave;
-	foreach my $par (@ancestors) {
-	    $par = commitid2pset($par);
-	    if (defined $par->{merges}) {
-		foreach my $merge (@{$par->{merges}}) {
-		    $ancestorshave{$merge}=1;
-		}
-	    }
-	}
-	# print "++++ Merges in $ps->{id} are....\n";
-	# my @have = sort keys %have;	print Dumper(\@have);
-
-	# merge what we have with what ancestors have
-	%have = (%have, %ancestorshave);
-
-	# see what the remote branch has - these are the merges we
-	# will want to have in a consecutive series from the mergebase
-	my $otherbranchtip = git_rev_parse($branch);
-	my @needraw = `git-rev-list --topo-order $otherbranchtip ^$mergebase`;
-	my @need;
-	foreach my $needps (@needraw) { 	# get the psets
-	    $needps = commitid2pset($needps);
-	    # git-rev-list will also
-	    # list commits merged in via earlier
-	    # merges. we are only interested in commits
-	    # from the branch we're looking at
-	    if ($branch eq $needps->{branch}) {
-		push @need, $needps->{id};
-	    }
-	}
-
-	# print "++++ Merges from $branch we want are....\n";
-	# print Dumper(\@need);
-
-	my $newparent;
-	while (my $needed_commit = pop @need) {
-	    if ($have{$needed_commit}) {
-		$newparent = $needed_commit;
-	    } else {
-		last; # break out of the while
-	    }
-	}
-	if ($newparent) {
-	    push @parents, $newparent;
-	}
-
-
-    } # end foreach branch
-
-    # prune redundant parents
-    my %parents;
-    foreach my $p (@parents) {
-	$parents{$p} = 1;
-    }
-    foreach my $p (@parents) {
-	next unless exists $psets{$p}{merges};
-	next unless ref    $psets{$p}{merges};
-	my @merges = @{$psets{$p}{merges}};
-	foreach my $merge (@merges) {
-	    if ($parents{$merge}) {
-		delete $parents{$merge};
-	    }
-	}
-    }
-
-    @parents = ();
-    foreach (keys %parents) {
-        push @parents, '-p', ptag($_);
-    }
-    return @parents;
-}
-
-sub git_rev_parse {
-    my $name = shift;
-    my $val  = `git-rev-parse $name`;
-    die "Error: git-rev-parse $name" if $?;
-    chomp $val;
-    return $val;
-}
-
-# resolve a SHA1 to a known patchset
-sub commitid2pset {
-    my $commitid = shift;
-    chomp $commitid;
-    my $name = $rptags{$commitid}
-	|| die "Cannot find reverse tag mapping for $commitid";
-    $name =~ s|,|/|;
-    my $ps   = $psets{$name}
-	|| (print Dumper(sort keys %psets)) && die "Cannot find patchset for $name";
-    return $ps;
-}
-
-
-# an alternative to `command` that allows input to be passed as an array
-# to work around shell problems with weird characters in arguments
-sub safe_pipe_capture {
-    my @output;
-    if (my $pid = open my $child, '-|') {
-        @output = (<$child>);
-        close $child or die join(' ',@_).": $! $?";
-    } else {
-	exec(@_) or die "$! $?"; # exec() can fail the executable can't be found
-    }
-    return wantarray ? @output : join('',@output);
-}
-
-# `tla logs -rf -d <dir> | head -n1` or `baz tree-id <dir>`
-sub arch_tree_id {
-    my $dir = shift;
-    chomp( my $ret = (safe_pipe_capture($TLA,'logs','-rf','-d',$dir))[0] );
-    return $ret;
-}
-
-sub archive_reachable {
-    my $archive = shift;
-    return 1 if $reachable{$archive};
-    return 0 if $unreachable{$archive};
-
-    if (system "$TLA whereis-archive $archive >/dev/null") {
-        if ($opt_a && (system($TLA,'register-archive',
-                      "http://mirrors.sourcecontrol.net/$archive";) == 0)) {
-            $reachable{$archive} = 1;
-            return 1;
-        }
-        print STDERR "Archive is unreachable: $archive\n";
-        $unreachable{$archive} = 1;
-        return 0;
-    } else {
-        $reachable{$archive} = 1;
-        return 1;
-    }
-}
diff --git a/git.spec.in b/git.spec.in
index d61d537..ec74d61 100644
--- a/git.spec.in
+++ b/git.spec.in
@@ -166,13 +166,6 @@ rm -rf $RPM_BUILD_ROOT
 %{!?_without_docs: %{_mandir}/man1/*cvs*.1*}
 %{!?_without_docs: %doc Documentation/*git-cvs*.html }
 
-%files arch
-%defattr(-,root,root)
-%doc Documentation/git-archimport.txt
-%{_libexecdir}/git-core/git-archimport
-%{!?_without_docs: %{_mandir}/man1/git-archimport.1*}
-%{!?_without_docs: %doc Documentation/git-archimport.html }
-
 %files email
 %defattr(-,root,root)
 %doc Documentation/*email*.txt
@@ -214,6 +207,9 @@ rm -rf $RPM_BUILD_ROOT
 # No files for you!
 
 %changelog
+* Thu May 08 2014 Felipe Contreras <felipe.contreras@xxxxxxxxx>
+- Remove 'git archimport'.
+
 * Sun Sep 18 2011 Jakub Narebski <jnareb@xxxxxxxxx>
 - Add gitweb manpages to 'gitweb' subpackage
 
-- 
1.9.2+fc1.27.gbce2056

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Linux Kernel Development]     [Gcc Help]     [IETF Annouce]     [DCCP]     [Netdev]     [Networking]     [Security]     [V4L]     [Bugtraq]     [Yosemite]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux RAID]     [Linux SCSI]     [Fedora Users]