class Bootstrapper
{
private $hostAggregator;
public function __construct(callable $hostAggregator = null)
{
$this->hostAggregator = $hostAggregator ?: ['\\Aerys\\Host', "getDefinitions"];
}
/**
* Bootstrap a server from command line options
*
* @param PsrLogger $logger
* @param \Aerys\Console $console
* @return \Generator
*/
public function boot(PsrLogger $logger, Console $console) : \Generator
{
$configFile = self::selectConfigFile((string) $console->getArg("config"));
$logger->info("Using config file found at {$configFile}");
// may return Promise or Generator for async I/O inside config file
$returnValue = (include $configFile);
if (!$returnValue) {
throw new \DomainException("Config file inclusion failure: {$configFile}");
}
if (is_callable($returnValue)) {
$returnValue = \call_user_func($returnValue);
}
if ($returnValue instanceof \Generator) {
yield from $returnValue;
} elseif ($returnValue instanceof Promise) {
(yield $returnValue);
}
if (!defined("AERYS_OPTIONS")) {
$options = [];
} elseif (is_array(AERYS_OPTIONS)) {
$options = AERYS_OPTIONS;
} else {
throw new \DomainException("Invalid AERYS_OPTIONS constant: expected array, got " . gettype(AERYS_OPTIONS));
}
if (array_key_exists("debug", $options)) {
throw new \DomainException('AERYS_OPTIONS constant contains "debug" key; "debug" option is read-only and only settable to true via the -d command line option');
}
$options["debug"] = $console->isArgDefined("debug");
$options["configPath"] = $configFile;
return $this->init($logger, $options);
}
/**
* Initializes the server directly without config file inclusion
*
* @param PsrLogger $logger
* @param array $options Aerys options array
* @return Server
*/
public function init(PsrLogger $logger, array $options = []) : Server
{
if (!array_key_exists("debug", $options)) {
$options["debug"] = false;
}
$options = $this->generateOptionsObjFromArray($options);
$vhosts = new VhostContainer(new Http1Driver());
$ticker = new Ticker($logger);
$server = new Server($options, $vhosts, $logger, $ticker);
$bootLoader = static function (Bootable $bootable) use($server, $logger) {
$booted = $bootable->boot($server, $logger);
if ($booted !== null && !$booted instanceof Middleware && !is_callable($booted)) {
throw new \InvalidArgumentException("Any return value of " . get_class($bootable) . '::boot() must return an instance of Aerys\\Middleware and/or be callable, got ' . gettype($booted) . ".");
}
return $booted ?? $bootable;
};
$hosts = \call_user_func($this->hostAggregator) ?: [new Host()];
foreach ($hosts as $host) {
$vhost = self::buildVhost($host, $bootLoader);
$vhosts->use($vhost);
}
return $server;
}
public static function selectConfigFile(string $configFile) : string
{
if ($configFile == "") {
throw new \DomainException("No config file found, specify one via the -c switch on command line");
}
return realpath(is_dir($configFile) ? rtrim($configFile, "/") . "/config.php" : $configFile);
}
private function generateOptionsObjFromArray(array $optionsArray) : Options
{
try {
$optionsObj = new Options();
foreach ($optionsArray as $key => $value) {
$optionsObj->{$key} = $value;
}
return $optionsObj->debug ? $optionsObj : $this->generatePublicOptionsStruct($optionsObj);
} catch (\Throwable $e) {
throw new \DomainException("Failed assigning options from config file", 0, $e);
}
}
private function generatePublicOptionsStruct(Options $options) : Options
{
$code = "return new class extends \\Aerys\\Options {\n";
foreach ((new \ReflectionClass($options))->getProperties() as $property) {
$name = $property->getName();
if ($name[0] !== "_") {
$code .= "\tpublic \${$name};\n";
}
}
$code .= "};\n";
$publicOptions = eval($code);
foreach ($publicOptions as $option => $value) {
$publicOptions->{$option} = $options->{$option};
}
return $publicOptions;
}
private static function buildVhost(Host $host, callable $bootLoader) : Vhost
{
try {
$hostExport = $host->export();
$interfaces = $hostExport["interfaces"];
$name = $hostExport["name"];
$actions = $hostExport["actions"];
$middlewares = [];
$applications = [];
$monitors = [];
foreach ($actions as $key => $action) {
if ($action instanceof Bootable) {
$action = $bootLoader($action);
} elseif (is_array($action) && $action[0] instanceof Bootable) {
$bootLoader($action[0]);
}
if ($action instanceof Middleware) {
$middlewares[] = [$action, "do"];
} elseif (is_array($action) && $action[0] instanceof Middleware) {
$middlewares[] = [$action[0], "do"];
}
if ($action instanceof Monitor) {
$monitors[get_class($action)][] = $action;
} elseif (is_array($action) && $action[0] instanceof Monitor) {
$monitors[get_class($action[0])][] = $action[0];
}
if (is_callable($action)) {
$applications[] = $action;
}
}
if (empty($applications)) {
$application = static function (Request $request, Response $response) {
$response->end("<html><body><h1>It works!</h1></body></html>");
};
} elseif (count($applications) === 1) {
$application = current($applications);
} else {
// Observe the Server in our stateful multi-responder so if a shutdown triggers
// while we're iterating over our coroutines we can send a 503 response. This
// obviates the need for applications to pay attention to server state themselves.
$application = $bootLoader(new class($applications) implements Bootable, ServerObserver
{
private $applications;
private $isStopping = false;
public function __construct(array $applications)
{
$this->applications = $applications;
}
public function boot(Server $server, PsrLogger $logger)
{
$server->attach($this);
}
public function update(Server $server) : Promise
{
if ($server->state() === Server::STOPPING) {
$this->isStopping = true;
}
return new Success();
}
public function __invoke(Request $request, Response $response)
{
foreach ($this->applications as $action) {
$out = $action($request, $response);
if ($out instanceof \Generator) {
yield from $out;
}
if ($response->state() & Response::STARTED) {
return;
}
if ($this->isStopping) {
$response->setStatus(HTTP_STATUS["SERVICE_UNAVAILABLE"]);
$response->setReason("Server shutting down");
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
}
}
public function __debugInfo()
{
return ["applications" => $this->applications];
}
});
}
$vhost = new Vhost($name, $interfaces, $application, $middlewares, $monitors, $hostExport["httpdriver"]);
if ($crypto = $hostExport["crypto"]) {
$vhost->setCrypto($crypto);
}
return $vhost;
} catch (\Throwable $previousException) {
throw new \DomainException("Failed building Vhost instance", $code = 0, $previousException);
}
}
}
