Cron::setCronTab() - Code Metrics - Inspection of "status table" - itrukhin/bxconsole - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e49e3e...821da0 )

by Ioannes

created 2021-11-11 23:35 UTC

Cron::setCronTab() A

↳ Parent: Cron

Complexity

Conditions	3
Paths	3

Size

Total Lines	15
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	9
c	2
b	0
f	0
dl	0
loc	15
rs	9.9666
cc	3
nc	3
nop	1

<?php
namespace App\BxConsole;

use Doctrine\Common\Annotations\AnnotationReader;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Helper\TableCell;
use Symfony\Component\Console\Helper\TableSeparator;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use App\BxConsole\Annotations\Agent;

class Cron extends BxCommand {

    use LockableTrait;

    const EXEC_STATUS_SUCCESS = 'SUCCESS';
    const EXEC_STATUS_ERROR = 'ERROR';
    const EXEC_STATUS_WORK = 'WORK';

    const SORT_NAME = 'name';
    const SORT_TIME = 'time';

    private $minAgentPeriod;

    protected function configure() {

        $this->setName('system:cron')
            ->setDescription('Job sheduler for application comands')
            ->addOption('status', 's', InputOption::VALUE_NONE, 'Show BX_CRONTAB status table')
            ->addOption('bytime', 't', InputOption::VALUE_NONE, 'Sort status table by exec time desc')
            ->addOption('clean', 'c', InputOption::VALUE_REQUIRED, 'Command to be clean crontab data (status, last exec)');
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $logger = EnvHelper::getLogger('bx_cron');
        if($logger) {
            $this->setLogger($logger);
        }

        $showStatus = $input->getOption('status');
        $byTime = $input->getOption('bytime');
        if($showStatus) {
            $sort = ($byTime ? self::SORT_TIME : self::SORT_NAME);
            $this->showStatus($output, $sort);
            return 0;
        }

        if(EnvHelper::getSwitch('BX_CRONTAB_RUN', EnvHelper::SWITCH_STATE_OFF)) {
            if($this->logger) {
                $this->logger->alert('BxCron switch off');
            }
            return 0;
        }

        if(!$this->lock()) {
            $msg = 'The command is already running in another process.';
            $output->writeln($msg);
            if($this->logger) {
                $this->logger->warning($msg);
            }
            return 0;
        }

        if($sleepInterval = EnvHelper::checkSleepInterval()) {
            $msg = sprintf("Sleep in interval %s", $sleepInterval);
            $output->writeln($msg);
            if($this->logger) {
                $this->logger->warning($msg);
            }
            return 0;
        }

        $clean = $input->getOption('clean');
        if($clean) {
            $command = $this->getApplication()->find($clean);
            $this->cleanJob($command->getName());
            $output->writeln($command->getName() . " will be executed now");
            return 0;
        }

        $this->executeJobs($output);

        $this->release();
    }

    protected function showStatus(OutputInterface $output, $sort) {

        $table = new Table($output);
        $table->setStyle('box-double');

        $isSwitchOff = EnvHelper::getSwitch('BX_CRONTAB_RUN', EnvHelper::SWITCH_STATE_OFF);

        $jobs = $this->getCronJobs();
        $this->sortCronTab($jobs, $sort);
        $lastExec = 0;
        $hasError = false;

        foreach($jobs as $cmd => $job) {
            $execTime = $job['last_exec'];
            if($execTime > $lastExec) $lastExec = $execTime;
            if(!empty($job['error'])) {
                $hasError = true;
            }
        }

        $headStr = sprintf(
            "BX_CRONTAB_RUN: %s;  LAST_EXEC: %s;  AGENTS_COUNT: %d",
            ($isSwitchOff ? 'OFF' : 'ON'),
            ($lastExec ? date("d.m.Y H:i:s", $lastExec) : 'NONE'),
            count($jobs),
        );

        $header = [
            'Command',
            'Period',
            'Last Exec',
            'Status',
        ];

        if($hasError) {
            $header[] = 'Error';
        }

        $table->setHeaders([
            [new TableCell($headStr, ['colspan' => ($hasError ? 5 : 4)])],
            $header,
        ]);

        $cnt = 1;
        foreach($jobs as $cmd => $job) {
            if($cnt > 1) $table->addRow(new TableSeparator());
            $row = [
                $cmd,
                $job['period'],
                ($job['last_exec'] ? date("d.m.Y H:i:s", $job['last_exec']) : 'NONE'),
                $job['status'],
            ];
            if($hasError) {
                $row[] = $job['error'];
            }
            $table->addRow($row);
            $cnt++;
        }

        $table->render();
    }

