/**
* @return Connection
*/
public function getConnection()
{
if (false === $this->connection->ping()) {
$this->connection->close();
$this->connection->connect();
}
return $this->connection;
}
protected function pingIt(Connection $con)
{
if ($con->ping() === false) {
$con->close();
$con->connect();
}
return $con;
}
/**
* Test if is connected
*
* @param bool $forceConnection
* @return bool
*/
public function isConnected($forceConnection = false)
{
if ($forceConnection) {
$this->connection->connect();
}
return $this->connection->isConnected();
}
/**
* Connects to the database.
*
* @return boolean
*/
public function connect()
{
if ($connected = $this->connection->connect()) {
$this->events->dispatch(Events::postConnect, new Event\ConnectionEvent($this));
}
return $connected;
}
/**
* setup configuration for Doctrine Dbal.
*
* @param array $db_config array config for override the default configuration.
*/
public function setupConfigurationDbal(array $db_config = [])
{
$dbal_config = new Configuration();
if (empty($db_config)) {
//setup connection configuration.
$config = new SystemConfig();
$config->load('db');
$db_params = $config->get('ALL', 'db');
unset($config, $db_params['table_prefix']);
} else {
$db_params = $db_config;
unset($db_params['table_prefix']);
}
$dbal_config->setSQLLogger(new \System\Libraries\Db\Logger());
try {
$this->Conn = DriverManager::getConnection($db_params, $dbal_config);
$this->Conn->connect();
} catch (\Doctrine\DBAL\DBALException $e) {
http_response_code(500);
echo $e->getMessage();
exit;
}
$this->Conn->setFetchMode(\PDO::FETCH_OBJ);
unset($dbal_config, $db_params);
}
private function connectDatabase(OutputInterface $output)
{
$param = array();
$param['host'] = $this->dialog->ask($output, '<question>Where is your database server? [localhost]</question> ', 'localhost');
$param['user'] = $this->dialog->ask($output, '<question>What is your database username? [root]</question> ', 'root');
$param['password'] = $this->dialog->ask($output, '<question>What is your database password?</question> ', '');
$param['driver'] = 'pdo_mysql';
// Save dbName for later use to create database
$this->dbName = $this->dialog->ask($output, '<question>What is your database name? [BungaWire]</question> ', 'BungaWire');
$output->writeln('');
// Write empty line for easy read
$config = new Configuration();
$this->dbConnection = DriverManager::getConnection($param, $config);
$this->dbConnection->connect();
if ($this->dbConnection->isConnected() === false) {
$output->writeln('Database connection failed, please check your setting');
$output->writeln('You connection configuration is:');
$output->writeln('host: ' . $param['host']);
$output->writeln('user: '******'user']);
$output->writeln('password: '******'password']);
$output->writeln('Database Name: ' . $param['dbname']);
$output->writeln('Driver: ' . $param['driver']);
$output->writeln($this->dbConnection->errorInfo());
$output->writeln('Please try again!');
$this->connectDatabase($output);
} else {
$output->writeln('Database connected!');
}
}
protected function setUp()
{
try {
$this->con = DriverManager::getConnection(array('driver' => 'pdo_mysql', 'host' => 'localhost', 'user' => 'root', 'dbname' => 'testdb'));
$this->con->connect();
} catch (\Exception $e) {
$this->markTestSkipped('Unable to connect to the database: ' . $e->getMessage());
}
}
/**
* @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;
}
/**
* Check Doctrine connection
*
* @return Result
*/
public function check()
{
$result = new Result($this->label);
try {
$this->db->connect();
} catch (\Exception $e) {
$result->setSuccess(false);
$result->setError($e->getMessage());
}
return $result;
}
/**
* Connect to the store.
*
* @throws StoreConnectionFailedException When could not connect to the store.
*/
protected function connect()
{
if ($this->connected) {
return;
}
try {
$this->connection->connect();
} catch (\Exception $e) {
throw new StoreConnectionFailedException('DoctrineDBAL: ' . $e->getMessage(), $e->getCode(), $e);
}
$this->connected = true;
}
/**
* Check if the given table exists in a database
*
* @param string $tableName
* @return bool TRUE if a table exists; otherwise, FALSE
*/
public function isTableExist($tableName)
{
if (!empty($tableName)) {
try {
$this->connection->connect();
return $this->connection->getSchemaManager()->tablesExist($tableName);
} catch (\PDOException $e) {
} catch (DBALException $e) {
}
}
return false;
}
protected function setUp()
{
if (!class_exists('Doctrine\\DBAL\\DriverManager')) {
$this->markTestSkipped('The "Doctrine DBAL" library is not available');
}
try {
$this->con = DriverManager::getConnection(array('driver' => 'pdo_mysql', 'host' => 'localhost', 'user' => 'root', 'dbname' => 'testdb'));
$this->con->connect();
} catch (\Exception $e) {
$this->markTestSkipped('Unable to connect to the database: ' . $e->getMessage());
}
}
/**
* Outputs the caller method name so that accidental queries can be noticed
*
* Using echo() is safe, since fixtures should be enabled on the command line while running PHPUnit only!
*
* @return bool
*/
public function connect()
{
if ($this->usesFixtures() && $this->showFixtureWarnings) {
echo ' [SQL CONNECT BY "' . $this->getFixtureCaller() . '"] ';
}
return parent::connect();
}
/**
* Explicitely opens the database connection. This is done to play nice
* with DBAL's MasterSlaveConnection. Which, in some cases, connects to a
* follower when fetching the executed migrations. If a follower is lagging
* significantly behind that means the migrations system may see unexecuted
* migrations that were actually executed earlier.
*
* @return bool The same value returned from the `connect` method
*/
protected function connect()
{
if ($this->connection instanceof MasterSlaveConnection) {
return $this->connection->connect('master');
}
return $this->connection->connect();
}
public function connect()
{
$ret = parent::connect();
if ($ret) {
$params = $this->getParams();
if (isset($params['portability'])) {
if ($this->_platform->getName() === "oracle") {
$params['portability'] = $params['portability'] & self::PORTABILITY_ORACLE;
} else {
if ($this->_platform->getName() === "postgresql") {
$params['portability'] = $params['portability'] & self::PORTABILITY_POSTGRESQL;
} else {
if ($this->_platform->getName() === "sqlite") {
$params['portability'] = $params['portability'] & self::PORTABILITY_SQLITE;
} else {
$params['portability'] = $params['portability'] & self::PORTABILITY_OTHERVENDORS;
}
}
}
$this->portability = $params['portability'];
}
if (isset($params['fetch_case']) && $this->portability & self::PORTABILITY_FIX_CASE) {
if ($this->_conn instanceof \Doctrine\DBAL\Driver\PDOConnection) {
// make use of c-level support for case handling
$this->_conn->setAttribute(\PDO::ATTR_CASE, $params['fetch_case']);
} else {
$this->case = $params['fetch_case'] == \PDO::CASE_LOWER ? CASE_LOWER : CASE_UPPER;
}
}
}
return $ret;
}
public function connect() {
try {
return parent::connect();
} catch (DBALException $e) {
// throw a new exception to prevent leaking info from the stacktrace
throw new DBALException('Failed to connect to the database: ' . $e->getMessage(), $e->getCode());
}
}
/**
* @param Connection $connection
*
* @return bool
*/
protected function checkDatabase(Connection $connection)
{
$result = false;
try {
$connection->connect();
$result = $connection->isConnected() && $connection->getSchemaManager()->tablesExist([self::EVENT_TABLE_NAME]);
} catch (\PDOException $e) {
}
return $result;
}
/**
* {@inheritdoc}
*/
public function connect()
{
try {
return parent::connect();
} catch (DBALException $e) {
if ($this->_eventManager->hasListeners('failConnect')) {
$eventArgs = new FailedConnectionEvent($this, $e);
$this->_eventManager->dispatchEvent('failConnect', $eventArgs);
}
}
}
public function connect()
{
// enable sharing connection across multiple instances
$return = parent::connect();
if (DoctrineDBALTestConnection::$_test_conn) {
$this->_conn = DoctrineDBALTestConnection::$_test_conn;
} else {
DoctrineDBALTestConnection::$_test_conn = $this->_conn;
}
return $return;
}
/**
* Open the database connection.
*
* @return Connection
* @throws \Doctrine\DBAL\DBALException
*/
private function connect()
{
$connectionParams = array('driver' => $this->config->getDriver(), 'host' => $this->config->getHost(), 'user' => $this->config->getUser(), 'password' => $this->config->getPassword(), 'dbname' => $this->config->getDatabaseName(), 'charset' => $this->config->getCharset());
$dbalConfig = new Configuration();
$this->connection = DriverManager::getConnection($connectionParams, $dbalConfig);
$this->connection->connect();
$this->initPlatformAdjustment($this->connection);
$this->platformAdjustment->initConnection();
$this->platformAdjustment->registerCustomTypeMappings();
return $this->connection;
}
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));
}
}
}
public function testConnectDispatchEvent()
{
$listenerMock = $this->getMock('ConnectDispatchEventListener', array('postConnect'));
$listenerMock->expects($this->once())->method('postConnect');
$eventManager = new EventManager();
$eventManager->addEventListener(array(Events::postConnect), $listenerMock);
$driverMock = $this->getMock('Doctrine\\DBAL\\Driver');
$driverMock->expects($this->at(0))->method('connect');
$platform = new Mocks\MockPlatform();
$conn = new Connection(array('platform' => $platform), $driverMock, new Configuration(), $eventManager);
$conn->connect();
}
/**
* Checks whether a database connection can be established and all given tables exist in the database.
*
* @param Connection $connection
* @param string[]|string|null $tables
*
* @return bool
*/
public static function tablesExist(Connection $connection, $tables)
{
$result = false;
if (!empty($tables)) {
try {
$connection->connect();
$result = $connection->getSchemaManager()->tablesExist($tables);
} catch (\PDOException $e) {
} catch (DBALException $e) {
}
}
return $result;
}
/**
* Initial setup.
*/
protected function setUp()
{
$this->db = \Doctrine\DBAL\DriverManager::getConnection(array('driver' => 'pdo_sqlite', 'memory' => true), new \Doctrine\DBAL\Configuration());
$this->db->connect();
$this->plugin = new Plugin($this->db);
$this->logger = Phake::mock('\\Psr\\Log\\LoggerInterface');
$this->plugin->setLogger($this->logger);
$this->connection = Phake::mock('\\Phergie\\Irc\\ConnectionInterface');
Phake::when($this->connection)->getNickname()->thenReturn('TestNick');
Phake::when($this->connection)->getUsername()->thenReturn('TestUser');
Phake::when($this->connection)->getServerHostname()->thenReturn('Test.Server');
$this->queue = Phake::mock('\\Phergie\\Irc\\Bot\\React\\EventQueueInterface');
}
/**
* @throws \Exception if an unexpected database error occurs
*/
private function configuredDatabaseExists()
{
try {
$this->db->connect();
} catch (ConnectionException $e) {
// @todo 1049 is MySQL's code for "database doesn't exist", refactor
if ($e->getPrevious()->getCode() == 1049) {
return false;
}
throw $e;
}
return true;
}
/**
* {@inheritDoc}
*/
public function connect()
{
if ($this->isConnected()) {
return false;
}
if ($this->hasPersistedConnection()) {
$this->_conn = $this->getPersistedConnection();
$this->setConnected(true);
} else {
parent::connect();
$this->persistConnection($this->_conn);
}
return true;
}
/**
* 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;
}
/**
* {@inheritDoc}
*/
public function connect()
{
if ($this->isConnected()) {
return false;
}
if ($this->hasPersistedConnection()) {
$this->_conn = $this->getPersistedConnection();
$this->setConnected(true);
} else {
parent::connect();
$this->setPersistedConnection($this->_conn);
$this->_conn->exec('SET SESSION wait_timeout=2147483');
}
return true;
}
/**
* 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();
}
/**
* Checks if a database connection can be established.
*
* @param string $name The database name
*
* @return bool True if a database connection can be established
*/
public function canConnectToDatabase($name)
{
if (null === $this->connection) {
return false;
}
try {
$this->connection->connect();
} catch (ConnectionException $e) {
return false;
}
$quotedName = $this->connection->quoteIdentifier($name);
try {
$this->connection->query('use ' . $quotedName);
} catch (DBALException $e) {
return false;
}
return true;
}
