view release on metacpan or search on metacpan
lib/ArrayData/Word/EN/Enable.pm view on Meta::CPAN
aliteracies
aliteracy
aliterate
aliterates
aliunde
alive
aliveness
alivenesses
aliya
aliyah
aliyahs
aliyas
aliyos
view release on metacpan or search on metacpan
It's alive! It's Aliiiive!
Is it an array, or is it a hash? Neither! Both! It's a disgusting
frankenstein's monster made by sewing together bits and pieces of
arrays and hashes into a monstrous and unholy creation!
view release on metacpan or search on metacpan
lib/Arriba/Connection/HTTP.pm view on Meta::CPAN
or die $!;
}
$self->{_inputbuf} = '';
$self->{_current_req} = undef;
$self->{_keepalive} = 1;
return $self;
}
sub read_request {
lib/Arriba/Connection/HTTP.pm view on Meta::CPAN
}
$req->{complete} = 1;
$self->{_current_req} = undef;
}
elsif ($self->{_keepalive}) {
# New request
$req = Arriba::Request->new($self);
$req->{scheme} = $self->{ssl} ? 'https' : 'http';
while (1) {
lib/Arriba/Connection/HTTP.pm view on Meta::CPAN
}
}
}
else {
if (!exists $headers{'transfer-encoding'}) {
$self->{_keepalive} = 0;
}
}
if ($self->{_keepalive}) {
push @header_lines, 'Connection: keep-alive';
}
else {
push @header_lines, 'Connection: close';
}
view release on metacpan or search on metacpan
t/201-current_contract.t view on Meta::CPAN
use Scalar::Util qw(refaddr);
my @trace;
my $report = refute_and_report {
push @trace, current_contract;
push @trace, "alive";
};
is refaddr $trace[0], refaddr $report, "current_contract is same as report";
is $trace[1], "alive", "current_contract lives";
my $permitted = eval {
current_contract;
"Should not be";
};
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 $ping = $astman->sendcommand({ Action => 'Ping' }, { timeout => '2' });
if( $ping ) {
# $ping->{Response} should be 'Pong'
print "Yay, we're alive! We got ". $ping->{Response} ."\n";
}
else {
print "Got no pong in 2 seconds :-(\n";
}
lib/Asterisk/CoroManager.pm view on Meta::CPAN
=head2 check_connection
$astman->check_connection();
Checks if the connection is still alive. Tries to reconnect if it
isn't.
=cut
sub check_connection {
view release on metacpan or search on metacpan
t/metrics.t-lwp-mock.out view on Meta::CPAN
"query" : "",
"scheme" : "https"
}
},
"response" : {
"body" : "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Origin: http://0.0.0.0:8000\r\nConnection: keep-alive\r\nContent-Length: 4531\r\nContent-Security-Policy: default-src 'self'; object-src 'none'\r\nCo...
"class" : "Mojo::Message::Response"
},
"txn_num" : 0
},
{
t/metrics.t-lwp-mock.out view on Meta::CPAN
"query" : "",
"scheme" : "https"
}
},
"response" : {
"body" : "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Origin: http://0.0.0.0:8000\r\nConnection: keep-alive\r\nContent-Length: 772\r\nContent-Security-Policy: default-src 'self'; object-src 'none'\r\nCon...
"class" : "Mojo::Message::Response"
},
"txn_num" : 1
},
{
t/metrics.t-lwp-mock.out view on Meta::CPAN
"query" : "",
"scheme" : "https"
}
},
"response" : {
"body" : "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Origin: http://0.0.0.0:8000\r\nConnection: keep-alive\r\nContent-Length: 3797\r\nContent-Security-Policy: default-src 'self'; object-src 'none'\r\nCo...
"class" : "Mojo::Message::Response"
},
"txn_num" : 2
},
{
t/metrics.t-lwp-mock.out view on Meta::CPAN
"query" : "",
"scheme" : "https"
}
},
"response" : {
"body" : "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Origin: http://0.0.0.0:8000\r\nConnection: keep-alive\r\nContent-Length: 2607\r\nContent-Security-Policy: default-src 'self'; object-src 'none'\r\nCo...
"class" : "Mojo::Message::Response"
},
"txn_num" : 3
}
]
view release on metacpan or search on metacpan
Constants/Constants.pm view on Meta::CPAN
use constant TYPE_GRB_COORDS => 1;
# Test coords packet
use constant TYPE_TEST_COORDS => 2;
# I'm_alive packet
use constant TYPE_IM_ALIVE => 3;
# Kill a socket connection packet
use constant TYPE_KILL_SOCKET => 4;
view release on metacpan or search on metacpan
my $t = Expect->spawn('cl') || croak "Cannot spawn CL: $!";
$t->expect(30,'-re',$self->{'cl_prompt'});
croak "Did not get CL prompt after starting up" if $t->error;
$self->{'dead'} = 0; # It is now alive.
my $output = $t->before();
my @output = split /\n/,$output;
if ($self->{'display_startup'}){
for (@output){print STDOUT $_ . "\n"}
view release on metacpan or search on metacpan
lib/Async/Event/Interval.pm view on Meta::CPAN
_events_write(sub { $events{$self->id}{_stop_requested} = 1 });
# Try graceful SIGTERM first so a user-installed SIGTERM handler in the
# callback can do cleanup (close files, release locks, etc.).
# Escalate to SIGKILL if the child is still alive after STOP_TERM_TIMEOUT
# _signal_and_wait polls at STOP_KILL_POLL_INTERVAL and returns 1 as
# soon as the process is gone, so the common case is a single poll.
return if $self->_signal_and_wait('TERM', STOP_TERM_TIMEOUT);
lib/Async/Event/Interval.pm view on Meta::CPAN
# External access: These allow unit tests to directly access live data in the
# %events hash
sub _events_count {
# Number of events currently alive
return _events_read(sub { $events{_event_count} || 0 });
}
sub _events_knot {
# The IPC::Shareable knot itself
return tied(%events);
view release on metacpan or search on metacpan
root/static/example_openapi.yaml view on Meta::CPAN
'/hcheck':
get:
description: 'Returns a 200 response and Perl package name as text when the service is available'
responses:
200:
description: 'alive'
content:
'text/plain':
example: "Service-name: async-microservice-time\nAPI-version: 1"
405:
$ref: '#/components/responses/Method-Not-Allowed'
view release on metacpan or search on metacpan
examples/pagi-chat/public/js/app.js view on Meta::CPAN
state.ws.onopen = () => {
setConnectionStatus('connected');
state.reconnectAttempts = 0;
state.lastPongTime = Date.now();
// Start keepalive ping interval
if (state.pingInterval) {
clearInterval(state.pingInterval);
}
state.pingInterval = setInterval(() => {
if (state.ws && state.ws.readyState === WebSocket.OPEN) {
examples/pagi-chat/public/js/app.js view on Meta::CPAN
showToast(data.message, 'error');
break;
case 'pong':
case 'server_ping':
// Keepalive messages - no action needed
break;
case 'stats':
updateStats(data);
break;
examples/pagi-chat/public/js/app.js view on Meta::CPAN
// Visibility change - send ping when tab becomes visible
// This helps prevent disconnects from browser throttling background tabs
document.addEventListener('visibilitychange', () => {
if (document.visibilityState === 'visible') {
// Tab became visible - send immediate ping to keep connection alive
if (state.ws && state.ws.readyState === WebSocket.OPEN) {
sendMessage({ type: 'ping' });
}
}
});
view release on metacpan or search on metacpan
sub make_use_of {
my ($self) = @_;
push $self->{events}, "make_use_of";
fail "We're not supposed to be alive" if $self->{closed};
}
sub release {
my ($self) = @_;
#
# This race condition should be allowed so long as the resource is still valid,
# but Async::ResourcePool may never dispatch it (there's a test below for
# that).
#
die "We're not supposed to be alive in release:\n@{$self->{events}}"
if $self->{closed};
$self->{pool}->release($self);
}
view release on metacpan or search on metacpan
t/30-error.t view on Meta::CPAN
my ($in) = @_;
$fired = 1;
ok(!defined($in), "condition input is undef.");
return 1;
});
is(int($s->watchers), 1, "watcher is alive");
$s->trigger('a');
is($fired, 1, "watcher fired.");
is(int($s->watchers), 1, "watcher is alive. cancel() is not called in the watcher callback.");
}
{
note('--- unregister() non-existent resource');
my $s = new_ok('Async::Selector');
view release on metacpan or search on metacpan
lib/Async/Simple/Task/Fork.pm view on Meta::CPAN
# Return for master process
# Only child tasks must go down and make a loop
return $self if $self->pid;
# Child loop: untill parent is alive
while ( 1 ) {
$self->clear_answer;
$self->get;
unless ( $self->has_answer ) {
view release on metacpan or search on metacpan
}
});
$fh->start();
B<Note:> The Firehose requires L<Codec::CBOR> and an async event loop to keep the connection alive. Currently, At.pm
supports L<Mojo::UserAgent> so you should usually use L<Mojo::IOLoop>:
use Mojo::IOLoop;
# ... setup firehose ...
Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
view release on metacpan or search on metacpan
t/truncated_mixed.t view on Meta::CPAN
syswrite($w->wh, substr($wire, 0, $cut)) or die "syswrite: $!";
$r->blocking(0);
my ($err, @got) = one_call($r);
unlike($err, qr/DEADLINE/, "the call returned instead of spinning");
is($err, '', "no exception while the writer is still alive");
ok(!@got, "returned empty: nothing complete yet, caller may retry");
# Deliver the rest; the reassembled message must come through intact.
syswrite($w->wh, substr($wire, $cut)) or die "syswrite: $!";
($err, @got) = one_call($r);
view release on metacpan or search on metacpan
use Attribute::TieClasses;
use Test::More tests => 1;
my $st : __TEST;
my @st : __TEST;
my %st : __TEST;
pass('still alive (well, it compiled)');
view release on metacpan or search on metacpan
lib/Audio/AMaMP.pm view on Meta::CPAN
$message{'parameters'} = \%params;
return %message;
}
# This sub checks if the core is still alive/available.
sub isCoreAlive {
# Just call C function to check.
my ($self) = @_;
return amampIsCoreAlive($self->{'core'});
}
lib/Audio/AMaMP.pm view on Meta::CPAN
=item isCoreAlive
print "Core has not terminated" if $amamp->isCoreAlive;
Checks if the AMaMP core is still "alive", e.g. if it has terminated.
If it has terminated, 0 is returned. If it is still alive, a non-zero
value is returned. Note that just because the core is no longer alive
does not mean there are no messages left to read.
=head1 SEE ALSO
AMaMP has a website at L<http://amamp.sourceforge.net/>, which has
view release on metacpan or search on metacpan
lib/Audio/RPLD.pm view on Meta::CPAN
=head3 $res = $rpld-E<gt>noop()
Send a NOOP command to the server.
This can be used to ping the server or for keep-alive.
=cut
# -- server info:
view release on metacpan or search on metacpan
lib/Audio/Scrobbler2.pm view on Meta::CPAN
}
sub _build_http_client {
return HTTP::Tiny->new(
agent => "Audio-Scrobbler2/$VERSION",
keep_alive => 1,
timeout => 30,
verify_SSL => 1,
);
}
view release on metacpan or search on metacpan
examples/js/jquery-1.9.1.js view on Meta::CPAN
return "script";
}
});
var xhrCallbacks, xhrSupported,
xhrId = 0,
// #5280: Internet Explorer will keep connections alive if we don't abort on unload
xhrOnUnloadAbort = window.ActiveXObject && function() {
// Abort all pending requests
var key;
for ( key in xhrCallbacks ) {
xhrCallbacks[ key ]( undefined, true );
view release on metacpan or search on metacpan
t/35-xml-sig-units.t view on Meta::CPAN
<Name>Bob</Name><!-- no surname -->
<DateOfBirth>1954-03-21</DateOfBirth>
</Identity>
</Assertion>
<Unsafe>
<Assertion>Elvis is alive</Assertion>
</Unsafe>
</Container>
};
$xc = parse_xml_to_xc($xml, @ns_ds);
view release on metacpan or search on metacpan
lib/Authen/Simple/HTTP.pm view on Meta::CPAN
agent => {
type => Params::Validate::OBJECT,
isa => 'LWP::UserAgent',
default => LWP::UserAgent->new(
cookie_jar => {},
keep_alive => 1,
timeout => 30
),
optional => 1
}
});
view release on metacpan or search on metacpan
smbval/rfcnb-io.c view on Meta::CPAN
{ int read_len, pkt_len;
char hdr[RFCNB_Pkt_Hdr_Len]; /* Local space for the header */
struct RFCNB_Pkt *pkt_frag;
int more, this_time, offset, frag_len, this_len;
BOOL seen_keep_alive = TRUE;
/* Read that header straight into the buffer */
if (len < RFCNB_Pkt_Hdr_Len) { /* What a bozo */
smbval/rfcnb-io.c view on Meta::CPAN
RFCNB_errno = RFCNBE_BadParam;
return(RFCNBE_Bad);
}
/* We discard keep alives here ... */
if (RFCNB_Timeout > 0)
alarm(RFCNB_Timeout);
while (seen_keep_alive) {
if ((read_len = read(con -> fd, hdr, sizeof(hdr))) < 0) { /* Problems */
#ifdef RFCNB_DEBUG
fprintf(stderr, "Reading the packet, we got:");
perror("");
smbval/rfcnb-io.c view on Meta::CPAN
fprintf(stderr, "RFCNB KEEP ALIVE received\n");
#endif
}
else {
seen_keep_alive = FALSE;
}
}
/* What if we got less than or equal to a hdr size in bytes? */
view release on metacpan or search on metacpan
bin/apache/site_perl/Apache/Toe.pm view on Meta::CPAN
my $reply = $c->getEvent( AW_INFINITE );
if ( ($eventTypeName = $reply->getTypeName) eq "Adapter::ack" ) {
#
# Adapter is alive, proceed:
#
if ( my $cgiBoard = $r->param( 'board' ) ) {
$cgiBoard =~ s/([eXO])/'$1'/g;
view release on metacpan or search on metacpan
lib/AxKit2/Connection.pm view on Meta::CPAN
use AxKit2::HTTPHeaders;
use AxKit2::Constants;
use AxKit2::Utils qw(http_date);
use fields qw(
alive_time
create_time
headers_string
headers_in
headers_out
ditch_leading_rn
lib/AxKit2/Connection.pm view on Meta::CPAN
http_headers_sent
notes
sock_closed
pause_count
continuation
keep_alive_count
);
use constant KEEP_ALIVE_MAX => 100;
use constant CLEANUP_TIME => 5; # every N seconds
use constant MAX_HTTP_HEADER_LENGTH => 102400; # 100k
lib/AxKit2/Connection.pm view on Meta::CPAN
$self = fields::new($self) unless ref($self);
$self->SUPER::new($sock);
my $now = time;
$self->{alive_time} = $self->{create_time} = $now;
$self->{headers_string} = '';
$self->{closed} = 0;
$self->{ditch_leading_rn} = 0; # TODO - work out how to set that...
$self->{server_config} = $servconf;
$self->{keep_alive_count} = 0;
$self->{notes} = {};
$self->log(LOGINFO, "Connection from " . $self->peer_addr_string);
$self->hook_connect();
lib/AxKit2/Connection.pm view on Meta::CPAN
sub event_hup { my AxKit2::Connection $self = shift; $self->close("Disconnect (HUP)") }
sub close { my AxKit2::Connection $self = shift; $self->{sock_closed}++; $self->{notes} = undef; $self->SUPER::close(@_) }
sub event_read {
my AxKit2::Connection $self = shift;
$self->{alive_time} = time;
if ($self->{headers_in}) {
# already got the headers... do we get a body too?
my $bref = $self->read(8192);
return $self->close($!) unless defined $bref;
lib/AxKit2/Connection.pm view on Meta::CPAN
$self->hook_post_read_request($self->{headers_in});
}
sub event_write {
my AxKit2::Connection $self = shift;
$self->{alive_time} = time;
if ($self->hook_write_body_data) {
return;
}
lib/AxKit2/Connection.pm view on Meta::CPAN
my $hd = $self->{headers_in};
$self->initialize_response($hd);
no warnings 'uninitialized';
if ($hd->header('Connection') =~ /\bkeep-alive\b/i) {
# client asked for keep alive. Do we?
$self->{keep_alive_count}++;
if ($self->{keep_alive_count} > KEEP_ALIVE_MAX) {
$self->{headers_out}->header(Connection => 'close');
}
else {
$self->{headers_out}->header(Connection => 'Keep-Alive');
$self->{headers_out}->header('Keep-Alive' =>
"timeout=" . $self->max_idle_time .
", max=" . (KEEP_ALIVE_MAX - $self->{keep_alive_count}));
}
}
# This starts off the chain reaction of the main state machine
$self->hook_uri_translation($hd, $hd->request_uri);
lib/AxKit2/Connection.pm view on Meta::CPAN
return 0 if $self->{sock_closed};
# close if we're supposed to
if (
! defined $self->{headers_out} ||
! $self->{headers_out}->res_keep_alive($self->{headers_in})
)
{
# do a final read so we don't have unread_data_waiting and RST
# the connection. IE and others send an extra \r\n after POSTs
my $dummy = $self->read(5);
# close if we have no response headers or they say to close
$self->close("no_keep_alive");
return 0;
}
# if they just did a POST, set the flag that says we might expect
# an unadvertised \r\n coming from some browsers. Old Netscape
lib/AxKit2/Connection.pm view on Meta::CPAN
# we will recork when we're processing a new request.
# TODO: Disabled because this seemed mostly relevant to Perlbal...
$self->tcp_cork(0);
# reset state
$self->{alive_time} = $self->{create_time} = time;
$self->{headers_string} = '';
$self->{headers_in} = undef;
$self->{headers_out} = undef;
$self->{http_headers_sent} = 0;
$self->{notes} = {};
lib/AxKit2/Connection.pm view on Meta::CPAN
push @to_close, $v;
next;
}
}
if (my $t = $max_age{$ref}) {
if ($v->{alive_time} < $now - $t) {
push @to_close, $v;
}
}
}
view release on metacpan or search on metacpan
call_sv((SV*)destructor, G_DISCARD|G_EVAL|G_KEEPERR|G_VOID);
POPSTACK;
SPAGAIN;
LEAVE;
if(SvREFCNT(tmpref) < 2) {
/* tmpref is not kept alive! */
SvREFCNT(sv)--;
SvRV_set(tmpref, NULL);
SvROK_off(tmpref);
}
SvREFCNT_dec(tmpref);
view release on metacpan or search on metacpan
#if DBVER >= 403
DB_SEQUENCE *seq;
db_seq_t seq_t;
#endif
SV *rsv1, *rsv2; // keep some request objects alive
} bdb_cb;
typedef bdb_cb *bdb_req;
enum {