view release on metacpan or search on metacpan
lib/Finance/YahooJPN/QuoteDetail.pm view on Meta::CPAN
sub _access_to_yahoo(){
my $self = shift;
#Create a user agent object
my $ua = LWP::UserAgent->new(env_proxy => 1,
keep_alive => 1,
timeout => 30,
);
$ua->proxy(['http'], $$self{'proxy'}) if $$self{'proxy'};
$ua->agent("MyApp/0.1");
view release on metacpan or search on metacpan
lib/Firefox/Marionette.pm view on Meta::CPAN
sub _reconnected {
my ($self) = @_;
return $self->{_reconnected};
}
sub _check_reconnecting_firefox_process_is_alive {
my ( $self, $pid ) = @_;
if ( $OSNAME eq 'MSWin32' ) {
if (
Win32::Process::Open(
my $process, $pid, _WIN32_PROCESS_INHERIT_FLAGS()
lib/Firefox/Marionette.pm view on Meta::CPAN
my ($self) = @_;
my $temp_directory = File::Spec->tmpdir();
my $temp_handle = DirHandle->new($temp_directory)
or Firefox::Marionette::Exception->throw(
"Failed to open directory '$temp_directory':$EXTENDED_OS_ERROR");
my $alive_pid;
my $local_name_regex = $self->_get_local_name_regex();
TEMP_DIR_LISTING: while ( my $tainted_entry = $temp_handle->read() ) {
next if ( $tainted_entry eq File::Spec->curdir() );
next if ( $tainted_entry eq File::Spec->updir() );
lib/Firefox/Marionette.pm view on Meta::CPAN
if ( ( defined $local_proxy->{firefox} )
&& ( $local_proxy->{firefox}->{pid} ) )
{
if (
my $check_pid =
$self->_check_reconnecting_firefox_process_is_alive(
$local_proxy->{firefox}->{pid}
)
)
{
$alive_pid = $check_pid;
}
else {
next TEMP_DIR_LISTING;
}
}
lib/Firefox/Marionette.pm view on Meta::CPAN
}
}
closedir $temp_handle
or Firefox::Marionette::Exception->throw(
"Failed to close directory '$temp_directory':$EXTENDED_OS_ERROR");
return $alive_pid;
}
sub _setup_profile {
my ($self) = @_;
if ( $self->{profile_name} ) {
lib/Firefox/Marionette.pm view on Meta::CPAN
}
sub _remote_process_running {
my ( $self, $remote_pid ) = @_;
my $now = time;
if ( ( defined $self->{last_remote_alive_status} )
&& ( $self->{last_remote_kill_time} >= $now ) )
{
return $self->{last_remote_alive_status};
}
$self->{last_remote_kill_time} = $now;
my $remote_uname = $self->_remote_uname();
if ( !defined $remote_uname ) {
return;
lib/Firefox/Marionette.pm view on Meta::CPAN
sub _win32_remote_process_running {
my ( $self, $remote_pid ) = @_;
my $binary = 'tasklist';
my @arguments = ( '/FI', q["PID eq ] . $remote_pid . q["] );
$self->{last_remote_alive_status} = 0;
foreach my $line ( split /\r?\n/smx, $self->execute( $binary, @arguments ) )
{
if ( $line =~ /^firefox[.]exe[ ]+(\d+)[ ]/smx ) {
if ( $1 == $remote_pid ) {
$self->{last_remote_alive_status} = 1;
}
}
}
return $self->{last_remote_alive_status};
}
sub _generic_remote_process_running {
my ( $self, $remote_pid ) = @_;
my $result = $self->_execute_via_ssh(
lib/Firefox/Marionette.pm view on Meta::CPAN
),
'-0',
$remote_pid
);
if ( $result == 0 ) {
$self->{last_remote_alive_status} = 1;
}
else {
$self->{last_remote_alive_status} = 0;
}
return $self->{last_remote_alive_status};
}
sub alive {
my ($self) = @_;
if ( $self->_adb() ) {
my $parameters;
my $binary = q[adb];
my @arguments =
lib/Firefox/Marionette.pm view on Meta::CPAN
my $host = _DEFAULT_HOST();
my $port;
my $socket;
my $sock_addr;
my $connected;
while ( ( !$connected ) && ( $self->alive() ) ) {
if ( $self->_adb() ) {
Firefox::Marionette::Exception->throw(
'TODO: Cannot connect to android yet. Patches welcome');
}
$socket = undef;
lib/Firefox/Marionette.pm view on Meta::CPAN
$connected =
$self->_network_connection_and_initial_read_from_marionette( $socket,
$sock_addr );
}
$self->_reap();
if ( ( $self->alive() ) && ($socket) ) {
}
else {
my $error_message =
$self->error_message()
? $self->error_message()
lib/Firefox/Marionette.pm view on Meta::CPAN
}
sub quit {
my ( $self, $flags ) = @_;
my $ssh_local_directory = $self->ssh_local_directory();
if ( !$self->alive() ) {
my $socket = delete $self->{_socket};
if ($socket) {
close $socket
or Firefox::Marionette::Exception->throw(
"Failed to close socket to firefox:$EXTENDED_OS_ERROR");
lib/Firefox/Marionette.pm view on Meta::CPAN
my $length = length $json;
if ( $self->debug() ) {
warn ">> $length:$json\n";
}
my $result;
if ( $self->alive() ) {
$result = syswrite $self->_socket(), "$length:$json";
}
if ( !defined $result ) {
my $socket_error = $EXTENDED_OS_ERROR;
if ( $self->alive() ) {
Firefox::Marionette::Exception->throw(
"Failed to send request to firefox:$socket_error");
}
else {
my $error_message =
lib/Firefox/Marionette.pm view on Meta::CPAN
}
sub _handle_socket_read_failure {
my ($self) = @_;
my $socket_error = $EXTENDED_OS_ERROR;
if ( $self->alive() ) {
Firefox::Marionette::Exception->throw(
"Failed to read size of response from socket to firefox:$socket_error"
);
}
else {
lib/Firefox/Marionette.pm view on Meta::CPAN
sub _read_from_socket {
my ($self) = @_;
my $number_of_bytes_in_response;
my $initial_buffer;
while ( ( !defined $number_of_bytes_in_response ) && ( $self->alive() ) ) {
my $number_of_bytes;
my $octet;
if ( $self->{_initial_octet_read_from_marionette_socket} ) {
$octet = delete $self->{_initial_octet_read_from_marionette_socket};
$number_of_bytes = length $octet;
lib/Firefox/Marionette.pm view on Meta::CPAN
}
my $number_of_bytes_already_read = 0;
my $json = q[];
while (( defined $number_of_bytes_in_response )
&& ( $number_of_bytes_already_read < $number_of_bytes_in_response )
&& ( $self->alive() ) )
{
my $number_of_bytes_read = sysread $self->_socket(), my $buffer,
$number_of_bytes_in_response - $number_of_bytes_already_read;
if ( defined $number_of_bytes_read ) {
$json .= $buffer;
$number_of_bytes_already_read += $number_of_bytes_read;
}
else {
my $socket_error = $EXTENDED_OS_ERROR;
if ( $self->alive() ) {
Firefox::Marionette::Exception->throw(
"Failed to read response from socket to firefox:$socket_error"
);
}
else {
lib/Firefox/Marionette.pm view on Meta::CPAN
sub _decode_json {
my ( $self, $json ) = @_;
my $parameters;
eval { $parameters = JSON::decode_json($json); } or do {
if ( $self->alive() ) {
if ($EVAL_ERROR) {
chomp $EVAL_ERROR;
die "$EVAL_ERROR\n";
}
}
lib/Firefox/Marionette.pm view on Meta::CPAN
=head2 alert_text
Returns the message shown in a currently displayed modal message box
=head2 alive
This method returns true or false depending on if the Firefox process is still running.
=head2 application_type
view release on metacpan or search on metacpan
FirstGoodURL.pm view on Meta::CPAN
if ($match = FirstGoodURL->in(@URLs)) {
print "good URL: $match\n";
}
else {
print "no URL was alive\n";
}
if ($match = FirstGoodURL->with('image/png')->in(@URLs)) {
print "PNG found at $match\n";
}
view release on metacpan or search on metacpan
examples/flickr_flickr_authentication.pl view on Meta::CPAN
=head1 DESCRIPTION
The original Flickr Authentication has been deprecated in favor
of OAuth. The example flickr_oauth_authentication.pl should be
used in favor of this one. However, this script uses the deprecated--
but seemingly still alive-- Flickr authentication to go from having
just the api_key and api_secret to an authenticated token.
=head1 USAGE
./flickr_flickr_authentication.pl \
view release on metacpan or search on metacpan
lib/Flower/Nodes.pm view on Meta::CPAN
if ( $node->has_timed_out ) {
print "$node - removing after timeout\n";
$self->remove($node);
}
# ping it if we need to, to keep it alive
else {
# tell the node what the 'us' node is, so it can pass that
# information on
$node->ping_if_necessary( $self->nodes_as_hashref );
view release on metacpan or search on metacpan
lib/Fluent/AgentLite.pm view on Meta::CPAN
use constant RECONNECT_WAIT_MAX => 3600; # 60min
use constant RECONNECT_WAIT_INCR_RATE => 1.5;
use constant SEND_RETRY_MAX => 4;
sub connection_keepalive_time {
my ($keepalive_time) = @_;
$keepalive_time + int(CONNECTION_KEEPALIVE_MARGIN_MAX * 2 * rand()) - CONNECTION_KEEPALIVE_MARGIN_MAX;
}
sub new {
my $this = shift;
my ($tag, $primary_servers, $secondary_servers, $configuration) = @_;
lib/Fluent/AgentLite.pm view on Meta::CPAN
secondary => $secondary_servers,
},
buffer_size => $configuration->{buffer_size},
ping_message => $configuration->{ping_message},
drain_log_tag => $configuration->{drain_log_tag},
keepalive_time => $configuration->{keepalive_time},
output_format => $configuration->{output_format},
};
if (defined $self->{output_format} and $self->{output_format} eq 'json') {
*pack = *pack_json;
lib/Fluent/AgentLite.pm view on Meta::CPAN
my $last_ping_message = time;
if ($self->{ping_message}) {
$last_ping_message = time - $self->{ping_message}->{interval} * 2;
}
my $keepalive_time = CONNECTION_KEEPALIVE_TIME;
if (defined $self->{keepalive_time}) {
$keepalive_time = $self->{keepalive_time};
if ($keepalive_time < CONNECTION_KEEPALIVE_MIN and $keepalive_time != CONNECTION_KEEPALIVE_INFINITY) {
warnf 'Keepalive time setting is too short. Set minimum value %s', CONNECTION_KEEPALIVE_MIN;
$keepalive_time = CONNECTION_KEEPALIVE_MIN;
}
}
my $pending_packed;
my $continuous_line;
my $disconnected_primary = 0;
my $expiration_enable = $keepalive_time != CONNECTION_KEEPALIVE_INFINITY;
while(not $check_terminated->()) {
# at here, connection initialized (after retry wait if required)
# connect to servers
lib/Fluent/AgentLite.pm view on Meta::CPAN
$reconnect_wait *= RECONNECT_WAIT_INCR_RATE;
$reconnect_wait = RECONNECT_WAIT_MAX if $reconnect_wait > RECONNECT_WAIT_MAX;
next;
}
# succeed to connect. set keepalive disconnect time
my $connecting = $secondary || $primary;
my $expired = time + connection_keepalive_time($keepalive_time) if $expiration_enable;
$reconnect_wait = RECONNECT_WAIT_MIN;
while(not $check_reconnect->()) {
# connection keepalive expired
if ($expiration_enable and time > $expired) {
infof "connection keepalive expired.";
last;
}
# ping message (if enabled)
my $ping_packed = undef;
view release on metacpan or search on metacpan
bin/foorum_server.pl view on Meta::CPAN
my $debug = 0;
my $fork = 0;
my $help = 0;
my $host = undef;
my $port = $ENV{FOORUM_PORT} || $ENV{CATALYST_PORT} || 3000;
my $keepalive = 0;
my $restart = $ENV{FOORUM_RELOAD} || $ENV{CATALYST_RELOAD} || 0;
my $restart_delay = 1;
my $restart_regex = '(?:/|^)(?!\.#).+(?:\.yml$|\.yaml$|\.conf|\.pm)$';
my $restart_directory = undef;
my $follow_symlinks = 0;
bin/foorum_server.pl view on Meta::CPAN
'debug|d' => \$debug,
'fork|f' => \$fork,
'help|?' => \$help,
'host=s' => \$host,
'port=s' => \$port,
'keepalive|k' => \$keepalive,
'restart|r' => \$restart,
'restartdelay|rd=s' => \$restart_delay,
'restartregex|rr=s' => \$restart_regex,
'restartdirectory=s@' => \$restart_directory,
'followsymlinks' => \$follow_symlinks,
bin/foorum_server.pl view on Meta::CPAN
require Foorum;
Foorum->run( $port, $host, {
argv => \@argv,
'fork' => $fork,
keepalive => $keepalive,
restart => $restart,
restart_delay => $restart_delay,
restart_regex => qr/$restart_regex/,
restart_directory => $restart_directory,
follow_symlinks => $follow_symlinks,
bin/foorum_server.pl view on Meta::CPAN
-f -fork handle each request in a new process
(defaults to false)
-? -help display this help and exits
-host host (defaults to all)
-p -port port (defaults to 3000)
-k -keepalive enable keep-alive connections
-r -restart restart when files get modified
(defaults to false)
-rd -restartdelay delay between file checks
-rr -restartregex regex match files that trigger
a restart when modified
view release on metacpan or search on metacpan
examples/pping.pl view on Meta::CPAN
}
}
my %working;
local $SIG{CHLD} = 'IGNORE';
my ($num_alive, $num_pinged) = 0;
while (my $result = $q2->get) {
if ($result->{start}) {
$working{$result->{start}}++;
next;
}
examples/pping.pl view on Meta::CPAN
}
my $addr = $result->{addr};
my $status = $result->{status};
print "$addr => $status\n";
$num_alive += $status;
$num_pinged++;
}
print "Got response from $num_alive out of $num_pinged queried addresses\n";
exit;
sub work {
my $p;
$q2->put( { start => $$ } );
view release on metacpan or search on metacpan
lib/Forks/Super/Job.pm view on Meta::CPAN
}
return scalar grep { defined($_->{state})
&& $_->{state} eq 'ACTIVE' } @ALL_JOBS;
}
sub count_alive_processes {
my ($count_bg, $optional_pgid) = @_;
my @alive = grep { $_->{state} eq 'ACTIVE' ||
$_->{state} eq 'COMPLETE' ||
$_->{state} eq 'DEFERRED' ||
$_->{state} eq 'LAUNCHING' || # rare
$_->{state} eq 'SUSPENDED' ||
$_->{state} eq 'SUSPENDED-DEFERRED'
} @ALL_JOBS;
if (!$count_bg) {
@alive = grep { $_->{_is_bg} == 0 } @alive;
}
if (defined $optional_pgid) {
@alive = grep { $_->{pgid} == $optional_pgid } @alive;
}
return scalar @alive;
}
sub count_queued_processes {
my ($count_bg,$optional_pgid) = @_;
my @deferred = grep { $_->{state} eq 'DEFERRED' ||
lib/Forks/Super/Job.pm view on Meta::CPAN
}
#
# _reap should distinguish:
#
# all alive jobs (ACTIVE+COMPLETE+SUSPENDED+DEFERRED+SUSPENDED-DEFERRED)
# all active jobs (ACTIVE + COMPLETE + DEFERRED)
# filtered alive jobs (by optional pgid)
# filtered ACTIVE + COMPLETE + DEFERRED jobs
#
# if all_active==0 and all_alive>0,
# then see Wait::WAIT_ACTION_ON_SUSPENDED_JOBS
#
sub count_processes {
my ($count_bg, $optional_pgid) = @_;
my @alive = grep {
$_->{state} ne 'REAPED' &&
$_->{state} ne 'NEW' &&
!$_->{daemon}
} @ALL_JOBS;
if (!$count_bg) {
@alive = grep { $_->{_is_bg} == 0 } @alive;
}
my @active = grep { $_->{state} !~ /SUSPENDED/ } @alive;
my @filtered_active = @active;
my @filtered_alive = @alive;
if (defined $optional_pgid) {
@filtered_active = grep $_->{pgid} == $optional_pgid, @filtered_active;
@filtered_alive = grep $_->{pgid} == $optional_pgid, @filtered_alive;
}
my @n = (scalar(@filtered_active), scalar(@alive),
scalar(@active), scalar(@filtered_alive));
if ($Forks::Super::Debug::DEBUG) {
debug("count_processes(): @n");
if ($n[0]) {
debug('count_processes(): Filtered active: ',
$filtered_active[0]->toString());
}
if ($n[1]) {
debug('count_processes(): Alive: ', $alive[0]->toShortString());
}
if ($n[2]) {
debug("count_processes(): Active: @active");
}
}
view release on metacpan or search on metacpan
example/BookDB/script/bookdb_server.pl view on Meta::CPAN
my $debug = 0;
my $fork = 0;
my $help = 0;
my $host = undef;
my $port = $ENV{BOOKDB_PORT} || $ENV{CATALYST_PORT} || 3000;
my $keepalive = 0;
my $restart = $ENV{BOOKDB_RELOAD} || $ENV{CATALYST_RELOAD} || 0;
my $restart_delay = 1;
my $restart_regex = '\.yml$|\.yaml$|\.pm$';
my $restart_directory = undef;
example/BookDB/script/bookdb_server.pl view on Meta::CPAN
'debug|d' => \$debug,
'fork' => \$fork,
'help|?' => \$help,
'host=s' => \$host,
'port=s' => \$port,
'keepalive|k' => \$keepalive,
'restart|r' => \$restart,
'restartdelay|rd=s' => \$restart_delay,
'restartregex|rr=s' => \$restart_regex,
'restartdirectory=s' => \$restart_directory,
);
example/BookDB/script/bookdb_server.pl view on Meta::CPAN
require BookDB;
BookDB->run( $port, $host, {
argv => \@argv,
'fork' => $fork,
keepalive => $keepalive,
restart => $restart,
restart_delay => $restart_delay,
restart_regex => qr/$restart_regex/,
restart_directory => $restart_directory,
} );
example/BookDB/script/bookdb_server.pl view on Meta::CPAN
-f -fork handle each request in a new process
(defaults to false)
-? -help display this help and exits
-host host (defaults to all)
-p -port port (defaults to 3000)
-k -keepalive enable keep-alive connections
-r -restart restart when files get modified
(defaults to false)
-rd -restartdelay delay between file checks
-rr -restartregex regex match files that trigger
a restart when modified
view release on metacpan or search on metacpan
share/passwords.txt view on Meta::CPAN
bambi
babycake
aprilia
ANDREW
allgood
alive
adriano
808080
7777777a
777666
31121986
share/passwords.txt view on Meta::CPAN
6070
6061
6011
6001
5speed
5alive
59382113kevinp
5884
5878
5864
5791
share/passwords.txt view on Meta::CPAN
allahuakbar
allahakbar
allabout
alla123
all4love
alive1
alitalia
alisa2010
alina2003
alina2000
alimony
view release on metacpan or search on metacpan
t/files/test5.hash view on Meta::CPAN
stype => 'single precision float', type => 6},
'iwig' => { value => [ '0' ],
stype => 'integer', type => 4 },
'awig' => { value => [ '1.000000' ],
stype => 'unspecified float', type => 5 },
'ialive' => { value => [ '0' ],
stype => 'integer', type => 4 },
'border_frac' => { value => [ ('0.0000000E+00') x 3 ],
stype => 'single precision float', type => 6},
'vel_spec' => { value => [ 'F' ],
stype => 'logical', type => 3 },
view release on metacpan or search on metacpan
lang_en/conceptnet-commonsense-is-1.pro view on Meta::CPAN
aquiring is obsessed <> many people <> wealth <> with <> <> <> nothing <> <> <> <> 50
is <> a computer <> a type <> of machine <> <> <> nothing <> <> <> <> 50
is <> whales <> a type <> of mammal <> <> <> nothing <> <> <> <> 50
is <> the sun <> a star <> <> <> <> nothing <> <> <> <> 50
is <> sherlock holmes <> a fictious detective <> <> <> <> nothing <> <> <> <> 50
is <> it <> necassary <> <> eat <> food <> nothing <> <> xxtoxx <> ;; stay <> nothing <> nothing <> alive <> xxtoxx <> <> 50
is <> it <> necassary <> <> consume <> nothing <> nothing <> <> xxtoxx <> ;; stay <> nothing <> nothing <> alive <> xxtoxx <> <> 50
is <> word <> a satellite <> for a moon <> <> <> nothing <> <> <> <> 50
is <> it <> a passage throuh <> to move <> <> <> nothing <> <> <> <> 50
is <> it <> a musical instrument <> <> <> <> nothing <> <> <> <> 50
is <> school <> a place <> <> learn <> nothing <> nothing <> <> xxtoxx <> <> 50
is <> saxophone <> a instrument <> <> <> <> nothing <> <> <> <> 50
view release on metacpan or search on metacpan
JS/js/jsscope.c view on Meta::CPAN
{
/*
* Test whether obj was finalized before prop's last dereference.
*
* This can happen when a deleted property is held by a property iterator
* object (which points to obj, keeping obj alive so long as the property
* iterator is reachable). As soon as the GC finds the iterator to be
* unreachable, it will finalize the iterator, and may also finalize obj,
* in an unpredictable order. If obj is finalized first, its map will be
* null below, and we need only free prop.
*
view release on metacpan or search on metacpan
t/data/00_preface view on Meta::CPAN
DAY 6 (Book iv).
Menelaus tells how he himself came home in the eighth year
after the fall of Troy. He had heard from Proteus, the Old
Man of the Sea, that Odysseus was alive, and a captive on
an island of the deep. Menelaus invites Telemachus to Stay
with him for eleven days or twelve, which Telemachus
declines to do. it will later appear that he made an even
longer stay at Sparta, though whether he changed his mind,
or whether we have here an inadvertence of the poet's it is
view release on metacpan or search on metacpan
lib/Fugu/Pidfile.pm view on Meta::CPAN
return 1;
}
# $self->is_running:
# Return the PID from the file when that process is alive.
# Otherwise return undef.
sub is_running ($self)
{
my $pid = $self->read_pid;
return unless defined $pid;
return unless Fugu::Process->is_alive($pid);
return $pid;
}
# $self->is_stale:
# Report if the file names a process that is not alive now. An
# absent PID file is not stale.
sub is_stale ($self)
{
my $pid = $self->read_pid;
return 0 unless defined $pid;
return !Fugu::Process->is_alive($pid);
}
# $self->_open_locked($nonblocking):
# Open the file for read and write, create it when it is absent,
# and take the exclusive lock. The open must not truncate. A
view release on metacpan or search on metacpan
t/lifetime.t view on Meta::CPAN
fun_rx via_fun_rx(@) { $forceclosure }
is $calls, 2;
TODO: {
local $TODO = 'bug/leak: runtime-installed subs are kept alive somehow';
is_deeply \%watcher, {};
}
view release on metacpan or search on metacpan
lib/Chj/HTTP/Daemon.pm view on Meta::CPAN
my $conn = $r->header('Connection');
if ($proto >= $HTTP_1_1) {
${*$self}{'httpd_nomore'}++ if $conn && lc($conn) =~ /\bclose\b/;
} else {
${*$self}{'httpd_nomore'}++
unless $conn && lc($conn) =~ /\bkeep-alive\b/;
}
if ($only_headers) {
${*$self}{'httpd_rbuf'} = $buf;
return $r;
lib/Chj/HTTP/Daemon.pm view on Meta::CPAN
} else {
$self->force_last_request;
}
} elsif (length($content)) {
$res->header("Content-Length" => length($content));
} elsif (lc($res->header('connection') // "") =~ /\bkeep-alive\b/) {
# don't close connection if user asks for it to stay open
} else {
$self->force_last_request;
$res->header('connection', 'close');
view release on metacpan or search on metacpan
author/benchmark/byown.pl view on Meta::CPAN
printf "Perl/%vd on %s\n", $^V, $Config{archname};
printf "Furl/$Furl::VERSION, LWP/$LWP::VERSION, WWW::Curl/$WWW::Curl::VERSION, HTTP::Lite/$HTTP::Lite::VERSION, libcurl[@{[ WWW::Curl::Easy::version() ]}]\n";
my $port = empty_port();
my $ua = LWP::UserAgent->new(parse_head => 0, keep_alive => 1);
my $curl = WWW::Curl::Easy->new();
my $furl = Furl::HTTP->new(parse_header => 0);
my $url = "http://127.0.0.1:$port/foo/bar";
my $child = Child->new(
view release on metacpan or search on metacpan
lib/Fuse/PerlSSH/FS.pm view on Meta::CPAN
Keep in mind that even when the underlying filesystem on the remote end has everything in
place for extended attribs, your local stack might be incomplete. As of this writing,
FUSE implementations on NetBSD and FreeBSD do not support xattr, for example.
=head2 No keep-alive
Currently, there's no keep-alive mechanism and the automatic reconnect generally fails.
So the mount might become unresponsive after a certain time of inactivity.
=head1 SEE ALSO
L<FUSE|Fuse>, L<IPC::PerlSSH>. L<Filesys::Virtual::SSH>.
view release on metacpan or search on metacpan
lib/FusionInventory/Agent/HTTP/Client.pm view on Meta::CPAN
$self->{ua} = LWP::UserAgent->new(
requests_redirectable => ['POST', 'GET', 'HEAD'],
agent => $FusionInventory::Agent::AGENT_STRING,
timeout => $params{timeout} || 180,
parse_head => 0, # No need to parse HTML
keep_alive => 1,
);
if ($params{proxy}) {
$self->{ua}->proxy(['http', 'https'], $params{proxy});
} else {
view release on metacpan or search on metacpan
lib/Future/Batch/XS.xs view on Meta::CPAN
/* Run the batch - fully in XS! */
run_loop(aTHX_ state_sv);
RETVAL = newSVsv(state->result_future);
/* Don't dec state_sv - callbacks hold copies that keep it alive */
/* It will be freed when all callbacks complete and are GC'd */
}
OUTPUT:
RETVAL
view release on metacpan or search on metacpan
lib/Future/Uring.pm view on Meta::CPAN
=head2 nop
await Future::Uring::nop(%options);
This will do absolutely nothing. This can be useful though if you want to run some code after submissions have been made or need to keep something alive until that point.
=head2 open
my $handle = await Future::Uring::open($filename, $mode = '<', %options);
view release on metacpan or search on metacpan
t/04-wrapper.t view on Meta::CPAN
my $sub = $ctx->new_child_context();
can_ok($sub, qw/get_type new_child_context/);
$ctx = undef;
is exception { $sub->get_type(GCC_JIT_TYPE_INT) }, undef, "subcontext is alive when parent is out of scope";
is exception { $volatile->as_object }, undef, "subcontext keeps parent's objects alive";
$sub = undef;
like exception { $volatile->as_object }, qr/this type is no longer usable/, "when all contexts are destroyed, objects become invalid";
view release on metacpan or search on metacpan
it and/or modify it under the same terms as Perl itself.
=head2 Acknowledgements
Thanks to Steve Bonds for releasing Chart::PNGgraph, and keeping the
code alive when GD reached version 1.20, and I didn't have time to do
something about it.
Thanks to the following people for contributing code, or sending me
fixes:
Dave Belcher,
view release on metacpan or search on metacpan
examples/async1.pl view on Meta::CPAN
});
my $p = $machine->async( hi => 1..4 );
# GRID::Machine::Process objects are overloaded
print "Doing something while $p is still alive ...\n" if $p;
my $r = $machine->waitall();
print "Result from process '$p': ",Dumper($r),"\n";
print "GRID::Machine::Process::Result objects are overloaded in a string context:\n$r\n";
view release on metacpan or search on metacpan
bin/wsutil.pl view on Meta::CPAN
-p use POST instead of GET
--post This is a boolean field and does not require an argument.
-k enable keepalives
--keepalive This is a boolean field and does not require an argument.
-o pass raw output from the service instead of trying to
--raw decode it as json This is a boolean field and does not
require an argument.
bin/wsutil.pl view on Meta::CPAN
my $args;
my $username;
my $realm;
my $timeout;
my $usePost;
my $use_keep_alive;
my $raw_output;
my $cookies_location;
my $service_cache_file;
my $name_services;
my $suppress_output;
bin/wsutil.pl view on Meta::CPAN
'u|username=s' => \$username,
'P|password=s' => \$password,
'r|realm=s' => \$realm,
't|timeout=i' => \$timeout,
'p|post' => \$usePost,
'k|keepalive' => \$use_keep_alive,
'o|raw' => \$raw_output,
'l|cookiejar=s' => \$cookies_location,
'c|servicecache=s' => \$service_cache_file,
'n|nameservice=s' => \$name_services,
'X|noresponse' => \$suppress_output,
bin/wsutil.pl view on Meta::CPAN
'uid' => $username,
'passwd' => $password,
'realm' => $realm,
'timeout' => $timeout,
'usePost' => $usePost,
'use_keep_alive' => $use_keep_alive,
'raw_output' => $raw_output,
'cookieJar' => HTTP::Cookies->new(
'file' => $cookies_location,
'autosave' => 1,
'ignore_discard' => 1,
view release on metacpan or search on metacpan
lib/GSM/SMS/NBS/Stack.pm view on Meta::CPAN
$VERSION = "0.161";
# $__NBSSTACK_PRINT++;
# Keep the packets alive for 1 day
$__TIME_TO_LIVE = 60*60*24;
# Constructor
sub new {
my $proto = shift;
view release on metacpan or search on metacpan
ChangeLog.pre-git view on Meta::CPAN
* t/GstClock.t, t/GstElement.t: Use alsasink instead of alsasrc
for the clock tests. Skip some tests that I'm unable to fix at
the moment.
* xs/GstClock.xs (gst2perl_clock_callback): Ref the clock id to
keep it alive. This should make GStreamer::Clock::wait_async work
correctly.
2006/01/29 kaffeetisch
* GStreamer.pm, NEWS: Release 0.06.
view release on metacpan or search on metacpan
lib/Game/Battleship.pm view on Meta::CPAN
}
}
}
# Do we have a winner?
my @alive = grep { $self->{players}{$_}->life } keys %{ $self->{players} };
$winner = @alive == 1 ? shift @alive : undef;
}
#warn $winner->name ." is the winner!\n";
return $winner;
}
lib/Game/Battleship.pm view on Meta::CPAN
=head2 play
$winner = $g->play;
Take a turn for each player, striking all the opponents, until there
is only one player left alive.
Return the C<Game::Battleship::Player> object that is the game
winner.
=head1 TO DO