X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FPlugin%2FStatic%2FSimple.pm;h=7e79cac92e2c6043a4e38b90e0af04cba8c69811;hb=766f4ce4c4047144e1644a848259a016e8b85beb;hp=01abfa2ebfe07b800ed4cbedcc64109c30eb6fc2;hpb=a28d35e93b7cf4de0f26f18774378bef7d99565e;p=catagits%2FCatalyst-Plugin-Static-Simple.git

diff --git a/lib/Catalyst/Plugin/Static/Simple.pm b/lib/Catalyst/Plugin/Static/Simple.pm
index 01abfa2..7e79cac 100644
--- a/lib/Catalyst/Plugin/Static/Simple.pm
+++ b/lib/Catalyst/Plugin/Static/Simple.pm
@@ -1,21 +1,19 @@
 package Catalyst::Plugin::Static::Simple;
 
 use strict;
+use warnings;
 use base qw/Class::Accessor::Fast Class::Data::Inheritable/;
-use File::Slurp;
 use File::stat;
+use IO::File;
 use MIME::Types;
 use NEXT;
 
-our $VERSION = '0.09';
+our $VERSION = '0.11';
 
 __PACKAGE__->mk_classdata( qw/_static_mime_types/ );
 __PACKAGE__->mk_accessors( qw/_static_file
-                              _static_apache_mode
                               _static_debug_message/ );
 
