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

 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'
  );

 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;

 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',
                    }
                }

 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",

 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);

 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

 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 }

 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') };

 view release on metacpan or  search on metacpan

t/basic.t  view on Meta::CPAN

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:!;

t/basic.t  view on Meta::CPAN

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__;

t/basic.t  view on Meta::CPAN

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__;

t/basic.t  view on Meta::CPAN

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) = @_;

 view release on metacpan or  search on metacpan

t/02-cli.t  view on Meta::CPAN

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';

 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
##############################################################################

 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|||

 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);

 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') };

 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;

 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;

 view release on metacpan or  search on metacpan

eg/ssh.pl  view on Meta::CPAN

        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;

eg/ssh.pl  view on Meta::CPAN

    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;

eg/ssh.pl  view on Meta::CPAN

            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;

 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;

 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();

 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])});

 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)
    {

 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),

 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.

 view release on metacpan or  search on metacpan

author.yml  view on Meta::CPAN

    - NcFTPd
    - syst
    - SYST
    - ALLO
    - standalone
    - stderr
    - auth
    - cred
    - inet
    - pam
    - readonly

 view release on metacpan or  search on metacpan

xt/author/pod_spelling_system.t  view on Meta::CPAN

add_stopwords($config->{pod_spelling_system}->{stopwords}->@*);
add_stopwords(qw(
Plicease
stdout
stderr
stdin
subref
loopback
username
os

 view release on metacpan or  search on metacpan

Fork.pm  view on Meta::CPAN

        ')
      ->send_fh ($output)
      ->send_arg ("/bin/echo", "hi")
      ->run ("run", my $cv = AE::cv);

   my $stderr = $cv->recv;

=head2 For stingy users: put the worker code into a C<DATA> section.

When you want to be stingy with files, you can put your code into the
C<DATA> section of your module (or program):

Fork.pm  view on Meta::CPAN

(for example, the C<require> method uses it). It's not supposed to be used
to completely take over the process, use C<run> for that.

The code will usually be executed after this call returns, and there is no
way to pass anything back to the calling process. Any evaluation errors
will be reported to stderr and cause the process to exit.

If you want to execute some code (that isn't in a module) to take over the
process, you should compile a function via C<eval> first, and then call
it via C<run>. This also gives you access to any arguments passed via the
C<send_xxx> methods, such as file handles. See the L<use AnyEvent::Fork as

 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;

 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;

 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>.