Symfony 3.4 - 从命令切换到动态数据库

Question

Recently I've been busy upgrading an older project from Symfony 2.7 to 3.4. The project uses a custom multi tenant setup and relies on a EventListener to switch between databases based on subdomain. This works since I can define the priority of that EventListener in my services.yml file so it's loaded before any other services. By doing that all my other code uses that database set by the listener.

    current_site_listener:
        class: AppBundle\Event\Listener\CurrentSiteListener
        arguments: ["@doctrine.dbal.default_connection", "%base_host%"]
        tags:
          - { name: kernel.event_listener, event: kernel.request, method: onKernelRequest, priority: 10 }

So far so good, but unfortunately that logic does not work for any of my tenant specific commands. These commands use an argument option to define which database should be used. Since I can't define a priority for these commands the other services are already loaded and I am not able to override the database connection from within the command. The code below is what I'm using in both the command and EventListener and works fine in the latter (and also worked fine in Symfony 2.7 within the command).

        $connectionParams = array(
            'dbname' => $client['database_name'],
            'user' => $client['database_login'],
            'password' => $client['database_password'],
            'host' => $client['database_host'],
            'driver' => 'pdo_mysql',
            'charset' =>  'UTF8'
        );

        /** @var Connection $connection */
        $connection = $this->container->get('doctrine.dbal.default_connection');

        if ($connection->isConnected()) {
            $connection->close();
        }
        $connection->__construct(
            $connectionParams, $connection->getDriver(), $connection->getConfiguration(),
            $connection->getEventManager()
        );

The code above was working fine in Symfony 2.7 but my guess is that between that version and Symfony 3.4 something has changed in the way services work and I am not able to override them anymore with my current database connection. I haven't come across any changes regarding this issue in the migration docs and am therefore clueless on how to solve this. I'm hoping someone on here has any ideas or suggestions on how to fix this.

Thanks in advance and kind regards,

Kevin

Answer 1

The problem is you can not change the connection parameters in runtime, I had the same before in Symfony 3.4 and I made a workaround that by extending connection to support change parameters in runtime.

I finally had created a Symfony bundle just for that

https://github.com/RamyHakam/doctrine-db-switcher-bundle But It will work only on Symfony 4+

However, I can share the idea of it with you it should work on Symfony 3.4

You should configure your connection like this example

connections:
  default:
    driver: ''
    charset: 
    host: ''
    port: ''
    dbname: ''
    user: ''
    password: ''
    wrapper_class: App\Doctrine\DBAL\TenantConnection

Where wrapper_class is your new conneciton

Class Example:

    
    namespace App\Doctrine\DBAL;
    
    use Doctrine\Common\EventManager;
    use Doctrine\DBAL\Configuration;
    use Doctrine\DBAL\Connection;
    use Doctrine\DBAL\Driver;
    use Doctrine\DBAL\Events;
    use Doctrine\DBAL\Event;
    
    class TenantConnection extends Connection
    {
        /** @var mixed */
        protected $params = [];
        /** @var bool */
        protected $isConnected = false;
        /** @var bool */
        protected $autoCommit = true;
    
        /**
         * TenantConnection constructor.
         *
         * @param $params
         * @param Driver $driver
         * @param Configuration|null $config
         * @param EventManager|null $eventManager
         * @throws \Doctrine\DBAL\DBALException
         */
        public function __construct($params, Driver $driver, ?Configuration $config = null, ?EventManager $eventManager = null)
        {
            $this->params = $params;
            parent::__construct($params, $driver, $config, $eventManager);
        }
    
        /**
         * @return bool
         */
        public function connect()
        {
            if ($this->isConnected) {
                return false;
            }
    
            $driverOptions = $this->params['driverOptions'] ?? [];
            $user = $this->params['user'] ?? null;
            $password = $this->params['password'] ?? null;
    
            $this->_conn = $this->_driver->connect($this->params, $user, $password, $driverOptions);
            $this->isConnected = true;
    
            if ($this->autoCommit === false) {
                $this->beginTransaction();
            }
    
            if ($this->_eventManager->hasListeners(Events::postConnect)) {
                $eventArgs = new Event\ConnectionEventArgs($this);
                $this->_eventManager->dispatchEvent(Events::postConnect, $eventArgs);
            }
    
            return true;
        }
    
        /**
         * @param string $dbName
         * @param string $dbUser
         * @param string $dbPassword
         */
        public function changeParams(string $dbName, string $dbUser, string $dbPassword)
        {
            $this->params['dbname'] = $dbName;
            $this->params['user'] = $dbUser;
            $this->params['password'] = $dbPassword;
        }
    
        public function reconnect()
        {
            if ($this->isConnected) {
                $this->close();
            }
    
            $this->connect();
        }
    
        /**
         * @return mixed|mixed[]
         */
        public function getParams()
        {
            return $this->params;
        }
    
        public function close()
        {
            $this->_conn = null;
    
            $this->isConnected = false;
        }

Then in your event listener, you can switch the connection to another DB

Example:

    namespace App\EventListener;
    
    
    use App\Doctrine\DBAL\TenantConnection;
    use App\Main\Domain\Model\Tenant;
    use App\Main\Infrastructure\Persistence\Doctrine\Repository\TenantRepository;
    use Symfony\Component\DependencyInjection\ContainerInterface;
    use Symfony\Component\EventDispatcher\EventSubscriberInterface;
    use Symfony\Component\HttpFoundation\Session\SessionInterface;
    use Symfony\Component\HttpKernel\Event\RequestEvent;
    
    class RequestListener implements EventSubscriberInterface
    {
        /**
         * @var ContainerInterface
         */
        private $container;
        /**
         * @var SessionInterface
         */
        private $session;
        /**
         * @var TenantRepository
         */
        private $tenantRepository;
    
        public function __construct(ContainerInterface $container,TenantRepository $tenantRepository)
        {
            $this->container = $container;
            $this->tenantRepository = $tenantRepository;
        }
    
        public static function getSubscribedEvents()
        {
            return [
                RequestEvent::class => 'onKernelRequest'
            ];
        }
    
        public function onKernelRequest( RequestEvent $event)
        {
            $userAgent = $event->getRequest()->headers->get('user_identifier');
    
            /**
             * @var TenantConnection $tenantConnection
             */
           $tenantConnection = $this->container->get('doctrine')->getConnection('tenant');
           /**@var Tenant $tenant */
            $tenants = $this->tenantRepository->findAll();
    
            $tenant = $tenants[1];
    
            $tenantConnection->changeParams($tenant->getDbName(), $tenant->getDbUserName(), $tenant->getDbPassword());
            $tenantConnection->reconnect();
        }
    }


  [1]: https://github.com/RamyHakam/doctrine-db-switcher-bundle