Vyššie na [Platon] / perl-modules / Platon / FastCGI

Fix.

#
# Platon/FastCGI/Restart.pm - check, if FastCGI script or user/system
#                             modules was modified
#
# Developed by Lubomir Host 'rajo' <rajo AT platon.sk>
# Copyright (c) 2004 Platon SDG, http://platon.sk/
# Licensed under terms of GNU General Public License.
# All rights reserved.
#
# Changelog:
# 09/02/2004 - created
#

# $Platon: web-apps/fastcgi-gallery/_modules/Platon/FastCGI/Restart.pm,v 1.3 2005/09/08 23:34:02 rajo Exp $

package Platon::FastCGI::Restart;

use strict;
use Carp;
use English;
use File::stat;
use Digest::MD5;
use vars qw($VERSION $DEBUG $CLASS @EXPORT $AUTOLOAD);

$VERSION = sprintf("%d.%02d", q$Revision: 1.7 $ =~ /(\d+)\.(\d+)/);
$DEBUG   = 0 unless defined $DEBUG;

@EXPORT  = qw( add_files add_loaded_modules restart );

sub new
{ # {{{
    my ($this, $hash) = @_;
    my $self;
    
    if (ref $hash eq 'HASH') {
        #warn "Using HASH";
        $self  = {
            restart_func            => $hash->{restart_func},
            use_lock                => defined($hash->{use_lock})                ? $hash->{use_lock}                : 'true',
            lock_dir                => defined($hash->{lock_dir})                ? $hash->{lock_dir}                : '/var/tmp',
            max_restart_interval    => defined($hash->{max_restart_interval})    ? $hash->{max_restart_interval}    : 60,
            CHECK_USER_MODULES        => defined($hash->{CHECK_USER_MODULES})        ? $hash->{CHECK_USER_MODULES}    : 'true',
            CHECK_SYSTEM_MODULES    => defined($hash->{CHECK_SYSTEM_MODULES})    ? $hash->{CHECK_SYSTEM_MODULES}    : 'false',
            system_modules_regexp    => defined($hash->{system_modules_regexp})    ? $hash->{system_modules_regexp}: '^/usr',
        };
    }
    else {
        # Defaults:
        $self  = {
            restart_func            => &exit(0),
            use_lock                => 'true',
            lock_dir                => '/var/tmp',
            max_restart_interval    => 60,
            CHECK_USER_MODULES        => 'true',
            CHECK_SYSTEM_MODULES    => 'false',
            system_modules_regexp    => '^/usr',
        };
    }
    my $class = ref($this) || $this;
    $CLASS = $class;

    bless $self, $class;

    return $self;
} # }}}

sub add_files ($;@)
{ # {{{
    my ($self, @files) = @_;
    
    push @{$self->{checked_files}}, @files;

} # }}}

sub add_loaded_modules ($;)
{ # {{{
    my ($self) = shift;

    my @keys = sort keys %INC;
    #warn scalar(@keys) . " modules loaded";
    foreach my $file (@keys) {
        if ($INC{$file} =~ m#$self->{system_modules_regexp}#o) {
            if ($self->{CHECK_SYSTEM_MODULES} eq 'true') {
                #warn "Adding system module '$file'\t=>'$INC{$file}'\n";
                push @{$self->{checked_files}}, $INC{$file};
            }
        }
        elsif ($self->{CHECK_USER_MODULES} eq 'true') {
            #warn "Adding user module '$file'\t=>'$INC{$file}'\n";
            push @{$self->{checked_files}}, $INC{$file};
        }
    }
} # }}}

sub restart ($;@)
{ # {{{
    my ($self, @files) = @_;

    my @check_files = @{$self->{checked_files}};
    foreach my $file (@files) {
        push @check_files, $file if defined $file;
    }

    my $lock_file;
    if ($self->{use_lock} eq 'true') {
        $lock_file = "$self->{lock_dir}/fastcgi_restart-$EUID-" . Digest::MD5::md5_hex(join('', @files));
    }

    if (defined $self->{checked_files}) {
        foreach my $file (@check_files) {
            my $modif = -M $file;
            my $seconds = defined($modif) ? -86400.0 * $modif : 0.0;
            if (defined($seconds) and  $seconds > 0.0) {
                if (defined($lock_file)) { # use lockfiles
                    if (-f $lock_file) { # lock file exists
                        my $st = stat($lock_file);
                        my $lock_modif = time - $st->mtime();

                        if ($lock_modif < $self->{max_restart_interval}) {
                            carp "$CLASS: Max. restart interval is $self->{max_restart_interval}, lockfile created $lock_modif seconds ago. Restart delayled ...";
                            return;
                        }
                    }

                    # create lockfile
                    open FILE, ">$lock_file" or croak "Can't create lock file '$file': $!";
                    print FILE $PID; # write pid to this file
                    close FILE;
                }
                
                carp "$CLASS: File '$file' modified $seconds seconds after startup, restarting ...";
                &{$self->{restart_func}}; # call function, e.g. exit(0)
            }
        }
    }
    else {
        croak "$CLASS: Invalid module usage!";
    }
    
} # }}}

sub version ($;)
{ # {{{
    return $VERSION;
} # }}}

1;

__END__

=head1 NAME

restart - restart program (e.g. FastCGI script) if modules was moodified

=head1 SYNOPSIS

  use lib qw ( path/to/Platon/perl-modules );
  use Platon::FastCGI::Restart;

  $restart = Platon::FastCGI::Restart->new({
        restart_func          => sub { $req->LastCall(); exit 0 },
        use_lock              => 'true',
        lock_dir              => '/var/tmp',
        max_restart_interval  => 60,
        CHECK_USER_MODULES    => 'true',
        CHECK_SYSTEM_MODULES  => 'false',
  });
  
  $restart->add_loaded_modules();

  $restart->add_files(@filename_list);
  
  $restart->restart(@other_files);

=head1 EXAMPLE

  #!/usr/bin/perl -w
  
  use strict;
  use lib qw( ./modules path/to/Platon/perl-modules );

  use FCGI;
  use Platon::FastCGI::Restart;

  use vars qw (
      $req $restart
  );
  
  $req = FCGI::Request();
  $restart    = Platon::FastCGI::Restart->new({
          restart_func        => sub { $req->LastCall() ; exit 0; },
          CHECK_USER_MODULES    => 'true',
          CHECK_SYSTEM_MODULES    => 'false',
  });

  # All modules loaded, push them to the Platon::FastCGI::Restart:
  $restart->add_loaded_modules();

  my $runlimit = 1000;
  my $runcount = 0;
  while ( $runcount++ < $runlimit && ($req->Accept() >= 0) ) {

      # YOUR CODE HERE
    print "Content-type: text/html\r\n\r\n";
    
      $restart->restart($ENV{SCRIPT_FILENAME});
      $req->Finish();
  }

  1;

=head1 DESCRIPTION

The Platon::FastCGI::Restart module cleanly restart your FastCGI script
(or other program), when modules was modified.

=head1 AUTHORS

Lubomir Host 'rajo', <rajo AT platon.sk>

=head1 COPYRIGHT

Copyright (c) 2004 Platon SDG, http://platon.sk/
Licensed under terms of GNU General Public License.
All rights reserved.

=cut

# vim: ts=4
# vim600: fdm=marker fdl=0 fdc=3