view release on metacpan or search on metacpan
lib/Perlbal/Plugin/PSGI.pm view on Meta::CPAN
'psgi.url_scheme' => 'http',
'psgi.nonblocking' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
REMOTE_ADDR => $pb->{peer_ip},
SERVER_NAME => $server_name,
SERVER_PORT => $server_port,
};
view release on metacpan or search on metacpan
lib/Perlito5X/Test2/API.pm view on Meta::CPAN
$hub->format(undef) if $hide;
}
}
elsif (! $parent->format) {
# If our parent has no format that means we're in a buffered subtest
# and now we're trying to run a streaming subtest. There's really no
# way for that to work, so we need to force the use of a buffered
# subtest here as
# well. https://github.com/Test-More/test-more/issues/721
$buffered = 1;
}
view release on metacpan or search on metacpan
t/01-basics.t view on Meta::CPAN
ok( my $oid = $o->pgblobs_create_blob() , "Blob is created");
ok( $oid = $o->pgblobs_store_blob('BINARYCONTENT') , "Something is stored in blob");
ok( my $rc = $o->pgblobs_fetch_blob($oid) , "Fetched content");
ok( $rc eq 'BINARYCONTENT' , "Same content was retrieved");
{
## A bit of cake streaming now
my $nslices = 1000;
my $cake;
my $read = sub{
unless( $nslices-- ){ return undef ;}
my $slice = int(rand(1000)) + 1 ;
view release on metacpan or search on metacpan
lib/Pg/Reindex.pm view on Meta::CPAN
SQL
my ($xlog_diff) = @{ query( '', $q )->[0] };
if ( $xlog_diff > $opt_throttle_on ) {
lg "streaming lag = $xlog_diff ==> pausing\n";
LOOP: {
do {
select undef, undef, undef, 1; ## no critic
($xlog_diff) = @{ query( '', $q )->[0] };
} while ( $xlog_diff > $opt_throttle_off );
lib/Pg/Reindex.pm view on Meta::CPAN
select undef, undef, undef, 1; ## no critic
($xlog_diff) = @{ query( '', $q )->[0] };
redo LOOP if $xlog_diff > $opt_throttle_off;
}
}
lg "streaming lag = $xlog_diff -- continuing\n";
}
return;
}
sub next_index {
lib/Pg/Reindex.pm view on Meta::CPAN
sub reindex {
my ( $oid, $nspname, $quoted_nspname, $idxname, $quoted_idxname, $idxdef,
$size, $opt_validate )
= @_;
throttle; # wait for streaming replicas to catch up
lg "Rebuilding Index $quoted_nspname.$quoted_idxname\n";
my @log_id;
@log_id = query '', $oid, <<'SQL' unless $opt_dryrun;
lib/Pg/Reindex.pm view on Meta::CPAN
It handles normal indexes and C<PRIMARY KEY>, C<FOREIGN KEY> and C<UNIQUE>
constraints.
=head2 Streaming replication and throttling
Before creating the next index, the streaming replication lag is checked to
be below a certain limit. If so, nothing special happens and the index is
built.
Otherwise, C<rebuild> waits for the replicas to catch up. When the lag
drops under a second limit, the C<rebuild> does not immediately continue.
lib/Pg/Reindex.pm view on Meta::CPAN
don't modify the database but print the essential SQL statements.
=item --high-txn-lag
the upper limit streaming replicas may lag behind in bytes.
Default is 10,000,000.
=item --low-txn-lag
view release on metacpan or search on metacpan
lib/Pinto/Remote/SelfContained.pm view on Meta::CPAN
chrome => $self->chrome,
httptiny => $self->httptiny,
);
}
sub run_streaming {
my ($self, $streaming_callback, $action_name, @args) = @_;
my $action = $self->make_action($action_name, @args);
$action->execute($streaming_callback);;
}
sub load_class_for_action {
my ($self, %args) = @_;
view release on metacpan or search on metacpan
t/data/usr/lib/pkgconfig/libarchive.pc view on Meta::CPAN
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include
Name: libarchive
Description: library that can create and read several streaming archive formats
Version: 2.8.4
Libs: -larchive
Libs.private: -lacl -lattr -lxml2 -llzma -lbz2 -lz -lxml2
view release on metacpan or search on metacpan
lib/Plack/App/CGIBin/Streaming.pm view on Meta::CPAN
}
sub serve_path {
my($self, $env, $file) = @_;
die "need a server that supports streaming" unless $env->{'psgi.streaming'};
my $app = $self->{_compiled}->{$file} ||= do {
local $0 = $file; # keep FindBin happy
$self->mkapp(CGI::Compile->compile($file));
lib/Plack/App/CGIBin/Streaming.pm view on Meta::CPAN
=encoding utf-8
=head1 NAME
Plack::App::CGIBin::Streaming - allow old style CGI applications to use
the plack streaming protocol
=head1 SYNOPSIS
in your F<app.psgi>:
view release on metacpan or search on metacpan
lib/Plack/App/CLI.pm view on Meta::CPAN
'psgi.version' => [1,1],
'psgi.errors' => $error,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::TRUE,
'psgi.streaming' => Plack::Util::FALSE,
'psgi.nonblocking' => Plack::Util::FALSE,
%ENV
};
view release on metacpan or search on metacpan
lib/Plack/App/DBI/Gofer.pm view on Meta::CPAN
=item * More tests
=item * Support http authorization (Basic and Digest)
=item * Support PSGI streaming and async.
=back
Please report any bugs or feature requests to
C<bug-plack-app-dbi-gofer@rt.cpan.org>, or through the web interface at
view release on metacpan or search on metacpan
# psgi.input *HTTP::Server::PSGI::$input (layers: scalar),
# psgi.multiprocess "",
# psgi.multithread "",
# psgi.nonblocking "",
# psgi.run_once "",
# psgi.streaming 1,
# psgi.url_scheme "http",
# psgi.version [
# [0] 1,
# [1] 1
# ],
view release on metacpan or search on metacpan
lib/Plack/App/FakeApache1/Handler.pm view on Meta::CPAN
'psgi.input' => $r,
'psgi.errors' => *STDERR,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
};
$class->fixup_path($r, $env);
view release on metacpan or search on metacpan
local/lib/perl5/HTTP/Message/PSGI.pm view on Meta::CPAN
'psgi.input' => $input,
'psgi.errors' => *STDERR,
'psgi.multithread' => $FALSE,
'psgi.multiprocess' => $FALSE,
'psgi.run_once' => $TRUE,
'psgi.streaming' => $TRUE,
'psgi.nonblocking' => $FALSE,
@_,
};
for my $field ( $req->headers->header_field_names ) {
view release on metacpan or search on metacpan
lib/Plack/App/Proxy/WebSocket.pm view on Meta::CPAN
my $req = Plack::Request->new($env);
# detect a protocol upgrade handshake or just proxy as usual
my $upgrade = $req->header('Upgrade') or return $self->SUPER::call($env);
$env->{'psgi.streaming'} or die "Plack server support for psgi.streaming is required";
my $client_fh = $env->{'psgix.io'} or die "Plack server support for the psgix.io extension is required";
my $url = $self->build_url_from_env($env) or return [502, [], ["Bad Gateway"]];
my $uri = URI->new($url);
lib/Plack/App/Proxy/WebSocket.pm view on Meta::CPAN
headers for the back-end request; see L</build_headers_from_env> for details.
This module has no configuration options beyond what L<Plack::App::Proxy>
requires or provides, so it may be an easy drop-in replacement. Read the
documentation of that module for advanced usage not covered here. Also, you
must use a L<PSGI> server that supports C<psgi.streaming> and C<psgix.io>.
For performance reasons, you should also use a C<psgi.nonblocking> server
(like L<Twiggy>) and the L<Plack::App::Proxy::Backend::AnyEvent::HTTP> user
agent back-end (which is the default, so no extra configuration is needed).
This module is B<EXPERIMENTAL>. I use it in development and it works
view release on metacpan or search on metacpan
lib/Plack/App/Proxy.pm view on Meta::CPAN
}
sub call {
my ($self, $env) = @_;
unless ($env->{'psgi.streaming'}) {
die "Plack::App::Proxy only runs with the server with psgi.streaming support";
}
my $url = $self->build_url_from_env($env)
or return [502, ["Content-Type","text/html"], ["Can't determine proxy remote URL"]];
view release on metacpan or search on metacpan
lib/Plack/App/RDF/Files.pm view on Meta::CPAN
iri('http://www.w3.org/2000/01/rdf-schema#Resource')
) ] );
}
# construct PSGI response
if ( $env->{'psgi.streaming'} ) {
$env->{'rdf.iterator'} = $iterator;
return sub {
my $responder = shift;
my $body = $self->_serialize_body( $serializer, $iterator );
$responder->( [ 200, $headers->headers, $body ] );
lib/Plack/App/RDF/Files.pm view on Meta::CPAN
The requested URI as string or L<URI> object.
=item rdf.iterator
The L<RDF::Trine::Iterator> that will be used for serializing, if
C<psgi.streaming> is set. One can use this variable to catch the RDF
data in another post-processing middleware.
=item rdf.files
An hash of source filenames, each with the number of triples (on success)
view release on metacpan or search on metacpan
lib/Plack/App/WebSocket.pm view on Meta::CPAN
}
}
sub call {
my ($self, $env) = @_;
if(!$env->{"psgi.streaming"} || !$env->{"psgi.nonblocking"} || !$env->{"psgix.io"}) {
$env->{$ERROR_ENV} = "not supported by the PSGI server";
return $self->{on_error}->($env);
}
my $cv_conn = $self->{websocket_server}->establish_psgi($env, $env->{"psgix.io"});
return sub {
lib/Plack/App/WebSocket.pm view on Meta::CPAN
=over
=item *
C<psgi.streaming> environment is true.
=item *
C<psgi.nonblocking> environment is true, and the server supports L<AnyEvent>.
view release on metacpan or search on metacpan
lib/Plack/Client/Backend/psgi_local.pm
t/00-compile.t
t/01-basic.t
t/02-inputs.t
t/03-delayed-response.t
t/04-streaming.t
t/lib/Plack/Client/Test.pm
t/release-eol.t
t/release-no-tabs.t
t/release-pod-coverage.t
t/release-pod-syntax.t
view release on metacpan or search on metacpan
lib/Plack/Middleware/Debugger/Injector.pm view on Meta::CPAN
sub handle_html_content_type {
my ($self, $env, $resp) = @_;
# content to be inserted ...
my $content = $self->get_content_to_insert( $env );
# if the response is not a streaming one ...
if ( (scalar @$resp) == 3 && ref $resp->[2] eq 'ARRAY' ) {
# adjust Content-Length if we have it ...
if ( my $content_length = Plack::Util::header_get( $resp->[1], 'Content-Length' ) ) {
Plack::Util::header_set( $resp->[1], 'Content-Length', $content_length + length($content) );
lib/Plack/Middleware/Debugger/Injector.pm view on Meta::CPAN
last;
}
return $resp;
}
# if we have streaming response, just do what is sensible
else {
# NOTE:
# Plack will remove the Content-Length header
# if it has a streaming response, so there is
# no need to worry about that at all.
# - SL
return sub {
my $chunk = shift;
return unless defined $chunk;
lib/Plack/Middleware/Debugger/Injector.pm view on Meta::CPAN
If we detect a PSGI response which is an array of strings, we will process
it (in reverse) looking for the closing C<<body>> tag and inject the
content accordingly.
All other PSGI responses will be handled as if they are streaming
responses, in which case we simple return a C<CODE> reference that will
process the stream and if a closing C<<body>> tag is found, inject
accordingly.
=item C<application/json>
view release on metacpan or search on metacpan
lib/Plack/Handler/AnyEvent/FCGI.pm view on Meta::CPAN
'psgi.input' => do { open my $io, "<", \$request->read_stdin || \''; $io },
'psgi.errors' => io_from_write_cb sub { $request->print_stderr(@_) },
'psgi.multithread' => 0,
'psgi.multiprocess' => 0,
'psgi.run_once' => 0,
'psgi.streaming' => 1,
'psgi.nonblocking' => 1,
'psgix.input.buffered' => 1,
};
my $res = Plack::Util::run_app($app, $env);
view release on metacpan or search on metacpan
lib/Plack/Handler/AnyEvent/HTTPD.pm view on Meta::CPAN
SERVER_PROTOCOL => 'HTTP/1.0', # no way to get this from HTTPConnection
'psgi.version' => [ 1, 1 ],
'psgi.errors' => *STDERR,
'psgi.url_scheme' => 'http',
'psgi.nonblocking' => Plack::Util::TRUE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::FALSE,
'psgi.input' => do {
open my $input, "<", \(ref $cont ? '' : $cont);
view release on metacpan or search on metacpan
lib/Plack/Handler/AnyEvent/ReverseHTTP.pm view on Meta::CPAN
if (my $client = delete $env->{HTTP_REQUESTING_CLIENT}) {
@{$env}{qw( REMOTE_ADDR REMOTE_PORT )} = split /:/, $client, 2;
}
$env->{'psgi.nonblocking'} = Plack::Util::TRUE;
$env->{'psgi.streaming'} = Plack::Util::TRUE;
$env->{'psgi.multithread'} = Plack::Util::FALSE;
$env->{'psgi.multiprocess'} = Plack::Util::FALSE;
$env->{'psgi.run_once'} = Plack::Util::FALSE;
my $r = $app->($env);
view release on metacpan or search on metacpan
lib/Plack/Handler/AnyEvent/SCGI.pm view on Meta::CPAN
'psgi.input' => do { open my $io, "<", $content_r || \''; $io },
'psgi.errors' => *STDERR,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::FALSE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::TRUE,
'psgix.input.buffered' => Plack::Util::TRUE,
};
my $res = Plack::Util::run_app $app, $env;
view release on metacpan or search on metacpan
lib/Plack/Handler/CLI.pm view on Meta::CPAN
'psgi.input' => $self->stdin,
'psgi.errors' => $self->stderr,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::TRUE,
'psgi.streaming' => Plack::Util::FALSE,
'psgi.nonblocking' => Plack::Util::FALSE,
%ENV, # override
);
$env{SCRIPT_NAME} = '' if $env{SCRIPT_NAME} eq '/';
view release on metacpan or search on metacpan
lib/Plack/Handler/FCGI/EV.pm view on Meta::CPAN
SCRIPT_NAME => '',
'psgi.version' => [ 1, 0 ],
'psgi.errors' => *STDERR,
'psgi.url_scheme' => 'http',
'psgi.nonblocking' => 1,
'psgi.streaming' => 1,
'psgi.multithread' => 0,
'psgi.multiprocess' => 1,
'psgi.run_once' => 0,
'psgix.input.buffered' => 1,
%$env,
view release on metacpan or search on metacpan
lib/Plack/Handler/H2.pm view on Meta::CPAN
Negotiation). Supports OpenSSL 1.1.1+ and 3.0+. Automatically generates
self-signed certificates for development.
=item * B<Streaming Responses>
Full support for PSGI streaming and delayed responses, including chunked
transfer without Content-Length, progressive rendering, and server-sent
events compatibility.
=item * B<Asynchronous I/O>
lib/Plack/Handler/H2.pm view on Meta::CPAN
=back
=head1 STREAMING RESPONSES
Plack::Handler::H2 fully supports PSGI streaming responses using the delayed
response pattern. This is useful for:
=over 4
=item * Large responses that don't fit in memory
lib/Plack/Handler/H2.pm view on Meta::CPAN
=over 4
=item 1. B<H2.pm> - High-level Perl interface
PSGI handler implementation, configuration management, self-signed certificate
generation, and streaming response coordination.
=item 2. B<H2.xs> - XS bindings layer
Efficient Perl-to-C++ interface, type conversion and marshalling, and function
wrappers for core operations.
view release on metacpan or search on metacpan
lib/Plack/Handler/Net/FastCGI.pm view on Meta::CPAN
'psgi.input' => $stdin,
'psgi.errors' => $stderr,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::FALSE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
};
delete $env->{HTTP_CONTENT_TYPE};
delete $env->{HTTP_CONTENT_LENGTH};
view release on metacpan or search on metacpan
lib/Plack/Handler/SCGI.pm view on Meta::CPAN
'psgi.input' => $request->connection,
'psgi.errors' => *STDERR,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
'psgix.input.buffered' => Plack::Util::FALSE,
};
my $res = Plack::Util::run_app $app, $env;
view release on metacpan or search on metacpan
lib/Plack/Handler/Stomp.pm view on Meta::CPAN
'psgi.url_scheme' => 'http',
'psgi.multithread' => 0,
'psgi.multiprocess' => 0,
'psgi.run_once' => 0,
'psgi.nonblocking' => 0,
'psgi.streaming' => 1,
'psgi.input' => do {
open my $input, '<', \($frame->body);
$input;
},
'psgi.errors' => Plack::Util::inline_object(
lib/Plack/Handler/Stomp.pm view on Meta::CPAN
'psgi.url_scheme' => 'http',
'psgi.multithread' => 0,
'psgi.multiprocess' => 0,
'psgi.run_once' => 0,
'psgi.nonblocking' => 0,
'psgi.streaming' => 1,
In addition, reading from C<psgi.input> will return the message body,
and writing to C<psgi.errors> will log via the L</logger> at level
C<error>.
view release on metacpan or search on metacpan
- Fix request_duration calculation for delayed responses (nfg)
0.001001 2018-02-08 22:16:54+01:00 Europe/Zurich
- Fix streaming server support
0.001000 2012-11-24 16:41:05 Europe/Zurich
- Initial release
view release on metacpan or search on metacpan
lib/HTTP/Message/PSGI.pm view on Meta::CPAN
'psgi.input' => $input,
'psgi.errors' => *STDERR,
'psgi.multithread' => $FALSE,
'psgi.multiprocess' => $FALSE,
'psgi.run_once' => $TRUE,
'psgi.streaming' => $TRUE,
'psgi.nonblocking' => $FALSE,
@_,
};
for my $field ( $req->headers->header_field_names ) {