Framework Configuration Reference (FrameworkBundle)

enabled

type: boolean default: false

Whether to enable the form services or not in the service container. If you don't use forms, setting this to false may increase your application's performance because less services will be loaded into the container.

This option will automatically be set to true when one of the child settings is configured.

enabled

type: boolean default: true if form support is enabled, false otherwise

This option can be used to disable CSRF protection on all forms. But you can also disable CSRF protection on individual forms.

If you're using forms, but want to avoid starting your session (e.g. using forms in an API-only website), csrf_protection will need to be set to false.

enabled

type: boolean default: false

Whether to enable the edge side includes support in the framework.

You can also set esi to true to enable it:

1
2
3

# app/config/config.yml
framework:
    esi: true

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:esi/>
    </framework:config>
</container>

1
2
3
4

// app/config/config.php
$container->loadFromExtension('framework', [
    'esi' => true,
]);

enabled

type: boolean default: false

Whether to enable the fragment listener or not. The fragment listener is used to render ESI fragments independently of the rest of the page.

This setting is automatically set to true when one of the child settings is configured.

path

type: string default: '/_fragment'

The path prefix for fragments. The fragment listener will only be executed when the request starts with this path.

enabled

type: boolean default: false

The profiler can be enabled by setting this option to true. When you are using the Symfony Standard Edition, the profiler is enabled in the dev and test environments.

collect

type: boolean default: true

This option configures the way the profiler behaves when it is enabled. If set to true, the profiler collects data for all requests (unless you configure otherwise, like a custom matcher). If you want to only collect information on-demand, you can set the collect flag to false and activate the data collectors manually:

1

$profiler->enable();

only_exceptions

type: boolean default: false

When this is set to true, the profiler will only be enabled when an exception is thrown during the handling of the request.

only_master_requests

type: boolean default: false

When this is set to true, the profiler will only be enabled on the master requests (and not on the subrequests).

dsn

type: string default: 'file:%kernel.cache_dir%/profiler'

The DSN where to store the profiling information.

matcher

Matcher options are configured to dynamically enable the profiler. For instance, based on the ip or path.

formats

type: array default: []

This setting is used to associate additional request formats (e.g. html) to one or more mime types (e.g. text/html), which will allow you to use the format & mime types to call Request::getFormat($mimeType) or Request::getMimeType($format).