    protected function cleanJob($command) {

        $crontab = $this->getCronTab();

        unset($crontab[$command]);

        $this->setCronTab($crontab);
    }

    protected function executeJobs(OutputInterface $output) {

        $jobs = $this->getCronJobs();

        /*
         * Минимально допустимый период выполнения одной задачи
         * при котором гарантируется выполнение всех задач
         */
        $this->minAgentPeriod = (count($jobs) + 1) * EnvHelper::getBxCrontabPeriod();

        if(!empty($jobs)) {

            foreach($jobs as $cmd => $job) {

                if($this->isActualJob($job)) {

                    $job['status'] = self::EXEC_STATUS_WORK;
                    $this->updaateJob($cmd, $job);

                    $command = $this->getApplication()->find($cmd);
                    $cmdInput = new ArrayInput(['command' => $cmd]);
                    try {

                        $timeStart = microtime(true);
                        $returnCode = $command->run($cmdInput, $output);

                        if(!$returnCode) {

                            $job['status'] = self::EXEC_STATUS_SUCCESS;

                            $msg = sprintf("%s: SUCCESS [%.2f s]", $cmd, microtime(true) - $timeStart);
                            if($this->logger) {
                                $this->logger->alert($msg);
                            }
                            $output->writeln(PHP_EOL . $msg);

                        } else {

                            $job['status'] = self::EXEC_STATUS_ERROR;
                            $job['error_code'] = $returnCode;

                            $msg = sprintf("%s: ERROR [%.2f s]", $cmd, microtime(true) - $timeStart);
                            if($this->logger) {
                                $this->logger->alert($msg);
                            }
                            $output->writeln(PHP_EOL . $msg);
                        }

                    } catch (\Exception $e) {

                        $job['status'] = self::EXEC_STATUS_ERROR;
                        $job['error'] = $e->getMessage();


                        if($this->logger) {
                            $this->logger->error($e, ['command' => $cmd]);
                        }
                        $output->writeln(PHP_EOL . 'ERROR: ' . $e->getMessage());

                    } finally {

                        $job['last_exec'] = time();
                    }

                    $this->updaateJob($cmd, $job);
                    /*
                     * Let's do just one task
                     */
                    break;
                }
            } // foreach($jobs as $cmd => $job)
        } // if(!empty($jobs))
    }

    protected function isActualJob(&$job) {

        if(isset($job['status']) && $job['status'] !== self::EXEC_STATUS_SUCCESS) {
            return false;
        }

        $period = intval($job['period']);

        if($period > 0) {
            if($period < $this->minAgentPeriod) {
                $job['orig_period'] = $period;
                $period = $job['period'] = $this->minAgentPeriod;
            }
            if(time() - $job['last_exec'] >= $period) {
                return true;
            }
        } else if(!empty($job['times'])) {
            //TODO:
        }

        return false;
    }

    protected function getCronJobs() {

        /** @var Application $app */
        $app = $this->getApplication();

        $commands = $app->all();

        $selfCommands = [];
        foreach($commands as $command) {
            /** @var BxCommand $command */
            if($command instanceof BxCommand) {
                $name = $command->getName();
                $selfCommands[$name] = [
                    'object' => $command,
                ];
            }
        }

        $agents = [];
        $reader = new AnnotationReader();
        foreach($selfCommands as $cmd => $selfCommand) {
            $reflectionClass = new \ReflectionClass($selfCommand['object']);
            $annotations = $reader->getClassAnnotations($reflectionClass);

            foreach($annotations as $annotation) {
                if($annotation instanceof Agent) {
                    $agents[$cmd] = $annotation->toArray();
                }
            }
        }

        $crontab = $this->getCronTab();

        foreach($crontab as $cmd => $job) {
            if(is_array($job) && isset($agents[$cmd])) {
                $agents[$cmd] = array_merge($job, $agents[$cmd]);
            }
        }

        $this->setCronTab($agents);

        return $agents;
    }

    protected function updaateJob($cmd, $job) {

        $this->updateCronTab([$cmd => $job]);
    }

    protected function updateCronTab(array $changedAgents) {

        $crontab = $this->getCronTab();

        $crontab = array_merge($crontab, $changedAgents);

        $this->setCronTab($crontab);
    }


