public function shutdown()
{
if ($this->connection->isTransactionActive()) {
$this->rollback();
}
$this->connection->close();
}
/**
* @return Connection
*/
public function getConnection()
{
if (false === $this->connection->ping()) {
$this->connection->close();
$this->connection->connect();
}
return $this->connection;
}
private function singleImport($config, OutputInterface &$output, $entity_key = null)
{
$this->connection = $this->connectionFactory->createConnection($config['database']);
$this->connection->getConfiguration()->getSQLLogger(null);
if ($entity_key) {
if (!isset($config['maps'][$entity_key])) {
throw new \Exception("Entity alias not found: " . $entity_key);
}
$map = $config['maps'][$entity_key];
if (!$this->container->has($map['old_data']['service_id'])) {
throw new \Exception("Service not exists: " . $map['old_data']['service_id']);
}
$result = $this->importEntity($map);
$output->writeln("<info>Total " . count($result) . " {$entity_key} imported </info>");
} else {
foreach ((array) $config['maps'] as $key => $map) {
if (!$this->container->has($map['old_data']['service_id'])) {
throw new \Exception("Service not exists: " . $map['old_data']['service_id']);
}
$offset = 0;
do {
$result = $this->importEntity($map);
$output->writeln("<info>Total " . count($result) . " {$key} imported </info>");
if (!$result) {
break;
}
$offset++;
$this->setOffset($offset);
} while (true);
}
}
$this->connection->close();
}
protected function pingIt(Connection $con)
{
if ($con->ping() === false) {
$con->close();
$con->connect();
}
return $con;
}
/**
* Retrieves hte index database.
*
* @return Connection
*/
public function getConnection()
{
if (!$this->connection) {
$isNewDatabase = !file_exists($this->databasePath);
$configuration = new Configuration();
$this->connection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'path' => $this->databasePath], $configuration);
$outOfDate = null;
if ($isNewDatabase) {
$this->createDatabaseTables($this->connection);
// NOTE: This causes a database write and will cause locking problems if multiple PHP processes are
// spawned and another one is also writing (e.g. indexing).
$this->connection->executeQuery('PRAGMA user_version=' . $this->databaseVersion);
} else {
$version = $this->connection->executeQuery('PRAGMA user_version')->fetchColumn();
if ($version < $this->databaseVersion) {
$this->connection->close();
$this->connection = null;
@unlink($this->databasePath);
return $this->getConnection();
// Do it again.
}
}
}
// Have to be a douche about this as these PRAGMA's seem to reset, even though the connection is not closed.
$this->connection->executeQuery('PRAGMA foreign_keys=ON');
// Data could become corrupted if the operating system were to crash during synchronization, but this
// matters very little as we will just reindex the project next time. In the meantime, this majorly reduces
// hard disk I/O during indexing and increases indexing speed dramatically (dropped from over a minute to a
// couple of seconds for a very small (!) project).
$this->connection->executeQuery('PRAGMA synchronous=OFF');
return $this->connection;
}
protected function resetSharedConn()
{
if (self::$_sharedConn) {
self::$_sharedConn->close();
self::$_sharedConn = null;
}
}
/**
* This method checks whether the connection is still open or reconnects otherwise.
*
* The connection might drop in some scenarios, where the server has a configured timeout and the handling
* of the result set takes longer. To prevent failures of the dumper, the connection will be opened again.
*/
public function reconnectIfNecessary()
{
if (!$this->connection->ping()) {
$this->connection->close();
$this->connect();
}
}
public function tearDown()
{
$this->connection->close();
$this->eventStore = null;
$this->eventNameResolver = null;
$this->serializer = null;
$this->connection = null;
}
/**
* @return Job[]
*/
public function getAll()
{
$this->conn->connect();
$stmt = $this->conn->query("select * from {$this->table_name}");
$stmt->setFetchMode(\PDO::FETCH_CLASS, '\\ebussola\\job\\job\\Job');
$stmt->execute();
$jobs = $stmt->fetchAll();
$this->conn->close();
return $jobs;
}
/**
* close Doctrine Dbal and ORM connection and reset everything to default.
*/
public function close()
{
$this->Conn->close();
if (is_object($this->EntityManager) && method_exists($this->EntityManager, 'close')) {
$this->EntityManager->close();
}
if (function_exists('gc_collect_cycles')) {
gc_collect_cycles();
}
$this->Conn = '';
$this->EntityManager = '';
$this->table_prefix = '';
$this->table_siteid_prefix = '';
}
/**
* {@inheritDoc}
*/
public function close($force = false)
{
if ($force) {
parent::close();
$this->unsetPersistedConnection();
}
}
/**
* {@inheritDoc}
*/
public function logout()
{
if ($this->loggedIn) {
$this->loggedIn = false;
$this->conn->close();
$this->conn = null;
}
}
public function preTask(Worker $worker, array $options = null)
{
if ($worker instanceof DoctrineAwareWorker) {
if ($this->connection) {
try {
$this->connection->executeQuery('SELECT 1');
} catch (DBALException $e) {
if ($e->getPrevious()->getCode() == "HY000") {
$this->logger->info('Reconnecting doctrine', ['e' => $e]);
$this->connection->close();
} else {
throw $e;
}
}
}
}
}
public function testHeartBeatException()
{
$this->setExpectedException('\\RuntimeException', 'Counld not connect to database');
$this->getDatabaseTester()->getConnection();
$config1 = new DoctrineConfig($this->connection);
$this->assertEquals(0, $config1->getMachine());
$this->connection->close();
$config1->heartbeat();
}
private static final function initializeDatabase()
{
if (!self::$dbReused) {
self::runCommand('doctrine:database:drop', array('--force' => true));
self::runCommand('doctrine:database:create');
self::$conn->close();
self::$conn->connect();
foreach (self::$dbInitializer->getMigrationFiles() as $file) {
self::runCommand('dbal:import', array('file' => $file));
}
}
}
/**
* It attempts to reconnect if connection is non responsive. Failing to reconnect triggers a critical error.
* If connection is responsive or successfully reconnected it rethrows, relying on the bus retries
* to re-execute everything from the beginning.
*
* @param \Exception $e
*
* @return \Exception|CriticalErrorException
*/
private function attemptToReconnectPresumedLostConnection(\Exception $e)
{
// presumably, any exception caught here is related to some connection error
if (!$this->connection->ping()) {
// if pinging fails, we try to reconnect
try {
$this->connection->close();
$this->connection->connect();
} catch (\Exception $e) {
// if reconnecting fails, there is no way that the bus can continue to function
return new CriticalErrorException("Database connection failed.", 0, $e);
}
}
return $e;
}
/**
* Closes connection if open, opens a unbuffered connection.
*
* @param Connection $connection
*
* @throws InvalidArgumentException
*/
public static function unbufferConnection(Connection $connection)
{
/** @var PDOConnection $wrappedConnection */
$wrappedConnection = $connection->getWrappedConnection();
if (!$wrappedConnection instanceof PDOConnection) {
throw new InvalidArgumentException('unbufferConection can only be used with pdo_mysql Doctrine driver.');
}
if ($wrappedConnection->getAttribute(PDO::ATTR_DRIVER_NAME) != 'mysql') {
throw new InvalidArgumentException('unbufferConection can only be used with PDO mysql driver, got "' . $wrappedConnection->getAttribute(PDO::ATTR_DRIVER_NAME) . '" instead.');
}
if ($connection->isConnected()) {
$connection->close();
}
$connection->getWrappedConnection()->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
$connection->connect();
}
/**
* Generates SQL for installation.
*
* @param object $originalData
*
* @return array|bool Array containing the flash message data on a failure, boolean true on success
*/
public function installSchema()
{
$sm = $this->db->getSchemaManager();
try {
//check to see if the table already exist
$tables = $sm->listTableNames();
} catch (\Exception $e) {
$this->db->close();
throw $e;
}
$this->platform = $sm->getDatabasePlatform();
$backupPrefix = !empty($this->dbParams['backup_prefix']) ? $this->dbParams['backup_prefix'] : 'bak_';
$metadatas = $this->em->getMetadataFactory()->getAllMetadata();
if (empty($metadatas)) {
$this->db->close();
return false;
}
$schemaTool = new SchemaTool($this->em);
$installSchema = $schemaTool->getSchemaFromMetadata($metadatas);
$mauticTables = [];
foreach ($installSchema->getTables() as $m) {
$tableName = $m->getName();
$mauticTables[$tableName] = $this->generateBackupName($this->dbParams['table_prefix'], $backupPrefix, $tableName);
}
$sql = ['SET foreign_key_checks = 0;'];
if ($this->dbParams['backup_tables']) {
$sql = array_merge($sql, $this->backupExistingSchema($tables, $mauticTables, $backupPrefix));
} else {
$sql = array_merge($sql, $this->dropExistingSchema($tables, $mauticTables));
}
$sql = array_merge($sql, $installSchema->toSql($this->platform));
// Execute drop queries
if (!empty($sql)) {
foreach ($sql as $q) {
try {
$this->db->query($q);
} catch (\Exception $exception) {
$this->db->close();
throw $exception;
}
}
}
$this->db->close();
return true;
}
/**
* {@inheritDoc}
*/
public function close()
{
unset($this->connections['master']);
unset($this->connections['slave']);
parent::close();
$this->_conn = null;
$this->connections = array('master' => null, 'slave' => null);
}
private function closeConnection(Connection $connection)
{
$connection->close();
}
public function testConnectionIsClosed()
{
$this->_conn->close();
$this->setExpectedException('Doctrine\\DBAL\\Exception\\DriverException');
$this->_conn->quoteIdentifier('Bug');
}
/**
* Close this connection.
*/
public function close()
{
$this->_conn->close();
}
public function tearDown()
{
$this->conn->close();
imap_close($this->imap->getImapStream());
}
/**
* {@inheritDoc}
*/
public function close()
{
unset($this->connections['master']);
unset($this->connections['slave']);
parent::close();
}
private function keepalive(Connection $db)
{
if (false === $db->ping()) {
$db->close();
$db->connect();
}
}
private function shutdown()
{
if ($this->connection !== null && $this->connection->isConnected()) {
$this->connection->close();
}
}
/**
* {@inheritDoc}
*/
public function close()
{
if ($this->isConnected()) {
parent::close();
$this->_isConnected = false;
}
}
private function connectToDatabase(Connection $db, $databaseName)
{
$db->close();
$db->__construct(['dbname' => $databaseName] + $db->getParams(), $db->getDriver(), $db->getConfiguration(), $db->getEventManager());
$db->connect();
}
private function dropAndCreateDB(Connection $connection)
{
// Drop and recreate the database
if ($connection->getDatabasePlatform()->supportsCreateDropDatabase()) {
$dbname = $connection->getDatabase();
$connection->close();
$connection->getSchemaManager()->dropAndCreateDatabase($dbname);
$connection->connect();
} else {
$sm = $connection->getSchemaManager();
/* @var $schema Schema */
$schema = $sm->createSchema();
$stmts = $schema->toDropSql($connection->getDatabasePlatform());
foreach ($stmts as $stmt) {
$connection->exec($stmt);
}
}
}
/**
* This method can be called to explicitly close the connection
*/
public function closeForReal()
{
parent::close();
}
