src/AppBundle/Session/LegacySessionHandler.php line 16

Open in your IDE?
  1. <?php
  3. namespace AppBundle\Session;
  5. use Doctrine\DBAL\Connection;
  6. use Doctrine\DBAL\Driver\DriverException;
  7. use Doctrine\DBAL\Platforms\SQLServer2008Platform;
  9. /**
  10.  * Copied from Symfony\Bridge\Doctrine\HttpFoundation\DbalSessionHandler,
  11.  * but the existing sessions table we need to interface with for compatibility
  12.  * with uses different column names (and these properties are defined as private),
  13.  * the timestamp is a datetime field rather than integer, and the main data column
  14.  * is a blob (no encoding)
  15.  */
  16. class LegacySessionHandler implements \SessionHandlerInterface
  17. {
  18.     /**
  19.      * @var Connection
  20.      */
  21.     private $con;
  23.     /**
  24.      * @var string
  25.      */
  26.     private $table;
  28.     /**
  29.      * @var string Column for session id
  30.      */
  31.     private $idCol = 'sessionId';
  33.     /**
  34.      * @var string Column for session data
  35.      */
  36.     private $dataCol = 'contents';
  38.     /**
  39.      * @var string Column for timestamp
  40.      */
  41.     private $timeCol = 'modify_date';
  43.     /**
  44.      * Constructor.
  45.      *
  46.      * @param Connection $con       A connection
  47.      * @param string     $tableName Table name
  48.      */
  49.     public function __construct(Connection $con, $tableName = 'sessions')
  50.     {
  51.         $this->con = $con;
  52.         $this->table = $tableName;
  53.     }
  55.     /**
  56.      * {@inheritdoc}
  57.      */
  58.     public function open($savePath, $sessionName): bool
  59.     {
  60.         return true;
  61.     }
  63.     /**
  64.      * {@inheritdoc}
  65.      */
  66.     public function close(): bool
  67.     {
  68.         return true;
  69.     }
  71.     /**
  72.      * {@inheritdoc}
  73.      */
  74.     public function destroy($sessionId): bool
  75.     {
  76.         // delete the record associated with this id
  77.         $sql = "DELETE FROM $this->table WHERE $this->idCol = :id";
  79.         try {
  80.             $stmt = $this->con->prepare($sql);
  81.             $stmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
  82.             $stmt->execute();
  83.         } catch (\Exception $e) {
  84.             throw new \RuntimeException(sprintf('Exception was thrown when trying to delete a session: %s', $e->getMessage()), 0, $e);
  85.         }
  87.         return true;
  88.     }
  90.     /**
  91.      * {@inheritdoc}
  92.      */
  93.     public function gc($maxlifetime): bool
  94.     {
  95.         // delete the session records that have expired
  96.         $sql = "DELETE FROM $this->table WHERE $this->timeCol < :time";
  98.         try {
  99.             $stmt = $this->con->prepare($sql);
  100.             $stmt->bindValue(':time', date('Y-m-d H:i:s', time() - $maxlifetime), \PDO::PARAM_STR);
  101.             $stmt->execute();
  102.         } catch (\Exception $e) {
  103.             throw new \RuntimeException(sprintf('Exception was thrown when trying to delete expired sessions: %s', $e->getMessage()), 0, $e);
  104.         }
  106.         return true;
  107.     }
  109.     /**
  110.      * {@inheritdoc}
  111.      */
  112.     public function read($sessionId): bool
  113.     {
  114.         $sql = "SELECT $this->dataCol FROM $this->table WHERE $this->idCol = :id";
  116.         try {
  117.             $stmt = $this->con->prepare($sql);
  118.             $stmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
  119.             $stmt->execute();
  121.             // We use fetchAll instead of fetchColumn to make sure the DB cursor gets closed
  122.             $sessionRows = $stmt->fetchAll(\PDO::FETCH_NUM);
  124.             if ($sessionRows) {
  125.                 return $sessionRows[0][0];
  126.             }
  128.             return '';
  129.         } catch (\Exception $e) {
  130.             throw new \RuntimeException(sprintf('Exception was thrown when trying to read the session data: %s', $e->getMessage()), 0, $e);
  131.         }
  132.     }
  134.     /**
  135.      * {@inheritdoc}
  136.      */
  137.     public function write($sessionId, $data): bool
  138.     {
  139.         try {
  140.             // We use a single MERGE SQL query when supported by the database.
  141.             $mergeSql = $this->getMergeSql();
  143.             if (null !== $mergeSql) {
  144.                 $mergeStmt = $this->con->prepare($mergeSql);
  145.                 $mergeStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
  146.                 $mergeStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
  147.                 $mergeStmt->bindValue(':time', date('Y-m-d H:i:s'), \PDO::PARAM_STR);
  148.                 $mergeStmt->execute();
  150.                 return true;
  151.             }
  153.             $updateStmt = $this->con->prepare(
  154.                 "UPDATE $this->table SET $this->dataCol = :data, $this->timeCol = :time WHERE $this->idCol = :id"
  155.             );
  156.             $updateStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
  157.             $updateStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
  158.             $updateStmt->bindValue(':time', date('Y-m-d H:i:s'), \PDO::PARAM_STR);
  159.             $updateStmt->execute();
  161.             // When MERGE is not supported, like in Postgres, we have to use this approach that can result in
  162.             // duplicate key errors when the same session is written simultaneously. We can just catch such an
  163.             // error and re-execute the update. This is similar to a serializable transaction with retry logic
  164.             // on serialization failures but without the overhead and without possible false positives due to
  165.             // longer gap locking.
  166.             if (!$updateStmt->rowCount()) {
  167.                 try {
  168.                     $insertStmt = $this->con->prepare(
  169.                         "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->timeCol) VALUES (:id, :data, :time)"
  170.                     );
  171.                     $insertStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
  172.                     $insertStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
  173.                     $insertStmt->bindValue(':time', date('Y-m-d H:i:s'), \PDO::PARAM_STR);
  174.                     $insertStmt->execute();
  175.                 } catch (\Exception $e) {
  176.                     $driverException = $e->getPrevious();
  177.                     // Handle integrity violation SQLSTATE 23000 (or a subclass like 23505 in Postgres) for duplicate keys
  178.                     // DriverException only available since DBAL 2.5
  179.                     if (
  180.                         ($driverException instanceof DriverException && 0 === strpos($driverException->getSQLState(), '23')) ||
  181.                         ($driverException instanceof \PDOException && 0 === strpos($driverException->getCode(), '23'))
  182.                     ) {
  183.                         $updateStmt->execute();
  184.                     } else {
  185.                         throw $e;
  186.                     }
  187.                 }
  188.             }
  189.         } catch (\Exception $e) {
  190.             throw new \RuntimeException(sprintf('Exception was thrown when trying to write the session data: %s', $e->getMessage()), 0, $e);
  191.         }
  193.         return true;
  194.     }
  196.     /**
  197.      * Returns a merge/upsert (i.e. insert or update) SQL query when supported by the database.
  198.      *
  199.      * @return string|null The SQL string or null when not supported
  200.      */
  201.     private function getMergeSql()
  202.     {
  203.         $platform = $this->con->getDatabasePlatform()->getName();
  205.         switch ($platform) {
  206.             case 'mysql':
  207.                 return "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->timeCol) VALUES (:id, :data, :time) ".
  208.                     "ON DUPLICATE KEY UPDATE $this->dataCol = VALUES($this->dataCol), $this->timeCol = VALUES($this->timeCol)";
  209.             case 'oracle':
  210.                 // DUAL is Oracle specific dummy table
  211.                 return "MERGE INTO $this->table USING DUAL ON ($this->idCol = :id) ".
  212.                     "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->timeCol) VALUES (:id, :data, :time) ".
  213.                     "WHEN MATCHED THEN UPDATE SET $this->dataCol = :data, $this->timeCol = :time";
  214.             case $this->con->getDatabasePlatform() instanceof SQLServer2008Platform:
  215.                 // MERGE is only available since SQL Server 2008 and must be terminated by semicolon
  216.                 // It also requires HOLDLOCK according to http://weblogs.sqlteam.com/dang/archive/2009/01/31/UPSERT-Race-Condition-With-MERGE.aspx
  217.                 return "MERGE INTO $this->table WITH (HOLDLOCK) USING (SELECT 1 AS dummy) AS src ON ($this->idCol = :id) ".
  218.                     "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->timeCol) VALUES (:id, :data, :time) ".
  219.                     "WHEN MATCHED THEN UPDATE SET $this->dataCol = :data, $this->timeCol = :time;";
  220.             case 'sqlite':
  221.                 return "INSERT OR REPLACE INTO $this->table ($this->idCol, $this->dataCol, $this->timeCol) VALUES (:id, :data, :time)";
  222.         }
  223.     }
  224. }