The Runtime Component

Resolvable Arguments

The closure returned from the front-controller may have zero or more arguments:

1
2
3
4
5
6
7
8
9
10

// public/index.php
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return function (InputInterface $input, OutputInterface $output): Application {
    // ...
};

The following arguments are supported by the SymfonyRuntime:

Request

A request created from globals.

InputInterface

An input to read options and arguments.

OutputInterface

Console output to print to the CLI with style.

Application

An application for creating CLI applications.

Command

For creating one line command CLI applications (using Command::setCode()).

And these arguments are supported by both the SymfonyRuntime and GenericRuntime (both type and variable name are important):

array $context

This is the same as $_SERVER + $_ENV.

array $argv

The arguments passed to the command (same as $_SERVER['argv']).

array $request

With keys query, body, files and session.

Resolvable Applications

The application returned by the closure below is a Symfony Kernel. However, a number of different applications are supported:

1
2
3
4
5
6
7
8

// public/index.php
use App\Kernel;

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return static function (): Kernel {
    return new Kernel('prod', false);
};

The SymfonyRuntime can handle these applications:

HttpKernelInterface

The application will be run with HttpKernelRunner like a "standard" Symfony application.

Response

The Response will be printed by ResponseRunner:

1
2
3
4
5
6
7
8

// public/index.php
use Symfony\Component\HttpFoundation\Response;

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return static function (): Response {
    return new Response('Hello world');
};

Command

To write single command applications. This will use the ConsoleApplicationRunner:

1
2
3
4
5
6
7
8
9
10
11
12
13

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return static function (Command $command): Command {
    $command->setCode(static function (InputInterface $input, OutputInterface $output): void {
        $output->write('Hello World');
    });

    return $command;
};

Application

Useful with console applications with more than one command. This will use the ConsoleApplicationRunner:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return static function (array $context): Application {
    $command = new Command('hello');
    $command->setCode(static function (InputInterface $input, OutputInterface $output): void {
        $output->write('Hello World');
    });

    $app = new Application();
    $app->add($command);
    $app->setDefaultCommand('hello', true);

    return $app;
};

The GenericRuntime and SymfonyRuntime also support these generic applications:

RunnerInterface

The RunnerInterface is a way to use a custom application with the generic Runtime:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// public/index.php
use Symfony\Component\Runtime\RunnerInterface;

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return static function (): RunnerInterface {
    return new class implements RunnerInterface {
        public function run(): int
        {
            echo 'Hello World';

            return 0;
        }
    };
};

callable

Your "application" can also be a callable. The first callable will return the "application" and the second callable is the "application" itself:

1
2
3
4
5
6
7
8
9
10
11
12

// public/index.php
require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return static function (): callable {
    $app = static function(): int {
        echo 'Hello World';

        return 0;
    };

    return $app;
};

void

If the callable doesn't return anything, the SymfonyRuntime will assume everything is fine:

1
2
3
4
5

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

return function (): void {
    echo 'Hello world';
};

Using Options

Some behavior of the Runtimes can be modified through runtime options. They can be set using the APP_RUNTIME_OPTIONS environment variable:

1
2
3
4
5
6
7

$_SERVER['APP_RUNTIME_OPTIONS'] = [
    'project_dir' => '/var/task',
];

require_once dirname(__DIR__).'/vendor/autoload_runtime.php';

// ...

You can also configure extra.runtime in composer.json:

1
2
3
4
5
6
7
8
9
10

{
    "require": {
        "...": "..."
    },
    "extra": {
        "runtime": {
            "project_dir": "/var/task"
        }
    }
}

Then, update your Composer files (running composer dump-autoload, for instance), so that the vendor/autoload_runtime.php files gets regenerated with the new option.

The following options are supported by the SymfonyRuntime:

env (default: APP_ENV environment variable, or "dev")

To define the name of the environment the app runs in.

disable_dotenv (default: false)

To disable looking for .env files.

dotenv_path (default: .env)

To define the path of dot-env files.

dotenv_overload (default: false)

To tell Dotenv whether to override .env vars with .env.local (or other .env.* files)

use_putenv

To tell Dotenv to set env vars using putenv() (NOT RECOMMENDED).

prod_envs (default: ["prod"])

To define the names of the production envs.

test_envs (default: ["test"])

To define the names of the test envs.

Besides these, the GenericRuntime and SymfonyRuntime also support these options:

debug (default: the value of the env var defined by debug_var_name option

(usually, APP_DEBUG), or true if such env var is not defined) Toggles the debug mode of Symfony applications (e.g. to display errors)

runtimes

Maps "application types" to a GenericRuntime implementation that knows how to deal with each of them.

error_handler (default: BasicErrorHandler or SymfonyErrorHandler for SymfonyRuntime)

Defines the class to use to handle PHP errors.

env_var_name (default: "APP_ENV")

Defines the name of the env var that stores the name of the configuration environment to use when running the application.

debug_var_name (default: "APP_DEBUG")

Defines the name of the env var that stores the value of the debug mode flag to use when running the application.