HTTP::Engine::Middleware is official middlewares distribution of
HTTP::Engine.
This library allows you to recognize and build URLs in a Rack application.
Although using the conventional LWP::UserAgent is fast and easy it does have
some drawbacks - the code execution blocks until the request has been
completed and it is only possible to process one request at a time.
HTTP::Async attempts to address these limitations.
It gives you a 'Async' object that you can add requests to, and then get the
requests off as they finish. The actual sending and receiving of the
requests is abstracted. As soon as you add a request it is transmitted, if
there are too many requests in progress at the moment they are queued. There
is no concept of starting or stopping - it runs continuously.
net-http-persistent manages persistent connections using Net::HTTP plus a speed
fix for Ruby 1.8. It's thread-safe too! Using persistent HTTP connections can
dramatically increase the speed of HTTP. Creating a new HTTP connection for
every request involves an extra TCP round-trip and causes TCP congestion
avoidance negotiation to start over. Net::HTTP supports persistent connections
with some API methods but does not handle reconnection gracefully.
Net::HTTP::Persistent supports reconnection and retry according to RFC 2616.
Net::Async::HTTP implements an asynchronous HTTP user agent. It sends requests
to servers, returning Future instances to yield responses when they are
received. The object supports multiple concurrent connections to servers, and
allows multiple requests in the pipeline to any one connection. Normally, only
one such object will be needed per program to support any number of requests.
As well as using futures the module also supports a callback-based interface.
Net::Async::HTTP optionally supports SSL connections, if IO::Async::SSL is
installed. If so, SSL can be requested either by passing a URI with the https
scheme, or by passing a true value as the SSL parameter.
This module adds the following methods to HTTP::Response objects.
$res->charset
Tells the charset exactly as appears in the Content-Type: header. Note that
the presence of the charset does not guarantee if the response content is
decodable via Encode.
$res->encoder
Returns the corresponding encoder object or undef if it can't.
$res->encoding
Tells the content encoding in the canonical name in Encode. Returns undef
if it can't.
$res->decoded_content
Discontinued since HTTP::Message already has this method.
HTTP::Tiny::SPDY is a subclass of HTTP::Tiny with added support for the SPDY
protocol. It is intended to be fully compatible with HTTP::Tiny so that it can
be used as a drop-in replacement for it.
mini_httpd is a small HTTP server. Its performance is not great, but for
low or medium traffic sites it's quite adequate. It implements all the
basic features of an HTTP server, including:
- GET, HEAD, and POST methods
- CGI and basic authentication support
- Security against ".." filename snooping
- The common MIME types
- Trailing-slash redirection
- index.html, index.htm, index.cgi
- Directory listings
- Multihoming (virtual hosting)
- Standard logging
- Custom error pages
It can also be configured to do SSL/HTTPS and IPv6.
HTTP::Headers::Fast is a perl class for parsing/writing HTTP headers.
The interface is same as HTTP::Headers.
Async (EventMachine) HTTP client, with support for:
o Asynchronous HTTP API for single & parallel request execution
o Keep-Alive and HTTP pipelining support
o Auto-follow 3xx redirects with max depth
o Automatic gzip & deflate decoding
o Streaming response processing
o Streaming file uploads
o HTTP proxy and SOCKS5 support
o Basic Auth & OAuth
o Connection-level & Global middleware support
o HTTP parser via http_parser.rb
o Works wherever EventMachine runs: Rubinius, JRuby, MRI