Make supported DBs configurable within config.php

This commit will make the supported DBs for installation configurable within config.php. By default the following databases are tested: "sqlite", "mysql", "pgsql". The reason behind this is that there might be instances where we want to prevent SQLite to be used by mistake.

To test this play around with the new configuration parameter "supportedDatabases".

diff --git a/config/config.sample.php b/config/config.sample.php
index 621e5df80b3e5d03766c099fa8f5a9e53544bc5e..78bbfff8c857a28b1b8f3d95459c49aed30f6642 100644 (file)
--- a/config/config.sample.php
+++ b/config/config.sample.php
@@ -800,6 +800,23 @@ $CONFIG = array(
        ),
 ),
 
+/**
+ * Database types that are supported for installation
+ * Available:
+ *     - sqlite (SQLite3)
+ *     - mysql (MySQL)
+ *     - pgsql (PostgreSQL)
+ *     - oci (Oracle)
+ *     - mssql (Microsoft SQL Server)
+ */
+'supportedDatabases' => array(
+       'sqlite',
+       'mysql',
+       'pgsql',
+       'oci',
+       'mssql'
+),
+
 /**
  * Custom CSP policy, changing this will overwrite the standard policy
  */

diff --git a/core/setup/controller.php b/core/setup/controller.php
index 53f247e9769c6ba8a2809110dba98ac72f871544..628a4b0349fce1bc094b0bfcdcddb29f28a13d06 100644 (file)
--- a/core/setup/controller.php
+++ b/core/setup/controller.php
@@ -1,6 +1,7 @@
 <?php
 /**
  * Copyright (c) 2013 Bart Visscher <bartv@thisnet.nl>
+ * Copyright (c) 2014 Lukas Reschke <lukas@owncloud.com>
  * This file is licensed under the Affero General Public License version 3 or
  * later.
  * See the COPYING-README file.
@@ -8,7 +9,19 @@
 
 namespace OC\Core\Setup;
 
+use OCP\IConfig;
+
 class Controller {
+       /** @var \OCP\IConfig */
+       protected $config;
+
+       /**
+        * @param IConfig $config
+        */
+       function __construct(IConfig $config) {
+               $this->config = $config;
+       }
+
        public function run($post) {
                // Check for autosetup:
                $post = $this->loadAutoConfig($post);
@@ -87,28 +100,10 @@ class Controller {
         * in case of errors/warnings
         */
        public function getSystemInfo() {
-               $hasSQLite = class_exists('SQLite3');
-               $hasMySQL = is_callable('mysql_connect');
-               $hasPostgreSQL = is_callable('pg_connect');
-               $hasOracle = is_callable('oci_connect');
-               $hasMSSQL = is_callable('sqlsrv_connect');
-               $databases = array();
-               if ($hasSQLite) {
-                       $databases['sqlite'] = 'SQLite';
-               }
-               if ($hasMySQL) {
-                       $databases['mysql'] = 'MySQL/MariaDB';
-               }
-               if ($hasPostgreSQL) {
-                       $databases['pgsql'] = 'PostgreSQL';
-               }
-               if ($hasOracle) {
-                       $databases['oci'] = 'Oracle';
-               }
-               if ($hasMSSQL) {
-                       $databases['mssql'] = 'MS SQL';
-               }
-               $datadir = \OC_Config::getValue('datadirectory', \OC::$SERVERROOT.'/data');
+               $setup = new \OC_Setup($this->config);
+               $databases = $setup->getSupportedDatabases();
+
+               $datadir = $this->config->getSystemValue('datadirectory', \OC::$SERVERROOT.'/data');
                $vulnerableToNullByte = false;
                if(@file_exists(__FILE__."\0Nullbyte")) { // Check if the used PHP version is vulnerable to the NULL Byte attack (CVE-2006-7243)
                        $vulnerableToNullByte = true;
@@ -150,11 +145,11 @@ class Controller {
                }
 
                return array(
-                       'hasSQLite' => $hasSQLite,
-                       'hasMySQL' => $hasMySQL,
-                       'hasPostgreSQL' => $hasPostgreSQL,
-                       'hasOracle' => $hasOracle,
-                       'hasMSSQL' => $hasMSSQL,
+                       'hasSQLite' => isset($databases['sqlite']),
+                       'hasMySQL' => isset($databases['mysql']),
+                       'hasPostgreSQL' => isset($databases['postgre']),
+                       'hasOracle' => isset($databases['oci']),
+                       'hasMSSQL' => isset($databases['mssql']),
                        'databases' => $databases,
                        'directory' => $datadir,
                        'htaccessWorking' => $htaccessWorking,

diff --git a/lib/base.php b/lib/base.php
index 23f0e594510d2d1114c35eff473b2fe3d4c256c7..22916c259fccd36cff9bbeb6fcdf6384d25e3193 100644 (file)
--- a/lib/base.php
+++ b/lib/base.php
@@ -716,7 +716,7 @@ class OC {
 
                // Check if ownCloud is installed or in maintenance (update) mode
                if (!OC_Config::getValue('installed', false)) {
-                       $controller = new OC\Core\Setup\Controller();
+                       $controller = new OC\Core\Setup\Controller(\OC::$server->getConfig());
                        $controller->run($_POST);
                        exit();
                }

diff --git a/lib/private/setup.php b/lib/private/setup.php
index 75dc1987ee6c3d91de55f1bad148dd313717d50c..8945c2c03f13b1ac1861c55cd65459739ea6b0c0 100644 (file)
--- a/lib/private/setup.php
+++ b/lib/private/setup.php
@@ -1,9 +1,27 @@
 <?php
+/**
+ * Copyright (c) 2014 Lukas Reschke <lukas@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+use OCP\IConfig;
 
 class DatabaseSetupException extends \OC\HintException {
 }
 
 class OC_Setup {
+       /** @var IConfig */
+       protected $config;
+
+       /**
+        * @param IConfig $config
+        */
+       function __construct(IConfig $config) {
+               $this->config = $config;
+       }
+
        static $dbSetupClasses = array(
                'mysql' => '\OC\Setup\MySQL',
                'pgsql' => '\OC\Setup\PostgreSQL',
@@ -13,10 +31,93 @@ class OC_Setup {
                'sqlite3' => '\OC\Setup\Sqlite',
        );
 
+       /**
+        * @return OC_L10N
+        */
        public static function getTrans(){
                return \OC::$server->getL10N('lib');
        }
 
+       /**
+        * Wrapper around the "class_exists" PHP function to be able to mock it
+        * @param string $name
+        * @return bool
+        */
+       public function class_exists($name) {
+               return class_exists($name);
+       }
+
+       /**
+        * Wrapper around the "is_callable" PHP function to be able to mock it
+        * @param string $name
+        * @return bool
+        */
+       public function is_callable($name) {
+               return is_callable($name);
+       }
+
+       /**
+        * Get the available and supported databases of this instance
+        *
+        * @throws Exception
+        * @return array
+        */
+       public function getSupportedDatabases() {
+               $availableDatabases = array(
+                       'sqlite' =>  array(
+                               'type' => 'class',
+                               'call' => 'SQLite3',
+                               'name' => 'SQLite'
+                       ),
+                       'mysql' => array(
+                               'type' => 'function',
+                               'call' => 'mysql_connect',
+                               'name' => 'MySQL/MariaDB'
+                       ),
+                       'pgsql' => array(
+                               'type' => 'function',
+                               'call' => 'oci_connect',
+                               'name' => 'PostgreSQL'
+                       ),
+                       'oci' => array(
+                               'type' => 'function',
+                               'call' => 'oci_connect',
+                               'name' => 'Oracle'
+                       ),
+                       'mssql' => array(
+                               'type' => 'function',
+                               'call' => 'sqlsrv_connect',
+                               'name' => 'MS SQL'
+                       )
+               );
+               $configuredDatabases = $this->config->getSystemValue('supportedDatabases', array('sqlite', 'mysql', 'pgsql', 'oci', 'mssql'));
+               if(!is_array($configuredDatabases)) {
+                       throw new Exception('Supported databases are not properly configured.');
+               }
+
+               $supportedDatabases = array();
+
+               foreach($configuredDatabases as $database) {
+                       if(array_key_exists($database, $availableDatabases)) {
+                               $working = false;
+                               if($availableDatabases[$database]['type'] === 'class') {
+                                       $working = $this->class_exists($availableDatabases[$database]['call']);
+                               } elseif ($availableDatabases[$database]['type'] === 'function') {
+                                       $working = $this->is_callable($availableDatabases[$database]['call']);
+                               }
+                               if($working) {
+                                       $supportedDatabases[$database] = $availableDatabases[$database]['name'];
+                               }
+                       }
+               }
+
+               return $supportedDatabases;
+       }
+
+       /**
+        * @param $options
+        * @return array
+        */
        public static function install($options) {
                $l = self::getTrans();
 
@@ -59,7 +160,7 @@ class OC_Setup {
                }
 
                //no errors, good
-               if(    isset($options['trusted_domains'])
+               if(isset($options['trusted_domains'])
                    && is_array($options['trusted_domains'])) {
                        $trustedDomains = $options['trusted_domains'];
                } else {

diff --git a/lib/private/util.php b/lib/private/util.php
index 858138f58fe1fabca6b7f58475fc0e027910987d..dd131e4131025a1c8643ea84d0824bf142149d54 100644 (file)
--- a/lib/private/util.php
+++ b/lib/private/util.php
@@ -436,12 +436,9 @@ class OC_Util {
                }
 
                $webServerRestart = false;
-               //check for database drivers
-               if (!(is_callable('sqlite_open') or class_exists('SQLite3'))
-                       and !is_callable('mysql_connect')
-                       and !is_callable('pg_connect')
-                       and !is_callable('oci_connect')
-               ) {
+               $setup = new OC_Setup($config);
+               $availableDatabases = $setup->getSupportedDatabases();
+               if (empty($availableDatabases)) {
                        $errors[] = array(
                                'error' => $l->t('No database drivers (sqlite, mysql, or postgresql) installed.'),
                                'hint' => '' //TODO: sane hint

diff --git a/tests/lib/setup.php b/tests/lib/setup.php
new file mode 100644 (file)
index 0000000..2c1569d
--- /dev/null
+++ b/tests/lib/setup.php
@@ -0,0 +1,103 @@
+<?php
+/**
+ * Copyright (c) 2014 Lukas Reschke <lukas@owncloud.com>
+ * This file is licensed under the Affero General Public License version 3 or
+ * later.
+ * See the COPYING-README file.
+ */
+
+use OCP\IConfig;
+
+class Test_OC_Setup extends PHPUnit_Framework_TestCase {
+
+       /** @var IConfig */
+       protected $config;
+       /** @var \OC_Setup */
+       protected $setupClass;
+
+       public function setUp() {
+               $this->config = $this->getMock('\OCP\IConfig');
+               $this->setupClass = $this->getMock('\OC_Setup', array('class_exists', 'is_callable'), array($this->config));
+       }
+
+       public function testGetSupportedDatabasesWithOneWorking() {
+               $this->config
+                       ->expects($this->once())
+                       ->method('getSystemValue')
+                       ->will($this->returnValue(
+                               array('sqlite', 'mysql', 'oci')
+                       ));
+               $this->setupClass
+                       ->expects($this->once())
+                       ->method('class_exists')
+                       ->will($this->returnValue(true));
+               $this->setupClass
+                       ->expects($this->exactly(2))
+                       ->method('is_callable')
+                       ->will($this->returnValue(false));
+               $result = $this->setupClass->getSupportedDatabases();
+               $expectedResult = array(
+                       'sqlite' => 'SQLite'
+               );
+
+               $this->assertSame($expectedResult, $result);
+       }
+
+       public function testGetSupportedDatabasesWithNoWorking() {
+               $this->config
+                       ->expects($this->once())
+                       ->method('getSystemValue')
+                       ->will($this->returnValue(
+                               array('sqlite', 'mysql', 'oci', 'pgsql')
+                       ));
+               $this->setupClass
+                       ->expects($this->once())
+                       ->method('class_exists')
+                       ->will($this->returnValue(false));
+               $this->setupClass
+                       ->expects($this->exactly(3))
+                       ->method('is_callable')
+                       ->will($this->returnValue(false));
+               $result = $this->setupClass->getSupportedDatabases();
+
+               $this->assertSame(array(), $result);
+       }
+
+       public function testGetSupportedDatabasesWitAllWorking() {
+               $this->config
+                       ->expects($this->once())
+                       ->method('getSystemValue')
+                       ->will($this->returnValue(
+                               array('sqlite', 'mysql', 'pgsql', 'oci', 'mssql')
+                       ));
+               $this->setupClass
+                       ->expects($this->once())
+                       ->method('class_exists')
+                       ->will($this->returnValue(true));
+               $this->setupClass
+                       ->expects($this->exactly(4))
+                       ->method('is_callable')
+                       ->will($this->returnValue(true));
+               $result = $this->setupClass->getSupportedDatabases();
+               $expectedResult = array(
+                       'sqlite' => 'SQLite',
+                       'mysql' => 'MySQL/MariaDB',
+                       'pgsql' => 'PostgreSQL',
+                       'oci' => 'Oracle',
+                       'mssql' => 'MS SQL'
+               );
+               $this->assertSame($expectedResult, $result);
+       }
+
+       /**
+        * @expectedException \Exception
+        * @expectedExceptionMessage Supported databases are not properly configured.
+        */
+       public function testGetSupportedDatabaseException() {
+               $this->config
+                       ->expects($this->once())
+                       ->method('getSystemValue')
+                       ->will($this->returnValue('NotAnArray'));
+               $this->setupClass->getSupportedDatabases();
+       }
+}
\ No newline at end of file