* [PATCHv7.4 1/4] gitweb: Prepare for splitting gitweb
2010-12-03 19:25 [PATCHv7.4 0/4] Gitweb caching v7.2 Jakub Narebski
@ 2010-12-03 19:25 ` Jakub Narebski
2010-12-03 19:25 ` [PATCHv7.4 2/4] gitweb: add output buffering and associated functions Jakub Narebski
` (3 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: Jakub Narebski @ 2010-12-03 19:25 UTC (permalink / raw)
To: git
Cc: John 'Warthog9' Hawley, John 'Warthog9' Hawley,
Junio C Hamano, Thomas Rast, Jakub Narebski
Prepare gitweb for having been split into modules that are to be
installed alongside gitweb in 'lib/' subdirectory, by adding
use lib __DIR__.'/lib';
to gitweb.perl (to main gitweb script), and preparing for putting
modules (relative path) in $(GITWEB_MODULES) in gitweb/Makefile.
This preparatory work allows to add new module to gitweb by simply
adding
GITWEB_MODULES += <module>
to gitweb/Makefile (assuming that the module is in 'gitweb/lib/'
directory).
While at it pass GITWEBLIBDIR in addition to GITWEB_TEST_INSTALLED to
allow testing installed version of gitweb and installed version of
modules (for future tests which would check individual (sub)modules).
Using __DIR__ from Dir::Self module (not in core, that's why currently
gitweb includes excerpt of code from Dir::Self defining __DIR__) was
chosen over using FindBin-based solution (in core since perl 5.00307,
while gitweb itself requires at least perl 5.8.0) because FindBin uses
BEGIN block, which is a problem under mod_perl and other persistent
Perl environments (thought there are workarounds).
At Pavan Kumar Sankara suggestion gitweb/Makefile uses
install [OPTION]... SOURCE... DIRECTORY
format (2nd format) with single SOURCE rather than
install [OPTION]... SOURCE DEST
format (1st format) because of security reasons (race conditions).
Modern GNU install has `-T' / `--no-target-directory' option, but we
cannot rely that the $(INSTALL) we are using supports this option.
The install-modules target in gitweb/Makefile uses shell 'for' loop,
instead of make's $(foreach) function, to avoid possible problem with
generating a command line that exceeded the maximum argument list
length.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
---
BUGFIX: shell variables should not be in single quotes
I am very sorry about this bug...
This version is identical to
[PATCHv7.3 1/4 (bugfix)] gitweb: Prepare for splitting gitweb
Message-Id: <201012021117.16183.jnareb@gmail.com>
http://article.gmane.org/gmane.comp.version-control.git/162690
sent as a separate patch.
gitweb/Makefile | 18 +++++++++++++++---
gitweb/gitweb.perl | 8 ++++++++
2 files changed, 23 insertions(+), 3 deletions(-)
diff --git a/gitweb/Makefile b/gitweb/Makefile
index 0a6ac00..ad5a282 100644
--- a/gitweb/Makefile
+++ b/gitweb/Makefile
@@ -57,6 +57,7 @@ PERL_PATH ?= /usr/bin/perl
bindir_SQ = $(subst ','\'',$(bindir))#'
gitwebdir_SQ = $(subst ','\'',$(gitwebdir))#'
gitwebstaticdir_SQ = $(subst ','\'',$(gitwebdir)/static)#'
+gitweblibdir_SQ = $(subst ','\'',$(gitwebdir)/lib)#'
SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))#'
PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))#'
DESTDIR_SQ = $(subst ','\'',$(DESTDIR))#'
@@ -153,20 +154,31 @@ test:
test-installed:
GITWEB_TEST_INSTALLED='$(DESTDIR_SQ)$(gitwebdir_SQ)' \
+ GITWEBLIBDIR='$(DESTDIR_SQ)$(gitweblibdir_SQ)' \
$(MAKE) -C ../t gitweb-test
### Installation rules
-install: all
+install: all install-modules
$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(gitwebdir_SQ)'
$(INSTALL) -m 755 $(GITWEB_PROGRAMS) '$(DESTDIR_SQ)$(gitwebdir_SQ)'
$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(gitwebstaticdir_SQ)'
$(INSTALL) -m 644 $(GITWEB_FILES) '$(DESTDIR_SQ)$(gitwebstaticdir_SQ)'
+install-modules:
+ install_dirs="$(sort $(dir $(GITWEB_MODULES)))" && \
+ for dir in $$install_dirs; do \
+ test -d '$(DESTDIR_SQ)$(gitweblibdir_SQ)'/"$$dir" || \
+ $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(gitweblibdir_SQ)'/"$$dir"; \
+ done
+ gitweb_modules="$(GITWEB_MODULES)" && \
+ for mod in $$gitweb_modules; do \
+ $(INSTALL) -m 644 "lib/$$mod" '$(DESTDIR_SQ)$(gitweblibdir_SQ)'/"$$(dirname $$mod)"; \
+ done
+
### Cleaning rules
clean:
$(RM) gitweb.cgi static/gitweb.min.js static/gitweb.min.css GITWEB-BUILD-OPTIONS
-.PHONY: all clean install test test-installed .FORCE-GIT-VERSION-FILE FORCE
-
+.PHONY: all clean install install-modules test test-installed .FORCE-GIT-VERSION-FILE FORCE
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index 679f2da..cfa511c 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -10,6 +10,14 @@
use 5.008;
use strict;
use warnings;
+
+use File::Spec;
+# __DIR__ is taken from Dir::Self __DIR__ fragment
+sub __DIR__ () {
+ File::Spec->rel2abs(join '', (File::Spec->splitpath(__FILE__))[0, 1]);
+}
+use lib __DIR__ . '/lib';
+
use CGI qw(:standard :escapeHTML -nosticky);
use CGI::Util qw(unescape);
use CGI::Carp qw(fatalsToBrowser set_message);
--
1.7.3
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCHv7.4 2/4] gitweb: add output buffering and associated functions
2010-12-03 19:25 [PATCHv7.4 0/4] Gitweb caching v7.2 Jakub Narebski
2010-12-03 19:25 ` [PATCHv7.4 1/4] gitweb: Prepare for splitting gitweb Jakub Narebski
@ 2010-12-03 19:25 ` Jakub Narebski
2010-12-03 19:25 ` [PATCHv7.4 3/4] gitweb: File based caching layer (from git.kernel.org) Jakub Narebski
` (2 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: Jakub Narebski @ 2010-12-03 19:25 UTC (permalink / raw)
To: git
Cc: John 'Warthog9' Hawley, John 'Warthog9' Hawley,
Junio C Hamano, Thomas Rast
From: John 'Warthog9' Hawley <warthog9@eaglescrag.net>
This adds output buffering for gitweb, mainly in preparation for
caching support. This is a dramatic change to how caching was being
done, mainly in passing around the variable manually and such.
This centrally flips the entire STDOUT to a variable, which after the
completion of the run, flips it back and does a print on the resulting
data.
This should save on the previous 10K line patch (or so) that adds more
explicit output passing.
[jn: modified reset_output to silence 'gitweb.perl: Name "main::STDOUT_REAL"
used only once: possible typo at ../gitweb/gitweb.perl line 1130.' warning]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
Reminder: it uses
open STDOUT, ">&", \*STDOUT_REAL;
rather than
open(STDOUT,">&STDOUT_REAL");
to silence spurious (invalid) warning
gitweb.perl: Name "main::STDOUT_REAL" used only once: possible typo
at ../gitweb/gitweb.perl line 1130.
This version is identical to
[PATCHv7.1 2/4] gitweb: add output buffering and associated functions
Message-Id: <1288607092-31458-3-git-send-email-jnareb@gmail.com>
http://article.gmane.org/gmane.comp.version-control.git/160475
gitweb/gitweb.perl | 29 +++++++++++++++++++++++++++++
1 files changed, 29 insertions(+), 0 deletions(-)
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index cfa511c..cae0e34 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -39,6 +39,9 @@ BEGIN {
our $version = "++GIT_VERSION++";
+# Output buffer variable
+our $output = "";
+
our ($my_url, $my_uri, $base_url, $path_info, $home_link);
sub evaluate_uri {
our $cgi;
@@ -1134,6 +1137,25 @@ sub evaluate_argv {
);
}
+sub change_output {
+ our $output;
+
+ # Trap the 'proper' STDOUT to STDOUT_REAL for things like error messages and such
+ open(STDOUT_REAL,">&STDOUT") or die "Unable to capture STDOUT $!\n";
+
+ # Close STDOUT, so that it isn't being used anymore.
+ close STDOUT;
+
+ # Trap STDOUT to the $output variable, which is what I was using in the original
+ # patch anyway.
+ open(STDOUT,">", \$output) || die "Unable to open STDOUT: $!"; #open STDOUT handle to use $var
+}
+
+sub reset_output {
+ # This basically takes STDOUT_REAL and puts it back as STDOUT
+ open STDOUT, ">&", \*STDOUT_REAL;
+}
+
sub run {
evaluate_argv();
@@ -1145,7 +1167,10 @@ sub run {
$pre_dispatch_hook->()
if $pre_dispatch_hook;
+ change_output();
run_request();
+ reset_output();
+ print $output;
$post_dispatch_hook->()
if $post_dispatch_hook;
@@ -3655,6 +3680,10 @@ sub die_error {
500 => '500 Internal Server Error',
503 => '503 Service Unavailable',
);
+ # Reset the output so that we are actually going to STDOUT as opposed
+ # to buffering the output.
+ reset_output();
+
git_header_html($http_responses{$status}, undef, %opts);
print <<EOF;
<div class="page_body">
--
1.7.3
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCHv7.4 3/4] gitweb: File based caching layer (from git.kernel.org)
2010-12-03 19:25 [PATCHv7.4 0/4] Gitweb caching v7.2 Jakub Narebski
2010-12-03 19:25 ` [PATCHv7.4 1/4] gitweb: Prepare for splitting gitweb Jakub Narebski
2010-12-03 19:25 ` [PATCHv7.4 2/4] gitweb: add output buffering and associated functions Jakub Narebski
@ 2010-12-03 19:25 ` Jakub Narebski
2010-12-03 19:25 ` [PATCHv7.4 4/4] gitweb: Minimal testing of gitweb caching Jakub Narebski
2010-12-03 19:30 ` [PATCHv7.4 0/4] Gitweb caching v7.2 Jakub Narebski
4 siblings, 0 replies; 6+ messages in thread
From: Jakub Narebski @ 2010-12-03 19:25 UTC (permalink / raw)
To: git
Cc: John 'Warthog9' Hawley, John 'Warthog9' Hawley,
Junio C Hamano, Thomas Rast
From: John 'Warthog9' Hawley <warthog9@eaglescrag.net>
This is a relatively large patch that implements the file based
caching layer that is quite similar to the one used on such large
sites as kernel.org and soon git.fedoraproject.org. This provides
a simple, and straight forward caching mechanism that scales
dramatically better than Gitweb by itself.
The caching layer basically buffers the output that Gitweb would
normally return, and saves that output to a cache file on the local
disk. When the file is requested it attempts to gain a shared lock
on the cache file and cat it out to the client. Should an exclusive
lock be on a file (it's being updated) the code has a choice to either
update in the background and go ahead and show the stale page while
update is being performed, or stall the client(s) until the page
is generated.
There are two forms of stalling involved here, background building
and non-background building, both of which are discussed in the
configuration page.
There are still a few known "issues" with respect to this:
- Code needs to be added to be "browser" aware so
that clients like wget that are trying to get a
binary blob don't obtain a "Generating..." page
Caching is disabled by default. You can turn it on by setting
$caching_enabled variable to true to enable file based caching.
[jn: added error checking to loading 'cache.pl'; moved check
for $caching_enabled outside out of cache_fetch, which required
update to die_error()]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
This fixes a bug that generated problems with t9501 test, as noticed
by Thomas Rast in
http://article.gmane.org/gmane.comp.version-control.git/162787
http://marc.info/?l=git&m=129137257619613&w=2
Fixup was sent as interdiff in
http://marc.info/?l=git&m=129138558404482&w=2
and it was tested that it fixes problem by Thomas Rast... so perhaps
it should be
Noticed-and-tested-by: Thomas Rast <trast@student.ethz.ch>
gitweb/Makefile | 3 +
gitweb/gitweb.perl | 107 +++++++++++++--
gitweb/lib/cache.pl | 348 ++++++++++++++++++++++++++++++++++++++++++++++
gitweb/static/gitweb.css | 6 +
4 files changed, 452 insertions(+), 12 deletions(-)
create mode 100644 gitweb/lib/cache.pl
diff --git a/gitweb/Makefile b/gitweb/Makefile
index ad5a282..1f892c3 100644
--- a/gitweb/Makefile
+++ b/gitweb/Makefile
@@ -113,6 +113,9 @@ endif
GITWEB_FILES += static/git-logo.png static/git-favicon.png
+# Gitweb caching
+GITWEB_MODULES += cache.pl
+
GITWEB_REPLACE = \
-e 's|++GIT_VERSION++|$(GIT_VERSION)|g' \
-e 's|++GIT_BINDIR++|$(bindir)|g' \
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index cae0e34..c465aa6 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -250,6 +250,53 @@ our %avatar_size = (
# Leave it undefined (or set to 'undef') to turn off load checking.
our $maxload = 300;
+# This enables/disables the caching layer in gitweb. This currently only supports the
+# 'dumb' file based caching layer, primarily used on git.kernel.org. this is reasonably
+# effective but it has the downside of requiring a huge amount of disk space if there
+# are a number of repositories involved. It is not uncommon for git.kernel.org to have
+# on the order of 80G - 120G accumulate over the course of a few months. It is recommended
+# that the cache directory be periodically completely deleted, and this is safe to perform.
+# Suggested mechanism
+# mv $cacheidr $cachedir.flush;mkdir $cachedir;rm -rf $cachedir.flush
+our $caching_enabled = 0;
+
+# Used to set the minimum cache timeout for the dynamic caching algorithm. Basically
+# if we calculate the cache to be under this number of seconds we set the cache timeout
+# to this minimum.
+# Value is in seconds. 1 = 1 seconds, 60 = 1 minute, 600 = 10 minutes, 3600 = 1 hour
+our $minCacheTime = 20;
+
+# Used to set the maximum cache timeout for the dynamic caching algorithm. Basically
+# if we calculate the cache to exceed this number of seconds we set the cache timeout
+# to this maximum.
+# Value is in seconds. 1 = 1 seconds, 60 = 1 minute, 600 = 10 minutes, 3600 = 1 hour
+our $maxCacheTime = 1200;
+
+# If you need to change the location of the caching directory, override this
+# otherwise this will probably do fine for you
+our $cachedir = 'cache';
+
+# If this is set (to 1) cache will do it's best to always display something instead
+# of making someone wait for the cache to update. This will launch the cacheUpdate
+# into the background and it will lock a <file>.bg file and will only lock the
+# actual cache file when it needs to write into it. In theory this will make
+# gitweb seem more responsive at the price of possibly stale data.
+our $backgroundCache = 1;
+
+# Used to set the maximum cache file life. If a cache files last modify time exceeds
+# this value, it will assume that the data is just too old, and HAS to be regenerated
+# instead of trying to display the existing cache data.
+# Value is in seconds. 1 = 1 seconds, 60 = 1 minute, 600 = 10 minutes, 3600 = 1 hour
+# 18000 = 5 hours
+our $maxCacheLife = 18000;
+
+# Used to enable or disable background forking of the gitweb caching. Mainly here for debugging purposes
+our $cacheDoFork = 1;
+
+our $fullhashpath = *STDOUT;
+our $fullhashbinpath = *STDOUT;
+our $fullhashbinpathfinal = *STDOUT;
+
# configuration for 'highlight' (http://www.andre-simon.de/)
# match by basename
our %highlight_basename = (
@@ -506,6 +553,15 @@ our %feature = (
'default' => [0]},
);
+#
+# Includes
+#
+if (!exists $INC{'cache.pl'}) {
+ my $return = do 'cache.pl';
+ die $@ if $@;
+ die "Couldn't read 'cache.pl': $!" if (!defined $return);
+}
+
sub gitweb_get_feature {
my ($name) = @_;
return unless exists $feature{$name};
@@ -734,6 +790,10 @@ our %actions = (
"project_list" => \&git_project_list,
"project_index" => \&git_project_index,
);
+sub is_cacheable {
+ my $action = shift;
+ return !($action eq 'blame_data' || $action eq 'blame_incremental');
+}
# finally, we have the hash of allowed extra_options for the commands that
# allow them
@@ -1072,7 +1132,11 @@ sub dispatch {
!$project) {
die_error(400, "Project needed");
}
- $actions{$action}->();
+ if ($caching_enabled && is_cacheable($action)) {
+ cache_fetch($action);
+ } else {
+ $actions{$action}->();
+ }
}
sub reset_timer {
@@ -1142,6 +1206,7 @@ sub change_output {
# Trap the 'proper' STDOUT to STDOUT_REAL for things like error messages and such
open(STDOUT_REAL,">&STDOUT") or die "Unable to capture STDOUT $!\n";
+ print STDOUT_REAL "";
# Close STDOUT, so that it isn't being used anymore.
close STDOUT;
@@ -1167,10 +1232,7 @@ sub run {
$pre_dispatch_hook->()
if $pre_dispatch_hook;
- change_output();
run_request();
- reset_output();
- print $output;
$post_dispatch_hook->()
if $post_dispatch_hook;
@@ -3447,7 +3509,8 @@ sub git_header_html {
# support xhtml+xml but choking when it gets what it asked for.
if (defined $cgi->http('HTTP_ACCEPT') &&
$cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\+xml(,|;|\s|$)/ &&
- $cgi->Accept('application/xhtml+xml') != 0) {
+ $cgi->Accept('application/xhtml+xml') != 0 &&
+ !$caching_enabled) {
$content_type = 'application/xhtml+xml';
} else {
$content_type = 'text/html';
@@ -3592,6 +3655,7 @@ sub git_footer_html {
my $feed_class = 'rss_logo';
print "<div class=\"page_footer\">\n";
+ print "<div class=\"cachetime\">Cache Last Updated: ". gmtime( time ) ." GMT</div>\n";
if (defined $project) {
my $descr = git_get_project_description($project);
if (defined $descr) {
@@ -3680,9 +3744,14 @@ sub die_error {
500 => '500 Internal Server Error',
503 => '503 Service Unavailable',
);
+ # The output handlers for die_error need to be reset to STDOUT
+ # so that half the message isn't being output to random and
+ # half to STDOUT as expected. This is mainly for the benefit
+ # of using git_header_html() and git_footer_html() since
+ #
# Reset the output so that we are actually going to STDOUT as opposed
# to buffering the output.
- reset_output();
+ reset_output() if ($caching_enabled);
git_header_html($http_responses{$status}, undef, %opts);
print <<EOF;
@@ -5592,9 +5661,16 @@ sub git_blob_plain {
($sandbox ? 'attachment' : 'inline')
. '; filename="' . $save_as . '"');
local $/ = undef;
- binmode STDOUT, ':raw';
- print <$fd>;
- binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
+ if ($caching_enabled) {
+ open BINOUT, '>', $fullhashbinpath or die_error(500, "Could not open bin dump file");
+ binmode BINOUT, ':raw';
+ print BINOUT <$fd>;
+ close BINOUT;
+ } else {
+ binmode STDOUT, ':raw';
+ print <$fd>;
+ binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
+ }
close $fd;
}
@@ -5879,9 +5955,16 @@ sub git_snapshot {
open my $fd, "-|", $cmd
or die_error(500, "Execute git-archive failed");
- binmode STDOUT, ':raw';
- print <$fd>;
- binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
+ if ($caching_enabled) {
+ open BINOUT, '>', $fullhashbinpath or die_error(500, "Could not open bin dump file");
+ binmode BINOUT, ':raw';
+ print BINOUT <$fd>;
+ close BINOUT;
+ } else {
+ binmode STDOUT, ':raw';
+ print <$fd>;
+ binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
+ }
close $fd;
}
diff --git a/gitweb/lib/cache.pl b/gitweb/lib/cache.pl
new file mode 100644
index 0000000..4360b3d
--- /dev/null
+++ b/gitweb/lib/cache.pl
@@ -0,0 +1,348 @@
+# gitweb - simple web interface to track changes in git repositories
+#
+# (C) 2006, John 'Warthog9' Hawley <warthog19@eaglescrag.net>
+#
+# This program is licensed under the GPLv2
+
+#
+# Gitweb caching engine
+#
+
+#use File::Path qw(make_path remove_tree);
+use File::Path qw(mkpath rmtree); # Used for compatability reasons
+use Digest::MD5 qw(md5 md5_hex md5_base64);
+use Fcntl ':flock';
+use File::Copy;
+
+sub cache_fetch {
+ my ($action) = @_;
+ my $cacheTime = 0;
+
+ if(! -d $cachedir){
+ print "*** Warning ***: Caching enabled but cache directory does not exsist. ($cachedir)\n";
+ mkdir ("cache", 0755) || die "Cannot create cache dir - you will need to manually create";
+ print "Cache directory created successfully\n";
+ }
+
+ our $full_url = "$my_url?". $ENV{'QUERY_STRING'};
+ our $urlhash = md5_hex($full_url);
+ our $fullhashdir = "$cachedir/". substr( $urlhash, 0, 2) ."/";
+
+ eval { mkpath( $fullhashdir, 0, 0777 ) };
+ if ($@) {
+ die_error(500, "Internal Server Error", "Could not create cache directory: $@");
+ }
+ $fullhashpath = "$fullhashdir/". substr( $urlhash, 2 );
+ $fullhashbinpath = "$fullhashpath.bin.wt";
+ $fullhashbinpathfinal = "$fullhashpath.bin";
+
+ if(! -e "$fullhashpath" ){
+ if(! $cacheDoFork || ! defined(my $childPid = fork()) ){
+ cacheUpdate($action,0);
+ cacheDisplay($action);
+ } elsif ( $childPid == 0 ){
+ #run the updater
+ cacheUpdate($action,1);
+ }else{
+ cacheWaitForUpdate($action);
+ }
+ }else{
+ #if cache is out dated, update
+ #else displayCache();
+ open(cacheFile, '<', "$fullhashpath");
+ stat(cacheFile);
+ close(cacheFile);
+ my $stat_time = (stat(_))[9];
+ my $stat_size = (stat(_))[7];
+
+ $cacheTime = get_loadavg() * 60;
+ if( $cacheTime > $maxCacheTime ){
+ $cacheTime = $maxCacheTime;
+ }
+ if( $cacheTime < $minCacheTime ){
+ $cacheTime = $minCacheTime;
+ }
+ if( $stat_time < (time - $cacheTime) || $stat_size == 0 ){
+ if( ! $cacheDoFork || ! defined(my $childPid = fork()) ){
+ cacheUpdate($action,0);
+ cacheDisplay($action);
+ } elsif ( $childPid == 0 ){
+ #run the updater
+ #print "Running updater\n";
+ cacheUpdate($action,1);
+ }else{
+ #print "Waiting for update\n";
+ cacheWaitForUpdate($action);
+ }
+ } else {
+ cacheDisplay($action);
+ }
+
+
+ }
+
+ #
+ # If all of the caching failes - lets go ahead and press on without it and fall back to 'default'
+ # non-caching behavior. This is the softest of the failure conditions.
+ #
+ #$actions{$action}->();
+}
+
+sub cacheUpdate {
+ my ($action,$areForked) = @_;
+ my $lockingStatus;
+ my $fileData = "";
+
+ if($backgroundCache){
+ open(cacheFileBG, '>:utf8', "$fullhashpath.bg");
+ my $lockStatBG = flock(cacheFileBG,LOCK_EX|LOCK_NB);
+
+ $lockStatus = $lockStatBG;
+ }else{
+ open(cacheFile, '>:utf8', $fullhashpath);
+ my $lockStat = flock(cacheFile,LOCK_EX|LOCK_NB);
+
+ $lockStatus = $lockStat;
+ }
+ #print "lock status: $lockStat\n";
+
+
+ if (! $lockStatus ){
+ if ( $areForked ){
+ exit(0);
+ }else{
+ return;
+ }
+ }
+
+ if(
+ $action eq "snapshot"
+ ||
+ $action eq "blob_plain"
+ ){
+ my $openstat = open(cacheFileBinWT, '>>:utf8', "$fullhashbinpath");
+ my $lockStatBin = flock(cacheFileBinWT,LOCK_EX|LOCK_NB);
+ }
+
+ # Trap all output from the action
+ change_output();
+
+ $actions{$action}->();
+
+ # Reset the outputs as we should be fine now
+ reset_output();
+
+
+ if($backgroundCache){
+ open(cacheFile, '>:utf8', "$fullhashpath");
+ $lockStat = flock(cacheFile,LOCK_EX);
+
+ if (! $lockStat ){
+ if ( $areForked ){
+ exit(0);
+ }else{
+ return;
+ }
+ }
+ }
+
+ if(
+ $action eq "snapshot"
+ ||
+ $action eq "blob_plain"
+ ){
+ my $openstat = open(cacheFileBinFINAL, '>:utf8', "$fullhashbinpathfinal");
+ $lockStatBIN = flock(cacheFileBinFINAL,LOCK_EX);
+
+ if (! $lockStatBIN ){
+ if ( $areForked ){
+ exit(0);
+ }else{
+ return;
+ }
+ }
+ }
+
+ # Actually dump the output to the proper file handler
+ local $/ = undef;
+ $|++;
+ print cacheFile "$output";
+ $|--;
+ if(
+ $action eq "snapshot"
+ ||
+ $action eq "blob_plain"
+ ){
+ move("$fullhashbinpath", "$fullhashbinpathfinal") or die "Binary Cache file could not be updated: $!";
+
+ flock(cacheFileBinFINAL,LOCK_UN);
+ close(cacheFileBinFINAL);
+
+ flock(cacheFileBinWT,LOCK_UN);
+ close(cacheFileBinWT);
+ }
+
+ flock(cacheFile,LOCK_UN);
+ close(cacheFile);
+
+ if($backgroundCache){
+ flock(cacheFileBG,LOCK_UN);
+ close(cacheFileBG);
+ }
+
+ if ( $areForked ){
+ exit(0);
+ } else {
+ return;
+ }
+}
+
+
+sub cacheWaitForUpdate {
+ my ($action) = @_;
+ my $x = 0;
+ my $max = 10;
+ my $lockStat = 0;
+
+ if( $backgroundCache ){
+ if( -e "$fullhashpath" ){
+ open(cacheFile, '<:utf8', "$fullhashpath");
+ $lockStat = flock(cacheFile,LOCK_SH|LOCK_NB);
+ stat(cacheFile);
+ close(cacheFile);
+
+ if( $lockStat && ( (stat(_))[9] > (time - $maxCacheLife) ) ){
+ cacheDisplay($action);
+ return;
+ }
+ }
+ }
+
+ if(
+ $action eq "atom"
+ ||
+ $action eq "rss"
+ ||
+ $action eq "opml"
+ ){
+ do {
+ sleep 2 if $x > 0;
+ open(cacheFile, '<:utf8', "$fullhashpath");
+ $lockStat = flock(cacheFile,LOCK_SH|LOCK_NB);
+ close(cacheFile);
+ $x++;
+ $combinedLockStat = $lockStat;
+ } while ((! $combinedLockStat) && ($x < $max));
+
+ if( $x != $max ){
+ cacheDisplay($action);
+ }
+ return;
+ }
+
+ $| = 1;
+
+ print $::cgi->header(
+ -type=>'text/html',
+ -charset => 'utf-8',
+ -status=> 200,
+ -expires => 'now',
+ # HTTP/1.0
+ -Pragma => 'no-cache',
+ # HTTP/1.1
+ -Cache_Control => join(
+ ', ',
+ qw(
+ private
+ no-cache
+ no-store
+ must-revalidate
+ max-age=0
+ pre-check=0
+ post-check=0
+ )
+ )
+ );
+
+ print <<EOF;
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www/w3.porg/TR/html4/strict.dtd">
+<!-- git web w/caching interface version $version, (C) 2006-2010, John 'Warthog9' Hawley <warthog9\@kernel.org> -->
+<!-- git core binaries version $git_version -->
+<head>
+<meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
+<meta name="generator" content="gitweb/$version git/$git_version"/>
+<meta name="robots" content="index, nofollow"/>
+<meta http-equiv="refresh" content="0"/>
+<title>$title</title>
+</head>
+<body>
+EOF
+
+ print "Generating..";
+ do {
+ print ".";
+ sleep 2 if $x > 0;
+ open(cacheFile, '<:utf8', "$fullhashpath");
+ $lockStat = flock(cacheFile,LOCK_SH|LOCK_NB);
+ close(cacheFile);
+ $x++;
+ $combinedLockStat = $lockStat;
+ } while ((! $combinedLockStat) && ($x < $max));
+ print <<EOF;
+</body>
+</html>
+EOF
+ return;
+}
+
+sub cacheDisplay {
+ local $/ = undef;
+ $|++;
+
+ my ($action) = @_;
+ open(cacheFile, '<:utf8', "$fullhashpath");
+ $lockStat = flock(cacheFile,LOCK_SH|LOCK_NB);
+
+ if (! $lockStat ){
+ close(cacheFile);
+ cacheWaitForUpdate($action);
+ }
+
+ if(
+ (
+ $action eq "snapshot"
+ ||
+ $action eq "blob_plain"
+ )
+ ){
+ my $openstat = open(cacheFileBin, '<', "$fullhashbinpathfinal");
+ $lockStatBIN = flock(cacheFileBin,LOCK_SH|LOCK_NB);
+ if (! $lockStatBIN ){
+ system ("echo 'cacheDisplay - bailing due to binary lock failure' >> /tmp/gitweb.log");
+ close(cacheFile);
+ close(cacheFileBin);
+ cacheWaitForUpdate($action);
+ }
+
+ my $binfilesize = -s "$fullhashbinpathfinal";
+ print "Content-Length: $binfilesize";
+ }
+ while( <cacheFile> ){
+ print $_;
+ }
+ if(
+ $action eq "snapshot"
+ ||
+ $action eq "blob_plain"
+ ){
+ binmode STDOUT, ':raw';
+ print <cacheFileBin>;
+ binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
+ close(cacheFileBin);
+ }
+ close(cacheFile);
+ $|--;
+}
+
+1;
+__END__
diff --git a/gitweb/static/gitweb.css b/gitweb/static/gitweb.css
index 4132aab..972d32e 100644
--- a/gitweb/static/gitweb.css
+++ b/gitweb/static/gitweb.css
@@ -67,6 +67,12 @@ div.page_path {
border-width: 0px 0px 1px;
}
+div.cachetime {
+ float: left;
+ margin-right: 10px;
+ color: #555555;
+}
+
div.page_footer {
height: 17px;
padding: 4px 8px;
--
1.7.3
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCHv7.4 4/4] gitweb: Minimal testing of gitweb caching
2010-12-03 19:25 [PATCHv7.4 0/4] Gitweb caching v7.2 Jakub Narebski
` (2 preceding siblings ...)
2010-12-03 19:25 ` [PATCHv7.4 3/4] gitweb: File based caching layer (from git.kernel.org) Jakub Narebski
@ 2010-12-03 19:25 ` Jakub Narebski
2010-12-03 19:30 ` [PATCHv7.4 0/4] Gitweb caching v7.2 Jakub Narebski
4 siblings, 0 replies; 6+ messages in thread
From: Jakub Narebski @ 2010-12-03 19:25 UTC (permalink / raw)
To: git
Cc: John 'Warthog9' Hawley, John 'Warthog9' Hawley,
Junio C Hamano, Thomas Rast, Jakub Narebski
Add basic tests of caching support to t9500-gitweb-standalone-no-errors
test: set $caching_enabled to true and check for errors for first time
run (generating cache) and second time run (retrieving from cache) for a
single view - summary view for a project. Check also that request for
non-existent object (which results in die_error() codepath to be called)
doesn't produce errors.
Check in t9501-gitweb-standalone-http-status that request for
non-existent object produces correct output (HTTP headers and HTML
output) also when caching is enabled.
Check in the t9502-gitweb-standalone-parse-output test that gitweb
produces the same output with and without caching, for first and
second run, with binary (raw) or plain text (utf8) output.
The common routine that enables cache, gitweb_enable_caching, is
defined in t/gitweb-lib.sh
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
---
The minor bug in value for $xxxCacheTime value in t/gitweb-lib.sh
noticed by Junio C Hamano in
http://thread.gmane.org/gmane.comp.version-control.git/160147/focus=161635
is fixed here, but it doesn't make gitweb pass new tests.
t/gitweb-lib.sh | 15 +++++++++++++
t/t9500-gitweb-standalone-no-errors.sh | 20 +++++++++++++++++
t/t9501-gitweb-standalone-http-status.sh | 13 +++++++++++
t/t9502-gitweb-standalone-parse-output.sh | 33 +++++++++++++++++++++++++++++
4 files changed, 81 insertions(+), 0 deletions(-)
diff --git a/t/gitweb-lib.sh b/t/gitweb-lib.sh
index b9bb95f..2c2ac90 100644
--- a/t/gitweb-lib.sh
+++ b/t/gitweb-lib.sh
@@ -52,6 +52,21 @@ EOF
export SCRIPT_NAME
}
+gitweb_enable_caching () {
+ test_expect_success 'enable caching' '
+ cat >>gitweb_config.perl <<-\EOF &&
+ our $caching_enabled = 1;
+ our $minCacheTime = 60*60*24*7; # very long expiration time for tests (a week)
+ our $maxCacheTime = 60*60*24*30; # upper bound for dynamic (adaptive) caching
+ our $cachedir = "cache"; # for testsuite to clear the right thing
+ # required, because otherwise some tests might intermittently not pass
+ our $backgroundCache = 0; # should turn off cacheWaitForUpdate() / "Generating..."
+ #our $cacheDoFork = 0;
+ EOF
+ rm -rf cache/
+ '
+}
+
gitweb_run () {
GATEWAY_INTERFACE='CGI/1.1'
HTTP_ACCEPT='*/*'
diff --git a/t/t9500-gitweb-standalone-no-errors.sh b/t/t9500-gitweb-standalone-no-errors.sh
index 21cd286..86c1b50 100755
--- a/t/t9500-gitweb-standalone-no-errors.sh
+++ b/t/t9500-gitweb-standalone-no-errors.sh
@@ -677,4 +677,24 @@ test_expect_success HIGHLIGHT \
gitweb_run "p=.git;a=blob;f=test.sh"'
test_debug 'cat gitweb.log'
+# ----------------------------------------------------------------------
+# caching
+
+gitweb_enable_caching
+
+test_expect_success \
+ 'caching enabled (project summary, first run, generating cache)' \
+ 'gitweb_run "p=.git;a=summary"'
+test_debug 'cat gitweb.log'
+
+test_expect_success \
+ 'caching enabled (project summary, second run, cached version)' \
+ 'gitweb_run "p=.git;a=summary"'
+test_debug 'cat gitweb.log'
+
+test_expect_success \
+ 'caching enabled (non-existent commit, non-cache error page)' \
+ 'gitweb_run "p=.git;a=commit;h=non-existent"'
+test_debug 'cat gitweb.log'
+
test_done
diff --git a/t/t9501-gitweb-standalone-http-status.sh b/t/t9501-gitweb-standalone-http-status.sh
index 2487da1..5b1df3f 100755
--- a/t/t9501-gitweb-standalone-http-status.sh
+++ b/t/t9501-gitweb-standalone-http-status.sh
@@ -134,5 +134,18 @@ cat >>gitweb_config.perl <<\EOF
our $maxload = undef;
EOF
+# ----------------------------------------------------------------------
+# output caching
+
+gitweb_enable_caching
+
+test_expect_success 'caching enabled (non-existent commit, 404 error)' '
+ gitweb_run "p=.git;a=commit;h=non-existent" &&
+ grep "Status: 404 Not Found" gitweb.headers &&
+ grep "404 - Unknown commit object" gitweb.body
+'
+test_debug 'echo "log" && cat gitweb.log'
+test_debug 'echo "headers" && cat gitweb.headers'
+test_debug 'echo "body" && cat gitweb.body'
test_done
diff --git a/t/t9502-gitweb-standalone-parse-output.sh b/t/t9502-gitweb-standalone-parse-output.sh
index dd83890..bc8eb01 100755
--- a/t/t9502-gitweb-standalone-parse-output.sh
+++ b/t/t9502-gitweb-standalone-parse-output.sh
@@ -112,4 +112,37 @@ test_expect_success 'snapshot: hierarchical branch name (xx/test)' '
'
test_debug 'cat gitweb.headers'
+
+# ----------------------------------------------------------------------
+# whether gitweb with caching enabled produces the same output
+
+test_expect_success 'setup for caching tests (utf8 patch, binary file)' '
+ . "$TEST_DIRECTORY"/t3901-utf8.txt &&
+ cp "$TEST_DIRECTORY"/test9200a.png image.png &&
+ git add image.png &&
+ git commit -F "$TEST_DIRECTORY"/t3900/1-UTF-8.txt &&
+ gitweb_run "p=.git;a=patch" &&
+ mv gitweb.body no_cache.txt &&
+ gitweb_run "p=.git;a=blob_plain;f=image.png" &&
+ mv gitweb.body no_cache.png
+'
+
+gitweb_enable_caching
+
+for desc in 'generating cache' 'cached version'; do
+ test_expect_success "caching enabled, plain text (utf8) output, $desc" '
+ gitweb_run "p=.git;a=patch" &&
+ mv gitweb.body cache.txt &&
+ test_cmp no_cache.txt cache.txt
+ '
+done
+
+for desc in 'generating cache' 'cached version'; do
+ test_expect_success "caching enabled, binary output (raw), $desc" '
+ gitweb_run "p=.git;a=blob_plain;f=image.png" &&
+ mv gitweb.body cache.png &&
+ cmp no_cache.png cache.png
+ '
+done
+
test_done
--
1.7.3
^ permalink raw reply related [flat|nested] 6+ messages in thread