In practice, this is important because Symfony uses it to automatically set the Content-Type header on the Response (if you don't explicitly set one). If you pass an array of mime types, the first will be used for the header.

To configure a jsonp format:

1
2
3
4
5

# app/config/config.yml
framework:
    request:
        formats:
            jsonp: 'application/javascript'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>

<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony
        https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:request>
            <framework:format name="jsonp">
                <framework:mime-type>application/javascript</framework:mime-type>
            </framework:format>
        </framework:request>
    </framework:config>
</container>

1
2
3
4
5
6
7
8

// app/config/config.php
$container->loadFromExtension('framework', [
    'request' => [
        'formats' => [
            'jsonp' => 'application/javascript',
        ],
    ],
]);

resource

type: string required

The path the main routing resource (e.g. a YAML file) that contains the routes and imports the router should load.

type

type: string

The type of the resource to hint the loaders about the format. This isn't needed when you use the default routers with the expected file extensions (.xml, .yml / .yaml, .php).

http_port

type: integer default: 80

The port for normal http requests (this is used when matching the scheme).

https_port

type: integer default: 443

The port for https requests (this is used when matching the scheme).

strict_requirements

type: mixed default: true

Determines the routing generator behavior. When generating a route that has specific requirements, the generator can behave differently in case the used parameters do not meet these requirements.

The value can be one of:

true

Throw an exception when the requirements are not met;

false

Disable exceptions when the requirements are not met and return null instead;

null

Disable checking the requirements (thus, match the route even when the requirements don't match).

true is recommended in the development environment, while false or null might be preferred in production.

storage_id

type: string default: 'session.storage.native'

The service id used for session storage. The session.storage service alias will be set to this service id. This class has to implement SessionStorageInterface.

handler_id

type: string default: 'session.handler.native_file'

The service id used for session storage. The session.handler service alias will be set to this service id.

You can also set it to null, to default to the handler of your PHP installation.

name

type: string default: null

This specifies the name of the session cookie. By default, it will use the cookie name which is defined in the php.ini with the session.name directive.

cookie_lifetime

type: integer default: null

This determines the lifetime of the session - in seconds. The default value - null - means that the session.cookie_lifetime value from php.ini will be used. Setting this value to 0 means the cookie is valid for the length of the browser session.

cookie_path

type: string default: /

This determines the path to set in the session cookie. By default, it will use /.

cache_limiter

type: string or int default: ''

If set to 0, Symfony won't set any particular header related to the cache and it will rely on the cache control method configured in the session.cache-limiter PHP.ini option.

Unlike the other session options, cache_limiter is set as a regular container parameter:

1
2
3
4

# app/config/services.yml
parameters:
    session.storage.options:
        cache_limiter: 0

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

<!-- app/config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd">

    <parameters>
        <parameter key="session.storage.options" type="collection">
            <parameter key="cache_limiter">0</parameter>
        </parameter>
    </parameters>
</container>

1
2
3
4

// app/config/services.php
$container->setParameter('session.storage.options', [
    'cache_limiter' => 0,
]);

cookie_domain

type: string default: ''

This determines the domain to set in the session cookie. By default, it's blank, meaning the host name of the server which generated the cookie according to the cookie specification.

cookie_secure

type: boolean default: false

This determines whether cookies should only be sent over secure connections.

cookie_httponly

type: boolean default: true

This determines whether cookies should only be accessible through the HTTP protocol. This means that the cookie won't be accessible by scripting languages, such as JavaScript. This setting can effectively help to reduce identity theft through XSS attacks.

gc_divisor

type: integer default: 100

See gc_probability.

gc_probability

type: integer default: 1

This defines the probability that the garbage collector (GC) process is started on every session initialization. The probability is calculated by using gc_probability / gc_divisor, e.g. 1/100 means there is a 1% chance that the GC process will start on each request.

gc_maxlifetime

type: integer default: 1440

This determines the number of seconds after which data will be seen as "garbage" and potentially cleaned up. Garbage collection may occur during session start and depends on gc_divisor and gc_probability.

save_path

type: string default: %kernel.cache_dir%/sessions

This determines the argument to be passed to the save handler. If you choose the default file handler, this is the path where the session files are created. For more information, see Configuring the Directory where Session Files are Saved.

You can also set this value to the save_path of your php.ini by setting the value to null:

1
2
3
4

# app/config/config.yml
framework:
    session:
        save_path: ~

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:session save-path="null"/>
    </framework:config>
</container>

1
2
3
4
5
6

// app/config/config.php
$container->loadFromExtension('framework', [
    'session' => [
        'save_path' => null,
    ],
]);

metadata_update_threshold

type: integer default: 0

This is how many seconds to wait between updating/writing the session metadata. This can be useful if, for some reason, you want to limit the frequency at which the session persists, instead of doing that on every request.

enabled

type: boolean default: true

Whether to enable the session support in the framework.

1
2
3
4

# app/config/config.yml
framework:
    session:
        enabled: true

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:session enabled="true"/>
    </framework:config>
</container>

1
2
3
4
5
6

// app/config/config.php
$container->loadFromExtension('framework', [
    'session' => [
        'enabled' => true,
    ],
]);

use_cookies

type: boolean default: null

This specifies if the session ID is stored on the client side using cookies or not. By default, it will use the value defined in the php.ini with the session.use_cookies directive.

base_path

type: string

This option allows you to define a base path to be used for assets:

1
2
3
4
5

# app/config/config.yml
framework:
    # ...
    assets:
        base_path: '/images'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:assets base-path="/images"/>
    </framework:config>
</container>

1
2
3
4
5
6
7

// app/config/config.php
$container->loadFromExtension('framework', [
    // ...
    'assets' => [
        'base_path' => '/images',
    ],
]);

base_urls

type: array

This option allows you to define base URLs to be used for assets. If multiple base URLs are provided, Symfony will select one from the collection each time it generates an asset's path:

1
2
3
4
5
6

# app/config/config.yml
framework:
    # ...
    assets:
        base_urls:
            - 'http://cdn.example.com/'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:assets base-url="http://cdn.example.com/"/>
    </framework:config>
</container>

1
2
3
4
5
6
7

// app/config/config.php
$container->loadFromExtension('framework', [
    // ...
    'assets' => [
        'base_urls' => ['http://cdn.example.com/'],
    ],
]);

packages

You can group assets into packages, to specify different base URLs for them:

1
2
3
4
5
6
7

# app/config/config.yml
framework:
    # ...
    assets:
        packages:
            avatars:
                base_urls: 'http://static_cdn.example.com/avatars'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:assets>
            <framework:package
                name="avatars"
                base-url="http://static_cdn.example.com/avatars"/>
        </framework:assets>
    </framework:config>
</container>

1
2
3
4
5
6
7
8
9
10
11

// app/config/config.php
$container->loadFromExtension('framework', [
    // ...
    'assets' => [
        'packages' => [
            'avatars' => [
                'base_urls' => 'http://static_cdn.example.com/avatars',
            ],
        ],
    ],
]);

Now you can use the avatars package in your templates:

1

<img src="{{ asset('...', 'avatars') }}">

Each package can configure the following options:

• base_path
• base_urls
• version_strategy
• version
• version_format
• json_manifest_path

version

type: string

This option is used to bust the cache on assets by globally adding a query parameter to all rendered asset paths (e.g. /images/logo.png?v2). This applies only to assets rendered via the Twig asset() function (or PHP equivalent) as well as assets rendered with Assetic.

For example, suppose you have the following:

1

<img src="{{ asset('images/logo.png') }}" alt="Symfony!"/>

By default, this will render a path to your image such as /images/logo.png. Now, activate the version option:

1
2
3
4
5

# app/config/config.yml
framework:
    # ...
    assets:
        version: 'v2'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:assets version="v2"/>
    </framework:config>
</container>

1
2
3
4
5
6
7

// app/config/config.php
$container->loadFromExtension('framework', [
    // ...
    'assets' => [
        'version' => 'v2',
    ],
]);

Now, the same asset will be rendered as /images/logo.png?v2 If you use this feature, you must manually increment the version value before each deployment so that the query parameters change.

You can also control how the query string works via the version_format option.

version_format

type: string default: %%s?%%s

This specifies a sprintf pattern that will be used with the version option to construct an asset's path. By default, the pattern adds the asset's version as a query string. For example, if version_format is set to %%s?version=%%s and version is set to 5, the asset's path would be /images/logo.png?version=5.

version_strategy

type: string default: null

The service id of the asset version strategy applied to the assets. This option can be set globally for all assets and individually for each asset package:

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

# app/config/config.yml
framework:
    assets:
        # this strategy is applied to every asset (including packages)
        version_strategy: 'app.asset.my_versioning_strategy'
        packages:
            foo_package:
                # this package removes any versioning (its assets won't be versioned)
                version: ~
            bar_package:
                # this package uses its own strategy (the default strategy is ignored)
                version_strategy: 'app.asset.another_version_strategy'
            baz_package:
                # this package inherits the default strategy
                base_path: '/images'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:assets version-strategy="app.asset.my_versioning_strategy">
            <!-- this package removes any versioning (its assets won't be versioned) -->
            <framework:package
                name="foo_package"
                version="null"/>
            <!-- this package uses its own strategy (the default strategy is ignored) -->
            <framework:package
                name="bar_package"
                version-strategy="app.asset.another_version_strategy"/>
            <!-- this package inherits the default strategy -->
            <framework:package
                name="baz_package"
                base_path="/images"/>
        </framework:assets>
    </framework:config>
</container>

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

// app/config/config.php
$container->loadFromExtension('framework', [
    'assets' => [
        'version_strategy' => 'app.asset.my_versioning_strategy',
        'packages' => [
            'foo_package' => [
                // this package removes any versioning (its assets won't be versioned)
                'version' => null,
            ],
            'bar_package' => [
                // this package uses its own strategy (the default strategy is ignored)
                'version_strategy' => 'app.asset.another_version_strategy',
            ],
            'baz_package' => [
                // this package inherits the default strategy
                'base_path' => '/images',
            ],
        ],
    ],
]);

json_manifest_path

type: string default: null

The file path to a manifest.json file containing an associative array of asset names and their respective compiled names. A common cache-busting technique using a "manifest" file works by writing out assets with a "hash" appended to their file names (e.g. main.ae433f1cb.css) during a front-end compilation routine.

This option can be set globally for all assets and individually for each asset package:

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

# app/config/config.yml
framework:
    assets:
        # this manifest is applied to every asset (including packages)
        json_manifest_path: "%kernel.project_dir%/web/assets/manifest.json"
        packages:
            foo_package:
                # this package uses its own manifest (the default file is ignored)
                json_manifest_path: "%kernel.project_dir%/web/assets/a_different_manifest.json"
            bar_package:
                # this package uses the global manifest (the default file is used)
                base_path: '/images'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <!-- this manifest is applied to every asset (including packages) -->
        <framework:assets json-manifest-path="%kernel.project_dir%/web/assets/manifest.json">
            <!-- this package uses its own manifest (the default file is ignored) -->
            <framework:package
                name="foo_package"
                json-manifest-path="%kernel.project_dir%/web/assets/a_different_manifest.json"/>
            <!-- this package uses the global manifest (the default file is used) -->
            <framework:package
                name="bar_package"
                base-path="/images"/>
        </framework:assets>
    </framework:config>
</container>

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

// app/config/config.php
$container->loadFromExtension('framework', [
    'assets' => [
        // this manifest is applied to every asset (including packages)
        'json_manifest_path' => '%kernel.project_dir%/web/assets/manifest.json',
        'packages' => [
            'foo_package' => [
                // this package uses its own manifest (the default file is ignored)
                'json_manifest_path' => '%kernel.project_dir%/web/assets/a_different_manifest.json',
            ],
            'bar_package' => [
                // this package uses the global manifest (the default file is used)
                'base_path' => '/images',
            ],
        ],
    ],
]);

hinclude_default_template

type: string default: null

Sets the content shown during the loading of the fragment or when JavaScript is disabled. This can be either a template name or the content itself.

form

1
2
3
4
5
6

# app/config/config.yml
framework:
    templating:
        form:
            resources:
                - 'WebsiteBundle:Form'

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>

        <framework:templating>

            <framework:form>

                <framework:resource>WebsiteBundle:Form</framework:resource>

            </framework:form>

        </framework:templating>

    </framework:config>
</container>

1
2
3
4
5
6
7
8
9
10

// app/config/config.php
$container->loadFromExtension('framework', [
    'templating' => [
        'form' => [
            'resources' => [
                'WebsiteBundle:Form',
            ],
        ],
    ],
]);

cache

type: string

The path to the cache directory for templates. When this is not set, caching is disabled.

engines

type: string[] / string required

The Templating Engine to use. This can either be a string (when only one engine is configured) or an array of engines.

At least one engine is required.

loaders

type: string[]

An array (or a string when configuring just one loader) of service ids for templating loaders. Templating loaders are used to find and load templates from a resource (e.g. a filesystem or database). Templating loaders must implement LoaderInterface.

enabled

type: boolean default: false

Whether or not to enable the translator service in the service container.

fallbacks

type: string|array default: ['en']

This option is used when the translation key for the current locale wasn't found.

logging

default: true when the debug mode is enabled, false otherwise.

When true, a log entry is made whenever the translator cannot find a translation for a given key. The logs are made to the translation channel and at the debug for level for keys where there is a translation in the fallback locale and the warning level if there is no translation to use at all.

formatter

type: string default: translator.formatter.default

The ID of the service used to format translation messages. The service class must implement the MessageFormatterInterface.

paths

type: array default: []

This option allows to define an array of paths where the component will look for translation files.

default_path

type: string default: %kernel.project_dir%/translations

This option allows to define the path where the application translations files are stored.

magic_call

type: boolean default: false

When enabled, the property_accessor service uses PHP's magic __call() method when its getValue() method is called.

throw_exception_on_invalid_index

type: boolean default: false

When enabled, the property_accessor service throws an exception when you try to access an invalid index of an array.

enabled

type: boolean default: false

enabled

type: boolean default: true if form support is enabled, false otherwise

Whether or not to enable validation support.

This option will automatically be set to true when one of the child settings is configured.

cache

type: string

The service that is used to persist class metadata in a cache. The service has to implement the CacheInterface.

Set this option to validator.mapping.cache.doctrine.apc to use the APC cache provide from the Doctrine project.

enable_annotations

type: boolean default: false

If this option is enabled, validation constraints can be defined using annotations.

translation_domain

type: string | false default: validators

The translation domain that is used when translating validation constraint error messages. Use false to disable translations.

static_method

type: string | array default: ['loadValidatorMetadata']

Defines the name of the static method which is called to load the validation metadata of the class. You can define an array of strings with the names of several methods. In that case, all of them will be called in that order to load the metadata.

strict_email

type: Boolean default: false

If this option is enabled, the egulias/email-validator library will be used by the Email constraint validator. Otherwise, the validator uses a simple regular expression to validate email addresses.

mapping

cache

type: string default: 'file'

This option can be one of the following values:

file

Use the filesystem to cache annotations

none

Disable the caching of annotations

a service id

A service id referencing a Doctrine Cache implementation

file_cache_dir

type: string default: '%kernel.cache_dir%/annotations'

The directory to store cache files for annotations, in case annotations.cache is set to 'file'.

debug

type: boolean default: %kernel.debug%

Whether to enable debug mode for caching. If enabled, the cache will automatically update when the original file is changed (both with code and annotation changes). For performance reasons, it is recommended to disable debug mode in production, which will happen automatically if you use the default value.

enabled

type: boolean default: false

Whether to enable the serializer service or not in the service container.

cache

type: string

The service that is used to persist class metadata in a cache. The service has to implement the Doctrine\Common\Cache\Cache interface.

enable_annotations

type: boolean default: false

If this option is enabled, serialization groups can be defined using annotations.

name_converter

type: string

The name converter to use. The CamelCaseToSnakeCaseNameConverter name converter can enabled by using the serializer.name_converter.camel_case_to_snake_case value.

circular_reference_handler

type string

The service id that is used as the circular reference handler of the default serializer. The service has to implement the magic __invoke($object) method.

mapping

log

type: boolean default: %kernel.debug%

Use the application logger instead of the PHP logger for logging PHP errors.

throw

type: boolean default: %kernel.debug%

Throw PHP errors as \ErrorException instances. The parameter debug.error_handler.throw_at controls the threshold.

app

type: string default: cache.adapter.filesystem

The cache adapter used by the cache.app service. The FrameworkBundle ships with multiple adapters: cache.adapter.apcu, cache.adapter.doctrine, cache.adapter.system, cache.adapter.filesystem, cache.adapter.psr6, cache.adapter.redis and cache.adapter.memcached.

system

type: string default: cache.adapter.system

The cache adapter used by the cache.system service. It supports the same adapters available for the cache.app service.

directory

type: string default: %kernel.cache_dir%/pools

The path to the cache directory used by services inheriting from the cache.adapter.filesystem adapter (including cache.app).

default_doctrine_provider

type: string

The service name to use as your default Doctrine provider. The provider is available as the cache.default_doctrine_provider service.

default_psr6_provider

type: string

The service name to use as your default PSR-6 provider. It is available as the cache.default_psr6_provider service.

default_redis_provider

type: string default: redis://localhost

The DSN to use by the Redis provider. The provider is available as the cache.default_redis_provider service.

default_memcached_provider

type: string default: memcached://localhost

The DSN to use by the Memcached provider. The provider is available as the cache.default_memcached_provider service.

pools

type: array

A list of cache pools to be created by the framework extension.

To configure a Redis cache pool with a default lifetime of 1 hour, do the following:

1
2
3
4
5
6
7

# app/config/config.yml
framework:
    cache:
        pools:
            cache.mycache:
                adapter: cache.adapter.redis
                default_lifetime: 3600

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

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:cache>
            <framework:pool
                name="cache.mycache"
                adapter="cache.adapter.redis"
                default-lifetime=3600
            />
        </framework:cache>
        <!-- ... -->
    </framework:config>
</container>

1
2
3
4
5
6
7
8
9
10
11

// app/config/config.php
$container->loadFromExtension('framework', [
    'cache' => [
        'pools' => [
            'cache.mycache' => [
                'adapter' => 'cache.adapter.redis',
                'default_lifetime' => 3600,
            ],
        ],
    ],
]);

prefix_seed

type: string default: null

If defined, this value is used as part of the "namespace" generated for the cache item keys. A common practice is to use the unique name of the application (e.g. symfony.com) because that prevents naming collisions when deploying multiple applications into the same path (on different servers) that share the same cache backend.

It's also useful when using blue/green deployment strategies and more generally, when you need to abstract out the actual deployment directory (for example, when warming caches offline).

enabled

type: boolean default: true

Whether to enable the support for lock or not. This setting is automatically set to true when one of the child settings is configured.

resources

type: array

A list of lock stores to be created by the framework extension.

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

# app/config/config.yml
framework:
    # these are all the supported lock stores
    lock: ~
    lock: 'flock'
    lock: 'semaphore'
    lock: 'memcached://m1.docker'
    lock: ['memcached://m1.docker', 'memcached://m2.docker']
    lock: 'redis://r1.docker'
    lock: ['redis://r1.docker', 'redis://r2.docker']
    lock: '%env(MEMCACHED_OR_REDIS_URL)%'

    # named locks
    lock:
        invoice: ['redis://r1.docker', 'redis://r2.docker']
        report: 'semaphore'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<!-- app/config/config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:framework="http://symfony.com/schema/dic/symfony"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        https://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/symfony https://symfony.com/schema/dic/symfony/symfony-1.0.xsd">

    <framework:config>
        <framework:lock>
            <!-- these are all the supported lock stores -->
            <framework:resource>flock</framework:resource>

            <framework:resource>semaphore</framework:resource>

            <framework:resource>memcached://m1.docker</framework:resource>

            <framework:resource>memcached://m1.docker</framework:resource>
            <framework:resource>memcached://m2.docker</framework:resource>

            <framework:resource>redis://r1.docker</framework:resource>

            <framework:resource>redis://r1.docker</framework:resource>
            <framework:resource>redis://r2.docker</framework:resource>

            <framework:resource>%env(REDIS_URL)%</framework:resource>

            <!-- named locks -->
            <framework:resource name="invoice">redis://r1.docker</framework:resource>
            <framework:resource name="invoice">redis://r2.docker</framework:resource>
            <framework:resource name="report">semaphore</framework:resource>
        </framework:lock>
    </framework:config>
</container>

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

// app/config/config.php
$container->loadFromExtension('framework', [
    // these are all the supported lock stores
    'lock' => null,
    'lock' => 'flock',
    'lock' => 'semaphore',
    'lock' => 'memcached://m1.docker',
    'lock' => ['memcached://m1.docker', 'memcached://m2.docker'],
    'lock' => 'redis://r1.docker',
    'lock' => ['redis://r1.docker', 'redis://r2.docker'],
    'lock' => '%env(MEMCACHED_OR_REDIS_URL)%',

    // named locks
    'lock' => [
        'invoice' => ['redis://r1.docker', 'redis://r2.docker'],
        'report' => 'semaphore',
    ],
]);

1
2
3
4

lock.invoice.retry_till_save.store:
    class: Symfony\Component\Lock\Store\RetryTillSaveStore
    decorates: lock.invoice.store
    arguments: ['@lock.invoice.retry_till_save.store.inner', 100, 50]

enabled

type: boolean default: false

Whether to enable the support for workflows or not. This setting is automatically set to true when one of the child settings is configured.

name

type: prototype

Name of the workflow you want to create.