2005-06-28 14:48:40 +00:00
|
|
|
#!/usr/bin/perl -w
|
2005-06-10 06:38:32 +00:00
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
# This tool is copyright (c) 2005, Matthias Urlichs.
|
|
|
|
# It is released under the Gnu Public License, version 2.
|
|
|
|
#
|
|
|
|
# The basic idea is to aggregate CVS check-ins into related changes.
|
|
|
|
# Fortunately, "cvsps" does that for us; all we have to do is to parse
|
|
|
|
# its output.
|
|
|
|
#
|
|
|
|
# Checking out the files is done by a single long-running CVS connection
|
|
|
|
# / server process.
|
|
|
|
#
|
|
|
|
# The head revision is on branch "origin" by default.
|
|
|
|
# You can change that with the '-o' option.
|
|
|
|
|
|
|
|
use strict;
|
|
|
|
use warnings;
|
2008-02-28 10:18:22 +00:00
|
|
|
use Getopt::Long;
|
2005-07-04 11:36:59 +00:00
|
|
|
use File::Spec;
|
2006-06-24 11:13:08 +00:00
|
|
|
use File::Temp qw(tempfile tmpnam);
|
2005-06-28 14:48:40 +00:00
|
|
|
use File::Path qw(mkpath);
|
|
|
|
use File::Basename qw(basename dirname);
|
|
|
|
use Time::Local;
|
2005-06-28 17:49:19 +00:00
|
|
|
use IO::Socket;
|
|
|
|
use IO::Pipe;
|
2006-05-24 13:58:28 +00:00
|
|
|
use POSIX qw(strftime dup2 ENOENT);
|
2005-09-06 17:36:01 +00:00
|
|
|
use IPC::Open2;
|
2005-06-28 14:48:40 +00:00
|
|
|
|
|
|
|
$SIG{'PIPE'}="IGNORE";
|
|
|
|
$ENV{'TZ'}="UTC";
|
|
|
|
|
2008-02-28 10:18:22 +00:00
|
|
|
our ($opt_h,$opt_o,$opt_v,$opt_k,$opt_u,$opt_d,$opt_p,$opt_C,$opt_z,$opt_i,$opt_P, $opt_s,$opt_m,@opt_M,$opt_A,$opt_S,$opt_L, $opt_a, $opt_r);
|
2006-01-12 23:38:59 +00:00
|
|
|
my (%conv_author_name, %conv_author_email);
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2007-04-06 21:52:41 +00:00
|
|
|
sub usage(;$) {
|
|
|
|
my $msg = shift;
|
|
|
|
print(STDERR "Error: $msg\n") if $msg;
|
2005-06-28 14:48:40 +00:00
|
|
|
print STDERR <<END;
|
2008-07-13 13:36:15 +00:00
|
|
|
Usage: git cvsimport # fetch/update GIT from CVS
|
2006-01-12 23:38:59 +00:00
|
|
|
[-o branch-for-HEAD] [-h] [-v] [-d CVSROOT] [-A author-conv-file]
|
2007-04-06 21:52:39 +00:00
|
|
|
[-p opts-for-cvsps] [-P file] [-C GIT_repository] [-z fuzz] [-i] [-k]
|
|
|
|
[-u] [-s subst] [-a] [-m] [-M regex] [-S regex] [-L commitlimit]
|
2007-06-04 09:01:34 +00:00
|
|
|
[-r remote] [CVS_module]
|
2005-06-28 14:48:40 +00:00
|
|
|
END
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2006-01-12 23:38:59 +00:00
|
|
|
sub read_author_info($) {
|
|
|
|
my ($file) = @_;
|
|
|
|
my $user;
|
|
|
|
open my $f, '<', "$file" or die("Failed to open $file: $!\n");
|
|
|
|
|
|
|
|
while (<$f>) {
|
2006-01-15 11:30:30 +00:00
|
|
|
# Expected format is this:
|
2006-01-12 23:38:59 +00:00
|
|
|
# exon=Andreas Ericsson <ae@op5.se>
|
2006-01-15 11:30:30 +00:00
|
|
|
if (m/^(\S+?)\s*=\s*(.+?)\s*<(.+)>\s*$/) {
|
2006-01-12 23:38:59 +00:00
|
|
|
$user = $1;
|
2006-01-15 11:30:30 +00:00
|
|
|
$conv_author_name{$user} = $2;
|
|
|
|
$conv_author_email{$user} = $3;
|
2006-01-12 23:38:59 +00:00
|
|
|
}
|
2006-01-15 11:30:30 +00:00
|
|
|
# However, we also read from CVSROOT/users format
|
|
|
|
# to ease migration.
|
|
|
|
elsif (/^(\w+):(['"]?)(.+?)\2\s*$/) {
|
|
|
|
my $mapped;
|
|
|
|
($user, $mapped) = ($1, $3);
|
|
|
|
if ($mapped =~ /^\s*(.*?)\s*<(.*)>\s*$/) {
|
|
|
|
$conv_author_name{$user} = $1;
|
|
|
|
$conv_author_email{$user} = $2;
|
|
|
|
}
|
|
|
|
elsif ($mapped =~ /^<?(.*)>?$/) {
|
|
|
|
$conv_author_name{$user} = $user;
|
|
|
|
$conv_author_email{$user} = $1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
# NEEDSWORK: Maybe warn on unrecognized lines?
|
2006-01-12 23:38:59 +00:00
|
|
|
}
|
|
|
|
close ($f);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub write_author_info($) {
|
|
|
|
my ($file) = @_;
|
|
|
|
open my $f, '>', $file or
|
|
|
|
die("Failed to open $file for writing: $!");
|
|
|
|
|
|
|
|
foreach (keys %conv_author_name) {
|
2006-01-15 11:30:30 +00:00
|
|
|
print $f "$_=$conv_author_name{$_} <$conv_author_email{$_}>\n";
|
2006-01-12 23:38:59 +00:00
|
|
|
}
|
|
|
|
close ($f);
|
|
|
|
}
|
|
|
|
|
2008-01-14 04:51:10 +00:00
|
|
|
# convert getopts specs for use by git config
|
2007-02-07 22:57:43 +00:00
|
|
|
sub read_repo_config {
|
|
|
|
# Split the string between characters, unless there is a ':'
|
|
|
|
# So "abc:de" becomes ["a", "b", "c:", "d", "e"]
|
|
|
|
my @opts = split(/ *(?!:)/, shift);
|
|
|
|
foreach my $o (@opts) {
|
|
|
|
my $key = $o;
|
|
|
|
$key =~ s/://g;
|
2008-01-14 04:51:10 +00:00
|
|
|
my $arg = 'git config';
|
2007-02-07 22:57:43 +00:00
|
|
|
$arg .= ' --bool' if ($o !~ /:$/);
|
|
|
|
|
|
|
|
chomp(my $tmp = `$arg --get cvsimport.$key`);
|
|
|
|
if ($tmp && !($arg =~ /--bool/ && $tmp eq 'false')) {
|
|
|
|
no strict 'refs';
|
|
|
|
my $opt_name = "opt_" . $key;
|
|
|
|
if (!$$opt_name) {
|
|
|
|
$$opt_name = $tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-30 00:56:41 +00:00
|
|
|
my $opts = "haivmkuo:d:p:r:C:z:s:M:P:A:S:L:";
|
2007-02-07 22:57:43 +00:00
|
|
|
read_repo_config($opts);
|
2008-02-28 10:18:22 +00:00
|
|
|
Getopt::Long::Configure( 'no_ignore_case', 'bundling' );
|
|
|
|
|
|
|
|
# turn the Getopt::Std specification in a Getopt::Long one,
|
|
|
|
# with support for multiple -M options
|
|
|
|
GetOptions( map { s/:/=s/; /M/ ? "$_\@" : $_ } split( /(?!:)/, $opts ) )
|
|
|
|
or usage();
|
2005-06-28 14:48:40 +00:00
|
|
|
usage if $opt_h;
|
|
|
|
|
2007-11-30 22:22:12 +00:00
|
|
|
if (@ARGV == 0) {
|
2008-01-14 04:51:10 +00:00
|
|
|
chomp(my $module = `git config --get cvsimport.module`);
|
2007-11-30 22:22:12 +00:00
|
|
|
push(@ARGV, $module) if $? == 0;
|
|
|
|
}
|
2007-04-06 21:52:41 +00:00
|
|
|
@ARGV <= 1 or usage("You can't specify more than one CVS module");
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($opt_d) {
|
2005-06-28 17:49:19 +00:00
|
|
|
$ENV{"CVSROOT"} = $opt_d;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif (-f 'CVS/Root') {
|
2005-07-03 09:34:59 +00:00
|
|
|
open my $f, '<', 'CVS/Root' or die 'Failed to open CVS/Root';
|
|
|
|
$opt_d = <$f>;
|
|
|
|
chomp $opt_d;
|
|
|
|
close $f;
|
|
|
|
$ENV{"CVSROOT"} = $opt_d;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($ENV{"CVSROOT"}) {
|
2005-06-28 17:49:19 +00:00
|
|
|
$opt_d = $ENV{"CVSROOT"};
|
|
|
|
} else {
|
2007-04-06 21:52:41 +00:00
|
|
|
usage("CVSROOT needs to be set");
|
2005-06-28 17:49:19 +00:00
|
|
|
}
|
2005-08-17 09:19:20 +00:00
|
|
|
$opt_s ||= "-";
|
2007-01-08 06:43:39 +00:00
|
|
|
$opt_a ||= 0;
|
|
|
|
|
2005-07-03 09:34:59 +00:00
|
|
|
my $git_tree = $opt_C;
|
2005-06-28 17:49:19 +00:00
|
|
|
$git_tree ||= ".";
|
|
|
|
|
2007-05-30 00:56:41 +00:00
|
|
|
my $remote;
|
|
|
|
if (defined $opt_r) {
|
|
|
|
$remote = 'refs/remotes/' . $opt_r;
|
|
|
|
$opt_o ||= "master";
|
|
|
|
} else {
|
|
|
|
$opt_o ||= "origin";
|
|
|
|
$remote = 'refs/heads';
|
|
|
|
}
|
|
|
|
|
2005-07-03 09:34:59 +00:00
|
|
|
my $cvs_tree;
|
|
|
|
if ($#ARGV == 0) {
|
|
|
|
$cvs_tree = $ARGV[0];
|
|
|
|
} elsif (-f 'CVS/Repository') {
|
2007-06-07 07:04:01 +00:00
|
|
|
open my $f, '<', 'CVS/Repository' or
|
2005-07-03 09:34:59 +00:00
|
|
|
die 'Failed to open CVS/Repository';
|
|
|
|
$cvs_tree = <$f>;
|
|
|
|
chomp $cvs_tree;
|
2005-08-16 10:35:27 +00:00
|
|
|
close $f;
|
2005-07-03 09:34:59 +00:00
|
|
|
} else {
|
2007-04-06 21:52:41 +00:00
|
|
|
usage("CVS module has to be specified");
|
2005-07-03 09:34:59 +00:00
|
|
|
}
|
|
|
|
|
2005-08-16 10:35:27 +00:00
|
|
|
our @mergerx = ();
|
|
|
|
if ($opt_m) {
|
2008-02-28 10:18:21 +00:00
|
|
|
@mergerx = ( qr/\b(?:from|of|merge|merging|merged) ([-\w]+)/i );
|
2005-08-16 10:35:27 +00:00
|
|
|
}
|
2008-02-28 10:18:22 +00:00
|
|
|
if (@opt_M) {
|
|
|
|
push (@mergerx, map { qr/$_/ } @opt_M);
|
2005-08-16 10:35:27 +00:00
|
|
|
}
|
|
|
|
|
2007-01-08 01:11:23 +00:00
|
|
|
# Remember UTC of our starting time
|
|
|
|
# we'll want to avoid importing commits
|
|
|
|
# that are too recent
|
|
|
|
our $starttime = time();
|
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
select(STDERR); $|=1; select(STDOUT);
|
|
|
|
|
|
|
|
|
|
|
|
package CVSconn;
|
|
|
|
# Basic CVS dialog.
|
2005-06-28 17:49:19 +00:00
|
|
|
# We're only interested in connecting and downloading, so ...
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2005-07-03 22:43:26 +00:00
|
|
|
use File::Spec;
|
|
|
|
use File::Temp qw(tempfile);
|
2005-06-28 17:58:40 +00:00
|
|
|
use POSIX qw(strftime dup2);
|
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
sub new {
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($what,$repo,$subdir) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
$what=ref($what) if ref($what);
|
|
|
|
|
|
|
|
my $self = {};
|
|
|
|
$self->{'buffer'} = "";
|
|
|
|
bless($self,$what);
|
|
|
|
|
|
|
|
$repo =~ s#/+$##;
|
|
|
|
$self->{'fullrep'} = $repo;
|
|
|
|
$self->conn();
|
|
|
|
|
|
|
|
$self->{'subdir'} = $subdir;
|
|
|
|
$self->{'lines'} = undef;
|
|
|
|
|
|
|
|
return $self;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub conn {
|
|
|
|
my $self = shift;
|
|
|
|
my $repo = $self->{'fullrep'};
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($repo =~ s/^:pserver(?:([^:]*)):(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?//) {
|
|
|
|
my ($param,$user,$pass,$serv,$port) = ($1,$2,$3,$4,$5);
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($proxyhost,$proxyport);
|
|
|
|
if ($param && ($param =~ m/proxy=([^;]+)/)) {
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
$proxyhost = $1;
|
|
|
|
# Default proxyport, if not specified, is 8080.
|
|
|
|
$proxyport = 8080;
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($ENV{"CVS_PROXY_PORT"}) {
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
$proxyport = $ENV{"CVS_PROXY_PORT"};
|
|
|
|
}
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($param =~ m/proxyport=([^;]+)/) {
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
$proxyport = $1;
|
|
|
|
}
|
|
|
|
}
|
2008-06-10 12:32:06 +00:00
|
|
|
$repo ||= '/';
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
|
2007-11-08 20:15:20 +00:00
|
|
|
# if username is not explicit in CVSROOT, then use current user, as cvs would
|
|
|
|
$user=(getlogin() || $ENV{'LOGNAME'} || $ENV{'USER'} || "anonymous") unless $user;
|
2005-06-28 17:49:19 +00:00
|
|
|
my $rr2 = "-";
|
2006-11-27 22:21:30 +00:00
|
|
|
unless ($port) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$rr2 = ":pserver:$user\@$serv:$repo";
|
|
|
|
$port=2401;
|
|
|
|
}
|
|
|
|
my $rr = ":pserver:$user\@$serv:$port$repo";
|
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
unless ($pass) {
|
2005-06-28 14:48:40 +00:00
|
|
|
open(H,$ENV{'HOME'}."/.cvspass") and do {
|
|
|
|
# :pserver:cvs@mea.tmt.tele.fi:/cvsroot/zmailer Ah<Z
|
2006-11-27 22:21:30 +00:00
|
|
|
while (<H>) {
|
2005-06-28 14:48:40 +00:00
|
|
|
chomp;
|
|
|
|
s/^\/\d+\s+//;
|
|
|
|
my ($w,$p) = split(/\s/,$_,2);
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($w eq $rr or $w eq $rr2) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$pass = $p;
|
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
$pass="A" unless $pass;
|
|
|
|
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
my ($s, $rep);
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($proxyhost) {
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
|
|
|
|
# Use a HTTP Proxy. Only works for HTTP proxies that
|
|
|
|
# don't require user authentication
|
|
|
|
#
|
|
|
|
# See: http://www.ietf.org/rfc/rfc2817.txt
|
|
|
|
|
|
|
|
$s = IO::Socket::INET->new(PeerHost => $proxyhost, PeerPort => $proxyport);
|
|
|
|
die "Socket to $proxyhost: $!\n" unless defined $s;
|
|
|
|
$s->write("CONNECT $serv:$port HTTP/1.1\r\nHost: $serv:$port\r\n\r\n")
|
|
|
|
or die "Write to $proxyhost: $!\n";
|
|
|
|
$s->flush();
|
|
|
|
|
|
|
|
$rep = <$s>;
|
|
|
|
|
|
|
|
# The answer should look like 'HTTP/1.x 2yy ....'
|
2006-11-27 22:21:30 +00:00
|
|
|
if (!($rep =~ m#^HTTP/1\.. 2[0-9][0-9]#)) {
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
die "Proxy connect: $rep\n";
|
|
|
|
}
|
|
|
|
# Skip up to the empty line of the proxy server output
|
|
|
|
# including the response headers.
|
|
|
|
while ($rep = <$s>) {
|
|
|
|
last if (!defined $rep ||
|
|
|
|
$rep eq "\n" ||
|
|
|
|
$rep eq "\r\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$s = IO::Socket::INET->new(PeerHost => $serv, PeerPort => $port);
|
|
|
|
die "Socket to $serv: $!\n" unless defined $s;
|
|
|
|
}
|
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
$s->write("BEGIN AUTH REQUEST\n$repo\n$user\n$pass\nEND AUTH REQUEST\n")
|
|
|
|
or die "Write to $serv: $!\n";
|
|
|
|
$s->flush();
|
|
|
|
|
git-cvsimport: add support for CVS pserver method HTTP/1.x proxying
This patch adds support for 'proxy' and 'proxyport' connection options
when using the pserver method for the CVS Root.
It has been tested with a Squid 2.5.x proxy server.
Quoting from the CVS info manual:
The `gserver' and `pserver' connection methods all accept optional
method options, specified as part of the METHOD string, like so:
:METHOD[;OPTION=ARG...]:
Currently, the only two valid connection options are `proxy', which
takes a hostname as an argument, and `proxyport', which takes a port
number as an argument. These options can be used to connect via an HTTP
tunnel style web proxy. For example, to connect pserver via a web proxy
at www.myproxy.net and port 8000, you would use a method of:
:pserver;proxy=www.myproxy.net;proxyport=8000:
*NOTE: The rest of the connection string is required to connect to
the server as noted in the upcoming sections on password authentication,
gserver and kserver. The example above would only modify the METHOD
portion of the repository name.*
PROXY must be supplied to connect to a CVS server via a proxy
server, but PROXYPORT will default to port 8080 if not supplied.
PROXYPORT may also be set via the CVS_PROXY_PORT environment variable.
Signed-off-by: Iñaki Arenaza <iarenuno@eteo.mondragon.edu>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-22 22:26:57 +00:00
|
|
|
$rep = <$s>;
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($rep ne "I LOVE YOU\n") {
|
2005-06-28 14:48:40 +00:00
|
|
|
$rep="<unknown>" unless $rep;
|
|
|
|
die "AuthReply: $rep\n";
|
|
|
|
}
|
|
|
|
$self->{'socketo'} = $s;
|
|
|
|
$self->{'socketi'} = $s;
|
2005-07-03 11:02:06 +00:00
|
|
|
} else { # local or ext: Fork off our own cvs server.
|
2005-06-28 14:48:40 +00:00
|
|
|
my $pr = IO::Pipe->new();
|
|
|
|
my $pw = IO::Pipe->new();
|
|
|
|
my $pid = fork();
|
|
|
|
die "Fork: $!\n" unless defined $pid;
|
2005-07-03 10:26:51 +00:00
|
|
|
my $cvs = 'cvs';
|
|
|
|
$cvs = $ENV{CVS_SERVER} if exists $ENV{CVS_SERVER};
|
2005-07-03 11:02:06 +00:00
|
|
|
my $rsh = 'rsh';
|
|
|
|
$rsh = $ENV{CVS_RSH} if exists $ENV{CVS_RSH};
|
|
|
|
|
|
|
|
my @cvs = ($cvs, 'server');
|
|
|
|
my ($local, $user, $host);
|
|
|
|
$local = $repo =~ s/:local://;
|
|
|
|
if (!$local) {
|
|
|
|
$repo =~ s/:ext://;
|
|
|
|
$local = !($repo =~ s/^(?:([^\@:]+)\@)?([^:]+)://);
|
|
|
|
($user, $host) = ($1, $2);
|
|
|
|
}
|
|
|
|
if (!$local) {
|
|
|
|
if ($user) {
|
|
|
|
unshift @cvs, $rsh, '-l', $user, $host;
|
|
|
|
} else {
|
|
|
|
unshift @cvs, $rsh, $host;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
unless ($pid) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$pr->writer();
|
|
|
|
$pw->reader();
|
|
|
|
dup2($pw->fileno(),0);
|
|
|
|
dup2($pr->fileno(),1);
|
|
|
|
$pr->close();
|
|
|
|
$pw->close();
|
2005-07-03 11:02:06 +00:00
|
|
|
exec(@cvs);
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
|
|
|
$pw->writer();
|
|
|
|
$pr->reader();
|
|
|
|
$self->{'socketo'} = $pw;
|
|
|
|
$self->{'socketi'} = $pr;
|
|
|
|
}
|
|
|
|
$self->{'socketo'}->write("Root $repo\n");
|
|
|
|
|
|
|
|
# Trial and error says that this probably is the minimum set
|
2005-08-15 18:18:25 +00:00
|
|
|
$self->{'socketo'}->write("Valid-responses ok error Valid-requests Mode M Mbinary E Checked-in Created Updated Merged Removed\n");
|
2005-06-28 14:48:40 +00:00
|
|
|
|
|
|
|
$self->{'socketo'}->write("valid-requests\n");
|
|
|
|
$self->{'socketo'}->flush();
|
|
|
|
|
|
|
|
chomp(my $rep=$self->readline());
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($rep !~ s/^Valid-requests\s*//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$rep="<unknown>" unless $rep;
|
|
|
|
die "Expected Valid-requests from server, but got: $rep\n";
|
|
|
|
}
|
|
|
|
chomp(my $res=$self->readline());
|
|
|
|
die "validReply: $res\n" if $res ne "ok";
|
|
|
|
|
|
|
|
$self->{'socketo'}->write("UseUnchanged\n") if $rep =~ /\bUseUnchanged\b/;
|
|
|
|
$self->{'repo'} = $repo;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub readline {
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($self) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
return $self->{'socketi'}->getline();
|
|
|
|
}
|
|
|
|
|
|
|
|
sub _file {
|
|
|
|
# Request a file with a given revision.
|
|
|
|
# Trial and error says this is a good way to do it. :-/
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($self,$fn,$rev) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
$self->{'socketo'}->write("Argument -N\n") or return undef;
|
|
|
|
$self->{'socketo'}->write("Argument -P\n") or return undef;
|
2005-08-16 05:39:29 +00:00
|
|
|
# -kk: Linus' version doesn't use it - defaults to off
|
|
|
|
if ($opt_k) {
|
|
|
|
$self->{'socketo'}->write("Argument -kk\n") or return undef;
|
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
$self->{'socketo'}->write("Argument -r\n") or return undef;
|
|
|
|
$self->{'socketo'}->write("Argument $rev\n") or return undef;
|
|
|
|
$self->{'socketo'}->write("Argument --\n") or return undef;
|
|
|
|
$self->{'socketo'}->write("Argument $self->{'subdir'}/$fn\n") or return undef;
|
|
|
|
$self->{'socketo'}->write("Directory .\n") or return undef;
|
|
|
|
$self->{'socketo'}->write("$self->{'repo'}\n") or return undef;
|
2005-06-30 10:19:48 +00:00
|
|
|
# $self->{'socketo'}->write("Sticky T1.0\n") or return undef;
|
2005-06-28 14:48:40 +00:00
|
|
|
$self->{'socketo'}->write("co\n") or return undef;
|
|
|
|
$self->{'socketo'}->flush() or return undef;
|
|
|
|
$self->{'lines'} = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
sub _line {
|
|
|
|
# Read a line from the server.
|
|
|
|
# ... except that 'line' may be an entire file. ;-)
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($self, $fh) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
die "Not in lines" unless defined $self->{'lines'};
|
|
|
|
|
|
|
|
my $line;
|
2005-07-03 22:43:26 +00:00
|
|
|
my $res=0;
|
2006-11-27 22:21:30 +00:00
|
|
|
while (defined($line = $self->readline())) {
|
2005-06-28 14:48:40 +00:00
|
|
|
# M U gnupg-cvs-rep/AUTHORS
|
|
|
|
# Updated gnupg-cvs-rep/
|
|
|
|
# /daten/src/rsync/gnupg-cvs-rep/AUTHORS
|
|
|
|
# /AUTHORS/1.1///T1.1
|
|
|
|
# u=rw,g=rw,o=rw
|
|
|
|
# 0
|
|
|
|
# ok
|
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($line =~ s/^(?:Created|Updated) //) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$line = $self->readline(); # path
|
|
|
|
$line = $self->readline(); # Entries line
|
|
|
|
my $mode = $self->readline(); chomp $mode;
|
|
|
|
$self->{'mode'} = $mode;
|
|
|
|
defined (my $cnt = $self->readline())
|
|
|
|
or die "EOF from server after 'Changed'\n";
|
|
|
|
chomp $cnt;
|
|
|
|
die "Duh: Filesize $cnt" if $cnt !~ /^\d+$/;
|
|
|
|
$line="";
|
2006-05-23 08:08:58 +00:00
|
|
|
$res = $self->_fetchfile($fh, $cnt);
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($line =~ s/^ //) {
|
2005-07-03 22:43:26 +00:00
|
|
|
print $fh $line;
|
|
|
|
$res += length($line);
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($line =~ /^M\b/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
# output, do nothing
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($line =~ /^Mbinary\b/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
my $cnt;
|
|
|
|
die "EOF from server after 'Mbinary'" unless defined ($cnt = $self->readline());
|
|
|
|
chomp $cnt;
|
|
|
|
die "Duh: Mbinary $cnt" if $cnt !~ /^\d+$/ or $cnt<1;
|
|
|
|
$line="";
|
2006-05-23 08:08:58 +00:00
|
|
|
$res += $self->_fetchfile($fh, $cnt);
|
2005-06-28 14:48:40 +00:00
|
|
|
} else {
|
|
|
|
chomp $line;
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($line eq "ok") {
|
2005-06-28 14:48:40 +00:00
|
|
|
# print STDERR "S: ok (".length($res).")\n";
|
|
|
|
return $res;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($line =~ s/^E //) {
|
2005-06-28 14:48:40 +00:00
|
|
|
# print STDERR "S: $line\n";
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($line =~ /^(Remove-entry|Removed) /i) {
|
2005-08-15 09:28:19 +00:00
|
|
|
$line = $self->readline(); # filename
|
|
|
|
$line = $self->readline(); # OK
|
|
|
|
chomp $line;
|
|
|
|
die "Unknown: $line" if $line ne "ok";
|
|
|
|
return -1;
|
2005-06-28 14:48:40 +00:00
|
|
|
} else {
|
|
|
|
die "Unknown: $line\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-02-18 20:44:20 +00:00
|
|
|
return undef;
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
|
|
|
sub file {
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($self,$fn,$rev) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
my $res;
|
|
|
|
|
2007-06-07 07:04:01 +00:00
|
|
|
my ($fh, $name) = tempfile('gitcvs.XXXXXX',
|
2005-07-03 22:43:26 +00:00
|
|
|
DIR => File::Spec->tmpdir(), UNLINK => 1);
|
|
|
|
|
|
|
|
$self->_file($fn,$rev) and $res = $self->_line($fh);
|
|
|
|
|
|
|
|
if (!defined $res) {
|
2006-02-18 20:44:20 +00:00
|
|
|
print STDERR "Server has gone away while fetching $fn $rev, retrying...\n";
|
|
|
|
truncate $fh, 0;
|
2005-07-03 22:43:26 +00:00
|
|
|
$self->conn();
|
2006-02-18 20:44:20 +00:00
|
|
|
$self->_file($fn,$rev) or die "No file command send";
|
2005-07-03 22:43:26 +00:00
|
|
|
$res = $self->_line($fh);
|
2006-02-18 20:44:20 +00:00
|
|
|
die "Retry failed" unless defined $res;
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
2005-07-06 06:37:12 +00:00
|
|
|
close ($fh);
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2005-07-03 22:43:26 +00:00
|
|
|
return ($name, $res);
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
2006-05-23 08:08:58 +00:00
|
|
|
sub _fetchfile {
|
|
|
|
my ($self, $fh, $cnt) = @_;
|
2006-05-23 23:30:39 +00:00
|
|
|
my $res = 0;
|
2006-05-23 08:08:58 +00:00
|
|
|
my $bufsize = 1024 * 1024;
|
2006-11-27 22:21:30 +00:00
|
|
|
while ($cnt) {
|
2006-05-23 08:08:58 +00:00
|
|
|
if ($bufsize > $cnt) {
|
|
|
|
$bufsize = $cnt;
|
|
|
|
}
|
|
|
|
my $buf;
|
|
|
|
my $num = $self->{'socketi'}->read($buf,$bufsize);
|
|
|
|
die "Server: Filesize $cnt: $num: $!\n" if not defined $num or $num<=0;
|
|
|
|
print $fh $buf;
|
|
|
|
$res += $num;
|
|
|
|
$cnt -= $num;
|
|
|
|
}
|
|
|
|
return $res;
|
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
|
|
|
|
|
|
|
|
package main;
|
|
|
|
|
2005-06-28 17:49:19 +00:00
|
|
|
my $cvs = CVSconn->new($opt_d, $cvs_tree);
|
2005-06-28 14:48:40 +00:00
|
|
|
|
|
|
|
|
|
|
|
sub pdate($) {
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($d) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
m#(\d{2,4})/(\d\d)/(\d\d)\s(\d\d):(\d\d)(?::(\d\d))?#
|
|
|
|
or die "Unparseable date: $d\n";
|
|
|
|
my $y=$1; $y-=1900 if $y>1900;
|
|
|
|
return timegm($6||0,$5,$4,$3,$2-1,$y);
|
2005-06-10 06:38:32 +00:00
|
|
|
}
|
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
sub pmode($) {
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($mode) = @_;
|
2005-06-28 14:48:40 +00:00
|
|
|
my $m = 0;
|
|
|
|
my $mm = 0;
|
|
|
|
my $um = 0;
|
|
|
|
for my $x(split(//,$mode)) {
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($x eq ",") {
|
2005-06-28 14:48:40 +00:00
|
|
|
$m |= $mm&$um;
|
|
|
|
$mm = 0;
|
|
|
|
$um = 0;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($x eq "u") { $um |= 0700;
|
|
|
|
} elsif ($x eq "g") { $um |= 0070;
|
|
|
|
} elsif ($x eq "o") { $um |= 0007;
|
|
|
|
} elsif ($x eq "r") { $mm |= 0444;
|
|
|
|
} elsif ($x eq "w") { $mm |= 0222;
|
|
|
|
} elsif ($x eq "x") { $mm |= 0111;
|
|
|
|
} elsif ($x eq "=") { # do nothing
|
2005-06-28 14:48:40 +00:00
|
|
|
} else { die "Unknown mode: $mode\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$m |= $mm&$um;
|
|
|
|
return $m;
|
|
|
|
}
|
2005-06-07 22:11:28 +00:00
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
sub getwd() {
|
|
|
|
my $pwd = `pwd`;
|
|
|
|
chomp $pwd;
|
|
|
|
return $pwd;
|
2005-06-07 22:11:28 +00:00
|
|
|
}
|
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
sub is_sha1 {
|
|
|
|
my $s = shift;
|
|
|
|
return $s =~ /^[a-f0-9]{40}$/;
|
|
|
|
}
|
2005-08-16 10:35:27 +00:00
|
|
|
|
2007-11-28 18:56:11 +00:00
|
|
|
sub get_headref ($) {
|
|
|
|
my $name = shift;
|
|
|
|
my $r = `git rev-parse --verify '$name' 2>/dev/null`;
|
|
|
|
return undef unless $? == 0;
|
|
|
|
chomp $r;
|
|
|
|
return $r;
|
2005-08-16 10:35:27 +00:00
|
|
|
}
|
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
-d $git_tree
|
|
|
|
or mkdir($git_tree,0777)
|
|
|
|
or die "Could not create $git_tree: $!";
|
|
|
|
chdir($git_tree);
|
2005-06-07 22:11:28 +00:00
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
my $last_branch = "";
|
2005-06-28 19:08:15 +00:00
|
|
|
my $orig_branch = "";
|
2005-06-28 14:48:40 +00:00
|
|
|
my %branch_date;
|
2006-03-17 22:08:39 +00:00
|
|
|
my $tip_at_start = undef;
|
2005-06-28 14:48:40 +00:00
|
|
|
|
|
|
|
my $git_dir = $ENV{"GIT_DIR"} || ".git";
|
|
|
|
$git_dir = getwd()."/".$git_dir unless $git_dir =~ m#^/#;
|
|
|
|
$ENV{"GIT_DIR"} = $git_dir;
|
2005-07-04 11:36:59 +00:00
|
|
|
my $orig_git_index;
|
|
|
|
$orig_git_index = $ENV{GIT_INDEX_FILE} if exists $ENV{GIT_INDEX_FILE};
|
2006-06-12 11:50:49 +00:00
|
|
|
|
|
|
|
my %index; # holds filenames of one index per branch
|
2006-06-24 19:42:20 +00:00
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
unless (-d $git_dir) {
|
2007-01-12 21:01:46 +00:00
|
|
|
system("git-init");
|
2005-06-28 14:48:40 +00:00
|
|
|
die "Cannot init the GIT db at $git_tree: $?\n" if $?;
|
|
|
|
system("git-read-tree");
|
|
|
|
die "Cannot init an empty tree: $?\n" if $?;
|
|
|
|
|
|
|
|
$last_branch = $opt_o;
|
2005-06-28 19:08:15 +00:00
|
|
|
$orig_branch = "";
|
2005-06-28 14:48:40 +00:00
|
|
|
} else {
|
2005-11-16 18:27:28 +00:00
|
|
|
open(F, "git-symbolic-ref HEAD |") or
|
|
|
|
die "Cannot run git-symbolic-ref: $!\n";
|
|
|
|
chomp ($last_branch = <F>);
|
|
|
|
$last_branch = basename($last_branch);
|
|
|
|
close(F);
|
2006-11-27 22:21:30 +00:00
|
|
|
unless ($last_branch) {
|
2005-06-28 19:08:15 +00:00
|
|
|
warn "Cannot read the last branch name: $! -- assuming 'master'\n";
|
|
|
|
$last_branch = "master";
|
|
|
|
}
|
|
|
|
$orig_branch = $last_branch;
|
2006-03-17 22:08:39 +00:00
|
|
|
$tip_at_start = `git-rev-parse --verify HEAD`;
|
2005-06-28 14:48:40 +00:00
|
|
|
|
|
|
|
# Get the last import timestamps
|
2006-09-20 16:37:04 +00:00
|
|
|
my $fmt = '($ref, $author) = (%(refname), %(author));';
|
2007-05-30 00:56:41 +00:00
|
|
|
open(H, "git-for-each-ref --perl --format='$fmt' $remote |") or
|
2006-09-20 16:37:04 +00:00
|
|
|
die "Cannot run git-for-each-ref: $!\n";
|
2006-11-27 22:21:30 +00:00
|
|
|
while (defined(my $entry = <H>)) {
|
2006-09-20 16:37:04 +00:00
|
|
|
my ($ref, $author);
|
|
|
|
eval($entry) || die "cannot eval refs list: $@";
|
2007-05-30 00:56:41 +00:00
|
|
|
my ($head) = ($ref =~ m|^$remote/(.*)|);
|
2006-09-20 16:37:04 +00:00
|
|
|
$author =~ /^.*\s(\d+)\s[-+]\d{4}$/;
|
|
|
|
$branch_date{$head} = $1;
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
2006-09-20 16:37:04 +00:00
|
|
|
close(H);
|
2007-05-23 11:13:21 +00:00
|
|
|
if (!exists $branch_date{$opt_o}) {
|
|
|
|
die "Branch '$opt_o' does not exist.\n".
|
|
|
|
"Either use the correct '-o branch' option,\n".
|
|
|
|
"or import to a new repository.\n";
|
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
-d $git_dir
|
|
|
|
or die "Could not create git subdir ($git_dir).\n";
|
|
|
|
|
2006-01-12 23:38:59 +00:00
|
|
|
# now we read (and possibly save) author-info as well
|
|
|
|
-f "$git_dir/cvs-authors" and
|
|
|
|
read_author_info("$git_dir/cvs-authors");
|
|
|
|
if ($opt_A) {
|
|
|
|
read_author_info($opt_A);
|
|
|
|
write_author_info("$git_dir/cvs-authors");
|
|
|
|
}
|
|
|
|
|
2006-06-11 08:12:20 +00:00
|
|
|
|
|
|
|
#
|
|
|
|
# run cvsps into a file unless we are getting
|
|
|
|
# it passed as a file via $opt_P
|
|
|
|
#
|
2007-01-08 08:08:46 +00:00
|
|
|
my $cvspsfile;
|
2006-06-11 08:12:20 +00:00
|
|
|
unless ($opt_P) {
|
|
|
|
print "Running cvsps...\n" if $opt_v;
|
|
|
|
my $pid = open(CVSPS,"-|");
|
2007-01-08 08:08:46 +00:00
|
|
|
my $cvspsfh;
|
2006-06-11 08:12:20 +00:00
|
|
|
die "Cannot fork: $!\n" unless defined $pid;
|
2006-11-27 22:21:30 +00:00
|
|
|
unless ($pid) {
|
2006-06-11 08:12:20 +00:00
|
|
|
my @opt;
|
|
|
|
@opt = split(/,/,$opt_p) if defined $opt_p;
|
|
|
|
unshift @opt, '-z', $opt_z if defined $opt_z;
|
|
|
|
unshift @opt, '-q' unless defined $opt_v;
|
|
|
|
unless (defined($opt_p) && $opt_p =~ m/--no-cvs-direct/) {
|
|
|
|
push @opt, '--cvs-direct';
|
|
|
|
}
|
|
|
|
exec("cvsps","--norc",@opt,"-u","-A",'--root',$opt_d,$cvs_tree);
|
|
|
|
die "Could not start cvsps: $!\n";
|
2005-10-12 04:57:04 +00:00
|
|
|
}
|
2007-01-08 08:08:46 +00:00
|
|
|
($cvspsfh, $cvspsfile) = tempfile('gitXXXXXX', SUFFIX => '.cvsps',
|
|
|
|
DIR => File::Spec->tmpdir());
|
2006-06-11 08:12:20 +00:00
|
|
|
while (<CVSPS>) {
|
|
|
|
print $cvspsfh $_;
|
2005-11-02 00:48:47 +00:00
|
|
|
}
|
2006-06-11 08:12:20 +00:00
|
|
|
close CVSPS;
|
2007-12-24 03:08:19 +00:00
|
|
|
$? == 0 or die "git-cvsimport: fatal: cvsps reported error\n";
|
2006-06-11 08:12:20 +00:00
|
|
|
close $cvspsfh;
|
2007-01-08 08:08:46 +00:00
|
|
|
} else {
|
|
|
|
$cvspsfile = $opt_P;
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
|
|
|
|
2007-01-08 08:08:46 +00:00
|
|
|
open(CVS, "<$cvspsfile") or die $!;
|
2006-06-11 08:12:20 +00:00
|
|
|
|
2005-06-28 14:48:40 +00:00
|
|
|
## cvsps output:
|
|
|
|
#---------------------
|
|
|
|
#PatchSet 314
|
|
|
|
#Date: 1999/09/18 13:03:59
|
|
|
|
#Author: wkoch
|
|
|
|
#Branch: STABLE-BRANCH-1-0
|
|
|
|
#Ancestor branch: HEAD
|
|
|
|
#Tag: (none)
|
|
|
|
#Log:
|
|
|
|
# See ChangeLog: Sat Sep 18 13:03:28 CEST 1999 Werner Koch
|
|
|
|
#Members:
|
|
|
|
# README:1.57->1.57.2.1
|
|
|
|
# VERSION:1.96->1.96.2.1
|
|
|
|
#
|
|
|
|
#---------------------
|
|
|
|
|
|
|
|
my $state = 0;
|
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
sub update_index (\@\@) {
|
|
|
|
my $old = shift;
|
|
|
|
my $new = shift;
|
2006-05-23 07:27:45 +00:00
|
|
|
open(my $fh, '|-', qw(git-update-index -z --index-info))
|
|
|
|
or die "unable to open git-update-index: $!";
|
|
|
|
print $fh
|
|
|
|
(map { "0 0000000000000000000000000000000000000000\t$_\0" }
|
2006-05-23 07:27:46 +00:00
|
|
|
@$old),
|
2006-05-23 07:27:45 +00:00
|
|
|
(map { '100' . sprintf('%o', $_->[0]) . " $_->[1]\t$_->[2]\0" }
|
2006-05-23 07:27:46 +00:00
|
|
|
@$new)
|
2006-05-23 07:27:45 +00:00
|
|
|
or die "unable to write to git-update-index: $!";
|
|
|
|
close $fh
|
|
|
|
or die "unable to write to git-update-index: $!";
|
|
|
|
$? and die "git-update-index reported error: $?";
|
2006-05-23 07:27:46 +00:00
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
sub write_tree () {
|
|
|
|
open(my $fh, '-|', qw(git-write-tree))
|
|
|
|
or die "unable to open git-write-tree: $!";
|
|
|
|
chomp(my $tree = <$fh>);
|
|
|
|
is_sha1($tree)
|
|
|
|
or die "Cannot get tree id ($tree): $!";
|
|
|
|
close($fh)
|
2005-06-28 14:48:40 +00:00
|
|
|
or die "Error running git-write-tree: $?\n";
|
|
|
|
print "Tree ID $tree\n" if $opt_v;
|
2006-05-23 07:27:46 +00:00
|
|
|
return $tree;
|
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
my ($patchset,$date,$author_name,$author_email,$branch,$ancestor,$tag,$logmsg);
|
|
|
|
my (@old,@new,@skipped,%ignorebranch);
|
2006-06-11 08:12:09 +00:00
|
|
|
|
|
|
|
# commits that cvsps cannot place anywhere...
|
|
|
|
$ignorebranch{'#CVSPS_NO_BRANCH'} = 1;
|
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
sub commit {
|
2007-11-28 18:56:11 +00:00
|
|
|
if ($branch eq $opt_o && !$index{branch} &&
|
|
|
|
!get_headref("$remote/$branch")) {
|
2006-06-28 10:13:23 +00:00
|
|
|
# looks like an initial commit
|
2007-01-12 21:01:46 +00:00
|
|
|
# use the index primed by git-init
|
2007-06-05 06:06:30 +00:00
|
|
|
$ENV{GIT_INDEX_FILE} = "$git_dir/index";
|
|
|
|
$index{$branch} = "$git_dir/index";
|
2006-06-28 10:13:23 +00:00
|
|
|
} else {
|
|
|
|
# use an index per branch to speed up
|
|
|
|
# imports of projects with many branches
|
|
|
|
unless ($index{$branch}) {
|
|
|
|
$index{$branch} = tmpnam();
|
|
|
|
$ENV{GIT_INDEX_FILE} = $index{$branch};
|
|
|
|
if ($ancestor) {
|
2007-05-30 00:56:41 +00:00
|
|
|
system("git-read-tree", "$remote/$ancestor");
|
2006-06-28 10:13:23 +00:00
|
|
|
} else {
|
2007-05-30 00:56:41 +00:00
|
|
|
system("git-read-tree", "$remote/$branch");
|
2006-06-28 10:13:23 +00:00
|
|
|
}
|
|
|
|
die "read-tree failed: $?\n" if $?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$ENV{GIT_INDEX_FILE} = $index{$branch};
|
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
update_index(@old, @new);
|
|
|
|
@old = @new = ();
|
|
|
|
my $tree = write_tree();
|
2007-11-28 18:56:11 +00:00
|
|
|
my $parent = get_headref("$remote/$last_branch");
|
2006-05-23 07:27:46 +00:00
|
|
|
print "Parent ID " . ($parent ? $parent : "(empty)") . "\n" if $opt_v;
|
|
|
|
|
|
|
|
my @commit_args;
|
|
|
|
push @commit_args, ("-p", $parent) if $parent;
|
|
|
|
|
|
|
|
# loose detection of merges
|
|
|
|
# based on the commit msg
|
|
|
|
foreach my $rx (@mergerx) {
|
|
|
|
next unless $logmsg =~ $rx && $1;
|
|
|
|
my $mparent = $1 eq 'HEAD' ? $opt_o : $1;
|
2007-11-28 18:56:11 +00:00
|
|
|
if (my $sha1 = get_headref("$remote/$mparent")) {
|
2008-03-12 19:54:21 +00:00
|
|
|
push @commit_args, '-p', "$remote/$mparent";
|
2006-05-23 07:27:46 +00:00
|
|
|
print "Merge parent branch: $mparent\n" if $opt_v;
|
2005-08-16 10:35:27 +00:00
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
2006-05-23 07:27:46 +00:00
|
|
|
|
|
|
|
my $commit_date = strftime("+0000 %Y-%m-%d %H:%M:%S",gmtime($date));
|
2006-05-23 20:59:44 +00:00
|
|
|
$ENV{GIT_AUTHOR_NAME} = $author_name;
|
|
|
|
$ENV{GIT_AUTHOR_EMAIL} = $author_email;
|
|
|
|
$ENV{GIT_AUTHOR_DATE} = $commit_date;
|
|
|
|
$ENV{GIT_COMMITTER_NAME} = $author_name;
|
|
|
|
$ENV{GIT_COMMITTER_EMAIL} = $author_email;
|
|
|
|
$ENV{GIT_COMMITTER_DATE} = $commit_date;
|
2006-05-23 07:27:46 +00:00
|
|
|
my $pid = open2(my $commit_read, my $commit_write,
|
|
|
|
'git-commit-tree', $tree, @commit_args);
|
2005-06-30 20:09:42 +00:00
|
|
|
|
|
|
|
# compatibility with git2cvs
|
|
|
|
substr($logmsg,32767) = "" if length($logmsg) > 32767;
|
|
|
|
$logmsg =~ s/[\s\n]+\z//;
|
|
|
|
|
2006-01-30 06:12:41 +00:00
|
|
|
if (@skipped) {
|
|
|
|
$logmsg .= "\n\n\nSKIPPED:\n\t";
|
|
|
|
$logmsg .= join("\n\t", @skipped) . "\n";
|
2006-05-22 12:45:47 +00:00
|
|
|
@skipped = ();
|
2006-01-30 06:12:41 +00:00
|
|
|
}
|
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
print($commit_write "$logmsg\n") && close($commit_write)
|
2005-06-28 14:48:40 +00:00
|
|
|
or die "Error writing to git-commit-tree: $!\n";
|
2005-06-28 17:49:19 +00:00
|
|
|
|
2006-05-23 07:27:46 +00:00
|
|
|
print "Committed patch $patchset ($branch $commit_date)\n" if $opt_v;
|
|
|
|
chomp(my $cid = <$commit_read>);
|
|
|
|
is_sha1($cid) or die "Cannot get commit id ($cid): $!\n";
|
2005-06-28 14:48:40 +00:00
|
|
|
print "Commit ID $cid\n" if $opt_v;
|
2006-05-23 07:27:46 +00:00
|
|
|
close($commit_read);
|
2005-06-28 17:49:19 +00:00
|
|
|
|
|
|
|
waitpid($pid,0);
|
|
|
|
die "Error running git-commit-tree: $?\n" if $?;
|
2005-06-28 14:48:40 +00:00
|
|
|
|
2008-04-30 04:36:14 +00:00
|
|
|
system('git-update-ref', "$remote/$branch", $cid) == 0
|
2005-06-28 14:48:40 +00:00
|
|
|
or die "Cannot write branch $branch for update: $!\n";
|
|
|
|
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($tag) {
|
|
|
|
my ($xtag) = $tag;
|
2005-09-06 17:36:01 +00:00
|
|
|
$xtag =~ s/\s+\*\*.*$//; # Remove stuff like ** INVALID ** and ** FUNKY **
|
|
|
|
$xtag =~ tr/_/\./ if ( $opt_u );
|
2006-01-06 20:52:27 +00:00
|
|
|
$xtag =~ s/[\/]/$opt_s/g;
|
2008-05-23 18:29:22 +00:00
|
|
|
$xtag =~ s/\[//g;
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2007-09-07 21:35:07 +00:00
|
|
|
system('git-tag', '-f', $xtag, $cid) == 0
|
2005-09-06 17:36:01 +00:00
|
|
|
or die "Cannot create tag $xtag: $!\n";
|
|
|
|
|
|
|
|
print "Created tag '$xtag' on '$branch'\n" if $opt_v;
|
2005-06-28 14:48:40 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-05-22 11:38:08 +00:00
|
|
|
my $commitcount = 1;
|
2006-11-27 22:21:30 +00:00
|
|
|
while (<CVS>) {
|
2005-06-28 14:48:40 +00:00
|
|
|
chomp;
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($state == 0 and /^-+$/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 1;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 0) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 1;
|
|
|
|
redo;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif (($state==0 or $state==1) and s/^PatchSet\s+//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$patchset = 0+$_;
|
|
|
|
$state=2;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 2 and s/^Date:\s+//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$date = pdate($_);
|
2006-11-27 22:21:30 +00:00
|
|
|
unless ($date) {
|
2005-06-28 14:48:40 +00:00
|
|
|
print STDERR "Could not parse date: $_\n";
|
|
|
|
$state=0;
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
$state=3;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 3 and s/^Author:\s+//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
s/\s+$//;
|
2005-09-30 08:48:57 +00:00
|
|
|
if (/^(.*?)\s+<(.*)>/) {
|
|
|
|
($author_name, $author_email) = ($1, $2);
|
2006-01-12 23:38:59 +00:00
|
|
|
} elsif ($conv_author_name{$_}) {
|
|
|
|
$author_name = $conv_author_name{$_};
|
|
|
|
$author_email = $conv_author_email{$_};
|
2005-09-30 08:48:57 +00:00
|
|
|
} else {
|
|
|
|
$author_name = $author_email = $_;
|
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 4;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 4 and s/^Branch:\s+//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
s/\s+$//;
|
2007-11-03 11:55:02 +00:00
|
|
|
tr/_/\./ if ( $opt_u );
|
2005-08-17 09:19:20 +00:00
|
|
|
s/[\/]/$opt_s/g;
|
2005-06-28 14:48:40 +00:00
|
|
|
$branch = $_;
|
|
|
|
$state = 5;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 5 and s/^Ancestor branch:\s+//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
s/\s+$//;
|
|
|
|
$ancestor = $_;
|
2005-06-30 15:23:22 +00:00
|
|
|
$ancestor = $opt_o if $ancestor eq "HEAD";
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 6;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 5) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$ancestor = undef;
|
|
|
|
$state = 6;
|
|
|
|
redo;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 6 and s/^Tag:\s+//) {
|
2005-06-28 14:48:40 +00:00
|
|
|
s/\s+$//;
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($_ eq "(none)") {
|
2005-06-28 14:48:40 +00:00
|
|
|
$tag = undef;
|
|
|
|
} else {
|
|
|
|
$tag = $_;
|
|
|
|
}
|
|
|
|
$state = 7;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 7 and /^Log:/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$logmsg = "";
|
|
|
|
$state = 8;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 8 and /^Members:/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$branch = $opt_o if $branch eq "HEAD";
|
2006-11-27 22:21:30 +00:00
|
|
|
if (defined $branch_date{$branch} and $branch_date{$branch} >= $date) {
|
2005-06-28 14:48:40 +00:00
|
|
|
# skip
|
2005-07-03 17:03:30 +00:00
|
|
|
print "skip patchset $patchset: $date before $branch_date{$branch}\n" if $opt_v;
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 11;
|
|
|
|
next;
|
|
|
|
}
|
2007-01-08 06:43:39 +00:00
|
|
|
if (!$opt_a && $starttime - 300 - (defined $opt_z ? $opt_z : 300) <= $date) {
|
2007-01-08 01:11:23 +00:00
|
|
|
# skip if the commit is too recent
|
2007-12-21 15:57:26 +00:00
|
|
|
# given that the cvsps default fuzz is 300s, we give ourselves another
|
2007-01-08 01:11:23 +00:00
|
|
|
# 300s just in case -- this also prevents skipping commits
|
|
|
|
# due to server clock drift
|
|
|
|
print "skip patchset $patchset: $date too recent\n" if $opt_v;
|
|
|
|
$state = 11;
|
|
|
|
next;
|
|
|
|
}
|
2006-06-11 08:12:09 +00:00
|
|
|
if (exists $ignorebranch{$branch}) {
|
|
|
|
print STDERR "Skipping $branch\n";
|
|
|
|
$state = 11;
|
|
|
|
next;
|
|
|
|
}
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($ancestor) {
|
|
|
|
if ($ancestor eq $branch) {
|
2006-06-11 08:12:09 +00:00
|
|
|
print STDERR "Branch $branch erroneously stems from itself -- changed ancestor to $opt_o\n";
|
|
|
|
$ancestor = $opt_o;
|
|
|
|
}
|
2007-11-28 18:56:28 +00:00
|
|
|
if (defined get_headref("$remote/$branch")) {
|
2005-06-28 14:48:40 +00:00
|
|
|
print STDERR "Branch $branch already exists!\n";
|
|
|
|
$state=11;
|
|
|
|
next;
|
|
|
|
}
|
2007-11-28 18:56:28 +00:00
|
|
|
my $id = get_headref("$remote/$ancestor");
|
|
|
|
if (!$id) {
|
2005-06-28 14:48:40 +00:00
|
|
|
print STDERR "Branch $ancestor does not exist!\n";
|
2006-06-11 08:12:09 +00:00
|
|
|
$ignorebranch{$branch} = 1;
|
2005-06-28 14:48:40 +00:00
|
|
|
$state=11;
|
|
|
|
next;
|
|
|
|
}
|
2007-11-28 18:56:28 +00:00
|
|
|
|
|
|
|
system(qw(git update-ref -m cvsimport),
|
|
|
|
"$remote/$branch", $id);
|
|
|
|
if($? != 0) {
|
|
|
|
print STDERR "Could not create branch $branch\n";
|
2006-06-11 08:12:09 +00:00
|
|
|
$ignorebranch{$branch} = 1;
|
2005-06-28 14:48:40 +00:00
|
|
|
$state=11;
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2005-07-04 13:28:36 +00:00
|
|
|
$last_branch = $branch if $branch ne $last_branch;
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 9;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 8) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$logmsg .= "$_\n";
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 9 and /^\s+(.+?):(INITIAL|\d+(?:\.\d+)+)->(\d+(?:\.\d+)+)\s*$/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
# VERSION:1.96->1.96.2.1
|
2005-06-28 17:49:19 +00:00
|
|
|
my $init = ($2 eq "INITIAL");
|
2005-06-28 14:48:40 +00:00
|
|
|
my $fn = $1;
|
2005-06-28 17:58:40 +00:00
|
|
|
my $rev = $3;
|
|
|
|
$fn =~ s#^/+##;
|
2006-01-30 06:12:41 +00:00
|
|
|
if ($opt_S && $fn =~ m/$opt_S/) {
|
|
|
|
print "SKIPPING $fn v $rev\n";
|
|
|
|
push(@skipped, $fn);
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
print "Fetching $fn v $rev\n" if $opt_v;
|
2005-07-03 22:43:26 +00:00
|
|
|
my ($tmpname, $size) = $cvs->file($fn,$rev);
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($size == -1) {
|
2005-08-15 09:28:19 +00:00
|
|
|
push(@old,$fn);
|
|
|
|
print "Drop $fn\n" if $opt_v;
|
|
|
|
} else {
|
|
|
|
print "".($init ? "New" : "Update")." $fn: $size bytes\n" if $opt_v;
|
2006-02-20 22:17:28 +00:00
|
|
|
my $pid = open(my $F, '-|');
|
|
|
|
die $! unless defined $pid;
|
|
|
|
if (!$pid) {
|
|
|
|
exec("git-hash-object", "-w", $tmpname)
|
2005-08-15 09:28:19 +00:00
|
|
|
or die "Cannot create object: $!\n";
|
2006-02-20 22:17:28 +00:00
|
|
|
}
|
2005-08-15 09:28:19 +00:00
|
|
|
my $sha = <$F>;
|
|
|
|
chomp $sha;
|
|
|
|
close $F;
|
|
|
|
my $mode = pmode($cvs->{'mode'});
|
|
|
|
push(@new,[$mode, $sha, $fn]); # may be resurrected!
|
|
|
|
}
|
2005-07-03 22:43:26 +00:00
|
|
|
unlink($tmpname);
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 9 and /^\s+(.+?):\d+(?:\.\d+)+->(\d+(?:\.\d+)+)\(DEAD\)\s*$/) {
|
2005-06-28 17:58:40 +00:00
|
|
|
my $fn = $1;
|
|
|
|
$fn =~ s#^/+##;
|
|
|
|
push(@old,$fn);
|
2005-08-15 09:28:19 +00:00
|
|
|
print "Delete $fn\n" if $opt_v;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 9 and /^\s*$/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 10;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif (($state == 9 or $state == 10) and /^-+$/) {
|
2006-05-23 02:28:37 +00:00
|
|
|
$commitcount++;
|
|
|
|
if ($opt_L && $commitcount > $opt_L) {
|
2006-05-22 11:38:08 +00:00
|
|
|
last;
|
|
|
|
}
|
2006-05-22 12:45:39 +00:00
|
|
|
commit();
|
2006-05-23 02:28:37 +00:00
|
|
|
if (($commitcount & 1023) == 0) {
|
|
|
|
system("git repack -a -d");
|
|
|
|
}
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 1;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state == 11 and /^-+$/) {
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 1;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif (/^-+$/) { # end of unknown-line processing
|
2005-06-28 14:48:40 +00:00
|
|
|
$state = 1;
|
2006-11-27 22:21:30 +00:00
|
|
|
} elsif ($state != 11) { # ignore stuff when skipping
|
2005-06-28 14:48:40 +00:00
|
|
|
print "* UNKNOWN LINE * $_\n";
|
|
|
|
}
|
|
|
|
}
|
2006-05-22 12:45:39 +00:00
|
|
|
commit() if $branch and $state != 11;
|
2005-06-07 22:11:28 +00:00
|
|
|
|
2007-01-08 08:08:46 +00:00
|
|
|
unless ($opt_P) {
|
|
|
|
unlink($cvspsfile);
|
|
|
|
}
|
|
|
|
|
2006-11-15 20:15:44 +00:00
|
|
|
# The heuristic of repacking every 1024 commits can leave a
|
|
|
|
# lot of unpacked data. If there is more than 1MB worth of
|
|
|
|
# not-packed objects, repack once more.
|
|
|
|
my $line = `git-count-objects`;
|
|
|
|
if ($line =~ /^(\d+) objects, (\d+) kilobytes$/) {
|
|
|
|
my ($n_objects, $kb) = ($1, $2);
|
|
|
|
1024 < $kb
|
|
|
|
and system("git repack -a -d");
|
|
|
|
}
|
|
|
|
|
2006-06-12 11:50:49 +00:00
|
|
|
foreach my $git_index (values %index) {
|
2007-06-05 06:06:30 +00:00
|
|
|
if ($git_index ne "$git_dir/index") {
|
2006-06-28 10:13:23 +00:00
|
|
|
unlink($git_index);
|
|
|
|
}
|
2006-06-12 11:50:49 +00:00
|
|
|
}
|
2005-07-04 11:36:59 +00:00
|
|
|
|
2005-07-05 11:19:59 +00:00
|
|
|
if (defined $orig_git_index) {
|
|
|
|
$ENV{GIT_INDEX_FILE} = $orig_git_index;
|
|
|
|
} else {
|
|
|
|
delete $ENV{GIT_INDEX_FILE};
|
|
|
|
}
|
|
|
|
|
2005-06-28 19:08:15 +00:00
|
|
|
# Now switch back to the branch we were in before all of this happened
|
2006-11-27 22:21:30 +00:00
|
|
|
if ($orig_branch) {
|
2006-03-17 22:08:39 +00:00
|
|
|
print "DONE.\n" if $opt_v;
|
|
|
|
if ($opt_i) {
|
|
|
|
exit 0;
|
|
|
|
}
|
|
|
|
my $tip_at_end = `git-rev-parse --verify HEAD`;
|
|
|
|
if ($tip_at_start ne $tip_at_end) {
|
2006-03-18 10:05:02 +00:00
|
|
|
for ($tip_at_start, $tip_at_end) { chomp; }
|
2006-03-17 22:08:39 +00:00
|
|
|
print "Fetched into the current branch.\n" if $opt_v;
|
|
|
|
system(qw(git-read-tree -u -m),
|
|
|
|
$tip_at_start, $tip_at_end);
|
|
|
|
die "Fast-forward update failed: $?\n" if $?;
|
|
|
|
}
|
|
|
|
else {
|
2007-05-30 00:56:41 +00:00
|
|
|
system(qw(git-merge cvsimport HEAD), "$remote/$opt_o");
|
2006-03-17 22:08:39 +00:00
|
|
|
die "Could not merge $opt_o into the current branch.\n" if $?;
|
|
|
|
}
|
2005-06-28 19:08:15 +00:00
|
|
|
} else {
|
|
|
|
$orig_branch = "master";
|
|
|
|
print "DONE; creating $orig_branch branch\n" if $opt_v;
|
2007-05-30 00:56:41 +00:00
|
|
|
system("git-update-ref", "refs/heads/master", "$remote/$opt_o")
|
2007-11-28 18:56:28 +00:00
|
|
|
unless defined get_headref('refs/heads/master');
|
2007-06-04 09:01:49 +00:00
|
|
|
system("git-symbolic-ref", "$remote/HEAD", "$remote/$opt_o")
|
|
|
|
if ($opt_r && $opt_o ne 'HEAD');
|
2005-11-16 18:27:28 +00:00
|
|
|
system('git-update-ref', 'HEAD', "$orig_branch");
|
2005-07-11 14:57:49 +00:00
|
|
|
unless ($opt_i) {
|
2007-06-28 11:12:07 +00:00
|
|
|
system('git checkout -f');
|
2005-07-11 14:57:49 +00:00
|
|
|
die "checkout failed: $?\n" if $?;
|
|
|
|
}
|
2005-06-28 19:08:15 +00:00
|
|
|
}
|