Result:
found more than 1028 distributions - search limited to the first 2001 files matching your query
( run in 1.237 )
Alvis-Pipeline
view release on metacpan or search on metacpan
lib/Alvis/Logger.pm view on Meta::CPAN
# Create a new logger object. Options that may be specified include:
# level [default 0]: only emit messages with priority less than
# or equal to this (so that the default behaviour is to
# be silent except for priority-zero messages, which are
# really error messages).
# stream [stderr]: where to write messages
#
sub new {
my $class = shift();
#warn("new($class): \@_ = ", join(", ", map { "'$_'" } @_), "\n");
my %options = ( level => 0, stream => \*STDERR, @_ );
Alvis-QueryFilter
view release on metacpan or search on metacpan
bin/run_QF.pl view on Meta::CPAN
B<--testquery> Transform queries and return response without forwarding query to a real SRU server.
B<--verbose> Some additional trace data provided.
This is a simple SRU query filter built using HTTP::Daemon. All configuration data is read from the ALVIS configuration file at <AlvisDir>/alvis.cnf. Error messages and a simple URL trail go to stderr. The linguistic resources used by
Alvis::Query filter are located in <AlvisDir>/resources.
It is intended to be copied and modified for any application.
=head1 CONFIGURATION
Amazon-Dash-Button
view release on metacpan or search on metacpan
t/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { require blib; blib->VERSION('1.01') };
Amazon-MWS
view release on metacpan or search on metacpan
lib/Amazon/MWS/Uploader.pm view on Meta::CPAN
{ success => 1 },
{
feed_id => $feed_id,
shop_id => $self->_unique_shop_id,
}));
# if we have a success, print the warnings on the stderr.
# if we have a failure, the warnings will just confuse us.
if ($type eq 'order_ack') {
# flip the confirmation bit
$self->_exe_query($self->sqla->update(amazon_mws_orders => { confirmed => 1 },
Amazon-S3-Thin
view release on metacpan or search on metacpan
lib/Amazon/S3/Thin.pm view on Meta::CPAN
=item * C<signature_version> - AWS signature version to use. Supported values
are 2 and 4. Default is 4.
=item * C<debug> - debug option. Default is 0 (false).
If set 1, contents of HTTP request and response are shown on stderr
=item * C<virtual_host> - whether to use virtual-hosted style request format. Default is 0 (path-style).
=back
Amazon-S3
view release on metacpan or search on metacpan
t/02-logger.t view on Meta::CPAN
sub test_all_levels {
########################################################################
my ($s3) = @_;
$s3->level('trace');
stderr_like( sub { test_levels($s3); },
qr/trace\n.*debug\n.*info\n.*warn\n.*error\n.*fatal\n/xsm, 'trace' );
$s3->level('debug');
stderr_like( sub { test_levels($s3); },
qr/debug\n.*info\n.*warn\n.*error\n.*fatal\n/xsm, 'debug' );
stderr_unlike( sub { test_levels($s3); },
qr/trace/, 'debug - not like trace' );
$s3->level('info');
stderr_like( sub { test_levels($s3); },
qr/info\n.*warn\n.*error\n.*fatal\n/xsm, 'info' );
stderr_unlike( sub { test_levels($s3); },
qr/trace|debug/, 'info - not like trace, debug' );
$s3->level('warn');
stderr_like( sub { test_levels($s3); },
qr/warn\n.*error\n.*fatal\n/xsm, 'warn' );
stderr_unlike( sub { test_levels($s3); },
qr/trace|debug|info/, 'warn - not like trace, debug, info' );
$s3->level('error');
stderr_like( sub { test_levels($s3); }, qr/error\n.*fatal\n/xsm, 'error' );
stderr_unlike( sub { test_levels($s3); },
qr/trace|debug|info|warn/, 'error - not like trace, debug, info, warn' );
$s3->level('fatal');
stderr_like( sub { test_levels($s3); }, qr/fatal\n/xsm, 'fatal' );
stderr_unlike(
sub { test_levels($s3); },
qr/trace|debug|info|warn|error/,
'fatal - not like trace, debug, info, warn, error'
);
Amazon-SQS-Client
view release on metacpan or search on metacpan
bin/QueueDaemon.pl view on Meta::CPAN
END_OF_LOGGER
Readonly::Scalar our $SCREEN_CONFIG => <<'END_OF_LOGGER';
log4perl.rootLogger=INFO, SCREEN
log4perl.appender.SCREEN=Log::Log4perl::Appender::Screen
log4perl.appender.SCREEN.stderr=%s
log4perl.appender.SCREEN.layout=PatternLayout
log4perl.appender.SCREEN.layout.ConversionPattern=%%d (%%r,%%R) (%%p/%%c) [%%P] [%%M:%%L] - %%m%%n
END_OF_LOGGER
our $KEEP_GOING = $TRUE;
bin/QueueDaemon.pl view on Meta::CPAN
my $service = $handler->get_service;
if ( $options{daemonize} ) {
my @dont_close_fh;
if ( $options{logfile} && $options{logfile} !~ /(?:stderr|stdout)/ixsm ) {
my $appender = Log::Log4perl->appender_by_name($APPENDER_NAME);
push @dont_close_fh, $appender->{fh};
}
push @dont_close_fh, 'STDERR';
bin/QueueDaemon.pl view on Meta::CPAN
warn => $WARN,
}->{ lc $loglevel };
$loglevel //= $INFO;
$logfile //= 'stderr';
my $log4perl_config;
if ( !$logfile || $logfile =~ /(?:stderr|stdout)/xsmi ) {
$log4perl_config = sprintf $SCREEN_CONFIG, $logfile eq 'stdout' ? 0 : 1;
$options->{logfile} = lc $logfile;
}
else {
$log4perl_config = sprintf $log4perl_config, $logfile;
bin/QueueDaemon.pl view on Meta::CPAN
my $config = Amazon::SQS::Config->new( file => $options->{config} );
$options->{loglevel} //= $config->get_log_level;
$options->{logfile} //= $config->get_log_file;
$options->{logfile} //= 'stderr';
$options->{'delete-when'} //= $config->get_error_delete;
$options->{'exit-when'} //= $config->get_error_exit;
Amon2-Plugin-LogDispatch
view release on metacpan or search on metacpan
lib/Amon2/Plugin/LogDispatch.pm view on Meta::CPAN
'Log::Dispatch' => {
outputs => [
[Screen::Color',
min_level => 'debug',
name => 'debug',
stderr => 1,
color => {
debug => {
text => 'green',
}
}
Amp-Client
view release on metacpan or search on metacpan
script/dash view on Meta::CPAN
"parents" => [],
"priority" => 0,
"queue" => "low",
"result" => {
"status" => "Completed successfully",
"stderr" => "",
"stdout" => "x is 1.\nGoodbye, World!\n"
},
"retried" => undef,
"retries" => 0,
"started" => "2021-05-03T14:45:33.66996Z",
Analizo
view release on metacpan or search on metacpan
t/features/step_definitions/analizo_steps.pl view on Meta::CPAN
use DBI;
use File::Spec;
our $exit_status;
our $stdout;
our $stderr;
use Env qw(@PATH $PWD);
push @PATH, "$PWD/blib/script", "$PWD/bin";
use IPC::Open3;
t/features/step_definitions/analizo_steps.pl view on Meta::CPAN
my $pid = open3($IN, $STDOUT, $STDERR, "$command 2>tmp.err");
waitpid $pid, 0;
$exit_status = $?;
local $/ = undef;
$stdout = <$STDOUT>;
$stderr = <$STDERR> . read_file('tmp.err');
};
When qr/^I run "([^\"]*)" on database "([^\"]*)"$/, sub {
my ($c) = @_;
my $statement = $1;
t/features/step_definitions/analizo_steps.pl view on Meta::CPAN
chdir $1;
};
Then qr/^analizo must emit a warning matching "([^\"]*)"$/, sub {
my ($c) = @_;
like($stderr, qr/$1|\Q$1\E/);
};
Then qr/^analizo must not emit a warning matching "([^\"]*)"$/, sub {
my ($c) = @_;
unlike($stderr, qr/$1|\Q$1\E/);
};
Then qr/^analizo must report that "([^\"]*)" is part of "([^\"]*)"$/, sub {
my ($c) = @_;
my ($func, $mod) = ($1, $2);
Anarres-Mud-Driver
view release on metacpan or search on metacpan
Compiler/lexer.c view on Meta::CPAN
#else
static void amd_yy_fatal_error( msg )
char msg[];
#endif
{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
Compiler/lexer.c view on Meta::CPAN
void
amd_yywarnv(const char *fmt, va_list args)
{
char msg[BUFSIZ];
vsnprintf(msg, BUFSIZ, fmt, args);
fprintf(stderr, "%s", msg);
}
void
amd_yywarnf(const char *fmt, ...)
{
Compiler/lexer.c view on Meta::CPAN
SV **svp;
SV *sv;
SV **lvp;
#if 0
fprintf(stderr, "amd_yyidentifier: %s\n", amd_yytext);
fflush(stderr);
#endif
svp = hv_fetch(amd_kwtab, amd_yytext, amd_yyleng, FALSE);
if (svp) {
lvalp->number = 0;
Compiler/lexer.c view on Meta::CPAN
amd_yylex_verbose(AMD_YYSTYPE *amd_yylval, amd_parse_param_t *param)
{
int tok;
tok = amd_yylex(amd_yylval, param);
fprintf(stderr, "L: %d (%s) [%s]\n", tok, amd_yytokname(tok), amd_yytext);
return tok;
}
int
Android-ElectricSheep-Automator
view release on metacpan or search on metacpan
lib/Android/ElectricSheep/Automator.pm view on Meta::CPAN
}
@cmd = ('input', 'touchscreen', 'swipe', $x1, $y1, $x2, $y2, $dt);
}
# unfortunately Android::ADB uses IPC::Open2::open2() to run the adb shell command
# which does not capture STDERR, and so either they use open3 or we capture stderr thusly:
if( $verbosity > 0 ){ $log->info("${whoami} (via $parent), line ".__LINE__." : sending command to adb: @cmd") }
my $res = $self->adb->shell(@cmd);
if( ! defined $res ){ $log->error(join(" ", @cmd)."\n${whoami} (via $parent), line ".__LINE__." : error, above shell command has failed, got undefined result, most likely shell command did not run at all, this should not be happening."); return unde...
if( $res->[0] != 0 ){ $log->error(join(" ", @cmd)."\n${whoami} (via $parent), line ".__LINE__." : error, above shell command has failed, with:\nSTDOUT:\n".$res->[1]."\n\nSTDERR:\n".$res->[2]."\nEND."); return undef }
Android-Releases
view release on metacpan or search on metacpan
t/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { require blib; blib->VERSION('1.01') };
Anego
view release on metacpan or search on metacpan
spew($config_file, $config);
subtest 'status subcommand' => sub {
$Anego::Config::CONFIG = undef;
my ($stdout, $stderr) = capture {
Anego::CLI::Status->run();
};
like $stdout, qr!RDBMS:\s+SQLite!;
like $stdout, qr!Database:\s+:memory:!;
subtest 'diff / migrate subcommand (latest)' => sub {
$Anego::Config::CONFIG = undef;
subtest 'diff (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run();
};
is $stdout, <<__DDL__;
COMMIT;
__DDL__
is $stderr, '';
};
subtest 'migrate (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run();
};
is $stdout, "Migrated\n";
is $stderr, '';
};
subtest 'diff (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run();
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
subtest 'migrate (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run();
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
};
subtest 'diff / migrate subcommand (revision)' => sub {
$Anego::Config::CONFIG = undef;
subtest 'diff (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run(qw/ revision HEAD^ /);
};
is $stdout, <<__DDL__;
COMMIT;
__DDL__
is $stderr, '';
};
subtest 'migrate (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run(qw/ revision HEAD^ /);
};
is $stdout, "Migrated\n";
is $stderr, '';
};
subtest 'diff (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run(qw/ revision HEAD^ /);
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
subtest 'migrate (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run(qw/ revision HEAD^ /);
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
};
sub spew {
my ($path, $content) = @_;
Anki-Import
view release on metacpan or search on metacpan
plan tests => $tests;
my $cmd = File::Spec->catfile('bin', 'anki_import');
$cmd =~ s/\\/\\\\/;
stderr_like { `$^X $cmd` } qr/usage: anki_import FILE/, 'dies without file';
$cmd = File::Spec->catfile('bin', 'anki_import');
$cmd =~ s/\\/\\\\/;
stderr_like { `$^X $cmd blasdfah` } qr/[FATAL].*does not exist/, 'dies with bad file';
$cmd = File::Spec->catfile('bin', 'anki_import');
$cmd =~ s/\\/\\\\/;
my $path = File::Spec->catfile('t', 'data' , 'source.anki');
lives_ok { `$^X $cmd $path` } 'can process good file';
Ansible-Util
view release on metacpan or search on metacpan
lib/Ansible/Util/Run.pm view on Meta::CPAN
version 0.001
=head1 SYNOPSIS
$run = Ansible::Util::Run->new;
( $stdout, $stderr, $exit ) = $run->ansiblePlaybook(playbook => $playbook);
$run = Ansible::Util::Run->new(
vaultPasswordFiles => ['secret1', 'secret2']
);
( $stdout, $stderr, $exit ) = $run->ansiblePlaybook(playbook => $playbook);
=head1 DESCRIPTION
A thin wrapper around the Ansible CLI tools.
lib/Ansible/Util/Run.pm view on Meta::CPAN
Invokes the ansible-playbook command with the specified args.
=head3 usage:
($stdout, $stderr, $exit) =
$run->ansiblePlaybook(playbook => $file,
[extraArgs => $aref],
[confessOnError => $bool],
[wantArrayRefs => $bool]);
=head3 returns:
An array containing the stdout, stderr, and exit status from the
ansible-playbook command.
=head3 args:
=over
lib/Ansible/Util/Run.pm view on Meta::CPAN
=over
=item confessOnError
If the command exits with an error, the call will simply confess with the
output from stderr.
=over
=item type: Bool
lib/Ansible/Util/Run.pm view on Meta::CPAN
=over
=item wantArrayRefs
The stdout and stderr are returned as array refs split across newlines.
=over
=item type: Bool
lib/Ansible/Util/Run.pm view on Meta::CPAN
push @cmd, @$extraArgs if $extraArgs;
push @cmd, $playbook if $playbook;
$self->Spawn->confessOnError($confessOnError);
my ( $stdout, $stderr, $exit ) =
$self->Spawn->capture( cmd => \@cmd, wantArrayRefs => $wantArrayRefs);
return ( $stdout, $stderr, $exit );
}
##############################################################################
# PRIVATE METHODS
##############################################################################
AntTweakBar
view release on metacpan or search on metacpan
src/ppport.h view on Meta::CPAN
PerlIO_read||5.007003|
PerlIO_seek||5.007003|
PerlIO_set_cnt||5.007003|
PerlIO_set_ptrcnt||5.007003|
PerlIO_setlinebuf||5.007003|
PerlIO_stderr||5.007003|
PerlIO_stdin||5.007003|
PerlIO_stdout||5.007003|
PerlIO_tell||5.007003|
PerlIO_unread||5.007003|
PerlIO_write||5.007003|
src/ppport.h view on Meta::CPAN
whichsig_sv||5.015004|
whichsig|||
win32_croak_not_implemented|||n
with_queued_errors|||
wrap_op_checker||5.015008|
write_to_stderr|||
xmldump_all_perl|||
xmldump_all|||
xmldump_attr|||
xmldump_eval|||
xmldump_form|||
Any-Daemon-HTTP
view release on metacpan or search on metacpan
lib/Any/Daemon/FCGI/ClientConn.pm view on Meta::CPAN
$request;
}
sub send_response($;$)
{ my ($self, $response, $stderr) = @_;
#XXX Net::Async::FastCGI::Request demonstrates how to catch stdout and
#XXX stderr via ties. We don't use that here: cleanly work with
#XXX HTTP::Message objects... errors are logged locally.
my $req_id = $response->request->request_id;
# Simply "Status: " in front of the Response header will make the whole
# message HTTP::Response into a valid CGI response.
$self->_reply_record(STDOUT => $req_id
, 'Status: '.$response->as_string(CRLF));
$self->_reply_record(STDOUT => $req_id, '');
if($stderr && length $$stderr)
{ $self->_reply_record(STDERR => $req_id, $$stderr);
$self->_reply_record(STDERR => $req_id, '');
}
$self->_fcgi_end_request(REQUEST_COMPLETE => $req_id);
Any-Moose
view release on metacpan or search on metacpan
xt/author/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { require blib; blib->VERSION('1.01') };
AnyEvent-APNS
view release on metacpan or search on metacpan
inc/Test/Base/Filter.pm view on Meta::CPAN
untie *STDOUT;
untie *STDERR;
return $return, $@, $out, $err;
}
sub eval_stderr {
$self->assert_scalar(@_);
my $output = '';
Test::Base::tie_output(*STDERR, $output);
CORE::eval(shift);
no warnings;
AnyEvent-Atom-Stream
view release on metacpan or search on metacpan
inc/Test/Base/Filter.pm view on Meta::CPAN
untie *STDOUT;
untie *STDERR;
return $return, $@, $out, $err;
}
sub eval_stderr {
$self->assert_scalar(@_);
my $output = '';
Test::Base::tie_output(*STDERR, $output);
CORE::eval(shift);
no warnings;
AnyEvent-Beanstalk-Worker
view release on metacpan or search on metacpan
my $cv = AnyEvent->condvar(
cb => sub {
my ($results, $res_out, $res_err) = $_[0]->recv;
say "success or fail: " . Dumper($results);
say "script stdout: " . Dumper($res_out);
say "script stderr: " . Dumper($res_err);
$self->finish( delete => $qjob->id );
}
);
my %results = ();
my %stdout = ();
my %stderr = ();
$cv->begin( sub { $_[0]->send( \%results, \%stdout, \%stderr ) } );
run_scripts( $cv, $job->{target}, $job->{scripts}, \%results, \%stdout, \%stderr );
$cv->end;
}
);
$w->start;
my $target = shift;
my $scripts = shift;
my $results = shift;
my $stdout = shift;
my $stderr = shift;
my $ipc = AnyEvent::Open3::Simple->new(
on_start => sub {
my $proc = shift;
AE::log trace => "pid: " . $proc->pid;
my $line = shift;
AE::log trace => $proc->pid . " stdout: " . $line;
$stdout->{$proc->pid} .= $line . "\n";
},
on_stderr => sub {
my $proc = shift;
my $line = shift;
AE::log trace => $proc->pid . " stderr: " . $line;
$stderr->{$proc->pid} .= $line . "\n";
},
on_exit => sub {
my $proc = shift;
my $exval = shift;
AnyEvent-DBI-Abstract-Limit
view release on metacpan or search on metacpan
inc/Test/Base/Filter.pm view on Meta::CPAN
untie *STDOUT;
untie *STDERR;
return $return, $@, $out, $err;
}
sub eval_stderr {
$self->assert_scalar(@_);
my $output = '';
Test::Base::tie_output(*STDERR, $output);
CORE::eval(shift);
no warnings;
AnyEvent-DBI-MySQL
view release on metacpan or search on metacpan
t/superfluous_warning.t view on Meta::CPAN
my $h = Test::Database->handle('mysql') or plan skip_all => '~/.test-database not configured';
local *STDERR;
open STDERR, '>', \my $stderr or die $!;
# failed connect (because of wrong port 3307) will add undefined $dbh into {CachedKids}
AnyEvent::DBI::MySQL->connect($h->dsn.';port=3307', $h->username, $h->password,
{RaiseError=>0,PrintError=>0});
# passed connect shouldn't print warnings because of undefined $dbh in {CachedKids}
AnyEvent::DBI::MySQL->connect($h->connection_info,
{RaiseError=>0,PrintError=>0});
# work around warning in EV because ./Build test run `perl -w`
my $cleaned_stderr = join "\n", grep {!/Too late to run CHECK block/} split "\n", $stderr || q{};
is $cleaned_stderr, q{}, 'no warnings';
done_testing();
AnyEvent-DBI
view release on metacpan or search on metacpan
t/02_sql_lite.t view on Meta::CPAN
use warnings;
use AnyEvent;
use AnyEvent::DBI;
use File::Temp qw(tempfile);
# we are going to watch what the sub-processes send to stderr
close STDERR;
my($tfh_err,$tfn_err) = tempfile;
close $tfh_err;
open(STDERR,">>$tfn_err");
t/02_sql_lite.t view on Meta::CPAN
# lets have an error
$cv = AnyEvent->condvar;
$dbh->exec('select bogus_column from no_such_table',sub {return $cv->send($@) unless $_[1];$cv->send(undef,$_[1])});
($error,$result) = $cv->recv();
like ($error,qr{no such table}i,'Select from non existant table results in error');
# ensure we got no stderr output
ok(-z $tfn_err,'Error does not result in output on STDERR');
# check the error behavior
$cv = AnyEvent->condvar;
$dbh->attr('PrintError',sub {return $cv->send($@) unless $_[1]; $cv->send(undef,$_[1])});
AnyEvent-Digest
view release on metacpan or search on metacpan
t/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
open my $stdin, '<', File::Spec->devnull or die "can't open devnull: $!";
my $stderr = IO::Handle->new;
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, '-Mblib', '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($? >> 8, 0, "$lib loaded ok");
if (@_warnings)
{
AnyEvent-FCGI
view release on metacpan or search on metacpan
lib/AnyEvent/FCGI/Request.pm view on Meta::CPAN
stdin_done => 0,
params => {},
params_string => '',
params_done => 0,
used_stderr => 0,
}, $class;
weaken($self->{fcgi});
weaken($self->{connection});
lib/AnyEvent/FCGI/Request.pm view on Meta::CPAN
my ($self, $data) = @_;
$self->_print_stream($data, AnyEvent::FCGI->FCGI_STDOUT);
}
=head2 print_stderr($data)
This method appends the given data to the STDERR stream of the FastCGI
request, sending it to the webserver.
=cut
sub print_stderr {
my ($self, $data) = @_;
$self->{used_stderr} = 1;
$self->_print_stream($data, AnyEvent::FCGI->FCGI_STDERR);
}
=head2 finish
lib/AnyEvent/FCGI/Request.pm view on Meta::CPAN
$self->_send_record({
request_id => $self->{id},
type => AnyEvent::FCGI->FCGI_STDERR,
content => '',
}) if $self->{used_stderr};
$self->_send_record({
request_id => $self->{id},
type => AnyEvent::FCGI->FCGI_END_REQUEST,
content => pack('Ncccc', 0, AnyEvent::FCGI->FCGI_REQUEST_COMPLETE, 0, 0, 0),
AnyEvent-FDpasser
view release on metacpan or search on metacpan
lib/AnyEvent/FDpasser.pm view on Meta::CPAN
=head1 SEE ALSO
L<The AnyEvent::FDpasser github repo|https://github.com/hoytech/AnyEvent-FDpasser>
This module gets its name from L<File::FDpasser> which does roughly the same thing as this module except this module provides a non-blocking interface, buffers the sending and receiving of descriptors, doesn't lose descriptors in the event of a full ...
L<Socket::PassAccessRights> is another module similar to File::FDpasser. It supports BSD4.3 and BSD4.4 interfaces.
L<Sprocket::Util::FDpasser> is an example of a non-blocking interface to File::FDpasser. It is based on L<POE> whereas this module is (obviously) based on AnyEvent.
AnyEvent-FTP
view release on metacpan or search on metacpan
- NcFTPd
- syst
- SYST
- ALLO
- standalone
- stderr
- auth
- cred
- inet
- pam
- readonly
AnyEvent
view release on metacpan or search on metacpan
lib/AnyEvent.pm view on Meta::CPAN
certain features.
=item C<PERL_ANYEVENT_LOG>
Accepts rather complex logging specifications. For example, you could log
all C<debug> messages of some module to stderr, warnings and above to
stderr, and errors and above to syslog, with:
PERL_ANYEVENT_LOG=Some::Module=debug,+log:filter=warn,+%syslog:%syslog=error,syslog
For the rather extensive details, see L<AnyEvent::Log>.
( run in 1.237 second using v1.01-cache-2.11-cpan-1fa8183d00c )