svn2cvs/trunk/svn2cvs.pl

#!/usr/bin/perl -w

# This script will transfer changes from Subversion repository
# to CVS repository (e.g. SourceForge) while preserving commit
# logs.
#
# Based on original shell version by Tollef Fog Heen available at
# http://raw.no/personal/blog
#
# 2004-03-09 Dobrica Pavlinusic <dpavlin@rot13.org>
#
# documentation is after __END__

use strict;
use File::Temp qw/ tempdir /;
use File::Path;
use Data::Dumper;
use XML::Simple;

# do we want to sync just part of repository?
my $partial_import = 1;

# do we want to add svk-like prefix with original revision, author and date?
my $decorate_commit_message = 1;

if (@ARGV < 2) {
        print "usage: $0 SVN_URL CVSROOT CVSREPOSITORY\n";
        exit 1;
}

my ($SVNROOT,$CVSROOT, $CVSREP) = @ARGV;

if ($SVNROOT !~ m,^[\w+]+:///*\w+,) {
        print "ERROR: invalid svn root $SVNROOT\n";
        exit 1;
}

# Ensure File::Temp::END can clean up:
$SIG{__DIE__} = sub { chdir("/tmp"); die @_ };

my $TMPDIR=tempdir( "/tmp/checkoutXXXXX", CLEANUP => 1 );

sub cd_tmp {
        chdir($TMPDIR) || die "can't cd to $TMPDIR: $!";
}

sub cd_rep {
        chdir("$TMPDIR/$CVSREP") || die "can't cd to $TMPDIR/$CVSREP: $!";
}

print "## using TMPDIR $TMPDIR\n";

# cvs command with root
my $cvs="cvs -f -d $CVSROOT";

# current revision in CVS
my $rev;

#
# sub to do logging and system calls
#
sub log_system($$) {
        my ($cmd,$errmsg) = @_;
        print STDERR "## $cmd\n";
        system($cmd) == 0 || die "$errmsg: $!";
}

#
# sub to commit .svn rev file later
#
sub commit_svnrev {
        my $rev = shift @_;
        my $add_new = shift @_;

        die "commit_svnrev needs revision" if (! defined($rev));

        open(SVNREV,"> .svnrev") || die "can't open $TMPDIR/$CVSREP/.svnrev: $!";
        print SVNREV $rev;
        close(SVNREV);

        my $path=".svnrev";

        if ($add_new) {
                system "$cvs add '$path'" || die "cvs add of $path failed: $!";
        } else {
                my $msg="subversion revision $rev commited to CVS";
                print "$msg\n";
                system "$cvs commit -m '$msg' '$path'" || die "cvs commit of $path failed: $!";
        }
}

