Merge branch 'jk/maint-http-half-auth-fetch'
[git] / perl / Git / SVN / Migration.pm
1 package Git::SVN::Migration;
2 # these version numbers do NOT correspond to actual version numbers
3 # of git nor git-svn.  They are just relative.
4 #
5 # v0 layout: .git/$id/info/url, refs/heads/$id-HEAD
6 #
7 # v1 layout: .git/$id/info/url, refs/remotes/$id
8 #
9 # v2 layout: .git/svn/$id/info/url, refs/remotes/$id
10 #
11 # v3 layout: .git/svn/$id, refs/remotes/$id
12 #            - info/url may remain for backwards compatibility
13 #            - this is what we migrate up to this layout automatically,
14 #            - this will be used by git svn init on single branches
15 # v3.1 layout (auto migrated):
16 #            - .rev_db => .rev_db.$UUID, .rev_db will remain as a symlink
17 #              for backwards compatibility
18 #
19 # v4 layout: .git/svn/$repo_id/$id, refs/remotes/$repo_id/$id
20 #            - this is only created for newly multi-init-ed
21 #              repositories.  Similar in spirit to the
22 #              --use-separate-remotes option in git-clone (now default)
23 #            - we do not automatically migrate to this (following
24 #              the example set by core git)
25 #
26 # v5 layout: .rev_db.$UUID => .rev_map.$UUID
27 #            - newer, more-efficient format that uses 24-bytes per record
28 #              with no filler space.
29 #            - use xxd -c24 < .rev_map.$UUID to view and debug
30 #            - This is a one-way migration, repositories updated to the
31 #              new format will not be able to use old git-svn without
32 #              rebuilding the .rev_db.  Rebuilding the rev_db is not
33 #              possible if noMetadata or useSvmProps are set; but should
34 #              be no problem for users that use the (sensible) defaults.
35 use strict;
36 use warnings;
37 use Carp qw/croak/;
38 use File::Path qw/mkpath/;
39 use File::Basename qw/dirname basename/;
40
41 our $_minimize;
42 use Git qw(
43         command
44         command_noisy
45         command_output_pipe
46         command_close_pipe
47 );
48
49 sub migrate_from_v0 {
50         my $git_dir = $ENV{GIT_DIR};
51         return undef unless -d $git_dir;
52         my ($fh, $ctx) = command_output_pipe(qw/rev-parse --symbolic --all/);
53         my $migrated = 0;
54         while (<$fh>) {
55                 chomp;
56                 my ($id, $orig_ref) = ($_, $_);
57                 next unless $id =~ s#^refs/heads/(.+)-HEAD$#$1#;
58                 next unless -f "$git_dir/$id/info/url";
59                 my $new_ref = "refs/remotes/$id";
60                 if (::verify_ref("$new_ref^0")) {
61                         print STDERR "W: $orig_ref is probably an old ",
62                                      "branch used by an ancient version of ",
63                                      "git-svn.\n",
64                                      "However, $new_ref also exists.\n",
65                                      "We will not be able ",
66                                      "to use this branch until this ",
67                                      "ambiguity is resolved.\n";
68                         next;
69                 }
70                 print STDERR "Migrating from v0 layout...\n" if !$migrated;
71                 print STDERR "Renaming ref: $orig_ref => $new_ref\n";
72                 command_noisy('update-ref', $new_ref, $orig_ref);
73                 command_noisy('update-ref', '-d', $orig_ref, $orig_ref);
74                 $migrated++;
75         }
76         command_close_pipe($fh, $ctx);
77         print STDERR "Done migrating from v0 layout...\n" if $migrated;
78         $migrated;
79 }
80
81 sub migrate_from_v1 {
82         my $git_dir = $ENV{GIT_DIR};
83         my $migrated = 0;
84         return $migrated unless -d $git_dir;
85         my $svn_dir = "$git_dir/svn";
86
87         # just in case somebody used 'svn' as their $id at some point...
88         return $migrated if -d $svn_dir && ! -f "$svn_dir/info/url";
89
90         print STDERR "Migrating from a git-svn v1 layout...\n";
91         mkpath([$svn_dir]);
92         print STDERR "Data from a previous version of git-svn exists, but\n\t",
93                      "$svn_dir\n\t(required for this version ",
94                      "($::VERSION) of git-svn) does not exist.\n";
95         my ($fh, $ctx) = command_output_pipe(qw/rev-parse --symbolic --all/);
96         while (<$fh>) {
97                 my $x = $_;
98                 next unless $x =~ s#^refs/remotes/##;
99                 chomp $x;
100                 next unless -f "$git_dir/$x/info/url";
101                 my $u = eval { ::file_to_s("$git_dir/$x/info/url") };
102                 next unless $u;
103                 my $dn = dirname("$git_dir/svn/$x");
104                 mkpath([$dn]) unless -d $dn;
105                 if ($x eq 'svn') { # they used 'svn' as GIT_SVN_ID:
106                         mkpath(["$git_dir/svn/svn"]);
107                         print STDERR " - $git_dir/$x/info => ",
108                                         "$git_dir/svn/$x/info\n";
109                         rename "$git_dir/$x/info", "$git_dir/svn/$x/info" or
110                                croak "$!: $x";
111                         # don't worry too much about these, they probably
112                         # don't exist with repos this old (save for index,
113                         # and we can easily regenerate that)
114                         foreach my $f (qw/unhandled.log index .rev_db/) {
115                                 rename "$git_dir/$x/$f", "$git_dir/svn/$x/$f";
116                         }
117                 } else {
118                         print STDERR " - $git_dir/$x => $git_dir/svn/$x\n";
119                         rename "$git_dir/$x", "$git_dir/svn/$x" or
120                                croak "$!: $x";
121                 }
122                 $migrated++;
123         }
124         command_close_pipe($fh, $ctx);
125         print STDERR "Done migrating from a git-svn v1 layout\n";
126         $migrated;
127 }
128
129 sub read_old_urls {
130         my ($l_map, $pfx, $path) = @_;
131         my @dir;
132         foreach (<$path/*>) {
133                 if (-r "$_/info/url") {
134                         $pfx .= '/' if $pfx && $pfx !~ m!/$!;
135                         my $ref_id = $pfx . basename $_;
136                         my $url = ::file_to_s("$_/info/url");
137                         $l_map->{$ref_id} = $url;
138                 } elsif (-d $_) {
139                         push @dir, $_;
140                 }
141         }
142         foreach (@dir) {
143                 my $x = $_;
144                 $x =~ s!^\Q$ENV{GIT_DIR}\E/svn/!!o;
145                 read_old_urls($l_map, $x, $_);
146         }
147 }
148
149 sub migrate_from_v2 {
150         my @cfg = command(qw/config -l/);
151         return if grep /^svn-remote\..+\.url=/, @cfg;
152         my %l_map;
153         read_old_urls(\%l_map, '', "$ENV{GIT_DIR}/svn");
154         my $migrated = 0;
155
156         require Git::SVN;
157         foreach my $ref_id (sort keys %l_map) {
158                 eval { Git::SVN->init($l_map{$ref_id}, '', undef, $ref_id) };
159                 if ($@) {
160                         Git::SVN->init($l_map{$ref_id}, '', $ref_id, $ref_id);
161                 }
162                 $migrated++;
163         }
164         $migrated;
165 }
166
167 sub minimize_connections {
168         require Git::SVN;
169         require Git::SVN::Ra;
170
171         my $r = Git::SVN::read_all_remotes();
172         my $new_urls = {};
173         my $root_repos = {};
174         foreach my $repo_id (keys %$r) {
175                 my $url = $r->{$repo_id}->{url} or next;
176                 my $fetch = $r->{$repo_id}->{fetch} or next;
177                 my $ra = Git::SVN::Ra->new($url);
178
179                 # skip existing cases where we already connect to the root
180                 if (($ra->url eq $ra->{repos_root}) ||
181                     ($ra->{repos_root} eq $repo_id)) {
182                         $root_repos->{$ra->url} = $repo_id;
183                         next;
184                 }
185
186                 my $root_ra = Git::SVN::Ra->new($ra->{repos_root});
187                 my $root_path = $ra->url;
188                 $root_path =~ s#^\Q$ra->{repos_root}\E(/|$)##;
189                 foreach my $path (keys %$fetch) {
190                         my $ref_id = $fetch->{$path};
191                         my $gs = Git::SVN->new($ref_id, $repo_id, $path);
192
193                         # make sure we can read when connecting to
194                         # a higher level of a repository
195                         my ($last_rev, undef) = $gs->last_rev_commit;
196                         if (!defined $last_rev) {
197                                 $last_rev = eval {
198                                         $root_ra->get_latest_revnum;
199                                 };
200                                 next if $@;
201                         }
202                         my $new = $root_path;
203                         $new .= length $path ? "/$path" : '';
204                         eval {
205                                 $root_ra->get_log([$new], $last_rev, $last_rev,
206                                                   0, 0, 1, sub { });
207                         };
208                         next if $@;
209                         $new_urls->{$ra->{repos_root}}->{$new} =
210                                 { ref_id => $ref_id,
211                                   old_repo_id => $repo_id,
212                                   old_path => $path };
213                 }
214         }
215
216         my @emptied;
217         foreach my $url (keys %$new_urls) {
218                 # see if we can re-use an existing [svn-remote "repo_id"]
219                 # instead of creating a(n ugly) new section:
220                 my $repo_id = $root_repos->{$url} || $url;
221
222                 my $fetch = $new_urls->{$url};
223                 foreach my $path (keys %$fetch) {
224                         my $x = $fetch->{$path};
225                         Git::SVN->init($url, $path, $repo_id, $x->{ref_id});
226                         my $pfx = "svn-remote.$x->{old_repo_id}";
227
228                         my $old_fetch = quotemeta("$x->{old_path}:".
229                                                   "$x->{ref_id}");
230                         command_noisy(qw/config --unset/,
231                                       "$pfx.fetch", '^'. $old_fetch . '$');
232                         delete $r->{$x->{old_repo_id}}->
233                                {fetch}->{$x->{old_path}};
234                         if (!keys %{$r->{$x->{old_repo_id}}->{fetch}}) {
235                                 command_noisy(qw/config --unset/,
236                                               "$pfx.url");
237                                 push @emptied, $x->{old_repo_id}
238                         }
239                 }
240         }
241         if (@emptied) {
242                 my $file = $ENV{GIT_CONFIG} || "$ENV{GIT_DIR}/config";
243                 print STDERR <<EOF;
244 The following [svn-remote] sections in your config file ($file) are empty
245 and can be safely removed:
246 EOF
247                 print STDERR "[svn-remote \"$_\"]\n" foreach @emptied;
248         }
249 }
250
251 sub migration_check {
252         migrate_from_v0();
253         migrate_from_v1();
254         migrate_from_v2();
255         minimize_connections() if $_minimize;
256 }
257
258 1;