FCGI-ProcManager-0.28/ 0000755 0001750 0001750 00000000000 13055160477 013701 5 ustar andrew andrew FCGI-ProcManager-0.28/Makefile.old 0000644 0001750 0001750 00000066760 12433527327 016135 0 ustar andrew andrew # This Makefile is for the FCGI::ProcManager extension to perl.
#
# It was generated automatically by MakeMaker version
# 6.98 (Revision: 69800) from the contents of
# Makefile.PL. Don't edit this file, edit Makefile.PL instead.
#
# ANY CHANGES MADE HERE WILL BE LOST!
#
# MakeMaker ARGV: ()
#
# MakeMaker Parameters:
# ABSTRACT => q[A perl-based FastCGI process manager]
# AUTHOR => [q[James E Jurach (muaddib@erf.net)]]
# BUILD_REQUIRES => { }
# CONFIGURE_REQUIRES => { }
# DISTNAME => q[FCGI-ProcManager]
# META_MERGE => { resources=>{ repository=>q[git://git.shadowcat.co.uk/catagits/FCGI-ProcManager] } }
# NAME => q[FCGI::ProcManager]
# PREREQ_PM => { }
# TEST_REQUIRES => { }
# VERSION_FROM => q[lib/FCGI/ProcManager.pm]
# dist => { SUFFIX=>q[gz], COMPRESS=>q[gzip] }
# --- MakeMaker post_initialize section:
# --- MakeMaker const_config section:
# These definitions are from config.sh (via /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0/x86_64-linux/Config.pm).
# They may have been overridden via Makefile.PL or on the command line.
AR = ar
CC = cc
CCCDLFLAGS = -fPIC
CCDLFLAGS = -Wl,-E
DLEXT = so
DLSRC = dl_dlopen.xs
EXE_EXT =
FULL_AR = /usr/bin/ar
LD = cc
LDDLFLAGS = -shared -O2 -L/usr/local/lib -fstack-protector
LDFLAGS = -fstack-protector -L/usr/local/lib
LIBC =
LIB_EXT = .a
OBJ_EXT = .o
OSNAME = linux
OSVERS = 3.13.0-29-generic
RANLIB = :
SITELIBEXP = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/site_perl/5.20.0
SITEARCHEXP = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/site_perl/5.20.0/x86_64-linux
SO = so
VENDORARCHEXP =
VENDORLIBEXP =
# --- MakeMaker constants section:
AR_STATIC_ARGS = cr
DIRFILESEP = /
DFSEP = $(DIRFILESEP)
NAME = FCGI::ProcManager
NAME_SYM = FCGI_ProcManager
VERSION = 0.25
VERSION_MACRO = VERSION
VERSION_SYM = 0_25
DEFINE_VERSION = -D$(VERSION_MACRO)=\"$(VERSION)\"
XS_VERSION = 0.25
XS_VERSION_MACRO = XS_VERSION
XS_DEFINE_VERSION = -D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"
INST_ARCHLIB = blib/arch
INST_SCRIPT = blib/script
INST_BIN = blib/bin
INST_LIB = blib/lib
INST_MAN1DIR = blib/man1
INST_MAN3DIR = blib/man3
MAN1EXT = 1
MAN3EXT = 3
INSTALLDIRS = site
DESTDIR =
PREFIX = $(SITEPREFIX)
PERLPREFIX = /home/andrew/perl5/perlbrew/perls/perl-5.20.0
SITEPREFIX = /home/andrew/perl5/perlbrew/perls/perl-5.20.0
VENDORPREFIX =
INSTALLPRIVLIB = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0
DESTINSTALLPRIVLIB = $(DESTDIR)$(INSTALLPRIVLIB)
INSTALLSITELIB = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/site_perl/5.20.0
DESTINSTALLSITELIB = $(DESTDIR)$(INSTALLSITELIB)
INSTALLVENDORLIB =
DESTINSTALLVENDORLIB = $(DESTDIR)$(INSTALLVENDORLIB)
INSTALLARCHLIB = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0/x86_64-linux
DESTINSTALLARCHLIB = $(DESTDIR)$(INSTALLARCHLIB)
INSTALLSITEARCH = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/site_perl/5.20.0/x86_64-linux
DESTINSTALLSITEARCH = $(DESTDIR)$(INSTALLSITEARCH)
INSTALLVENDORARCH =
DESTINSTALLVENDORARCH = $(DESTDIR)$(INSTALLVENDORARCH)
INSTALLBIN = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin
DESTINSTALLBIN = $(DESTDIR)$(INSTALLBIN)
INSTALLSITEBIN = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin
DESTINSTALLSITEBIN = $(DESTDIR)$(INSTALLSITEBIN)
INSTALLVENDORBIN =
DESTINSTALLVENDORBIN = $(DESTDIR)$(INSTALLVENDORBIN)
INSTALLSCRIPT = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin
DESTINSTALLSCRIPT = $(DESTDIR)$(INSTALLSCRIPT)
INSTALLSITESCRIPT = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin
DESTINSTALLSITESCRIPT = $(DESTDIR)$(INSTALLSITESCRIPT)
INSTALLVENDORSCRIPT =
DESTINSTALLVENDORSCRIPT = $(DESTDIR)$(INSTALLVENDORSCRIPT)
INSTALLMAN1DIR = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/man/man1
DESTINSTALLMAN1DIR = $(DESTDIR)$(INSTALLMAN1DIR)
INSTALLSITEMAN1DIR = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/man/man1
DESTINSTALLSITEMAN1DIR = $(DESTDIR)$(INSTALLSITEMAN1DIR)
INSTALLVENDORMAN1DIR =
DESTINSTALLVENDORMAN1DIR = $(DESTDIR)$(INSTALLVENDORMAN1DIR)
INSTALLMAN3DIR = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/man/man3
DESTINSTALLMAN3DIR = $(DESTDIR)$(INSTALLMAN3DIR)
INSTALLSITEMAN3DIR = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/man/man3
DESTINSTALLSITEMAN3DIR = $(DESTDIR)$(INSTALLSITEMAN3DIR)
INSTALLVENDORMAN3DIR =
DESTINSTALLVENDORMAN3DIR = $(DESTDIR)$(INSTALLVENDORMAN3DIR)
PERL_LIB = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0
PERL_ARCHLIB = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0/x86_64-linux
LIBPERL_A = libperl.a
FIRST_MAKEFILE = Makefile
MAKEFILE_OLD = Makefile.old
MAKE_APERL_FILE = Makefile.aperl
PERLMAINCC = $(CC)
PERL_INC = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0/x86_64-linux/CORE
PERL = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin/perl
FULLPERL = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin/perl
ABSPERL = $(PERL)
PERLRUN = $(PERL)
FULLPERLRUN = $(FULLPERL)
ABSPERLRUN = $(ABSPERL)
PERLRUNINST = $(PERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"
FULLPERLRUNINST = $(FULLPERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"
ABSPERLRUNINST = $(ABSPERLRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"
PERL_CORE = 0
PERM_DIR = 755
PERM_RW = 644
PERM_RWX = 755
MAKEMAKER = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/lib/5.20.0/ExtUtils/MakeMaker.pm
MM_VERSION = 6.98
MM_REVISION = 69800
# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
# DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
MAKE = make
FULLEXT = FCGI/ProcManager
BASEEXT = ProcManager
PARENT_NAME = FCGI
DLBASE = $(BASEEXT)
VERSION_FROM = lib/FCGI/ProcManager.pm
OBJECT =
LDFROM = $(OBJECT)
LINKTYPE = dynamic
BOOTDEP =
# Handy lists of source code files:
XS_FILES =
C_FILES =
O_FILES =
H_FILES =
MAN1PODS =
MAN3PODS = lib/FCGI/ProcManager.pm \
lib/FCGI/ProcManager/Constrained.pm
# Where is the Config information that we are using/depend on
CONFIGDEP = $(PERL_ARCHLIB)$(DFSEP)Config.pm $(PERL_INC)$(DFSEP)config.h
# Where to build things
INST_LIBDIR = $(INST_LIB)/FCGI
INST_ARCHLIBDIR = $(INST_ARCHLIB)/FCGI
INST_AUTODIR = $(INST_LIB)/auto/$(FULLEXT)
INST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)
INST_STATIC =
INST_DYNAMIC =
INST_BOOT =
# Extra linker info
EXPORT_LIST =
PERL_ARCHIVE =
PERL_ARCHIVE_AFTER =
TO_INST_PM = lib/FCGI/ProcManager.pm \
lib/FCGI/ProcManager/Constrained.pm
PM_TO_BLIB = lib/FCGI/ProcManager.pm \
blib/lib/FCGI/ProcManager.pm \
lib/FCGI/ProcManager/Constrained.pm \
blib/lib/FCGI/ProcManager/Constrained.pm
# --- MakeMaker platform_constants section:
MM_Unix_VERSION = 6.98
PERL_MALLOC_DEF = -DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc -Dfree=Perl_mfree -Drealloc=Perl_realloc -Dcalloc=Perl_calloc
# --- MakeMaker tool_autosplit section:
# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
AUTOSPLITFILE = $(ABSPERLRUN) -e 'use AutoSplit; autosplit($$$$ARGV[0], $$$$ARGV[1], 0, 1, 1)' --
# --- MakeMaker tool_xsubpp section:
# --- MakeMaker tools_other section:
SHELL = /bin/sh
CHMOD = chmod
CP = cp
MV = mv
NOOP = $(TRUE)
NOECHO = @
RM_F = rm -f
RM_RF = rm -rf
TEST_F = test -f
TOUCH = touch
UMASK_NULL = umask 0
DEV_NULL = > /dev/null 2>&1
MKPATH = $(ABSPERLRUN) -MExtUtils::Command -e 'mkpath' --
EQUALIZE_TIMESTAMP = $(ABSPERLRUN) -MExtUtils::Command -e 'eqtime' --
FALSE = false
TRUE = true
ECHO = echo
ECHO_N = echo -n
UNINST = 0
VERBINST = 0
MOD_INSTALL = $(ABSPERLRUN) -MExtUtils::Install -e 'install([ from_to => {@ARGV}, verbose => '\''$(VERBINST)'\'', uninstall_shadows => '\''$(UNINST)'\'', dir_mode => '\''$(PERM_DIR)'\'' ]);' --
DOC_INSTALL = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'perllocal_install' --
UNINSTALL = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'uninstall' --
WARN_IF_OLD_PACKLIST = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'warn_if_old_packlist' --
MACROSTART =
MACROEND =
USEMAKEFILE = -f
FIXIN = $(ABSPERLRUN) -MExtUtils::MY -e 'MY->fixin(shift)' --
CP_NONEMPTY = $(ABSPERLRUN) -MExtUtils::Command::MM -e 'cp_nonempty' --
# --- MakeMaker makemakerdflt section:
makemakerdflt : all
$(NOECHO) $(NOOP)
# --- MakeMaker dist section:
TAR = tar
TARFLAGS = cvf
ZIP = zip
ZIPFLAGS = -r
COMPRESS = gzip
SUFFIX = .gz
SHAR = shar
PREOP = $(NOECHO) $(NOOP)
POSTOP = $(NOECHO) $(NOOP)
TO_UNIX = $(NOECHO) $(NOOP)
CI = ci -u
RCS_LABEL = rcs -Nv$(VERSION_SYM): -q
DIST_CP = best
DIST_DEFAULT = tardist
DISTNAME = FCGI-ProcManager
DISTVNAME = FCGI-ProcManager-0.25
# --- MakeMaker macro section:
# --- MakeMaker depend section:
# --- MakeMaker cflags section:
# --- MakeMaker const_loadlibs section:
# --- MakeMaker const_cccmd section:
# --- MakeMaker post_constants section:
# --- MakeMaker pasthru section:
PASTHRU = LIBPERL_A="$(LIBPERL_A)"\
LINKTYPE="$(LINKTYPE)"\
PREFIX="$(PREFIX)"
# --- MakeMaker special_targets section:
.SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)
.PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir
# --- MakeMaker c_o section:
# --- MakeMaker xs_c section:
# --- MakeMaker xs_o section:
# --- MakeMaker top_targets section:
all :: pure_all manifypods
$(NOECHO) $(NOOP)
pure_all :: config pm_to_blib subdirs linkext
$(NOECHO) $(NOOP)
subdirs :: $(MYEXTLIB)
$(NOECHO) $(NOOP)
config :: $(FIRST_MAKEFILE) blibdirs
$(NOECHO) $(NOOP)
help :
perldoc ExtUtils::MakeMaker
# --- MakeMaker blibdirs section:
blibdirs : $(INST_LIBDIR)$(DFSEP).exists $(INST_ARCHLIB)$(DFSEP).exists $(INST_AUTODIR)$(DFSEP).exists $(INST_ARCHAUTODIR)$(DFSEP).exists $(INST_BIN)$(DFSEP).exists $(INST_SCRIPT)$(DFSEP).exists $(INST_MAN1DIR)$(DFSEP).exists $(INST_MAN3DIR)$(DFSEP).exists
$(NOECHO) $(NOOP)
# Backwards compat with 6.18 through 6.25
blibdirs.ts : blibdirs
$(NOECHO) $(NOOP)
$(INST_LIBDIR)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_LIBDIR)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_LIBDIR)
$(NOECHO) $(TOUCH) $(INST_LIBDIR)$(DFSEP).exists
$(INST_ARCHLIB)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_ARCHLIB)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_ARCHLIB)
$(NOECHO) $(TOUCH) $(INST_ARCHLIB)$(DFSEP).exists
$(INST_AUTODIR)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_AUTODIR)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_AUTODIR)
$(NOECHO) $(TOUCH) $(INST_AUTODIR)$(DFSEP).exists
$(INST_ARCHAUTODIR)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_ARCHAUTODIR)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_ARCHAUTODIR)
$(NOECHO) $(TOUCH) $(INST_ARCHAUTODIR)$(DFSEP).exists
$(INST_BIN)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_BIN)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_BIN)
$(NOECHO) $(TOUCH) $(INST_BIN)$(DFSEP).exists
$(INST_SCRIPT)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_SCRIPT)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_SCRIPT)
$(NOECHO) $(TOUCH) $(INST_SCRIPT)$(DFSEP).exists
$(INST_MAN1DIR)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_MAN1DIR)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_MAN1DIR)
$(NOECHO) $(TOUCH) $(INST_MAN1DIR)$(DFSEP).exists
$(INST_MAN3DIR)$(DFSEP).exists :: Makefile.PL
$(NOECHO) $(MKPATH) $(INST_MAN3DIR)
$(NOECHO) $(CHMOD) $(PERM_DIR) $(INST_MAN3DIR)
$(NOECHO) $(TOUCH) $(INST_MAN3DIR)$(DFSEP).exists
# --- MakeMaker linkext section:
linkext :: $(LINKTYPE)
$(NOECHO) $(NOOP)
# --- MakeMaker dlsyms section:
# --- MakeMaker dynamic_bs section:
BOOTSTRAP =
# --- MakeMaker dynamic section:
dynamic :: $(FIRST_MAKEFILE) $(BOOTSTRAP) $(INST_DYNAMIC)
$(NOECHO) $(NOOP)
# --- MakeMaker dynamic_lib section:
# --- MakeMaker static section:
## $(INST_PM) has been moved to the all: target.
## It remains here for awhile to allow for old usage: "make static"
static :: $(FIRST_MAKEFILE) $(INST_STATIC)
$(NOECHO) $(NOOP)
# --- MakeMaker static_lib section:
# --- MakeMaker manifypods section:
POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
POD2MAN = $(POD2MAN_EXE)
manifypods : pure_all \
lib/FCGI/ProcManager.pm \
lib/FCGI/ProcManager/Constrained.pm
$(NOECHO) $(POD2MAN) --section=3 --perm_rw=$(PERM_RW) \
lib/FCGI/ProcManager.pm $(INST_MAN3DIR)/FCGI::ProcManager.$(MAN3EXT) \
lib/FCGI/ProcManager/Constrained.pm $(INST_MAN3DIR)/FCGI::ProcManager::Constrained.$(MAN3EXT)
# --- MakeMaker processPL section:
# --- MakeMaker installbin section:
# --- MakeMaker subdirs section:
# none
# --- MakeMaker clean_subdirs section:
clean_subdirs :
$(NOECHO) $(NOOP)
# --- MakeMaker clean section:
# Delete temporary files but do not touch installed files. We don't delete
# the Makefile here so a later make realclean still has a makefile to use.
clean :: clean_subdirs
- $(RM_F) \
$(BASEEXT).bso $(BASEEXT).def \
$(BASEEXT).exp $(BASEEXT).x \
$(BOOTSTRAP) $(INST_ARCHAUTODIR)/extralibs.all \
$(INST_ARCHAUTODIR)/extralibs.ld $(MAKE_APERL_FILE) \
*$(LIB_EXT) *$(OBJ_EXT) \
*perl.core MYMETA.json \
MYMETA.yml blibdirs.ts \
core core.*perl.*.? \
core.[0-9] core.[0-9][0-9] \
core.[0-9][0-9][0-9] core.[0-9][0-9][0-9][0-9] \
core.[0-9][0-9][0-9][0-9][0-9] lib$(BASEEXT).def \
mon.out perl \
perl$(EXE_EXT) perl.exe \
perlmain.c pm_to_blib \
pm_to_blib.ts so_locations \
tmon.out
- $(RM_RF) \
blib
$(NOECHO) $(RM_F) $(MAKEFILE_OLD)
- $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL)
# --- MakeMaker realclean_subdirs section:
realclean_subdirs :
$(NOECHO) $(NOOP)
# --- MakeMaker realclean section:
# Delete temporary files (via clean) and also delete dist files
realclean purge :: clean realclean_subdirs
- $(RM_F) \
$(FIRST_MAKEFILE) $(MAKEFILE_OLD)
- $(RM_RF) \
$(DISTVNAME)
# --- MakeMaker metafile section:
metafile : create_distdir
$(NOECHO) $(ECHO) Generating META.yml
$(NOECHO) $(ECHO) '---' > META_new.yml
$(NOECHO) $(ECHO) 'abstract: '\''A perl-based FastCGI process manager'\''' >> META_new.yml
$(NOECHO) $(ECHO) 'author:' >> META_new.yml
$(NOECHO) $(ECHO) ' - '\''James E Jurach (muaddib@erf.net)'\''' >> META_new.yml
$(NOECHO) $(ECHO) 'build_requires:' >> META_new.yml
$(NOECHO) $(ECHO) ' ExtUtils::MakeMaker: '\''0'\''' >> META_new.yml
$(NOECHO) $(ECHO) 'configure_requires:' >> META_new.yml
$(NOECHO) $(ECHO) ' ExtUtils::MakeMaker: '\''0'\''' >> META_new.yml
$(NOECHO) $(ECHO) 'dynamic_config: 1' >> META_new.yml
$(NOECHO) $(ECHO) 'generated_by: '\''ExtUtils::MakeMaker version 6.98, CPAN::Meta::Converter version 2.142060'\''' >> META_new.yml
$(NOECHO) $(ECHO) 'license: unknown' >> META_new.yml
$(NOECHO) $(ECHO) 'meta-spec:' >> META_new.yml
$(NOECHO) $(ECHO) ' url: http://module-build.sourceforge.net/META-spec-v1.4.html' >> META_new.yml
$(NOECHO) $(ECHO) ' version: '\''1.4'\''' >> META_new.yml
$(NOECHO) $(ECHO) 'name: FCGI-ProcManager' >> META_new.yml
$(NOECHO) $(ECHO) 'no_index:' >> META_new.yml
$(NOECHO) $(ECHO) ' directory:' >> META_new.yml
$(NOECHO) $(ECHO) ' - t' >> META_new.yml
$(NOECHO) $(ECHO) ' - inc' >> META_new.yml
$(NOECHO) $(ECHO) 'requires: {}' >> META_new.yml
$(NOECHO) $(ECHO) 'resources:' >> META_new.yml
$(NOECHO) $(ECHO) ' repository: git://git.shadowcat.co.uk/catagits/FCGI-ProcManager' >> META_new.yml
$(NOECHO) $(ECHO) 'version: '\''0.25'\''' >> META_new.yml
-$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml
$(NOECHO) $(ECHO) Generating META.json
$(NOECHO) $(ECHO) '{' > META_new.json
$(NOECHO) $(ECHO) ' "abstract" : "A perl-based FastCGI process manager",' >> META_new.json
$(NOECHO) $(ECHO) ' "author" : [' >> META_new.json
$(NOECHO) $(ECHO) ' "James E Jurach (muaddib@erf.net)"' >> META_new.json
$(NOECHO) $(ECHO) ' ],' >> META_new.json
$(NOECHO) $(ECHO) ' "dynamic_config" : 1,' >> META_new.json
$(NOECHO) $(ECHO) ' "generated_by" : "ExtUtils::MakeMaker version 6.98, CPAN::Meta::Converter version 2.142060",' >> META_new.json
$(NOECHO) $(ECHO) ' "license" : [' >> META_new.json
$(NOECHO) $(ECHO) ' "unknown"' >> META_new.json
$(NOECHO) $(ECHO) ' ],' >> META_new.json
$(NOECHO) $(ECHO) ' "meta-spec" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",' >> META_new.json
$(NOECHO) $(ECHO) ' "version" : "2"' >> META_new.json
$(NOECHO) $(ECHO) ' },' >> META_new.json
$(NOECHO) $(ECHO) ' "name" : "FCGI-ProcManager",' >> META_new.json
$(NOECHO) $(ECHO) ' "no_index" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "directory" : [' >> META_new.json
$(NOECHO) $(ECHO) ' "t",' >> META_new.json
$(NOECHO) $(ECHO) ' "inc"' >> META_new.json
$(NOECHO) $(ECHO) ' ]' >> META_new.json
$(NOECHO) $(ECHO) ' },' >> META_new.json
$(NOECHO) $(ECHO) ' "prereqs" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "build" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "requires" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "ExtUtils::MakeMaker" : "0"' >> META_new.json
$(NOECHO) $(ECHO) ' }' >> META_new.json
$(NOECHO) $(ECHO) ' },' >> META_new.json
$(NOECHO) $(ECHO) ' "configure" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "requires" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "ExtUtils::MakeMaker" : "0"' >> META_new.json
$(NOECHO) $(ECHO) ' }' >> META_new.json
$(NOECHO) $(ECHO) ' },' >> META_new.json
$(NOECHO) $(ECHO) ' "runtime" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "requires" : {}' >> META_new.json
$(NOECHO) $(ECHO) ' }' >> META_new.json
$(NOECHO) $(ECHO) ' },' >> META_new.json
$(NOECHO) $(ECHO) ' "release_status" : "stable",' >> META_new.json
$(NOECHO) $(ECHO) ' "resources" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "repository" : {' >> META_new.json
$(NOECHO) $(ECHO) ' "url" : "git://git.shadowcat.co.uk/catagits/FCGI-ProcManager"' >> META_new.json
$(NOECHO) $(ECHO) ' }' >> META_new.json
$(NOECHO) $(ECHO) ' },' >> META_new.json
$(NOECHO) $(ECHO) ' "version" : "0.25"' >> META_new.json
$(NOECHO) $(ECHO) '}' >> META_new.json
-$(NOECHO) $(MV) META_new.json $(DISTVNAME)/META.json
# --- MakeMaker signature section:
signature :
cpansign -s
# --- MakeMaker dist_basics section:
distclean :: realclean distcheck
$(NOECHO) $(NOOP)
distcheck :
$(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck
skipcheck :
$(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck
manifest :
$(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest
veryclean : realclean
$(RM_F) *~ */*~ *.orig */*.orig *.bak */*.bak *.old */*.old
# --- MakeMaker dist_core section:
dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE)
$(NOECHO) $(ABSPERLRUN) -l -e 'print '\''Warning: Makefile possibly out of date with $(VERSION_FROM)'\''' \
-e ' if -e '\''$(VERSION_FROM)'\'' and -M '\''$(VERSION_FROM)'\'' < -M '\''$(FIRST_MAKEFILE)'\'';' --
tardist : $(DISTVNAME).tar$(SUFFIX)
$(NOECHO) $(NOOP)
uutardist : $(DISTVNAME).tar$(SUFFIX)
uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu
$(NOECHO) $(ECHO) 'Created $(DISTVNAME).tar$(SUFFIX)_uu'
$(DISTVNAME).tar$(SUFFIX) : distdir
$(PREOP)
$(TO_UNIX)
$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
$(RM_RF) $(DISTVNAME)
$(COMPRESS) $(DISTVNAME).tar
$(NOECHO) $(ECHO) 'Created $(DISTVNAME).tar$(SUFFIX)'
$(POSTOP)
zipdist : $(DISTVNAME).zip
$(NOECHO) $(NOOP)
$(DISTVNAME).zip : distdir
$(PREOP)
$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
$(RM_RF) $(DISTVNAME)
$(NOECHO) $(ECHO) 'Created $(DISTVNAME).zip'
$(POSTOP)
shdist : distdir
$(PREOP)
$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
$(RM_RF) $(DISTVNAME)
$(NOECHO) $(ECHO) 'Created $(DISTVNAME).shar'
$(POSTOP)
# --- MakeMaker distdir section:
create_distdir :
$(RM_RF) $(DISTVNAME)
$(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \
-e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
distdir : create_distdir distmeta
$(NOECHO) $(NOOP)
# --- MakeMaker dist_test section:
disttest : distdir
cd $(DISTVNAME) && $(ABSPERLRUN) Makefile.PL
cd $(DISTVNAME) && $(MAKE) $(PASTHRU)
cd $(DISTVNAME) && $(MAKE) test $(PASTHRU)
# --- MakeMaker dist_ci section:
ci :
$(PERLRUN) "-MExtUtils::Manifest=maniread" \
-e "@all = keys %{ maniread() };" \
-e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \
-e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});"
# --- MakeMaker distmeta section:
distmeta : create_distdir metafile
$(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'exit unless -e q{META.yml};' \
-e 'eval { maniadd({q{META.yml} => q{Module YAML meta-data (added by MakeMaker)}}) }' \
-e ' or print "Could not add META.yml to MANIFEST: $$$${'\''@'\''}\n"' --
$(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'exit unless -f q{META.json};' \
-e 'eval { maniadd({q{META.json} => q{Module JSON meta-data (added by MakeMaker)}}) }' \
-e ' or print "Could not add META.json to MANIFEST: $$$${'\''@'\''}\n"' --
# --- MakeMaker distsignature section:
distsignature : create_distdir
$(NOECHO) cd $(DISTVNAME) && $(ABSPERLRUN) -MExtUtils::Manifest=maniadd -e 'eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) }' \
-e ' or print "Could not add SIGNATURE to MANIFEST: $$$${'\''@'\''}\n"' --
$(NOECHO) cd $(DISTVNAME) && $(TOUCH) SIGNATURE
cd $(DISTVNAME) && cpansign -s
# --- MakeMaker install section:
install :: pure_install doc_install
$(NOECHO) $(NOOP)
install_perl :: pure_perl_install doc_perl_install
$(NOECHO) $(NOOP)
install_site :: pure_site_install doc_site_install
$(NOECHO) $(NOOP)
install_vendor :: pure_vendor_install doc_vendor_install
$(NOECHO) $(NOOP)
pure_install :: pure_$(INSTALLDIRS)_install
$(NOECHO) $(NOOP)
doc_install :: doc_$(INSTALLDIRS)_install
$(NOECHO) $(NOOP)
pure__install : pure_site_install
$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
doc__install : doc_site_install
$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
pure_perl_install :: all
$(NOECHO) $(MOD_INSTALL) \
read $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist \
write $(DESTINSTALLARCHLIB)/auto/$(FULLEXT)/.packlist \
$(INST_LIB) $(DESTINSTALLPRIVLIB) \
$(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
$(INST_BIN) $(DESTINSTALLBIN) \
$(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
$(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
$(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
$(SITEARCHEXP)/auto/$(FULLEXT)
pure_site_install :: all
$(NOECHO) $(MOD_INSTALL) \
read $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist \
write $(DESTINSTALLSITEARCH)/auto/$(FULLEXT)/.packlist \
$(INST_LIB) $(DESTINSTALLSITELIB) \
$(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
$(INST_BIN) $(DESTINSTALLSITEBIN) \
$(INST_SCRIPT) $(DESTINSTALLSITESCRIPT) \
$(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
$(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
$(PERL_ARCHLIB)/auto/$(FULLEXT)
pure_vendor_install :: all
$(NOECHO) $(MOD_INSTALL) \
read $(VENDORARCHEXP)/auto/$(FULLEXT)/.packlist \
write $(DESTINSTALLVENDORARCH)/auto/$(FULLEXT)/.packlist \
$(INST_LIB) $(DESTINSTALLVENDORLIB) \
$(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
$(INST_BIN) $(DESTINSTALLVENDORBIN) \
$(INST_SCRIPT) $(DESTINSTALLVENDORSCRIPT) \
$(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
$(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)
doc_perl_install :: all
$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
-$(NOECHO) $(DOC_INSTALL) \
"Module" "$(NAME)" \
"installed into" "$(INSTALLPRIVLIB)" \
LINKTYPE "$(LINKTYPE)" \
VERSION "$(VERSION)" \
EXE_FILES "$(EXE_FILES)" \
>> $(DESTINSTALLARCHLIB)/perllocal.pod
doc_site_install :: all
$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
-$(NOECHO) $(DOC_INSTALL) \
"Module" "$(NAME)" \
"installed into" "$(INSTALLSITELIB)" \
LINKTYPE "$(LINKTYPE)" \
VERSION "$(VERSION)" \
EXE_FILES "$(EXE_FILES)" \
>> $(DESTINSTALLARCHLIB)/perllocal.pod
doc_vendor_install :: all
$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
-$(NOECHO) $(DOC_INSTALL) \
"Module" "$(NAME)" \
"installed into" "$(INSTALLVENDORLIB)" \
LINKTYPE "$(LINKTYPE)" \
VERSION "$(VERSION)" \
EXE_FILES "$(EXE_FILES)" \
>> $(DESTINSTALLARCHLIB)/perllocal.pod
uninstall :: uninstall_from_$(INSTALLDIRS)dirs
$(NOECHO) $(NOOP)
uninstall_from_perldirs ::
$(NOECHO) $(UNINSTALL) $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist
uninstall_from_sitedirs ::
$(NOECHO) $(UNINSTALL) $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist
uninstall_from_vendordirs ::
$(NOECHO) $(UNINSTALL) $(VENDORARCHEXP)/auto/$(FULLEXT)/.packlist
# --- MakeMaker force section:
# Phony target to force checking subdirectories.
FORCE :
$(NOECHO) $(NOOP)
# --- MakeMaker perldepend section:
# --- MakeMaker makefile section:
# We take a very conservative approach here, but it's worth it.
# We move Makefile to Makefile.old here to avoid gnu make looping.
$(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
$(NOECHO) $(ECHO) "Makefile out-of-date with respect to $?"
$(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
-$(NOECHO) $(RM_F) $(MAKEFILE_OLD)
-$(NOECHO) $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
- $(MAKE) $(USEMAKEFILE) $(MAKEFILE_OLD) clean $(DEV_NULL)
$(PERLRUN) Makefile.PL
$(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <=="
$(NOECHO) $(ECHO) "==> Please rerun the $(MAKE) command. <=="
$(FALSE)
# --- MakeMaker staticmake section:
# --- MakeMaker makeaperl section ---
MAP_TARGET = perl
FULLPERL = /home/andrew/perl5/perlbrew/perls/perl-5.20.0/bin/perl
$(MAP_TARGET) :: static $(MAKE_APERL_FILE)
$(MAKE) $(USEMAKEFILE) $(MAKE_APERL_FILE) $@
$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE) pm_to_blib
$(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
$(NOECHO) $(PERLRUNINST) \
Makefile.PL DIR= \
MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=
# --- MakeMaker test section:
TEST_VERBOSE=0
TEST_TYPE=test_$(LINKTYPE)
TEST_FILE = test.pl
TEST_FILES = t/*.t
TESTDB_SW = -d
testdb :: testdb_$(LINKTYPE)
test :: $(TEST_TYPE) subdirs-test
subdirs-test ::
$(NOECHO) $(NOOP)
test_dynamic :: pure_all
PERL_DL_NONLAZY=1 $(FULLPERLRUN) "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness($(TEST_VERBOSE), '$(INST_LIB)', '$(INST_ARCHLIB)')" $(TEST_FILES)
testdb_dynamic :: pure_all
PERL_DL_NONLAZY=1 $(FULLPERLRUN) $(TESTDB_SW) "-I$(INST_LIB)" "-I$(INST_ARCHLIB)" $(TEST_FILE)
test_ : test_dynamic
test_static :: test_dynamic
testdb_static :: testdb_dynamic
# --- MakeMaker ppd section:
# Creates a PPD (Perl Package Description) for a binary distribution.
ppd :
$(NOECHO) $(ECHO) '' > $(DISTNAME).ppd
$(NOECHO) $(ECHO) ' A perl-based FastCGI process manager' >> $(DISTNAME).ppd
$(NOECHO) $(ECHO) ' James E Jurach (muaddib@erf.net)' >> $(DISTNAME).ppd
$(NOECHO) $(ECHO) ' ' >> $(DISTNAME).ppd
$(NOECHO) $(ECHO) ' ' >> $(DISTNAME).ppd
$(NOECHO) $(ECHO) ' ' >> $(DISTNAME).ppd
$(NOECHO) $(ECHO) ' ' >> $(DISTNAME).ppd
$(NOECHO) $(ECHO) '' >> $(DISTNAME).ppd
# --- MakeMaker pm_to_blib section:
pm_to_blib : $(FIRST_MAKEFILE) $(TO_INST_PM)
$(NOECHO) $(ABSPERLRUN) -MExtUtils::Install -e 'pm_to_blib({@ARGV}, '\''$(INST_LIB)/auto'\'', q[$(PM_FILTER)], '\''$(PERM_DIR)'\'')' -- \
lib/FCGI/ProcManager.pm blib/lib/FCGI/ProcManager.pm \
lib/FCGI/ProcManager/Constrained.pm blib/lib/FCGI/ProcManager/Constrained.pm
$(NOECHO) $(TOUCH) pm_to_blib
# --- MakeMaker selfdocument section:
# --- MakeMaker postamble section:
# End.
FCGI-ProcManager-0.28/Makefile.PL 0000644 0001750 0001750 00000001652 12433524674 015661 0 ustar andrew andrew # -*- perl -*-
# Copyright (c) 2000, FundsXpress Financial Network, Inc.
# This library is free software released "AS IS WITH ALL FAULTS"
# and WITHOUT ANY WARRANTIES under the terms of the GNU Lesser
# General Public License, Version 2.1, a copy of which can be
# found in the "COPYING" file of this distribution.
# $Id: Makefile.PL,v 1.2 2000/11/10 01:09:41 muaddib Exp $
require 5.004;
use strict;
use ExtUtils::MakeMaker;
WriteMakefile
(NAME => 'FCGI::ProcManager',
VERSION_FROM => 'lib/FCGI/ProcManager.pm', # finds $VERSION
DISTNAME => 'FCGI-ProcManager',
($] >= 5.005 ?
(ABSTRACT => 'A perl-based FastCGI process manager',
AUTHOR => 'James E Jurach (muaddib@erf.net)') : ()),
dist => { COMPRESS => 'gzip', SUFFIX => 'gz' },
META_MERGE => {
resources => {
repository => 'git://git.shadowcat.co.uk/catagits/FCGI-ProcManager',
},
},
);
FCGI-ProcManager-0.28/MANIFEST 0000644 0001750 0001750 00000000614 13055160477 015033 0 ustar andrew andrew .gitignore
ChangeLog
COPYING
lib/FCGI/ProcManager.pm
lib/FCGI/ProcManager/Constrained.pm
Makefile.old
Makefile.PL
MANIFEST This list of files
MANIFEST.SKIP
README
t/exporter.t
t/procmanager.t
t/procmanager_constrained.pm
TODO
META.yml Module YAML meta-data (added by MakeMaker)
META.json Module JSON meta-data (added by MakeMaker)
FCGI-ProcManager-0.28/TODO 0000644 0001750 0001750 00000000000 12433524674 014361 0 ustar andrew andrew FCGI-ProcManager-0.28/META.json 0000664 0001750 0001750 00000001755 13055160477 015334 0 ustar andrew andrew {
"abstract" : "A perl-based FastCGI process manager",
"author" : [
"James E Jurach (muaddib@erf.net)"
],
"dynamic_config" : 1,
"generated_by" : "ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010",
"license" : [
"unknown"
],
"meta-spec" : {
"url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
"version" : "2"
},
"name" : "FCGI-ProcManager",
"no_index" : {
"directory" : [
"t",
"inc"
]
},
"prereqs" : {
"build" : {
"requires" : {
"ExtUtils::MakeMaker" : "0"
}
},
"configure" : {
"requires" : {
"ExtUtils::MakeMaker" : "0"
}
}
},
"release_status" : "stable",
"resources" : {
"repository" : {
"type" : "git",
"url" : "git://git.shadowcat.co.uk/catagits/FCGI-ProcManager"
}
},
"version" : "0.28",
"x_serialization_backend" : "JSON::PP version 2.27300"
}
FCGI-ProcManager-0.28/.gitignore 0000644 0001750 0001750 00000000115 12433524674 015670 0 ustar andrew andrew FCGI-ProcManager-*
MANIFEST
MANIFEST.bak
MYMETA.*
Makefile
blib/
pm_to_blib
FCGI-ProcManager-0.28/MANIFEST.SKIP 0000644 0001750 0001750 00000000114 12433524674 015575 0 ustar andrew andrew ^blib/
^pm_to_blib
^FCGI-ProcManager-
MANIFEST.bak
Makefile$
MYMETA.
.git/
FCGI-ProcManager-0.28/lib/ 0000755 0001750 0001750 00000000000 13055160477 014447 5 ustar andrew andrew FCGI-ProcManager-0.28/lib/FCGI/ 0000755 0001750 0001750 00000000000 13055160477 015157 5 ustar andrew andrew FCGI-ProcManager-0.28/lib/FCGI/ProcManager/ 0000755 0001750 0001750 00000000000 13055160477 017355 5 ustar andrew andrew FCGI-ProcManager-0.28/lib/FCGI/ProcManager/Constrained.pm 0000644 0001750 0001750 00000014311 12433527056 022163 0 ustar andrew andrew package FCGI::ProcManager::Constrained;
use strict;
use warnings;
use Carp qw/ confess /;
use base 'FCGI::ProcManager';
use Config;
sub new {
my $proto = shift;
my $self = $proto->SUPER::new(@_);
$self->{max_requests} = $ENV{PM_MAX_REQUESTS} || 0 unless defined $self->{max_requests};
$self->{sizecheck_num_requests} = $ENV{PM_SIZECHECK_NUM_REQUESTS} || 0 unless defined $self->{sizecheck_num_requests};
$self->{max_size} = $ENV{PM_MAX_SIZE} || 0 unless defined $self->{max_size};
if ($self->{sizecheck_num_requests} && ! _can_check_size()) {
confess "Cannot load size check modules for your platform: sizecheck_num_requests > 0 unsupported";
}
return $self;
}
sub max_requests { shift->pm_parameter('max_requests', @_); }
sub sizecheck_num_requests { shift->pm_parameter('sizecheck_num_requests', @_); }
sub max_size { shift->pm_parameter('max_size', @_); }
sub handling_init {
my $self = shift;
$self->SUPER::handling_init();
$self->{_request_counter} = 0;
}
sub pm_post_dispatch {
my $self = shift;
if ($self->max_requests > 0 && ++$self->{_request_counter} == $self->max_requests) {
$self->pm_exit("safe exit after max_requests (" . $self->{_request_counter} . ")");
}
if ($self->sizecheck_num_requests
and $self->{_request_counter} # Not the first request
and $self->{_request_counter} % $self->sizecheck_num_requests == 0
) {
$self->pm_exit("safe exit due to memory limits exceeded after " . $self->{_request_counter} . " requests")
if $self->_limits_are_exceeded;
}
$self->SUPER::pm_post_dispatch();
}
sub _limits_are_exceeded {
my $self = shift;
my ($size, $share, $unshared) = $self->_check_size();
return 1 if $self->max_size && $size > $self->max_size;
return 0 unless $share;
# FIXME
# return 1 if $self->min_share_size && $share < $self->min_share_size;
# return 1 if $self->max_unshared_size && $unshared > $self->max_unshared_size;
return 0;
}
# The following code is wholesale is nicked from Apache::SizeLimit::Core
sub _check_size {
my $class = shift;
my ($size, $share) = $class->_platform_check_size();
return ($size, $share, $size - $share);
}
sub _load {
my $mod = shift;
$mod =~ s/::/\//g;
$mod .= '.pm';
eval { require($mod); 1; }
}
our $USE_SMAPS;
BEGIN {
my ($major,$minor) = split(/\./, $Config{'osvers'});
if ($Config{'osname'} eq 'solaris' &&
(($major > 2) || ($major == 2 && $minor >= 6))) {
*_can_check_size = sub () { 1 };
*_platform_check_size = \&_solaris_2_6_size_check;
*_platform_getppid = \&_perl_getppid;
}
elsif ($Config{'osname'} eq 'linux' && _load('Linux::Pid')) {
*_platform_getppid = \&_linux_getppid;
*_can_check_size = sub () { 1 };
if (_load('Linux::Smaps') && Linux::Smaps->new($$)) {
$USE_SMAPS = 1;
*_platform_check_size = \&_linux_smaps_size_check;
}
else {
$USE_SMAPS = 0;
*_platform_check_size = \&_linux_size_check;
}
}
elsif ($Config{'osname'} =~ /(?:bsd|aix)/i && _load('BSD::Resource')) {
# on OSX, getrusage() is returning 0 for proc & shared size.
*_can_check_size = sub () { 1 };
*_platform_check_size = \&_bsd_size_check;
*_platform_getppid = \&_perl_getppid;
}
else {
*_can_check_size = sub () { 0 };
}
}
sub _linux_smaps_size_check {
my $class = shift;
return $class->_linux_size_check() unless $USE_SMAPS;
my $s = Linux::Smaps->new($$)->all;
return ($s->size, $s->shared_clean + $s->shared_dirty);
}
sub _linux_size_check {
my $class = shift;
my ($size, $share) = (0, 0);
if (open my $fh, '<', '/proc/self/statm') {
($size, $share) = (split /\s/, scalar <$fh>)[0,2];
close $fh;
}
else {
$class->_error_log("Fatal Error: couldn't access /proc/self/status");
}
# linux on intel x86 has 4KB page size...
return ($size * 4, $share * 4);
}
sub _solaris_2_6_size_check {
my $class = shift;
my $size = -s "/proc/self/as"
or $class->_error_log("Fatal Error: /proc/self/as doesn't exist or is empty");
$size = int($size / 1024);
# return 0 for share, to avoid undef warnings
return ($size, 0);
}
# rss is in KB but ixrss is in BYTES.
# This is true on at least FreeBSD, OpenBSD, & NetBSD
sub _bsd_size_check {
my @results = BSD::Resource::getrusage();
my $max_rss = $results[2];
my $max_ixrss = int ( $results[3] / 1024 );
return ($max_rss, $max_ixrss);
}
sub _win32_size_check {
my $class = shift;
# get handle on current process
my $get_current_process = Win32::API->new(
'kernel32',
'get_current_process',
[],
'I'
);
my $proc = $get_current_process->Call();
# memory usage is bundled up in ProcessMemoryCounters structure
# populated by GetProcessMemoryInfo() win32 call
my $DWORD = 'B32'; # 32 bits
my $SIZE_T = 'I'; # unsigned integer
# build a buffer structure to populate
my $pmem_struct = "$DWORD" x 2 . "$SIZE_T" x 8;
my $mem_counters
= pack( $pmem_struct, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
# GetProcessMemoryInfo is in "psapi.dll"
my $get_process_memory_info = new Win32::API(
'psapi',
'GetProcessMemoryInfo',
[ 'I', 'P', 'I' ],
'I'
);
my $bool = $get_process_memory_info->Call(
$proc,
$mem_counters,
length $mem_counters,
);
# unpack ProcessMemoryCounters structure
my $peak_working_set_size =
(unpack($pmem_struct, $mem_counters))[2];
# only care about peak working set size
my $size = int($peak_working_set_size / 1024);
return ($size, 0);
}
sub _perl_getppid { return getppid }
sub _linux_getppid { return Linux::Pid::getppid() }
1;
=head1 NAME
FCGI::ProcManager::Constrained - Process manager with constraints
=head1 SYNOPSIS
$ENV{PM_MAX_REQUESTS} = 1000;
$ENV{PM_SIZECHECK_NUM_REQUESTS} = 10;
$ENV{PM_MAX_SIZE} = 4096;
=head1 DESCRIPTION
Subclass of L which adds checks for memory limits
like L.
=head1 AUTHORS, COPYRIGHT AND LICENSE
See L.
=cut
FCGI-ProcManager-0.28/lib/FCGI/ProcManager.pm 0000644 0001750 0001750 00000043257 13055160454 017721 0 ustar andrew andrew package FCGI::ProcManager;
# Copyright (c) 2000, FundsXpress Financial Network, Inc.
# This library is free software released under the GNU Lesser General
# Public License, Version 2.1. Please read the important licensing and
# disclaimer information included below.
# $Id: ProcManager.pm,v 1.23 2001/04/23 16:10:11 muaddie Exp $
use strict;
use Exporter;
use POSIX qw(:signal_h);
use vars qw($VERSION @ISA @EXPORT_OK %EXPORT_TAGS $Q $SIG_CODEREF);
BEGIN {
$VERSION = '0.28';
$VERSION = eval $VERSION;
@ISA = qw(Exporter);
@EXPORT_OK = qw(pm_manage pm_die pm_wait
pm_write_pid_file pm_remove_pid_file
pm_pre_dispatch pm_post_dispatch
pm_change_process_name pm_received_signal pm_parameter
pm_warn pm_notify pm_abort pm_exit
$SIG_CODEREF);
$EXPORT_TAGS{all} = \@EXPORT_OK;
$FCGI::ProcManager::Default = 'FCGI::ProcManager';
}
=head1 NAME
FCGI::ProcManager - functions for managing FastCGI applications.
=head1 SYNOPSIS
# In Object-oriented style.
use CGI::Fast;
use FCGI::ProcManager;
my $proc_manager = FCGI::ProcManager->new({
n_processes => 10
});
$proc_manager->pm_manage();
while (my $cgi = CGI::Fast->new()) {
$proc_manager->pm_pre_dispatch();
# ... handle the request here ...
$proc_manager->pm_post_dispatch();
}
# This style is also supported:
use CGI::Fast;
use FCGI::ProcManager qw(pm_manage pm_pre_dispatch
pm_post_dispatch);
pm_manage( n_processes => 10 );
while (my $cgi = CGI::Fast->new()) {
pm_pre_dispatch();
#...
pm_post_dispatch();
}
=head1 DESCRIPTION
FCGI::ProcManager is used to serve as a FastCGI process manager. By
re-implementing it in perl, developers can more finely tune performance in
their web applications, and can take advantage of copy-on-write semantics
prevalent in UNIX kernel process management. The process manager should
be invoked before the caller''s request loop
The primary routine, C, enters a loop in which it maintains a
number of FastCGI servers (via fork(2)), and which reaps those servers
when they die (via wait(2)).
C provides too hooks:
C - called just before the manager enters the manager loop.
C - called just before a server is returns from C
It is necessary for the caller, when implementing its request loop, to
insert a call to C at the top of the loop, and then
7C at the end of the loop.
=head2 Signal Handling
FCGI::ProcManager attempts to do the right thing for proper shutdowns now.
When it receives a SIGHUP, it sends a SIGTERM to each of its children, and
then resumes its normal operations.
When it receives a SIGTERM, it sends a SIGTERM to each of its children, sets
an alarm(3) "die timeout" handler, and waits for each of its children to
die. If all children die before this timeout, process manager exits with
return status 0. If all children do not die by the time the "die timeout"
occurs, the process manager sends a SIGKILL to each of the remaining
children, and exists with return status 1.
In order to get FastCGI servers to exit upon receiving a signal, it is
necessary to use its FAIL_ACCEPT_ON_INTR. See L's description of
FAIL_ACCEPT_ON_INTR. Unfortunately, if you want/need to use L, it
is currently necessary to run the latest (at the time of writing) development
version of FCGI.pm. (>= 0.71_02)
Otherwise, if you don't, there is a loop around accept(2) which prevents
os_unix.c OS_Accept() from returning the necessary error when FastCGI
servers blocking on accept(2) receive the SIGTERM or SIGHUP.
FCGI::ProcManager uses POSIX::sigaction() to override the default SA_RESTART
policy used for perl's %SIG behavior. Specifically, the process manager
never uses SA_RESTART, while the child FastCGI servers turn off SA_RESTART
around the accept(2) loop, but reinstate it otherwise.
The desired (and implemented) effect is to give a request as big a chance as
possible to succeed and to delay their exits until after their request,
while allowing the FastCGI servers waiting for new requests to die right
away.
=head1 METHODS
=head2 new
class or instance
(ProcManager) new([hash parameters])
Constructs a new process manager. Takes an option has of initial parameter
values, and assigns these to the constructed object HASH, overriding any
default values. The default parameter values currently are:
role => manager
start_delay => 0
die_timeout => 60
pm_title => 'perl-fcgi-pm'
=cut
sub new {
my ($proto,$init) = @_;
$init ||= {};
my $this = {
role => "manager",
start_delay => 0,
die_timeout => 60,
pm_title => 'perl-fcgi-pm',
%$init
};
bless $this, ref($proto)||$proto;
$this->{PIDS} = {};
# initialize signal constructions.
unless ($this->no_signals() or $^O eq 'MSWin32') {
$this->{sigaction_no_sa_restart} =
POSIX::SigAction->new('FCGI::ProcManager::sig_sub');
$this->{sigaction_sa_restart} =
POSIX::SigAction->new('FCGI::ProcManager::sig_sub',undef,POSIX::SA_RESTART);
}
return $this;
}
sub _set_signal_handler {
my ($this, $signal, $restart) = @_;
if ($^O eq 'MSWin32') {
$SIG{$signal} = 'FCGI::ProcManager::sig_sub';
} else {
no strict 'refs';
sigaction(&{"POSIX::SIG$signal"}(), $restart ? $this->{sigaction_sa_restart} : $this->{sigaction_no_sa_restart})
or $this->pm_warn("sigaction: SIG$signal: $!");
}
}
=head1 Manager methods
=head2 pm_manage
instance or export
(int) pm_manage([hash parameters])
DESCRIPTION:
When this is called by a FastCGI script to manage application servers. It
defines a sequence of instructions for a process to enter this method and
begin forking off and managing those handlers, and it defines a sequence of
instructions to intialize those handlers.
If n_processes < 1, the managing section is subverted, and only the
handling sequence is executed.
Either returns the return value of pm_die() and/or pm_abort() (which will
not ever return in general), or returns 1 to the calling script to begin
handling requests.
=cut
sub pm_manage {
my ($this,%values) = self_or_default(@_);
map { $this->pm_parameter($_,$values{$_}) } keys %values;
local $SIG{CHLD}; # Replace the SIGCHLD default handler in case
# somebody shit on it whilst loading code.
# skip to handling now if we won't be managing any processes.
$this->n_processes() or return;
# call the (possibly overloaded) management initialization hook.
$this->role("manager");
$this->managing_init();
$this->pm_notify("initialized");
my $manager_pid = $$;
MANAGING_LOOP: while (1) {
$this->n_processes() > 0 or
return $this->pm_die();
# while we have fewer servers than we want.
PIDS: while (keys(%{$this->{PIDS}}) < $this->n_processes()) {
if (my $pid = fork()) {
# the manager remembers the server.
$this->{PIDS}->{$pid} = { pid=>$pid };
$this->pm_notify("server (pid $pid) started");
} elsif (! defined $pid) {
return $this->pm_abort("fork: $!");
} else {
$this->{MANAGER_PID} = $manager_pid;
# the server exits the managing loop.
last MANAGING_LOOP;
}
for (my $s = $this->start_delay(); $s > 0; $s -= sleep $s) {};
}
# this should block until the next server dies.
$this->pm_wait();
}# while 1
HANDLING:
# forget any children we had been collecting.
delete $this->{PIDS};
# call the (possibly overloaded) handling init hook
$this->role("server");
$this->handling_init();
$this->pm_notify("initialized");
# server returns
return 1;
}
=head2 managing_init
instance
() managing_init()
DESCRIPTION:
Overrideable method which initializes a process manager. In order to
handle signals, manage the PID file, and change the process name properly,
any method which overrides this should call SUPER::managing_init().
=cut
sub managing_init {
my ($this) = @_;
# begin to handle signals.
# We do NOT want SA_RESTART in the process manager.
# -- we want start the shutdown sequence immediately upon SIGTERM.
unless ($this->no_signals()) {
$this->_set_signal_handler('TERM', 0);
$this->_set_signal_handler('HUP', 0);
$SIG_CODEREF = sub { $this->sig_manager(@_) };
}
# change the name of this process as it appears in ps(1) output.
$this->pm_change_process_name($this->pm_parameter('pm_title'));
$this->pm_write_pid_file();
}
=head2 pm_die
instance or export
() pm_die(string msg[, int exit_status])
DESCRIPTION:
This method is called when a process manager receives a notification to
shut itself down. pm_die() attempts to shutdown the process manager
gently, sending a SIGTERM to each managed process, waiting die_timeout()
seconds to reap each process, and then exit gracefully once all children
are reaped, or to abort if all children are not reaped.
=cut
sub pm_die {
my ($this,$msg,$n) = self_or_default(@_);
# stop handling signals.
undef $SIG_CODEREF;
$SIG{HUP} = 'DEFAULT';
$SIG{TERM} = 'DEFAULT';
$this->pm_remove_pid_file();
# prepare to die no matter what.
if (defined $this->die_timeout()) {
$SIG{ALRM} = sub { $this->pm_abort("wait timeout") };
alarm $this->die_timeout();
}
# send a TERM to each of the servers.
if (my @pids = keys %{$this->{PIDS}}) {
$this->pm_notify("sending TERM to PIDs, @pids");
kill "TERM", @pids;
}
# wait for the servers to die.
while (%{$this->{PIDS}}) {
$this->pm_wait();
}
# die already.
$this->pm_exit("dying: ".$msg,$n);
}
=head2 pm_wait
instance or export
(int pid) pm_wait()
DESCRIPTION:
This calls wait() which suspends execution until a child has exited.
If the process ID returned by wait corresponds to a managed process,
pm_notify() is called with the exit status of that process.
pm_wait() returns with the return value of wait().
=cut
sub pm_wait {
my ($this) = self_or_default(@_);
# wait for the next server to die.
return if ((my $pid = wait()) < 0);
# notify when one of our servers have died.
delete $this->{PIDS}->{$pid} and
$this->pm_notify("server (pid $pid) exited with status $?");
return $pid;
}
=head2 pm_write_pid_file
instance or export
() pm_write_pid_file([string filename])
DESCRIPTION:
Writes current process ID to optionally specified file. If no filename is
specified, it uses the value of the C parameter.
=cut
sub pm_write_pid_file {
my ($this,$fname) = self_or_default(@_);
$fname ||= $this->pid_fname() or return;
my $PIDFILE;
if (!open $PIDFILE, ">$fname") {
$this->pm_warn("open: $fname: $!");
return;
}
print $PIDFILE "$$\n" or die "Could not print PID: $!";
close $PIDFILE or die "Could not close PID file: $!";
}
=head2 pm_remove_pid_file
instance or export
() pm_remove_pid_file()
DESCRIPTION:
Removes optionally specified file. If no filename is specified, it uses
the value of the C parameter.
=cut
sub pm_remove_pid_file {
my ($this,$fname) = self_or_default(@_);
$fname ||= $this->pid_fname() or return;
my $ret = unlink($fname) or $this->pm_warn("unlink: $fname: $!");
return $ret;
}
=head2 sig_sub
instance
() sig_sub(string name)
DESCRIPTION:
The name of this method is passed to POSIX::sigaction(), and handles signals
for the process manager. If $SIG_CODEREF is set, then the input arguments
to this are passed to a call to that.
=cut
sub sig_sub {
$SIG_CODEREF->(@_) if ref $SIG_CODEREF;
}
=head2 sig_manager
instance
() sig_manager(string name)
DESCRIPTION:
Handles signals of the process manager. Takes as input the name of signal
being handled.
=cut
sub sig_manager {
my ($this,$name) = @_;
if ($name eq "TERM") {
$this->pm_notify("received signal $name");
$this->pm_die("safe exit from signal $name");
} elsif ($name eq "HUP") {
# send a TERM to each of the servers, and pretend like nothing happened..
if (my @pids = keys %{$this->{PIDS}}) {
$this->pm_notify("sending TERM to PIDs, @pids");
kill "TERM", @pids;
}
} else {
$this->pm_notify("ignoring signal $name");
}
}
=head1 Handler methods
=head2 handling_init
instance or export
() handling_init()
DESCRIPTION:
=cut
sub handling_init {
my ($this) = @_;
# begin to handle signals.
# We'll want accept(2) to return -1(EINTR) on caught signal..
unless ($this->no_signals()) {
$this->_set_signal_handler('TERM', 0);
$this->_set_signal_handler('HUP', 0);
$SIG_CODEREF = sub { $this->sig_handler(@_) };
}
# change the name of this process as it appears in ps(1) output.
$this->pm_change_process_name("perl-fcgi");
# Re-srand in case someone called rand before the fork, so that
# children get different random numbers.
srand;
}
=head2 pm_pre_dispatch
instance or export
() pm_pre_dispatch()
DESCRIPTION:
=cut
sub pm_pre_dispatch {
my ($this) = self_or_default(@_);
# Now, we want the request to continue unhindered..
unless ($this->no_signals()) {
$this->_set_signal_handler('TERM', 1);
$this->_set_signal_handler('HUP', 1);
}
}
=head2 pm_post_dispatch
instance or export
() pm_post_dispatch()
DESCRIPTION:
=cut
sub pm_post_dispatch {
my ($this) = self_or_default(@_);
if ($this->pm_received_signal("TERM")) {
$this->pm_exit("safe exit after SIGTERM");
}
if ($this->pm_received_signal("HUP")) {
$this->pm_exit("safe exit after SIGHUP");
}
if ($this->{MANAGER_PID} and getppid() != $this->{MANAGER_PID}) {
$this->pm_exit("safe exit: manager has died");
}
# We'll want accept(2) to return -1(EINTR) on caught signal..
unless ($this->no_signals()) {
$this->_set_signal_handler('TERM', 0);
$this->_set_signal_handler('HUP', 0);
}
}
=head2 sig_handler
instance or export
() sig_handler()
DESCRIPTION:
=cut
sub sig_handler {
my ($this,$name) = @_;
$this->pm_received_signal($name,1);
}
=head1 Common methods and routines
=head2 self_or_default
private global
(ProcManager, @args) self_or_default([ ProcManager, ] @args);
DESCRIPTION:
This is a helper subroutine to acquire or otherwise create a singleton
default object if one is not passed in, e.g., a method call.
=cut
sub self_or_default {
return @_ if defined $_[0] and !ref $_[0] and $_[0] eq 'FCGI::ProcManager';
if (!defined $_[0] or (ref($_[0]) ne 'FCGI::ProcManager' and
!UNIVERSAL::isa($_[0],'FCGI::ProcManager'))) {
$Q or $Q = $FCGI::ProcManager::Default->new;
unshift @_, $Q;
}
return wantarray ? @_ : $Q;
}
=head2 pm_change_process_name
instance or export
() pm_change_process_name()
DESCRIPTION:
=cut
sub pm_change_process_name {
my ($this,$name) = self_or_default(@_);
$0 = $name;
}
=head2 pm_received_signal
instance or export
() pm_received signal()
DESCRIPTION:
=cut
sub pm_received_signal {
my ($this,$sig,$received) = self_or_default(@_);
$sig or return $this->{SIG_RECEIVED};
$received and $this->{SIG_RECEIVED}->{$sig}++;
return $this->{SIG_RECEIVED}->{$sig};
}
=head1 parameters
=head2 pm_parameter
instance or export
() pm_parameter()
DESCRIPTION:
=cut
sub pm_parameter {
my ($this,$key,$value) = self_or_default(@_);
defined $value and $this->{$key} = $value;
return $this->{$key};
}
=head2 n_processes
=head2 no_signals
=head2 pid_fname
=head2 die_timeout
=head2 role
=head2 start_delay
DESCRIPTION:
=cut
sub n_processes { shift->pm_parameter("n_processes", @_); }
sub pid_fname { shift->pm_parameter("pid_fname", @_); }
sub no_signals { shift->pm_parameter("no_signals", @_); }
sub die_timeout { shift->pm_parameter("die_timeout", @_); }
sub role { shift->pm_parameter("role", @_); }
sub start_delay { shift->pm_parameter("start_delay", @_); }
=head1 notification and death
=head2 pm_warn
instance or export
() pm_warn()
DESCRIPTION:
=cut
sub pm_warn {
my ($this,$msg) = self_or_default(@_);
$this->pm_notify($msg);
}
=head2 pm_notify
instance or export
() pm_notify()
DESCRIPTION:
=cut
sub pm_notify {
my ($this,$msg) = self_or_default(@_);
$msg =~ s/\s*$/\n/;
print STDERR "FastCGI: ".$this->role()." (pid $$): ".$msg;
}
=head2 pm_exit
instance or export
() pm_exit(string msg[, int exit_status])
DESCRIPTION:
=cut
sub pm_exit {
my ($this,$msg,$n) = self_or_default(@_);
$n ||= 0;
# if we still have children at this point, something went wrong.
# SIGKILL them now.
kill "KILL", keys %{$this->{PIDS}} if $this->{PIDS};
$this->pm_warn($msg);
$@ = $msg;
exit $n;
}
=head2 pm_abort
instance or export
() pm_abort(string msg[, int exit_status])
DESCRIPTION:
=cut
sub pm_abort {
my ($this,$msg,$n) = self_or_default(@_);
$n ||= 1;
$this->pm_exit($msg,1);
}
1;
__END__
=head1 BUGS
No known bugs, but this does not mean no bugs exist.
=head1 SEE ALSO
L.
=head1 MAINTAINER
Gareth Kirwan
=head1 AUTHOR
James E Jurach Jr.
=head1 COPYRIGHT
FCGI-ProcManager - A Perl FCGI Process Manager
Copyright (c) 2000, FundsXpress Financial Network, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
BECAUSE THIS LIBRARY IS LICENSED FREE OF CHARGE, THIS LIBRARY IS
BEING PROVIDED "AS IS WITH ALL FAULTS," WITHOUT ANY WARRANTIES
OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT
LIMITATION, ANY IMPLIED WARRANTIES OF TITLE, NONINFRINGEMENT,
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, AND THE
ENTIRE RISK AS TO SATISFACTORY QUALITY, PERFORMANCE, ACCURACY,
AND EFFORT IS WITH THE YOU. See the GNU Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
=cut
FCGI-ProcManager-0.28/t/ 0000755 0001750 0001750 00000000000 13055160477 014144 5 ustar andrew andrew FCGI-ProcManager-0.28/t/procmanager_constrained.pm 0000644 0001750 0001750 00000002622 12433524674 021375 0 ustar andrew andrew # -*- perl -*-
# Copyright (c) 2000, FundsXpress Financial Network, Inc.
# This library is free software released "AS IS WITH ALL FAULTS"
# and WITHOUT ANY WARRANTIES under the terms of the GNU Lesser
# General Public License, Version 2.1, a copy of which can be
# found in the "COPYING" file of this distribution.
# $Id: procmanager.t,v 1.9 2001/04/23 16:13:45 muaddie Exp $
use strict;
use Test;
BEGIN { plan tests => 5; }
use FCGI::ProcManager::Constrained;
my $m;
ok $m = FCGI::ProcManager::Constrained->new();
ok $m->n_processes(100) == 100;
ok $m->n_processes(2) == 2;
ok $m->n_processes(0) == 0;
ok !$m->pm_manage();
#ok $m->n_processes(-3);
#eval { $m->pm_manage(); };
#ok $@ =~ /dying from number of processes exception: -3/;
#undef $@;
if ($ENV{PM_N_PROCESSES}) {
$m->n_processes($ENV{PM_N_PROCESSES});
$m->pm_manage();
sample_request_loop($m);
}
exit 0;
sub sample_request_loop {
my ($m) = @_;
while (1) {
# Simulate blocking for a request.
my $t1 = int(rand(2)+2);
print "TEST: simulating blocking for request: $t1 seconds.\n";
sleep $t1;
# (Here is where accept-fail-on-intr would exit request loop.)
$m->pm_pre_dispatch();
# Simulate a request dispatch.
my $t = int(rand(3)+2);
print "TEST: simulating new request: $t seconds.\n";
while (my $nslept = sleep $t) {
$t -= $nslept;
last unless $t;
}
$m->pm_post_dispatch();
}
}
FCGI-ProcManager-0.28/t/exporter.t 0000644 0001750 0001750 00000002551 12433524674 016206 0 ustar andrew andrew # -*- perl -*-
# Copyright (c) 2000, FundsXpress Financial Network, Inc.
# This library is free software released "AS IS WITH ALL FAULTS"
# and WITHOUT ANY WARRANTIES under the terms of the GNU Lesser
# General Public License, Version 2.1, a copy of which can be
# found in the "COPYING" file of this distribution.
# $Id: exporter.t,v 1.6 2001/04/23 16:13:45 muaddie Exp $
use strict;
use Test;
BEGIN { plan tests => 4; }
use FCGI::ProcManager qw(:all);
ok pm_parameter('n_processes',100) == 100;
ok pm_parameter('n_processes',2) == 2;
ok pm_parameter('n_processes',0) == 0;
ok !pm_manage();
#ok pm_parameter('n_processes',-3);
#eval { pm_manage(); };
#ok $@ =~ /dying from number of processes exception: -3/;
#undef $@;
if ($ENV{PM_N_PROCESSES}) {
pm_parameter('n_processes',$ENV{PM_N_PROCESSES});
pm_manage();
sample_request_loop();
}
exit 0;
sub sample_request_loop {
while (1) {
# Simulate blocking for a request.
my $t1 = int(rand(2)+1);
print "TEST: simulating blocking for request: $t1 seconds.\n";
sleep $t1;
# (Here is where accept-fail-on-intr would exit request loop.)
pm_pre_dispatch();
# Simulate a request dispatch.
my $t = int(rand(3)+2);
print "TEST: simulating request: sleeping $t seconds.\n";
while (my $nslept = sleep $t) {
$t -= $nslept;
last unless $t;
}
pm_post_dispatch();
}
}
FCGI-ProcManager-0.28/t/procmanager.t 0000644 0001750 0001750 00000002570 12433524674 016635 0 ustar andrew andrew # -*- perl -*-
# Copyright (c) 2000, FundsXpress Financial Network, Inc.
# This library is free software released "AS IS WITH ALL FAULTS"
# and WITHOUT ANY WARRANTIES under the terms of the GNU Lesser
# General Public License, Version 2.1, a copy of which can be
# found in the "COPYING" file of this distribution.
# $Id: procmanager.t,v 1.9 2001/04/23 16:13:45 muaddie Exp $
use strict;
use Test;
BEGIN { plan tests => 5; }
use FCGI::ProcManager;
my $m;
ok $m = FCGI::ProcManager->new();
ok $m->n_processes(100) == 100;
ok $m->n_processes(2) == 2;
ok $m->n_processes(0) == 0;
ok !$m->pm_manage();
#ok $m->n_processes(-3);
#eval { $m->pm_manage(); };
#ok $@ =~ /dying from number of processes exception: -3/;
#undef $@;
if ($ENV{PM_N_PROCESSES}) {
$m->n_processes($ENV{PM_N_PROCESSES});
$m->pm_manage();
sample_request_loop($m);
}
exit 0;
sub sample_request_loop {
my ($m) = @_;
while (1) {
# Simulate blocking for a request.
my $t1 = int(rand(2)+2);
print "TEST: simulating blocking for request: $t1 seconds.\n";
sleep $t1;
# (Here is where accept-fail-on-intr would exit request loop.)
$m->pm_pre_dispatch();
# Simulate a request dispatch.
my $t = int(rand(3)+2);
print "TEST: simulating new request: $t seconds.\n";
while (my $nslept = sleep $t) {
$t -= $nslept;
last unless $t;
}
$m->pm_post_dispatch();
}
}
FCGI-ProcManager-0.28/README 0000644 0001750 0001750 00000003100 12433524674 014555 0 ustar andrew andrew $Id: README,v 1.6 2001/04/23 16:07:16 muaddie Exp $
General Information
-------------------
FCGI-ProcManager is a process manager for FCGI. By implementing the
process manager in perl, we can more finely tune FastCGI performance, and
we can take CPU and memory advantages of fast forks and copy-on-write UNIX
process management characteristics.
Installation
------------
FCGI-ProcManager is expected to compile and run on all systems which
support normal UNIX fork/wait semantics. FCGI-ProcManager is known to
compile and run on the following systems:
- Linux (2.0.x, 2.1.x, 2.2.x, 2.3.x)
- Solaris (2.5.1, 2.6, 2.7)
- Digital UNIX 4.0
- NetBSD 1.4
Full installation instructions can be found in the INSTALL file.
To build,
perl Makefile.PL
make all
make install
Usage
-----
In order to use this process manager, you should create a FCGI::ProcManager
object, configure it, call its pm_manage() method. Then, you'll want to
call its pm_pre_dispatch() method at the top of your request loop, and then
pm_post_dispatch() at the bottom of your request loop. Consult
FCGI::ProcManager documentation for more detail. (perldoc ./ProcManager.pm)
Copyright
---------
Copyright (c) 2000, FundsXpress Financial Network, Inc.
Disclaimer
----------
This library is free software released "AS IS WITH ALL FAULTS"
and WITHOUT ANY WARRANTIES under the terms of the GNU Lesser
General Public License, Version 2.1, a copy of which can be
found in the "COPYING" file of this distribution.
Maintainer
------
Gareth Kirwan
Author
------
James Jurach
FCGI-ProcManager-0.28/ChangeLog 0000644 0001750 0001750 00000015274 13055160423 015453 0 ustar andrew andrew 0.28 2017-02-27 Andrew Rodland
* 2+ years may not have been long enough for a trial release.
* Fix startup failure in 0.27 (RT#120448).
0.27 2017-02-27 Andrew Rodland
* 2+ years seems like long enough for a trial release.
* No changes since 0.26_02.
0.26_02 2014-11-27 Andrew Rodland
* Try again, with the OS name spelled properly.
0.26_01 2014-11-26 Andrew Rodland
* Trial version of Win32 support
0.25 2014-11-20 Andrew Rodland
* Notice errors writing out the PID file and abort.
* Make sure that children get independent random numbers by calling
srand() after fork.
0.24 2011-10-04 Tomas Doran
* Further fix to pm_wait routine to find the correct PID and remove it
(fixing logical error introduced in the last release), noted by Vadim
Dashkevich
* Document (somewhat) FCGI::ProcManager::Constrainted
0.23 2011-09-27 Tomas Doran
* Fix pm_wait routine to exit without a warning
* Fix pm_wait to correctly detect child processes which have died.
* Fix to return SIGCHLD handler to it's default state in the
pm_manage loop so that loading code which sets SIGCHLD to ignore
won't interfere with normal operation.
* Add repository metadata.
0.22 2011-08-04 Tomas Doran
* Ship a version of FCGI::ProcManager::Constrainted which actually
works as advertised.
0.21 2011-08-02 Tomas Doran
* Ship a working dist.
0.20 2011-08-02 Gareth Kirwan
* ProcManager::Constrained: Add a new FCGI::ProcManager::Constrainted
subclass which will restart workers safely after a certain number of
requests, or at certain memory thresholds.
* ProcManager: Fix start_delay causing a permanent hang.
0.19 2009-07-22 Gareth Kirwan
* ProcManager.pm: Add a pm_title option to configure the process title
assigned to $0
0.18 2007-12-18 James Jurach
* ProcManager.pm: Remove constraint that parent process cannot die.
0.17
* ProcManager.pm: Remove constraint that process can't change pid.
This resolves the daemon exiting after first child dies
if the process id of the daemon has changed since starting.
This commonly happens when a script waits to check for the
socket being available and working before forking and exitting.
It can also happen in a race condition of fork && exit when
the exit is delayed until after the forked child has already
spawned the fastcgi handlers.
2001-04-23 18:12 James Jurach
* ProcManager.pm: SIGHUP handler now issues SIGTERM to children but
then proceeds normally. added documentation blurb about signal
handling. we now use POSIX::sigaction() to avoid SA_RESTART during
certain regions. added re-usable POSIX::SigAction members to toggle
SA_RESTART. added sig_sub() -- necessary to pass name to
POSIX::SigAction creation.
* README: added small blurb to consult FCGI::ProcManager
documentation.
* t/exporter.t:
* t/procmanager.t: fixed pm_manage() test.
2001-03-13 18:12 James Jurach
* ProcManager.pm: removed check for FCGI_ROLE. now more
transparent when undesired.
* ProcManager.pm: detect when no FastCGI environment exists.
* ProcManager.pm: only warn and sleep -- do not abort on fork
failure.
* ProcManager.pm: now, we give notification to which processes we
send a TERM signal.
2001-02-09 10:16 James Jurach
* t/: exporter.t, procmanager.t: made it easier to manage
sample_request_loop() for testing.
* ProcManager.pm: modified some error messages. added immediate
notify of manager signal.
* ProcManager.pm: added more documentation. renamed
pm_reap_server() to pm_wait(). fixed problem when ! MANAGER_PID
that caused server to die immediately we now delete list of child
PIDs from each child. added mechanism to pm_exit() to send a
SIGKILL to any remaining children.
2001-01-31 01:13 James Jurach
* README: more documentation
* ProcManager.pm: re-organized method layout. separated manager
vs. server vs. common moved more intialization into managing_init()
and handling_init() created pm_die() to be called when manager
should die. cleaned up error messages and notifications.
* t/: exporter.t, procmanager.t: revised test messages
2001-01-30 16:35 James Jurach
* t/: exporter.t, procmanager.t: removed call to pm_state()
* ProcManager.pm: removed sleep() call after testing
signal-during-fork-loop
2001-01-30 12:49 James Jurach
* ProcManager.pm: Cleaned up pm_manage(). removed signal
registration routines. replaced by direct %SIG access. there is
now a manager signal handler and a handler signal handler. added
checks to die when getppid() changes.
2001-01-20 02:06 James Jurach
* MANIFEST: removed Changes from MANIFEST
2001-01-13 00:44 James Jurach
* t/procmanager.t: corrected various recent method name changes.
removed calls to want_to_die(). added request loop hooks to
pm_pre_dispatch(), pm_post_dispatch(). renamed sample_handler() to
sample_request_loop().
* ProcManager.pm: renamed request loop hooks to pm_pre_dispatch(),
pm_post_dispatch(). when pm_manage() is called with
n_processes==0, return through goto. renamed pre_manage_init() to
managing_init(). renamed post_manage_init() to handling_init().
added received_signal() to remember that a signal was received.
signal handler simpler: now only notes signal and propagates
signal.
* t/exporter.t: this uses non-OO calling mode.
* MANIFEST: added t/exporter.t.
* Changes: ChangeLog is where per-file changes are listed.
2000-12-22 05:58 James Jurach
* ProcManager.pm: corrected logic error in self_or_default().
changed all occurances of write_pid_file() to pm_write_pid_file().
changed all occurances of remove_pid_file() to
pm_remove_pid_file().
2000-12-14 17:54 James Jurach
* ProcManager.pm: corrected state() -> pm_state() method call.
2000-12-10 17:25 James Jurach
* ProcManager.pm: corrected some method renaming issues.
2000-12-09 19:48 James Jurach
* t/procmanager.t: effected the changes to these subroutine names.
* ProcManager.pm: made this module OO/Exporter hybrid. removed
treatment of $ENV{PROCMANAGER_PROCESSES} from constructor. changed
several subroutine names.
2000-12-05 22:23 James Jurach
* ProcManager.pm: made SIGHUP's do what SIGTERM's do
2000-11-20 James Jurach
* Released first public version.
FCGI-ProcManager-0.28/META.yml 0000664 0001750 0001750 00000001154 13055160477 015155 0 ustar andrew andrew ---
abstract: 'A perl-based FastCGI process manager'
author:
- 'James E Jurach (muaddib@erf.net)'
build_requires:
ExtUtils::MakeMaker: '0'
configure_requires:
ExtUtils::MakeMaker: '0'
dynamic_config: 1
generated_by: 'ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010'
license: unknown
meta-spec:
url: http://module-build.sourceforge.net/META-spec-v1.4.html
version: '1.4'
name: FCGI-ProcManager
no_index:
directory:
- t
- inc
resources:
repository: git://git.shadowcat.co.uk/catagits/FCGI-ProcManager
version: '0.28'
x_serialization_backend: 'CPAN::Meta::YAML version 0.012'
FCGI-ProcManager-0.28/COPYING 0000644 0001750 0001750 00000063647 12433524674 014756 0 ustar andrew andrew
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations
below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
^L
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it
becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
^L
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control
compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
^L
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
^L
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
^L
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
^L
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply, and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License
may add an explicit geographical distribution limitation excluding those
countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
^L
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
^L
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms
of the ordinary General Public License).
To apply these terms, attach the following notices to the library.
It is safest to attach them to the start of each source file to most
effectively convey the exclusion of warranty; and each file should
have at least the "copyright" line and a pointer to where the full
notice is found.
Copyright (C)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper
mail.
You should also get your employer (if you work as a programmer) or
your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James
Random Hacker.
, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!