-# prepare_action is used to first check if the request path is a static file.
-# If so, we skip all other prepare_action steps to improve performance.
 sub prepare_action {
     my $c = shift;
     my $path = $c->req->path;
@@ -28,7 +26,7 @@ sub prepare_action {
         }
         if ( $path =~ $re ) {
             if ( $c->_locate_static_file ) {
-                $c->_debug_msg( "from static directory" )
+                $c->_debug_msg( 'from static directory' )
                     if ( $c->config->{static}->{debug} );
                 return;
             } else {
@@ -46,10 +44,9 @@ sub prepare_action {
         return if ( $c->_locate_static_file );
     }
     
-    return $c->NEXT::prepare_action(@_);
+    return $c->NEXT::ACTUAL::prepare_action(@_);
 }
 
-# dispatch takes the file found during prepare_action and serves it
 sub dispatch {
     my $c = shift;
     
@@ -62,33 +59,16 @@ sub dispatch {
         return $c->_serve_static;
     }
     else {
-        return $c->NEXT::dispatch(@_);
+        return $c->NEXT::ACTUAL::dispatch(@_);
     }
 }
 
-# finalize serves up final header information
 sub finalize {
     my $c = shift;
     
     # display all log messages
     if ( $c->config->{static}->{debug} && scalar @{$c->_debug_msg} ) {
-	$c->log->debug( "Static::Simple: Serving " .
-	    join( " ", @{$c->_debug_msg} ) );
-    }
-    
-    # return DECLINED when under mod_perl
-    if ( $c->config->{static}->{use_apache} && $c->_static_apache_mode ) {
-        my $engine = $c->_static_apache_mode;
-        no strict 'subs';
-        if ( $engine == 13 ) {
-            return Apache::Constants::DECLINED;
-        }
-        elsif ( $engine == 19 ) {
-            return Apache::Const::DECLINED;
-        }
-        elsif ( $engine == 20 ) {
-            return Apache2::Const::DECLINED;
-        }
+        $c->log->debug( 'Static::Simple: ' . join q{ }, @{$c->_debug_msg} );
     }
     
     if ( $c->res->status =~ /^(1\d\d|[23]04)$/xms ) {
@@ -96,7 +76,7 @@ sub finalize {
         return $c->finalize_headers;
     }
     
-    return $c->NEXT::finalize(@_);
+    return $c->NEXT::ACTUAL::finalize(@_);
 }
 
 sub setup {
@@ -104,14 +84,19 @@ sub setup {
     
     $c->NEXT::setup(@_);
     
+    if ( Catalyst->VERSION le '5.33' ) {
+        require File::Slurp;
+    }
+    
     $c->config->{static}->{dirs} ||= [];
     $c->config->{static}->{include_path} ||= [ $c->config->{root} ];
     $c->config->{static}->{mime_types} ||= {};
-    $c->config->{static}->{use_apache} ||= 0; 
+    $c->config->{static}->{ignore_extensions} ||= [ qw/tt tt2 html xhtml/ ];
+    $c->config->{static}->{ignore_dirs} ||= [];
     $c->config->{static}->{debug} ||= $c->debug;
     if ( ! defined $c->config->{static}->{no_logs} ) {
         $c->config->{static}->{no_logs} = 1;
-    }
+    }    
     
     # load up a MIME::Types object, only loading types with
     # at least 1 file extension
@@ -132,21 +117,43 @@ sub _locate_static_file {
     my $dpaths;
     my $count = 64; # maximum number of directories to search
     
+    DIR_CHECK:
     while ( @ipaths && --$count) {
-        my $dir = shift @ipaths || next;
+        my $dir = shift @ipaths || next DIR_CHECK;
         
         if ( ref $dir eq 'CODE' ) {
             eval { $dpaths = &$dir( $c ) };
             if ($@) {
-                $c->log->error( "Static::Simple: include_path error: " . $@ );
+                $c->log->error( 'Static::Simple: include_path error: ' . $@ );
             } else {
-                unshift( @ipaths, @$dpaths );
-                next;
+                unshift @ipaths, @$dpaths;
+                next DIR_CHECK;
             }
         } else {
             $dir =~ s/\/$//xms;
             if ( -d $dir && -f $dir . '/' . $path ) {
-                $c->_debug_msg( $dir . "/" . $path )
+                
+                # do we need to ignore the file?
+                for my $ignore ( @{ $c->config->{static}->{ignore_dirs} } ) {
+                    $ignore =~ s{/$}{};
+                    if ( $path =~ /^$ignore\// ) {
+                        $c->_debug_msg( "Ignoring directory `$ignore`" )
+                            if ( $c->config->{static}->{debug} );
+                        next DIR_CHECK;
+                    }
+                }
+                
+                # do we need to ignore based on extension?
+                for my $ignore_ext 
+                    ( @{ $c->config->{static}->{ignore_extensions} } ) {
+                        if ( $path =~ /.*\.${ignore_ext}$/ixms ) {
+                            $c->_debug_msg( "Ignoring extension `$ignore_ext`" )
+                                if ( $c->config->{static}->{debug} );
+                            next DIR_CHECK;
+                        }
+                }
+                
+                $c->_debug_msg( 'Serving ' . $dir . '/' . $path )
                     if ( $c->config->{static}->{debug} );
                 return $c->_static_file( $dir . '/' . $path );
             }
@@ -160,61 +167,33 @@ sub _serve_static {
     my $c = shift;
     
     my $path = $c->req->path;    
-    
-    # abort if running under mod_perl
-    # note that we do not use the Apache method if the user has defined
-    # custom MIME types or is using include paths, as Apache would not know
-    # about them
-    APACHE_CHECK:
-    {
-        if ( $c->config->{static}->{use_apache} ) {
-            # check engine version
-            last APACHE_CHECK unless $c->engine =~ /Apache::MP(\d{2})/xms;
-            my $engine = $1;
-    
-            # skip if we have user-defined MIME types
-            last APACHE_CHECK if keys %{ $c->config->{static}->{mime_types} };
-            
-            # skip if the file is in a user-defined include path
-            last APACHE_CHECK if $c->_static_file 
-                ne $c->config->{root} . '/' . $path;
-    
-             # check that Apache will serve the correct file
-             if ( $c->apache->document_root ne $c->config->{root} ) {
-                 $c->log->warn( "Static::Simple: Your Apache DocumentRoot"
-                              . " must be set to " . $c->config->{root} 
-                              . " to use the Apache feature.  Yours is"
-                              . " currently " . $c->apache->document_root
-                              );
-             }
-             else {
-                 $c->_debug_msg( "DECLINED to Apache" )
-                    if ( $c->config->{static}->{debug} );          
-                 $c->_static_apache_mode( $engine );
-                 return;
-             }
-        }
-    }
-    
     my $type = $c->_ext_to_type;
     
     my $full_path = $c->_static_file;
-    my $stat = stat( $full_path );
-
-    # the below code all from C::P::Static
-    if ( $c->req->headers->if_modified_since ) {
-        if ( $c->req->headers->if_modified_since == $stat->mtime ) {
-            $c->res->status( 304 ); # Not Modified
-            $c->res->headers->remove_content_headers;
-            return 1;
-        }
-    }
+    my $stat = stat $full_path;
 
-    my $content = read_file( $full_path );
     $c->res->headers->content_type( $type );
     $c->res->headers->content_length( $stat->size );
     $c->res->headers->last_modified( $stat->mtime );
-    $c->res->output( $content );
+
+    if ( Catalyst->VERSION le '5.33' ) {
+        # old File::Slurp method
+        my $content = File::Slurp::read_file( $full_path );
+        $c->res->body( $content );
+    }
+    else {
+        # new method, pass an IO::File object to body
+        my $fh = IO::File->new( $full_path, 'r' );
+        if ( defined $fh ) {
+            binmode $fh;
+            $c->res->body( $fh );
+        }
+        else {
+            Catalyst::Exception->throw( 
+                message => "Unable to open $full_path for reading" );
+        }
+    }
+    
     return 1;
 }
 
@@ -231,7 +210,7 @@ sub _ext_to_type {
         if ( $type ) {
             $c->_debug_msg( "as $type" )
                 if ( $c->config->{static}->{debug} );            
-            return $type;
+            return ( ref $type ) ? $type->type : $type;
         }
         else {
             $c->_debug_msg( "as text/plain (unknown extension $ext)" )
@@ -352,6 +331,35 @@ For example:
             die "No customer dir defined.";
         }
     }
+    
+=head2 Ignoring certain types of files
+
+There are some file types you may not wish to serve as static files.  Most
+important in this category are your raw template files.  By default, files
+with the extensions tt, tt2, html, and xhtml will be ignored by Static::Simple
+in the interest of security.  If you wish to define your own extensions to
+ignore, use the ignore_extensions option:
+
+    MyApp->config->{static}->{ignore_extensions} = [ qw/tt tt2 html xhtml/ ];
+    
+=head2 Ignoring entire directories
+
+To prevent an entire directory from being served statically, you can use the
+ignore_dirs option.  This option contains a list of relative directory paths
+to ignore.  If using include_path, the path will be checked against every
+included path.
+
+    MyApp->config->{static}->{ignore_dirs} = [ qw/tmpl css/ ];
+    
+For example, if combined with the above include_path setting, this
+ignore_dirs value will ignore the following directories if they exist:
+
+    /path/to/overlay/tmpl
+    /path/to/overlay/css
+    /dynamic/path/tmpl
+    /dynamic/path/css
+    /your/app/home/root/tmpl
+    /your/app/home/root/css    
 
 =head2 Custom MIME types
 
@@ -363,31 +371,6 @@ you may enter your own extension to MIME type mapping.
         png => 'image/png',
     };
 
-=head2 Apache integration and performance
-
-Optionally, when running under mod_perl, Static::Simple can return DECLINED
-on static files to allow Apache to serve the file.  A check is first done to
-make sure that Apache's DocumentRoot matches your Catalyst root, and that you
-are not using any custom MIME types or multiple roots.  To enable the Apache
-support, you can set the following option.
-
-    MyApp->config->{static}->{use_apache} = 1;
-    
-By default this option is disabled because after several benchmarks it
-appears that just serving the file from Catalyst is the better option.  On a
-3K file, Catalyst appears to be around 25% faster, and is 42% faster on a 10K
-file.  My benchmarking was done using the following 'siege' command, so other
-benchmarks would be welcome!
-
-    siege -u http://server/static/css/10K.css -b -t 1M -c 1
-
-For best static performance, you should still serve your static files directly
-from Apache by defining a Location block similar to the following:
-
-    <Location /static>
-        SetHandler default-handler
-    </Location>
-
 =head2 Bypassing other plugins
 
 This plugin checks for a static file in the prepare_action stage.  If the
@@ -406,6 +389,40 @@ Enable additional debugging information printed in the Catalyst log.  This
 is automatically enabled when running Catalyst in -Debug mode.
 
     MyApp->config->{static}->{debug} = 1;
+    
+=head1 USING WITH APACHE
+
+While Static::Simple will work just fine serving files through Catalyst in
+mod_perl, for increased performance, you may wish to have Apache handle the
+serving of your static files.  To do this, simply use a dedicated directory
+for your static files and configure an Apache Location block for that
+directory.  This approach is recommended for production installations.
+
+    <Location /static>
+        SetHandler default-handler
+    </Location>
+
+=head1 INTERNAL EXTENDED METHODS
+
+Static::Simple extends the following steps in the Catalyst process.
+
+=head2 prepare_action 
+
+prepare_action is used to first check if the request path is a static file.
+If so, we skip all other prepare_action steps to improve performance.
+
+=head2 dispatch
+
+dispatch takes the file found during prepare_action and writes it to the
+output.
+
+=head2 finalize
+
+finalize serves up final header information and displays any log messages.
+
+=head2 setup
+
+setup initializes all default values.
 
 =head1 SEE ALSO