    protected function setCronTab(array $agents) {

        $this->sortCronTab($agents);

        $filename = EnvHelper::getCrontabFile();

        $fh = fopen($filename, 'c');
        if (flock($fh, LOCK_EX)) {
            ftruncate($fh, 0);
            if(!fwrite($fh, json_encode($agents, JSON_PRETTY_PRINT))) {
                throw new \Exception('Unable to write BX_CRONTAB : ' . $filename);
            }
        }
        flock($fh, LOCK_UN);
        fclose($fh);
    }

    /**
     * @return array
     */
    protected function getCronTab() {

        $cronTab = [];

        $filename = EnvHelper::getCrontabFile();

        $fh = fopen($filename, 'r');
        if(flock($fh, LOCK_SH)) {
            if($data = @fread($fh, filesize($filename))) {
                $decoded = json_decode($data, true);
                if(is_array($decoded)) {
                    $cronTab = $decoded;
                }
            }
        }
        flock($fh, LOCK_UN);
        fclose($fh);

        return $cronTab;
    }

    protected function sortCronTab(array &$crontab, $sort = self::SORT_NAME) {

        if($sort == self::SORT_TIME) {
            $sorting = [];
            foreach($crontab as $cmd => $data) {
                $sorting[$cmd] = $data['last_exec'];
            }
            arsort($sorting, SORT_NUMERIC);
            $sorted = [];
            foreach($sorting as $cmd => $time) {
                $sorted[$cmd] = $crontab[$cmd];
            }
            $crontab = $sorted;
        } else {
            ksort($crontab, SORT_STRING);
        }
    }
}

