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;

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;
}

# my ($dir,$file) = dir_file($path);
sub dir_file($) {
        my $path = shift;
        if ($path !~ m,^(.*?/*)([^/]+)$,) {
                die "can't split '$path' to dir and file!";
        } else {
                my ($d,$f) = ($1,$2);
                if ($d !~ m,/$, && $d ne "") {
                        $d .= "/";
                }
                return ($d,$f);
        }
}

# 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;
        my ($dir,$file) = dir_file($path);
        open(E, "$dir/CVS/Entries") || return 0;
        while(<E>) {
                return(1) if (m,^/$file/,);
        }
        close(E);
        return 0;
}

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 "

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