New development from our side

.bowerrc

@@ -0,0 +1,3 @@
+{
+"directory":"Resources/public/vendor"
+}

.gitignore

@@ -1 +1,2 @@
+*.sql
 vendor/

.sensiolabs.yml

@@ -0,0 +1,5 @@
+rules:
+  symfony.controller.non_action_public_method_in_controller_class:
+    enabled: false
+  symfony.dependency_injection.no_container_as_parameter:
+    enabled: false

.travis.yml

@@ -2,7 +2,6 @@ language: php
 
 php:
     - 5.3
-    - 5.4
     - 5.5
     - 5.6
     - 7.0
@@ -16,14 +15,18 @@ branches:
 
 matrix:
     include:
+        - php: 5.3
+          env: SYMFONY_VERSION='2.8.*'
         - php: 5.5
-          env: SYMFONY_VERSION=2.3.*
-        - php: 5.5
-          env: SYMFONY_VERSION=2.4.*
-        - php: 5.5
-          env: SYMFONY_VERSION=2.6.*
-        - php: 5.5
-          env: SYMFONY_VERSION=2.7.*
+          env: SYMFONY_VERSION='2.8.*'
+        - php: 5.6
+          env: SYMFONY_VERSION='2.8.*'
+        - php: 5.6
+          env: SYMFONY_VERSION='3.0'
+        - php: 7.0
+          env: SYMFONY_VERSION='2.8.*'
+        - php: 7.0
+          env: SYMFONY_VERSION='3.0'
     allow_failures:
         - php: nightly
 
@@ -42,4 +45,4 @@ after_success: |
  sh -c 'if [ "$TRAVIS_PHP_VERSION" != "hhvm" -a "$TRAVIS_PHP_VERSION" != "hhvm-nightly" ]; then php vendor/bin/coveralls -v --config .coveralls.yml; fi;'
 
 notifications:
-    email: julienguyon@hotmail.com
+    email: homerj.simpson000@gmail.com

Command/ExecuteCommand.php

@@ -3,44 +3,24 @@
 namespace JMose\CommandSchedulerBundle\Command;
 
 use Cron\CronExpression;
-use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
+use JMose\CommandSchedulerBundle\Entity\Execution;
+use JMose\CommandSchedulerBundle\Entity\ScheduledCommand;
+use JMose\CommandSchedulerBundle\Component\CommandOutput;
 use Symfony\Component\Console\Input\ArrayInput;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\NullOutput;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Output\StreamOutput;
-use JMose\CommandSchedulerBundle\Entity\ScheduledCommand;
 
 /**
  * Class ExecuteCommand : This class is the entry point to execute all scheduled command
  *
  * @author  Julien Guyon <[email protected]>
  * @package JMose\CommandSchedulerBundle\Command
  */