1			<?php
2			namespace App\BxConsole;
3
4			use Doctrine\Common\Annotations\AnnotationReader;
5			use Symfony\Component\Console\Helper\Table;
6			use Symfony\Component\Console\Helper\TableCell;
7			use Symfony\Component\Console\Helper\TableSeparator;
8			use Symfony\Component\Console\Input\ArrayInput;
9			use Symfony\Component\Console\Input\InputInterface;
10			use Symfony\Component\Console\Input\InputOption;
11			use Symfony\Component\Console\Output\ConsoleOutputInterface;
12			use Symfony\Component\Console\Output\OutputInterface;
13			use App\BxConsole\Annotations\Agent;
14
15			class Cron extends BxCommand {
16
17			use LockableTrait;
18
19			const EXEC_STATUS_SUCCESS = 'SUCCESS';
20			const EXEC_STATUS_ERROR = 'ERROR';
21			const EXEC_STATUS_WORK = 'WORK';
22
23			const SORT_NAME = 'name';
24			const SORT_TIME = 'time';
25
26			private $minAgentPeriod;
27
28			protected function configure() {
29
30			$this->setName('system:cron')
31			->setDescription('Job sheduler for application comands')
32			->addOption('status', 's', InputOption::VALUE_NONE, 'Show BX_CRONTAB status table')
33			->addOption('bytime', 't', InputOption::VALUE_NONE, 'Sort status table by exec time desc')
34			->addOption('clean', 'c', InputOption::VALUE_REQUIRED, 'Command to be clean crontab data (status, last exec)');
35			}
36
37			protected function execute(InputInterface $input, OutputInterface $output)
38			{
39			$logger = EnvHelper::getLogger('bx_cron');
40			if($logger) {
41			$this->setLogger($logger);
42			}
43
44			$showStatus = $input->getOption('status');
45			$byTime = $input->getOption('bytime');
46			if($showStatus) {
47			$sort = ($byTime ? self::SORT_TIME : self::SORT_NAME);
48			$this->showStatus($output, $sort);
49			return 0;
50			}
51
52			if(EnvHelper::getSwitch('BX_CRONTAB_RUN', EnvHelper::SWITCH_STATE_OFF)) {
53			if($this->logger) {
54			$this->logger->alert('BxCron switch off');
55			}
56			return 0;
57			}
58
59			if(!$this->lock()) {
60			$msg = 'The command is already running in another process.';
61			$output->writeln($msg);
62			if($this->logger) {
63			$this->logger->warning($msg);
64			}
65			return 0;
66			}
67
68			if($sleepInterval = EnvHelper::checkSleepInterval()) {
69			$msg = sprintf("Sleep in interval %s", $sleepInterval);
70			$output->writeln($msg);
71			if($this->logger) {
72			$this->logger->warning($msg);
73			}
74			return 0;
75			}
76
77			$clean = $input->getOption('clean');
78			if($clean) {
79			$command = $this->getApplication()->find($clean);
80			$this->cleanJob($command->getName());
81			$output->writeln($command->getName() . " will be executed now");
82			return 0;
83			}
84
85			$this->executeJobs($output);
86
87			$this->release();
88			}
89
90			protected function showStatus(OutputInterface $output, $sort) {
91
92			$table = new Table($output);
93			$table->setStyle('box-double');
94
95			$isSwitchOff = EnvHelper::getSwitch('BX_CRONTAB_RUN', EnvHelper::SWITCH_STATE_OFF);
96
97			$jobs = $this->getCronJobs();
98			$this->sortCronTab($jobs, $sort);
99			$lastExec = 0;
100			$hasError = false;
101
102			foreach($jobs as $cmd => $job) {
103			$execTime = $job['last_exec'];
104			if($execTime > $lastExec) $lastExec = $execTime;
105			if(!empty($job['error'])) {
106			$hasError = true;
107			}
108			}
109
110			$headStr = sprintf(
111			"BX_CRONTAB_RUN: %s; LAST_EXEC: %s; AGENTS_COUNT: %d",
112			($isSwitchOff ? 'OFF' : 'ON'),
113			($lastExec ? date("d.m.Y H:i:s", $lastExec) : 'NONE'),
114			count($jobs),
115			);
116
117			$header = [
118			'Command',
119			'Period',
120			'Last Exec',
121			'Status',
122			];
123
124			if($hasError) {
125			$header[] = 'Error';
126			}
127
128			$table->setHeaders([
129			[new TableCell($headStr, ['colspan' => ($hasError ? 5 : 4)])],
130			$header,
131			]);
132
133			$cnt = 1;
134			foreach($jobs as $cmd => $job) {
135			if($cnt > 1) $table->addRow(new TableSeparator());
136			$row = [
137			$cmd,
138			$job['period'],
139			($job['last_exec'] ? date("d.m.Y H:i:s", $job['last_exec']) : 'NONE'),
140			$job['status'],
141			];
142			if($hasError) {
143			$row[] = $job['error'];
144			}
145			$table->addRow($row);
146			$cnt++;
147			}
148
149			$table->render();
150			}
151
152			protected function cleanJob($command) {
153
154			$crontab = $this->getCronTab();
155
156			unset($crontab[$command]);
157
158			$this->setCronTab($crontab);
159			}
160
161			protected function executeJobs(OutputInterface $output) {
162
163			$jobs = $this->getCronJobs();
164
165			/*
166			* Минимально допустимый период выполнения одной задачи
167			* при котором гарантируется выполнение всех задач
168			*/
169			$this->minAgentPeriod = (count($jobs) + 1) * EnvHelper::getBxCrontabPeriod();
170
171			if(!empty($jobs)) {
172
173			foreach($jobs as $cmd => $job) {
174
175			if($this->isActualJob($job)) {
176
177			$job['status'] = self::EXEC_STATUS_WORK;
178			$this->updaateJob($cmd, $job);
179
180			$command = $this->getApplication()->find($cmd);
181			$cmdInput = new ArrayInput(['command' => $cmd]);
182			try {
183
184			$timeStart = microtime(true);
185			$returnCode = $command->run($cmdInput, $output);
186
187			if(!$returnCode) {
188
189			$job['status'] = self::EXEC_STATUS_SUCCESS;
190
191			$msg = sprintf("%s: SUCCESS [%.2f s]", $cmd, microtime(true) - $timeStart);
192			if($this->logger) {
193			$this->logger->alert($msg);
194			}
195			$output->writeln(PHP_EOL . $msg);
196
197			} else {
198
199			$job['status'] = self::EXEC_STATUS_ERROR;
200			$job['error_code'] = $returnCode;
201
202			$msg = sprintf("%s: ERROR [%.2f s]", $cmd, microtime(true) - $timeStart);
203			if($this->logger) {
204			$this->logger->alert($msg);
205			}
206			$output->writeln(PHP_EOL . $msg);
207			}
208
209			} catch (\Exception $e) {
210
211			$job['status'] = self::EXEC_STATUS_ERROR;
212			$job['error'] = $e->getMessage();
213
214
215			if($this->logger) {
216			$this->logger->error($e, ['command' => $cmd]);
217			}
218			$output->writeln(PHP_EOL . 'ERROR: ' . $e->getMessage());
219
220			} finally {
221
222			$job['last_exec'] = time();
223			}
224
225			$this->updaateJob($cmd, $job);
226			/*
227			* Let's do just one task
228			*/
229			break;
230			}
231			} // foreach($jobs as $cmd => $job)
232			} // if(!empty($jobs))
233			}
234
235			protected function isActualJob(&$job) {
236
237			if(isset($job['status']) && $job['status'] !== self::EXEC_STATUS_SUCCESS) {
238			return false;
239			}
240
241			$period = intval($job['period']);
242
243			if($period > 0) {
244			if($period < $this->minAgentPeriod) {
245			$job['orig_period'] = $period;
246			$period = $job['period'] = $this->minAgentPeriod;
247			}
248			if(time() - $job['last_exec'] >= $period) {
249			return true;
250			}
251			} else if(!empty($job['times'])) {
252			//TODO:
253			}
254
255			return false;
256			}
257
258			protected function getCronJobs() {
259
260			/** @var Application $app */
261			$app = $this->getApplication();
262
263			$commands = $app->all();
264
265			$selfCommands = [];
266			foreach($commands as $command) {
267			/** @var BxCommand $command */
268			if($command instanceof BxCommand) {
269			$name = $command->getName();
270			$selfCommands[$name] = [
271			'object' => $command,
272			];
273			}
274			}
275
276			$agents = [];
277			$reader = new AnnotationReader();
278			foreach($selfCommands as $cmd => $selfCommand) {
279			$reflectionClass = new \ReflectionClass($selfCommand['object']);
280			$annotations = $reader->getClassAnnotations($reflectionClass);
281
282			foreach($annotations as $annotation) {
283			if($annotation instanceof Agent) {
284			$agents[$cmd] = $annotation->toArray();
285			}
286			}
287			}
288
289			$crontab = $this->getCronTab();
290
291			foreach($crontab as $cmd => $job) {
292			if(is_array($job) && isset($agents[$cmd])) {
293			$agents[$cmd] = array_merge($job, $agents[$cmd]);
294			}
295			}
296
297			$this->setCronTab($agents);
298
299			return $agents;
300			}
301
302			protected function updaateJob($cmd, $job) {
303
304			$this->updateCronTab([$cmd => $job]);
305			}
306
307			protected function updateCronTab(array $changedAgents) {
308
309			$crontab = $this->getCronTab();
310
311			$crontab = array_merge($crontab, $changedAgents);
312
313			$this->setCronTab($crontab);
314			}
315
316
317			protected function setCronTab(array $agents) {
318
319			$this->sortCronTab($agents);
320
321			$filename = EnvHelper::getCrontabFile();
322
323			$fh = fopen($filename, 'c');
324			if (flock($fh, LOCK_EX)) {
325			ftruncate($fh, 0);
326			if(!fwrite($fh, json_encode($agents, JSON_PRETTY_PRINT))) {
327			throw new \Exception('Unable to write BX_CRONTAB : ' . $filename);
328			}
329			}
330			flock($fh, LOCK_UN);
331			fclose($fh);
332			}
333
334			/**
335			* @return array
336			*/
337			protected function getCronTab() {
338
339			$cronTab = [];
340
341			$filename = EnvHelper::getCrontabFile();
342
343			$fh = fopen($filename, 'r');
344			if(flock($fh, LOCK_SH)) {
345			if($data = @fread($fh, filesize($filename))) {
346			$decoded = json_decode($data, true);
347			if(is_array($decoded)) {
348			$cronTab = $decoded;
349			}
350			}
351			}
352			flock($fh, LOCK_UN);
353			fclose($fh);
354
355			return $cronTab;
356			}
357
358			protected function sortCronTab(array &$crontab, $sort = self::SORT_NAME) {
359
360			if($sort == self::SORT_TIME) {
361			$sorting = [];
362			foreach($crontab as $cmd => $data) {
363			$sorting[$cmd] = $data['last_exec'];
364			}
365			arsort($sorting, SORT_NUMERIC);
366			$sorted = [];
367			foreach($sorting as $cmd => $time) {
368			$sorted[$cmd] = $crontab[$cmd];
369			}
370			$crontab = $sorted;
371			} else {
372			ksort($crontab, SORT_STRING);
373			}
374			}
375			}

itrukhin / bxconsole

Push — master ( e49e3e...821da0 )

Cron::setCronTab() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like