kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

git-svn: add support for metadata in .git/config 

Of course, we handle metadata migrations from previous versions
and we have added unit tests.

The new .git/config remotes resemble non-SVN remotes.  Below
is an example with comments:

[svn-remote "git-svn"]
	; like non-svn remotes, we have one URL per-remote
	url = http://foo.bar.org/svn

	; 'fetch' keys are done in the same way as non-svn
	; remotes, too.  With the left-hand-side of the ':'
	; being the remote (SVN) repository path relative to the
	; above 'url' key; and the right-hand-side being a
	; remote ref in git (refs/remotes/*).
	; An empty left-hand-side means that it will fetch
	; the entire contents of the 'url' key.
	; old-style (migrated from previous versions of git-svn)
	; are like this:
	fetch = :refs/remotes/git-svn

	; this is created by a current version of git-svn
	; using the multi-init command with an explicit
	; url (specified above).  This allows multi-init
	; to reuse SVN::Ra connections.
	fetch = trunk:refs/remotes/trunk
	fetch = branches/a:refs/remotes/a
	fetch = branches/b:refs/remotes/b
	fetch = tags/0.1:refs/remotes/tags/0.1
	fetch = tags/0.2:refs/remotes/tags/0.2
	fetch = tags/0.3:refs/remotes/tags/0.3

[svn-remote "alt"]
	; this is another old-style remote migrated over
	; to the new config format
	url = http://foo.bar.org/alt
	fetch = :refs/remotes/alt

Signed-off-by: Eric Wong <normalperson@yhbt.net>
maint
Eric Wong 2007-01-18 17:50:01 -08:00
parent d05d72e07e
commit 706587fc6d
2 changed files with 367 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

583
git-svn.perl
View File

@ -13,9 +13,8 @@ use vars qw/ $AUTHOR $VERSION
$AUTHOR = 'Eric Wong <normalperson@yhbt.net>'; $AUTHOR = 'Eric Wong <normalperson@yhbt.net>';
$VERSION = '@@GIT_VERSION@@'; $VERSION = '@@GIT_VERSION@@';


use Cwd qw/abs_path/; $ENV{GIT_DIR} ||= '.git';
$GIT_DIR = abs_path($ENV{GIT_DIR} || '.git'); $Git::SVN::default_repo_id = $ENV{GIT_SVN_ID} || 'git-svn';
$ENV{GIT_DIR} = $GIT_DIR;


my $LC_ALL = $ENV{LC_ALL}; my $LC_ALL = $ENV{LC_ALL};
$Git::SVN::Log::TZ = $ENV{TZ}; $Git::SVN::Log::TZ = $ENV{TZ};
@ -47,6 +46,7 @@ BEGIN {
foreach (qw/command command_oneline command_noisy command_output_pipe foreach (qw/command command_oneline command_noisy command_output_pipe
command_input_pipe command_close_pipe/) { command_input_pipe command_close_pipe/) {
$s .= "*SVN::Git::Editor::$_ = *SVN::Git::Fetcher::$_ = ". $s .= "*SVN::Git::Editor::$_ = *SVN::Git::Fetcher::$_ = ".
"*Git::SVN::Migration::$_ = ".
"*Git::SVN::Log::$_ = *Git::SVN::$_ = *$_ = *Git::$_; "; "*Git::SVN::Log::$_ = *Git::SVN::$_ = *$_ = *Git::$_; ";
} }
eval $s; eval $s;
@ -64,17 +64,17 @@ my ($_stdin, $_help, $_edit,
$_version, $_upgrade, $_version, $_upgrade,
$_merge, $_strategy, $_dry_run, $_merge, $_strategy, $_dry_run,
$_prefix); $_prefix);
my @repo_path_split_cache;


my %remote_opts = ( 'username=s' => \$Git::SVN::Prompt::_username,
'config-dir=s' => \$Git::SVN::Ra::config_dir,
'no-auth-cache' => \$Git::SVN::Prompt::_no_auth_cache );
my %fc_opts = ( 'follow-parent|follow' => \$_follow_parent, my %fc_opts = ( 'follow-parent|follow' => \$_follow_parent,
'authors-file|A=s' => \$_authors, 'authors-file|A=s' => \$_authors,
'repack:i' => \$_repack, 'repack:i' => \$_repack,
'no-metadata' => \$_no_metadata, 'no-metadata' => \$_no_metadata,
'quiet|q' => \$_q, 'quiet|q' => \$_q,
'username=s' => \$Git::SVN::Prompt::_username, 'repack-flags|repack-args|repack-opts=s' => \$_repack_flags,
'config-dir=s' => \$Git::SVN::Ra::config_dir, %remote_opts );
'no-auth-cache' => \$Git::SVN::Prompt::_no_auth_cache,
'repack-flags|repack-args|repack-opts=s' => \$_repack_flags);


my ($_trunk, $_tags, $_branches); my ($_trunk, $_tags, $_branches);
my %multi_opts = ( 'trunk|T=s' => \$_trunk, my %multi_opts = ( 'trunk|T=s' => \$_trunk,
@ -110,16 +110,20 @@ my %cmd = (
'upgrade' => \$_upgrade } ], 'upgrade' => \$_upgrade } ],
'multi-init' => [ \&cmd_multi_init, 'multi-init' => [ \&cmd_multi_init,
'Initialize multiple trees (like git-svnimport)', 'Initialize multiple trees (like git-svnimport)',
{ %multi_opts, %init_opts, { %multi_opts, %init_opts, %remote_opts,
'revision|r=i' => \$_revision, 'revision|r=i' => \$_revision,
'username=s' => \$Git::SVN::Prompt::_username,
'config-dir=s' => \$Git::SVN::Ra::config_dir,
'no-auth-cache' => \$Git::SVN::Prompt::_no_auth_cache,
'prefix=s' => \$_prefix, 'prefix=s' => \$_prefix,
} ], } ],
'multi-fetch' => [ \&cmd_multi_fetch, 'multi-fetch' => [ \&cmd_multi_fetch,
'Fetch multiple trees (like git-svnimport)', 'Fetch multiple trees (like git-svnimport)',
\%fc_opts ], \%fc_opts ],
'migrate' => [ sub { },
# no-op, we automatically run this anyways,
# we may add a flag to automatically optimize the
# configuration to avoid reconnects in the future
'Migrate configuration/metadata/layout from
previous versions of git-svn',
\%remote_opts ],
'log' => [ \&Git::SVN::Log::cmd_show_log, 'Show commit logs', 'log' => [ \&Git::SVN::Log::cmd_show_log, 'Show commit logs',
{ 'limit=i' => \$Git::SVN::Log::limit, { 'limit=i' => \$Git::SVN::Log::limit,
'revision|r=s' => \$_revision, 'revision|r=s' => \$_revision,
@ -154,15 +158,16 @@ my %opts = %{$cmd{$cmd}->[2]} if (defined $cmd);
read_repo_config(\%opts); read_repo_config(\%opts);
my $rv = GetOptions(%opts, 'help|H|h' => \$_help, my $rv = GetOptions(%opts, 'help|H|h' => \$_help,
'version|V' => \$_version, 'version|V' => \$_version,
'id|i=s' => \$GIT_SVN); 'id|i=s' => \$Git::SVN::default_repo_id);
exit 1 if (!$rv && $cmd ne 'log'); exit 1 if (!$rv && $cmd ne 'log');


usage(0) if $_help; usage(0) if $_help;
version() if $_version; version() if $_version;
usage(1) unless defined $cmd; usage(1) unless defined $cmd;
init_vars();
load_authors() if $_authors; load_authors() if $_authors;
migration_check() unless $cmd =~ /^(?:init|rebuild|multi-init|commit-diff)$/; unless ($cmd =~ /^(?:init|rebuild|multi-init|commit-diff)$/) {
Git::SVN::Migration::migration_check();
}
$cmd{$cmd}->[0]->(@ARGV); $cmd{$cmd}->[0]->(@ARGV);
exit 0; exit 0;


@ -203,17 +208,12 @@ sub version {


sub cmd_rebuild { sub cmd_rebuild {
my $url = shift; my $url = shift;
my $gs = $url ? Git::SVN->init(undef, $url) my $gs = $url ? Git::SVN->init($url)
: eval { Git::SVN->new }; : eval { Git::SVN->new };
$gs ||= Git::SVN->_new; $gs ||= Git::SVN->_new;
if (!verify_ref($gs->refname.'^0')) { if (!verify_ref($gs->refname.'^0')) {
$gs->copy_remote_ref; $gs->copy_remote_ref;
} }
if ($_upgrade) {
command_noisy('update-ref',$gs->refname, $gs->{id}.'-HEAD');
} else {
$gs->check_upgrade_needed;
}


my ($rev_list, $ctx) = command_output_pipe("rev-list", $gs->refname); my ($rev_list, $ctx) = command_output_pipe("rev-list", $gs->refname);
my $latest; my $latest;
@ -238,7 +238,7 @@ sub cmd_rebuild {
if (!$gs->{url} && !$url) { if (!$gs->{url} && !$url) {
fatal "SVN repository location required\n"; fatal "SVN repository location required\n";
} }
$gs = Git::SVN->init(undef, $url); $gs = Git::SVN->init($url);
$latest = $rev; $latest = $rev;
} }
$gs->rev_db_set($rev, $c); $gs->rev_db_set($rev, $c);
@ -268,7 +268,7 @@ sub cmd_init {
} }
do_git_init_db(); do_git_init_db();


Git::SVN->init(undef, $url); Git::SVN->init($url);
} }


sub cmd_fetch { sub cmd_fetch {
@ -389,28 +389,35 @@ sub cmd_multi_init {
} }
do_git_init_db(); do_git_init_db();
$_prefix = '' unless defined $_prefix; $_prefix = '' unless defined $_prefix;
$url =~ s#/+$## if defined $url;
if (defined $_trunk) { if (defined $_trunk) {
my $gs_trunk = eval { Git::SVN->new($_prefix . 'trunk') }; my $trunk_ref = $_prefix . 'trunk';
# try both old-style and new-style lookups:
my $gs_trunk = eval { Git::SVN->new($trunk_ref) };
unless ($gs_trunk) { unless ($gs_trunk) {
my $trunk_url = complete_svn_url($url, $_trunk); my ($trunk_url, $trunk_path) =
$gs_trunk = Git::SVN->init($_prefix . 'trunk', complete_svn_url($url, $_trunk);
$trunk_url); $gs_trunk = Git::SVN->init($trunk_url, $trunk_path,
command_noisy('config', 'svn.trunk', $trunk_url); undef, $trunk_ref);
} }
} }
return unless defined $_branches || defined $_tags;
my $ra = $url ? Git::SVN::Ra->new($url) : undef; my $ra = $url ? Git::SVN::Ra->new($url) : undef;
complete_url_ls_init($ra, $_branches, '--branches/-b', $_prefix); complete_url_ls_init($ra, $_branches, '--branches/-b', $_prefix);
complete_url_ls_init($ra, $_tags, '--tags/-t', $_prefix . 'tags/'); complete_url_ls_init($ra, $_tags, '--tags/-t', $_prefix . 'tags/');
} }


sub cmd_multi_fetch { sub cmd_multi_fetch {
# try to do trunk first, since branches/tags my @gs;
# may be descended from it. foreach (command(qw/config -l/)) {
if (-e "$ENV{GIT_DIR}/svn/trunk/info/url") { next unless m!^svn-remote\.(.+)\.fetch=
my $gs = Git::SVN->new('trunk'); \s*(.*)\s*:\s*refs/remotes/(.+)\s*$!x;
$gs->fetch(@_); my ($repo_id, $path, $ref_id) = ($1, $2, $3);
push @gs, Git::SVN->new($ref_id, $repo_id, $path);
}
foreach (@gs) {
$_->fetch;
} }
rec_fetch('', "$ENV{GIT_DIR}/svn", @_);
} }


# this command is special because it requires no metadata # this command is special because it requires no metadata
@ -464,95 +471,50 @@ sub cmd_commit_diff {


########################### utility functions ######################### ########################### utility functions #########################


sub rec_fetch {
my ($pfx, $p, @args) = @_;
my @dir;
foreach (sort <$p/*>) {
if (-r "$_/info/url") {
$pfx .= '/' if $pfx && $pfx !~ m!/$!;
my $id = $pfx . basename $_;
next if $id eq 'trunk';
my $gs = Git::SVN->new($id);
$gs->fetch(@args);
} elsif (-d $_) {
push @dir, $_;
}
}
foreach (@dir) {
my $x = $_;
$x =~ s!^\Q$ENV{GIT_DIR}\E/svn/!!o;
rec_fetch($x, $_, @args);
}
}

sub complete_svn_url { sub complete_svn_url {
my ($url, $path) = @_; my ($url, $path) = @_;
$path =~ s#/+$##; $path =~ s#/+$##;
$url =~ s#/+$## if $url;
if ($path !~ m#^[a-z\+]+://#) { if ($path !~ m#^[a-z\+]+://#) {
$path = '/' . $path if ($path !~ m#^/#);
if (!defined $url || $url !~ m#^[a-z\+]+://#) { if (!defined $url || $url !~ m#^[a-z\+]+://#) {
fatal("E: '$path' is not a complete URL ", fatal("E: '$path' is not a complete URL ",
"and a separate URL is not specified\n"); "and a separate URL is not specified\n");
} }
$path = $url . $path; return ($url, $path);
} }
return $path; return ($path, '');
} }


sub complete_url_ls_init { sub complete_url_ls_init {
my ($ra, $path, $switch, $pfx) = @_; my ($ra, $repo_path, $switch, $pfx) = @_;
unless ($path) { unless ($repo_path) {
print STDERR "W: $switch not specified\n"; print STDERR "W: $switch not specified\n";
return; return;
} }
$path =~ s#/+$##; $repo_path =~ s#/+$##;
if ($path =~ m#^[a-z\+]+://#) { if ($repo_path =~ m#^[a-z\+]+://#) {
$ra = Git::SVN::Ra->new($path); $ra = Git::SVN::Ra->new($repo_path);
$path = ''; $repo_path = '';
} else { } else {
$path =~ s#^/+##; $repo_path =~ s#^/+##;
unless ($ra) { unless ($ra) {
fatal("E: '$path' is not a complete URL ", fatal("E: '$repo_path' is not a complete URL ",
"and a separate URL is not specified\n"); "and a separate URL is not specified\n");
} }
} }
my $r = defined $_revision ? $_revision : $ra->get_latest_revnum; my $r = defined $_revision ? $_revision : $ra->get_latest_revnum;
my ($dirent, undef, undef) = $ra->get_dir($path, $r); my ($dirent, undef, undef) = $ra->get_dir($repo_path, $r);
my $url = $ra->{url} . (length $path ? "/$path" : ''); my $url = $ra->{url};
foreach my $d (sort keys %$dirent) { foreach my $d (sort keys %$dirent) {
next if ($dirent->{$d}->kind != $SVN::Node::dir); next if ($dirent->{$d}->kind != $SVN::Node::dir);
my $u = "$url/$d"; my $path = "$repo_path/$d";
my $id = "$pfx$d"; my $ref = "$pfx$d";
my $gs = eval { Git::SVN->new($id) }; my $gs = eval { Git::SVN->new($ref) };
# don't try to init already existing refs # don't try to init already existing refs
unless ($gs) { unless ($gs) {
print "init $u => $id\n"; print "init $url/$path => $ref\n";
Git::SVN->init($id, $u); Git::SVN->init($url, $path, undef, $ref);
} }
} }
my ($n) = ($switch =~ /^--(\w+)/);
command_noisy('config', "svn.$n", $url);
}

sub common_prefix {
my $paths = shift;
my %common;
foreach (@$paths) {
my @tmp = split m#/#, $_;
my $p = '';
while (my $x = shift @tmp) {
$p .= "/$x";
$common{$p} ||= 0;
$common{$p}++;
}
}
foreach (sort {length $b <=> length $a} keys %common) {
if ($common{$_} == @$paths) {
return $_;
}
}
return '';
} }


sub verify_ref { sub verify_ref {
@ -561,34 +523,6 @@ sub verify_ref {
{ STDERR => 0 }); }; { STDERR => 0 }); };
} }


sub repo_path_split {
my $full_url = shift;
$full_url =~ s#/+$##;

foreach (@repo_path_split_cache) {
if ($full_url =~ s#$_##) {
my $u = $1;
$full_url =~ s#^/+##;
return ($u, $full_url);
}
}
my $tmp = Git::SVN::Ra->new($full_url);
return ($tmp->{repos_root}, $tmp->{svn_path});
}

sub setup_git_svn {
defined $SVN_URL or croak "SVN repository location required\n";
unless (-d $GIT_DIR) {
croak "GIT_DIR=$GIT_DIR does not exist!\n";
}
mkpath([$GIT_SVN_DIR]);
mkpath(["$GIT_SVN_DIR/info"]);
open my $fh, '>>',$REVDB or croak $!;
close $fh;
s_to_file($SVN_URL,"$GIT_SVN_DIR/info/url");

}

sub get_tree_from_treeish { sub get_tree_from_treeish {
my ($treeish) = @_; my ($treeish) = @_;
# $treeish can be a symbolic ref, too: # $treeish can be a symbolic ref, too:
@ -668,23 +602,6 @@ sub file_to_s {
return $ret; return $ret;
} }


sub check_upgrade_needed {
if (!-r $REVDB) {
-d $GIT_SVN_DIR or mkpath([$GIT_SVN_DIR]);
open my $fh, '>>',$REVDB or croak $!;
close $fh;
}
return unless eval {
command([qw/rev-parse --verify/,"$GIT_SVN-HEAD^0"],
{STDERR => 0});
};
my $head = eval { command('rev-parse',"refs/remotes/$GIT_SVN") };
if ($@ || !$head) {
print STDERR "Please run: $0 rebuild --upgrade\n";
exit 1;
}
}

# '<svn username> = real-name <email address>' mapping based on git-svnimport: # '<svn username> = real-name <email address>' mapping based on git-svnimport:
sub load_authors { sub load_authors {
open my $authors, '<', $_authors or die "Can't open $_authors $!\n"; open my $authors, '<', $_authors or die "Can't open $_authors $!\n";
@ -702,75 +619,9 @@ sub load_authors {
close $authors or croak $!; close $authors or croak $!;
} }


sub git_svn_each {
my $sub = shift;
foreach (command(qw/rev-parse --symbolic --all/)) {
next unless s#^refs/remotes/##;
chomp $_;
next unless -f "$GIT_DIR/svn/$_/info/url";
&$sub($_);
}
}

sub migrate_revdb {
git_svn_each(sub {
my $id = shift;
defined(my $pid = fork) or croak $!;
if (!$pid) {
$GIT_SVN = $ENV{GIT_SVN_ID} = $id;
init_vars();
exit 0 if -r $REVDB;
print "Upgrading svn => git mapping...\n";
-d $GIT_SVN_DIR or mkpath([$GIT_SVN_DIR]);
open my $fh, '>>',$REVDB or croak $!;
close $fh;
rebuild();
print "Done upgrading. You may now delete the ",
"deprecated $GIT_SVN_DIR/revs directory\n";
exit 0;
}
waitpid $pid, 0;
croak $? if $?;
});
}

sub migration_check {
migrate_revdb() unless (-e $REVDB);
return if (-d "$GIT_DIR/svn" || !-d $GIT_DIR);
print "Upgrading repository...\n";
unless (-d "$GIT_DIR/svn") {
mkdir "$GIT_DIR/svn" or croak $!;
}
print "Data from a previous version of git-svn exists, but\n\t",
"$GIT_SVN_DIR\n\t(required for this version ",
"($VERSION) of git-svn) does not.\n";

foreach my $x (command(qw/rev-parse --symbolic --all/)) {
next unless $x =~ s#^refs/remotes/##;
chomp $x;
next unless -f "$GIT_DIR/$x/info/url";
my $u = eval { file_to_s("$GIT_DIR/$x/info/url") };
next unless $u;
my $dn = dirname("$GIT_DIR/svn/$x");
mkpath([$dn]) unless -d $dn;
rename "$GIT_DIR/$x", "$GIT_DIR/svn/$x" or croak "$!: $x";
}
migrate_revdb() if (-d $GIT_SVN_DIR && !-w $REVDB);
print "Done upgrading.\n";
}

sub init_vars {
$GIT_SVN ||= $ENV{GIT_SVN_ID} || 'git-svn';
$Git::SVN::default = $GIT_SVN;
$GIT_SVN_DIR = "$GIT_DIR/svn/$GIT_SVN";
$REVDB = "$GIT_SVN_DIR/.rev_db";
$GIT_SVN_INDEX = "$GIT_SVN_DIR/index";
$SVN_URL = undef;
}

# convert GetOpt::Long specs for use by git-config # convert GetOpt::Long specs for use by git-config
sub read_repo_config { sub read_repo_config {
return unless -d $GIT_DIR; return unless -d $ENV{GIT_DIR};
my $opts = shift; my $opts = shift;
foreach my $o (keys %$opts) { foreach my $o (keys %$opts) {
my $v = $opts->{$o}; my $v = $opts->{$o};
@ -791,38 +642,6 @@ sub read_repo_config {
} }
} }


sub read_url_paths_all {
my ($l_map, $pfx, $p) = @_;
my @dir;
foreach (<$p/*>) {
if (-r "$_/info/url") {
$pfx .= '/' if $pfx && $pfx !~ m!/$!;
my $id = $pfx . basename $_;
my $url = file_to_s("$_/info/url");
my ($u, $p) = repo_path_split($url);
$l_map->{$u}->{$p} = $id;
} elsif (-d $_) {
push @dir, $_;
}
}
foreach (@dir) {
my $x = $_;
$x =~ s!^\Q$GIT_DIR\E/svn/!!o;
read_url_paths_all($l_map, $x, $_);
}
}

# this one only gets ids that have been imported, not new ones
sub read_url_paths {
my $l_map = {};
git_svn_each(sub { my $x = shift;
my $url = file_to_s("$GIT_DIR/svn/$x/info/url");
my ($u, $p) = repo_path_split($url);
$l_map->{$u}->{$p} = $x;
});
return $l_map;
}

sub extract_metadata { sub extract_metadata {
my $id = shift or return (undef, undef, undef); my $id = shift or return (undef, undef, undef);
my ($url, $rev, $uuid) = ($id =~ /^git-svn-id:\s(\S+?)\@(\d+) my ($url, $rev, $uuid) = ($id =~ /^git-svn-id:\s(\S+?)\@(\d+)
@ -866,7 +685,7 @@ sub tz_to_s_offset {
package Git::SVN; package Git::SVN;
use strict; use strict;
use warnings; use warnings;
use vars qw/$default/; use vars qw/$default_repo_id/;
use Carp qw/croak/; use Carp qw/croak/;
use File::Path qw/mkpath/; use File::Path qw/mkpath/;
use IPC::Open3; use IPC::Open3;
@ -882,28 +701,76 @@ BEGIN {
svn:entry:committed-date/; svn:entry:committed-date/;
} }


# we allow dashes, unlike remotes2config.sh
sub sanitize_remote_name {
my ($name) = @_;
$name =~ tr/A-Za-z0-9-/./c;
$name;
}

sub init { sub init {
my ($class, $id, $url) = @_; my ($class, $url, $path, $repo_id, $ref_id) = @_;
my $self = _new($class, $id); my $self = _new($class, $repo_id, $ref_id, $path);
mkpath(["$self->{dir}/info"]); mkpath([$self->{dir}]);
if (defined $url) { if (defined $url) {
$url =~ s!/+$!!; # strip trailing slash $url =~ s!/+$!!; # strip trailing slash
::s_to_file($url, "$self->{dir}/info/url"); my $orig_url = eval {
command_oneline('config', '--get',
"svn-remote.$repo_id.url")
};
if ($orig_url) {
if ($orig_url ne $url) {
die "svn-remote.$repo_id.url already set: ",
"$orig_url\nwanted to set to: $url\n";
}
} else {
command_noisy('config',
"svn-remote.$repo_id.url", $url);
}
command_noisy('config', '--add',
"svn-remote.$repo_id.fetch",
"$path:".$self->refname);
} }
$self->{url} = $url; $self->{url} = $url;
open my $fh, '>>', $self->{db_path} or croak $!; unless (-f $self->{db_path}) {
close $fh or croak $!; open my $fh, '>>', $self->{db_path} or croak $!;
close $fh or croak $!;
}
$self; $self;
} }


sub find_ref {
my ($ref_id) = @_;
foreach (command(qw/config -l/)) {
next unless m!^svn-remote\.(.+)\.fetch=
\s*(.*)\s*:\s*refs/remotes/(.+)\s*$!x;
my ($repo_id, $path, $ref) = ($1, $2, $3);
if ($ref eq $ref_id) {
$path = '' if ($path =~ m#^\./?#);
return ($repo_id, $path);
}
}
(undef, undef, undef);
}

sub new { sub new {
my ($class, $id) = @_; my ($class, $ref_id, $repo_id, $path) = @_;
my $self = _new($class, $id); if (defined $ref_id && !defined $repo_id && !defined $path) {
$self->{url} = ::file_to_s("$self->{dir}/info/url"); ($repo_id, $path) = find_ref($ref_id);
if (!defined $repo_id) {
die "Could not find a \"svn-remote.*.fetch\" key ",
"in the repository configuration matching: ",
"refs/remotes/$ref_id\n";
}
}
my $self = _new($class, $repo_id, $ref_id, $path);
$self->{url} = command_oneline('config', '--get',
"svn-remote.$repo_id.url") or
die "Failed to read \"svn-remote.$repo_id.url\" in config\n";
$self; $self;
} }


sub refname { "refs/remotes/$_[0]->{id}" } sub refname { "refs/remotes/$_[0]->{ref_id}" }


sub ra { sub ra {
my ($self) = shift; my ($self) = shift;
@ -952,7 +819,7 @@ sub last_rev_commit {
return ($self->{last_rev}, $self->{last_commit}); return ($self->{last_rev}, $self->{last_commit});
} }
my $c = ::verify_ref($self->refname.'^0'); my $c = ::verify_ref($self->refname.'^0');
if (defined $c && length $c) { if ($c) {
my $rev = (::cmt_metadata($c))[1]; my $rev = (::cmt_metadata($c))[1];
if (defined $rev) { if (defined $rev) {
($self->{last_rev}, $self->{last_commit}) = ($rev, $c); ($self->{last_rev}, $self->{last_commit}) = ($rev, $c);
@ -1064,18 +931,9 @@ sub get_commit_parents {
@ret; @ret;
} }


sub check_upgrade_needed { sub full_url {
my ($self) = @_; my ($self) = @_;
if (!-r $self->{db_path}) { $self->ra->{url} . (length $self->{path} ? '/' . $self->{path} : '');
-d $self->{dir} or mkpath([$self->{dir}]);
open my $fh, '>>', $self->{db_path} or croak $!;
close $fh;
}
return unless ::verify_ref($self->{id}.'-HEAD^0');
my $head = ::verify_ref($self->refname.'^0');
if ($@ || !$head) {
::fatal("Please run: $0 rebuild --upgrade\n");
}
} }


sub do_git_commit { sub do_git_commit {
@ -1105,7 +963,7 @@ sub do_git_commit {
defined(my $pid = open3(my $msg_fh, my $out_fh, '>&STDERR', @exec)) defined(my $pid = open3(my $msg_fh, my $out_fh, '>&STDERR', @exec))
or croak $!; or croak $!;
print $msg_fh $log_entry->{log} or croak $!; print $msg_fh $log_entry->{log} or croak $!;
print $msg_fh "\ngit-svn-id: ", $self->ra->{url}, '@', print $msg_fh "\ngit-svn-id: ", $self->full_url, '@',
$log_entry->{revision}, ' ', $log_entry->{revision}, ' ',
$self->ra->uuid, "\n" or croak $!; $self->ra->uuid, "\n" or croak $!;
$msg_fh->flush == 0 or croak $!; $msg_fh->flush == 0 or croak $!;
@ -1128,7 +986,7 @@ sub do_git_commit {
} }


sub do_fetch { sub do_fetch {
my ($self, $paths, $rev) = @_; #, $author, $date, $log) = @_; my ($self, $paths, $rev) = @_;
my $ed = SVN::Git::Fetcher->new($self); my $ed = SVN::Git::Fetcher->new($self);
my ($last_rev, @parents); my ($last_rev, @parents);
if ($self->{last_commit}) { if ($self->{last_commit}) {
@ -1138,7 +996,8 @@ sub do_fetch {
} else { } else {
$last_rev = $rev; $last_rev = $rev;
} }
unless ($self->ra->gs_do_update($last_rev, $rev, '', 1, $ed)) { unless ($self->ra->gs_do_update($last_rev, $rev,
$self->{path}, 1, $ed)) {
die "SVN connection failed somewhere...\n"; die "SVN connection failed somewhere...\n";
} }
$self->make_log_entry($rev, \@parents, $ed); $self->make_log_entry($rev, \@parents, $ed);
@ -1361,11 +1220,19 @@ sub rev_db_get {
} }


sub _new { sub _new {
my ($class, $id) = @_; my ($class, $repo_id, $ref_id, $path) = @_;
$id ||= $Git::SVN::default; unless (defined $repo_id && length $repo_id) {
my $dir = "$ENV{GIT_DIR}/svn/$id"; $repo_id = $Git::SVN::default_repo_id;
bless { id => $id, dir => $dir, index => "$dir/index", }
db_path => "$dir/.rev_db" }, $class; unless (defined $ref_id && length $ref_id) {
$_[2] = $ref_id = $repo_id;
}
$_[1] = $repo_id = sanitize_remote_name($repo_id);
my $dir = "$ENV{GIT_DIR}/svn/$ref_id";
$_[3] = $path = '' unless (defined $path);
bless { ref_id => $ref_id, dir => $dir, index => "$dir/index",
path => $path,
db_path => "$dir/.rev_db", repo_id => $repo_id }, $class;
} }


sub uri_encode { sub uri_encode {
@ -1630,6 +1497,9 @@ sub new {
my $self = SVN::Delta::Editor->new; my $self = SVN::Delta::Editor->new;
bless $self, $class; bless $self, $class;
$self->{c} = $git_svn->{last_commit} if exists $git_svn->{last_commit}; $self->{c} = $git_svn->{last_commit} if exists $git_svn->{last_commit};
if (length $git_svn->{path}) {
$self->{path_strip} = qr/\Q$git_svn->{path}\E\/?/;
}
$self->{empty} = {}; $self->{empty} = {};
$self->{dir_prop} = {}; $self->{dir_prop} = {};
$self->{file_prop} = {}; $self->{file_prop} = {};
@ -1650,33 +1520,41 @@ sub open_directory {
{ path => $path }; { path => $path };
} }


sub git_path {
my ($self, $path) = @_;
$path =~ s!$self->{path_strip}!! if $self->{path_strip};
$path;
}

sub delete_entry { sub delete_entry {
my ($self, $path, $rev, $pb) = @_; my ($self, $path, $rev, $pb) = @_;
my $gui = $self->{gui}; my $gui = $self->{gui};


my $gpath = $self->git_path($path);
# remove entire directories. # remove entire directories.
if (command('ls-tree', $self->{c}, '--', $path) =~ /^040000 tree/) { if (command('ls-tree', $self->{c}, '--', $gpath) =~ /^040000 tree/) {
my ($ls, $ctx) = command_output_pipe(qw/ls-tree my ($ls, $ctx) = command_output_pipe(qw/ls-tree
-r --name-only -z/, -r --name-only -z/,
$self->{c}, '--', $path); $self->{c}, '--', $gpath);
local $/ = "\0"; local $/ = "\0";
while (<$ls>) { while (<$ls>) {
print $gui '0 ',0 x 40,"\t",$_ or croak $!; print $gui '0 ',0 x 40,"\t",$_ or croak $!;
print "\tD\t$_\n" unless $self->{q}; print "\tD\t$_\n" unless $self->{q};
} }
print "\tD\t$path/\n" unless $self->{q}; print "\tD\t$gpath/\n" unless $self->{q};
command_close_pipe($ls, $ctx); command_close_pipe($ls, $ctx);
$self->{empty}->{$path} = 0 $self->{empty}->{$path} = 0
} else { } else {
print $gui '0 ',0 x 40,"\t",$path,"\0" or croak $!; print $gui '0 ',0 x 40,"\t",$gpath,"\0" or croak $!;
print "\tD\t$path\n" unless $self->{q}; print "\tD\t$gpath\n" unless $self->{q};
} }
undef; undef;
} }


sub open_file { sub open_file {
my ($self, $path, $pb, $rev) = @_; my ($self, $path, $pb, $rev) = @_;
my ($mode, $blob) = (command('ls-tree', $self->{c}, '--',$path) my $gpath = $self->git_path($path);
my ($mode, $blob) = (command('ls-tree', $self->{c}, '--', $gpath)
=~ /^(\d{6}) blob ([a-f\d]{40})\t/); =~ /^(\d{6}) blob ([a-f\d]{40})\t/);
unless (defined $mode && defined $blob) { unless (defined $mode && defined $blob) {
die "$path was not found in commit $self->{c} (r$rev)\n"; die "$path was not found in commit $self->{c} (r$rev)\n";
@ -1775,7 +1653,7 @@ sub apply_textdelta {
sub close_file { sub close_file {
my ($self, $fb, $exp) = @_; my ($self, $fb, $exp) = @_;
my $hash; my $hash;
my $path = $fb->{path}; my $path = $self->git_path($fb->{path});
if (my $fh = $fb->{fh}) { if (my $fh = $fb->{fh}) {
seek($fh, 0, 0) or croak $!; seek($fh, 0, 0) or croak $!;
my $md5 = Digest::MD5->new; my $md5 = Digest::MD5->new;
@ -2223,7 +2101,7 @@ sub gs_do_update {
$editor, $pool); $editor, $pool);
my @lock = $SVN::Core::VERSION ge '1.2.0' ? (undef) : (); my @lock = $SVN::Core::VERSION ge '1.2.0' ? (undef) : ();
my $new = ($rev_a == $rev_b); my $new = ($rev_a == $rev_b);
$reporter->set_path($path, $rev_a, $new, @lock, $pool); $reporter->set_path('', $rev_a, $new, @lock, $pool);
$reporter->finish_report($pool); $reporter->finish_report($pool);
$pool->clear; $pool->clear;
$editor->{git_commit_ok}; $editor->{git_commit_ok};
@ -2561,6 +2439,153 @@ out:
print '-' x72,"\n" unless $incremental || $oneline; print '-' x72,"\n" unless $incremental || $oneline;
} }


package Git::SVN::Migration;
# these version numbers do NOT correspond to actual version numbers
# of git nor git-svn. They are just relative.
#
# v0 layout: .git/$id/info/url, refs/heads/$id-HEAD
#
# v1 layout: .git/$id/info/url, refs/remotes/$id
#
# v2 layout: .git/svn/$id/info/url, refs/remotes/$id
#
# v3 layout: .git/svn/$id, refs/remotes/$id
# - info/url may remain for backwards compatibility
# - this is what we migrate up to this layout automatically,
# - this will be used by git svn init on single branches
#
# v4 layout: .git/svn/$repo_id/$id, refs/remotes/$repo_id/$id
# - this is only created for newly multi-init-ed
# repositories. Similar in spirit to the
# --use-separate-remotes option in git-clone (now default)
# - we do not automatically migrate to this (following
# the example set by core git)
use strict;
use warnings;
use Carp qw/croak/;
use File::Path qw/mkpath/;
use File::Basename qw/dirname/;

sub migrate_from_v0 {
my $git_dir = $ENV{GIT_DIR};
return undef unless -d $git_dir;
my ($fh, $ctx) = command_output_pipe(qw/rev-parse --symbolic --all/);
my $migrated = 0;
while (<$fh>) {
chomp;
my ($id, $orig_ref) = ($_, $_);
next unless $id =~ s#^refs/heads/(.+)-HEAD$#$1#;
next unless -f "$git_dir/$id/info/url";
my $new_ref = "refs/remotes/$id";
if (::verify_ref("$new_ref^0")) {
print STDERR "W: $orig_ref is probably an old ",
"branch used by an ancient version of ",
"git-svn.\n",
"However, $new_ref also exists.\n",
"We will not be able ",
"to use this branch until this ",
"ambiguity is resolved.\n";
next;
}
print STDERR "Migrating from v0 layout...\n" if !$migrated;
print STDERR "Renaming ref: $orig_ref => $new_ref\n";
command_noisy('update-ref', $new_ref, $orig_ref);
command_noisy('update-ref', '-d', $orig_ref, $orig_ref);
$migrated++;
}
command_close_pipe($fh, $ctx);
print STDERR "Done migrating from v0 layout...\n" if $migrated;
$migrated;
}

sub migrate_from_v1 {
my $git_dir = $ENV{GIT_DIR};
my $migrated = 0;
return $migrated unless -d $git_dir;
my $svn_dir = "$git_dir/svn";

# just in case somebody used 'svn' as their $id at some point...
return $migrated if -d $svn_dir && ! -f "$svn_dir/info/url";

print STDERR "Migrating from a git-svn v1 layout...\n";
mkpath([$svn_dir]);
print STDERR "Data from a previous version of git-svn exists, but\n\t",
"$svn_dir\n\t(required for this version ",
"($::VERSION) of git-svn) does not. exist\n";
my ($fh, $ctx) = command_output_pipe(qw/rev-parse --symbolic --all/);
while (<$fh>) {
my $x = $_;
next unless $x =~ s#^refs/remotes/##;
chomp $x;
next unless -f "$git_dir/$x/info/url";
my $u = eval { ::file_to_s("$git_dir/$x/info/url") };
next unless $u;
my $dn = dirname("$git_dir/svn/$x");
mkpath([$dn]) unless -d $dn;
if ($x eq 'svn') { # they used 'svn' as GIT_SVN_ID:
mkpath(["$git_dir/svn/svn"]);
print STDERR " - $git_dir/$x/info => ",
"$git_dir/svn/$x/info\n";
rename "$git_dir/$x/info", "$git_dir/svn/$x/info" or
croak "$!: $x";
# don't worry too much about these, they probably
# don't exist with repos this old (save for index,
# and we can easily regenerate that)
foreach my $f (qw/unhandled.log index .rev_db/) {
rename "$git_dir/$x/$f", "$git_dir/svn/$x/$f";
}
} else {
print STDERR " - $git_dir/$x => $git_dir/svn/$x\n";
rename "$git_dir/$x", "$git_dir/svn/$x" or
croak "$!: $x";
}
$migrated++;
}
command_close_pipe($fh, $ctx);
print STDERR "Done migrating from a git-svn v1 layout\n";
$migrated;
}

sub read_old_urls {
my ($l_map, $pfx, $path) = @_;
my @dir;
foreach (<$path/*>) {
if (-r "$_/info/url") {
$pfx .= '/' if $pfx && $pfx !~ m!/$!;
my $ref_id = $pfx . basename $_;
my $url = ::file_to_s("$_/info/url");
$l_map->{$ref_id} = $url;
} elsif (-d $_) {
push @dir, $_;
}
}
foreach (@dir) {
my $x = $_;
$x =~ s!^\Q$ENV{GIT_DIR}\E/svn/!!o;
read_old_urls($l_map, $x, $_);
}
}

sub migrate_from_v2 {
my @cfg = command(qw/config -l/);
return if grep /^svn-remote\..+\.url=/, @cfg;
my %l_map;
read_old_urls(\%l_map, '', "$ENV{GIT_DIR}/svn");
my $migrated = 0;

foreach my $ref_id (sort keys %l_map) {
Git::SVN->init($l_map{$ref_id}, $ref_id);
$migrated++;
}
$migrated;
}

sub migration_check {
migrate_from_v0();
migrate_from_v1();
migrate_from_v2();
}

__END__ __END__


Data structures: Data structures:

63
t/t9107-git-svn-migrate.sh Executable file
View File

@ -0,0 +1,63 @@
#!/bin/sh
# Copyright (c) 2006 Eric Wong
test_description='git-svn metadata migrations from previous versions'
. ./lib-git-svn.sh

test_expect_success 'setup old-looking metadata' "
cp $GIT_DIR/config $GIT_DIR/config-old-git-svn &&
git-svn init $svnrepo &&
git-svn fetch &&
for i in trunk branches/a branches/b tags/0.1 tags/0.2 tags/0.3; do
mkdir -p \$i && echo hello >> \$i/README || exit 1; done &&
git ls-files -o trunk branches tags | git update-index --add --stdin &&
git commit -m 'test' &&
git-svn dcommit &&
mv $GIT_DIR/svn/* $GIT_DIR/ &&
rmdir $GIT_DIR/svn &&
git-update-ref refs/heads/git-svn-HEAD refs/remotes/git-svn &&
git-update-ref refs/heads/svn-HEAD refs/remotes/git-svn &&
git-update-ref -d refs/remotes/git-svn refs/remotes/git-svn
"

head=`git rev-parse --verify refs/heads/git-svn-HEAD^0`
test_expect_success 'git-svn-HEAD is a real HEAD' "test -n '$head'"

test_expect_success 'initialize old-style (v0) git-svn layout' "
mkdir -p $GIT_DIR/git-svn/info $GIT_DIR/svn/info &&
echo $svnrepo > $GIT_DIR/git-svn/info/url &&
echo $svnrepo > $GIT_DIR/svn/info/url &&
git-svn migrate &&
! test -d $GIT_DIR/git-svn &&
git-rev-parse --verify refs/remotes/git-svn^0 &&
git-rev-parse --verify refs/remotes/svn^0 &&
test \`git repo-config --get svn-remote.git-svn.url\` = '$svnrepo' &&
test \`git repo-config --get svn-remote.git-svn.fetch\` = \
':refs/remotes/git-svn'
"

test_expect_success 'initialize a multi-repository repo' "
git-svn multi-init $svnrepo -T trunk -t tags -b branches &&
git-repo-config --get-all svn-remote.git-svn.fetch > fetch.out &&
grep '^trunk:refs/remotes/trunk$' fetch.out &&
grep '^branches/a:refs/remotes/a$' fetch.out &&
grep '^branches/b:refs/remotes/b$' fetch.out &&
grep '^tags/0\.1:refs/remotes/tags/0\.1$' fetch.out &&
grep '^tags/0\.2:refs/remotes/tags/0\.2$' fetch.out &&
grep '^tags/0\.3:refs/remotes/tags/0\.3$' fetch.out
"

test_expect_success 'multi-fetch works on partial urls + paths' "
git-svn multi-fetch &&
for i in trunk a b tags/0.1 tags/0.2 tags/0.3; do
git rev-parse --verify refs/remotes/\$i^0 >> refs.out || exit 1;
done &&
test -z \"\`sort < refs.out | uniq -d\`\" &&
for i in trunk a b tags/0.1 tags/0.2 tags/0.3; do
for j in trunk a b tags/0.1 tags/0.2 tags/0.3; do
if test \$j != \$i; then continue; fi
test -z \"\`git diff refs/remotes/\$i \
refs/remotes/\$j\`\" ||exit 1; done; done
"

test_done