'Valid-responses' => \&req_Validresponses,
'valid-requests' => \&req_validrequests,
'Directory' => \&req_Directory,
+ 'Sticky' => \&req_Sticky,
'Entry' => \&req_Entry,
'Modified' => \&req_Modified,
'Unchanged' => \&req_Unchanged,
{
$log->info("Setting prepend to '$state->{path}'");
$state->{prependdir} = $state->{path};
+ my %entries;
foreach my $entry ( keys %{$state->{entries}} )
{
- $state->{entries}{$state->{prependdir} . $entry} = $state->{entries}{$entry};
- delete $state->{entries}{$entry};
+ $entries{$state->{prependdir} . $entry} = $state->{entries}{$entry};
}
+ $state->{entries}=\%entries;
+
+ my %dirMap;
+ foreach my $dir ( keys %{$state->{dirMap}} )
+ {
+ $dirMap{$state->{prependdir} . $dir} = $state->{dirMap}{$dir};
+ }
+ $state->{dirMap}=\%dirMap;
}
if ( defined ( $state->{prependdir} ) )
$log->debug("Prepending '$state->{prependdir}' to state|directory");
$state->{directory} = $state->{prependdir} . $state->{directory}
}
+
+ if ( ! defined($state->{dirMap}{$state->{directory}}) )
+ {
+ $state->{dirMap}{$state->{directory}} =
+ {
+ 'names' => {}
+ #'tagspec' => undef
+ };
+ }
+
$log->debug("req_Directory : localdir=$data repository=$repository path=$state->{path} directory=$state->{directory} module=$state->{module}");
}
+# Sticky tagspec \n
+# Response expected: no. Tell the server that the directory most
+# recently specified with Directory has a sticky tag or date
+# tagspec. The first character of tagspec is T for a tag, D for
+# a date, or some other character supplied by a Set-sticky
+# response from a previous request to the server. The remainder
+# of tagspec contains the actual tag or date, again as supplied
+# by Set-sticky.
+# The server should remember Static-directory and Sticky requests
+# for a particular directory; the client need not resend them each
+# time it sends a Directory request for a given directory. However,
+# the server is not obliged to remember them beyond the context
+# of a single command.
+sub req_Sticky
+{
+ my ( $cmd, $tagspec ) = @_;
+
+ my ( $stickyInfo );
+ if($tagspec eq "")
+ {
+ # nothing
+ }
+ elsif($tagspec=~/^T([^ ]+)\s*$/)
+ {
+ $stickyInfo = { 'tag' => $1 };
+ }
+ elsif($tagspec=~/^D([0-9.]+)\s*$/)
+ {
+ $stickyInfo= { 'date' => $1 };
+ }
+ else
+ {
+ die "Unknown tag_or_date format\n";
+ }
+ $state->{dirMap}{$state->{directory}}{stickyInfo}=$stickyInfo;
+
+ $log->debug("req_Sticky : tagspec=$tagspec repository=$state->{repository}"
+ . " path=$state->{path} directory=$state->{directory}"
+ . " module=$state->{module}");
+}
+
# Entry entry-line \n
# Response expected: no. Tell the server what version of a file is on the
# local machine. The name in entry-line is a name relative to the directory
tag_or_date => $data[5],
};
+ $state->{dirMap}{$state->{directory}}{names}{$data[1]} = 'F';
+
$log->info("Received entry line '$data' => '" . $state->{directory} . $data[1] . "'");
}
}
}
-# This method uses $state->{directory} to populate $state->{args} with a list of filenames
-sub argsfromdir
+# Used by argsfromdir
+sub expandArg
{
- my $updater = shift;
+ my ($updater,$outNameMap,$outDirMap,$path,$isDir) = @_;
- $state->{args} = [] if ( scalar(@{$state->{args}}) == 1 and $state->{args}[0] eq "." );
+ my $fullPath = filecleanup($path);
- return if ( scalar ( @{$state->{args}} ) > 1 );
+ # Is it a directory?
+ if( defined($state->{dirMap}{$fullPath}) ||
+ defined($state->{dirMap}{"$fullPath/"}) )
+ {
+ # It is a directory in the user's sandbox.
+ $isDir=1;
- my @gethead = @{$updater->gethead};
+ if(defined($state->{entries}{$fullPath}))
+ {
+ $log->fatal("Inconsistent file/dir type");
+ die "Inconsistent file/dir type";
+ }
+ }
+ elsif(defined($state->{entries}{$fullPath}))
+ {
+ # It is a file in the user's sandbox.
+ $isDir=0;
+ }
+ my($revDirMap,$otherRevDirMap);
+ if(!defined($isDir) || $isDir)
+ {
+ # Resolve version tree for sticky tag:
+ # (for now we only want list of files for the version, not
+ # particular versions of those files: assume it is a directory
+ # for the moment; ignore Entry's stick tag)
+
+ # Order of precedence of sticky tags:
+ # -A [head]
+ # -r /tag/
+ # [file entry sticky tag, but that is only relevant to files]
+ # [the tag specified in dir req_Sticky]
+ # [the tag specified in a parent dir req_Sticky]
+ # [head]
+ # Also, -r may appear twice (for diff).
+ #
+ # FUTURE: When/if -j (merges) are supported, we also
+ # need to add relevant files from one or two
+ # versions specified with -j.
+
+ if(exists($state->{opt}{A}))
+ {
+ $revDirMap=$updater->getRevisionDirMap();
+ }
+ elsif( defined($state->{opt}{r}) and
+ ref $state->{opt}{r} eq "ARRAY" )
+ {
+ $revDirMap=$updater->getRevisionDirMap($state->{opt}{r}[0]);
+ $otherRevDirMap=$updater->getRevisionDirMap($state->{opt}{r}[1]);
+ }
+ elsif(defined($state->{opt}{r}))
+ {
+ $revDirMap=$updater->getRevisionDirMap($state->{opt}{r});
+ }
+ else
+ {
+ my($sticky)=getDirStickyInfo($fullPath);
+ $revDirMap=$updater->getRevisionDirMap($sticky->{tag});
+ }
- # push added files
- foreach my $file (keys %{$state->{entries}}) {
- if ( exists $state->{entries}{$file}{revision} &&
- $state->{entries}{$file}{revision} eq '0' )
- {
- push @gethead, { name => $file, filehash => 'added' };
- }
+ # Is it a directory?
+ if( defined($revDirMap->{$fullPath}) ||
+ defined($otherRevDirMap->{$fullPath}) )
+ {
+ $isDir=1;
+ }
}
- if ( scalar(@{$state->{args}}) == 1 )
+ # What to do with it?
+ if(!$isDir)
+ {
+ $outNameMap->{$fullPath}=1;
+ }
+ else
{
- my $arg = $state->{args}[0];
- $arg .= $state->{prependdir} if ( defined ( $state->{prependdir} ) );
+ $outDirMap->{$fullPath}=1;
- $log->info("Only one arg specified, checking for directory expansion on '$arg'");
+ if(defined($revDirMap->{$fullPath}))
+ {
+ addDirMapFiles($updater,$outNameMap,$outDirMap,
+ $revDirMap->{$fullPath});
+ }
+ if( defined($otherRevDirMap) &&
+ defined($otherRevDirMap->{$fullPath}) )
+ {
+ addDirMapFiles($updater,$outNameMap,$outDirMap,
+ $otherRevDirMap->{$fullPath});
+ }
+ }
+}
+
+# Used by argsfromdir
+# Add entries from dirMap to outNameMap. Also recurse into entries
+# that are subdirectories.
+sub addDirMapFiles
+{
+ my($updater,$outNameMap,$outDirMap,$dirMap)=@_;
- foreach my $file ( @gethead )
+ my($fullName);
+ foreach $fullName (keys(%$dirMap))
+ {
+ my $cleanName=$fullName;
+ if(defined($state->{prependdir}))
{
- next if ( $file->{filehash} eq "deleted" and not defined ( $state->{entries}{$file->{name}} ) );
- next unless ( $file->{name} =~ /^$arg\// or $file->{name} eq $arg );
- push @{$state->{args}}, $file->{name};
+ if(!($cleanName=~s/^\Q$state->{prependdir}\E//))
+ {
+ $log->fatal("internal error stripping prependdir");
+ die "internal error stripping prependdir";
+ }
}
- shift @{$state->{args}} if ( scalar(@{$state->{args}}) > 1 );
- } else {
- $log->info("Only one arg specified, populating file list automatically");
+ if($dirMap->{$fullName} eq "F")
+ {
+ $outNameMap->{$cleanName}=1;
+ }
+ elsif($dirMap->{$fullName} eq "D")
+ {
+ if(!$state->{opt}{l})
+ {
+ expandArg($updater,$outNameMap,$outDirMap,$cleanName,1);
+ }
+ }
+ else
+ {
+ $log->fatal("internal error in addDirMapFiles");
+ die "internal error in addDirMapFiles";
+ }
+ }
+}
- $state->{args} = [];
+# This method replaces $state->{args} with a directory-expanded
+# list of all relevant filenames (recursively unless -d), based
+# on $state->{entries}, and the "current" list of files in
+# each directory. "Current" files as determined by
+# either the requested (-r/-A) or "req_Sticky" version of
+# that directory.
+# Both the input args and the new output args are relative
+# to the cvs-client's CWD, although some of the internal
+# computations are relative to the top of the project.
+sub argsfromdir
+{
+ my $updater = shift;
- foreach my $file ( @gethead )
+ # Notes about requirements for specific callers:
+ # update # "standard" case (entries; a single -r/-A/default; -l)
+ # # Special case: -d for create missing directories.
+ # diff # 0 or 1 -r's: "standard" case.
+ # # 2 -r's: We could ignore entries (just use the two -r's),
+ # # but it doesn't really matter.
+ # annotate # "standard" case
+ # log # Punting: log -r has a more complex non-"standard"
+ # # meaning, and we don't currently try to support log'ing
+ # # branches at all (need a lot of work to
+ # # support CVS-consistent branch relative version
+ # # numbering).
+#HERE: But we still want to expand directories. Maybe we should
+# essentially force "-A".
+ # status # "standard", except that -r/-A/default are not possible.
+ # # Mostly only used to expand entries only)
+ #
+ # Don't use argsfromdir at all:
+ # add # Explicit arguments required. Directory args imply add
+ # # the directory itself, not the files in it.
+ # co # Obtain list directly.
+ # remove # HERE: TEST: MAYBE client does the recursion for us,
+ # # since it only makes sense to remove stuff already in
+ # # the sandobx?
+ # ci # HERE: Similar to remove...
+ # # Don't try to implement the confusing/weird
+ # # ci -r bug er.."feature".
+
+ if(scalar(@{$state->{args}})==0)
+ {
+ $state->{args} = [ "." ];
+ }
+ my %allArgs;
+ my %allDirs;
+ for my $file (@{$state->{args}})
+ {
+ expandArg($updater,\%allArgs,\%allDirs,$file);
+ }
+
+ # Include any entries from sandbox. Generally client won't
+ # send entries that shouldn't be used.
+ foreach my $file (keys %{$state->{entries}})
+ {
+ $allArgs{remove_prependdir($file)} = 1;
+ }
+
+ $state->{dirArgs} = \%allDirs;
+ $state->{args} = [
+ sort {
+ # Sort priority: by directory depth, then actual file name:
+ my @piecesA=split('/',$a);
+ my @piecesB=split('/',$b);
+
+ my $count=scalar(@piecesA);
+ my $tmp=scalar(@piecesB);
+ return $count<=>$tmp if($count!=$tmp);
+
+ for($tmp=0;$tmp<$count;$tmp++)
+ {
+ if($piecesA[$tmp] ne $piecesB[$tmp])
+ {
+ return $piecesA[$tmp] cmp $piecesB[$tmp]
+ }
+ }
+ return 0;
+ } keys(%allArgs) ];
+}
+
+## look up directory sticky tag, of either fullPath or a parent:
+sub getDirStickyInfo
+{
+ my($fullPath)=@_;
+
+ $fullPath=~s%/+$%%;
+ while($fullPath ne "" && !defined($state->{dirMap}{"$fullPath/"}))
+ {
+ $fullPath=~s%/?[^/]*$%%;
+ }
+
+ if( !defined($state->{dirMap}{"$fullPath/"}) &&
+ ( $fullPath eq "" ||
+ $fullPath eq "." ) )
+ {
+ return $state->{dirMap}{""}{stickyInfo};
+ }
+ else
+ {
+ return $state->{dirMap}{"$fullPath/"}{stickyInfo};
+ }
+}
+
+# Resolve precedence of various ways of specifying which version of
+# a file you want. Returns undef (for default head), or a ref to a hash
+# that contains "tag" and/or "date" keys.
+sub resolveStickyInfo
+{
+ my($filename,$stickyTag,$stickyDate,$reset) = @_;
+
+ # Order of precedence of sticky tags:
+ # -A [head]
+ # -r /tag/
+ # [file entry sticky tag]
+ # [the tag specified in dir req_Sticky]
+ # [the tag specified in a parent dir req_Sticky]
+ # [head]
+
+ my $result;
+ if($reset)
+ {
+ # $result=undef;
+ }
+ elsif( defined($stickyTag) && $stickyTag ne "" )
+ # || ( defined($stickyDate) && $stickyDate ne "" ) # TODO
+ {
+ $result={ 'tag' => (defined($stickyTag)?$stickyTag:undef) };
+
+ # TODO: Convert -D value into the form 2011.04.10.04.46.57,
+ # similar to an entry line's sticky date, without the D prefix.
+ # It sometimes (always?) arrives as something more like
+ # '10 Apr 2011 04:46:57 -0000'...
+ # $result={ 'date' => (defined($stickyDate)?$stickyDate:undef) };
+ }
+ elsif( defined($state->{entries}{$filename}) &&
+ defined($state->{entries}{$filename}{tag_or_date}) &&
+ $state->{entries}{$filename}{tag_or_date} ne "" )
+ {
+ my($tagOrDate)=$state->{entries}{$filename}{tag_or_date};
+ if($tagOrDate=~/^T([^ ]+)\s*$/)
+ {
+ $result = { 'tag' => $1 };
+ }
+ elsif($tagOrDate=~/^D([0-9.]+)\s*$/)
{
- next if ( $file->{filehash} eq "deleted" and not defined ( $state->{entries}{$file->{name}} ) );
- next unless ( $file->{name} =~ s/^$state->{prependdir}// );
- push @{$state->{args}}, $file->{name};
+ $result= { 'date' => $1 };
+ }
+ else
+ {
+ die "Unknown tag_or_date format\n";
}
}
+ else
+ {
+ $result=getDirStickyInfo($filename);
+ }
+
+ return $result;
+}
+
+# Convert a stickyInfo (ref to a hash) as returned by resolveStickyInfo into
+# a form appropriate for the sticky tag field of an Entries
+# line (field index 5, 0-based).
+sub getStickyTagOrDate
+{
+ my($stickyInfo)=@_;
+
+ my $result;
+ if(defined($stickyInfo) && defined($stickyInfo->{tag}))
+ {
+ $result="T$stickyInfo->{tag}";
+ }
+ # TODO: When/if we actually pick versions by {date} properly,
+ # also handle it here:
+ # "D$stickyInfo->{date}" (example: "D2011.04.13.20.37.07").
+ else
+ {
+ $result="";
+ }
+
+ return $result;
}
# This method cleans up the $state variable after a command that uses arguments has run
sub statecleanup
{
$state->{files} = [];
+ $state->{dirArgs} = {};
$state->{args} = [];
$state->{arguments} = [];
$state->{entries} = {};
+ $state->{dirMap} = {};
}
# Return working directory CVS revision "1.X" out
die "Git repo '$self->{git_path}' doesn't exist" unless ( -d $self->{git_path} );
+ # Stores full sha1's for various branch/tag names, abbreviations, etc:
+ $self->{commitRefCache} = {};
+
$self->{dbdriver} = $cfg->{gitcvs}{$state->{method}}{dbdriver} ||
$cfg->{gitcvs}{dbdriver} || "SQLite";
$self->{dbname} = $cfg->{gitcvs}{$state->{method}}{dbname} ||
);
}
# invalidate the gethead cache
- $self->{gethead_cache} = undef;
+ $self->clearCommitRefCaches();
# Ending exclusive lock here
return $tree;
}
+=head2 getAnyHead
+
+Returns a reference to an array of getmeta structures, one
+per file in the specified tree hash.
+
+=cut
+
+sub getAnyHead
+{
+ my ($self,$hash) = @_;
+
+ if(!defined($hash))
+ {
+ return $self->gethead();
+ }
+
+ my @files;
+ {
+ open(my $filePipe, '-|', 'git', 'ls-tree', '-z', '-r', $hash)
+ or die("Cannot call git-ls-tree : $!");
+ local $/ = "\0";
+ @files=<$filePipe>;
+ close $filePipe;
+ }
+
+ my $tree=[];
+ my($line);
+ foreach $line (@files)
+ {
+ $line=~s/\0$//;
+ unless ( $line=~/^(\d+)\s+(\w+)\s+([a-zA-Z0-9]+)\t(.*)$/o )
+ {
+ die("Couldn't process git-ls-tree line : $_");
+ }
+
+ my($mode, $git_type, $git_hash, $git_filename) = ($1, $2, $3, $4);
+ push @$tree, $self->getMetaFromCommithash($git_filename,$hash);
+ }
+
+ return $tree;
+}
+
+=head2 getRevisionDirMap
+
+A "revision dir map" contains all the plain-file filenames associated
+with a particular revision (treeish), organized by directory:
+
+ $type = $out->{$dir}{$fullName}
+
+The type of each is "F" (for ordinary file) or "D" (for directory,
+for which the map $out->{$fullName} will also exist).
+
+=cut
+
+sub getRevisionDirMap
+{
+ my ($self,$ver)=@_;
+
+ if(!defined($self->{revisionDirMapCache}))
+ {
+ $self->{revisionDirMapCache}={};
+ }
+
+ # Get file list (previously cached results are dependent on HEAD,
+ # but are early in each case):
+ my $cacheKey;
+ my (@fileList);
+ if( !defined($ver) || $ver eq "" )
+ {
+ $cacheKey="";
+ if( defined($self->{revisionDirMapCache}{$cacheKey}) )
+ {
+ return $self->{revisionDirMapCache}{$cacheKey};
+ }
+
+ my @head = @{$self->gethead()};
+ foreach my $file ( @head )
+ {
+ next if ( $file->{filehash} eq "deleted" );
+
+ push @fileList,$file->{name};
+ }
+ }
+ else
+ {
+ my ($hash)=$self->lookupCommitRef($ver);
+ if( !defined($hash) )
+ {
+ return undef;
+ }
+
+ $cacheKey=$hash;
+ if( defined($self->{revisionDirMapCache}{$cacheKey}) )
+ {
+ return $self->{revisionDirMapCache}{$cacheKey};
+ }
+
+ open(my $filePipe, '-|', 'git', 'ls-tree', '-z', '-r', $hash)
+ or die("Cannot call git-ls-tree : $!");
+ local $/ = "\0";
+ while ( <$filePipe> )
+ {
+ chomp;
+ unless ( /^(\d+)\s+(\w+)\s+([a-zA-Z0-9]+)\t(.*)$/o )
+ {
+ die("Couldn't process git-ls-tree line : $_");
+ }
+
+ my($mode, $git_type, $git_hash, $git_filename) = ($1, $2, $3, $4);
+
+ push @fileList, $git_filename;
+ }
+ close $filePipe;
+ }
+
+ # Convert to normalized form:
+ my %revMap;
+ my $file;
+ foreach $file (@fileList)
+ {
+ my($dir) = ($file=~m%^(?:(.*)/)?([^/]*)$%);
+ $dir='' if(!defined($dir));
+
+ # parent directories:
+ # ... create empty dir maps for parent dirs:
+ my($td)=$dir;
+ while(!defined($revMap{$td}))
+ {
+ $revMap{$td}={};
+
+ my($tp)=($td=~m%^(?:(.*)/)?([^/]*)$%);
+ $tp='' if(!defined($tp));
+ $td=$tp;
+ }
+ # ... add children to parent maps (now that they exist):
+ $td=$dir;
+ while($td ne "")
+ {
+ my($tp)=($td=~m%^(?:(.*)/)?([^/]*)$%);
+ $tp='' if(!defined($tp));
+
+ if(defined($revMap{$tp}{$td}))
+ {
+ if($revMap{$tp}{$td} ne 'D')
+ {
+ die "Weird file/directory inconsistency in $cacheKey";
+ }
+ last; # loop exit
+ }
+ $revMap{$tp}{$td}='D';
+
+ $td=$tp;
+ }
+
+ # file
+ $revMap{$dir}{$file}='F';
+ }
+
+ # Save in cache:
+ $self->{revisionDirMapCache}{$cacheKey}=\%revMap;
+ return $self->{revisionDirMapCache}{$cacheKey};
+}
+
=head2 getlog
See also gethistorydense().
This function takes a filename (with path) argument and returns a hashref of
metadata for that file.
+There are several ways $revision can be specified:
+
+ - A reference to hash that contains a "tag" that is the
+ actual revision (one of the below). TODO: Also allow it to
+ specify a "date" in the hash.
+ - undef, to refer to the latest version on the main branch.
+ - Full CVS client revision number (mapped to integer in DB, without the
+ "1." prefix),
+ - Complex CVS-compatible "special" revision number for
+ non-linear history (see comment below)
+ - git commit sha1 hash
+ - branch or tag name
+
=cut
sub getmeta
my $tablename_rev = $self->tablename("revision");
my $tablename_head = $self->tablename("head");
- my $db_query;
- if ( defined($revision) and $revision =~ /^1\.(\d+)$/ )
+ if ( ref($revision) eq "HASH" )
{
- my ($intRev) = $1;
- $db_query = $self->{dbh}->prepare_cached("SELECT * FROM $tablename_rev WHERE name=? AND revision=?",{},1);
- $db_query->execute($filename, $intRev);
+ $revision = $revision->{tag};
}
- elsif ( defined($revision) and $revision =~ /^[a-zA-Z0-9]{40}$/ )
+
+ # Overview of CVS revision numbers:
+ #
+ # General CVS numbering scheme:
+ # - Basic mainline branch numbers: "1.1", "1.2", "1.3", etc.
+ # - Result of "cvs checkin -r" (possible, but not really
+ # recommended): "2.1", "2.2", etc
+ # - Branch tag: "1.2.0.n", where "1.2" is revision it was branched
+ # from, "0" is a magic placeholder that identifies it as a
+ # branch tag instead of a version tag, and n is 2 times the
+ # branch number off of "1.2", starting with "2".
+ # - Version on a branch: "1.2.n.x", where "1.2" is branch-from, "n"
+ # is branch number off of "1.2" (like n above), and "x" is
+ # the version number on the branch.
+ # - Branches can branch off of branches: "1.3.2.7.4.1" (even number
+ # of components).
+ # - Odd "n"s are used by "vendor branches" that result
+ # from "cvs import". Vendor branches have additional
+ # strangeness in the sense that the main rcs "head" of the main
+ # branch will (temporarily until first normal commit) point
+ # to the version on the vendor branch, rather than the actual
+ # main branch. (FUTURE: This may provide an opportunity
+ # to use "strange" revision numbers for fast-forward-merged
+ # branch tip when CVS client is asking for the main branch.)
+ #
+ # git-cvsserver CVS-compatible special numbering schemes:
+ # - Currently git-cvsserver only tries to be identical to CVS for
+ # simple "1.x" numbers on the "main" branch (as identified
+ # by the module name that was originally cvs checkout'ed).
+ # - The database only stores the "x" part, for historical reasons.
+ # But most of the rest of the cvsserver preserves
+ # and thinks using the full revision number.
+ # - To handle non-linear history, it uses a version of the form
+ # "2.1.1.2000.b.b.b."..., where the 2.1.1.2000 is to help uniquely
+ # identify this as a special revision number, and there are
+ # 20 b's that together encode the sha1 git commit from which
+ # this version of this file originated. Each b is
+ # the numerical value of the corresponding byte plus
+ # 100.
+ # - "plus 100" avoids "0"s, and also reduces the
+ # likelyhood of a collision in the case that someone someday
+ # writes an import tool that tries to preserve original
+ # CVS revision numbers, and the original CVS data had done
+ # lots of branches off of branches and other strangeness to
+ # end up with a real version number that just happens to look
+ # like this special revision number form. Also, if needed
+ # there are several ways to extend/identify alternative encodings
+ # within the "2.1.1.2000" part if necessary.
+ # - Unlike real CVS revisions, you can't really reconstruct what
+ # relation a revision of this form has to other revisions.
+ # - FUTURE: TODO: Rework database somehow to make up and remember
+ # fully-CVS-compatible branches and branch version numbers.
+
+ my $meta;
+ if ( defined($revision) )
{
- $db_query = $self->{dbh}->prepare_cached("SELECT * FROM $tablename_rev WHERE name=? AND commithash=?",{},1);
- $db_query->execute($filename, $revision);
- } else {
- $db_query = $self->{dbh}->prepare_cached("SELECT * FROM $tablename_head WHERE name=?",{},1);
+ if ( $revision =~ /^1\.(\d+)$/ )
+ {
+ my ($intRev) = $1;
+ my $db_query;
+ $db_query = $self->{dbh}->prepare_cached(
+ "SELECT * FROM $tablename_rev WHERE name=? AND revision=?",
+ {},1);
+ $db_query->execute($filename, $intRev);
+ $meta = $db_query->fetchrow_hashref;
+ }
+ elsif ( $revision =~ /^2\.1\.1\.2000(\.[1-3][0-9][0-9]){20}$/ )
+ {
+ my ($commitHash)=($revision=~/^2\.1\.1\.2000(.*)$/);
+ $commitHash=~s/\.([0-9]+)/sprintf("%02x",$1-100)/eg;
+ if($commitHash=~/^[0-9a-f]{40}$/)
+ {
+ return $self->getMetaFromCommithash($filename,$commitHash);
+ }
+
+ # error recovery: fall back on head version below
+ print "E Failed to find $filename version=$revision or commit=$commitHash\n";
+ $log->warning("failed get $revision with commithash=$commitHash");
+ undef $revision;
+ }
+ elsif ( $revision =~ /^[0-9a-f]{40}$/ )
+ {
+ # Try DB first. This is mostly only useful for req_annotate(),
+ # which only calls this for stuff that should already be in
+ # the DB. It is fairly likely to be a waste of time
+ # in most other cases [unless the file happened to be
+ # modified in $revision specifically], but
+ # it is probably in the noise compared to how long
+ # getMetaFromCommithash() will take.
+ my $db_query;
+ $db_query = $self->{dbh}->prepare_cached(
+ "SELECT * FROM $tablename_rev WHERE name=? AND commithash=?",
+ {},1);
+ $db_query->execute($filename, $revision);
+ $meta = $db_query->fetchrow_hashref;
+
+ if(! $meta)
+ {
+ my($revCommit)=$self->lookupCommitRef($revision);
+ if($revCommit=~/^[0-9a-f]{40}$/)
+ {
+ return $self->getMetaFromCommithash($filename,$revCommit);
+ }
+
+ # error recovery: nothing found:
+ print "E Failed to find $filename version=$revision\n";
+ $log->warning("failed get $revision");
+ return $meta;
+ }
+ }
+ else
+ {
+ my($revCommit)=$self->lookupCommitRef($revision);
+ if($revCommit=~/^[0-9a-f]{40}$/)
+ {
+ return $self->getMetaFromCommithash($filename,$revCommit);
+ }
+
+ # error recovery: fall back on head version below
+ print "E Failed to find $filename version=$revision\n";
+ $log->warning("failed get $revision");
+ undef $revision; # Allow fallback
+ }
+ }
+
+ if(!defined($revision))
+ {
+ my $db_query;
+ $db_query = $self->{dbh}->prepare_cached(
+ "SELECT * FROM $tablename_head WHERE name=?",{},1);
$db_query->execute($filename);
+ $meta = $db_query->fetchrow_hashref;
}
- my $meta = $db_query->fetchrow_hashref;
if($meta)
{
$meta->{revision} = "1.$meta->{revision}";
return $meta;
}
+sub getMetaFromCommithash
+{
+ my $self = shift;
+ my $filename = shift;
+ my $revCommit = shift;
+
+ # NOTE: This function doesn't scale well (lots of forks), especially
+ # if you have many files that have not been modified for many commits
+ # (each git-rev-parse redoes a lot of work for each file
+ # that theoretically could be done in parallel by smarter
+ # graph traversal).
+ #
+ # TODO: Possible optimization strategies:
+ # - Solve the issue of assigning and remembering "real" CVS
+ # revision numbers for branches, and ensure the
+ # data structure can do this efficiently. Perhaps something
+ # similar to "git notes", and carefully structured to take
+ # advantage same-sha1-is-same-contents, to roll the same
+ # unmodified subdirectory data onto multiple commits?
+ # - Write and use a C tool that is like git-blame, but
+ # operates on multiple files with file granularity, instead
+ # of one file with line granularity. Cache
+ # most-recently-modified in $self->{commitRefCache}{$revCommit}.
+ # Try to be intelligent about how many files we do with
+ # one fork (perhaps one directory at a time, without recursion,
+ # and/or include directory as one line item, recurse from here
+ # instead of in C tool?).
+ # - Perhaps we could ask the DB for (filename,fileHash),
+ # and just guess that it is correct (that the file hadn't
+ # changed between $revCommit and the found commit, then
+ # changed back, confusing anything trying to interpret
+ # history). Probably need to add another index to revisions
+ # DB table for this.
+ # - NOTE: Trying to store all (commit,file) keys in DB [to
+ # find "lastModfiedCommit] (instead of
+ # just files that changed in each commit as we do now) is
+ # probably not practical from a disk space perspective.
+
+ # Does the file exist in $revCommit?
+ # TODO: Include file hash in dirmap cache.
+ my($dirMap)=$self->getRevisionDirMap($revCommit);
+ my($dir,$file)=($filename=~m%^(?:(.*)/)?([^/]*$)%);
+ if(!defined($dir))
+ {
+ $dir="";
+ }
+ if( !defined($dirMap->{$dir}) ||
+ !defined($dirMap->{$dir}{$filename}) )
+ {
+ my($fileHash)="deleted";
+
+ my($retVal)={};
+ $retVal->{name}=$filename;
+ $retVal->{filehash}=$fileHash;
+
+ # not needed and difficult to compute:
+ $retVal->{revision}="0"; # $revision;
+ $retVal->{commithash}=$revCommit;
+ #$retVal->{author}=$commit->{author};
+ #$retVal->{modified}=convertToCvsDate($commit->{date});
+ #$retVal->{mode}=convertToDbMode($mode);
+
+ return $retVal;
+ }
+
+ my($fileHash)=safe_pipe_capture("git","rev-parse","$revCommit:$filename");
+ chomp $fileHash;
+ if(!($fileHash=~/^[0-9a-f]{40}$/))
+ {
+ die "Invalid fileHash '$fileHash' looking up"
+ ." '$revCommit:$filename'\n";
+ }
+
+ # information about most recent commit to modify $filename:
+ open(my $gitLogPipe, '-|', 'git', 'rev-list',
+ '--max-count=1', '--pretty', '--parents',
+ $revCommit, '--', $filename)
+ or die "Cannot call git-rev-list: $!";
+ my @commits=readCommits($gitLogPipe);
+ close $gitLogPipe;
+ if(scalar(@commits)!=1)
+ {
+ die "Can't find most recent commit changing $filename\n";
+ }
+ my($commit)=$commits[0];
+ if( !defined($commit) || !defined($commit->{hash}) )
+ {
+ return undef;
+ }
+
+ # does this (commit,file) have a real assigned CVS revision number?
+ my $tablename_rev = $self->tablename("revision");
+ my $db_query;
+ $db_query = $self->{dbh}->prepare_cached(
+ "SELECT * FROM $tablename_rev WHERE name=? AND commithash=?",
+ {},1);
+ $db_query->execute($filename, $commit->{hash});
+ my($meta)=$db_query->fetchrow_hashref;
+ if($meta)
+ {
+ $meta->{revision} = "1.$meta->{revision}";
+ return $meta;
+ }
+
+ # fall back on special revision number
+ my($revision)=$commit->{hash};
+ $revision=~s/(..)/'.' . (hex($1)+100)/eg;
+ $revision="2.1.1.2000$revision";
+
+ # meta data about $filename:
+ open(my $filePipe, '-|', 'git', 'ls-tree', '-z',
+ $commit->{hash}, '--', $filename)
+ or die("Cannot call git-ls-tree : $!");
+ local $/ = "\0";
+ my $line;
+ $line=<$filePipe>;
+ if(defined(<$filePipe>))
+ {
+ die "Expected only a single file for git-ls-tree $filename\n";
+ }
+ close $filePipe;
+
+ chomp $line;
+ unless ( $line=~m/^(\d+)\s+(\w+)\s+([a-zA-Z0-9]+)\t(.*)$/o )
+ {
+ die("Couldn't process git-ls-tree line : $line\n");
+ }
+ my ( $mode, $git_type, $git_hash, $git_filename ) = ( $1, $2, $3, $4 );
+
+ # save result:
+ my($retVal)={};
+ $retVal->{name}=$filename;
+ $retVal->{revision}=$revision;
+ $retVal->{filehash}=$fileHash;
+ $retVal->{commithash}=$revCommit;
+ $retVal->{author}=$commit->{author};
+ $retVal->{modified}=convertToCvsDate($commit->{date});
+ $retVal->{mode}=convertToDbMode($mode);
+
+ return $retVal;
+}
+
+=head2 lookupCommitRef
+
+Convert tag/branch/abbreviation/etc into a commit sha1 hash. Caches
+the result so looking it up again is fast.
+
+=cut
+
+sub lookupCommitRef
+{
+ my $self = shift;
+ my $ref = shift;
+
+ my $commitHash = $self->{commitRefCache}{$ref};
+ if(defined($commitHash))
+ {
+ return $commitHash;
+ }
+
+ $commitHash=safe_pipe_capture("git","rev-parse","--verify","--quiet",
+ $self->unescapeRefName($ref));
+ $commitHash=~s/\s*$//;
+ if(!($commitHash=~/^[0-9a-f]{40}$/))
+ {
+ $commitHash=undef;
+ }
+
+ if( defined($commitHash) )
+ {
+ my $type=safe_pipe_capture("git","cat-file","-t",$commitHash);
+ if( ! ($type=~/^commit\s*$/ ) )
+ {
+ $commitHash=undef;
+ }
+ }
+ if(defined($commitHash))
+ {
+ $self->{commitRefCache}{$ref}=$commitHash;
+ }
+ return $commitHash;
+}
+
+=head2 clearCommitRefCaches
+
+Clears cached commit cache (sha1's for various tags/abbeviations/etc),
+and related caches.
+
+=cut
+
+sub clearCommitRefCaches
+{
+ my $self = shift;
+ $self->{commitRefCache} = {};
+ $self->{revisionDirMapCache} = undef;
+ $self->{gethead_cache} = undef;
+}
+
=head2 commitmessage
this function takes a commithash and returns the commit message for that commit