perl/Git/SVN/Ra.pm

   1 package Git::SVN::Ra;
   2 use vars qw/@ISA $config_dir $_ignore_refs_regex $_log_window_size/;
   3 use strict;
   4 use warnings;
   5 use Memoize;
   6 use SVN::Client;
   7 use Git::SVN::Utils qw(
   8         canonicalize_url
   9         canonicalize_path
  10         add_path_to_url
  11 );
  12
  13 use SVN::Ra;
  14 BEGIN {
  15         @ISA = qw(SVN::Ra);
  16 }
  17
  18 my ($ra_invalid, $can_do_switch, %ignored_err, $RA);
  19
  20 BEGIN {
  21         # enforce temporary pool usage for some simple functions
  22         no strict 'refs';
  23         for my $f (qw/rev_proplist get_latest_revnum get_uuid get_repos_root
  24                       get_file/) {
  25                 my $SUPER = "SUPER::$f";
  26                 *$f = sub {
  27                         my $self = shift;
  28                         my $pool = SVN::Pool->new;
  29                         my @ret = $self->$SUPER(@_,$pool);
  30                         $pool->clear;
  31                         wantarray ? @ret : $ret[0];
  32                 };
  33         }
  34 }
  35
  36 # serf has a bug that leads to a coredump upon termination if the
  37 # remote access object is left around (not fixed yet in serf 1.3.1).
  38 # Explicitly free it to work around the issue.
  39 END {
  40         $RA = undef;
  41         $ra_invalid = 1;
  42 }
  43
  44 sub _auth_providers () {
  45         my @rv = (
  46           SVN::Client::get_simple_provider(),
  47           SVN::Client::get_ssl_server_trust_file_provider(),
  48           SVN::Client::get_simple_prompt_provider(
  49             \&Git::SVN::Prompt::simple, 2),
  50           SVN::Client::get_ssl_client_cert_file_provider(),
  51           SVN::Client::get_ssl_client_cert_prompt_provider(
  52             \&Git::SVN::Prompt::ssl_client_cert, 2),
  53           SVN::Client::get_ssl_client_cert_pw_file_provider(),
  54           SVN::Client::get_ssl_client_cert_pw_prompt_provider(
  55             \&Git::SVN::Prompt::ssl_client_cert_pw, 2),
  56           SVN::Client::get_username_provider(),
  57           SVN::Client::get_ssl_server_trust_prompt_provider(
  58             \&Git::SVN::Prompt::ssl_server_trust),
  59           SVN::Client::get_username_prompt_provider(
  60             \&Git::SVN::Prompt::username, 2)
  61         );
  62
  63         # earlier 1.6.x versions would segfault, and <= 1.5.x didn't have
  64         # this function
  65         if (::compare_svn_version('1.6.15') >= 0) {
  66                 my $config = SVN::Core::config_get_config($config_dir);
  67                 my ($p, @a);
  68                 # config_get_config returns all config files from
  69                 # ~/.subversion, auth_get_platform_specific_client_providers
  70                 # just wants the config "file".
  71                 @a = ($config->{'config'}, undef);
  72                 $p = SVN::Core::auth_get_platform_specific_client_providers(@a);
  73                 # Insert the return value from
  74                 # auth_get_platform_specific_providers
  75                 unshift @rv, @$p;
  76         }
  77         \@rv;
  78 }
  79
  80 sub prepare_config_once {
  81         SVN::_Core::svn_config_ensure($config_dir, undef);
  82         my ($baton, $callbacks) = SVN::Core::auth_open_helper(_auth_providers);
  83         my $config = SVN::Core::config_get_config($config_dir);
  84         my $dont_store_passwords = 1;
  85         my $conf_t = $config->{'config'};
  86
  87         no warnings 'once';
  88         # The usage of $SVN::_Core::SVN_CONFIG_* variables
  89         # produces warnings that variables are used only once.
  90         # I had not found the better way to shut them up, so
  91         # the warnings of type 'once' are disabled in this block.
  92         if (SVN::_Core::svn_config_get_bool($conf_t,
  93             $SVN::_Core::SVN_CONFIG_SECTION_AUTH,
  94             $SVN::_Core::SVN_CONFIG_OPTION_STORE_PASSWORDS,
  95             1) == 0) {
  96                 SVN::_Core::svn_auth_set_parameter($baton,
  97                     $SVN::_Core::SVN_AUTH_PARAM_DONT_STORE_PASSWORDS,
  98                     bless (\$dont_store_passwords, "_p_void"));
  99         }
 100         if (SVN::_Core::svn_config_get_bool($conf_t,
 101             $SVN::_Core::SVN_CONFIG_SECTION_AUTH,
 102             $SVN::_Core::SVN_CONFIG_OPTION_STORE_AUTH_CREDS,
 103             1) == 0) {
 104                 $Git::SVN::Prompt::_no_auth_cache = 1;
 105         }
 106
 107         return ($config, $baton, $callbacks);
 108 } # no warnings 'once'
 109
 110 INIT {
 111         Memoize::memoize '_auth_providers';
 112         Memoize::memoize 'prepare_config_once';
 113 }
 114
 115 sub new {
 116         my ($class, $url) = @_;
 117         $url = canonicalize_url($url);
 118         return $RA if ($RA && $RA->url eq $url);
 119
 120         ::_req_svn();
 121
 122         $RA = undef;
 123         my ($config, $baton, $callbacks) = prepare_config_once();
 124         my $self = SVN::Ra->new(url => $url, auth => $baton,
 125                               config => $config,
 126                               pool => SVN::Pool->new,
 127                               auth_provider_callbacks => $callbacks);
 128         $RA = bless $self, $class;
 129
 130         # Make sure its canonicalized
 131         $self->url($url);
 132         $self->{svn_path} = $url;
 133         $self->{repos_root} = $self->get_repos_root;
 134         $self->{svn_path} =~ s#^\Q$self->{repos_root}\E(/|$)##;
 135         $self->{cache} = { check_path => { r => 0, data => {} },
 136                            get_dir => { r => 0, data => {} } };
 137
 138         return $RA;
 139 }
 140
 141 sub url {
 142         my $self = shift;
 143
 144         if (@_) {
 145                 my $url = shift;
 146                 $self->{url} = canonicalize_url($url);
 147                 return;
 148         }
 149
 150         return $self->{url};
 151 }
 152
 153 sub check_path {
 154         my ($self, $path, $r) = @_;
 155         my $cache = $self->{cache}->{check_path};
 156         if ($r == $cache->{r} && exists $cache->{data}->{$path}) {
 157                 return $cache->{data}->{$path};
 158         }
 159         my $pool = SVN::Pool->new;
 160         my $t = $self->SUPER::check_path($path, $r, $pool);
 161         $pool->clear;
 162         if ($r != $cache->{r}) {
 163                 %{$cache->{data}} = ();
 164                 $cache->{r} = $r;
 165         }
 166         $cache->{data}->{$path} = $t;
 167 }
 168
 169 sub get_dir {
 170         my ($self, $dir, $r) = @_;
 171         my $cache = $self->{cache}->{get_dir};
 172         if ($r == $cache->{r}) {
 173                 if (my $x = $cache->{data}->{$dir}) {
 174                         return wantarray ? @$x : $x->[0];
 175                 }
 176         }
 177         my $pool = SVN::Pool->new;
 178         my ($d, undef, $props);
 179
 180         if (::compare_svn_version('1.4.0') >= 0) {
 181                 # n.b. in addition to being potentially more efficient,
 182                 # this works around what appears to be a bug in some
 183                 # SVN 1.8 versions
 184                 my $kind = 1; # SVN_DIRENT_KIND
 185                 ($d, undef, $props) = $self->get_dir2($dir, $r, $kind, $pool);
 186         } else {
 187                 ($d, undef, $props) = $self->SUPER::get_dir($dir, $r, $pool);
 188         }
 189         my %dirents = map { $_ => { kind => $d->{$_}->kind } } keys %$d;
 190         $pool->clear;
 191         if ($r != $cache->{r}) {
 192                 %{$cache->{data}} = ();
 193                 $cache->{r} = $r;
 194         }
 195         $cache->{data}->{$dir} = [ \%dirents, $r, $props ];
 196         wantarray ? (\%dirents, $r, $props) : \%dirents;
 197 }
 198
 199 # get_log(paths, start, end, limit,
 200 #         discover_changed_paths, strict_node_history, receiver)
 201 sub get_log {
 202         my ($self, @args) = @_;
 203         my $pool = SVN::Pool->new;
 204
 205         # svn_log_changed_path_t objects passed to get_log are likely to be
 206         # overwritten even if only the refs are copied to an external variable,
 207         # so we should dup the structures in their entirety.  Using an
 208         # externally passed pool (instead of our temporary and quickly cleared
 209         # pool in Git::SVN::Ra) does not help matters at all...
 210         my $receiver = pop @args;
 211         my $prefix = "/".$self->{svn_path};
 212         $prefix =~ s#/+($)##;
 213         my $prefix_regex = qr#^\Q$prefix\E#;
 214         push(@args, sub {
 215                 my ($paths) = $_[0];
 216                 return &$receiver(@_) unless $paths;
 217                 $_[0] = ();
 218                 foreach my $p (keys %$paths) {
 219                         my $i = $paths->{$p};
 220                         # Make path relative to our url, not repos_root
 221                         $p =~ s/$prefix_regex//;
 222                         my %s = map { $_ => $i->$_; }
 223                                 qw/copyfrom_path copyfrom_rev action/;
 224                         if ($s{'copyfrom_path'}) {
 225                                 $s{'copyfrom_path'} =~ s/$prefix_regex//;
 226                                 $s{'copyfrom_path'} = canonicalize_path($s{'copyfrom_path'});
 227                         }
 228                         $_[0]{$p} = \%s;
 229                 }
 230                 &$receiver(@_);
 231         });
 232
 233
 234         # the limit parameter was not supported in SVN 1.1.x, so we
 235         # drop it.  Therefore, the receiver callback passed to it
 236         # is made aware of this limitation by being wrapped if
 237         # the limit passed to is being wrapped.
 238         if (::compare_svn_version('1.2.0') <= 0) {
 239                 my $limit = splice(@args, 3, 1);
 240                 if ($limit > 0) {
 241                         my $receiver = pop @args;
 242                         push(@args, sub { &$receiver(@_) if (--$limit >= 0) });
 243                 }
 244         }
 245         my $ret = $self->SUPER::get_log(@args, $pool);
 246         $pool->clear;
 247         $ret;
 248 }
 249
 250 sub trees_match {
 251         my ($self, $url1, $rev1, $url2, $rev2) = @_;
 252         my $ctx = SVN::Client->new(auth => _auth_providers);
 253         my $out = IO::File->new_tmpfile;
 254
 255         # older SVN (1.1.x) doesn't take $pool as the last parameter for
 256         # $ctx->diff(), so we'll create a default one
 257         my $pool = SVN::Pool->new_default_sub;
 258
 259         $ra_invalid = 1; # this will open a new SVN::Ra connection to $url1
 260         $ctx->diff([], $url1, $rev1, $url2, $rev2, 1, 1, 0, $out, $out);
 261         $out->flush;
 262         my $ret = (($out->stat)[7] == 0);
 263         close $out or croak $!;
 264
 265         $ret;
 266 }
 267
 268 sub get_commit_editor {
 269         my ($self, $log, $cb, $pool) = @_;
 270
 271         my @lock = (::compare_svn_version('1.2.0') >= 0) ? (undef, 0) : ();
 272         $self->SUPER::get_commit_editor($log, $cb, @lock, $pool);
 273 }
 274
 275 sub gs_do_update {
 276         my ($self, $rev_a, $rev_b, $gs, $editor) = @_;
 277         my $new = ($rev_a == $rev_b);
 278         my $path = $gs->path;
 279
 280         if ($new && -e $gs->{index}) {
 281                 unlink $gs->{index} or die
 282                   "Couldn't unlink index: $gs->{index}: $!\n";
 283         }
 284         my $pool = SVN::Pool->new;
 285         $editor->set_path_strip($path);
 286         my (@pc) = split m#/#, $path;
 287         my $reporter = $self->do_update($rev_b, (@pc ? shift @pc : ''),
 288                                         1, $editor, $pool);
 289         my @lock = (::compare_svn_version('1.2.0') >= 0) ? (undef) : ();
 290
 291         # Since we can't rely on svn_ra_reparent being available, we'll
 292         # just have to do some magic with set_path to make it so
 293         # we only want a partial path.
 294         my $sp = '';
 295         my $final = join('/', @pc);
 296         while (@pc) {
 297                 $reporter->set_path($sp, $rev_b, 0, @lock, $pool);
 298                 $sp .= '/' if length $sp;
 299                 $sp .= shift @pc;
 300         }
 301         die "BUG: '$sp' != '$final'\n" if ($sp ne $final);
 302
 303         $reporter->set_path($sp, $rev_a, $new, @lock, $pool);
 304
 305         $reporter->finish_report($pool);
 306         $pool->clear;
 307         $editor->{git_commit_ok};
 308 }
 309
 310 # this requires SVN 1.4.3 or later (do_switch didn't work before 1.4.3, and
 311 # svn_ra_reparent didn't work before 1.4)
 312 sub gs_do_switch {
 313         my ($self, $rev_a, $rev_b, $gs, $url_b, $editor) = @_;
 314         my $path = $gs->path;
 315         my $pool = SVN::Pool->new;
 316
 317         my $old_url = $self->url;
 318         my $full_url = add_path_to_url( $self->url, $path );
 319         my ($ra, $reparented);
 320
 321         if ($old_url =~ m#^svn(\+\w+)?://# ||
 322             ($full_url =~ m#^https?://# &&
 323              canonicalize_url($full_url) ne $full_url)) {
 324                 $_[0] = undef;
 325                 $self = undef;
 326                 $RA = undef;
 327                 $ra = Git::SVN::Ra->new($full_url);
 328                 $ra_invalid = 1;
 329         } elsif ($old_url ne $full_url) {
 330                 SVN::_Ra::svn_ra_reparent(
 331                         $self->{session},
 332                         canonicalize_url($full_url),
 333                         $pool
 334                 );
 335                 $self->url($full_url);
 336                 $reparented = 1;
 337         }
 338
 339         $ra ||= $self;
 340         $url_b = canonicalize_url($url_b);
 341         my $reporter = $ra->do_switch($rev_b, '', 1, $url_b, $editor, $pool);
 342         my @lock = (::compare_svn_version('1.2.0') >= 0) ? (undef) : ();
 343         $reporter->set_path('', $rev_a, 0, @lock, $pool);
 344         $reporter->finish_report($pool);
 345
 346         if ($reparented) {
 347                 SVN::_Ra::svn_ra_reparent($self->{session}, $old_url, $pool);
 348                 $self->url($old_url);
 349         }
 350
 351         $pool->clear;
 352         $editor->{git_commit_ok};
 353 }
 354
 355 sub longest_common_path {
 356         my ($gsv, $globs) = @_;
 357         my %common;
 358         my $common_max = scalar @$gsv;
 359
 360         foreach my $gs (@$gsv) {
 361                 my @tmp = split m#/#, $gs->path;
 362                 my $p = '';
 363                 foreach (@tmp) {
 364                         $p .= length($p) ? "/$_" : $_;
 365                         $common{$p} ||= 0;
 366                         $common{$p}++;
 367                 }
 368         }
 369         $globs ||= [];
 370         $common_max += scalar @$globs;
 371         foreach my $glob (@$globs) {
 372                 my @tmp = split m#/#, $glob->{path}->{left};
 373                 my $p = '';
 374                 foreach (@tmp) {
 375                         $p .= length($p) ? "/$_" : $_;
 376                         $common{$p} ||= 0;
 377                         $common{$p}++;
 378                 }
 379         }
 380
 381         my $longest_path = '';
 382         foreach (sort {length $b <=> length $a} keys %common) {
 383                 if ($common{$_} == $common_max) {
 384                         $longest_path = $_;
 385                         last;
 386                 }
 387         }
 388         $longest_path;
 389 }
 390
 391 sub gs_fetch_loop_common {
 392         my ($self, $base, $head, $gsv, $globs) = @_;
 393         return if ($base > $head);
 394         my $gpool = SVN::Pool->new_default;
 395         my $ra_url = $self->url;
 396         my $reload_ra = sub {
 397                 $_[0] = undef;
 398                 $self = undef;
 399                 $RA = undef;
 400                 $gpool->clear;
 401                 $self = Git::SVN::Ra->new($ra_url);
 402                 $ra_invalid = undef;
 403         };
 404         my $inc = $_log_window_size;
 405         my ($min, $max) = ($base, $head < $base + $inc ? $head : $base + $inc);
 406         my $longest_path = longest_common_path($gsv, $globs);
 407         my $find_trailing_edge;
 408         while (1) {
 409                 my %revs;
 410                 my $err;
 411                 my $err_handler = $SVN::Error::handler;
 412                 $SVN::Error::handler = sub {
 413                         ($err) = @_;
 414                         skip_unknown_revs($err);
 415                 };
 416                 sub _cb {
 417                         my ($paths, $r, $author, $date, $log) = @_;
 418                         [ $paths,
 419                           { author => $author, date => $date, log => $log } ];
 420                 }
 421                 $self->get_log([$longest_path], $min, $max, 0, 1, 1,
 422                                sub { $revs{$_[1]} = _cb(@_) });
 423                 if ($err) {
 424                         print "Checked through r$max\r";
 425                 } else {
 426                         $find_trailing_edge = 1;
 427                 }
 428                 if ($err and $find_trailing_edge) {
 429                         print STDERR "Path '$longest_path' ",
 430                                      "was probably deleted:\n",
 431                                      $err->expanded_message,
 432                                      "\nWill attempt to follow ",
 433                                      "revisions r$min .. r$max ",
 434                                      "committed before the deletion\n";
 435                         my $hi = $max;
 436                         while (--$hi >= $min) {
 437                                 my $ok;
 438                                 $self->get_log([$longest_path], $min, $hi,
 439                                                0, 1, 1, sub {
 440                                                $ok = $_[1];
 441                                                $revs{$_[1]} = _cb(@_) });
 442                                 if ($ok) {
 443                                         print STDERR "r$min .. r$ok OK\n";
 444                                         last;
 445                                 }
 446                         }
 447                         $find_trailing_edge = 0;
 448                 }
 449                 $SVN::Error::handler = $err_handler;
 450
 451                 my %exists = map { $_->path => $_ } @$gsv;
 452                 foreach my $r (sort {$a <=> $b} keys %revs) {
 453                         my ($paths, $logged) = @{delete $revs{$r}};
 454
 455                         foreach my $gs ($self->match_globs(\%exists, $paths,
 456                                                            $globs, $r)) {
 457                                 if ($gs->rev_map_max >= $r) {
 458                                         next;
 459                                 }
 460                                 next unless $gs->match_paths($paths, $r);
 461                                 $gs->{logged_rev_props} = $logged;
 462                                 if (my $last_commit = $gs->last_commit) {
 463                                         $gs->assert_index_clean($last_commit);
 464                                 }
 465                                 my $log_entry = $gs->do_fetch($paths, $r);
 466                                 if ($log_entry) {
 467                                         $gs->do_git_commit($log_entry);
 468                                 }
 469                                 $Git::SVN::INDEX_FILES{$gs->{index}} = 1;
 470                         }
 471                         foreach my $g (@$globs) {
 472                                 my $k = "svn-remote.$g->{remote}." .
 473                                         "$g->{t}-maxRev";
 474                                 Git::SVN::tmp_config($k, $r);
 475                         }
 476                         $reload_ra->() if $ra_invalid;
 477                 }
 478                 # pre-fill the .rev_db since it'll eventually get filled in
 479                 # with '0' x40 if something new gets committed
 480                 foreach my $gs (@$gsv) {
 481                         next if $gs->rev_map_max >= $max;
 482                         next if defined $gs->rev_map_get($max);
 483                         $gs->rev_map_set($max, 0 x40);
 484                 }
 485                 foreach my $g (@$globs) {
 486                         my $k = "svn-remote.$g->{remote}.$g->{t}-maxRev";
 487                         Git::SVN::tmp_config($k, $max);
 488                 }
 489                 last if $max >= $head;
 490                 $min = $max + 1;
 491                 $max += $inc;
 492                 $max = $head if ($max > $head);
 493
 494                 $reload_ra->();
 495         }
 496         Git::SVN::gc();
 497 }
 498
 499 sub get_dir_globbed {
 500         my ($self, $left, $depth, $r) = @_;
 501
 502         my @x = eval { $self->get_dir($left, $r) };
 503         return unless scalar @x == 3;
 504         my $dirents = $x[0];
 505         my @finalents;
 506         foreach my $de (keys %$dirents) {
 507                 next if $dirents->{$de}->{kind} != $SVN::Node::dir;
 508                 if ($depth > 1) {
 509                         my @args = ("$left/$de", $depth - 1, $r);
 510                         foreach my $dir ($self->get_dir_globbed(@args)) {
 511                                 push @finalents, "$de/$dir";
 512                         }
 513                 } else {
 514                         push @finalents, $de;
 515                 }
 516         }
 517         @finalents;
 518 }
 519
 520 # return value: 0 -- don't ignore, 1 -- ignore
 521 sub is_ref_ignored {
 522         my ($g, $p) = @_;
 523         my $refname = $g->{ref}->full_path($p);
 524         return 1 if defined($g->{ignore_refs_regex}) &&
 525                     $refname =~ m!$g->{ignore_refs_regex}!;
 526         return 0 unless defined($_ignore_refs_regex);
 527         return 1 if $refname =~ m!$_ignore_refs_regex!o;
 528         return 0;
 529 }
 530
 531 sub match_globs {
 532         my ($self, $exists, $paths, $globs, $r) = @_;
 533
 534         sub get_dir_check {
 535                 my ($self, $exists, $g, $r) = @_;
 536
 537                 my @dirs = $self->get_dir_globbed($g->{path}->{left},
 538                                                   $g->{path}->{depth},
 539                                                   $r);
 540
 541                 foreach my $de (@dirs) {
 542                         my $p = $g->{path}->full_path($de);
 543                         next if $exists->{$p};
 544                         next if (length $g->{path}->{right} &&
 545                                  ($self->check_path($p, $r) !=
 546                                   $SVN::Node::dir));
 547                         next unless $p =~ /$g->{path}->{regex}/;
 548                         $exists->{$p} = Git::SVN->init($self->url, $p, undef,
 549                                          $g->{ref}->full_path($de), 1);
 550                 }
 551         }
 552         foreach my $g (@$globs) {
 553                 if (my $path = $paths->{"/$g->{path}->{left}"}) {
 554                         if ($path->{action} =~ /^[AR]$/) {
 555                                 get_dir_check($self, $exists, $g, $r);
 556                         }
 557                 }
 558                 foreach (keys %$paths) {
 559                         if (/$g->{path}->{left_regex}/ &&
 560                             !/$g->{path}->{regex}/) {
 561                                 next if $paths->{$_}->{action} !~ /^[AR]$/;
 562                                 get_dir_check($self, $exists, $g, $r);
 563                         }
 564                         next unless /$g->{path}->{regex}/;
 565                         my $p = $1;
 566                         my $pathname = $g->{path}->full_path($p);
 567                         next if is_ref_ignored($g, $p);
 568                         next if $exists->{$pathname};
 569                         next if ($self->check_path($pathname, $r) !=
 570                                  $SVN::Node::dir);
 571                         $exists->{$pathname} = Git::SVN->init(
 572                                               $self->url, $pathname, undef,
 573                                               $g->{ref}->full_path($p), 1);
 574                 }
 575                 my $c = '';
 576                 foreach (split m#/#, $g->{path}->{left}) {
 577                         $c .= "/$_";
 578                         next unless ($paths->{$c} &&
 579                                      ($paths->{$c}->{action} =~ /^[AR]$/));
 580                         get_dir_check($self, $exists, $g, $r);
 581                 }
 582         }
 583         values %$exists;
 584 }
 585
 586 sub minimize_url {
 587         my ($self) = @_;
 588         return $self->url if ($self->url eq $self->{repos_root});
 589         my $url = $self->{repos_root};
 590         my @components = split(m!/!, $self->{svn_path});
 591         my $c = '';
 592         do {
 593                 $url = add_path_to_url($url, $c);
 594                 eval {
 595                         my $ra = (ref $self)->new($url);
 596                         my $latest = $ra->get_latest_revnum;
 597                         $ra->get_log("", $latest, 0, 1, 0, 1, sub {});
 598                 };
 599         } while ($@ && ($c = shift @components));
 600
 601         return canonicalize_url($url);
 602 }
 603
 604 sub can_do_switch {
 605         my $self = shift;
 606         unless (defined $can_do_switch) {
 607                 my $pool = SVN::Pool->new;
 608                 my $rep = eval {
 609                         $self->do_switch(1, '', 0, $self->url,
 610                                          SVN::Delta::Editor->new, $pool);
 611                 };
 612                 if ($@) {
 613                         $can_do_switch = 0;
 614                 } else {
 615                         $rep->abort_report($pool);
 616                         $can_do_switch = 1;
 617                 }
 618                 $pool->clear;
 619         }
 620         $can_do_switch;
 621 }
 622
 623 sub skip_unknown_revs {
 624         my ($err) = @_;
 625         my $errno = $err->apr_err();
 626         # Maybe the branch we're tracking didn't
 627         # exist when the repo started, so it's
 628         # not an error if it doesn't, just continue
 629         #
 630         # Wonderfully consistent library, eh?
 631         # 160013 - svn:// and file://
 632         # 175002 - http(s)://
 633         # 175007 - http(s):// (this repo required authorization, too...)
 634         #   More codes may be discovered later...
 635         if ($errno == 175007 || $errno == 175002 || $errno == 160013) {
 636                 my $err_key = $err->expanded_message;
 637                 # revision numbers change every time, filter them out
 638                 $err_key =~ s/\d+/\0/g;
 639                 $err_key = "$errno\0$err_key";
 640                 unless ($ignored_err{$err_key}) {
 641                         warn "W: Ignoring error from SVN, path probably ",
 642                              "does not exist: ($errno): ",
 643                              $err->expanded_message,"\n";
 644                         warn "W: Do not be alarmed at the above message ",
 645                              "git-svn is just searching aggressively for ",
 646                              "old history.\n",
 647                              "This may take a while on large repositories\n";
 648                         $ignored_err{$err_key} = 1;
 649                 }
 650                 return;
 651         }
 652         die "Error from SVN, ($errno): ", $err->expanded_message,"\n";
 653 }
 654
 655 1;
 656 __END__
 657
 658 =head1 NAME
 659
 660 Git::SVN::Ra - Subversion remote access functions for git-svn
 661
 662 =head1 SYNOPSIS
 663
 664     use Git::SVN::Ra;
 665
 666     my $ra = Git::SVN::Ra->new($branchurl);
 667     my ($dirents, $fetched_revnum, $props) =
 668         $ra->get_dir('.', $SVN::Core::INVALID_REVNUM);
 669
 670 =head1 DESCRIPTION
 671
 672 This is a wrapper around the L<SVN::Ra> module for use by B<git-svn>.
 673 It fills in some default parameters (such as the authentication
 674 scheme), smooths over incompatibilities between libsvn versions, adds
 675 caching, and implements some functions specific to B<git-svn>.
 676
 677 Do not use it unless you are developing git-svn.  The interface will
 678 change as git-svn evolves.
 679
 680 =head1 DEPENDENCIES
 681
 682 Subversion perl bindings,
 683 L<Git::SVN>.
 684
 685 C<Git::SVN::Ra> has not been tested using callers other than
 686 B<git-svn> itself.
 687
 688 =head1 SEE ALSO
 689
 690 L<SVN::Ra>.
 691
 692 =head1 INCOMPATIBILITIES
 693
 694 None reported.
 695
 696 =head1 BUGS
 697
 698 None.