An advanced async HTTP server library for PHP, perfect for real-time apps and APIs with high concurrency demands.
Full Changelog: https://github.com/amphp/http-server/compare/v3.3.0...v3.3.1
RequestBody
now implements Stringable
so the entire request body can be buffered by simply casting the object to a string (note the request body length limits still apply).ClientException
now extends Amp\ByteStream\StreamException
to avoid violating the ReadableStream
interface by throwing a non-StreamException
from a stream method.Full Changelog: https://github.com/amphp/http-server/compare/v3.2.0...v3.3.0
league/[email protected]
and psr/message@v2
HttpErrorException
constructorFull Changelog: https://github.com/amphp/http-server/compare/v3.1.0...v3.2.0
HttpErrorException
by @kelunik in https://github.com/amphp/http-server/pull/352
Full Changelog: https://github.com/amphp/http-server/compare/v3.0.0...v3.1.0
Stable release compatible with AMPHP v3 and fibers! 🎉
As with other libraries compatible with AMPHP v3, most cases of parameters or returns of Promise<ResolutionType>
have been replaced with ResolutionType
.
The RequestHandler
and Middleware
interfaces along with the Request
and Response
objects are largely unchanged with the exception of replacing Promise
objects with the resolution type.
RequestHandler::handleRequest()
and Middleware::handleRequest()
has changed from Promise<Response>
to Response
.ReadableStream
or a string (note the interface name change in amphp/byte-stream
). null
will no longer be cast to an empty body.Initializing a server has changed significantly.
The Options
object has been removed, replaced by constructor parameters on various components. PHP 8.0's named parameters allows only defining the parameters you wish to override without the need to define those you do not wish to change.
HttpServer
is now an interface. ServerObserver
has been removed and replaced with onStart()
and onStop()
methods on the HttpServer
interface. SocketHttpServer
is the provided default implementation of HttpServer
. The methods getLogger()
, getRequestHandler()
, and getErrorHandler()
are no longer part of HttpServer
to avoid the interface being used as a service-locator.
In addition to the constructor, SocketHttpServer
provides two convenience static constructors for common use-cases.
createForDirectAccess()
— Creates an instance appropriate for direct access by the publiccreateForBehindProxy()
— Creates an instance appropriate for use when behind a proxy service such as nginx'Listening interfaces are provided to SocketHttpServer
using the expose()
method. The RequestHandler
and ErrorHandler
instances are not provided to the constructor, instead being provided to the SocketHttpServer::start()
method. As these objects are provided after constructing the HttpServer
instance, RequestHandlers
may now require an instance of HttpServer
in their constructors to attach start and stop handlers.
SocketServer
instances are then created by SocketHttpServer
using an instance of SocketServerFactory
passed to the constructor. This allows server bind contexts to be initialized based on the provided (or default) HttpDriverFactory
.
Below is the "Hello, World!" example from examples/hello-world.php as an example of initializing a SocketHttpServer
instance.
<?php
require dirname(__DIR__) . "/vendor/autoload.php";
use Amp\ByteStream;
use Amp\Http\HttpStatus;
use Amp\Http\Server\DefaultErrorHandler;
use Amp\Http\Server\Driver\SocketClientFactory;
use Amp\Http\Server\Request;
use Amp\Http\Server\RequestHandler;
use Amp\Http\Server\Response;
use Amp\Http\Server\SocketHttpServer;
use Amp\Log\ConsoleFormatter;
use Amp\Log\StreamHandler;
use Amp\Socket;
use Monolog\Logger;
use Monolog\Processor\PsrLogMessageProcessor;
use function Amp\trapSignal;
// Run this script, then visit http://localhost:1337/ or https://localhost:1338/ in your browser.
$cert = new Socket\Certificate(__DIR__ . '/../test/server.pem');
$context = (new Socket\BindContext)
->withTlsContext((new Socket\ServerTlsContext)
->withDefaultCertificate($cert));
$logHandler = new StreamHandler(ByteStream\getStdout());
$logHandler->pushProcessor(new PsrLogMessageProcessor());
$logHandler->setFormatter(new ConsoleFormatter());
$logger = new Logger('server');
$logger->pushHandler($logHandler);
$logger->useLoggingLoopDetection(false);
$server = new SocketHttpServer(
$logger,
new Socket\ResourceServerSocketFactory(),
new SocketClientFactory($logger),
);
$server->expose("0.0.0.0:1337");
$server->expose("[::]:1337");
$server->expose("0.0.0.0:1338", $context);
$server->expose("[::]:1338", $context);
$server->start(new class implements RequestHandler {
public function handleRequest(Request $request): Response
{
return new Response(
status: HttpStatus::OK,
headers: ["content-type" => "text/plain; charset=utf-8"],
body: "Hello, World!",
);
}
}, new DefaultErrorHandler());
// Await a termination signal to be received.
$signal = trapSignal([SIGHUP, SIGINT, SIGQUIT, SIGTERM]);
$logger->info(sprintf("Received signal %d, stopping HTTP server", $signal));
$server->stop();
ConcurrencyLimitingMiddleware
to limit the number of requests which may be concurrently handled by the server.ForwardedMiddleware
and associated Forwarded
class and ForwardedHeaderType
enum. This middleware parses either Forwarded
or X-Forwarded-For
headers to determine the original client address when used behind a proxy supporting these headers.AllowedMethodsMiddleware
which limits the allowed HTTP verbs used by requests. This middleware is used automatically by SocketHttpServer
. The allowed methods can be specified through a constructor parameter, using null to disable the middleware.Generally consumers of this library need not worry about these changes unless they implemented their own HTTP driver or interacted with the Client
interface beyond grabbing client metadata.
Client
is a significantly thinner interface, consisting of only metadata about the client connection.HttpDriver
instances now handle responding to requests instead of the Client
object.HttpDriver::setup()
has been replaced with HttpDriver::handleClient
. Rather than returning a Generator parser which is fed data read from the client, this method is instead expected to read/write data from the provided streams itself.HttpDriver::write()
has been removed, as writing to the client should be handled internally within the driver.SocketHttpServer
createForDirectAccess()
— Creates an instance appropriate for direct access by the publiccreateForBehindProxy()
— Creates an instance appropriate for use when behind a proxy service such as nginx'SocketHttpServer
has changed to require an instance of ServerSocketFactory
and ClientFactory
, as well as accepting an array of middleware and a list of allowed HTTP methods. Use SocketHttpServer::createForDirectAccess()
to create a server with similar defaults as the previous constructor.ForwardedMiddleware
and associated Forwarded
class and ForwardedHeaderType
enum. This middleware parses either Forwarded
or X-Forwarded-For
headers to determine the original client address when used behind a proxy supporting these headers.AllowedMethodsMiddleware
which limits the allowed HTTP verbs used by requests. This middleware is used automatically by SocketHttpServer
. The allowed methods can be specified through a constructor parameter, using null to disable the middleware.$allowedMethods
argument from the constructors of HttpDriverFactory
, Http1Driver
, and Http2Driver
since this functionality is now handled by the middleware above.Request
to get individual query keys in a manner similar to headers.2.0
of amphp/socket
.SocketHttpServer::expose()
in addition to a SocketAddress
instance.Response::onDispose()
being invoked as soon as the client connection or stream is closed. Prior it was not invoked until another chunk was read from the response body.v2.0
of amphp/byte-stream
by updating ReadableStream
implementations to also implement Traversable
.Note: 3.0.0 Beta 5 was skipped due to the tag missing a commit to update UpgradedSocket
to be iterable.
composer.json