application/hub/main/handler/tasks/class_TaskHandler.php

   1 <?php
   2 /**
   3  * A Task handler
   4  *
   5  * @author              Roland Haeder <webmaster@ship-simu.org>
   6  * @version             0.0.0
   7  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 Hub Developer Team
   8  * @license             GNU GPL 3.0 or any newer version
   9  * @link                http://www.ship-simu.org
  10  *
  11  * This program is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 3 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24 class TaskHandler extends BaseHandler implements Registerable, HandleableTask {
  25         // Exception constants
  26         const EXCEPTION_TASK_IS_INVALID = 0xb00;
  27
  28         /**
  29          * A task list instance
  30          */
  31         private $listInstance = null;
  32
  33         /**
  34          * Instance for iterator
  35          */
  36         private $iteratorInstance = null;
  37
  38         /**
  39          * Visitor instance for all tasks while they are active
  40          */
  41         private $visitorInstance = null;
  42
  43         /**
  44          * Protected constructor
  45          *
  46          * @return      void
  47          */
  48         protected function __construct () {
  49                 // Call parent constructor
  50                 parent::__construct(__CLASS__);
  51
  52                 // Init the task list
  53                 $this->listInstance = ObjectFactory::createObjectByConfiguredName('task_list_class');
  54
  55                 // Get default instance
  56                 $this->iteratorInstance = $this->listInstance->getIterator();
  57
  58                 // Init visitor instance for faster loop
  59                 $this->visitorInstance = ObjectFactory::createObjectByConfiguredName('active_task_visitor_class');
  60         }
  61
  62         /**
  63          * Creates an instance of this class
  64          *
  65          * @return      $handlerInstance        An instance of a HandleableTask class
  66          */
  67         public final static function createTaskHandler () {
  68                 // Get new instance
  69                 $handlerInstance = new TaskHandler();
  70
  71                 // Output debug message
  72                 $handlerInstance->debugOutput('TASK-HANDLER: Task handler initialized.');
  73
  74                 // Return the prepared instance
  75                 return $handlerInstance;
  76         }
  77
  78         /**
  79          * Tries to execute the given task. If as task should not be started (yet)
  80          * or the interval time (see task_interval_delay) is not yet reached the
  81          * task is quietly skipped.
  82          *
  83          * @return      void
  84          * @throws      InvalidTaskException    If the current task is invalid
  85          */
  86         private function executeCurrentTask () {
  87                 // Update no task by default
  88                 $updateTask = false;
  89
  90                 // Is the current task valid?
  91                 if (!$this->iteratorInstance->valid()) {
  92                         // Not valid!
  93                         throw new InvalidTaskException($this, self::EXCEPTION_TASK_IS_INVALID);
  94                 } // END - if
  95
  96                 // Get current task
  97                 $currentTask = $this->iteratorInstance->current();
  98
  99                 // Is the task not yet started?
 100                 if ($currentTask['task_started'] === false) {
 101                         // Determine difference between current time and registration
 102                         $diff = ($this->getMilliTime() - $currentTask['task_registered']) * 1000;
 103
 104                         // Should we start now?
 105                         if ($diff < $currentTask['task_startup_delay']) {
 106                                 // Skip this silently
 107                                 return false;
 108                         } // END - if
 109
 110                         // Launch the task and mark it as updated
 111                         $currentTask['task_started'] = true;
 112                         $updateTask = true;
 113
 114                         // Debug message
 115                         $this->debugOutput('TASK-HANDLER: Task ' . $currentTask['id'] . ' started with startup_delay=' . $currentTask['task_startup_delay']);
 116                 } // END - if
 117
 118                 // Get time difference from interval delay
 119                 $diff = ($this->getMilliTime() - $currentTask['task_last_activity']) * 1000;
 120
 121                 // Is the interval delay reached?
 122                 if ($diff < $currentTask['task_interval_delay']) {
 123                         // Should we update the task from startup?
 124                         if ($updateTask === true) {
 125                                 // Update the task before leaving
 126                                 $this->updateTask($currentTask);
 127                         } // END - if
 128
 129                         // Skip this silently
 130                         return false;
 131                 } // END - if
 132
 133                 // Set last activity
 134                 $currentTask['task_last_activity'] = $this->getMilliTime();
 135
 136                 // Update the task
 137                 $this->updateTask($currentTask);
 138
 139                 // And visit/run it
 140                 // @TODO Messurement can be added around this call
 141                 $currentTask['task_instance']->accept($this->visitorInstance);
 142         }
 143
 144         /**
 145          * Updates given task by updating the underlaying list
 146          *
 147          * @param       $taskEntry      An array with a task
 148          * @return      void
 149          */
 150         private function updateTask (array $taskEntry) {
 151                 // Get the key from current iteration
 152                 $key = $this->iteratorInstance->key();
 153
 154                 // Get the hash from key
 155                 $hash = $this->listInstance->getHash($key);
 156
 157                 // Update the entry
 158                 $this->listInstance->updateCurrentEntryByHash($hash, $taskEntry);
 159         }
 160
 161         /**
 162          * Registers a task with a task handler.
 163          *
 164          * @param       $taskName               A task name to register the task on
 165          * @param       $taskInstance   The instance we should register as a task
 166          * @return      void
 167          */
 168         public function registerTask ($taskName, Visitable $taskInstance) {
 169                 // Create the entry
 170                 $taskEntry = array(
 171                         // Identifier for the generateHash() method
 172                         'id'                  => $taskName,
 173                         // Wether the task is started
 174                         'task_started'        => false,
 175                         // Wether the task is paused (not yet implemented)
 176                         'task_paused'         => false,
 177                         // Wether the task can be paused (not yet implemented)
 178                         'task_pauseable'      => true,
 179                         // Timestamp of registration
 180                         'task_registered'     => $this->getMilliTime(),
 181                         // Last activity timestamp
 182                         'task_last_activity'  => 0,
 183                         // Task instance itself
 184                         'task_instance'       => $taskInstance,
 185                         // Startup delay in milliseconds
 186                         'task_startup_delay'  => $this->getConfigInstance()->getConfigEntry('task_' . $taskName . '_startup_delay'),
 187                         // Interval time (delay) in milliseconds before this task is executed again
 188                         'task_interval_delay' => $this->getConfigInstance()->getConfigEntry('task_' . $taskName . '_interval_delay'),
 189                 );
 190
 191                 // Add the entry
 192                 $this->listInstance->addEntry('tasks', $taskEntry);
 193
 194                 // Debug message
 195                 $this->debugOutput('TASK-HANDLER: Task ' . $taskName .
 196                         ' (taskInstance=' . $taskInstance->__toString() . ')' .
 197                         ', startupDelay=' . $taskEntry['task_startup_delay'] . 'ms' .
 198                         ', intervalDelay=' . $taskEntry['task_interval_delay'] . 'ms registered.'
 199                 );
 200         }
 201
 202         /**
 203          * Checks wether tasks are left including idle task
 204          *
 205          * @return      $tasksLeft      Wether there are tasks left to handle
 206          */
 207         public function hasTasksLeft () {
 208                 // Do we have tasks there?
 209                 $tasksLeft = (($this->listInstance instanceof Listable) && ($this->listInstance->count() > 0));
 210
 211                 // Return result
 212                 return $tasksLeft;
 213         }
 214
 215         /**
 216          * Handles all tasks by checking if they should startup or if it is their
 217          * turn to run. You should use this method in a while() loop in conjuntion
 218          * with hasTasksLeft() so you can e.g. shutdown by adding a ShutdownTask
 219          * which will attempt to remove all tasks from the task handler.
 220          *
 221          * @return      void
 222          */
 223         public function handleTasks () {
 224                 // Should we rewind?
 225                 if (!$this->iteratorInstance->valid()) {
 226                         // Rewind to the beginning for next loop
 227                         $this->iteratorInstance->rewind();
 228                 } // END - if
 229
 230                 // Try to execute the task
 231                 $this->executeCurrentTask();
 232
 233                 // Go to next entry
 234                 $this->iteratorInstance->next();
 235         }
 236 }
 237
 238 // [EOF]
 239 ?>