Activator
view release on metacpan or search on metacpan
bin/activator.pl view on Meta::CPAN
# $config, $args, $project, $action and the current apache pid are globally interesting
my ( $config, $args, $project, $action, $httpd_pid );
try eval {
# Act::Config requires that project be set via an option or be the
# last arg, hence the flag after undef below
$config = Activator::Config->get_config( \@ARGV, undef, 1 );
};
if ( catch my $e ) {
die( "Error while processing command line options: $e" );
}
my $log_level = $config->{log_level} || 'WARN';
if ( $config->{v} || $config->{verbose} ) {
Activator::Log->level( 'INFO' );
}
$action = $ARGV[-2];
$project = $ARGV[-1];
bin/activator.pl view on Meta::CPAN
if ( my $dict_targ = $config->{Activator}->{Dictionary}->{dict_files} ) {
push @cmds, "ln -sf $config->{conf_path}/dict $dict_targ";
}
foreach $cmd ( @cmds ) {
DEBUG( $cmd );
die "$cmd failed" unless !system( $cmd );
}
# TODO: abstract this out such that we can process any number of
# configured directories. Since this is running under the apache
# engine, we know to process the share/apache/ config.
#
# TODO: make activator_codebase NOT be required: When activator
# installs, it should look for the share directory.
#
find( \&process, "$config->{activator_codebase}/share/apache2" );
# process configuration files
my $config_files = $config->{sync_config_files};
my $reg = Activator::Registry->new();
foreach my $config_file ( @$config_files ) {
DEBUG( "processing config file: $config_file");
my $fq_source_file = "$config->{conf_path}/$config_file";
my $fq_dest_file ="$config->{sync_conf_dir}/$config_file";
if ( $config_file =~ /\.ya?ml$/i ) {
# Read the project registry and catalyst configuration files and
# do variable replacements. We do this by kinda cheating: load the
# yml into a special registry realm (named after the file), and
# since it is a hash, do a YAML dump of that hash.
bin/activator.pl view on Meta::CPAN
# do replacments
$reg->replace_in_realm( $config_file, $config );
$YAML::Syck::SingleQuote = 1;
DEBUG( qq(dumping config: $fq_dest_file, ). $reg->get_realm( $config_file ) );
YAML::Syck::DumpFile( $fq_dest_file,
# get realm returns a hashref
$reg->get_realm( $config_file ) );
};
if ( catch my $e ) {
WARN( "Couldn't process YAML file '$config_file': $e");
}
}
# if it's a template process it based on the current config.
elsif ($config_file =~ /\.tt$/i ) {
$config_file =~ /(.+)\.tt$/;
my $out = $1;
if ( !$out ) {
WARN( "Couldn't process Template file '$config_file'");
next;
}
# $fq_dest_file = "$config->{sync_conf_dir}/$out";
my $tt = Template->new( { DEBUG => 1,
ABSOLUTE => 1,
OUTPUT_PATH => $config->{sync_conf_dir},
}
);
DEBUG( qq(tt processing: $fq_source_file, $config, $out ));
$tt->process( $fq_source_file, $config, $out ) || Activator::Log->logdie( $tt->error()."\n");
}
# just copy the file
else {
my $rsync_flags = ( $config->{debug} ? '-v' : '' );
$rsync_flags .= ' --cvs-exclude';
my $cmd = "rsync -a $rsync_flags $fq_source_file $fq_dest_file";
die "$cmd failed" unless !system( $cmd );
}
}
bin/activator.pl view on Meta::CPAN
sleep(1);
}
print "\n";
$cmd = "/usr/sbin/httpd -f $httpd_conf";
INFO("Starting apache");
DEBUG("...with command: $cmd");
system( $cmd );
}
# TODO: this should process anything, not just apache2 files
sub process {
my $dir = $File::Find::dir; # is the current directory name,
my $file = $_; # is the current filename within that directory
my $fq = $File::Find::name; # is the complete pathname to the file.
# capture the intervening path
$fq =~ m|share/apache2/(.+)\.tt$|;
my $out = $1;
return unless $out;
DEBUG( qq( processing $file into ).$config->{apache2}->{ServerRoot}.'/'.$out );
my $tt = Template->new( { DEBUG => 1,
ABSOLUTE => 1,
OUTPUT_PATH => $config->{apache2}->{ServerRoot},
}
);
$tt->process( $fq, $config, $out ) || Activator::Log->logdie( $tt->error()."\n");
# TODO: use some smart hueristics to properly chmod that which
# should be executable
#
#if( $out =~ m@/s?bin/|/init.d/@ ) {
# chmod 0755, $config->{apache2}->{ServerRoot}.'/'.$out
#}
}
# copy the default project config for a catalyst app to the correct
lib/Activator.pm view on Meta::CPAN
=item *
Role based logging utilizing Log4Perl
=item *
Global database access definitions allowing generic abstraction of database queries (supports intentionally avoiding an ORM)
=item *
Role and configuration file aware command line options processing
=back
=head2 Motivation
We are users of Catalyst. We love it, but sometimes making all the
parts of our projects play nice together within our eco-system is
difficult. As software would travel from inception to development, to
QA, to production, there were always design issues that would crop up
lib/Activator/Config.pm view on Meta::CPAN
configuration files. These files will be deterministically merged into
one hash. You can then pass this to an application or write it to file.
This module is not an options validator. It uses command line options
as overrides to existing keys in configuration files and DOES NOT
validate them. Unrecognized command line options are ignored and
C<@ARGV> is modified to remove recognized options, leaving barewords
and unrecognized options in place and the same order for a real
options validator (like L<Getopt::Long>). If you do use another
options module, make sure you call C<get_config()> BEFORE you call
their processor, so that C<@ARGV> will be in an appropriate state.
Environment variables can be used to act as a default to command line
options, and/or override any top level configuration file key which is
a scalar.
This module is cool because:
=over
=item *
lib/Activator/Config.pm view on Meta::CPAN
structures for configuration, you can only override top level keys
that are scalars using command line arguments and/or environment
variables.
=head2 Reserved Arguments
There are a few reserved command line arguments:
--skip_env : ignore environment variables (EXCEPT $USER)
--project=<> : used to search for the C<E<lt>projectE<gt>.yml> file
--realm=<> : use C<E<lt>realmE<gt>.yml> in config file processing and
consider all command line arguments to be in this realm
--conf_path : colon separated list of directories to search for config files
=head2 Project as a Bareword Argument
There are times where a script takes the project name as a required
bareword argument. For these cases, require that project be the last
argument, and pass a flag to L</get_config()>.
That is, when your script is called like this:
lib/Activator/Config.pm view on Meta::CPAN
=head1 CONFIGURATION FILES
Currently, you can put your YAML configuration file wherever you like,
but you must set a key inside your configuration files C<conf_path>,
then set the environment variable C<ACT_CONFIG_conf_path> or use the
C<--conf_path> option. It is somewhat wonky the way this currently
works, and it'll get fixed Real Soon Now.
This path behaves the same as a bash shell C<$PATH>, in that you can
set this to one or more colon separated fully qualified path values.
Note that the leftmost path takes precedence when processing config
files.
=head2 Configuration File Heirarchy
In order to facilite the varied ways in which software is developed,
deployed, and used, the following heirarchy lists the configuration
file heirarchy suported from highest precedence to lowest:
$ENV{USER}.yml - user specific settings
<realm>.yml - realm specific settings and defaults
lib/Activator/Config.pm view on Meta::CPAN
A common configuration directory will have the following files:
<user>.yml files
qa.yml
dev.yml
prod.yml
Using the C<--realm> option or C<ACT_CONFIG_realm> environment variable
set to qa, dev or prod will cause I<realm>.yml to be used during
configuration file processing in addition to any I<realm> specific
keys in any other config files being utilized.
=head1 CONFIGURATION FILE FORMAT
The format for configuration files is YAML. In addition to YAML's
requirements, you must define top level relams within your YAML files.
When passing a realm to L</get_config()> (or via the C<--realm>
command line argument), values for the realm take precedence over the
default realm's values. For example, given YAML:
lib/Activator/Config.pm view on Meta::CPAN
#
my $config = Activator::Config->get_config( \@ARGV, 'some' );
#
# don't ignore --realm and ACT_CONFIG_realm, use $barewords[-1] (the
# last bareword argument) as the project
#
Activator::Config->get_config( \@ARGV, undef, 1 );
See L</get_args()> for a description of the way command line arguments
are processed.
If called repeatedly, this sub does NOT reprocess C<\@ARGV>. This
allows you to make multiple calls to get a reference to the config for
multiple realms if desired.
=cut
sub get_config {
my ( $pkg, $argv, $realm, $project_is_arg ) = @_;
my $self = &new( @_ );
# get_args sets $self->{ARGV}
lib/Activator/Config.pm view on Meta::CPAN
}
# setup or get the merged YAML configuration settings from files
# into the registry
my $config = $self->{REGISTRY}->get_realm( $realm );
# first call
if ( !keys %$config ) {
# define valid config from config files
try eval {
$self->_process_config_files( $realm, $skip_env, $project_is_arg );
};
if ( catch my $e ) {
$e->rethrow;
}
# read environment variables, set any keys found
if ( !$skip_env ) {
my ( $env_key, $env_realm );
foreach my $env_key ( keys %ENV ) {
next unless $env_key =~ /^ACT_CONFIG_(.+)/;
lib/Activator/Config.pm view on Meta::CPAN
elsif( $env_opt_realm ne $opt_realm &&
!grep( /$opt_key/, qw( skip_env project
realm conf_path ) ) ) {
WARN( "Skipped invalid environment variable $env_key. Key '$opt_key' for realm '$opt_realm' unchanged");
}
}
}
# forced overrides from config files
my $overrides = $self->{REGISTRY}->get_realm( 'overrides' );
DEBUG( Data::Dumper->Dump( [ $overrides ], [ 'processing overrides' ] ) );
# NOTE: bad (typo) keys could be in overrides. Someday,
# Activator::Registry will allow debug mode so we can
# show this.
if ( exists( $overrides->{ $realm } ) ) {
$self->{REGISTRY}->register_hash( 'right', $overrides->{ $realm }, $realm );
}
# now that realm is set, make sure our $config points to it
$config = $self->{REGISTRY}->get_realm( $realm );
lib/Activator/Config.pm view on Meta::CPAN
my ( $pkg, $argv_raw ) = @_;
my $self = &new( @_ );
# quick and dirty check for debug mode
if( grep /^--?debug$/, @$argv_raw ) {
Activator::Log->level('DEBUG');
DEBUG('Entering debug mode');
}
if ( defined( $self->{ARGV} ) || defined( $self->{BAREWORDS} ) ) {
DEBUG("skipping ARGV reprocessing");
return ( $self->{ARGV}, $self->{BAREWORDS} );
}
DEBUG("got ARGV: ". join(' ', @$argv_raw ));
# use refs to insure that that $self->{ARGV} and
# $self->{BAREWORDS} are defined, so we don't return undef.
my $argv = {};
my $barewords = [];
my $found_terminator = 0;
lib/Activator/Config.pm view on Meta::CPAN
# clean up value, if quoted
if ( defined $value ) {
$value =~ s/^"//;
$value =~ s/"$//;
}
return ( $key, $value );
}
# Merge config files into this objects Activator::Registry object
sub _process_config_files {
my ( $pkg, $realm, $skip_env, $project_is_arg ) = @_;
my $self = &new( @_ );
# figure out what project we are working on
my $project =
$self->{ARGV}->{project} ||
( $project_is_arg ? $self->{BAREWORDS}->[-1] : undef ) ||
( $skip_env ? undef : $ENV{ACT_CONFIG_project} ) ||
Activator::Exception::Config->throw( 'project', 'missing' );
# process these files:
# $ENV{USER}.yml
# <realm>.yml - realm specific settings and defaults
# <project>.yml - project specific settings and defaults
# org.yml - top level organization settings and defaults
# in one of these paths, if set
# --conf_file= : use $self->{ARGV}->{conf_file} (which could be an arrayref )
# ACT_CONFIG_conf_file= : comma separated list of files
my $conf_path = $self->{ARGV}->{conf_path};
if ( ! $conf_path ) {
lib/Activator/Config.pm view on Meta::CPAN
if ( defined( $org_yml ) && exists( $org_yml->{overrides} ) ) {
$self->{REGISTRY}->register_hash( 'left', $org_yml->{overrides}, 'overrides' );
DEBUG('Registered: ' . $files->{org}->{file} . " overrides" );
}
# make sure all is kosher
my $test = $self->{REGISTRY}->get_realm( $realm );
if ( !keys %$test ) {
DEBUG( Data::Dumper->Dump( [ $self->{REGISTRY} ], [ qw/ registry / ] ) );
ERROR( "After processing, '$realm' realm should not be empty, but it is!");
Activator::Exception::Config->throw('realm', 'empty', $realm);
}
}
# Override any options in $config with the values in $argv. Sets non-existent keys.
#
# Arguments:
# $config : hashref to the options for $realm
# $argv : arrayref to command line arguments. All recognized options are removed.
#
lib/Activator/DB.pm view on Meta::CPAN
Allows all code in your project/team/company to access the db in a
consistent fashion.
=item *
By default, dies on all errors enforcing try/catch programming
=item *
Implemented as a singleton so each process is guranteed to be using no
more than one connection to each database from the pool.
=back
Disadvantages:
=over
=item *
lib/Activator/Dictionary.pm view on Meta::CPAN
use Activator::Dictionary;
my $dict = Activator::Dictionary->get_dict();
my $val = $dict->lookup( $key );
=head1 DESCRIPTION
This module provides simple lookup of key/value pairs for intended for
internationalization/localization(I18N/L10N). It is also useful for
separating the progamming of a project from the creation of the text
used by it. The object created by this module is a per-process
singleton that uses dictionary definintions from a simple
space-delimeted file or database table(s). The dictionary is
completely maintained in memory and loads realms and languages
dynamically on an as-needed basis, so this module may not be
appropriate for extremely large lexicons or for projects that create
large numbers of program instances. That being said, it can be
relatively memory efficient when used for a single language deployment
in an application that provides multiple language support.
An C<Activator::Dictionary> object can have multiple realms: that is, you
lib/Activator/Dictionary.pm view on Meta::CPAN
}
if ( defined( $self->{config}->{dict_tables} ) &&
!defined( $self->{config}->{db_alias} ) ) {
Activator::Exception::Dictionary->throw( 'db_alias', 'missing' );
}
}
sub _init_lang {
my ($self, $lang) = @_;
my $processed = 0;
# import all the realms for this language from the db
if ( defined( $self->{config}->{dict_tables} ) ) {
my ( $sql, $rows, $row, $col, $realm, $key );
foreach my $table ( @{ $self->{config}->{dict_tables} } ) {
$sql = "SELECT * FROM $table WHERE lang = ?";
try eval {
$rows = Activator::DB->getall_hashrefs( $sql, [ $lang ], connect => 'def' );
};
if ( catch my $e ) {
lib/Activator/Dictionary.pm view on Meta::CPAN
if ( exists( $self->{ $lang }->{ $realm }->{ $key } ) ) {
local $Log::Log4perl::caller_depth;
$Log::Log4perl::caller_depth += 3;
WARN( "dictionary table $table redefines value for realm '$realm' key_prefix '$row->{key_prefix}' column '$col'");
}
$self->{ $lang }->{ $realm }->{ $key } =
$row->{ $col };
}
}
}
$processed = 1;
}
}
# import all the realms for this lang from files
if ( defined( $self->{config}->{dict_files} ) ) {
my $dir_loc = $self->{config}->{dict_files};
$dir_loc =~ s|/$||;
$dir_loc .= "/$lang";
if (!opendir( DIR, $dir_loc ) ) {
lib/Activator/Dictionary.pm view on Meta::CPAN
s/^\s+//;
s/\s+$//;
($key, $value) = split /\s+/, $_, 2;
$value =~ s/("$)//;
if ( $1 ) {
$value =~ s/^"//;
}
$self->{ $lang }->{ $realm }->{ $key } = $value;
}
close DICT;
$processed = 1;
}
}
}
return $processed;
}
=head1 SEE ALSO
L<Activator::Log>, L<Activator::Exception>, L<Activator::DB>,
L<Exception::Class::TryCatch>, L<Class::StrongSingleton>
=head1 AUTHOR
Karim A. Nassar
lib/Activator/Emailer.pm view on Meta::CPAN
my $args = { mailer => $self->{mailer_type} };
if ( keys %{ $self->{mailer_args} } ) {
$args->{mailer_args} = [ %{ $self->{mailer_args} } ];
}
$self->{sender} = Email::Send->new( $args );
return $self;
}
=head2 send( $tt_vars )
Send the email using C<$tt_vars> for the L<Template::Toolkit> C<process> method.
=cut
sub send {
my ( $self, $tt_vars ) = @_;
# TODO: test that tt_vars is a hashref
$tt_vars->{'Activator_Emailer_format'} = 'text';
$tt_vars->{html_header} = $self->{html_header};
$tt_vars->{html_body} = $self->{html_body};
$tt_vars->{html_footer} = $self->{html_footer};
my $text_body = '';
my $html_body = '';
my $tt = Template->new( $self->{tt_options} ) ||
Activator::Exception::Emailer->throw( 'tt_new_error', $Template::ERROR, "\n" );
$tt->process( $self->{email_wrap}, $tt_vars, \$text_body ) ||
Activator::Exception::Emailer->throw( 'tt_process_error', $tt->error(), "\n" );
$tt_vars->{'Activator_Emailer_format'} = 'html';
$tt->process( $self->{email_wrap}, $tt_vars, \$html_body ) ||
Activator::Exception::Emailer->throw( 'tt_process_error', $tt->error(), "\n" );
my @email_args = (
From => $self->{From},
To => $self->{To},
Cc => $self->{Cc},
Subject => $self->{Subject},
SkipBad => 1,
);
push @email_args, ( Type => 'multipart/alternative' );
lib/Activator/Log.pm view on Meta::CPAN
Activator::Log->DEBUG( $msg );
Activator::Log->TRACE( $msg );
=head2 Using Alternate Loggers
You can set the default logger dynamically:
Activator::Log->default_logger( 'My.Default.Logger' );
Note that since C<Activator::Log> is a singleton, this sub will set
the level for the entire process. This is probably fine for cron jobs,
not so good for web processes.
You can avoid trouble by logging to an alternate Log4perl logger
without changing the default logger:
Activator::Log->DEBUG( $msg, 'My.Configured.Debug.Logger' );
=head2 Setting Log Level Dynamically
You can set the minimum level with the C<default_level> sub:
# only show only levels WARN, ERROR and FATAL
Activator::Log->default_level( 'WARN' );
# only show only levels ERROR and FATAL
Activator::Log->default_level( 'ERROR' );
Note that since C<Activator::Log> is a singleton, this sub will set
the level for the entire process. This is probably fine for cron jobs,
not so good for web processes.
=head2 Additional Functionality provided
The following Log::Log4perl subs you would normally call with
$logger->SUB are supported through a static call:
Activator::Log->logwarn( $msg );
Activator::Log->logdie( $msg );
Activator::Log->error_warn( $msg );
Activator::Log->error_die( $msg );
lib/Activator/Options.pm view on Meta::CPAN
use Activator::Log qw( :levels );
use Scalar::Util qw( reftype );
use Exception::Class::TryCatch;
use base 'Class::StrongSingleton';
=head1 NAME
THIS MODULE DEPRECATED. USE L<Activator::Config> instead.
C<Activator::Options> - process options for a script combining command
line, environment variables, and configuration files.
=head1 SYNOPSIS
use Activator::Options;
my $opts = Activator::Options->get_opts( \@ARGV); # default realm
my $opts = Activator::Options->get_opts( \@ARGV, $otherrealm);
#### Get a hashref of command line arguments, and an arrayref of barewords
lib/Activator/Options.pm view on Meta::CPAN
myscript.pl --foo=bar
Command line overrides only apply to keys that exist in a
configuration file and any unrecognized options are ignored. C<@ARGV>
is modified to remove recognized options, leaving barewords and
unrecognized options in the order they were specified. This module has
no support for argument validation, and your script must handle
unrecognizd options and behave appropriately. There are numerous
modules on CPAN that can help you do that (L<Getopt::Long> for
example). If you do use another options module, make sure you call
C<get_opts()> BEFORE you call their processor, so that @ARGV will be
in an appropriate state.
Also, while YAML configuration (and this module) support deep
structures for options, you can only override top level keys that are
scalars using command line arguments and/or environment variables.
=head2 Special Arguments
There are a few special command line arguments that do not require
YAML existence:
--skip_env : ignore environment variables
--project=<> : use this value for <project> in config file search path.
--project_home=<> : useful for when utilizing <project_home>/.<project> config dir
--realm=<> : use <realm>.yml in config file processing and consider all
command line arguments to be in this realm
TODO: these are not implemented yet
Also supported are these variables which can be listed as many times
as necessary:
--conf_file=<> : include <> file for inclusion
--conf_path=<> : include <> path when looking for config files
lib/Activator/Options.pm view on Meta::CPAN
},
other_realm => {
name => 'Ron Johnson from Ronson, Wisconson',
},
}
=head2 Variable Substitution
#### TODO: NOT YET IMPLEMENTED
Substitution occurs as the last step of processing. Every value for
every key (including values within lists ) are visited. Values for any
key can optionally contain a reference to another key by using C<${}>
notation. Use the indirect operator C<'-E<gt>'> to reference deeply nested
values. For example:
default:
key1: value1
key2: value2
realm1:
foo: bar
lib/Activator/Options.pm view on Meta::CPAN
Examples:
#### get options for default realm
my $opts = Activator::Options->get_opts( \@ARGV );
#### get options for 'some' realm
my $opts = Activator::Options->get_opts( \@ARGV, 'some' );
See L<get_args()> for a description of the way command line arguments
are processed.
=cut
sub get_opts {
my ( $pkg, $argv, $realm ) = @_;
my $self = &new( @_ );
my $argx = {};
# get_args sets $self->{ARGV}
$self->get_args( $argv );
lib/Activator/Options.pm view on Meta::CPAN
'default';
# setup or get the merged YAML configuration settings from files
# into the registry
my $opts = $self->{REGISTRY}->get_realm( $realm );
# first call
if ( !keys %$opts ) {
# define valid opts from config files
try eval {
$self->_process_config_for( $realm );
};
# _set_reg throws err if $realm is invalid
if ( catch my $e ) {
$e->rethrow;
}
# read environment variables, set any keys found
if ( !$skip_env ) {
my ( $env_key, $env_realm );
lib/Activator/Options.pm view on Meta::CPAN
elsif( $env_opt_realm ne $opt_realm &&
!grep( /$opt_key/, qw( skip_env project project_home
realm conf_file conf_path ) ) ) {
WARN( "Skipped invalid environment variable $env_key. Key '$opt_key' for realm '$opt_realm' unchanged");
}
}
}
# forced overrides from config files
my $overrides = $self->{REGISTRY}->get_realm( 'overrides' );
DEBUG( 'processing overrides: '.Dumper( $overrides ));
# NOTE: bad (typo) keys could be in overrides. Someday,
# Activator::Registry will allow debug mode so we can state
# show this.
if ( exists( $overrides->{ $realm } ) ) {
$self->{REGISTRY}->register_hash( 'right', $overrides->{ $realm }, $realm );
}
# now that realm is set, make sure our $opts points to it
$opts = $self->{REGISTRY}->get_realm( $realm );
lib/Activator/Options.pm view on Meta::CPAN
my ( $pkg, $argv_raw ) = @_;
my $self = &new( @_ );
# quick and dirty check for debug mode
if( grep /^--?debug$/, @$argv_raw ) {
Activator::Log->level('DEBUG');
DEBUG('Entering debug mode');
}
if ( defined( $self->{ARGV} ) || defined( $self->{BAREWORDS} ) ) {
DEBUG("skipping ARGV reprocessing");
return ( $self->{ARGV}, $self->{BAREWORDS} );
}
DEBUG("got ARGV: ". join(' ', @$argv_raw ));
# use refs to insure that that $self->{ARGV} and
# $self->{BAREWORDS} are defined, so we don't return undef.
my $argv = {};
my $barewords = [];
my $found_terminator = 0;
lib/Activator/Options.pm view on Meta::CPAN
# clean up value, if quoted
if ( defined $value ) {
$value =~ s/^"//;
$value =~ s/"$//;
}
return ( $key, $value );
}
# Merge config files into this objects Activator::Registry object
sub _process_config_for {
my ( $pkg, $realm ) = @_;
my $self = &new( @_ );
# figure out what project we are working on
my $project =
$self->{ARGV}->{project} ||
$ENV{ACT_OPT_project} ||
Activator::Exception::Options->throw( 'project', 'missing' );
# assemble a list of paths to look for config files
# TODO: look in all these places:
# --conf_path
# ACT_OPT_conf_path
# $ENV{ACT_OPT_project_home}/.<$ENV{ACT_OPT_project}>.d/
# $ENV{HOME}/.<$ENV{ACT_OPT_project}>.d/
# $ENV{HOME}/.activator.d/
# /etc/<$ENV{ACT_OPT_project}>.d/
# /etc/activator.d/
#
# assemble a list of files to process into the keys of $seach_paths
# TODO: assemble list of files for each of the above dirs
# --conf_file= : use $self->{ARGV}->{conf_file} (which could be an arrayref )
# ACT_OPT_conf_file= : comma separated list of files
# $ENV{USER}.yml
# <realm>.yml - realm specific settings and defaults
# <project>.yml - project specific settings and defaults
# org.yml - top level organization settings and defaults
# For now, just use ~/.activator.d/$project : key/value is path/'where
# found', 'where found' being one of: hardcoded, env, or arg
lib/Activator/Registry.pm view on Meta::CPAN
my $self = $pkg->new();
$self->{DEFAULT_REALM} = $realm;
}
=head2 replace_in_realm( $realm, $replacements )
Replace variables matching C<${}> notation with the values in
C<$replacements>. C<$realm> must be specified. Use C<'default'> for
the default realm. Keys that refer to other keys in the realm are
processed AFTER the passed in C<$replacements> are processed.
=cut
sub replace_in_realm {
my ($pkg, $realm, $replacements) = @_;
my $self = $pkg->new();
my $reg = $self->get_realm( $realm );
if ( !keys %$reg ) {
Activator::Exception::Registry->throw( 'realm', 'invalid', $realm );
share/apache2/conf/httpd.conf.tt view on Meta::CPAN
# In particular, see
# <URL:http://httpd.apache.org/docs/2.2/mod/directives.html>
# for a discussion of each configuration directive.
#
#
# Do NOT simply read the instructions in here without understanding
# what they do. They're here only as hints or reminders. If you are unsure
# consult the online docs. You have been warned.
#
# The configuration directives are grouped into three basic sections:
# 1. Directives that control the operation of the Apache server process as a
# whole (the 'global environment').
# 2. Directives that define the parameters of the 'main' or 'default' server,
# which responds to requests that aren't handled by a virtual host.
# These directives also provide default values for the settings
# of all virtual hosts.
# 3. Settings for virtual hosts, which allow Web requests to be sent to
# different IP addresses or hostnames and have them handled by the
# same Apache server process.
#
# Configuration and logfile names: If the filenames you specify for many
# of the server's control files begin with "/" (or "drive:/" for Win32), the
# server will use that explicit path. If the filenames do *not* begin
# with "/", the value of ServerRoot is prepended -- so "logs/foo.log"
# with ServerRoot set to "/etc/httpd" will be interpreted by the
# server as "/etc/httpd/logs/foo.log".
#
### Section 1: Global Environment
share/apache2/conf/httpd.conf.tt view on Meta::CPAN
# NOTE! If you intend to place this on an NFS (or otherwise network)
# mounted filesystem then please read the LockFile documentation
# (available at <URL:http://httpd.apache.org/docs/2.2/mod/mpm_common.html#lockfile>);
# you will save yourself a lot of trouble.
#
# Do NOT add a slash at the end of the directory path.
#
ServerRoot "[% apache2.ServerRoot %]"
#
# PidFile: The file in which the server should record its process
# identification number when it starts.
#
PidFile [% apache2.PidFile %]
#
# Timeout: The number of seconds before receives and sends time out.
#
Timeout 120
#
share/apache2/conf/httpd.conf.tt view on Meta::CPAN
# KeepAliveTimeout: Number of seconds to wait for the next request from the
# same client on the same connection.
#
KeepAliveTimeout 15
##
## Server-Pool Size Regulation (MPM specific)
##
# prefork MPM
# StartServers: number of server processes to start
# MinSpareServers: minimum number of server processes which are kept spare
# MaxSpareServers: maximum number of server processes which are kept spare
# ServerLimit: maximum value for MaxClients for the lifetime of the server
# MaxClients: maximum number of server processes allowed to start
# MaxRequestsPerChild: maximum number of requests a server process serves
<IfModule prefork.c>
StartServers 8
MinSpareServers 5
MaxSpareServers 20
ServerLimit 256
MaxClients 256
MaxRequestsPerChild 4000
</IfModule>
# worker MPM
# StartServers: initial number of server processes to start
# MaxClients: maximum number of simultaneous client connections
# MinSpareThreads: minimum number of worker threads which are kept spare
# MaxSpareThreads: maximum number of worker threads which are kept spare
# ThreadsPerChild: constant number of worker threads in each server process
# MaxRequestsPerChild: maximum number of requests a server process serves
<IfModule worker.c>
StartServers 2
MaxClients 150
MinSpareThreads 25
MaxSpareThreads 75
ThreadsPerChild 25
MaxRequestsPerChild 0
</IfModule>
#
share/apache2/conf/httpd.conf.tt view on Meta::CPAN
#AddHandler send-as-is asis
#
# For type maps (negotiated resources):
# (This is enabled by default to allow the Apache "It Worked" page
# to be distributed in multiple languages.)
#
AddHandler type-map var
#
# Filters allow you to process content before it is sent to the client.
#
# To parse .shtml files for server-side includes (SSI):
# (You will also need to add "Includes" to the "Options" directive.)
#
AddType text/html .shtml
AddOutputFilter INCLUDES .shtml
#
# Action lets you define media types that will execute a script whenever
# a matching file is called. This eliminates the need for repeated URL
# pathnames for oft-used CGI file processors.
# Format: Action media/type /cgi-script/location
# Format: Action handler-name /cgi-script/location
#
#
# Customizable error responses come in three flavors:
# 1) plain text 2) local redirects 3) external redirects
#
# Some examples:
#ErrorDocument 500 "The server made a boo boo."
share/conf/default-project.yml view on Meta::CPAN
# functionality, list them here.
sync_data_dirs :
- ${sync_target}/var/lib/${project_alias}
- ${sync_target}/var/tmp/${project_alias}
#
# Files listed here will be copied from ${conf_dir} to ${sync_conf_dir}. Additionally:
# - If the file looks like a YAML file (ends in .ya?ml), variable
# replacement is performed and the file is written as the same name.
# - If the file looks like a Template Toolkit file (ends in .tt), it
# is processed with your project config and written with .tt stripped off.
#
# It is OK to have deep dir paths relative to ${conf_dir}. They will be preserved.
#
# Note that most projects need at least these two files listed here:
# one to configure every catalyst thing that is not Activator aware
# (usually ${project_alias}-catalyst.yml), and one to have the multi-
# functional project registry (usually ${project_alias}-registry.yml).
#
# Note also that this is a great place for a log4perl.conf and your
# Activator::Dictionary files (but don't list dictionary files here,
( run in 0.385 second using v1.01-cache-2.11-cpan-8d75d55dd25 )