ProvisionCommand::start() - Code Metrics - Inspection of "Additional input options support" - tworzenieweb/sql-provisioner - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Pull Request — master (#20)

unknown

created 2019-03-10 20:04 UTC

ProvisionCommand::start() A

↳ Parent: ProvisionCommand

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
ccs	0
cts	5
cp	0
cc	1
nc	1
nop	2
crap	2

<?php

namespace Tworzenieweb\SqlProvisioner\Command;

use RuntimeException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Finder\SplFileInfo;
use Tworzenieweb\SqlProvisioner\Config\ProvisionConfig;
use Tworzenieweb\SqlProvisioner\Controller\ProvisionDispatcher;
use Tworzenieweb\SqlProvisioner\Database\Connection;
use Tworzenieweb\SqlProvisioner\Filesystem\Exception;
use Tworzenieweb\SqlProvisioner\Filesystem\WorkingDirectory;
use Tworzenieweb\SqlProvisioner\Model\Candidate;
use Tworzenieweb\SqlProvisioner\Model\CandidateBuilder;
use Tworzenieweb\SqlProvisioner\Table\DataRowsBuilder;

/**
 * @author  Luke Adamczewski
 * @package Tworzenieweb\SqlProvisioner\Command
 */
class ProvisionCommand extends Command
{
    const HELP_MESSAGE = <<<'EOF'
The <info>%command.name% [path-to-folder]</info> command will scan the content of [path-to-folder] directory.
 
The script will look for <info>.env</info> file containing connection information in format:
<comment>
DATABASE_USER=[user]
DATABASE_PASSWORD=[password]
DATABASE_HOST=[host]
DATABASE_PORT=[port]
DATABASE_NAME=[database]
PROVISIONING_TABLE=changelog_database_deployments
PROVISIONING_TABLE_CANDIDATE_NUMBER_COLUMN=deploy_script_number
</comment>

If you want to create initial .env use <info>--init</info>

<info>%command.name% --init [path-to-folder]</info>

The next step is searching for sql files and trying to queue them in numerical order.
First n-th digits of a filename will be treated as candidate number. 
This will be used then to check in database if a certain file was already deployed (PROVISIONING_TABLE_CANDIDATE_NUMBER_COLUMN).
Before the insert, it will print the formatted output of a file and result of internal syntax check.
Then you can either skip or execute each.

If you would like to skip already provisioned candidates use <info>--skip-provisioned</info>
If you would like to skip syntax checking (for speed purpose) of candidates use <info>--skip-syntax-check</info>

EOF;

    /** @var Candidate[] */
    private $workingDirectoryCandidates = [];

    /** @var WorkingDirectory */
    private $workingDirectory;

    /** @var SymfonyStyle */
    private $io;

    /** @var Connection */
    private $connection;

    /** @var boolean */
    private $skipProvisionedCandidates = false;

    /** @var CandidateBuilder */
    private $candidateBuilder;

    /** @var DataRowsBuilder */
    private $dataRowsBuilder;

    /** @var integer */
    private $queuedCandidatesCount = 0;

    /** @var array */
    private $errorMessages = [];

    /** @var ProvisionDispatcher */
    private $dispatcher;

    /** @var ProvisionConfig */
    private $config;


    /**
     * @param string              $name
     * @param WorkingDirectory    $workingDirectory
     * @param Connection          $connection
     * @param CandidateBuilder    $candidateBuilder
     * @param DataRowsBuilder     $dataRowsBuilder
     * @param ProvisionDispatcher $dispatcher
     * @param ProvisionConfig     $config
     */
    public function __construct(
        $name,
        WorkingDirectory $workingDirectory,
        Connection $connection,
        CandidateBuilder $candidateBuilder,
        DataRowsBuilder $dataRowsBuilder,
        ProvisionDispatcher $dispatcher,
        ProvisionConfig $config
    ) {
        $this->workingDirectory = $workingDirectory;
        $this->connection       = $connection;
        $this->candidateBuilder = $candidateBuilder;
        $this->dataRowsBuilder  = $dataRowsBuilder;
        $this->dispatcher       = $dispatcher;
        $this->config           = $config;

        parent::__construct($name);
    }


    protected function configure()
    {
        $this
            ->setDescription('Execute the content of *.sql files from given')
            ->setHelp(self::HELP_MESSAGE);
        $this->addOption('init', null, InputOption::VALUE_NONE, 'Initialize .env in given directory');
        $this->addOption(
            'skip-provisioned',
            null,
            InputOption::VALUE_NONE,
            'Skip provisioned candidates from printing'
        );
        $this->addOption(
            'skip-syntax-check',
            null,
            InputOption::VALUE_NONE,
            'Skip executing of sql syntax check for each entry'
        );
        $this->addOption(
            'skip-email',
            null,
            InputOption::VALUE_NONE,
            'Skip email notification after provision is done'
        );
        $this->addOption(
            'force',
            'f',
            InputOption::VALUE_NONE,
            'Execute provision candidates without asking for confirmation'
        );
        $this->addOption(
            'env-file',
            null,
            InputOption::VALUE_OPTIONAL,
            'Environment variables file path. Use this env file to seed base environment variables.'
        );
        $this->addArgument('path', InputArgument::REQUIRED, 'Path to dbdeploys folder');
    }

    protected function initialize(InputInterface $input, OutputInterface $output)
    {
        if ($envFile = $input->getOption('env-file')) {
            $this->config->withEnvPath($envFile);
        }

        if ($input->getOption('force')) {
            $this->config->force();
        }

        if ($input->getOption('skip-email')) {
            $this->config->skipEmail();
        }

        if ($input->getOption('skip-syntax-check')) {
            $this->config->skipSyntaxCheck();
        }

        if ($input->getOption('skip-provisioned')) {
            $this->config->skipProvisioned();
        }

        $this->config->load();
    }

    /**
     * @param InputInterface  $input
     * @param OutputInterface $output
     *
     * @return int
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->start($input, $output);
        $this->io->section('Working directory processing');
        $this->io->comment(sprintf('Using env file from [%s]', $this->config->getEnvPath()));

        if ($this->config->isSkipProvisioned()) {
            $this->skipProvisionedCandidates = true;
            $this->io->warning('Hiding of provisioned candidates ENABLED');
        }

        if ($this->config->isSkipSyntaxCheck()) {
            $this->dispatcher->skipSyntaxCheck();
        }

        $this->processWorkingDirectory($input);
        $this->processCandidates();

        return 0;
    }


    /**
     * @param InputInterface  $input
     * @param OutputInterface $output
     */
    protected function start(InputInterface $input, OutputInterface $output)
    {
        $this->io = new SymfonyStyle($input, $output);
        $this->dispatcher->setInputOutput($this->io);

        $this->io->title('SQL Provisioner');
        $this->io->block(sprintf('Provisioning started at %s', date('Y-m-d H:i:s')));
    }


    protected function fetchCandidates()
    {
        $this->iterateOverWorkingDirectory();

        if (!empty($this->errorMessages)) {
            $this->showSyntaxErrors();
        }

        if (!$this->queuedCandidatesCount) {
            $this->io->block('All candidates scripts were executed already.');
            $this->dispatcher->finalizeAndExit();
        }
    }


    /**
     * @param SplFileInfo $candidateFile
     */
    protected function processCandidateFile($candidateFile)
    {
        $candidate = $this->candidateBuilder->build($candidateFile);
        array_push($this->workingDirectoryCandidates, $candidate);

        try {
            $this->dispatcher->validate($candidate);

            // can be also ignored but without error
            if ($candidate->isQueued()) {
                $this->queuedCandidatesCount++;
            }
        } catch (RuntimeException $validationError) {
            if ($validationError->getMessage()) {
                array_push($this->errorMessages, $validationError->getMessage());
            }
        }
    }


    protected function iterateOverWorkingDirectory()
    {
        foreach ($this->workingDirectory->getCandidates() as $candidateFile) {
            $this->processCandidateFile($candidateFile);
        }

        $this->io->text(sprintf('<info>%d</info> files found', count($this->workingDirectoryCandidates)));

        if (count($this->workingDirectoryCandidates) === 0) {
            throw Exception::noFilesInDirectory($this->workingDirectory);
        }
    }


    protected function showSyntaxErrors()
    {
        $this->io->warning(sprintf('Detected %d syntax checking issues', count($this->errorMessages)));
        $this->printAllCandidates();
        $this->io->warning(implode("\n", $this->errorMessages));
        $this->dispatcher->finalizeAndExit();
    }


    /**
     * @param InputInterface $input
     */
    protected function processWorkingDirectory(InputInterface $input)
    {
        $this->workingDirectory = $this->workingDirectory->cd($input->getArgument('path'));

        $this->loadOrCreateEnvironment($input);
        $this->io->success('DONE');
    }


    /**
     * @param InputInterface $input
     */
    private function loadOrCreateEnvironment(InputInterface $input)
    {
        if ($input->getOption('init')) {
            $this->workingDirectory->createEnvironmentFile();
            $this->io->success(sprintf('Initial .env file created in %s', $this->workingDirectory));
            die(0);
        }

        $this->workingDirectory->loadEnvironment();
    }


    private function setConnectionParameters()
    {
        $this->connection->useMysql($_ENV['DATABASE_HOST'], $_ENV['DATABASE_PORT'], $_ENV['DATABASE_NAME'],
                                    $_ENV['DATABASE_USER'], $_ENV['DATABASE_PASSWORD']);
        $this->connection->setProvisioningTable($_ENV['PROVISIONING_TABLE']);
        $this->connection->setCriteriaColumn($_ENV['PROVISIONING_TABLE_CANDIDATE_NUMBER_COLUMN']);

        $this->io->success(sprintf('Connection with `%s` established', $_ENV['DATABASE_NAME']));
    }


    private function processCandidates()
    {
        $this->io->newLine(2);
        $this->io->section('Candidates processing');

        $this->setConnectionParameters();
        $this->fetchCandidates();
        $this->printAllCandidates();
        $this->dispatcher->deploy($this->workingDirectoryCandidates, $this->queuedCandidatesCount);
    }


    private function printAllCandidates()
    {
        $this->io->table(
            DataRowsBuilder::TABLE_HEADERS,
            $this->dataRowsBuilder->build(
                $this->workingDirectoryCandidates, $this->skipProvisionedCandidates)
        );
        $this->io->newLine(3);
    }
}


1		<?php
2
3		namespace Tworzenieweb\SqlProvisioner\Command;
4
5		use RuntimeException;
6		use Symfony\Component\Console\Command\Command;
7		use Symfony\Component\Console\Input\InputArgument;
8		use Symfony\Component\Console\Input\InputInterface;
9		use Symfony\Component\Console\Input\InputOption;
10		use Symfony\Component\Console\Output\OutputInterface;
11		use Symfony\Component\Console\Style\SymfonyStyle;
12		use Symfony\Component\Finder\SplFileInfo;
13		use Tworzenieweb\SqlProvisioner\Config\ProvisionConfig;
14		use Tworzenieweb\SqlProvisioner\Controller\ProvisionDispatcher;
15		use Tworzenieweb\SqlProvisioner\Database\Connection;
16		use Tworzenieweb\SqlProvisioner\Filesystem\Exception;
17		use Tworzenieweb\SqlProvisioner\Filesystem\WorkingDirectory;
18		use Tworzenieweb\SqlProvisioner\Model\Candidate;
19		use Tworzenieweb\SqlProvisioner\Model\CandidateBuilder;
20		use Tworzenieweb\SqlProvisioner\Table\DataRowsBuilder;
21
22		/**
23		* @author Luke Adamczewski
24		* @package Tworzenieweb\SqlProvisioner\Command
25		*/
26		class ProvisionCommand extends Command
27		{
28		const HELP_MESSAGE = <<<'EOF'
29		The <info>%command.name% [path-to-folder]</info> command will scan the content of [path-to-folder] directory.
30
31		The script will look for <info>.env</info> file containing connection information in format:
32		<comment>
33		DATABASE_USER=[user]
34		DATABASE_PASSWORD=[password]
35		DATABASE_HOST=[host]
36		DATABASE_PORT=[port]
37		DATABASE_NAME=[database]
38		PROVISIONING_TABLE=changelog_database_deployments
39		PROVISIONING_TABLE_CANDIDATE_NUMBER_COLUMN=deploy_script_number
40		</comment>
41
42		If you want to create initial .env use <info>--init</info>
43
44		<info>%command.name% --init [path-to-folder]</info>
45
46		The next step is searching for sql files and trying to queue them in numerical order.
47		First n-th digits of a filename will be treated as candidate number.
48		This will be used then to check in database if a certain file was already deployed (PROVISIONING_TABLE_CANDIDATE_NUMBER_COLUMN).
49		Before the insert, it will print the formatted output of a file and result of internal syntax check.
50		Then you can either skip or execute each.
51
52		If you would like to skip already provisioned candidates use <info>--skip-provisioned</info>
53		If you would like to skip syntax checking (for speed purpose) of candidates use <info>--skip-syntax-check</info>
54
55		EOF;
56
57		/** @var Candidate[] */
58		private $workingDirectoryCandidates = [];
59
60		/** @var WorkingDirectory */
61		private $workingDirectory;
62
63		/** @var SymfonyStyle */
64		private $io;
65
66		/** @var Connection */
67		private $connection;
68
69		/** @var boolean */
70		private $skipProvisionedCandidates = false;
71
72		/** @var CandidateBuilder */
73		private $candidateBuilder;
74
75		/** @var DataRowsBuilder */
76		private $dataRowsBuilder;
77
78		/** @var integer */
79		private $queuedCandidatesCount = 0;
80
81		/** @var array */
82		private $errorMessages = [];
83
84		/** @var ProvisionDispatcher */
85		private $dispatcher;
86
87		/** @var ProvisionConfig */
88		private $config;
89
90
91		/**
92		* @param string $name
93		* @param WorkingDirectory $workingDirectory
94		* @param Connection $connection
95		* @param CandidateBuilder $candidateBuilder
96	1	* @param DataRowsBuilder $dataRowsBuilder
97		* @param ProvisionDispatcher $dispatcher
98		* @param ProvisionConfig $config
99		*/
100		public function __construct(
101		$name,
102		WorkingDirectory $workingDirectory,
103		Connection $connection,
104		CandidateBuilder $candidateBuilder,
105	1	DataRowsBuilder $dataRowsBuilder,
106	1	ProvisionDispatcher $dispatcher,
107	1	ProvisionConfig $config
108	1	) {
109	1	$this->workingDirectory = $workingDirectory;
110		$this->connection = $connection;
111	1	$this->candidateBuilder = $candidateBuilder;
112	1	$this->dataRowsBuilder = $dataRowsBuilder;
113		$this->dispatcher = $dispatcher;
114		$this->config = $config;
115	1
116		parent::__construct($name);
117	1	}
118	1
119	1
120	1	protected function configure()
121	1	{
122	1	$this
123	1	->setDescription('Execute the content of *.sql files from given')
124	1	->setHelp(self::HELP_MESSAGE);
125		$this->addOption('init', null, InputOption::VALUE_NONE, 'Initialize .env in given directory');
126	1	$this->addOption(
127	1	'skip-provisioned',
128	1	null,
129	1	InputOption::VALUE_NONE,
130	1	'Skip provisioned candidates from printing'
131		);
132	1	$this->addOption(
133	1	'skip-syntax-check',
134	1	null,
135		InputOption::VALUE_NONE,
136		'Skip executing of sql syntax check for each entry'
137		);
138		$this->addOption(
139		'skip-email',
140		null,
141		InputOption::VALUE_NONE,
142		'Skip email notification after provision is done'
143		);
144		$this->addOption(
145		'force',
146		'f',
147		InputOption::VALUE_NONE,
148		'Execute provision candidates without asking for confirmation'
149		);
150		$this->addOption(
151		'env-file',
152		null,
153		InputOption::VALUE_OPTIONAL,
154		'Environment variables file path. Use this env file to seed base environment variables.'
155		);
156		$this->addArgument('path', InputArgument::REQUIRED, 'Path to dbdeploys folder');
157		}
158
159		protected function initialize(InputInterface $input, OutputInterface $output)
160		{
161		if ($envFile = $input->getOption('env-file')) {
162		$this->config->withEnvPath($envFile);
163		}
164
165		if ($input->getOption('force')) {
166		$this->config->force();
167		}
168
169		if ($input->getOption('skip-email')) {
170		$this->config->skipEmail();
171		}
172
173		if ($input->getOption('skip-syntax-check')) {
174		$this->config->skipSyntaxCheck();
175		}
176
177		if ($input->getOption('skip-provisioned')) {
178		$this->config->skipProvisioned();
179		}
180
181		$this->config->load();
182		}
183
184		/**
185		* @param InputInterface $input
186		* @param OutputInterface $output
187		*
188		* @return int
189		*/
190		protected function execute(InputInterface $input, OutputInterface $output)
191		{
192		$this->start($input, $output);
193		$this->io->section('Working directory processing');
194		$this->io->comment(sprintf('Using env file from [%s]', $this->config->getEnvPath()));
195
196		if ($this->config->isSkipProvisioned()) {
197		$this->skipProvisionedCandidates = true;
198		$this->io->warning('Hiding of provisioned candidates ENABLED');
199		}
200
201		if ($this->config->isSkipSyntaxCheck()) {
202		$this->dispatcher->skipSyntaxCheck();
203		}
204
205		$this->processWorkingDirectory($input);
206		$this->processCandidates();
207
208		return 0;
209		}
210
211
212		/**
213		* @param InputInterface $input
214		* @param OutputInterface $output
215		*/
216		protected function start(InputInterface $input, OutputInterface $output)
217		{
218		$this->io = new SymfonyStyle($input, $output);
219		$this->dispatcher->setInputOutput($this->io);
220
221		$this->io->title('SQL Provisioner');
222		$this->io->block(sprintf('Provisioning started at %s', date('Y-m-d H:i:s')));
223		}
224
225
226		protected function fetchCandidates()
227		{
228		$this->iterateOverWorkingDirectory();
229
230		if (!empty($this->errorMessages)) {
231		$this->showSyntaxErrors();
232		}
233
234		if (!$this->queuedCandidatesCount) {
235		$this->io->block('All candidates scripts were executed already.');
236		$this->dispatcher->finalizeAndExit();
237		}
238		}
239
240
241		/**
242		* @param SplFileInfo $candidateFile
243		*/
244		protected function processCandidateFile($candidateFile)
245		{
246		$candidate = $this->candidateBuilder->build($candidateFile);
247		array_push($this->workingDirectoryCandidates, $candidate);
248
249		try {
250		$this->dispatcher->validate($candidate);
251
252		// can be also ignored but without error
253		if ($candidate->isQueued()) {
254		$this->queuedCandidatesCount++;
255		}
256		} catch (RuntimeException $validationError) {
257		if ($validationError->getMessage()) {
258		array_push($this->errorMessages, $validationError->getMessage());
259		}
260		}
261		}
262
263
264		protected function iterateOverWorkingDirectory()
265		{
266		foreach ($this->workingDirectory->getCandidates() as $candidateFile) {
267		$this->processCandidateFile($candidateFile);
268		}
269
270		$this->io->text(sprintf('<info>%d</info> files found', count($this->workingDirectoryCandidates)));
271
272		if (count($this->workingDirectoryCandidates) === 0) {
273		throw Exception::noFilesInDirectory($this->workingDirectory);
274		}
275		}
276
277
278		protected function showSyntaxErrors()
279		{
280		$this->io->warning(sprintf('Detected %d syntax checking issues', count($this->errorMessages)));
281		$this->printAllCandidates();
282		$this->io->warning(implode("\n", $this->errorMessages));
283		$this->dispatcher->finalizeAndExit();
284		}
285
286
287		/**
288		* @param InputInterface $input
289		*/
290		protected function processWorkingDirectory(InputInterface $input)
291		{
292		$this->workingDirectory = $this->workingDirectory->cd($input->getArgument('path'));
		0 ignored issues – show Bug introduced 2019-03-10 20:16 UTC by Report Bug Copy Issue Report It seems like `$input->getArgument('path')` targeting `Symfony\Component\Consol...nterface::getArgument()` can also be of type `array<integer,string>` or `null`; however, `Tworzenieweb\SqlProvisio...\WorkingDirectory::cd()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
293		$this->loadOrCreateEnvironment($input);
294		$this->io->success('DONE');
295		}
296
297
298		/**
299		* @param InputInterface $input
300		*/
301		private function loadOrCreateEnvironment(InputInterface $input)
302		{
303		if ($input->getOption('init')) {
304		$this->workingDirectory->createEnvironmentFile();
305		$this->io->success(sprintf('Initial .env file created in %s', $this->workingDirectory));
306		die(0);
307		}
308
309		$this->workingDirectory->loadEnvironment();
310		}
311
312
313		private function setConnectionParameters()
314		{
315		$this->connection->useMysql($_ENV['DATABASE_HOST'], $_ENV['DATABASE_PORT'], $_ENV['DATABASE_NAME'],
316		$_ENV['DATABASE_USER'], $_ENV['DATABASE_PASSWORD']);
317		$this->connection->setProvisioningTable($_ENV['PROVISIONING_TABLE']);
318		$this->connection->setCriteriaColumn($_ENV['PROVISIONING_TABLE_CANDIDATE_NUMBER_COLUMN']);
319
320		$this->io->success(sprintf('Connection with `%s` established', $_ENV['DATABASE_NAME']));
321		}
322
323
324		private function processCandidates()
325		{
326		$this->io->newLine(2);
327		$this->io->section('Candidates processing');
328
329		$this->setConnectionParameters();
330		$this->fetchCandidates();
331		$this->printAllCandidates();
332		$this->dispatcher->deploy($this->workingDirectoryCandidates, $this->queuedCandidatesCount);
333		}
334
335
336		private function printAllCandidates()
337		{
338		$this->io->table(
339		DataRowsBuilder::TABLE_HEADERS,
340		$this->dataRowsBuilder->build(
341		$this->workingDirectoryCandidates, $this->skipProvisionedCandidates)
342		);
343		$this->io->newLine(3);
344		}
345		}
346

tworzenieweb / sql-provisioner

Pull Request — master (#20)

ProvisionCommand::start() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like