view release on metacpan or search on metacpan
lib/Fetch.pm view on Meta::CPAN
L<Fetch::Future> objects that compose with the Hyperman event loop and other
CPAN loops (IO::Async, AnyEvent) - or with nothing at all, since Fetch ships
its own event loop (L<Fetch::Loop::Standalone>) and uses it automatically.
HTTP/1.1 and HTTP/2 (ALPN-negotiated over TLS), over cleartext and TLS, with
keep-alive connection pooling, redirect following, per-request timeouts,
streaming response bodies, a cookie jar, JSON request/response helpers, and
native WebSockets. Every request method returns a
L<Fetch::Future>; C<< ->get >> on one awaits it, pumping whichever event loop
is active (its own if none), so the same code serves both a simple synchronous
call and thousands of requests multiplexed on one loop.
lib/Fetch.pm view on Meta::CPAN
=item C<max_redirects>
How many redirects to follow. Default C<5>; C<0> disables following.
Overridable per request.
=item C<keep_alive>
Reuse connections via a keep-alive pool (default true). Set false to close
every connection after one request.
=item C<pool_size>
Maximum idle connections the keep-alive pool parks (default C<32>).
=item C<cookie_jar>
A L<Fetch::CookieJar> to store and send cookies (applied across redirects), or
a true scalar to create a fresh one. Default: no jar.
lib/Fetch.pm view on Meta::CPAN
The case it exists for is a B<per-request cookie jar>. A jar belongs to the
agent, so a jar on a long-lived agent is shared by every request that agent
serves: fine when the cookies authenticate the application itself, a
cross-request leak the moment they identify an end user. Building a whole fresh
agent per request avoids the leak but throws away the keep-alive pool and
re-resolves the loop adapter, which is most of what C<new> costs. A clone gives
you the isolation without the bill.
C<cookie_jar>, C<headers>, C<agent>, C<timeout>, C<tls_verify>,
C<max_redirects>, C<keep_alive> and C<simple_response> can be overridden;
C<< cookie_jar => undef >> drops an inherited jar. Headers are copied rather
than shared, so a clone cannot write into the parent's defaults.
C<loop> and C<pool_size> cannot be overridden and croak if given: they are what
the clone shares, and an agent on a different loop driving the parent's parked
connections would be reaching into the wrong one.
A clone holds references to the shared pool and loop, so they live until the
last agent using them goes. Keep the parent alive for as long as its clones, as
you would anyway.
=head1 ACCESSORS
=head2 loop
lib/Fetch.pm view on Meta::CPAN
=item C<ua_new(kv, nkv)>
Construct a Fetch user agent from C<nkv> flat key/value SVs (the same options
C<new> takes: C<loop>, C<pool_size>, C<tls_verify>, C<timeout>, C<agent>,
C<headers>, C<cookie_jar>, C<keep_alive>, C<max_redirects>,
C<simple_response>). Returns the blessed Fetch UA SV (+1 owned). A consumer may
instead call C<< Fetch->new >> from Perl once and cache the object; C<ua_new>
just removes that last Perl call.
=item C<request(ua_sv, method, url, hdrs, nhdrs, body, blen, timeout, max_redirects, map, ud)>
lib/Fetch.pm view on Meta::CPAN
=item C<request_stream(ua_sv, method, url, hdrs, nhdrs, body, blen, timeout, max_redirects, on_headers, on_body, on_done, ud)>
Like C<request>, but streams the response instead of buffering it: C<on_headers>
fires once up front with the status and header AV, C<on_body> once per body
chunk, and C<on_done> at completion (with success/failure). Returns the request
future SV (+1 owned) - keep it alive until C<on_done> fires. Lets a consumer
forward a large download or an endless SSE stream with flat memory.
=item C<tunnel_connect(host, port, tls, verify)> and friends
A raw blocking upstream TCP connection Fetch owns, for a proxy's
view release on metacpan or search on metacpan
lib/AptFetch.pm view on Meta::CPAN
=cut
=head1 DIAGNOSTICS
Most error communication is done through give-up codes.
However, some conditions aren't worth of keeping process alive -- those are
marked as B<(fatal)>.
Others are (mostly) in just B<fork>ed process that just couldn't boot
properly -- those are communicated back (somehow).
=over
view release on metacpan or search on metacpan
lib/File/Download.pm view on Meta::CPAN
my $self = shift;
my ($url) = @_;
my $file;
$self->{user_agent} = LWP::UserAgent->new(
agent => "File::Download/$VERSION ",
keep_alive => 1,
env_proxy => 1,
) if !$self->{user_agent};
my $ua = $self->{user_agent};
my $res = $ua->request(HTTP::Request->new(GET => $url),
sub {
view release on metacpan or search on metacpan
lib/File/Information/Lock.pm view on Meta::CPAN
Returns a new lock object. Requires an instance (L<File::Information>), a parent object (what is locked), and an unlock function.
If no instance is given C<$parent-E<gt>instance> is called to obtain one.
Once this lock is gone the unlock function is called. It is normally a private method of the object that is locked.
The unlock function is responsible of handling the case with multiple lock objects being alive at the same time. So any unlock function must check
if all locks are gone before performing an actual unlock. The unlock function is called on C<$parent> and passing the lock as first argument.
=head2 instance
my File::Information $instance = $lock->instance;
view release on metacpan or search on metacpan
lib/File/Locate/Iterator.pm view on Meta::CPAN
# position lets $it->rewind work on it too.
#
# fm
# When using mmap, a File::Locate::Iterator::FileMap object which is the
# cache entry for the database file, otherwise no such field. This is
# hung onto to keep it alive while in use. $self->{'mref'} is
# $fm->mmapref in this case.
#
# pos
# When mref is not undef, an integer offset into the $$mref string which
# is the current read position. The file header is checked in new() so
view release on metacpan or search on metacpan
lib/File/Lock/ParentLock.pm view on Meta::CPAN
}
return PERMITTED_LOCKED_BY_US if ($oldpid==$pid);
if ($pidmap{$oldpid}) {
# old pid still alive;
my $intermedpid=$pid;
my $counter=0;
my $counter_threshhold=70000;
while ($intermedpid and $counter++ <$counter_threshhold) {
if ($intermedpid==$oldpid) {
view release on metacpan or search on metacpan
lib/File/NFSLock.pm view on Meta::CPAN
###----------------------------------------------------------------###
my $graceful_sig = sub {
print STDERR "Received SIG$_[0]\n" if @_;
# Perl's exit should safely DESTROY any objects
# still "alive" before calling the real _exit().
exit 1;
};
our @CATCH_SIGS = qw(TERM INT);
view release on metacpan or search on metacpan
t/public_html/demo/civil.txt view on Meta::CPAN
business in which they are concerned; they are all peaceably inclined.
Now, what are they? Men at all? or small movable forts and
magazines, at the service of some unscrupulous man in power? Visit the
Navy-Yard, and behold a marine, such a man as an American government
can make, or such as it can make a man with its black arts- a mere
shadow and reminiscence of humanity, a man laid out alive and
standing, and already, as one may say, buried under arms with
funeral accompaniments, though it may be,
"Not a drum was heard, not a funeral note,
view release on metacpan or search on metacpan
t/public_html/demo/civil.txt view on Meta::CPAN
business in which they are concerned; they are all peaceably inclined.
Now, what are they? Men at all? or small movable forts and
magazines, at the service of some unscrupulous man in power? Visit the
Navy-Yard, and behold a marine, such a man as an American government
can make, or such as it can make a man with its black arts- a mere
shadow and reminiscence of humanity, a man laid out alive and
standing, and already, as one may say, buried under arms with
funeral accompaniments, though it may be,
"Not a drum was heard, not a funeral note,
view release on metacpan or search on metacpan
return newRV_noinc((SV *)meta);
}
/* Decode a Perl entry hashref into ArchiveEntry. The returned entry
* borrows pointers into SVs that must outlive the call - caller keeps
* the hash alive until write_add returns. */
static void
hv_to_entry(pTHX_ HV *h, ArchiveEntry *e,
ArchiveXattr *xattr_buf, size_t xattr_buf_n,
size_t *xattr_used)
{
if (!workers) {
close(err_r); close(err_w);
croak("File::Raw::Archive: out of memory");
}
/* Ignore SIGPIPE while workers are alive. A worker crash would
* otherwise SIGPIPE the parent on the next dispatch write. */
new_sa.sa_handler = SIG_IGN;
sigemptyset(&new_sa.sa_mask);
new_sa.sa_flags = 0;
sigaction(SIGPIPE, &new_sa, &old_sigpipe);
view release on metacpan or search on metacpan
lib/File/Raw.pm view on Meta::CPAN
} FilePluginContext;
=item B<FilePlugin>
Registration block; the caller owns the storage (typically a file-scope
static) and must keep it alive for as long as the plugin is registered.
typedef struct FilePlugin {
const char *name;
file_plugin_read_fn read_fn; /* NULL if not implemented */
file_plugin_write_fn write_fn;
view release on metacpan or search on metacpan
script/rsybak view on Meta::CPAN
#
#
#my @attributes;
#BEGIN {
# @attributes = qw(
# cookie_jar default_headers http_proxy https_proxy keep_alive
# local_address max_redirect max_size proxy no_proxy
# SSL_options verify_SSL
# );
# my %persist_ok = map {; $_ => 1 } qw(
# cookie_jar default_headers max_redirect max_size
script/rsybak view on Meta::CPAN
# my($class, %args) = @_;
#
# my $self = {
# max_redirect => 5,
# timeout => defined $args{timeout} ? $args{timeout} : 60,
# keep_alive => 1,
# verify_SSL => $args{verify_SSL} || $args{verify_ssl} || 0,
# no_proxy => $ENV{no_proxy},
# };
#
# bless $self, $class;
script/rsybak view on Meta::CPAN
# my $cb_args = @redir_args ? +{} : $args;
# my $data_cb = $self->_prepare_data_cb($response, $cb_args);
# $known_message_length = $handle->read_body($data_cb, $response);
# }
#
# if ( $self->{keep_alive}
# && $known_message_length
# && $response->{protocol} eq 'HTTP/1.1'
# && ($response->{headers}{connection} || '') ne 'close'
# ) {
# $self->{handle} = $handle;
script/rsybak view on Meta::CPAN
# my $handle = HTTP::Tiny::Handle->new(
# timeout => $self->{timeout},
# SSL_options => $self->{SSL_options},
# verify_SSL => $self->{verify_SSL},
# local_address => $self->{local_address},
# keep_alive => $self->{keep_alive}
# );
#
# if ($self->{_has_proxy}{$scheme} && ! grep { $host =~ /\Q$_\E$/ } @{$self->{no_proxy}}) {
# return $self->_proxy_connect( $request, $handle );
# }
script/rsybak view on Meta::CPAN
# }
#
# $request->{headers}{'host'} = $request->{host_port};
# $request->{headers}{'user-agent'} ||= $self->{agent};
# $request->{headers}{'connection'} = "close"
# unless $self->{keep_alive};
#
# if ( defined $args->{content} ) {
# if (ref $args->{content} eq 'CODE') {
# $request->{headers}{'content-type'} ||= "application/octet-stream";
# $request->{headers}{'transfer-encoding'} = 'chunked'
script/rsybak view on Meta::CPAN
# ) or die(qq/Could not connect to '$host:$port': $@\n/);
#
# binmode($self->{fh})
# or die(qq/Could not binmode() socket: '$!'\n/);
#
# if ( $self->{keep_alive} ) {
# unless ( defined( $self->{fh}->setsockopt( SOL_SOCKET, SO_KEEPALIVE, 1 ) ) ) {
# CORE::close($self->{fh});
# die(qq/Could not set SO_KEEPALIVE on socket: '$!'\n/);
# }
# }
view release on metacpan or search on metacpan
2008-10-10 Andreas J. Koenig <andreas.koenig.7os6VVqR@franz.ak.mind.de>
* Slaven suggests to have the current epoch or the whole current
recentfile available from the HTTP server and take it away with
keepalive. This direction goes the granularity down to subseconds.
We might want to rewrite everything to factor out transport and allow
the whole thing to run via HTTP.
2008-10-09 Andreas J. Koenig <andreas.koenig.7os6VVqR@franz.ak.mind.de>
view release on metacpan or search on metacpan
lib/File/Samba.pm view on Meta::CPAN
global:2:hide unreadable
global:2:homedir map
global:2:host msdfs
global:2:hosts equiv
global:2:interfaces
global:2:keepalive
global:2:kernel oplocks
global:2:lanman auth
global:2:large readwrite
global:2:ldap admin dn
global:2:ldap filter
lib/File/Samba.pm view on Meta::CPAN
global:3:idmap backend
global:3:idmap gid
global:3:idmap uid
global:3:include
global:3:interfaces
global:3:keepalive
global:3:kernel change notify
global:3:kernel oplocks
global:3:lanman auth
global:3:large readwrite
global:3:ldap admin dn
view release on metacpan or search on metacpan
lib/File/Scan/ClamAV.pm view on Meta::CPAN
return bless \%options, $class;
}
=head2 ping()
Pings the clamd to check it is alive. Returns true if it is alive, false if it is dead. Note that it is still possible for a race condition to occur between your test for ping() and any call to scan(). See below for more details.
On error nothing is returned and the errstr() error handler is set.
=cut
view release on metacpan or search on metacpan
lib/File/Unpack2.pm view on Meta::CPAN
# syscall number was unresolved this is skipped; then that narrow orphan window remains and
# such orphans must be cleaned up out of band (or the worker stopped via systemd
# KillMode=control-group, which reaps the whole cgroup).
eval { syscall($SYS_PRCTL, 1, POSIX::SIGKILL()) if $SYS_PRCTL; 1 };
# ... and put each helper in its own process group so _kill_family can reap the whole family
# (grandchildren included) while we are alive.
setpgrp(0, 0); # builtin; POSIX::setpgrp is unimplemented on modern perl
};
}
my $has_i_redir = 0;
view release on metacpan or search on metacpan
lib/File/Write/Rotate.pm view on Meta::CPAN
name => "$self->{prefix}-compress",
verify => 1,
);
my $latest_period = $files_ref->[-1][2];
if ($pid->alive) {
warn "Another compression is in progress";
} else {
my @tocompress;
#use DD; dd $self;
for my $file_ref (@{$files_ref}) {
view release on metacpan or search on metacpan
t/resources/filmaffinity-local-movie/410035.html view on Meta::CPAN
<dd>Cayo Largo Productions</dd>
<dt>Genre</dt>
<dd>
<span><a href="http://www.filmaffinity.com/en/moviegenre.php?genre=TH&attr=rat_count">Thriller</a></span> </dd>
<dt>Synopsis / Plot</dt>
<dd>Poker Run - Live to Ride, Ride to DIE! Robert and Allan are two upstanding lawyers, suburbanites, husbands caught in the grip of boring normalcy that sometimes plagues us all - the wife, the house, the cars, the debt. A quiet desperation ...
</dl>
<dl class="margin-top movie-info">
</dl>
<dl class="margin-top movie-info">
</dl>
view release on metacpan or search on metacpan
lib/Finance/Bank/Fubon/TW.pm view on Meta::CPAN
use Carp;
our $VERSION = '0.01';
use WWW::Mechanize;
our $ua = WWW::Mechanize->new(
env_proxy => 1,
keep_alive => 1,
timeout => 60,
);
sub check_balance {
my ($class, %opts) = @_;
view release on metacpan or search on metacpan
lib/Finance/Bank/IE/PermanentTSB.pm view on Meta::CPAN
}
}
if(!defined($agent)) {
$agent = WWW::Mechanize->new( env_proxy => 1, autocheck => 1,
keep_alive => 10);
$agent->env_proxy;
$agent->quiet(0);
$agent->agent('Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.12) Gecko/20071126 Fedora/1.5.0.12-7.fc6 Firefox/1.5.0.12' );
my $jar = $agent->cookie_jar();
$jar->{hide_cookie2} = 1;
view release on metacpan or search on metacpan
lib/Finance/Bank/IE.pm view on Meta::CPAN
my $self = shift;
if ( !$agent{$self} ) {
$agent{$self} = WWW::Mechanize->new( env_proxy => 1,
autocheck => 0,
keep_alive => 10 );
if ( !$agent{$self}) {
confess( "can't create agent" );
}
$agent{$self}->quiet( 0 );
}
view release on metacpan or search on metacpan
lib/Finance/Bank/LloydsTSB.pm view on Meta::CPAN
use Finance::Bank::LloydsTSB::utils qw(debug trim);
use Finance::Bank::LloydsTSB::Account;
our $ua = WWW::Mechanize->new(
env_proxy => 1,
keep_alive => 1,
timeout => 30,
autocheck => 1,
);
our $logged_in = 0;
view release on metacpan or search on metacpan
lib/Finance/Bank/Natwest/Connection.pm view on Meta::CPAN
$proxy{env_proxy} = 1;
}
$self->{ua} = LWP::UserAgent->new(
env_proxy => $proxy{env_proxy},
keep_alive => 1,
timeout => 30,
cookie_jar => {},
requests_redirectable => [ 'GET', 'HEAD', 'POST' ],
agent => "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)"
);
view release on metacpan or search on metacpan
lib/Finance/Bank/Postbank_de/APIv1.pm view on Meta::CPAN
has ua => (
is => 'ro',
default => sub( $self ) {
my $ua = WWW::Mechanize->new(
autocheck => 0,
keep_alive => 1,
cookie_jar => HTTP::CookieJar::LWP->new(),
);
if( $self->diagnostics ) {
require LWP::ConsoleLogger::Easy;
lib/Finance/Bank/Postbank_de/APIv1.pm view on Meta::CPAN
$ua->add_header(
'api-key' => $config->{'iob5-base'}->{apiKey},
'device-signature' => $config->{'iob5-base'}->{apiKey},
accept => ['application/hal+json', '*/*'],
keep_alive => 1,
# / businessCategory =Private Organization/ jurisdictionC =DE/ jurisdictionST =Hes...
"If-SSL-Cert-Subject" => $self->certificate_subject->{ api_public_postbank_de },
);
};
view release on metacpan or search on metacpan
lib/Finance/Bank/SCSB/TW.pm view on Meta::CPAN
my $ua;
sub ua {
return $ua if $ua;
$ua = WWW::Mechanize->new(
env_proxy => 1,
keep_alive => 1,
timeout => 60,
);
$ua->agent_alias("Mac Mozilla");
return $ua;
}
view release on metacpan or search on metacpan
lib/Finance/Bank/Schwab.pm view on Meta::CPAN
our $VERSION = '2.03';
our $ua = WWW::Mechanize->new(
env_proxy => 1,
keep_alive => 1,
timeout => 30,
cookie_jar => {},
);
# Debug logging:
view release on metacpan or search on metacpan
lib/Finance/BitStamp/Socket.pm view on Meta::CPAN
$self->frame(Protocol::WebSocket::Frame->new);
$self->{handle} = AnyEvent::Handle->new(
connect => [$self->host, $self->port],
tls => $self->tls,
tls_ctx => {verify => 0},
keepalive => 1,
wtimeout => 50,
on_connect => $self->on_connect,
on_read => $self->on_read,
on_wtimeout => $self->on_wtimeout,
on_error => $self->on_error,
view release on metacpan or search on metacpan
lib/Finance/Bitcoin/Feed/Pusher.pm view on Meta::CPAN
$self->frame(Protocol::WebSocket::Frame->new);
$self->{handle} = AnyEvent::Handle->new(
connect => [$self->host, $self->port],
tls => $self->tls,
tls_ctx => {verify => 0},
keepalive => 1,
wtimeout => 50,
on_connect => $self->on_connect,
on_read => $self->on_read,
on_wtimeout => $self->on_wtimeout,
on_error => $self->on_error,
view release on metacpan or search on metacpan
CompanyNames/TextSupport.pm view on Meta::CPAN
aligns
alike
aliment
aliments
alimony
alive
alkali
alkaline
alkalis
alkaloid
alkaloids