mirror of
https://github.com/git/git.git
synced 2024-11-15 05:33:04 +01:00
68f532f4ba
Since v1.7.0-rc2~11 (git-svn: persistent memoization, 2010-01-30), git-svn has maintained some private per-repository caches in .git/svn/.caches to avoid refetching and recalculating some mergeinfo-related information with every "git svn fetch". These caches use the 'nstore' format from the perl core module Storable, which can be read and written quickly and was designed for transfer over the wire (the 'n' stands for 'network'). This format is endianness-independent and independent of floating-point representation. Unfortunately the format is *not* independent of the perl version --- new perl versions will write files that very old perl cannot read. Worse, the format is not independent of the size of a perl integer. So if you toggle perl's use64bitint compile-time option, then using 'git svn fetch' on your old repositories produces errors like this: Byte order is not compatible at ../../lib/Storable.pm (autosplit into ../../lib/auto/Storable/_retrieve.al) line 380, at /usr/share/perl/5.12/Memoize/Storable.pm line 21 That is, upgrading perl to a version that uses use64bitint for the first time makes git-svn suddenly refuse to fetch in existing repositories. Removing .git/svn/.caches lets git-svn recover. It's time to switch to a platform independent serializer backend with better compatibility guarantees. This patch uses YAML::Any. Other choices were considered: - thawing data from Data::Dumper involves "eval". Doing that without creating a security risk is fussy. - the JSON API works on scalars in memory and doesn't provide a standard way to serialize straight to disk. YAML::Any is reasonably fast and has a pleasant API. In most backends, LoadFile() reads the entire file into a scalar anyway and converts it as a second step, but having an interface that allows the deserialization to happen on the fly without a temporary is still a comfort. YAML::Any is not a core perl module, so we take care to use it when and only when it is available. Installations without that module should fall back to using Storable with all its quirks, keeping their cache files in .git/svn/.caches/*.db Installations with YAML peacefully coexist by keeping a separate set of cache files in .git/svn/.caches/*.yaml. In most cases, switching between is a one-time thing, so it doesn't seem worth the complication to migrate existing caches. The upshot: after this patch, as long as YAML::Any is installed you can move your git repository between machines with different perl installations and "git svn fetch" will work fine. If you do not have YAML::Any, the behavior is unchanged (and in particular does not get any worse). Reported-by: Sandro Weiser <sandro.weiser@informatik.tu-chemnitz.de> Reported-by: Bdale Garbee <bdale@gag.com> Signed-off-by: Jonathan Nieder <jrnieder@gmail.com> Signed-off-by: Eric Wong <normalperson@yhbt.net>
93 lines
1.7 KiB
Perl
93 lines
1.7 KiB
Perl
package Git::SVN::Memoize::YAML;
|
|
use warnings;
|
|
use strict;
|
|
use YAML::Any ();
|
|
|
|
# based on Memoize::Storable.
|
|
|
|
sub TIEHASH {
|
|
my $package = shift;
|
|
my $filename = shift;
|
|
my $truehash = (-e $filename) ? YAML::Any::LoadFile($filename) : {};
|
|
my $self = {FILENAME => $filename, H => $truehash};
|
|
bless $self => $package;
|
|
}
|
|
|
|
sub STORE {
|
|
my $self = shift;
|
|
$self->{H}{$_[0]} = $_[1];
|
|
}
|
|
|
|
sub FETCH {
|
|
my $self = shift;
|
|
$self->{H}{$_[0]};
|
|
}
|
|
|
|
sub EXISTS {
|
|
my $self = shift;
|
|
exists $self->{H}{$_[0]};
|
|
}
|
|
|
|
sub DESTROY {
|
|
my $self = shift;
|
|
YAML::Any::DumpFile($self->{FILENAME}, $self->{H});
|
|
}
|
|
|
|
sub SCALAR {
|
|
my $self = shift;
|
|
scalar(%{$self->{H}});
|
|
}
|
|
|
|
sub FIRSTKEY {
|
|
'Fake hash from Git::SVN::Memoize::YAML';
|
|
}
|
|
|
|
sub NEXTKEY {
|
|
undef;
|
|
}
|
|
|
|
1;
|
|
__END__
|
|
|
|
=head1 NAME
|
|
|
|
Git::SVN::Memoize::YAML - store Memoized data in YAML format
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
use Memoize;
|
|
use Git::SVN::Memoize::YAML;
|
|
|
|
tie my %cache => 'Git::SVN::Memoize::YAML', $filename;
|
|
memoize('slow_function', SCALAR_CACHE => [HASH => \%cache]);
|
|
slow_function(arguments);
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
This module provides a class that can be used to tie a hash to a
|
|
YAML file. The file is read when the hash is initialized and
|
|
rewritten when the hash is destroyed.
|
|
|
|
The intent is to allow L<Memoize> to back its cache with a file in
|
|
YAML format, just like L<Memoize::Storable> allows L<Memoize> to
|
|
back its cache with a file in Storable format. Unlike the Storable
|
|
format, the YAML format is platform-independent and fairly stable.
|
|
|
|
Carps on error.
|
|
|
|
=head1 DIAGNOSTICS
|
|
|
|
See L<YAML::Any>.
|
|
|
|
=head1 DEPENDENCIES
|
|
|
|
L<YAML::Any> from CPAN.
|
|
|
|
=head1 INCOMPATIBILITIES
|
|
|
|
None reported.
|
|
|
|
=head1 BUGS
|
|
|
|
The entire cache is read into a Perl hash when loading the file,
|
|
so this is not very scalable.
|