Plack-App-MCCS
view release on metacpan or search on metacpan
local/bin/streamzip view on Meta::CPAN
Usage()
if @ARGV;
my @extraOpts = ();
if ($compression_method == ZIP_CM_DEFLATE && defined $level)
{
push @extraOpts, (Level => $level)
}
# force streaming zip file when writing to stdout.
$stream = 1
if $zipfile eq '-';
zip '-' => $zipfile,
Name => $memberName,
Zip64 => $zip64,
Method => $compression_method,
Stream => $stream,
@extraOpts
or die "Error creating zip file '$zipfile': $\n" ;
local/bin/streamzip view on Meta::CPAN
producer | streamzip [opts] | consumer
producer | streamzip [opts] -zipfile=output.zip
=head1 DESCRIPTION
This program will read data from C<stdin>, compress it into a zip container
and, by default, write a I<streamed> zip file to C<stdout>. No temporary
files are created.
The zip container written to C<stdout> is, by necessity, written in
streaming format. Most programs that read Zip files can cope with a
streamed zip file, but if interoperability is important, and your workflow
allows you to write the zip file directly to disk you can create a
non-streamed zip file using the C<zipfile> option.
=head2 OPTIONS
=over 5
=item -zip64
local/bin/zipdetails view on Meta::CPAN
$ExtraContext{InCentralDir} = 0;
walkExtra($extraLength, \%ExtraContext);
}
my @msg ;
# if ($cdZip64 && ! $ZIP64)
# {
# # Central directory said this was Zip64
# # some zip files don't have the Zip64 field in the local header
# # seems to be a streaming issue.
# push @msg, "Missing Zip64 extra field in Local Header #$hexHdrCount\n";
# if (! $zip64Sizes)
# {
# # Central has a ZIP64 entry that doesn't have sizes
# # Local doesn't have a Zip 64 at all
# push @msg, "Unzip may complain about 'overlapped components' #$hexHdrCount\n";
# }
# else
# {
local/lib/perl5/HTTP/Message/PSGI.pm view on Meta::CPAN
REMOTE_PORT => int( rand(64000) + 1000 ), # not in RFC 3875
REQUEST_URI => $uri->path_query || '/', # not in RFC 3875
REQUEST_METHOD => $req->method,
'psgi.version' => [ 1, 1 ],
'psgi.url_scheme' => $uri->scheme eq 'https' ? 'https' : 'http',
'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 ) {
my $key = uc("HTTP_$field");
$key =~ tr/-/_/;
$key =~ s/^HTTP_// if $field =~ /^Content-(Length|Type)$/;
unless ( exists $env->{$key} ) {
local/lib/perl5/HTTP/Server/PSGI.pm view on Meta::CPAN
SERVER_NAME => $self->{host},
SCRIPT_NAME => '',
REMOTE_ADDR => $conn->peerhost,
REMOTE_PORT => $conn->peerport || 0,
'psgi.version' => [ 1, 1 ],
'psgi.errors' => *STDERR,
'psgi.url_scheme' => $self->{ssl} ? 'https' : 'http',
'psgi.run_once' => Plack::Util::FALSE,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
'psgix.harakiri' => Plack::Util::TRUE,
'psgix.input.buffered' => Plack::Util::TRUE,
'psgix.io' => $conn,
};
$self->handle_connection($env, $conn, $app);
$conn->close;
last if $env->{'psgix.harakiri.commit'};
}
local/lib/perl5/IO/Compress/Bzip2.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot Examples
Here are a few example that show the capabilities of the module.
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities of the module.
The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
$ echo hello world | perl -MIO::Compress::Bzip2=bzip2 -e 'bzip2 \*STDIN => \*STDOUT' >output.bz2
The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
so the above can be rewritten as
$ echo hello world | perl -MIO::Compress::Bzip2=bzip2 -e 'bzip2 "-" => "-"' >output.bz2
=head3 Compressing a file from the filesystem
local/lib/perl5/IO/Compress/Bzip2.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
my $z = IO::Compress::Bzip2->new("-", Stream => 1)
or die "IO::Compress::Bzip2 failed: $Bzip2Error\n";
local/lib/perl5/IO/Compress/Deflate.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot Examples
Here are a few example that show the capabilities of the module.
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities of the module.
The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
$ echo hello world | perl -MIO::Compress::Deflate=deflate -e 'deflate \*STDIN => \*STDOUT' >output.1950
The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
so the above can be rewritten as
$ echo hello world | perl -MIO::Compress::Deflate=deflate -e 'deflate "-" => "-"' >output.1950
=head3 Compressing a file from the filesystem
local/lib/perl5/IO/Compress/Deflate.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Deflate qw(deflate $DeflateError) ;
my $z = IO::Compress::Deflate->new("-", Stream => 1)
or die "IO::Compress::Deflate failed: $DeflateError\n";
local/lib/perl5/IO/Compress/Gzip.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot Examples
Here are a few example that show the capabilities of the module.
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities of the module.
The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
$ echo hello world | perl -MIO::Compress::Gzip=gzip -e 'gzip \*STDIN => \*STDOUT' >output.gz
The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
so the above can be rewritten as
$ echo hello world | perl -MIO::Compress::Gzip=gzip -e 'gzip "-" => "-"' >output.gz
=head3 Compressing a file from the filesystem
local/lib/perl5/IO/Compress/Gzip.pm view on Meta::CPAN
The ID header in an C<ExtraField> sub-field can consist of any two bytes.
=back
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Gzip qw(gzip $GzipError) ;
my $z = IO::Compress::Gzip->new("-", Stream => 1)
or die "IO::Compress::Gzip failed: $GzipError\n";
local/lib/perl5/IO/Compress/RawDeflate.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot Examples
Here are a few example that show the capabilities of the module.
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities of the module.
The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
$ echo hello world | perl -MIO::Compress::RawDeflate=rawdeflate -e 'rawdeflate \*STDIN => \*STDOUT' >output.1951
The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
so the above can be rewritten as
$ echo hello world | perl -MIO::Compress::RawDeflate=rawdeflate -e 'rawdeflate "-" => "-"' >output.1951
=head3 Compressing a file from the filesystem
local/lib/perl5/IO/Compress/RawDeflate.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
my $z = IO::Compress::RawDeflate->new("-", Stream => 1)
or die "IO::Compress::RawDeflate failed: $RawDeflateError\n";
local/lib/perl5/IO/Compress/Zip.pm view on Meta::CPAN
*$self->{ZipData}{Version} = $version;
*$self->{ZipData}{MadeBy} = $madeBy;
my $ifa = 0;
$ifa |= ZIP_IFA_TEXT_MASK
if $param->getValue('textflag');
$hdr .= pack "V", ZIP_LOCAL_HDR_SIG ; # signature
$hdr .= pack 'v', $extract ; # extract Version & OS
$hdr .= pack 'v', $gpFlag ; # general purpose flag (set streaming mode)
$hdr .= pack 'v', $method ; # compression method (deflate)
$hdr .= pack 'V', $time ; # last mod date/time
$hdr .= pack 'V', 0 ; # crc32 - 0 when streaming
$hdr .= pack 'V', $empty ; # compressed length - 0 when streaming
$hdr .= pack 'V', $empty ; # uncompressed length - 0 when streaming
$hdr .= pack 'v', length $filename ; # filename length
$hdr .= pack 'v', length $extra ; # extra length
$hdr .= $filename ;
# Remember the offset for the compressed & uncompressed lengths in the
# local header.
if (*$self->{ZipData}{Zip64}) {
*$self->{ZipData}{SizesOffset} = *$self->{ZipData}{Offset}->get64bit()
+ length($hdr) + 4 ;
local/lib/perl5/IO/Compress/Zip.pm view on Meta::CPAN
}
$hdr .= $extra ;
my $ctl = '';
$ctl .= pack "V", ZIP_CENTRAL_HDR_SIG ; # signature
$ctl .= pack 'v', $madeBy ; # version made by
$ctl .= pack 'v', $extract ; # extract Version
$ctl .= pack 'v', $gpFlag ; # general purpose flag (streaming mode)
$ctl .= pack 'v', $method ; # compression method (deflate)
$ctl .= pack 'V', $time ; # last mod date/time
$ctl .= pack 'V', 0 ; # crc32
$ctl .= pack 'V', $empty ; # compressed length
$ctl .= pack 'V', $empty ; # uncompressed length
$ctl .= pack 'v', length $filename ; # filename length
*$self->{ZipData}{ExtraOffset} = length $ctl;
*$self->{ZipData}{ExtraSize} = length $ctlExtra ;
local/lib/perl5/IO/Compress/Zip.pm view on Meta::CPAN
seek $z, $position, $whence
binmode $z
fileno $z
close $z ;
=head1 DESCRIPTION
This module provides a Perl interface that allows writing zip
compressed data to files or buffer.
The primary purpose of this module is to provide streaming write access to
zip files and buffers.
At present the following compression methods are supported by IO::Compress::Zip
=over 5
=item Store (0)
=item Deflate (8)
local/lib/perl5/IO/Compress/Zip.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot Examples
Here are a few example that show the capabilities of the module.
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities of the module.
The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
$ echo hello world | perl -MIO::Compress::Zip=zip -e 'zip \*STDIN => \*STDOUT' >output.zip
The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
so the above can be rewritten as
$ echo hello world | perl -MIO::Compress::Zip=zip -e 'zip "-" => "-"' >output.zip
One problem with creating a zip archive directly from STDIN can be demonstrated by looking at
local/lib/perl5/IO/Compress/Zip.pm view on Meta::CPAN
If specified, this option will disable the creation of all extra fields
in the zip local and central headers. So the C<exTime>, C<exUnix2>,
C<exUnixN>, C<ExtraFieldLocal> and C<ExtraFieldCentral> options will
be ignored.
This parameter defaults to 0.
=item C<< Stream => 0|1 >>
This option controls whether the zip file/buffer output is created in
streaming mode.
Note that when outputting to a file with streaming mode disabled (C<Stream>
is 0), the output file must be seekable.
The default is 1.
=item C<< Zip64 => 0|1 >>
Create a Zip64 zip file/buffer. This option is used if you want
to store files larger than 4 Gig or store more than 64K files in a single
zip archive.
local/lib/perl5/IO/Compress/Zip.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Zip qw(zip $ZipError) ;
my $z = IO::Compress::Zip->new("-", Stream => 1)
or die "IO::Compress::Zip failed: $ZipError\n";
local/lib/perl5/IO/Compress/Zstd.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot Examples
Here are a few example that show the capabilities of the module.
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities of the module.
The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
$ echo hello world | perl -MIO::Compress::Zstd=zstd -e 'zstd \*STDIN => \*STDOUT' >output.zst
The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
so the above can be rewritten as
$ echo hello world | perl -MIO::Compress::Zstd=zstd -e 'zstd "-" => "-"' >output.zst
=head3 Compressing a file from the filesystem
local/lib/perl5/IO/Compress/Zstd.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Zstd qw(zstd $ZstdError) ;
my $z = IO::Compress::Zstd->new("-", Stream => 1)
or die "IO::Compress::Zstd failed: $ZstdError\n";
local/lib/perl5/IO/Uncompress/Adapter/Identity.pm view on Meta::CPAN
use IO::Compress::Zip::Constants ;
our ($VERSION);
$VERSION = '2.206';
use Compress::Raw::Zlib 2.206 ();
sub mkUncompObject
{
my $streaming = shift;
my $zip64 = shift;
my $crc32 = 1; #shift ;
my $adler32 = shift;
bless { 'CompSize' => U64->new(), # 0,
'UnCompSize' => 0,
'wantCRC32' => $crc32,
'CRC32' => Compress::Raw::Zlib::crc32(''),
'wantADLER32'=> $adler32,
'ADLER32' => Compress::Raw::Zlib::adler32(''),
'ConsumesInput' => 1,
'Streaming' => $streaming,
'Zip64' => $zip64,
'DataHdrSize' => $zip64 ? 24 : 16,
'Pending' => '',
} ;
}
sub uncompr
{
local/lib/perl5/IO/Uncompress/Unzip.pm view on Meta::CPAN
my $filename_length = unpack ("v", substr($buffer, 26-4, 2));
my $extra_length = unpack ("v", substr($buffer, 28-4, 2));
my $filename;
my $extraField;
my @EXTRA = ();
# Some programs (some versions of LibreOffice) mark entries as streamed, but still fill out
# compressedLength/uncompressedLength & crc32 in the local file header.
# The expected data descriptor is not populated.
# So only assume streaming if the Streaming bit is set AND the compressed length is zero
my $streamingMode = (($gpFlag & ZIP_GP_FLAG_STREAMING_MASK) && $crc32 == 0) ? 1 : 0 ;
my $efs_flag = ($gpFlag & ZIP_GP_FLAG_LANGUAGE_ENCODING) ? 1 : 0;
return $self->HeaderError("Encrypted content not supported")
if $gpFlag & (ZIP_GP_FLAG_ENCRYPTED_MASK|ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK);
return $self->HeaderError("Patch content not supported")
if $gpFlag & ZIP_GP_FLAG_PATCHED_MASK;
*$self->{ZipData}{Streaming} = $streamingMode;
if ($filename_length)
{
$self->smartReadExact(\$filename, $filename_length)
or return $self->TruncatedHeader("Filename");
if (*$self->{UnzipData}{efs} && $efs_flag && $] >= 5.008004)
{
require Encode;
local/lib/perl5/IO/Uncompress/Unzip.pm view on Meta::CPAN
if (defined $Extra{ZIP_EXTRA_ID_ZIP64()})
{
$zip64 = 1 ;
my $buff = ${ $Extra{ZIP_EXTRA_ID_ZIP64()} };
# This code assumes that all the fields in the Zip64
# extra field aren't necessarily present. The spec says that
# they only exist if the equivalent local headers are -1.
if (! $streamingMode) {
my $offset = 0 ;
if (U64::full32 $uncompressedLength->get32bit() ) {
$uncompressedLength
= U64::newUnpack_V64 substr($buff, 0, 8);
$offset += 8 ;
}
if (U64::full32 $compressedLength->get32bit() ) {
local/lib/perl5/IO/Uncompress/Unzip.pm view on Meta::CPAN
= U64::newUnpack_V64 substr($buff, $offset, 8);
$offset += 8 ;
}
}
}
}
*$self->{ZipData}{Zip64} = $zip64;
if (! $streamingMode) {
*$self->{ZipData}{Streaming} = 0;
*$self->{ZipData}{Crc32} = $crc32;
*$self->{ZipData}{CompressedLen} = $compressedLength;
*$self->{ZipData}{UnCompressedLen} = $uncompressedLength;
*$self->{CompressedInputLengthRemaining} =
*$self->{CompressedInputLength} = $compressedLength->get64bit();
}
*$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef);
*$self->{ZipData}{Method} = $compressedMethod;
local/lib/perl5/IO/Uncompress/Unzip.pm view on Meta::CPAN
$self->smartReadExact(\$LzmaHeader, 4)
or return $self->saveErrorString(undef, "Truncated file");
my ($verHi, $verLo) = unpack ("CC", substr($LzmaHeader, 0, 2));
my $LzmaPropertiesSize = unpack ("v", substr($LzmaHeader, 2, 2));
my $LzmaPropertyData;
$self->smartReadExact(\$LzmaPropertyData, $LzmaPropertiesSize)
or return $self->saveErrorString(undef, "Truncated file");
if (! $streamingMode) {
*$self->{ZipData}{CompressedLen}->subtract(4 + $LzmaPropertiesSize) ;
*$self->{CompressedInputLengthRemaining} =
*$self->{CompressedInputLength} = *$self->{ZipData}{CompressedLen}->get64bit();
}
my $obj =
IO::Uncompress::Adapter::UnLzma::mkUncompZipObject($LzmaPropertyData);
*$self->{Uncomp} = $obj;
}
elsif ($compressedMethod == ZIP_CM_STORE)
{
*$self->{Type} = 'zip-stored';
my $obj =
IO::Uncompress::Adapter::Identity::mkUncompObject($streamingMode,
$zip64);
*$self->{Uncomp} = $obj;
}
else
{
return $self->HeaderError("Unsupported Compression format $compressedMethod");
}
return {
'Type' => 'zip',
'FingerprintLength' => 4,
#'HeaderLength' => $compressedMethod == 8 ? length $keep : 0,
'HeaderLength' => length $keep,
'Zip64' => $zip64,
'TrailerLength' => ! $streamingMode ? 0 : $zip64 ? 24 : 16,
'Header' => $keep,
'CompressedLength' => $compressedLength ,
'UncompressedLength' => $uncompressedLength ,
'CRC32' => $crc32 ,
'Name' => $filename,
'efs' => $efs_flag, # language encoding flag
'Time' => _dosToUnixTime($lastModTime),
'Stream' => $streamingMode,
'MethodID' => $compressedMethod,
'MethodName' => $MethodNames{$compressedMethod} || 'Unknown',
# 'TextFlag' => $flag & GZIP_FLG_FTEXT ? 1 : 0,
# 'HeaderCRCFlag' => $flag & GZIP_FLG_FHCRC ? 1 : 0,
# 'NameFlag' => $flag & GZIP_FLG_FNAME ? 1 : 0,
# 'CommentFlag' => $flag & GZIP_FLG_FCOMMENT ? 1 : 0,
# 'ExtraFlag' => $flag & GZIP_FLG_FEXTRA ? 1 : 0,
# 'Comment' => $comment,
local/lib/perl5/IO/Uncompress/Unzip.pm view on Meta::CPAN
eof($z)
close($z)
=head1 DESCRIPTION
This module provides a Perl interface that allows the reading of
zlib files/buffers.
For writing zip files/buffers, see the companion module IO::Compress::Zip.
The primary purpose of this module is to provide I<streaming> read access to
zip files and buffers.
At present the following compression methods are supported by IO::Uncompress::Unzip
=over 5
=item Store (0)
=item Deflate (8)
local/lib/perl5/LWP/media.types view on Meta::CPAN
application/vnd.oasis.opendocument.presentation odp
application/vnd.oasis.opendocument.presentation-template otp
application/vnd.oasis.opendocument.spreadsheet ods
application/vnd.oasis.opendocument.spreadsheet-template ots
application/vnd.oasis.opendocument.text odt
application/vnd.oasis.opendocument.text-master odm
application/vnd.oasis.opendocument.text-template ott
application/vnd.oasis.opendocument.text-web oth
# application/vnd.obn
# application/vnd.oipf.contentaccessdownload+xml
# application/vnd.oipf.contentaccessstreaming+xml
# application/vnd.oipf.cspg-hexbinary
# application/vnd.oipf.dae.svg+xml
# application/vnd.oipf.dae.xhtml+xml
# application/vnd.oipf.mippvcontrolmessage+xml
# application/vnd.oipf.pae.gem
# application/vnd.oipf.spdiscovery+xml
# application/vnd.oipf.spdlist+xml
# application/vnd.oipf.ueprofile+xml
# application/vnd.oipf.userprofile+xml
application/vnd.olpc-sugar xo
local/lib/perl5/Plack/Handler/Apache1.pm view on Meta::CPAN
my $env = {
%ENV,
'psgi.version' => [ 1, 1 ],
'psgi.url_scheme' => ($ENV{HTTPS}||'off') =~ /^(?:on|1)$/i ? 'https' : 'http',
'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,
'psgix.harakiri' => Plack::Util::TRUE,
};
if (defined(my $HTTP_AUTHORIZATION = $r->headers_in->{Authorization})) {
$env->{HTTP_AUTHORIZATION} = $HTTP_AUTHORIZATION;
}
my $vpath = $env->{SCRIPT_NAME} . ($env->{PATH_INFO} || '');
local/lib/perl5/Plack/Handler/Apache2.pm view on Meta::CPAN
my $env = {
%ENV,
'psgi.version' => [ 1, 1 ],
'psgi.url_scheme' => ($ENV{HTTPS}||'off') =~ /^(?:on|1)$/i ? 'https' : 'http',
'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,
'psgix.harakiri' => Plack::Util::TRUE,
'psgix.cleanup' => Plack::Util::TRUE,
'psgix.cleanup.handlers' => [],
};
if (defined(my $HTTP_AUTHORIZATION = $r->headers_in->{Authorization})) {
$env->{HTTP_AUTHORIZATION} = $HTTP_AUTHORIZATION;
}
local/lib/perl5/Plack/Handler/CGI.pm view on Meta::CPAN
my $env = {
%ENV,
'psgi.version' => [ 1, 1 ],
'psgi.url_scheme' => ($ENV{HTTPS}||'off') =~ /^(?:on|1)$/i ? 'https' : 'http',
'psgi.input' => *STDIN,
'psgi.errors' => *STDERR,
'psgi.multithread' => 0,
'psgi.multiprocess' => 1,
'psgi.run_once' => 1,
'psgi.streaming' => 1,
'psgi.nonblocking' => 1,
%{ $override_env },
};
delete $env->{HTTP_CONTENT_TYPE};
delete $env->{HTTP_CONTENT_LENGTH};
$env->{'HTTP_COOKIE'} ||= $ENV{COOKIE}; # O'Reilly server bug
if (!exists $env->{PATH_INFO}) {
$env->{PATH_INFO} = '';
local/lib/perl5/Plack/Handler/FCGI.pm view on Meta::CPAN
my $env = {
%env,
'psgi.version' => [1,1],
'psgi.url_scheme' => ($env{HTTPS}||'off') =~ /^(?:on|1)$/i ? 'https' : 'http',
'psgi.input' => $self->{stdin},
'psgi.errors' =>
($self->{keep_stderr} ? \*STDERR : $self->{stderr}),
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => defined $proc_manager,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
'psgix.harakiri' => defined $proc_manager,
'psgix.cleanup' => 1,
'psgix.cleanup.handlers' => [],
};
delete $env->{HTTP_CONTENT_TYPE};
delete $env->{HTTP_CONTENT_LENGTH};
# lighttpd munges multiple slashes in PATH_INFO into one. Try recovering it
local/lib/perl5/Plack/Loader/Shotgun.pm view on Meta::CPAN
close $read;
waitpid($pid, 0);
return $res;
} else {
# child
close $read;
my $res;
try {
$env->{'psgi.streaming'} = 0;
$res = $self->{builder}->()->($env);
my @body;
Plack::Util::foreach($res->[2], sub { push @body, $_[0] });
$res->[2] = \@body;
} catch {
$env->{'psgi.errors'}->print($_);
$res = [ 500, [ "Content-Type", "text/plain" ], [ "Internal Server Error" ] ];
};
print {$write} Storable::freeze($res);
local/lib/perl5/Plack/Middleware.pm view on Meta::CPAN
sub call {
my($self, $env) = @_;
# pre-processing $env
my $res = $self->app->($env);
# post-processing $res
return $res;
}
The tricky thing about post-processing the response is that it could
either be an immediate 3 element array ref, or a code reference that
implements the delayed (streaming) interface.
Dealing with these two types of response in each piece of middleware
is pointless, so you're recommended to use the C<response_cb> wrapper
function in L<Plack::Util> when implementing a post processing
middleware.
sub call {
my($self, $env) = @_;
# pre-processing $env
my $res = $self->app->($env);
local/lib/perl5/Plack/Middleware.pm view on Meta::CPAN
do:
Plack::Util::response_cb($res, sub {
my $res = shift;
@$res = ($new_status, $new_headers, $new_body); # THIS WORKS
return;
});
The third element of the response array ref is a body, and it could
be either an arrayref or L<IO::Handle>-ish object. The application could
also make use of the C<$writer> object if C<psgi.streaming> is in
effect, and in this case, the third element will not exist
(C<@$res == 2>). Dealing with these variants is again really painful,
and C<response_cb> can take care of that too, by allowing you to return
a content filter as a code reference.
# replace all "Foo" in content body with "Bar"
Plack::Util::response_cb($res, sub {
my $res = shift;
return sub {
my $chunk = shift;
local/lib/perl5/Plack/Middleware/BufferedStreaming.pm view on Meta::CPAN
no warnings;
use Carp;
use Plack::Util;
use Plack::Util::Accessor qw(force);
use Scalar::Util qw(weaken);
use parent qw(Plack::Middleware);
sub call {
my ( $self, $env ) = @_;
my $caller_supports_streaming = $env->{'psgi.streaming'};
$env->{'psgi.streaming'} = Plack::Util::TRUE;
my $res = $self->app->($env);
return $res if $caller_supports_streaming && !$self->force;
if ( ref($res) eq 'CODE' ) {
my $ret;
$res->(sub {
my $write = shift;
if ( @$write == 2 ) {
my @body;
local/lib/perl5/Plack/Middleware/BufferedStreaming.pm view on Meta::CPAN
return $res;
}
}
1;
__END__
=head1 NAME
Plack::Middleware::BufferedStreaming - Enable buffering for non-streaming aware servers
=head1 SYNOPSIS
enable "BufferedStreaming";
=head1 DESCRIPTION
Plack::Middleware::BufferedStreaming is a PSGI middleware component
that wraps the application that uses C<psgi.streaming> interface to
run on the servers that do not support the interface, by buffering the
writer output to a temporary buffer.
This middleware doesn't do anything and bypass the application if the
server supports C<psgi.streaming> interface, unless you set C<force>
option (see below).
=head1 OPTIONS
=over 4
=item force
Force enable this middleware only if the container supports C<psgi.streaming>.
=back
=head1 AUTHOR
Yuval Kogman
Tatsuhiko Miyagawa
=cut
local/lib/perl5/Plack/Middleware/JSONP.pm view on Meta::CPAN
enable "JSONP", callback_key => 'jsonp';
=head1 DESCRIPTION
Plack::Middleware::JSONP wraps JSON response, which has Content-Type
value either C<text/javascript> or C<application/json> as a JSONP
response which is specified with the C<callback> query parameter. The
name of the parameter can be set while enabling the middleware.
This middleware only works with a non-streaming response, and doesn't
touch the response otherwise.
=head1 AUTHOR
Tatsuhiko Miyagawa
=head1 SEE ALSO
L<Plack>
local/lib/perl5/Plack/Middleware/Lint.pm view on Meta::CPAN
unless (ref($env->{'psgi.version'}) eq 'ARRAY') {
die("psgi.version should be ArrayRef: $env->{'psgi.version'}");
}
unless (scalar(@{$env->{'psgi.version'}}) == 2) {
die('psgi.version should contain 2 elements, not ', scalar(@{$env->{'psgi.version'}}));
}
unless ($env->{'psgi.url_scheme'} =~ /^https?$/) {
die("psgi.url_scheme should be 'http' or 'https': ", $env->{'psgi.url_scheme'});
}
if ($env->{"psgi.version"}->[1] == 1) { # 1.1
for my $param (qw(streaming nonblocking run_once)) {
unless (exists $env->{"psgi.$param"}) {
die("Missing psgi.$param");
}
}
}
if ($env->{HTTP_CONTENT_TYPE}) {
die('HTTP_CONTENT_TYPE should not exist');
}
if ($env->{HTTP_CONTENT_LENGTH}) {
die('HTTP_CONTENT_LENGTH should not exist');
local/lib/perl5/Plack/Middleware/Lint.pm view on Meta::CPAN
sub is_possibly_fh {
my $fh = shift;
ref $fh eq 'GLOB' &&
*{$fh}{IO} &&
*{$fh}{IO}->can('getline');
}
sub validate_res {
my ($self, $res, $streaming) = @_;
unless (ref($res) eq 'ARRAY' or ref($res) eq 'CODE') {
die("Response should be array ref or code ref: $res");
}
if (ref $res eq 'CODE') {
return $self->response_cb($res, sub { $self->validate_res(@_, 1) });
}
unless (@$res == 3 || ($streaming && @$res == 2)) {
die('Response needs to be 3 element array, or 2 element in streaming');
}
unless ($res->[0] =~ /^\d+$/ && $res->[0] >= 100) {
die("Status code needs to be an integer greater than or equal to 100: $res->[0]");
}
unless (ref $res->[1] eq 'ARRAY') {
die("Headers needs to be an array ref: $res->[1]");
}
local/lib/perl5/Plack/Middleware/Lint.pm view on Meta::CPAN
die("Response headers MUST consist only of letters, digits, _ or - and MUST start with a letter. Header: $key");
}
if ($val =~ /[\000-\037]/) {
die("Response headers MUST NOT contain characters below octal \037. Header: $key. Value: $val");
}
unless (defined $val) {
die("Response headers MUST be a defined string. Header: $key");
}
}
# @$res == 2 is only right in psgi.streaming, and it's already checked.
unless (@$res == 2 ||
ref $res->[2] eq 'ARRAY' ||
Plack::Util::is_real_fh($res->[2]) ||
is_possibly_fh($res->[2]) ||
(blessed($res->[2]) && $res->[2]->can('getline'))) {
die("Body should be an array ref or filehandle: $res->[2]");
}
if (ref $res->[2] eq 'ARRAY' && grep _has_wide_char($_), @{$res->[2]}) {
die("Body must be bytes and should not contain wide characters (UTF-8 strings)");
local/lib/perl5/Plack/Middleware/StackTrace.pm view on Meta::CPAN
This middleware is enabled by default when you run L<plackup> in the
default I<development> mode.
You're recommended to use this middleware during the development and
use L<Plack::Middleware::HTTPExceptions> in the deployment mode as a
replacement, so that all the exceptions thrown from your application
still get caught and rendered as a 500 error response, rather than
crashing the web server.
Catching errors in streaming response is not supported.
=head2 Stack Trace Module
The L<Devel::StackTrace::WithLexicals> module will be used to capture the stack trace
if the installed version is 0.08 or later. Otherwise L<Devel::StackTrace> is used.
=head2 Performance
Gathering the information for a stack trace via L<Devel::StackTrace> is slow,
and L<Devel::StackTrace::WithLexicals> is significantly slower still.
local/lib/perl5/Plack/Test/Suite.pm view on Meta::CPAN
my $res = $cb->(GET "http://127.0.0.1/?name=miyagawa");
return if $res->code == 501;
is $res->code, 200;
is $res->message, 'OK';
is $res->header('content_type'), 'text/plain';
is $res->content, 'Hello, name=miyagawa';
},
sub {
my $env = shift;
$env->{'psgi.streaming'} or return [ 501, ['Content-Type','text/plain'], [] ];
return sub {
my $respond = shift;
$respond->([
200,
[ 'Content-Type' => 'text/plain', ],
[ 'Hello, ' . $env->{QUERY_STRING} ],
]);
}
},
],
[
'coderef streaming',
sub {
my $cb = shift;
my $res = $cb->(GET "http://127.0.0.1/?name=miyagawa");
return if $res->code == 501;
is $res->code, 200;
is $res->message, 'OK';
is $res->header('content_type'), 'text/plain';
is $res->content, 'Hello, name=miyagawa';
},
sub {
my $env = shift;
$env->{'psgi.streaming'} or return [ 501, ['Content-Type','text/plain'], [] ];
return sub {
my $respond = shift;
my $writer = $respond->([
200,
[ 'Content-Type' => 'text/plain', ],
]);
$writer->write("Hello, ");
local/lib/perl5/Twiggy.pm view on Meta::CPAN
=head1 DESCRIPTION
Twiggy is a lightweight and fast HTTP server with unique features such
as:
=over 4
=item PSGI
Can run any PSGI applications. Fully supports I<psgi.nonblocking> and
I<psgi.streaming> interfaces.
=item AnyEvent
This server uses AnyEvent and runs in a non-blocking event loop, so
it's best to run event-driven web applications that runs I/O bound
jobs or delayed responses such as long-poll, WebSocket or streaming
content (server push).
This software used to be called Plack::Server::AnyEvent but was
renamed to Twiggy.
=item Fast header parser
Uses XS/C based HTTP header parser for the best performance. (optional,
install the L<HTTP::Parser::XS> module to enable it; see also
L<Plack::HTTPParser> for more information).
local/lib/perl5/Twiggy/Server.pm view on Meta::CPAN
if ( $self->_try_read_headers($sock, $headers) ) {
my $env = {
SERVER_NAME => $$listen_host_r,
SERVER_PORT => $$listen_port_r,
SCRIPT_NAME => '',
REMOTE_ADDR => $peer_host,
'psgi.version' => [ 1, 0 ],
'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' => undef, # will be set by _run_app()
'psgix.io' => $sock,
'psgix.input.buffered' => Plack::Util::TRUE,
};
my $reqlen = parse_http_request($headers, $env);
DEBUG && warn "$sock Parsed HTTP headers: request length=$reqlen\n";
local/lib/perl5/Twiggy/Server.pm view on Meta::CPAN
} else {
$env->{'psgi.input'} = $null_io;
}
}
my $res = Plack::Util::run_app $app, $env;
if ( ref $res eq 'ARRAY' ) {
$self->_write_psgi_response($sock, $res);
} elsif ( blessed($res) and $res->isa("AnyEvent::CondVar") ) {
Carp::carp("Returning AnyEvent condvar is deprecated and will be removed in the next release of Twiggy. Use the streaming callback interface intstead.");
$res->cb(sub { $self->_write_psgi_response($sock, shift->recv) });
} elsif ( ref $res eq 'CODE' ) {
my $created_writer;
$res->(
sub {
my $res = shift;
if ( @$res < 2 ) {
croak "Insufficient arguments";
local/lib/perl5/YAML/Tiny.pm view on Meta::CPAN
=for stopwords deserialization
The YAML specification dictates three-phase serialization and three-phase
deserialization.
The YAML Tiny specification does not mandate any particular methodology
or mechanism for parsing.
Any compliant parser is only required to parse a single document at a
time. The ability to support streaming documents is optional and most
likely non-typical.
=for stopwords acyclic
Because anchors and aliases are not supported, the resulting representation
graph is thus directed but (unlike the main YAML specification) B<acyclic>.
Circular references/pointers are not possible, and any YAML Tiny serializer
detecting a circular reference should error with an appropriate message.
local/lib/perl5/x86_64-linux-thread-multi/AnyEvent/Handle.pm view on Meta::CPAN
=head1 NAME
AnyEvent::Handle - non-blocking I/O on streaming handles via AnyEvent
=head1 SYNOPSIS
use AnyEvent;
use AnyEvent::Handle;
my $cv = AnyEvent->condvar;
my $hdl; $hdl = new AnyEvent::Handle
fh => \*STDIN,
local/lib/perl5/x86_64-linux-thread-multi/AnyEvent/IO.pm view on Meta::CPAN
This works with disk files, and even with sockets and other sources. It
is, however, not very efficient when used with sources that could be
driven in a non-blocking way, because it usually has higher overhead
in the OS than non-blocking I/O, because it ties memory buffers for a
potentially unlimited time and often only a limited number of operations
can be done in parallel.
That's why asynchronous I/O makes most sense when confronted with disk
files, and non-blocking I/O only makes sense with sockets, pipes and
similar streaming sources.
=head1 IMPORT TAGS
By default, this module exports all C<aio_>xxx functions. In addition,
the following import tags can be used:
:aio all aio_* functions, same as :DEFAULT
:flags the fcntl open flags (O_CREAT, O_RDONLY, ...)
=head1 API NOTES
local/lib/perl5/x86_64-linux-thread-multi/AnyEvent/Intro.pod view on Meta::CPAN
handle that provides queueing and buffering of incoming and outgoing data
for you.
It also implements the most common data formats, such as text lines, or
fixed and variable-width data blocks.
=head2 L<AnyEvent::Socket>
This module provides you with functions that handle socket creation
and IP address magic. The two main functions are C<tcp_connect> and
C<tcp_server>. The former will connect a (streaming) socket to an internet
host for you and the later will make a server socket for you, to accept
connections.
This module also comes with transparent IPv6 support, this means: If you
write your programs with this module, you will be IPv6 ready without doing
anything special.
It also works around a lot of portability quirks (especially on the
windows platform), which makes it even easier to write your programs in a
portable way (did you know that windows uses different error codes for all
( run in 0.391 second using v1.01-cache-2.11-cpan-4d50c553e7e )