Result:
found more than 672 distributions - search limited to the first 2001 files matching your query
( run in 0.539 )
Plack-Middleware-StackTrace-RethrowFriendly
view release on metacpan or search on metacpan
lib/Plack/Middleware/StackTrace/RethrowFriendly.pm
minil.toml
t/00_compile.t
t/01_basic.t
t/02_force.t
t/03_streaming.t
t/04_utf8.t
t/05_sigdie.t
t/06_rethrow.t
t/07_multiple_exceptions.t
META.yml
Plack-Middleware-SuppressResponseCodes
view release on metacpan or search on metacpan
Makefile.PL
README
lib/Plack/Middleware/SuppressResponseCodes.pm
t/00_compile.t
t/10_codes.t
t/20_streaming.t
Plack-Middleware-Test-StashWarnings
view release on metacpan or search on metacpan
lib/Plack/Middleware/Test/StashWarnings.pm view on Meta::CPAN
return [ 200, ["Content-Type", "application/x-storable"], [ $self->dump_warnings ] ];
}
my $ret = $self->_stash_warnings_for($self->app, $env);
# for the streaming API, we need to re-instate the dynamic sigwarn handler
# around the streaming callback
if (ref($ret) eq 'CODE') {
return sub { $self->_stash_warnings_for($ret, @_) };
}
return $ret;
Plack-Middleware-TrafficLog
view release on metacpan or search on metacpan
lib/Plack/Middleware/TrafficLog.pm view on Meta::CPAN
This module works also with applications that have delayed response. In that
case, each chunk is logged separately and shares the same unique ID number and
headers.
The body of the request and response is not logged by default. For streaming
responses, only the first chunk is logged by default.
=for readme stop
=cut
lib/Plack/Middleware/TrafficLog.pm view on Meta::CPAN
The true value enables logging of the message's body.
=item with_all_chunks
The true value enables logging of every chunk for streaming responses.
=item eol
Sets the line separator for the message's headers and the body. The default
value is the pipe character C<|>.
Plack-Middleware-XSLT
view release on metacpan or search on metacpan
lib/Plack/Middleware/XSLT.pm view on Meta::CPAN
$headers->set('Content-Length', length($output));
$res->[2] = [ $output ];
}
}
else {
# PSGI streaming
my ($done, @chunks);
return sub {
my $chunk = shift;
Plack-Middleware-XSRFBlock
view release on metacpan or search on metacpan
lib/Plack/Middleware/XSRFBlock.pm view on Meta::CPAN
=head2 filter_response_html($self, $request, $env, $res, $token)
Filters the response, injecting C<< <input> >> elements with the token
value into all forms whose method matches C<http_method_regex>.
Streaming responses are still streaming after the filtering.
=head2 filter_response($self, $request, $env)
Calls the application, and (if the response L<< /C<should_be_filtered>
>>), it injects the token in the cookie and (if L<<
Plack-Middleware-iPhone
view release on metacpan or search on metacpan
1.100830 2010-03-24 15:08:11 EST5EDT
Switched to Dist::Zilla
0.02 2010-03-23
Manifest generation moved to middleware constructor
Now handles streaming apps (like Plack:App::Proxy)
0.01 2010-03-22
First version, released on an unsuspecting world.
Plack-Server-AnyEvent
view release on metacpan or search on metacpan
lib/Plack/Server/AnyEvent.pm view on Meta::CPAN
SCRIPT_NAME => '',
'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' => $sock,
'REMOTE_ADDR' => $peer_host,
lib/Plack/Server/AnyEvent.pm view on Meta::CPAN
=head1 DESCRIPTION
Plack::Server::AnyEvent is a Plack server implementation using
AnyEvent. This server runs in a non-blocking event loop and suitable
for event-driven web applications like streaming API servers.
=head1 LICENSE
This module is licensed under the same terms as Perl itself.
Plack-Server-Coro
view release on metacpan or search on metacpan
lib/Plack/Server/Coro.pm view on Meta::CPAN
'psgi.url_scheme' => 'http', # SSL support?
'psgi.nonblocking' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.multithread' => Plack::Util::TRUE,
'psgi.multiprocess' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
};
my $res = [ 400, [ 'Content-Type' => 'text/plain' ], [ 'Bad Request' ] ];
my $buf = '';
lib/Plack/Server/Coro.pm view on Meta::CPAN
push @lines, "\015\012";
$fh->syswrite(join '', @lines);
if (!defined $res->[2]) {
# streaming write
return Plack::Util::inline_object
write => sub { $fh->syswrite(join '', @_) },
close => $rouse_cb;
} elsif ($HasAIO && Plack::Util::is_real_fh($res->[2])) {
my $length = -s $res->[2];
Plack-Test-AnyEvent
view release on metacpan or search on metacpan
lib/Plack/Test/AnyEvent.pm view on Meta::CPAN
my $cb = sub {
my ( $req ) = @_;
$req->uri->scheme('http') unless defined $req->uri->scheme;
$req->uri->host('localhost') unless defined $req->uri->host;
my $env = $req->to_psgi;
$env->{'psgi.streaming'} = 1;
$env->{'psgi.nonblocking'} = 1;
my $res = $app->($env);
if(ref($res) eq 'CODE') {
lib/Plack/Test/AnyEvent.pm view on Meta::CPAN
$Plack::Test::Impl = 'AnyEvent'; # or 'AE' for short
test_psgi $app, sub {
my ( $cb ) = @_;
my $res = $cb->(GET '/streaming-response');
is $res->header('Transfer-Encoding'), 'chunked';
$res->on_content_received(sub {
my ( $content ) = @_;
# test chunk of streaming response
});
$res->recv;
}
=head1 DESCRIPTION
This L<Plack::Test> implementation allows you to easily test your
L<AnyEvent>-based PSGI applications. Normally, L<Plack::Test::MockHTTP>
or L<Plack::Test::Server> work fine for this, but this implementation comes
in handy when you'd like to test your streaming results as they come in, or
if your application uses long-polling. For non-streaming requests, you can
use this module exactly like Plack::Test::MockHTTP; otherwise, you can set
up a content handler and call C<$res-E<gt>recv>. The event loop will then
run until the PSGI application closes its writer handle or until your test
client calls C<send> on the response.
lib/Plack/Test/AnyEvent.pm view on Meta::CPAN
return sub {
my ( $respond ) = @_;
die 'still thrown by $cb';
if($streaming) {
my $writer = $respond->([
200,
['Content-Type' => 'text/plain'],
]);
lib/Plack/Test/AnyEvent.pm view on Meta::CPAN
=back
This list isn't exclusive; ie. just because your event loop isn't on this list
doesn't mean it doesn't work. Also, even if your event loop doesn't pass
the exception tests, the general usage of this module (testing requests,
handling streaming results and long polling) should work on any AnyEvent loop.
Just don't throw any uncaught exceptions =).
=head1 SEE ALSO
L<AnyEvent>, L<Plack>, L<Plack::Test>
Plagger
view release on metacpan or search on metacpan
t/samples/rss-20.xml view on Meta::CPAN
<webMaster>dave@userland.com (Dave Winer)</webMaster>
<generator>Weblog Editor 2.0</generator>
<item>
<title>Foo Bar</title>
<link>http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp</link>
<description>It's been a few days since I added a song to the Grateful Dead channel. Now that there are all these new Radio users, many of whom are tuned into this channel (it's #16 on the hotlist of upstreaming Radio users, there's...
</description>
<enclosure url="http://www.scripting.com/mp3s/weatherReportDicksPicsVol7.mp3" length="6182912" type="audio/mpeg"/>
<author>dave@userland.com (Dave Winer)</author>
</item>
</channel>
Plasp
view release on metacpan or search on metacpan
lib/Plasp/App.pm view on Meta::CPAN
# Setup a hash here holding references to various objects at this
# scope, so that the closures for calling the responder will be
# able to write to this scope.
my %refs = ( responder => shift );
# If a responder is passed in, that means streaming response is
# supported so pass a closure to write out headers and body
if ( $refs{responder} ) {
$_asp->Response->_headers_writer(
sub { $refs{writer} = $refs{responder}->( \@_ ) }
);
lib/Plasp/App.pm view on Meta::CPAN
# client
$refs{writer}->close;
} else {
# If not using streaming response, then save response
# for reference later
$refs{status} = $resp->Status;
$refs{headers} = $resp->Headers;
$refs{body} = [ $resp->Output ];
}
lib/Plasp/App.pm view on Meta::CPAN
? \( @refs{qw(status headers body)} )
: $error_response;
}
};
if ( $_asp->req->env->{'psgi.streaming'} ) {
# Return the callback subroutine if streaming is supported
return $callback;
} else {
# Manually call the callback to get response
return $callback->();
Pod-POM-Web
view release on metacpan or search on metacpan
lib/Pod/POM/Web.pm view on Meta::CPAN
$command .= "(from_scratch=>1)" if $req->parameters->get('from_scratch');
warn "STARTING COMMAND $command\n";
open my $pipe, '-|', qq{perl -Ilib -MPod::POM::Web -e "$command"};
# pipe progress reports from the subprocess into the HTTP response,
# using Plack's streaming API
my $res = Plack::Response->new(200);
$res->content_type('text/plain');
$res->body($pipe);
return $res->finalize;
}
Pod-POM
view release on metacpan or search on metacpan
t/YAML/Tiny.pm view on Meta::CPAN
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.
Because anchors and aliases are not supported, the resulting representation
graph is thus directed but (unlike the main YAML specification) B<acyclic>.
Pod-Webserver
view release on metacpan or search on metacpan
lib/Pod/Webserver.pm view on Meta::CPAN
while( my $conn = $daemon->accept ) {
if( my $req = $conn->get_request ) {
#^^ That used to be a while(... instead of an if( ..., but the
# keepalive wasn't working so great, so let's just leave it for now.
# It's not like our server here is streaming GIFs or anything.
DEBUG and print "Answering connection at ", localtime()."\n";
$self->_serve_thing($conn, $req);
}
$conn->close;
Porbo
view release on metacpan or search on metacpan
lib/Porbo/Server.pm view on Meta::CPAN
REMOTE_ADDR => $peer_host,
'psgi.version' => [ 1, 0 ],
'psgi.errors' => *STDERR,
'psgi.url_scheme' => $ssl ? 'https' : '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' => $hdl->fh,
Prancer
view release on metacpan or search on metacpan
lib/Prancer/Response.pm view on Meta::CPAN
# the extra array ref brackets around the sub are because Web::Simple,
# which we use as the router, will not do a callback without them. by
# returning an array ref we are telling Web::Simple that we are giving
# it a PSGI response. from the Web::Simple docs:
#
# Well, a sub is a valid PSGI response too (for ultimate streaming
# and async cleverness). If you want to return a PSGI sub you have
# to wrap it into an array ref.
#
return [ sub {
my $responder = shift;
# this idiom here borrows heavily from the documentation on this
# blog post, by tatsuhiko miyagawa:
#
# http://bulknews.typepad.com/blog/2009/10/psgiplack-streaming-is-now-complete.html
#
# this effectively allows the user of this api to stream data to
# the client.
# finalize will always return a three element array. the third
lib/Prancer/Response.pm view on Meta::CPAN
$response->body("hello");
$response->body("goodbye", "world");
If a buffered response is not desired then the body may be a callback to send a
streaming response to the client. Any headers or response codes set in the
callback will be ignored as they must all be set beforehand. Any body set
before a callback is set will also be ignored. For example:
$response->body(sub {
my $writer = shift;
ProgressMonitor
view release on metacpan or search on metacpan
0.11 2007-05-25
- Added a new message strategy - 'overlay_newline'.
0.12 2007-05-25
- When streaming a msg with \n at the end, no need to bs then.
0.20 2007-06-08
- changing the setMessage API, to enable setting 'delayed' messages
i.e. 'set message on next tick' etc.
Protocol-HTTP
view release on metacpan or search on metacpan
- treat protocol-relative urls as path
1.0.11 25.11.2020
- improve makefile
- change constant names
1.0.10 30.10.2020
- bugfix: chunked data streaming correctly supports compression
- bugfix: gzip uncompression
- multipart/form-data: allow to define filename and content/type
1.0.9 25.06.2020
- $request->method_str now returns stringified effective method
- fix compilation issues on *BSD
Protocol-HTTP2
view release on metacpan or search on metacpan
- updated protocol id string ("h2", "h2c"), dropped old interop id strings
0.16 2015-04-05T20:41:49Z
- update status (beta)
- add wiki link
- implemented server streaming
- implemented client downloading, request cancelling
0.15 2015-02-26T20:39:20Z
- Split settings for decoder/encoder
- Allow to setup custom settings in Server/Client constructor
Protocol-IMAP
view release on metacpan or search on metacpan
lib/Protocol/IMAP/Fetch.pm view on Meta::CPAN
If there's a {123} string literal, then we need to stream that amount of data:
we request a new sink, primed with the data we have so far, with the byte count
({123} value) as the limit, and allow it to pass us events until completion.
In streaming mode, we'll pass those to event listeners.
Otherwise, we'll store this data internally to the appropriate key.
then switch back to line mode.
Protocol-OSC
view release on metacpan or search on metacpan
lib/Protocol/OSC.pod view on Meta::CPAN
Reverse of previous.
=head2 to_stream($data)
Packs raw OSC data for (tcp) streaming.
=head2 from_stream($buf)
Returns list of raw OSC data packets in B<$buf> from stream buffer and residue of B<$buf>.
If $buf is incomplete - returns only B<$buf>.
Qt
view release on metacpan or search on metacpan
qtgui/examples/xml/htmlinfo/apache_org.html view on Meta::CPAN
figure represents an increase of more than 40% over the previous year,
demonstrating the rapidly growing interest in Apache and Open Source software
amongst European businesses.
If you have not been able to attend ApacheCon Europe, you can still watch
<a href="http://streaming.linux-magazin.de/en/archive_apachecon08eu.htm">videos of all keynotes and select talks online</a>. Keynote sessions
and the opening plenary are available <b>free of charge</b>:</p>
<ul>
<li><a href="http://streaming.linux-magazin.de/events/apacheconfree/archive/jjagielski/frames-java.htm" onclick="window.open(this.href, '_blank', 'width=1024, height=768'); return false;">State of the Feather</a>
by Jim Jagielski, Chairman of the Apache Software Foundation</li>
<li><a href="http://streaming.linux-magazin.de/events/apacheconfree/archive/cschmidt/frames-java.htm" onclick="window.open(this.href, '_blank', 'width=1024, height=768'); return false;">Using Audio Technology and Open Content to Reduce Global Illiter...
by Cliff Schmidt, Executive Director of Literacy Bridge</li>
<li><a href="http://streaming.linux-magazin.de/events/apacheconfree/archive/rghosh/frames-java.htm" onclick="window.open(this.href, '_blank', 'width=1024, height=768'); return false;">Apache and Steam Engines: the Magic of Collaborative Innovation</a...
by Rishab Aiyer Ghosh, Open Source Initiative Board Member</li>
<li><a href="http://streaming.linux-magazin.de/events/apacheconfree/archive/rfielding/frames-java.htm" onclick="window.open(this.href, '_blank', 'width=1024, height=768'); return false;">Apache 3.0 (a Tall Tale)</a>
by Roy Fielding, Co-founder of The Apache Software Foundation,
and Vice President, Apache HTTP Server</li>
</ul>
<p>The talks of the following select ApacheCon Europe tracks are
available for just 49 Euro:
<a href="http://streaming.linux-magazin.de/en/archive_apachecon08eu.htm#wednesday">System Administration</a>,
<a href="http://streaming.linux-magazin.de/en/archive_apachecon08eu.htm#thursday">Web Security</a>,
<a href="http://streaming.linux-magazin.de/en/archive_apachecon08eu.htm#friday">Web Services and Web 2.0</a>.
</p>
<hr />
</div>
<h4 id="apachecon-us">
RDF-Query
view release on metacpan or search on metacpan
bin/query.pl view on Meta::CPAN
my $iter = $query->execute( $model );
# print the results as a string to standard output
print $iter->as_string;
### this will allow the results to be printed in a streaming fashion:
### or, if you want to iterate over each result row:
# while (my $s = $iter->next) {
# print $s . "\n";
# }
RDF-Sesame
view release on metacpan or search on metacpan
lib/RDF/Sesame/Repository.pm view on Meta::CPAN
resulting RDF. The minimal method invocation looks like
my $rdf = $repo->extract( format => 'turtle' )
where C<$rdf> is a reference to a scalar containing the serialization of all
the triples in the repository. The streaming results returned by Sesame are
handled appropriately so that memory usage in minimized. If the output is
sent to a file (see L</output>), only one "chunk" is held in memory at a time
(subject to caching by your OS). The serialization may also be compressed (or
otherwise processed) as it's being streamed from the server (see
L</compress>).
RDF-Trine
view release on metacpan or search on metacpan
Changes.ttl view on Meta::CPAN
asc:update "Throw exception in RDF::Trine::Node::Resource->new when IRI contains bad characters." ;
asc:update "Fix RDF::Trine::Parser::RDFXML to UTF-8 encode strings before calling into the SAX parser (related to github pull request #82)." ;
asc:update "Fixed typo in exception throwing in RDF::Trine::Parser::TriG." ;
asc:update "Fixed mistaken use of 'otherwise' exception handler in turtle_tokenize.pl." ;
asc:update "Improved error handling in RDF::Trine::Parser->parse_url_into_model." ;
asc:update "Implemented streaming version of RDF::Trine::Parser::RDFXML->parse_file using parse_file from XML::SAX." ;
asc:update "Removed use of given/when statements to make perl 5.18 happy." ;
asc:update "Silence tracing code in RDF::Trine::Store::Hexastore." ;
asc:update "Added TryCatch to list of required modules." ;
asc:update "Changed key names and layout of nodemap data in Redis store." ;
] .
Changes.ttl view on Meta::CPAN
doap:Version [
doap:revision "1.001" ;
doap:created "2012-10-05" ;
];
asc:changes [
asc:update "Replaced old Turtle and TriG parsers with new streaming implementations." ;
asc:update "Added RDF::Trine::Node::Literal->canonicalize method." ;
asc:update "Updated RDF::Trine::Parser::Redland to construct a new parser object on each parse (avoiding a bug in redland)." ;
asc:update "Applied partial patch to 'fix interaction with HTML::Data::Parser' (from Dorian Taylor; commit 9b713b23b6)." ;
asc:update "Added Moose and MooseX::ArrayRef to prerequisites list." ;
asc:update "Updated code style to work with Perl::Critic core policies." ;
Changes.ttl view on Meta::CPAN
asc:changes [
asc:addition "Added RDF::Trine::Iterator->count method." ;
asc:addition "Added ability to access the number of rows returned from RDF::Trine::Iterator::Bindings::as_string." ;
asc:addition "Added RDF::Trine::Model::Dataset for constructing views over a model, and RDF::Trine::Model->dataset_model constructor method." ;
asc:addition "Added missing use of Encode to RDF::Trine::Store::Redland." ;
asc:addition "Added bin/rdf_transcode.pl for (streaming) conversion between RDF serialization formats." ;
asc:addition "Added ability for RDF::Trine::Store::Memory to load RDF files by URI in _new_with_string." ;
asc:update "Updated quality value heuristics in RDF::Trine::Serializer::negotiate to prefer turtle if no accept headers are supplied." ;
asc:update "Fixed RDF::Trine::Iterator::Bindings::as_string to respect $max_result_size argument." ;
asc:update "RDF::Trine::Iterator::Bindings::as_string now returns unescaped strings." ;
asc:update "Updated RDF::Trine::Parser::parse_url_into_model to fall back on file extension heuristics if the media-type based parse fails." ;
Changes.ttl view on Meta::CPAN
asc:addition "Added Text::CSV and HTTP::Negotiate to RDF::Trine prereq list." ;
asc:update "Fixed exception thrown on unrecognized parser name." ;
asc:update "Removed dependency list and added perlrdf link to POD in RDF::Trine and RDF::Query." ;
asc:update "Updated RDF::Trine::Serializer::Turtle->new API to take %args instead of \\%namespaces." ;
asc:update "Updated RDF::Trine::Serializer::RDFXML to take %args and properly accept and serialize xmlns namespaces." ;
asc:update "Updated RDF::Trine::Parser::RDFa to use streaming parsing (instead of materializing the graph first)." ;
asc:update "Updated RDF::Trine::Model::_debug to use quad semantics when getting statement iterator." ;
asc:update "Updated t/parser-turtle.t to use File::Glob::bsd_glob for cases where the test directory's path contains whitespace." ;
asc:update "Removed redundant parse_into_model methods from RDF::Trine::Parser subclasses." ;
asc:update "Renamed examples/create_store.pl to examples/foaf_labels.pl." ;
asc:update "Fixed bug in turtle serializer that improperly serialized bnode objects 'belonging' to a parent bnode." ;
Changes.ttl view on Meta::CPAN
asc:update "Moved the nested hash join from ::Iterator to ::Iterator::Bindings." ;
asc:update "Pipelined the code for nested loop joins on binding iterators." ;
asc:update "Fixed bug in ::Model::StatementFilter to call join_steams in ::Iterator::Bindings." ;
asc:update "Fixed bug in ::Iterator::Graph::as_bindings where not all arguments are ::Node::Variable objects." ;
asc:update "Updated SPARQL XML Results namespace for boolean iterators." ;
asc:update "Replaced XML::Twig code with new XML::SAX parser (allowing streaming parsing)." ;
asc:update "Moved as_sparql methods from RDF::Trine:: to RDF::Query:: classes." ;
asc:update "RDF::Trine::Iterator::smap now allows overriding default construct_args (e.g. binding names)." ;
asc:update "Fixed RDF::Trine::Model::StatementFilter::get_pattern to project away unused variables (fixing a bug that caused joining to always fail)." ;
asc:update "Updated example turtle parser to accept URLs as command line arguments." ;
asc:update "Turtle parser now removes dashes from the UUIDs used for blank node IDs." ;
RDFStore
view release on metacpan or search on metacpan
lib/DBD/RDFStore.pm view on Meta::CPAN
if($DBD::RDFStore::st::debug>1) {
print STDERR (" " x $tpi);
print STDERR "$tpi BEGIN\n";
};
# if we have a previous state try to recover it (this is needed for streaming results)
my $bind_state = pop @{ $sth->{'binds'} };
if( ( $bind_state ) && ($DBD::RDFStore::st::debug>1) ) {
print STDERR (" " x $tpi);
print STDERR "RECOVER previous state for $tpi\n";
lib/DBD/RDFStore.pm view on Meta::CPAN
};
return _fetchrow_RDF_or_XML( $sth );
};
# fetch the whole matching graph in one call (not streaming then)
# return RDFStore::Model of matching statements
sub fetchallgraph {
my($sth) = @_;
my $whole_graph;
lib/DBD/RDFStore.pm view on Meta::CPAN
};
return $whole_graph;
};
# should be streaming
sub _fetchrow_RDF_or_XML {
my($sth, $syntax) = @_;
return
if($sth->{'RDF_or_XML_stream_finished'});
lib/DBD/RDFStore.pm view on Meta::CPAN
unless( (!$syntax) ||
($syntax =~ m#(RDF/XML|N-Triples|dawg-results|rdf-for-xml|dawg-xml)#i) );
my $result = '';
my $mm = new RDFStore::Model; # we want streaming - that's why this...
# DESCRIBE <URI> are done once in one single subgraph / match
if( ( $sth->{'Statement'}->getQueryType eq 'DESCRIBE' ) &&
( grep m/^<([^>]+)>/, @{ $sth->{'Statement'}->{'describes'} }) ) {
foreach my $d ( @{ $sth->{'Statement'}->{'describes'} } ) {
REST-Neo4p
view release on metacpan or search on metacpan
lib/REST/Neo4p/Agent.pm view on Meta::CPAN
incrementally and (with the L<Mojo::UserAgent> backend) in a
non-blocking way. New Neo4j server versions may break the incremental
parsing. If this happens, L<make a
ticket|https://rt.cpan.org/Public/Bug/Report.html?Queue=REST-Neo4p>. In
the meantime, you should be able to keep things going (albeit more
slowly) by turning off streaming at the agent:
REST::Neo4p->agent->no_stream;
Streaming responses can be requested again by issuing
RPC-XML
view release on metacpan or search on metacpan
* lib/RPC/XML/Client.pm
* lib/RPC/XML/Parser.pm
* lib/RPC/XML/Server.pm
The parsing of incoming data in the client and both server
classes is now done to a streaming XML parser, eliminating the
need for the full message to ever be in memory at once.
Likewise, the client and server classes have new attributes and
accessor methods to allow them to spool outgoing messages to
files if the messages threaten to be too large to keep in
memory (this is best used when dealing with a lot of Base64
RTSP-Client
view release on metacpan or search on metacpan
lib/RTSP/Client.pm view on Meta::CPAN
=head1 DESCRIPTION
This module provides a high-level interface for communicating with an RTSP server.
RTSP is a protocol for controlling streaming applications, it is not a media transport or a codec.
It supports describing media streams and controlling playback, and that's about it.
In typical usage, you will open a connection to an RTSP server and send it the PLAY method. The server
will then stream the media at you on the client port range using the specified transport protocol.
You are responsible for listening on the client port range and handling the actual media data yourself,
( run in 0.539 second using v1.01-cache-2.11-cpan-a5abf4f5562 )