git2svn

   1 #!/usr/bin/perl
   2 #
   3 #    git2svn, converts a git branch to a svn ditto
   4 #    Copyright (C) 2008  Love Hörnquist Åstrand
   5 #
   6 #    This program is free software: you can redistribute it and/or modify
   7 #    it under the terms of the GNU General Public License as published by
   8 #    the Free Software Foundation, either version 3 of the License, or
   9 #    (at your option) any later version.
  10 #
  11 #    This program is distributed in the hope that it will be useful,
  12 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 #    GNU General Public License for more details.
  15 #
  16 #    You should have received a copy of the GNU General Public License
  17 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 use strict;
  20 use POSIX qw(strftime);
  21 use Getopt::Long qw/:config gnu_getopt no_ignore_case auto_abbrev/;
  22 use Pod::Usage;
  23
  24 my $IN;
  25 my $OUT;
  26
  27 my ($help, $verbose, $keeplogs, $no_load);
  28
  29 # svn
  30 my $svntree = "repro";
  31 my $basedir = "trunk";
  32 my $revision = 1;
  33
  34 # git
  35 my $branch = "master";
  36 my $syncname;
  37 my $masterrev;
  38 my $fexport;
  39
  40 my %blob;
  41 my %paths;
  42
  43 sub read_data
  44 {
  45     my ($IN, $next, $length, $data, $l) = (shift, shift);
  46     unless($next =~ m/^data (\d+)/) { die "missing data: $next" ; }
  47     $length = $1;
  48
  49     $l = read(IN, $data, $length);
  50     unless ($l == $length) { die "failed to read data $l != $length"; }
  51     $data = "" if ($length == 0);
  52     return $data;
  53 }
  54
  55 sub prop
  56 {
  57     my ($key, $value) = (shift, shift);
  58     "K " . length($key) . "\n$key\nV " . length($value) . "\n$value\n";
  59 }
  60
  61 sub parse_svn_tree
  62 {
  63     my $url = shift;
  64     my ($SVN, $type, $name);
  65
  66     open(SVN, "svn ls -R $url|") or die "failed to open svn ls -R $url";
  67     while (<SVN>) {
  68         chomp;
  69         if (m@/?(.*)/$@) {
  70             $type = 1;
  71             $name = "$1";
  72         } else {
  73             $type = 2;
  74             $name = "$_";
  75         }
  76         $paths{$name} = $type;
  77     }
  78     close SVN;
  79
  80     open(SVN, "svn info $url|") or die "failed to open svn info $url";
  81     while (<SVN>) {
  82         chomp;
  83         if ($revision eq 1 && /^Revision: (\d+)/) {
  84             $revision = $1 + 1;
  85         }
  86     }
  87     close SVN;
  88 }
  89
  90 sub find_branch_id
  91 {
  92     my ($gittree, $name) = (shift, shift);
  93
  94     my $GIT;
  95
  96     open FOO, "cd $gittree ".
  97         "&& git rev-parse $name 2>/dev/null|" or
  98         die "git rev-parse $name failed";
  99
 100     my $id = <FOO>;
 101     close GIT;
 102     chomp($id);
 103     $id = "" if ($id eq $name);
 104     return $id;
 105 }
 106
 107 sub parse_git_tree
 108 {
 109     my ($gittree, $branch, $shortbranch) = (shift, shift, shift);
 110
 111     $syncname = "git2svn-syncpoint-${shortbranch}";
 112     print STDERR "syncname tag: $syncname\n" if ($verbose);
 113
 114     $masterrev = find_branch_id($gittree, $branch);
 115     die "No head found for ${branch}" if ($masterrev eq "");
 116
 117     my $oldmasterrev = find_branch_id($gittree, $syncname);
 118
 119     if ($oldmasterrev ne "") {
 120
 121         die "no $svntree, but incremental (have synctag) ?\n".
 122             "(\"cd $gittree && git tag -d $syncname\" to remove)"
 123             unless ( -d $svntree);
 124
 125         if (${oldmasterrev} eq $masterrev) {
 126             print STDERR "nothing to sync, $syncname matches $branch\n"
 127                 if ($verbose);
 128             exit 0;
 129         }
 130
 131         $fexport = "$oldmasterrev..$masterrev";
 132     } else {
 133         $fexport="$masterrev";
 134
 135         system("svnadmin create ./$svntree") unless (-d $svntree);
 136     }
 137 }
 138
 139
 140 sub checkdirs
 141 {
 142     my $path = shift;
 143     my $base = "";
 144
 145     # pick first dir, create, take next dir, continue until we reached basename
 146     while ($path =~ m@^([^/]+)/(.*)$@) {
 147         my $first = $base . $1;
 148         $path = $2;
 149         $base = $first . "/";
 150         next if ($paths{$first});
 151
 152         $paths{$first} = 1;
 153
 154         printf OUT "Node-path: $first\n";
 155         printf OUT "Node-kind: dir\n";
 156         printf OUT "Node-action: add\n";
 157         printf OUT "Prop-content-length: 0\n";
 158         printf OUT "Content-length: 0\n";
 159         printf OUT "\n";
 160     }
 161 }
 162
 163 sub next_line
 164 {
 165     my $IN = shift;
 166     my $next = <IN>;
 167     chomp $next;
 168     return $next;
 169 }
 170
 171 #
 172 # This is to allow setting props for a path, XXX add configuration
 173 # file/options for this.
 174 #
 175
 176 sub auto_props
 177 {
 178     my $path = shift;
 179     ### given path, return prop("prop", "value")
 180     return "";
 181 }
 182
 183
 184 $|= 1;
 185
 186 my $result;
 187 $result = GetOptions ("git-branch=s" => \$branch,
 188                       "svn-prefix=s" => \$basedir,
 189                       "keep-logs" => \$keeplogs,
 190                       "no-load" => \$no_load,
 191                       "verbose+" => \$verbose,
 192                       "help" => \$help) or pod2usage(2);
 193
 194 pod2usage(0) if ($help);
 195
 196 die "to few arguments" if ($#ARGV < 1);
 197
 198 mkdir ".data" unless (-d ".data");
 199
 200 die "cant find branch name" unless ($branch =~ m@/?([^/]+)$@);
 201 my $shortbranch = $1;
 202
 203 my $gitdump = ".data/git.dump-${shortbranch}";
 204 my $svndump = ".data/svn.dump-${shortbranch}";
 205 my $log = ".data/log-${shortbranch}";
 206
 207 my $gittree = $ARGV[0];
 208 $svntree = $ARGV[1];
 209
 210 parse_git_tree($gittree, $branch, $shortbranch);
 211
 212 my $cwd = `pwd`;
 213 chomp($cwd);
 214 parse_svn_tree("file://" . $cwd ."/". $svntree);
 215
 216 system(">$log");
 217
 218 print STDERR "git fast-export $branch ($fexport)\n" if ($verbose);
 219
 220 system("(cd $gittree && git fast-export $fexport) > $gitdump 2>$log") == 0 or
 221     die "git fast-export: $!";
 222
 223 open IN, "$gitdump" or
 224     die "failed to open $gitdump";
 225
 226 open OUT, ">$svndump" or
 227     die "failed to open $svndump";
 228
 229 print STDERR "creating svn dump from revision $revision...\n" if ($verbose);
 230
 231 print OUT "SVN-fs-dump-format-version: 3\n";
 232
 233 my $next = next_line();
 234 COMMAND: while (!eof(IN)) {
 235     if ($next eq "") {
 236         $next = next_line($IN);
 237         next COMMAND;
 238     } elsif ($next =~ /^commit (.*)/) {
 239
 240         my %commit;
 241
 242         $next = next_line($IN);
 243         if ($next =~ m/mark +(.*)/) {
 244             $commit{Mark} = $1;
 245             $next = next_line($IN);
 246         }
 247         if ($next =~ m/author +(.*)/) {
 248             $commit{Author} = $1;
 249             $next = next_line($IN);
 250         }
 251         unless ($next =~ m/committer +(.+) +<([^>]+)> +(\d+) +[+-](\d+)$/) {
 252             die "missing comitter: $_";
 253         }
 254
 255         $commit{CommitterName} = $1;
 256         $commit{CommitterEmail} = $2;
 257         $commit{CommitterWhen} = $3;
 258         $commit{CommitterTZ} = $4;
 259
 260         $next = next_line($IN);
 261         my $log = read_data($IN, $next);
 262
 263         $next = next_line($IN);
 264         if ($next =~ m/from (.*)/) {
 265             $commit{From} = $1;
 266             $next = next_line($IN);
 267         }
 268         if ($next =~ m/merge (.*)/) {
 269             $commit{Merge} = $1;
 270             $next = next_line($IN);
 271         }
 272
 273         my $date =
 274             strftime("%Y-%m-%dT%H:%M:%S.000000Z",
 275                      gmtime($commit{CommitterWhen}));
 276
 277         my $author = "(no author)";
 278         if ($commit{CommitterEmail} =~ m/([^@]+)/) {
 279             $author = $1;
 280         }
 281         $author = "git2svn-dump" if ($author eq "(no author)");
 282
 283         my $props = "";
 284         $props .= prop("svn:author", $author);
 285         $props .= prop("svn:log", $log);
 286         $props .= prop("svn:date", $date);
 287         $props .= "PROPS-END";
 288
 289         # push out svn info
 290
 291         printf OUT "Revision-number: $revision\n"; $revision++;
 292         printf OUT "Prop-content-length: ". length($props) . "\n";
 293         printf OUT "Content-length: " . length($props) . "\n";
 294         printf OUT "\n";
 295         print OUT "$props\n";
 296
 297         while (1) {
 298             if ($next =~ m/M (\d+) (\S+) (.*)$/) {
 299                 my ($mode, $dataref, $path) = (oct $1, $2, $3);
 300                 my $content;
 301                 if ($dataref eq "inline") {
 302                     $next = next_line($IN);
 303                     $content = read_data($IN, $next);
 304                 } else {
 305                     die "Revision missing content ref $dataref"
 306                         unless(defined $blob{$dataref});
 307
 308                     $content = $blob{$dataref};
 309                     # here we really want to delete $blob{$dataref},
 310                     # but it might be referenced in the future. To
 311                     # avoid keepig everything in memory for larger
 312                     # repositories this must be written out to disk
 313                     # and removed when done.
 314                 }
 315
 316                 $path = "$basedir/$path";
 317                 checkdirs($path);
 318
 319                 my $action = "add";
 320
 321                 if ($paths{$path}) {
 322                     die "file was a dir" if ($paths{$path} != 2);
 323                     $action = "change";
 324                 } else {
 325                     $paths{$path} = 2;
 326                 }
 327
 328
 329                 my $type = $mode & 0777000;
 330                 my $kind = "";
 331                 $kind = "file" if ($type == 0100000);
 332                 $kind = "symlink" if ($type == 0120000);
 333                 die "$type unknown" if ($kind eq "");
 334
 335                 $props = "";
 336                 $props .= prop("svn:executable", "on") if ($mode & 0111);
 337                 $props .= prop("svn:special", "*") if ($kind eq "symlink");
 338                 $props .= auto_props($path);
 339                 $props .= "PROPS-END" if ($props ne "");
 340
 341                 $content = "link $content" if ($kind eq "symlink");
 342
 343                 my $plen = length($props);
 344                 my $clen = length($content);
 345
 346                 printf OUT "Node-path: $path\n";
 347                 printf OUT "Node-kind: file\n";
 348                 printf OUT "Node-action: $action\n";
 349                 printf OUT "Text-content-length: $clen\n";
 350                 printf OUT "Content-length: " . ($clen + $plen) . "\n";
 351                 printf OUT "Prop-content-length: $plen\n" if ($plen);
 352                 printf OUT "\n";
 353
 354                 print OUT "$props\n" if ($plen);
 355
 356                 print OUT $content;
 357                 printf OUT "\n";
 358             } elsif ($next =~ m/D (.*)/) {
 359                 my $path = $basedir . "/". $1;
 360
 361                 if ($paths{$path}) {
 362                     delete $paths{$path};
 363
 364                     printf OUT "Node-path: $path\n";
 365                     printf OUT "Node-action: delete\n";
 366                     printf OUT "\n";
 367                 } elsif ($verbose) {
 368                     print STDERR "deleting non existing object: $path\n";
 369                 }
 370
 371             } elsif ($next =~ m/^C (.*)/) {
 372                 die "file copy ?";
 373             } elsif ($next =~ m/^R (.*)/) {
 374                 die "file rename ?";
 375             } elsif ($next =~ m/^filedeleteall$/) {
 376                 die "file delete all ?";
 377             } else {
 378                 next COMMAND;
 379             }
 380             $next = next_line($IN);
 381         }
 382
 383     } elsif ($next =~ /^tag .*/) {
 384     } elsif ($next =~ /^reset .*/) {
 385     } elsif ($next =~ /^blob/) {
 386         my $mark = undef;
 387         $next = next_line($IN);
 388         if ($next =~ m/mark (.*)/) {
 389             $mark = $1;
 390             $next = next_line($IN);
 391         }
 392         my $data = read_data($IN, $next);
 393         $blob{$mark} = $data if (defined $mark);
 394     } elsif ($next =~ /^checkpoint .*/) {
 395     } elsif ($next =~ /^progress (.*)/) {
 396         print STDERR "progress: $1\n" if ($verbose);
 397     } else {
 398         die "unknown command $next";
 399     }
 400     $next = next_line($IN);
 401 }
 402
 403 close IN;
 404 close OUT;
 405
 406 print STDERR "...dumped to revision $revision\n" if ($verbose);
 407 print STDERR "(re-)setting sync-tag to new master\n" if ($verbose);
 408
 409 unless ($no_load) {
 410     system("cd $gittree && ".
 411            "git tag -m \"sync $(date)\" -a -f ${syncname} ${masterrev}");
 412 }
 413
 414 print STDERR "loading dump into svn\n" if ($verbose);
 415
 416 unless ($no_load) {
 417     system("svnadmin load $svntree < $svndump >>$log 2>&1") == 0 or
 418         die "svnadmin load";
 419 }
 420
 421 unlink $svndump, $gitdump, $log unless ($keeplogs);
 422
 423 exit 0;
 424
 425
 426 __END__
 427
 428 =head1 NAME
 429
 430 B<git2svn> - converts a git branch to a svn ditto
 431
 432 =head1 SYNOPSIS
 433
 434 B<git2svn> [options] git-repro svn-repro
 435
 436 =head1 OPTIONS
 437
 438 =over 8
 439
 440 =item B<--git-branch>
 441
 442 The git branch to export. The default is branch is master.
 443
 444 =item B<--svn-prefix>
 445
 446 The svn prefix where the branch is import. The default is trunk to
 447 match the default GIT branch (master).
 448
 449 =item B<--no-load>
 450
 451 Don't load the svn repository or update the syncpoint tagname.
 452
 453 =item B<--keep-logs>
 454
 455 Don't delete the logs in $CWD/.data on success.
 456
 457 =item B<--verbose>
 458
 459 More verbose output, can be give more then once to increase the verbosity.
 460
 461 =item B<--help>
 462
 463 Print a brief help message and exits.
 464
 465 =back
 466
 467 =head1 DESCRIPTION
 468
 469 B<git2svn> will convert a git branch to a svn ditto, it also
 470 support incremantal updates.
 471
 472 B<git2svn> takes a git fast-export dump and converts it into a
 473 svn dump that is feed into svnadmin load.
 474
 475 B<git2svn> assumes its the only process that writes into the svn
 476 repository. This is because of the race between getting the to svn
 477 Revsion number from the svn, creating the dump with correct Revsions,
 478 and do the svnadmin load.
 479
 480 B<git2svn> also support incremental updates from a git branch to
 481 a svn reprositry. Its does this by setting a git tag
 482 (git2svn-syncpoint-<branchname>) where the last update was pulled
 483 from.
 484
 485 B<git2svn> was created as a hack over a weekend to support a
 486 smoother migration away from svn and allow users access to tools to
 487 browse and search code (fisheye) and use anonymouns svn servers.
 488
 489 =head1 EXAMPLES
 490
 491         B<git2svn> ~/src/heimdal svn-repro
 492
 493         B<git2svn> --git-branch heimdal-1-0-branch \
 494              --svn-prefix branches/heimdal-1-0-branch \
 495              ~/src/heimdal svn-repro
 496
 497 =head1 DOWNLOAD
 498
 499 B<git2svn> is avaible from repo.or.cz
 500
 501         git clone git://repo.or.cz/git2svn.git
 502
 503 =head1 AUTHORS
 504
 505         Love Hörnquist Åstrand <lha@kth.se>
 506
 507 =head1 BUGS
 508
 509         Send bug reports to lha@kth.se
 510
 511 =cut