view release on metacpan or search on metacpan
lib/AsposeWordsCloud/ApiClient.pm view on Meta::CPAN
# @param integer $seconds Number of seconds before timing out [set to 0 for no timeout]
#
sub set_timeout {
my ($self, $seconds) = @_;
if (!looks_like_number($seconds)) {
croak('Timeout variable must be numeric.');
}
$self->{http_timeout} = $seconds;
}
# make the HTTP request
view release on metacpan or search on metacpan
examples/cmd_server.pl view on Meta::CPAN
#Connect to asterisk
my $astman = Asterisk::AMI->new(PeerAddr => '127.0.0.1',
Username => 'test',
Secret => 'supersecret',
Timeout => 3, #Default timeout for all operations, 3 seconds
Keepalive => 60, #Send a keepalive every minute
on_error => sub { print "Error occured on socket\r\n"; exit; },
on_timeout => sub { print "Connection to asterisk timed out\r\n"; exit; },
Blocking => 0
);
view release on metacpan or search on metacpan
lib/Asterisk/CoroManager.pm view on Meta::CPAN
my $resp = $astman->sendcommand({
Action => 'QueuePause',
Interface => 'SIP/1234',
Paused => 'true',
},
{ Timeout => 2 });
Sends a command to asterisk.
If you are looking for a response, the command will wait for the
specific response from asterisk (identified with an ActionID).
Otherwise it returns immediately.
TODO: Implement timeout: Timeout is how long to wait for the response.
Defaults to 3 seconds.
Returns a hash or hash-ref on success (depending on wantarray), undef
on timeout.
lib/Asterisk/CoroManager.pm view on Meta::CPAN
if (defined wantarray) {
$astman->debug("Waiting for response of command here.");
$astman->trace(longmess());
$astman->trace("-------------------------------------");
$args ||= {};
my $timeout = $args->{Timeout} || DEFAULT_TIMEOUT;
my $response = new Coro::Channel;
$astman->{action_cb}{$actionid} = sub{ $response->put(@_) };
my $resp = $response->get; # Cede's until a response is gotten
return unless( $resp );
return wantarray ? %{$resp} : $resp;
# TODO: Timeout!
}
return;
}
lib/Asterisk/CoroManager.pm view on Meta::CPAN
sub connected {
my ($astman, $timeout) = @_;
return ($astman->{fh}->connected and
$astman->sendcommand({ Action => 'Ping' },
{ Timeout => $timeout || DEFAULT_TIMEOUT })
);
}
##############################################################################
view release on metacpan or search on metacpan
lib/Asterisk/config/syntax/highlight.pm view on Meta::CPAN
return;
}
sub commands {
return qw/
AbsoluteTimeout
AddQueueMember
ADSIProg
AgentCallbackLogin
AgentLogin
AgentMonitorOutgoing
lib/Asterisk/config/syntax/highlight.pm view on Meta::CPAN
DBQuery
DBRewrite
DeadAGI
Dial
Dictate
DigitTimeout
Directory
DISA
DTMFToText
DUNDiLookup
EAGI
lib/Asterisk/config/syntax/highlight.pm view on Meta::CPAN
ReadFile
RealTime
Record
RemoveQueueMember
ResetCDR
ResponseTimeout
RetryDial
Return
Ringing
Rpt
SayAlpha
view release on metacpan or search on metacpan
t/useragent.t view on Meta::CPAN
$ua->connect_timeout(1);
my $search = Astro::ADS::Search->new( q => 'dark energy', sort => 'citation_count desc', rows => 100, ua => $ua);
$search->fl('ack,aff,aff_id,alternate_bibcode,alternate_title,arxiv_class,author,author_count,author_norm,bibcode,bibgroup,bibstem,citation,citation_count,cite_read_boost,classic_factor,comment,copyright,data,database,date,doctype,doi,eid,ent...
my $result = $search->query();
$DB::single = 1;
like $result->error, qr/Timeout/;
};
=cut
done_testing();
view release on metacpan or search on metacpan
# grab the argument list
my %args = @_;
# Loop over the allowed keys and modify the default query options
for my $key (qw / RA Dec Target Equinox Xsize Ysize Survey Format
URL Timeout Proxy / ) {
my $method = lc($key);
$self->$method( $args{$key} ) if exists $args{$key};
}
}
view release on metacpan or search on metacpan
=over 4
=item *
B<Timeout handling>
By default a script will die upon timeout, this can be modified in anyway you like to keep the script going and handle the exception cleanly, an example of a handler is:
my $timed_out = 0;
$iraf->exec(command => 'print "hello"',
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
Query/Query.pm view on Meta::CPAN
Units => $radius_units,
Frame => $coord_frame,
Epoch => $coord_epoch,
Equinox => $coord_equinox,
Proxy => $proxy,
Timeout => $timeout,
URL => $alternative_url );
my $results = $query->querydb();
$other = new Astro::SIMBAD::Query( Target => $object );
Query/Query.pm view on Meta::CPAN
Units => $radius_units,
Frame => $coord_frame,
Epoch => $coord_epoch,
Equinox => $coord_equinox,
Proxy => $proxy,
Timeout => $timeout,
URL => $alternative_url );
returns a reference to an SIMBAD query object.
=cut
Query/Query.pm view on Meta::CPAN
# Loop over the allowed keys and modify the default query options, note
# that due to the order these are called in supplying both and RA and Dec
# and an object Identifier (e.g. HT Cas) will cause the query to default
# to using the identifier rather than the supplied co-ordinates.
for my $key (qw / RA Dec Target Error Units Frame Epoch Equinox
Proxy Timeout URL / ) {
my $method = lc($key);
$self->$method( $args{$key} ) if exists $args{$key};
}
}
view release on metacpan or search on metacpan
lib/Astro/SkyX.pm view on Meta::CPAN
PeerAddr => $destinationIP,
PeerPort => $destinationPort,
Blocking => 0,
autoflush => 1,
Proto => 'tcp',
Timeout => "300",
);
if ( ! Scalar::Util::openhandle($SkyXConnection ) ){
die "Unable to connect to The Sky X\n";
}
$SkyXConnection->autoflush(1);
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
lib/Async/Redis.pm view on Meta::CPAN
use IO::Socket::INET;
use Time::HiRes ();
# Error classes
use Async::Redis::Error::Connection;
use Async::Redis::Error::Timeout;
use Async::Redis::Error::Disconnected;
use Async::Redis::Error::Redis;
use Async::Redis::Error::Protocol;
# Import auto-generated command methods
lib/Async/Redis.pm view on Meta::CPAN
port => $args{port} // 6379,
socket => undef,
parser => undef,
connected => 0,
# Timeout settings
connect_timeout => $args{connect_timeout} // 10,
read_timeout => $args{read_timeout} // 30,
write_timeout => $args{write_timeout} // 30,
request_timeout => $args{request_timeout} // 5,
blocking_timeout_buffer => $args{blocking_timeout_buffer} // 2,
lib/Async/Redis.pm view on Meta::CPAN
if ($completed_f->is_failed) {
my ($error) = $completed_f->failure;
close $socket;
if ($error eq 'connect_timeout') {
die Async::Redis::Error::Timeout->new(
message => "Connect timed out after $self->{connect_timeout}s",
timeout => $self->{connect_timeout},
);
}
die Async::Redis::Error::Connection->new(
lib/Async/Redis.pm view on Meta::CPAN
my $deadline = Time::HiRes::time() + $self->{connect_timeout};
while (1) {
# Check timeout
if (Time::HiRes::time() >= $deadline) {
die Async::Redis::Error::Timeout->new(
message => "TLS handshake timed out",
timeout => $self->{connect_timeout},
);
}
lib/Async/Redis.pm view on Meta::CPAN
my $wait_f = Future->wait_any($read_f, $timeout_f);
await $wait_f;
if ($wait_f->is_failed) {
die Async::Redis::Error::Timeout->new(
message => "TLS handshake timed out",
timeout => $self->{connect_timeout},
);
}
}
lib/Async/Redis.pm view on Meta::CPAN
my $wait_f = Future->wait_any($write_f, $timeout_f);
await $wait_f;
if ($wait_f->is_failed) {
die Async::Redis::Error::Timeout->new(
message => "TLS handshake timed out",
timeout => $self->{connect_timeout},
);
}
}
lib/Async/Redis.pm view on Meta::CPAN
while (1) {
my $remaining = $deadline - Time::HiRes::time();
if ($remaining <= 0) {
$self->_reset_connection;
die Async::Redis::Error::Timeout->new(
message => "Request timed out after $self->{request_timeout}s",
command => $cmd_ref,
timeout => $self->{request_timeout},
maybe_executed => 1, # already sent the command
);
lib/Async/Redis.pm view on Meta::CPAN
if ($wait_f->is_failed) {
my ($error) = $wait_f->failure;
if ($error eq 'read_timeout') {
$self->_reset_connection;
die Async::Redis::Error::Timeout->new(
message => "Request timed out after $self->{request_timeout}s",
command => $cmd_ref,
timeout => $self->{request_timeout},
maybe_executed => 1,
);
lib/Async/Redis.pm view on Meta::CPAN
while (@{$self->{inflight}} && Time::HiRes::time() < $deadline) {
await Future::IO->sleep(0.001);
}
if (@{$self->{inflight}}) {
$self->_fail_all_inflight("Timeout waiting for inflight commands");
}
}
async sub publish {
my ($self, $channel, $message) = @_;
lib/Async/Redis.pm view on Meta::CPAN
try {
await $redis->get('key');
} catch {
if ($_->isa('Async::Redis::Error::Connection')) {
# Connection error
} elsif ($_->isa('Async::Redis::Error::Timeout')) {
# Timeout error
} elsif ($_->isa('Async::Redis::Error::Redis')) {
# Redis error (e.g., WRONGTYPE)
}
};
lib/Async/Redis.pm view on Meta::CPAN
=item Async::Redis::Error::Connection
Connection-related errors (refused, reset, etc.)
=item Async::Redis::Error::Timeout
Timeout errors (connect, request, read).
=item Async::Redis::Error::Protocol
Protocol parsing errors.
view release on metacpan or search on metacpan
$('#comet_sequence').text(data[0]);
$('#comet_resource').text(data[1]);
sendCometRequest();
})
.fail(function() {
setTimeout(sendCometRequest, RECONNECT_BACKOFF);
});
};
sendCometRequest();
// Setup WebSocket
var data = event.data.split(" ");
$('#websocket_sequence').text(data[0]);
$('#websocket_resource').text(data[1]);
};
ws.onclose = function() {
setTimeout(connectWebsocket, RECONNECT_BACKOFF);
};
};
connectWebsocket();
});
//--></script>
view release on metacpan or search on metacpan
local ( $., $@, $!, $^E, $? );
kill 9, $pid; # I don't care.
waitpid $pid, 0;
}
package AsyncTimeout;
our $VERSION = '0.14';
our @ISA = 'Async';
sub new {
C<result()> takes an optional parameter, C<$force>. If C<$force> is
true, then the calling process will wait until the asynchronous
computation is complete before returning.
=head2 C<AsyncTimeout>
use Async;
$proc = AsyncTimeout->new( sub { ... }, $timeout, $special );
C<AsyncTimeout> implements a version of C<Async> that has an
automatic timeout. If the asynchronous computation does not complete
before C<$timeout> seconds have elapsed, it is forcibly terminated and
returns a special value C<$special>. The default special value is the
string "Timed out\n".
All the other methods for C<AsyncTimeout> are exactly the same as for
C<Async>.
=head2 C<AsyncData>
use Async;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
lib/Attribute/TieClasses.pm view on Meta::CPAN
Shadow => 'HASH=Tie::ShadowHash',
Sort => 'HASH=Tie::SortHash',
Strict => 'HASH=Tie::StrictHash',
Substr => 'HASH=Tie::SubstrHash',
TextDir => 'HASH=Tie::TextDir',
Timeout => 'SCALAR=Tie::Scalar::Timeout',
Toggle => 'SCALAR=Tie::Toggle',
Transact => 'HASH=Tie::TransactHash',
TwoLevel => 'HASH=Tie::TwoLevelHash',
Vec => 'ARRAY=Tie::VecArray',
WarnGlobal => 'SCALAR=Tie::WarnGlobal::Scalar',
lib/Attribute/TieClasses.pm view on Meta::CPAN
version 1.101700
=head1 SYNOPSIS
use Attribute::TieClasses;
my $k : Timeout(EXPIRES => '+2s');
# loads in Tie::Scalar::Timeout and tie()s $k with those options
=head1 DESCRIPTION
Damian Conway's wonderful C<Attribute::Handlers> module provides
an easy way to use attributes for C<tie()>ing variables. In effect,
the code in the synopsis is simply
use Attribute::Handlers
autotie => { Timeout => 'Tie::Scalar::Timeout' };
Still, going one step further, it might be useful to have centrally
defined attributes corresponding to commonly used Tie classes found
on CPAN.
lib/Attribute/TieClasses.pm view on Meta::CPAN
Sort HASH Tie::SortHash
Sorted HASH Tie::SortHash
Strict HASH Tie::StrictHash
Substr HASH Tie::SubstrHash
TextDir HASH Tie::TextDir
Timeout SCALAR Tie::Scalar::Timeout
Toggle SCALAR Tie::Toggle
Transact HASH Tie::TransactHash
TwoLevel HASH Tie::TwoLevelHash
Vec ARRAY Tie::VecArray
Vector ARRAY Tie::VecArray
lib/Attribute/TieClasses.pm view on Meta::CPAN
Is more flexible than the other C<make_tie_*()> functions in that it checks the
type of the variable that the attribute is being applied to.
=head1 EXAMPLES
# Tie::Scalar::Timeout
my $m : Timeout(NUM_USES => 3, VALUE => 456, POLICY => 777);
print "$m\n" for 1..5;
# Tie::Hash::Rank
my %scores : Ranked;
%scores = (
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;
view release on metacpan or search on metacpan
inc/Module/Install/Fetch.pm view on Meta::CPAN
if (eval { require LWP::Simple; 1 }) {
LWP::Simple::mirror($args{url}, $file);
}
elsif (eval { require Net::FTP; 1 }) { eval {
# use Net::FTP to get past firewall
my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
$ftp->login("anonymous", 'anonymous@example.com');
$ftp->cwd($path);
$ftp->binary;
$ftp->get($file) or (warn("$!\n"), return);
$ftp->quit;