Migration progressive

git shortlog --summary

/**
 * @param GetResponseEvent $event
 *
 * @return GetResponseEvent
 */
public function onKernelRequest(GetResponseEvent $event)
{
    try {
        $this->routerListener->onKernelRequest($event);
    } catch (NotFoundHttpException $e) {
        // Log ...

        $response = $this->legacyKernel->handle($event->getRequest(), 
            $event->getRequestType(), true);

        if ($response->getStatusCode() !== 404) {
            $event->setResponse($response);

            return $event;
        }
    }
}

class Symfony10Kernel extends LegacyKernel
{
    /** @var ContainerInterface */
    private $container;

    public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
    {
        $context = $this->setUpContext($request);

        ob_start();
        // Dispatch request
        try {
            $context->getController()->dispatch();
        } catch (\sfStopException $e) {
        } catch (\Exception $e) {
            throw $e;
        } finally {
            $context->shutdown();
        }
        $stdout = ob_get_contents();
        ob_end_clean();

        return $this->convertResponse($context->getResponse(), $stdout);
    }

    // ...
}

# app/config/config.yml

theodo_evolution_legacy_wrapper:
    root_dir: %kernel.root_dir%/../legacy
    kernel:
        id: legacy.kernel.symfony10
        options:
            application: frontend
            environment: '%kernel.environment%'
            debug:       '%kernel.debug%'

class BagConfiguration implements BagManagerConfigurationInterface
{
    private $namespaces = array(
        BagManagerConfigurationInterface::LAST_REQUEST_NAMESPACE => 'symfony/user/sfUser/lastRequest',
        BagManagerConfigurationInterface::AUTH_NAMESPACE         => 'symfony/user/sfUser/authenticated',
        BagManagerConfigurationInterface::CREDENTIAL_NAMESPACE   => 'symfony/user/sfUser/credentials',
        BagManagerConfigurationInterface::ATTRIBUTE_NAMESPACE    => 'symfony/user/sfUser/attributes',
        BagManagerConfigurationInterface::CULTURE_NAMESPACE      => 'symfony/user/sfUser/culture',
    );

    /**
     * {@inheritdoc}
     */
    public function getNamespaces()
    {
        return $this->namespaces;
    }

    /**
     * {@inheritdoc}
     */
    public function getNamespace($key)
    {
        return $this->namespaces[$key];
    }
}

namespace Veolys\LegacyBundle\Security\Firewall;

/**
 * Retrieves the user ID from the symfony1 session.
 */
class Symfony1SessionListener extends AbstractPreAuthenticatedListener
{
    /**
     * Gets the user and credentials from the Request.
     */
    protected function getPreAuthenticatedData(Request $request)
    {
        if (!$this->veolysSession->isAuthenticated()) {
            // For call the entryPoint and redirect the user to /
            throw new BadCredentialsException();
        }

        return [(string) $this->veolysSession->getUserId(), null];
    }
}

mysql> select id, name from veolys_permission;

+-----+-------------------------------------------------+
| id  | name                                            |
+-----+-------------------------------------------------+
|   1 | Building/Edit                                   |
|   3 | HotlineRequest/View                             |
|   5 | HotlineRequest/ViewAll                          |
|   6 | HotlineRequest/Post                             |
|   7 | HotlineRequest/PostForAll                       |
|   8 | HotlineRequest/DetailsChangeDescription         |
|   9 | HotlineRequest/DetailsDecideConclusion          |
|  16 | HotlineRequest/IsDispatcher                     |

# ...

| 158 | HotlineRequest/DelayAlert                       |
| 159 | HotlineRequest/Indicators                       |
| 160 | HotlineRequest/Lots                             |
+-----+-------------------------------------------------+
149 rows in set (0.00 sec)

namespace Veolys\LegacyBundle\Security\Authentication\Provider;

/**
 * Retrieves the user and his rights from the database
 */