-class ExecuteCommand extends ContainerAwareCommand
+class ExecuteCommand extends SchedulerBaseCommand
 {
-
-    /**
-     * @var \Doctrine\ORM\EntityManager
-     */
-    private $em;
-
-    /**
-     * @var string
-     */
-    private $logPath;
-
-    /**
-     * @var boolean
-     */
-    private $dumpMode;
-
-    /**
-     * @var integer
-     */
-    private $commandsVerbosity;
-
     /**
      * @inheritdoc
      */
@@ -55,66 +35,47 @@ protected function configure()
     }
 
     /**
-     * Initialize parameters and services used in execute function
-     *
      * @param InputInterface $input
      * @param OutputInterface $output
-     */
-    protected function initialize(InputInterface $input, OutputInterface $output)
-    {
-        $this->dumpMode = $input->getOption('dump');
-        $this->logPath = $this->getContainer()->getParameter('jmose_command_scheduler.log_path');
-
-	    // If logpath is not set to false, append the directory separator to it
-	    if(false !== $this->logPath) {
-            $this->logPath = rtrim($this->logPath, '/\\') . DIRECTORY_SEPARATOR ;
-	    }
-
-        // Store the original verbosity before apply the quiet parameter
-        $this->commandsVerbosity = $output->getVerbosity();
-
-        if( true === $input->getOption('no-output')){
-            $output->setVerbosity( OutputInterface::VERBOSITY_QUIET );
-        }
-
-        $this->em = $this->getContainer()->get('doctrine')->getManager(
-            $this->getContainer()->getParameter('jmose_command_scheduler.doctrine_manager')
-        );
-    }
-
-    /**
-     * @param InputInterface  $input
-     * @param OutputInterface $output
      * @return int|null|void
      */
     protected function execute(InputInterface $input, OutputInterface $output)
     {
         $output->writeln('<info>Start : ' . ($this->dumpMode ? 'Dump' : 'Execute') . ' all scheduled command</info>');
 
         // Before continue, we check that the output file is valid and writable (except for gaufrette)
-        if (false !== $this->logPath && strpos($this->logPath, 'gaufrette:') !== 0 && false === is_writable($this->logPath)) {
+        if (
+            false !== $this->logPath &&
+            strpos($this->logPath, 'gaufrette:') !== 0 &&
+            false === is_writable($this->logPath)
+        ) {
             $output->writeln(
-                '<error>'.$this->logPath.
-                ' not found or not writable. You should override `log_path` in your config.yml'.'</error>'
+                '<error>' . $this->logPath .
+                ' not found or not writable. You should override `log_path` in your config.yml' . '</error>'
             );
 
             return;
         }
 
-        $commands = $this->em->getRepository('JMoseCommandSchedulerBundle:ScheduledCommand')->findEnabledCommand();
+        $commands = $this->getRepository('ScheduledCommand')->findEnabledCommand();
 
         $noneExecution = true;
         foreach ($commands as $command) {
 
             /** @var ScheduledCommand $command */
-            $cron        = CronExpression::factory($command->getCronExpression());
+            // check if the command's rights (user and host) allow execution of the command at all.
+            if (!$command->checkRights()) {
+                continue;
+            }
+
+            $cron = CronExpression::factory($command->getCronExpression());
             $nextRunDate = $cron->getNextRunDate($command->getLastExecution());
-            $now         = new \DateTime();
+            $now = new \DateTime();
 
             if ($command->isExecuteImmediately()) {
                 $noneExecution = false;
                 $output->writeln(
-                    'Immediately execution asked for : <comment>' . $command->getCommand() . '</comment>'
+                    'Immediately execution asked for : <comment>' . $command->getCommand() . ' ' . $command->getArguments() . '</comment>'
                 );
 
                 if (!$input->getOption('dump')) {
@@ -123,9 +84,9 @@ protected function execute(InputInterface $input, OutputInterface $output)
             } elseif ($nextRunDate < $now) {
                 $noneExecution = false;
                 $output->writeln(
-                    'Command <comment>'.$command->getCommand().
-                    '</comment> should be executed - last execution : <comment>'.
-                    $command->getLastExecution()->format('d/m/Y H:i:s').'.</comment>'
+                    'Command <comment>' . $command->getCommand() .
+                    '</comment> should be executed - last execution : <comment>' .
+                    $command->getLastExecution()->format('d/m/Y H:i:s') . '.</comment>'
                 );
 
                 if (!$input->getOption('dump')) {
@@ -144,10 +105,21 @@ protected function execute(InputInterface $input, OutputInterface $output)
      */
     private function executeCommand(ScheduledCommand $scheduledCommand, OutputInterface $output, InputInterface $input)
     {
-        $scheduledCommand = $this->em->merge($scheduledCommand);
-        $scheduledCommand->setLastExecution(new \DateTime());
+        $now = new \DateTime();
+        /** @var ScheduledCommand $scheduledCommand */
+        $scheduledCommand = $this->entityManager->merge($scheduledCommand);
+        $scheduledCommand->setLastExecution($now);
         $scheduledCommand->setLocked(true);
-        $this->em->flush();
+
+        if ($scheduledCommand->logExecutions()) {
+            $log = new Execution();
+            $log->setCommand($scheduledCommand);
+            $log->setExecutionDate($now);
+            $this->entityManager->persist($log);
+            $scheduledCommand->addLog($log);
+        }
+
+        $this->entityManager->flush();
 
         try {
             $command = $this->getApplication()->find($scheduledCommand->getCommand());
@@ -161,47 +133,69 @@ private function executeCommand(ScheduledCommand $scheduledCommand, OutputInterf
         $input = new ArrayInput(array_merge(
             array(
                 'command' => $scheduledCommand->getCommand(),
-                '--env'   => $input->getOption('env')
+                '--env' => $input->getOption('env')
             ),
             $scheduledCommand->getArguments(true)
         ));
 
         // Use a StreamOutput or NullOutput to redirect write() and writeln() in a log file
         if (false === $this->logPath || '' != $scheduledCommand->getLogFile() ) {
             $logOutput = new NullOutput();
-        }else{
-            $logOutput = new StreamOutput(fopen(
-                $this->logPath . $scheduledCommand->getLogFile(), 'a', false
-            ),$this->commandsVerbosity );
+        } else {
+            $logOutput = new StreamOutput(
+                fopen(
+                    $this->logPath . $scheduledCommand->getLogFile(),
+                    'a',
+                    false
+                ),
+                $this->commandsVerbosity
+            );
         }
 
+        $commandOutput = new CommandOutput();
+        $commandOutput->setDefaultOutput($logOutput);
+
         // Execute command and get return code
         try {
             $output->writeln('<info>Execute</info> : <comment>' . $scheduledCommand->getCommand()
-                . ' ' .$scheduledCommand->getArguments() . '</comment>');
-            $result = $command->run($input, $logOutput);
+                . ' ' . $scheduledCommand->getArguments() . '</comment>');
+            $result = $command->run($input, $commandOutput);
+            sleep(3);
         } catch (\Exception $e) {
             $logOutput->writeln($e->getMessage());
             $logOutput->writeln($e->getTraceAsString());
             $result = -1;
         }
 
-        if (false === $this->em->isOpen()) {
+        if (false === $this->entityManager->isOpen()) {
             $output->writeln('<comment>Entity manager closed by the last command.</comment>');
-            $this->em = $this->em->create($this->em->getConnection(), $this->em->getConfiguration());
+            $this->entityManager = $this->entityManager->create($this->entityManager->getConnection(), $this->entityManager->getConfiguration());
         }
 
-        $scheduledCommand = $this->em->merge($scheduledCommand);
+        $scheduledCommand = $this->entityManager->merge($scheduledCommand);
         $scheduledCommand->setLastReturnCode($result);
         $scheduledCommand->setLocked(false);
         $scheduledCommand->setExecuteImmediately(false);
-        $this->em->flush();
+
+        if ($scheduledCommand->logExecutions()) {
+            /** @var Execution $log */
+            $log = $scheduledCommand->getCurrentLog();
+            $log->setReturnCode($result);
+            $log->setOutput($commandOutput->getBuffer('string'));
+
+            // calculate runtime in seconds
+            $now = new \DateTime();
+            $runtime = $now->getTimestamp() - $log->getExecutionDate()->getTimestamp();
+            $log->setRuntime($runtime);
+        }
+
+        $this->entityManager->flush();
 
         /*
          * This clear() is necessary to avoid conflict between commands and to be sure that none entity are managed
          * before entering in a new command
          */
-        $this->em->clear();
+        $this->entityManager->clear();
 
         unset($command);
         gc_collect_cycles();

Command/HelloCommand.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace JMose\CommandSchedulerBundle\Command;
+
+use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * Class HelloCommand : Say Hello World (can be used for testing purposes
+ *
+ * @author  Daniel Fischer <[email protected]>
+ * @package JMose\CommandSchedulerBundle\Command
+ */
+class HelloCommand extends ContainerAwareCommand
+{
+    /**
+     * @inheritdoc
+     */
+    protected function configure()
+    {
+        $this
+            ->setName('schedulerTest:hello')
+            ->setDescription('Hello world testcommand')
+            ->addOption(
+                'name',
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'Person who shall be greeted',
+                'World'
+            )
+            ->addOption(
+                'trash',
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'can be set to anything, not used',
+                false
+            )
+            ->addOption(
+                'randReturn',
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'set to enable random return value',
+                false
+            )
+            ->addOption(
+                'randSleep',
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'set to enable random sleep to increase runtime',
+                false
+            )
+            ->setHelp('This class is used for testing purposes only');
+    }
+
+    /**
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @return int|null|void
+     */
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $name = $input->getOption('name');
+        $output->writeln('<info>Hello ' . $name . '</info>');
+
+        if ($input->getOption('randSleep')) {
+            sleep(rand(1, 10));
+        }
+
+        $return = 0;
+        if ($input->getOption('randReturn')) {
+            $return = rand(0, 5);
+        }
+
+        return $return;
+    }
+}