view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
lib/AnyEvent/CouchDB.pm view on Meta::CPAN
what you should do is call C<cb> on the condvar, and give it a coderef to
execute when the results come back. The coderef will be given a condvar
as a parameter, and it can call C<recv> on it to get the data. The final
example in the SYNOPSIS gives a brief example of this.
Also note that C<recv> will throw an exception if the request fails, so be
prepared to catch exceptions where appropriate.
Please read the L<AnyEvent> documentation for more information on the proper
use of condvars.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
L<DBD::mysql/"ASYNCHRONOUS QUERIES"> feature. Unlike L<AnyEvent::DBI> it
doesn't spawn any processes.
You shouldn't use C<< {RaiseError=>1} >> with this module and should check
returned values in your callback to detect errors. This is because with
C<< {RaiseError=>1} >> exception will be thrown B<instead> of calling your
callback function, which isn't what you want in most cases.
=head1 INTERFACE
view release on metacpan or search on metacpan
lib/AnyEvent/DateTime/Cron.pm view on Meta::CPAN
my $cv = shift;
$cv->begin;
do_something_asynchronous( cb => sub { $cv->end })
}
Callbacks are called inside an C<eval> so if they throw an error, they
will warn, but won't cause the cron loop to exit.
=head1 AUTHORS
=over 4
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
t/04-prereqfail.t view on Meta::CPAN
# eval { use/no Test::Without::Module qw(...); };
# However, use is detected by build_prereq_matches_use,
# so eval guard is used.
eval { use Test::Without::Module qw(AnyEvent::AIO); };
throws_ok { $our = AnyEvent::Digest->new('Digest::MD5', backend => 'aio') }
qr/^AnyEvent::Digest: `aio' backend requires `IO::AIO' and `AnyEvent::AIO'/, 'without AnyEvent::AIO';
eval { no Test::Without::Module qw(AnyEvent::AIO); };
eval { use Test::Without::Module qw(IO::AIO); };
throws_ok { $our = AnyEvent::Digest->new('Digest::MD5', backend => 'aio') }
qr/^AnyEvent::Digest: `aio' backend requires `IO::AIO' and `AnyEvent::AIO'/, 'without IO::AIO';
view release on metacpan or search on metacpan
t/client/basic.t view on Meta::CPAN
die;
};
ok(
exception { AnyEvent::eris::Client->new() },
'Exception thrown',
);
};
subtest 'New with non-code MessageHandler' => sub {
no strict 'refs';
t/client/basic.t view on Meta::CPAN
exception {
AnyEvent::eris::Client->new(
MessageHandler => 1,
);
},
'Exception thrown',
);
};
subtest 'New with code MessageHandler' => sub {
my $client;
view release on metacpan or search on metacpan
same node, the paths are generally identical.
C<$want_read> and C<$want_write> should be set to a true value when you
want to read (get) files or write (put) files, respectively.
On error, an exception is thrown. Otherwise, C<$can_read> and
C<$can_write> indicate whether you can reaqd or write to freenet via the
directory.
=cut
view release on metacpan or search on metacpan
t/anyevent_ftp_client.t view on Meta::CPAN
isa_ok $client->mkd($dirname)->recv, 'AnyEvent::FTP::Response';
isa_ok $client->cwd($dirname)->recv, 'AnyEvent::FTP::Response';
SKIP: {
skip 'wu-ftpd throws an exception on empty directory', 2 if $detect->{wu};
my $res = $client->nlst->recv;
is $res, array { etc() };
is scalar(@$res), 0, 'list empty';
if(scalar(@$res) > 0)
{
view release on metacpan or search on metacpan
t/11-plugin-default.t view on Meta::CPAN
skip 'Test for Mac/Linux/BSD only', 1
unless $^O eq 'linux'
or $^O eq 'darwin'
or $^O =~ /bsd/;
throws_ok {
AnyEvent::Filesys::Notify->new( dirs => ['t'], cb => sub { } );
}
qr/You may want to install/, 'fails ok';
}
view release on metacpan or search on metacpan
lib/AnyEvent/Filesys/Watcher.pod view on Meta::CPAN
=over 4
=item B<new(OPTIONS)>
Creates a new B<AnyEvent::Filesys::Watcher>. The constructor may throw an
exception in case of an error!
In fact, it createss an instance of one of the subclasses
L<AnyEvent::Filesys::Watcher::Fallback> (all platforms),
L<AnyEvent::Filesys::Watcher::FSEvents> (macOS),
view release on metacpan or search on metacpan
)
=item C<$AnyEvent::Fork::RPC::STORABLE_SERIALISER> - L<Storable>
This serialiser uses L<Storable>, which means it has high chance of
serialising just about anything you throw at it, at the cost of having
very high overhead per operation. It also comes with perl. It should be
used when you need to serialise complex data structures.
Implementation:
eval {
...
};
if ($@) {
AnyEvent::RPC::event (throw => "$@");
AnyEvent::RPC::flush ();
exit;
}
...
view release on metacpan or search on metacpan
xt/podspell.t view on Meta::CPAN
rebased
rebasing
reblesses
refactored
refactoring
rethrows
RT
runtime
serializer
stacktrace
subclassable
view release on metacpan or search on metacpan
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
=over
=item B<die>
The method has thrown exception. The next argument contains B<$@>.
=item B<fatal>
A fatal error was occured (for example fork jail was killed).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
lib/AnyEvent/Future.pm view on Meta::CPAN
my @results = $cv->recv;
In this case, the moment any of the HTTP GET functions fails, the ones that
are still pending are all cancelled (by dropping their cancellation watcher
object) and the overall C<recv> call throws an exception.
Of course, there is no need to convert the outermost C<Future> into a
C<CondVar>; the full set of waiting semantics are implemented on these
instances, so instead you may simply call C<get> on it to achieve the same
effect:
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
my $log = $log[0];
is($log->id, (split /\s/, $rev_list[0])[0], 'id');
is($log->message, "FIRST\n\n\tBODY\n", "message");
throws_ok { $git->log( "--format=%H" ) } q{Git::Wrapper::Exception};
SKIP: {
skip 'testing old git without raw date support' , 1
unless $git->supports_log_raw_dates;
{
if ( versioncmp( $git->version , '1.6.3') eq -1 ) {
skip 'testing old git without log --oneline support' , 3;
}
throws_ok { $git->log('--oneline') } qr/^unhandled/ , 'log(--oneline) dies';
my @lines;
lives_ok { @lines = $git->RUN('log' , '--oneline' ) } 'RUN(log --oneline) lives';
is( @lines , 1 , 'one log entry' );
}
view release on metacpan or search on metacpan
lib/AnyEvent/GnuPG.pm view on Meta::CPAN
Asynchronous variant of L</decrypt>.
=head1 API OVERVIEW
The API is accessed through methods on a AnyEvent::GnuPG object which is a wrapper around the B<gpg> program. All methods takes their argument using named parameters, and errors are returned by throwing an exception (using croak). If you wan't to cat...
This modules uses L<AnyEvent::Proc>. For input data, all of L<AnyEvent::Proc/pull> and for output data, all of L<AnyEvent::Proc/pipe> possible handle types are allowed.
The code is based on L<GnuPG> with API compatibility except that L<GnuPG::Tie> is B<not> ported.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# If the modification time is only slightly in the future,
# sleep briefly to remove the problem.
my $a = $s - time;
if ( $a > 0 and $a < 5 ) { sleep 5 }
# Too far in the future, throw an error.
my $t = time;
if ( $s > $t ) { die <<"END_DIE" }
Your installer $0 has a modification time in the future ($s > $t).
view release on metacpan or search on metacpan
t/response.t view on Meta::CPAN
my $msg = new_ok('HTTP::Response', [200, 'Fine', [
X_Dog => 'Fluffy',
X_Dog => 'Fido',
], "bark!"]);
# don't throw warnings if protocol was undefined
{
my @w;
local $SIG{__WARN__} = sub { push @w, [@_] };
is new_ok($mod, [$msg])->pseudo_headers->{HTTPVersion}, undef,
'cannot set HTTPVersion without a protocol';
view release on metacpan or search on metacpan
lib/AnyEvent/HTTPD/ExtDirect.pm view on Meta::CPAN
my $router = $router_class->new(
config => $config,
api => $api,
);
# No need for eval here, Router won't throw exceptions
my $result = $router->route($router_input, $env);
# Router result is Plack-compatible arrayref; there's not much
# difference in what AnyEvent::HTTPD expects so we just convert it
# in place
view release on metacpan or search on metacpan
t/05_reg_routes_syntax.t view on Meta::CPAN
}
my $httpd = AnyEvent::HTTPD::Router->new();
throws_ok {
$httpd->reg_routes(
GET => '/some/url' => sub { },
POST => '/some/thing/else' => sub { },
'something that is wrong',
);
} qr/confusing/, 'wrong number of parameters';
throws_ok {
$httpd->reg_routes;
} qr/required/, 'reg_routes without parameter';
throws_ok {
$httpd->reg_routes( undef, '/url', sub {} );
} qr/verbs or methods/, 'undefined method';
throws_ok {
$httpd->reg_routes( 'strange method', '/url', sub {} );
} qr/verbs or methods/, 'unknown method';
throws_ok {
$httpd->reg_routes( GET => undef, sub {} );
} qr/path/, 'undefined path';
throws_ok {
$httpd->reg_routes( GET => '/url', undef );
} qr/callback/, 'undefined callback';
throws_ok {
$httpd->reg_routes( GET => 'path syntax', sub {} );
} qr/path syntax/, 'invalid path syntax';
$httpd = AnyEvent::HTTPD::Router->new(known_methods => ['GET']);
throws_ok {
$httpd->reg_routes(POST => '/foo' => sub { });
} qr/verbs or methods/, 'POST is no longer a known http method';
$httpd = AnyEvent::HTTPD::Router->new(known_methods => ['GET', 'COPY']);
lives_ok {