CodexShaper\Dumper\Drivers\MysqlDumper

Complexity

Total Complexity

32

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Test Coverage

Coverage

80.21%

Importance

Changes	13
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	dump()	0	5	2
A	useQuick()	0	4	1
A	useSkipLockTables()	0	4	1
A	useSingleTransaction()	0	4	1
A	restore()	0	5	2
A	doNotUseSkipComments()	0	4	1
A	setDefaultCharacterSet()	0	4	1
A	doNotCreateTables()	0	4	1
A	prepareSkipLockTables()	0	3	2
B	runCommand()	0	32	6
A	prepareAuthentication()	0	3	1
A	prepareQuick()	0	3	2
A	prepareDefaultCharSet()	0	3	2
A	prepareRestoreCommand()	0	16	2
A	prepareDumpCommand()	0	24	2
A	getCredentials()	0	10	1
A	prepareSkipComments()	0	3	2
A	prepareSingleTransaction()	0	3	2

<?php

namespace CodexShaper\Dumper\Drivers;

use CodexShaper\Dumper\Dumper;
use Symfony\Component\Process\Exception\ProcessFailedException;

class MysqlDumper extends Dumper
{
    /*@var bool*/
    protected $singleTransaction = false;
    /*@var bool*/
    protected $skipLockTables = false;
    /*@var bool*/
    protected $quick = false;
    /*@var bool*/
    protected $skipComments = true;
    /*@var string*/
    protected $defaultCharacterSet = '';
    /*@var bool*/
    protected $createTables = true;

    public function useSingleTransaction()
    {
        $this->singleTransaction = true;
        return $this;
    }
    public function useSkipLockTables()
    {
        $this->skipLockTables = true;
        return $this;
    }
    public function useQuick()
    {
        $this->quick = true;
        return $this;
    }
    public function doNotUseSkipComments()
    {
        $this->skipComments = false;
        return $this;
    }
    public function doNotCreateTables()
    {
        $this->createTables = false;
        return $this;
    }
    public function setDefaultCharacterSet(string $charecterSet)
    {
        $this->defaultCharacterSet = $charecterSet;
        return $this;
    }

    public function dump(string $destinationPath = "")
    {
        $destinationPath = !empty($destinationPath) ? $destinationPath : $this->destinationPath;
        $this->runCommand($destinationPath, "dump");
        return $this;
    }

    public function restore(string $restorePath = "")
    {
        $restorePath = !empty($restorePath) ? $restorePath : $this->restorePath;
        $this->runCommand($restorePath, 'restore');
        return $this;
    }

    protected function prepareDumpCommand(string $credentialFile, string $destinationPath): string
    {
        $dumpCommand = sprintf(
            '%s %s %s %s %s %s %s %s %s %s %s %s',
            $this->quoteCommand("{$this->commandBinaryPath}mysqldump"),
            $this->prepareAuthentication($credentialFile),
            $this->prepareSocket(),
            $this->prepareSkipComments(),
            $this->prepareCreateTables(),
            $this->prepareSingleTransaction(),
            $this->prepareSkipLockTables(),
            $this->prepareQuick(),
            $this->prepareDefaultCharSet(),
            $this->prepareDatabase(),
            $this->prepareIncludeTables(),
            $this->prepareIgnoreTables()
        );

        if ($this->isCompress) {
            $compressCommand = $this->quoteCommand("{$this->compressBinaryPath}{$this->compressCommand}");
            return "{$dumpCommand} | {$compressCommand} > \"{$destinationPath}{$this->compressExtension}\"";
        }

        return "{$dumpCommand} > \"{$destinationPath}\"";
    }

    protected function prepareRestoreCommand(string $credentialFile, string $filePath): string
    {
        $restoreCommand = sprintf("%s %s %s",
            $this->quoteCommand("{$this->commandBinaryPath}mysql"),
            $this->prepareAuthentication($credentialFile),
            $this->prepareDatabase()
        );

        if ($this->isCompress) {

            $compressCommand = $this->quoteCommand("{$this->compressBinaryPath}{$this->compressCommand}");

            return "{$compressCommand} < \"{$filePath}\" | {$restoreCommand}";
        }

        return "{$restoreCommand} < \"{$filePath}\"";
    }

    protected function runCommand($filePath, $action)
    {
        try {

            $credentials = $this->getCredentials();
            $tempFile    = tempnam(sys_get_temp_dir(), 'mysqlpass');
            $handler     = fopen($tempFile, 'r+');
            if ($handler !== false) {
                fwrite($handler, $credentials);

                if ($action == 'dump') {
                    $dumpCommand   = $this->prepareDumpCommand($tempFile, $filePath);
                    $this->command = $this->removeExtraSpaces($dumpCommand);
                } else if ($action == 'restore') {
                    $dumpCommand   = $this->prepareRestoreCommand($tempFile, $filePath);
                    $this->command = $this->removeExtraSpaces($dumpCommand);
                }

                $process = $this->prepareProcessCommand();

                if ($this->debug) {
                    $process->mustRun();
                } else {
                    $process->run();
                }

                fclose($handler);
                unlink($tempFile);
            }

        } catch (ProcessFailedException $e) {
            throw new \Exception($e->getMessage());

        }
    }

    protected function getCredentials()
    {
        $contents = [
            '[client]',
            "user = '{$this->username}'",
            "password = '{$this->password}'",
            "host = '{$this->host}'",
            "port = '{$this->port}'",
        ];
        return implode(PHP_EOL, $contents);
    }

    public function prepareSingleTransaction()
    {
        return $this->singleTransaction ? '--single-transaction' : '';
    }

    public function prepareSkipLockTables()
    {
        return $this->skipLockTables ? '--skip-lock-tables' : '';
    }

    public function prepareQuick()
    {
        return $this->quick ? '--quick' : '';
    }

    public function prepareSkipComments()
    {
        return $this->skipComments ? '--skip-comments' : '';
    }

    public function prepareDefaultCharSet()
    {
        return ($this->defaultCharacterSet !== '') ? "--default-character-set={$this->defaultCharacterSet}" : '';
    }

    public function prepareAuthentication(string $credentialFile)
    {
        return "--defaults-extra-file=\"{$credentialFile}\"";
    }
}