class Symfony1SessionProvider implements AuthenticationProviderInterface
{
    public function authenticate(TokenInterface $token)
    {
        $username = $token->getUsername();
        $user = $this->userProvider
            ->loadUserByUsername($username) // l'Id qui vient du PreAuthenticatedListener
        ;

        if (!$user) {
            throw new AuthenticationException('The symfony1 session authentication failed.');
        }

        $roles = $this->em
            ->getRepository('VeolysApplicationBundle:VeolysUser')
            ->getRoles($user)
        ;
        $user->setRoles($roles);

        $authenticatedToken = new PreAuthenticatedToken($user, null, 'veolys', $roles);

        return $authenticatedToken;
    }
}

    public function getRoles($user)
    {
        $permissions = $this->getUserPermissions();
  
        $roles = array_map(
            function ($permission) {
                preg_match_all('#((?:^|[A-Z])[a-z]+)/?#', $permission['name'], $matches);
                $name = strtoupper(implode('_', $matches[1]));

                return 'ROLE_'.$name;
            },
            $permissions
        );

        if ($user->isSuperAdmin()) {
            $roles[] = 'ROLE_SUPER_ADMIN';
        }

        $roles[] = 'ROLE_USER';

        return $roles;
    }

/**
 * @Route("/edit", name="i_love_veolys")
 *
 * @Security("has_role('ROLE_HOTLINE_REQUEST_POST')")
 */
public function editAction(Request $request): Response
{
}

Estimation: il faudra {{ random(20) + 20 }} jours 
+ 3 jours de récup 

// src/LegacyBundle/Kernel/Symfony10Kernel.php

class Symfony10Kernel extends LegacyKernel
{
    /**
     * Call the notify method from the legacy UserBroadCastList model.
     */
    public function notify($objectSF3)
    {
        // Map the doctrine entity to the propel model
        $legacyObject = $this->transformToLegacy($objectSF3);

        // Call the symfony1 method to get a UserBroadcastList
        $userBroadCastList = $legacyObject->getOrCreateUserBroadcastList();

        // Call the legacy method notify
        try {
            $broadCastList->notify($legacyObject);
        } catch (\Exception $e) {
        }
    }

    // ...
}

namespace AppBundle\Event;

class NotifyObjectEvent extends Event
{
    const NAME = 'veolys.notify_object';

    protected $object;

    public function __construct(NotifiableObjectInterface $object)
    {
        $this->object = $object;
    }

    public function getObject()
    {
        return $this->object;
    }
}

class NotifyObjectListener implements EventSubscriberInterface
{
    /** @var LoggerInterface */
    protected $logger;

    /** @var Symfony10Kernel */
    protected $kernel;

    /** @var Request */
    protected $request;

    public function notify(NotifyObjectEvent $event)
    {
        $object = $event->getObject();
        if (!$this->supports($object)) {
            return;
        }

        $this->kernel->notify($this->request, $object);

        $this->logger->notice('Legacy notification', [
            'object' => get_class($object),
        ]);
    }

    public function supports($object): bool
    {
        return $object instanceof NotifiableObjectInterface;
    }
}

// src/LegacyBundle/Kernel/Symfony10Kernel.php

class Symfony10Kernel extends LegacyKernel
{
    /**
     * Call the notify method from the legacy UserBroadCastList model.
     */
    public function notify(Request $request, NotifiableObjectInterface $object)
    {
        // Map the doctrine entity to the propel model
        $legacyObject = $this->transformToLegacy($object);

        // Call the symfony1 method to get a UserBroadcastList
        $userBroadCastList = $legacyObject->getOrCreateUserBroadcastList();

        // Call the legacy method notify
        try {
            $broadCastList->notify($legacyObject);
        } catch (\Exception $e) {
        }
    }

    // ...
}

/** @var NotifiableObjectInterface $object */
$id = $object->getId();

$legacyRepositoryName = sprintf('%sPeer', (new \ReflectionClass($object))->getShortName());
if (!class_exists($legacyRepositoryName)) {
    throw new \Exception(sprintf('Invalid legacy repository peer : %s', $legacyRepositoryName));
}

$legacyObject = $legacyRepositoryName::retrieveByPK($id);
if (empty($legacyObject)) {
    throw new \Exception(sprintf('Can\'t found the object with id: %s and legacy repository peer: %s', 
        $id, $legacyRepositoryName));
}

if (!$legacyObject instanceof \Notifiable) {
    throw new \Exception(sprintf('The object % should implement Notifiable interface from legacy', 
        get_class($legacyObject)));
}

// Call the method with Reflection Api because the method getOrCreateUserBroadcastList can be private...
$method = new \ReflectionMethod(get_class($legacyObject), 'getOrCreateUserBroadcastList');
$method->setAccessible(true);

/** @var \UserBroadcastList $broadCastList */
$broadCastList = $method->invoke($legacyObject);

public function notify(Request $request, NotifiableObjectInterface $object)