SilverStripe\SQLite\SQLiteDatabaseConfigurationHelper

Complexity

Total Complexity

31

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
C	createConnection()	0	39	7
A	requireDatabaseFunctions()	0	5	1
B	requireDatabaseServer()	0	21	5
B	requireDatabaseConnection()	0	42	5
A	getDatabaseVersion()	0	20	4
A	requireDatabaseVersion()	0	18	3
A	requireDatabaseOrCreatePermissions()	0	9	1
A	create_db_dir()	0	4	2
A	secure_db_dir()	0	4	2
A	requireDatabaseAlterPermissions()	0	8	1

<?php

namespace SilverStripe\SQLite;

use DatabaseConfigurationHelper;
use SQLite3;
use PDO;
use Exception;
use DatabaseAdapterRegistry;

/**
 * This is a helper class for the SS installer.
 *
 * It does all the specific checking for SQLiteDatabase
 * to ensure that the configuration is setup correctly.
 *
 * @package SQLite3
 */
class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper
{

    /**
     * Create a connection of the appropriate type
     *
     * @param array $databaseConfig
     * @param string $error Error message passed by value
     * @return mixed|null Either the connection object, or null if error
     */
    protected function createConnection($databaseConfig, &$error)
    {
        $error = null;
        try {
            if (!file_exists($databaseConfig['path'])) {
                self::create_db_dir($databaseConfig['path']);
                self::secure_db_dir($databaseConfig['path']);
            }
            $file = $databaseConfig['path'] . '/' . $databaseConfig['database'];
            $conn = null;

            switch ($databaseConfig['type']) {
                case 'SQLite3Database':
                    if (empty($databaseConfig['key'])) {
                        $conn = @new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE);
                    } else {
                        $conn = @new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, $databaseConfig['key']);
                    }
                    break;
                case 'SQLite3PDODatabase':
                    // May throw a PDOException if fails
                    $conn = @new PDO("sqlite:$file");
                    break;
                default:
                    $error = 'Invalid connection type';
                    return null;
            }

            if ($conn) {
                return $conn;
            } else {
                $error = 'Unknown connection error';
                return null;
            }
        } catch (Exception $ex) {
            $error = $ex->getMessage();
            return null;
        }
    }

    public function requireDatabaseFunctions($databaseConfig)
    {
        $data = DatabaseAdapterRegistry::get_adapter($databaseConfig['type']);
        return !empty($data['supported']);
    }

    public function requireDatabaseServer($databaseConfig)
    {
        $path = $databaseConfig['path'];
        $error = '';
        $success = false;

        if (!$path) {
            $error = 'No database path provided';
        } elseif (is_writable($path) || (!file_exists($path) && is_writable(dirname($path)))) {
            // check if folder is writeable
            $success = true;
        } else {
            $error = "Permission denied";
        }

        return array(
            'success' => $success,
            'error' => $error,
            'path' => $path
        );
    }

    /**
     * Ensure a database connection is possible using credentials provided.
     *
     * @todo Validate path
     *
     * @param array $databaseConfig Associative array of db configuration, e.g. "type", "path" etc
     * @return array Result - e.g. array('success' => true, 'error' => 'details of error')
     */
    public function requireDatabaseConnection($databaseConfig)
    {
        // Do additional validation around file paths
        if (empty($databaseConfig['path'])) {
            return array(
            'success' => false,
            'error' => "Missing directory path"
        );
        }
        if (empty($databaseConfig['database'])) {
            return array(
            'success' => false,
            'error' => "Missing database filename"
        );
        }

        // Create and secure db directory
        $path = $databaseConfig['path'];
        $dirCreated = self::create_db_dir($path);
        if (!$dirCreated) {
            return array(
            'success' => false,
            'error' => sprintf('Cannot create path: "%s"', $path)
        );
        }
        $dirSecured = self::secure_db_dir($path);
        if (!$dirSecured) {

The expression $dirSecured of type integer|false is loosely compared to false; this is ambiguous if the integer can be zero. You might want to explicitly use === null instead.

            return array(
            'success' => false,
            'error' => sprintf('Cannot secure path through .htaccess: "%s"', $path)
        );
        }

        $conn = $this->createConnection($databaseConfig, $error);
        $success = !empty($conn);

        return array(
            'success' => $success,
            'connection' => $conn,
            'error' => $error
        );
    }

    public function getDatabaseVersion($databaseConfig)
    {
        $version = 0;

        switch ($databaseConfig['type']) {
            case 'SQLite3Database':
                $info = SQLite3::version();
                $version = trim($info['versionString']);
                break;
            case 'SQLite3PDODatabase':
                // Fallback to using sqlite_version() query
                $conn = $this->createConnection($databaseConfig, $error);
                if ($conn) {
                    $version = $conn->getAttribute(PDO::ATTR_SERVER_VERSION);
                }
                break;
        }

        return $version;
    }

    public function requireDatabaseVersion($databaseConfig)
    {
        $success = false;
        $error = '';
        $version = $this->getDatabaseVersion($databaseConfig);

        if ($version) {
            $success = version_compare($version, '3.3', '>=');
            if (!$success) {
                $error = "Your SQLite3 library version is $version. It's recommended you use at least 3.3.";
            }
        }

        return array(
            'success' => $success,
            'error' => $error
        );
    }

    public function requireDatabaseOrCreatePermissions($databaseConfig)
    {
        $conn = $this->createConnection($databaseConfig, $error);
        $success = $alreadyExists = !empty($conn);
        return array(
            'success' => $success,
            'alreadyExists' => $alreadyExists,
        );
    }

    /**
     * Creates the provided directory and prepares it for
     * storing SQLlite. Use {@link secure_db_dir()} to
     * secure it against unauthorized access.
     *
     * @param String $path Absolute path, usually with a hidden folder.
     * @return boolean
     */
    public static function create_db_dir($path)
    {
        return file_exists($path) || mkdir($path);
    }

    /**
     * Secure the provided directory via web-access
     * by placing a .htaccess file in it.
     * This is just required if the database directory
     * is placed within a publically accessible webroot (the
     * default path is in a hidden folder within assets/).
     *
     * @param String $path Absolute path, containing a SQLite datatbase
     * @return boolean

Should the return type not be integer|false?

     */
    public static function secure_db_dir($path)
    {
        return (is_writeable($path)) ? file_put_contents($path . '/.htaccess', 'deny from all') : false;
    }

    public function requireDatabaseAlterPermissions($databaseConfig)
    {
        // no concept of table-specific permissions; If you can connect you can alter schema
        return array(
            'success' => true,
            'applies' => false
        );
    }
}