sub add_dir($$) {
        my ($path,$msg) = @_;
        print "# add_dir($path)\n";
        die "add_dir($path) is not directory" unless (-d $path);

        my $curr_dir;

        foreach my $d (split(m#/#, $path)) {
                $curr_dir .= ( $curr_dir ? '/' : '') . $d;

                next if in_entries($curr_dir);
                next if (-e "$curr_dir/CVS");

                log_system("$cvs add '$curr_dir'", "cvs add of $curr_dir failed");
        }
}

# ok, now do the checkout
eval {
        cd_tmp;
        log_system("$cvs -q checkout $CVSREP", "cvs checkout failed");
};

if ($@) {
        print <<_NEW_REP_;

There is no CVS repository '$CVSREP' in your CVS. I will assume that
this is import of new module in your CVS and start from revision 0.

Press enter to continue importing new CVS repository or CTRL+C to abort.

_NEW_REP_

        print "start import of new module [yes]: ";
        my $in = <STDIN>;
        cd_tmp;
        mkdir($CVSREP) || die "can't create $CVSREP: $!";
        cd_rep;

        open(SVNREV,"> .svnrev") || die "can't open $CVSREP/.svnrev: $!";
        print SVNREV "0";
        close(SVNREV);

        $rev = 0;

        # create new module
        cd_rep;
        log_system("$cvs import -d -m 'new CVS module' $CVSREP svn r$rev", "import of new repository");
        cd_tmp;
        rmtree($CVSREP) || die "can't remove $CVSREP";
        log_system("$cvs -q checkout $CVSREP", "cvs checkout failed");
        cd_rep;

} else {
        # import into existing module directory in CVS

        cd_rep;
        # check if svnrev exists
        if (! -e ".svnrev") {
                print <<_USAGE_;

Your CVS repository doesn't have .svnrev file!

This file is used to keep CVS repository and Subversion in sync, so
that only newer changes will be commited.

It's quote possible that this is first svn2cvs run for this repository.
If so, you will have to identify correct svn revision which
corresponds to current version of CVS repository that has just
been checkouted.

If you migrated your cvs repository to svn using cvs2svn, this will be
last Subversion revision. If this is initial run of conversion of
Subversion repository to CVS, correct revision is 0.

_USAGE_

                print "svn revision corresponding to CVS [abort]: ";
                my $in = <STDIN>;
                chomp($in);
                if ($in !~ /^\d+$/) {
                        print "Aborting: revision not a number\n";
                        exit 1;
                } else {
                        $rev = $in;
                        commit_svnrev($rev,1);  # create new
                }
        } else {
                open(SVNREV,".svnrev") || die "can't open $TMPDIR/$CVSREP/.svnrev: $!";
                $rev = <SVNREV>;
                chomp($rev);
                close(SVNREV);
        }

        print "Starting after revision $rev\n";
        $rev++;
}


#
# FIXME!! HEAD should really be next verison and loop because this way we
# loose multiple edits of same file and corresponding messages. On the
# other hand, if you want to compress your traffic to CVS server and don't
# case much about accuracy and completnes of logs there, this might
# be good. YMMV
#
open(LOG, "svn log -r $rev:HEAD -v --xml $SVNROOT |") || die "svn log for repository $SVNROOT failed: $!";
my $log;
while(<LOG>) {
        $log .= $_;
}
close(LOG);


my $xml;
eval {
        $xml = XMLin($log, ForceArray => [ 'logentry', 'path' ]);
};


#=begin log_example
#
#------------------------------------------------------------------------
#r256 | dpavlin | 2004-03-09 13:18:17 +0100 (Tue, 09 Mar 2004) | 2 lines
#
#ported r254 from hidra branch
#
#=cut

my $fmt = "\n" . "-" x 79 . "\nr%5s| %8s | %s\n\n%s\n";

if (! $xml->{'logentry'}) {
        print "no newer log entries in Subversion repostory. CVS is current\n";
        exit 0;
}

# return all files in CVS/Entries
sub entries($) {
        my $dir = shift;
        die "entries expects directory argument!" unless -d $dir;
        my @entries;
        open(my $fh, "$dir/CVS/Entries") || return 0;
        while(<$fh>) {
                if ( m{^D/([^/]+)}, ) {
                        my $sub_dir = $1;
                        warn "#### entries recurse into: $dir/$sub_dir";
                        push @entries, map { "$sub_dir/$_" } entries("$dir/$sub_dir");
                        push @entries, $sub_dir;
                } elsif ( m{^/([^/]+)/} ) {
                        push @entries, $1;
                } elsif ( ! m{^D$} ) {
                        die "can't decode entries line: $_";
                }
        }
        close($fh);
        warn "#### entries($dir) => ",join("|",@entries);
        return @entries;
}

# check if file exists in CVS/Entries
sub in_entries($) {
        my $path = shift;
        if ($path =~ m,^(.*?/*)([^/]+)$,) {
                my ($dir,$file) = ($1,$2);
                if ($dir !~ m,/$, && $dir ne "") {
                        $dir .= "/";
                }

                open(my $fh, "$dir/CVS/Entries") || return 0; #die "no entries file: $dir/CVS/Entries";
                while(<$fh>) {
                        return 1 if (m{^/$file/});
                }
                close($fh);
                return 0;
        } else {
                die "can't split '$path' to dir and file!";
        }
}

cd_tmp;
cd_rep;

foreach my $e (@{$xml->{'logentry'}}) {
        die "BUG: revision from .svnrev ($rev) greater than from subversion (".$e->{'revision'}.")" if ($rev > $e->{'revision'});
        $rev = $e->{'revision'};
        log_system("svn export --force -q -r $rev $SVNROOT $TMPDIR/$CVSREP", "svn export of revision $rev failed");

        # deduce name of svn directory
        my $SVNREP = "";
        my $tmpsvn = $SVNROOT || die "BUG: SVNROOT empty!";
        my $tmppath = $e->{'paths'}->{'path'}->[0]->{'content'} || die "BUG: tmppath empty!";
        do {
                if ($tmpsvn =~ s#(/[^/]+)/*$##) {       # vim fix
                        $SVNREP = $1 . $SVNREP;
                } elsif ($e->{'paths'}->{'path'}->[0]->{'copyfrom-path'}) {
                        print "NOTICE: copyfrom outside synced repository ignored - skipping\n";
                        next;
                } else {
                        print "NOTICE: can't deduce svn dir from $SVNROOT - skipping\n";
                        next;
                }
        } until ($tmppath =~ m/^$SVNREP/);

        print "NOTICE: using $SVNREP as directory for svn\n";

        printf($fmt, $e->{'revision'}, $e->{'author'}, $e->{'date'}, $e->{'msg'});
        my @commit;

        my $msg = $e->{'msg'};
        $msg =~ s/'/'\\''/g;    # quote "

        $msg = 'r' . $rev . ' ' . $e->{author} . ' | ' . $e->{date} . "\n" . $msg if $decorate_commit_message;

        sub cvs_commit {
                my $msg = shift || die "no msg?";
                if ( ! @_ ) {
                        warn "commit ignored, no files\n";
                        return;
                }
                log_system("$cvs commit -m '$msg' '".join("' '",@_)."'", "cvs commit of ".join(",",@_)." failed");
        }

        foreach my $p (@{$e->{'paths'}->{'path'}}) {
                my ($action,$path) = ($p->{'action'},$p->{'content'});

                next if ($path =~ m#/\.svnrev$#);

                print "svn2cvs: $action $path\n";

                # prepare path and message
                my $file = $path;
                if ( $path !~ s#^\Q$SVNREP\E/*## ) {
                        print "NOTICE: skipping '$path' which isn't under repository root '$SVNREP'\n";
                        die unless $partial_import;
                        next;
                }

                if (! $path) {
                        print "NOTICE: skipped this operation. Probably trunk creation\n";
                        next;
                }

                my $msg = $e->{'msg'};
                $msg =~ s/'/'\\''/g;    # quote "

                sub add_path {
                        my $path = shift || die "no path?";
        
                        if (-d $path) {
                                add_dir($path, $msg);
                        } elsif ($path =~ m,^(.+)/[^/]+$, && ! -e "$1/CVS/Root") {
                                my $dir = $1;
                                in_entries($dir) || add_dir($dir, $msg);
                                in_entries($path) || log_system("$cvs add '$path'", "cvs add of $path failed");
                        } else {
                                in_entries($path) || log_system("$cvs add '$path'", "cvs add of $path failed");
                        }
                }

                if ($action =~ /M/) {
                        if ( in_entries( $path ) ) {
                                print "svn2cvs: modify $path -- nop\n";
                        } else {
                                print "WARNING: modify $path which isn't in CVS, adding...\n";
                                add_path($path);
                        }
                } elsif ($action =~ /A/) {
                        add_path($path);
                } elsif ($action =~ /D/) {
                        if (-e $path) {
                                if ( -d $path ) {
                                        warn "#### remove directory: $path";
                                        my @sub_commit;
                                        foreach my $f ( entries($path) ) {
                                                $f = "$path/$f";
                                        if ( -f $f ) {
                                                        unlink($f) || die "can't delete file $f: $!";
#                                               } else {
#                                                       rmtree($f) || die "can't delete dir $f: $!";
                                                }
                                                log_system("$cvs delete '$f'", "cvs delete of file $f failed");
                                                push @sub_commit, $f;
                                        }
                                        log_system("$cvs delete '$path'", "cvs delete of file $path failed");
                                        cvs_commit($msg, @sub_commit, $path);
                                        log_system("$cvs update -dP '$path'", "cvs update -dP $path failed");
                                } else {
                                        warn "#### remove file: $path";
                                        unlink($path) || die "can't delete $path: $!";
                                        log_system("$cvs delete '$path'", "cvs delete of dir $path failed");
                                }
                        } else {
                                print "WARNING: $path is not present, skipping...\n";
                                undef $path;
                        }
                } else {
                        print "WARNING: action $action not implemented on $path. Bug or missing feature of $0\n";
                }

                # save commits for later
                push @commit, $path if ($path);

        }

        # now commit changes
        cvs_commit($msg, @commit);

        commit_svnrev($rev);
}

# cd out of $CVSREP before File::Temp::END is called
chdir("/tmp") || die "can't cd to /tmp: $!";

__END__

=pod

=head1 NAME

svn2cvs - save subversion commits to (read-only) cvs repository

=head1 SYNOPSIS

  ./svn2cvs.pl SVN_URL CVSROOT CVSREPOSITORY

Usage example (used to self-host this script):

  ./svn2cvs.pl file:///home/dpavlin/private/svn/svn2cvs/trunk/ \
               :pserver:dpavlin@cvs.tigris.org:/cvs svn2cvs/src

=head1 DESCRIPTION

This script will allows you to commit changes made to Subversion repository to
(read-only) CVS repository manually or from Subversion's C<post-commit> hook.

It's using F<.svnrev> file (which will be created on first run) in 
B<CVSROOT/CVSREPOSITORY> to store last Subversion revision which was
committed into CVS.

One run will do following things:

=over 4

=item *
checkout B<CVSREPOSITORY> from B<CVSROOT> to temporary directory

=item *
check if F<.svnrev> file exists and create it if it doesn't

=item *
loop through all revisions from current in B<CVSROOT/CVSREPOSITORY> (using
F<.svnrev>) up to B<HEAD> (current one)

=over 5

=item *
checkout next Subversion revision from B<SVN_URL> over CVS checkout
temporary directory

=item *
make modification (add and/or delete) done in that revision

=item *
commit modification (added, deleted or modified files/dirs) while
preserving original message from CVS

=item *
update F<.svnrev> to match current revision

=back

=item *
cleanup temporary directory

=back

If checkout fails for some reason (e.g. flaky ssh connection), you will
still have valid CVS repository, so all you have to do is run B<svn2cvs.pl>
again.

=head1 WARNINGS

"Cheap" copy operations in Subversion are not at all cheap in CVS. They will
create multiple copies of files in CVS repository!

This script assume that you want to sync your C<trunk> (or any other
directory for that matter) directory with CVS, not root of your subversion.
This might be considered bug, but since common practise is to have
directories C<trunk> and C<branches> in svn and source code in them, it's
not serious limitation.

=head1 RELATED PROJECTS

B<Subversion> L<http://subversion.tigris.org/> version control system that is a
compelling replacement for CVS in the open source community.

B<cvs2svn> L<http://cvs2svn.tigris.org/> converts a CVS repository to a
Subversion repository. It is designed for one-time conversions, not for
repeated synchronizations between CVS and Subversion.

=head1 CHANGES

Versions of this utility are actually Subversion repository revisions,
so they might not be in sequence.

=over 3

=item r10

First release available to public

=item r15

Addition of comprehensive documentation, fixes for quoting in commit
messages, and support for skipping changes which are not under current
Subversion checkout root (e.g. branches).

=item r18

Support for importing your svn into empty CVS repository (it will first
create module and than dump all revisions).
Group commit operations to save round-trips to CVS server.
Documentation improvements and other small fixes.

=item r20

Fixed path deduction (overlap between Subversion reporistory and CVS checkout).

=item r21

Use C<update -d> instead of checkout after import.
Added fixes by Paul Egan <paulegan@mail.com> for XMLin and fixing working
directory.

=item r22

Rewritten import from revision 0 to empty repository, better importing
of deep directory structures, initial support for recovery from partial
commit.

=back

=head1 AUTHOR

Dobrica Pavlinusic <dpavlin@rot13.org>

L<https://www.rot13.org/~dpavlin/>

=head1 LICENSE

This product is licensed under GNU Public License (GPL) v2 or later.

=cut

1	dpavlin	1	#!/usr/bin/perl -w
2
3			# This script will transfer changes from Subversion repository
4			# to CVS repository (e.g. SourceForge) while preserving commit
5			# logs.
6			#
7			# Based on original shell version by Tollef Fog Heen available at
8			# http://raw.no/personal/blog
9			#
10			# 2004-03-09 Dobrica Pavlinusic <dpavlin@rot13.org>
11	dpavlin	12	#
12			# documentation is after __END__
13	dpavlin	1
14			use strict;
15			use File::Temp qw/ tempdir /;
16	dpavlin	21	use File::Path;
17	dpavlin	1	use Data::Dumper;
18			use XML::Simple;
19
20	dpavlin	27	# do we want to sync just part of repository?
21			my $partial_import = 1;
22
23	dpavlin	36	# do we want to add svk-like prefix with original revision, author and date?
24			my $decorate_commit_message = 1;
25
26	dpavlin	8	if (@ARGV < 2) {
27			print "usage: $0 SVN_URL CVSROOT CVSREPOSITORY\n";
28			exit 1;
29			}
30	dpavlin	1
31	dpavlin	8	my ($SVNROOT,$CVSROOT, $CVSREP) = @ARGV;
32	dpavlin	1
33	dpavlin	10	if ($SVNROOT !~ m,^[\w+]+:///*\w+,) {
34	dpavlin	8	print "ERROR: invalid svn root $SVNROOT\n";
35			exit 1;
36			}
37	dpavlin	7
38	dpavlin	21	# Ensure File::Temp::END can clean up:
39			$SIG{__DIE__} = sub { chdir("/tmp"); die @_ };
40
41	dpavlin	1	my $TMPDIR=tempdir( "/tmp/checkoutXXXXX", CLEANUP => 1 );
42
43	dpavlin	22	sub cd_tmp {
44			chdir($TMPDIR) \|\| die "can't cd to $TMPDIR: $!";
45			}
46	dpavlin	1
47	dpavlin	22	sub cd_rep {
48			chdir("$TMPDIR/$CVSREP") \|\| die "can't cd to $TMPDIR/$CVSREP: $!";
49			}
50
51			print "## using TMPDIR $TMPDIR\n";
52
53	dpavlin	1	# cvs command with root
54	dpavlin	28	my $cvs="cvs -f -d $CVSROOT";
55	dpavlin	1
56	dpavlin	22	# current revision in CVS
57			my $rev;
58
59	dpavlin	1	#
60			# sub to do logging and system calls
61			#
62			sub log_system($$) {
63			my ($cmd,$errmsg) = @_;
64			print STDERR "## $cmd\n";
65	dpavlin	8	system($cmd) == 0 \|\| die "$errmsg: $!";
66	dpavlin	1	}
67
68	dpavlin	3	#
69			# sub to commit .svn rev file later
70			#
71			sub commit_svnrev {
72			my $rev = shift @_;
73			my $add_new = shift @_;
74	dpavlin	1
75	dpavlin	3	die "commit_svnrev needs revision" if (! defined($rev));
76
77	dpavlin	7	open(SVNREV,"> .svnrev") \|\| die "can't open $TMPDIR/$CVSREP/.svnrev: $!";
78	dpavlin	3	print SVNREV $rev;
79			close(SVNREV);
80
81			my $path=".svnrev";
82
83			if ($add_new) {
84	dpavlin	28	system "$cvs add '$path'" \|\| die "cvs add of $path failed: $!";
85	dpavlin	4	} else {
86			my $msg="subversion revision $rev commited to CVS";
87			print "$msg\n";
88	dpavlin	28	system "$cvs commit -m '$msg' '$path'" \|\| die "cvs commit of $path failed: $!";
89	dpavlin	3	}
90			}
91
92	dpavlin	22	sub add_dir($$) {
93			my ($path,$msg) = @_;
94			print "# add_dir($path)\n";
95			die "add_dir($path) is not directory" unless (-d $path);
96	dpavlin	18
97	dpavlin	22	my $curr_dir;
98
99			foreach my $d (split(m#/#, $path)) {
100			$curr_dir .= ( $curr_dir ? '/' : '') . $d;
101
102			next if in_entries($curr_dir);
103			next if (-e "$curr_dir/CVS");
104
105	dpavlin	28	log_system("$cvs add '$curr_dir'", "cvs add of $curr_dir failed");
106	dpavlin	22	}
107			}
108
109	dpavlin	1	# ok, now do the checkout
110	dpavlin	18	eval {
111	dpavlin	22	cd_tmp;
112	dpavlin	18	log_system("$cvs -q checkout $CVSREP", "cvs checkout failed");
113			};
114	dpavlin	1
115	dpavlin	18	if ($@) {
116			print <<_NEW_REP_;
117	dpavlin	1
118	dpavlin	18	There is no CVS repository '$CVSREP' in your CVS. I will assume that
119			this is import of new module in your CVS and start from revision 0.
120	dpavlin	7
121	dpavlin	18	Press enter to continue importing new CVS repository or CTRL+C to abort.
122	dpavlin	7
123	dpavlin	18	_NEW_REP_
124	dpavlin	3
125	dpavlin	18	print "start import of new module [yes]: ";
126			my $in = <STDIN>;
127	dpavlin	22	cd_tmp;
128	dpavlin	18	mkdir($CVSREP) \|\| die "can't create $CVSREP: $!";
129	dpavlin	22	cd_rep;
130	dpavlin	1
131	dpavlin	18	open(SVNREV,"> .svnrev") \|\| die "can't open $CVSREP/.svnrev: $!";
132			print SVNREV "0";
133			close(SVNREV);
134
135			$rev = 0;
136
137			# create new module
138	dpavlin	22	cd_rep;
139			log_system("$cvs import -d -m 'new CVS module' $CVSREP svn r$rev", "import of new repository");
140			cd_tmp;
141			rmtree($CVSREP) \|\| die "can't remove $CVSREP";
142			log_system("$cvs -q checkout $CVSREP", "cvs checkout failed");
143			cd_rep;
144	dpavlin	18
145			} else {
146			# import into existing module directory in CVS
147
148	dpavlin	22	cd_rep;
149	dpavlin	18	# check if svnrev exists
150			if (! -e ".svnrev") {
151			print <<_USAGE_;
152
153	dpavlin	3	Your CVS repository doesn't have .svnrev file!
154	dpavlin	1
155	dpavlin	12	This file is used to keep CVS repository and Subversion in sync, so
156	dpavlin	3	that only newer changes will be commited.
157	dpavlin	1
158	dpavlin	3	It's quote possible that this is first svn2cvs run for this repository.
159			If so, you will have to identify correct svn revision which
160			corresponds to current version of CVS repository that has just
161			been checkouted.
162	dpavlin	1
163	dpavlin	3	If you migrated your cvs repository to svn using cvs2svn, this will be
164	dpavlin	12	last Subversion revision. If this is initial run of conversion of
165			Subversion repository to CVS, correct revision is 0.
166	dpavlin	1
167			_USAGE_
168	dpavlin	3
169	dpavlin	18	print "svn revision corresponding to CVS [abort]: ";
170			my $in = <STDIN>;
171			chomp($in);
172			if ($in !~ /^\d+$/) {
173			print "Aborting: revision not a number\n";
174			exit 1;
175			} else {
176			$rev = $in;
177			commit_svnrev($rev,1); # create new
178			}
179	dpavlin	3	} else {
180	dpavlin	18	open(SVNREV,".svnrev") \|\| die "can't open $TMPDIR/$CVSREP/.svnrev: $!";
181			$rev = <SVNREV>;
182			chomp($rev);
183			close(SVNREV);
184	dpavlin	3	}
185	dpavlin	18
186			print "Starting after revision $rev\n";
187			$rev++;
188	dpavlin	1	}
189
190
191			#
192			# FIXME!! HEAD should really be next verison and loop because this way we
193			# loose multiple edits of same file and corresponding messages. On the
194			# other hand, if you want to compress your traffic to CVS server and don't
195			# case much about accuracy and completnes of logs there, this might
196			# be good. YMMV
197			#
198	dpavlin	8	open(LOG, "svn log -r $rev:HEAD -v --xml $SVNROOT \|") \|\| die "svn log for repository $SVNROOT failed: $!";
199	dpavlin	1	my $log;
200			while(<LOG>) {
201			$log .= $_;
202			}
203			close(LOG);
204
205
206	dpavlin	21	my $xml;
207			eval {
208			$xml = XMLin($log, ForceArray => [ 'logentry', 'path' ]);
209			};
210	dpavlin	1
211	dpavlin	21
212	dpavlin	12	#=begin log_example
213			#
214			#------------------------------------------------------------------------
215			#r256 \| dpavlin \| 2004-03-09 13:18:17 +0100 (Tue, 09 Mar 2004) \| 2 lines
216			#
217			#ported r254 from hidra branch
218			#
219			#=cut
220	dpavlin	1
221			my $fmt = "\n" . "-" x 79 . "\nr%5s\| %8s \| %s\n\n%s\n";
222
223	dpavlin	2	if (! $xml->{'logentry'}) {
224	dpavlin	12	print "no newer log entries in Subversion repostory. CVS is current\n";
225	dpavlin	2	exit 0;
226			}
227
228	dpavlin	35	# return all files in CVS/Entries
229			sub entries($) {
230			my $dir = shift;
231			die "entries expects directory argument!" unless -d $dir;
232			my @entries;
233			open(my $fh, "$dir/CVS/Entries") \|\| return 0;
234			while(<$fh>) {
235			if ( m{^D/([^/]+)}, ) {
236			my $sub_dir = $1;
237			warn "#### entries recurse into: $dir/$sub_dir";
238			push @entries, map { "$sub_dir/$_" } entries("$dir/$sub_dir");
239			push @entries, $sub_dir;
240			} elsif ( m{^/([^/]+)/} ) {
241			push @entries, $1;
242			} elsif ( ! m{^D$} ) {
243			die "can't decode entries line: $_";
244	dpavlin	14	}
245			}
246	dpavlin	35	close($fh);
247			warn "#### entries($dir) => ",join("\|",@entries);
248			return @entries;
249	dpavlin	14	}
250
251	dpavlin	35	# check if file exists in CVS/Entries
252			sub in_entries($) {
253			my $path = shift;
254	dpavlin	37	if ($path =~ m,^(.?/)([^/]+)$,) {
255			my ($dir,$file) = ($1,$2);
256			if ($dir !~ m,/$, && $dir ne "") {
257			$dir .= "/";
258			}
259
260			open(my $fh, "$dir/CVS/Entries") \|\| return 0; #die "no entries file: $dir/CVS/Entries";
261			while(<$fh>) {
262			return 1 if (m{^/$file/});
263			}
264			close($fh);
265			return 0;
266			} else {
267			die "can't split '$path' to dir and file!";
268	dpavlin	35	}
269			}
270
271	dpavlin	22	cd_tmp;
272			cd_rep;
273	dpavlin	21
274	dpavlin	1	foreach my $e (@{$xml->{'logentry'}}) {
275			die "BUG: revision from .svnrev ($rev) greater than from subversion (".$e->{'revision'}.")" if ($rev > $e->{'revision'});
276			$rev = $e->{'revision'};
277	dpavlin	8	log_system("svn export --force -q -r $rev $SVNROOT $TMPDIR/$CVSREP", "svn export of revision $rev failed");
278	dpavlin	1
279	dpavlin	8	# deduce name of svn directory
280			my $SVNREP = "";
281			my $tmpsvn = $SVNROOT \|\| die "BUG: SVNROOT empty!";
282			my $tmppath = $e->{'paths'}->{'path'}->[0]->{'content'} \|\| die "BUG: tmppath empty!";
283			do {
284	dpavlin	35	if ($tmpsvn =~ s#(/[^/]+)/*$##) { # vim fix
285	dpavlin	20	$SVNREP = $1 . $SVNREP;
286	dpavlin	26	} elsif ($e->{'paths'}->{'path'}->[0]->{'copyfrom-path'}) {
287			print "NOTICE: copyfrom outside synced repository ignored - skipping\n";
288			next;
289	dpavlin	8	} else {
290	dpavlin	15	print "NOTICE: can't deduce svn dir from $SVNROOT - skipping\n";
291			next;
292	dpavlin	8	}
293			} until ($tmppath =~ m/^$SVNREP/);
294
295			print "NOTICE: using $SVNREP as directory for svn\n";
296
297	dpavlin	1	printf($fmt, $e->{'revision'}, $e->{'author'}, $e->{'date'}, $e->{'msg'});
298	dpavlin	18	my @commit;
299
300	dpavlin	35	my $msg = $e->{'msg'};
301			$msg =~ s/'/'\\''/g; # quote "
302
303	dpavlin	36	$msg = 'r' . $rev . ' ' . $e->{author} . ' \| ' . $e->{date} . "\n" . $msg if $decorate_commit_message;
304
305	dpavlin	35	sub cvs_commit {
306			my $msg = shift \|\| die "no msg?";
307			if ( ! @_ ) {
308			warn "commit ignored, no files\n";
309			return;
310			}
311			log_system("$cvs commit -m '$msg' '".join("' '",@_)."'", "cvs commit of ".join(",",@_)." failed");
312			}
313
314	dpavlin	1	foreach my $p (@{$e->{'paths'}->{'path'}}) {
315			my ($action,$path) = ($p->{'action'},$p->{'content'});
316
317	dpavlin	23	next if ($path =~ m#/\.svnrev$#);
318
319	dpavlin	1	print "svn2cvs: $action $path\n";
320
321			# prepare path and message
322			my $file = $path;
323	dpavlin	27	if ( $path !~ s#^\Q$SVNREP\E/*## ) {
324			print "NOTICE: skipping '$path' which isn't under repository root '$SVNREP'\n";
325			die unless $partial_import;
326			next;
327			}
328	dpavlin	7
329			if (! $path) {
330			print "NOTICE: skipped this operation. Probably trunk creation\n";
331			next;
332			}
333
334	dpavlin	1	my $msg = $e->{'msg'};
335	dpavlin	14	$msg =~ s/'/'\\''/g; # quote "
336	dpavlin	1
337	dpavlin	31	sub add_path {
338			my $path = shift \|\| die "no path?";
339
340	dpavlin	8	if (-d $path) {
341	dpavlin	22	add_dir($path, $msg);
342	dpavlin	14	} elsif ($path =~ m,^(.+)/[^/]+$, && ! -e "$1/CVS/Root") {
343			my $dir = $1;
344	dpavlin	22	in_entries($dir) \|\| add_dir($dir, $msg);
345	dpavlin	28	in_entries($path) \|\| log_system("$cvs add '$path'", "cvs add of $path failed");
346	dpavlin	8	} else {
347	dpavlin	28	in_entries($path) \|\| log_system("$cvs add '$path'", "cvs add of $path failed");
348	dpavlin	8	}
349	dpavlin	31	}
350
351			if ($action =~ /M/) {
352			if ( in_entries( $path ) ) {
353			print "svn2cvs: modify $path -- nop\n";
354			} else {
355			print "WARNING: modify $path which isn't in CVS, adding...\n";
356			add_path($path);
357			}
358			} elsif ($action =~ /A/) {
359			add_path($path);
360	dpavlin	1	} elsif ($action =~ /D/) {
361	dpavlin	22	if (-e $path) {
362	dpavlin	35	if ( -d $path ) {
363			warn "#### remove directory: $path";
364			my @sub_commit;
365			foreach my $f ( entries($path) ) {
366			$f = "$path/$f";
367			if ( -f $f ) {
368			unlink($f) \|\| die "can't delete file $f: $!";
369			# } else {
370			# rmtree($f) \|\| die "can't delete dir $f: $!";
371			}
372			log_system("$cvs delete '$f'", "cvs delete of file $f failed");
373			push @sub_commit, $f;
374			}
375			log_system("$cvs delete '$path'", "cvs delete of file $path failed");
376			cvs_commit($msg, @sub_commit, $path);
377			log_system("$cvs update -dP '$path'", "cvs update -dP $path failed");
378			} else {
379			warn "#### remove file: $path";
380			unlink($path) \|\| die "can't delete $path: $!";
381			log_system("$cvs delete '$path'", "cvs delete of dir $path failed");
382			}
383	dpavlin	22	} else {
384			print "WARNING: $path is not present, skipping...\n";
385			undef $path;
386			}
387	dpavlin	1	} else {
388			print "WARNING: action $action not implemented on $path. Bug or missing feature of $0\n";
389			}
390
391	dpavlin	18	# save commits for later
392	dpavlin	22	push @commit, $path if ($path);
393	dpavlin	1
394			}
395
396	dpavlin	18	# now commit changes
397	dpavlin	35	cvs_commit($msg, @commit);
398	dpavlin	18
399	dpavlin	1	commit_svnrev($rev);
400			}
401	dpavlin	12
402	dpavlin	21	# cd out of $CVSREP before File::Temp::END is called
403			chdir("/tmp") \|\| die "can't cd to /tmp: $!";
404
405	dpavlin	12	__END__
406
407			=pod
408
409			=head1 NAME
410
411			svn2cvs - save subversion commits to (read-only) cvs repository
412
413			=head1 SYNOPSIS
414
415			./svn2cvs.pl SVN_URL CVSROOT CVSREPOSITORY
416
417			Usage example (used to self-host this script):
418
419			./svn2cvs.pl file:///home/dpavlin/private/svn/svn2cvs/trunk/ \
420			:pserver:dpavlin@cvs.tigris.org:/cvs svn2cvs/src
421
422			=head1 DESCRIPTION
423
424	dpavlin	18	This script will allows you to commit changes made to Subversion repository to
425			(read-only) CVS repository manually or from Subversion's C<post-commit> hook.
426	dpavlin	12
427			It's using F<.svnrev> file (which will be created on first run) in
428			B<CVSROOT/CVSREPOSITORY> to store last Subversion revision which was
429			committed into CVS.
430
431			One run will do following things:
432
433			=over 4
434
435			=item *
436			checkout B<CVSREPOSITORY> from B<CVSROOT> to temporary directory
437
438			=item *
439			check if F<.svnrev> file exists and create it if it doesn't
440
441			=item *
442			loop through all revisions from current in B<CVSROOT/CVSREPOSITORY> (using
443			F<.svnrev>) up to B<HEAD> (current one)
444
445			=over 5
446
447			=item *
448			checkout next Subversion revision from B<SVN_URL> over CVS checkout
449			temporary directory
450
451			=item *
452			make modification (add and/or delete) done in that revision
453
454			=item *
455			commit modification (added, deleted or modified files/dirs) while
456			preserving original message from CVS
457
458			=item *
459			update F<.svnrev> to match current revision
460
461			=back
462
463			=item *
464			cleanup temporary directory
465
466			=back
467
468			If checkout fails for some reason (e.g. flaky ssh connection), you will
469			still have valid CVS repository, so all you have to do is run B<svn2cvs.pl>
470			again.
471
472			=head1 WARNINGS
473
474			"Cheap" copy operations in Subversion are not at all cheap in CVS. They will
475			create multiple copies of files in CVS repository!
476
477	dpavlin	18	This script assume that you want to sync your C<trunk> (or any other
478			directory for that matter) directory with CVS, not root of your subversion.
479			This might be considered bug, but since common practise is to have
480			directories C<trunk> and C<branches> in svn and source code in them, it's
481			not serious limitation.
482
483	dpavlin	12	=head1 RELATED PROJECTS
484
485			B<Subversion> L<http://subversion.tigris.org/> version control system that is a
486			compelling replacement for CVS in the open source community.
487
488			B<cvs2svn> L<http://cvs2svn.tigris.org/> converts a CVS repository to a
489			Subversion repository. It is designed for one-time conversions, not for
490			repeated synchronizations between CVS and Subversion.
491
492	dpavlin	16	=head1 CHANGES
493
494			Versions of this utility are actually Subversion repository revisions,
495			so they might not be in sequence.
496
497			=over 3
498
499			=item r10
500
501			First release available to public
502
503			=item r15
504
505			Addition of comprehensive documentation, fixes for quoting in commit
506			messages, and support for skipping changes which are not under current
507			Subversion checkout root (e.g. branches).
508
509	dpavlin	19	=item r18
510	dpavlin	18
511			Support for importing your svn into empty CVS repository (it will first
512			create module and than dump all revisions).
513			Group commit operations to save round-trips to CVS server.
514			Documentation improvements and other small fixes.
515
516	dpavlin	20	=item r20
517	dpavlin	18
518	dpavlin	20	Fixed path deduction (overlap between Subversion reporistory and CVS checkout).
519
520	dpavlin	21	=item r21
521
522			Use C<update -d> instead of checkout after import.
523			Added fixes by Paul Egan <paulegan@mail.com> for XMLin and fixing working
524			directory.
525
526	dpavlin	22	=item r22
527	dpavlin	21
528	dpavlin	22	Rewritten import from revision 0 to empty repository, better importing
529			of deep directory structures, initial support for recovery from partial
530			commit.
531
532	dpavlin	16	=back
533
534	dpavlin	12	=head1 AUTHOR
535
536			Dobrica Pavlinusic <dpavlin@rot13.org>
537
538			L<https://www.rot13.org/~dpavlin/>
539
540			=head1 LICENSE
541
542			This product is licensed under GNU Public License (GPL) v2 or later.
543
544			=cut
545