package org.apache.turbine.services.schedule;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.util.Iterator;
  import java.util.List;
  
  import javax.servlet.ServletConfig;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.apache.torque.TorqueException;
  import org.apache.torque.util.Criteria;
  
  import org.apache.turbine.services.InitializationException;
  import org.apache.turbine.services.TurbineBaseService;
  import org.apache.turbine.util.TurbineException;
  
  /***
   * Service for a cron like scheduler.
   *
   * @author <a href="mailto:mbryson@mont.mindspring.com">Dave Bryson</a>
   * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
   * @version $Id: TurbineSchedulerService.java 534527 2007-05-02 16:10:59Z tv $
   */
  public class TurbineSchedulerService
          extends TurbineBaseService
          implements ScheduleService
  {
      /*** Logging */
      private static Log log = LogFactory.getLog(ScheduleService.LOGGER_NAME);
  
      /*** The queue */
      protected JobQueue scheduleQueue = null;
  
      /*** Current status of the scheduler */
      private boolean enabled = false;
  
      /*** The main loop for starting jobs. */
      protected MainLoop mainLoop;
  
      /*** The thread used to process commands.  */
      protected Thread thread;
  
      /***
       * Creates a new instance.
       */
      public TurbineSchedulerService()
      {
          mainLoop = null;
          thread = null;
      }
  
      /***
       * Initializes the SchedulerService.
       *
       * @throws InitializationException Something went wrong in the init
       *         stage
       */
      public void init()
              throws InitializationException
      {
          try
          {
              setEnabled(getConfiguration().getBoolean("enabled", true));
              scheduleQueue = new JobQueue();
              mainLoop = new MainLoop();
  
              // Load all from cold storage.
              List jobs = JobEntryPeer.doSelect(new Criteria());
  
              if (jobs != null && jobs.size() > 0)
              {
                  Iterator it = jobs.iterator();
                  while (it.hasNext())
                  {
                      ((JobEntry) it.next()).calcRunTime();
                  }
                  scheduleQueue.batchLoad(jobs);
  
                  restart();
             }
 
             setInit(true);
         }
         catch (Exception e)
         {
             String errorMessage = "Could not initialize the scheduler service";
             log.error(errorMessage, e);
             throw new InitializationException(errorMessage, e);
         }
     }
 
     /***
      * Called the first time the Service is used.<br>
      *
      * Load all the jobs from cold storage.  Add jobs to the queue
      * (sorted in ascending order by runtime) and start the scheduler
      * thread.
      *
      * @param config A ServletConfig.
      * @deprecated use init() instead.
      */
     public void init(ServletConfig config) throws InitializationException
     {
         init();
     }
 
     /***
      * Shutdowns the service.
      *
      * This methods interrupts the housekeeping thread.
      */
     public void shutdown()
     {
         if (getThread() != null)
         {
             getThread().interrupt();
         }
     }
 
     /***
      * Get a specific Job from Storage.
      *
      * @param oid The int id for the job.
      * @return A JobEntry.
      * @exception TurbineException job could not be retreived.
      */
     public JobEntry getJob(int oid)
             throws TurbineException
     {
         try
         {
             JobEntry je = JobEntryPeer.retrieveByPK(oid);
             return scheduleQueue.getJob(je);
         }
         catch (TorqueException e)
         {
             String errorMessage = "Error retrieving job from persistent storage.";
             log.error(errorMessage, e);
             throw new TurbineException(errorMessage, e);
         }
     }
 
     /***
      * Add a new job to the queue.
      *
      * @param je A JobEntry with the job to add.
      * @throws TurbineException job could not be added
      */
     public void addJob(JobEntry je)
             throws TurbineException
     {
         updateJob(je);
     }
 
     /***
      * Remove a job from the queue.
      *
      * @param je A JobEntry with the job to remove.
      * @exception TurbineException job could not be removed
      */
     public void removeJob(JobEntry je)
             throws TurbineException
     {
         try
         {
             // First remove from DB.
             Criteria c = new Criteria().add(JobEntryPeer.JOB_ID, je.getPrimaryKey());
             JobEntryPeer.doDelete(c);
 
             // Remove from the queue.
             scheduleQueue.remove(je);
 
             // restart the scheduler
             restart();
         }
         catch (Exception e)
         {
             String errorMessage = "Problem removing Scheduled Job: " + je.getTask();
             log.error(errorMessage, e);
             throw new TurbineException(errorMessage, e);
         }
     }
 
     /***
      * Add or update a job.
      *
      * @param je A JobEntry with the job to modify
      * @throws TurbineException job could not be updated
      */
     public void updateJob(JobEntry je)
             throws TurbineException
     {
         try
         {
             je.calcRunTime();
 
             // Update the queue.
             if (je.isNew())
             {
                 scheduleQueue.add(je);
             }
             else
             {
                 scheduleQueue.modify(je);
             }
 
             je.save();
 
             restart();
         }
         catch (Exception e)
         {
             String errorMessage = "Problem updating Scheduled Job: " + je.getTask();
             log.error(errorMessage, e);
             throw new TurbineException(errorMessage, e);
         }
     }
 
     /***
      * List jobs in the queue.  This is used by the scheduler UI.
      *
      * @return A List of jobs.
      */
     public List listJobs()
     {
         return scheduleQueue.list();
     }
 
     /***
      * Sets the enabled status of the scheduler
      *
      * @param enabled
      *
      */
     protected void setEnabled(boolean enabled)
     {
         this.enabled = enabled;
     }
 
     /***
      * Determines if the scheduler service is currently enabled.
      *
      * @return Status of the scheduler service.
      */
     public boolean isEnabled()
     {
         return enabled;
     }
 
     /***
      * Starts or restarts the scheduler if not already running.
      */
     public synchronized void startScheduler()
     {
         setEnabled(true);
         restart();
     }
 
     /***
      * Stops the scheduler if it is currently running.
      */
     public synchronized void stopScheduler()
     {
         log.info("Stopping job scheduler");
         Thread thread = getThread();
         if (thread != null)
         {
             thread.interrupt();
         }
         enabled = false;
     }
 
     /***
      * Return the thread being used to process commands, or null if
      * there is no such thread.  You can use this to invoke any
      * special methods on the thread, for example, to interrupt it.
      *
      * @return A Thread.
      */
     public synchronized Thread getThread()
     {
         return thread;
     }
 
     /***
      * Set thread to null to indicate termination.
      */
     private synchronized void clearThread()
     {
         thread = null;
     }
 
     /***
      * Start (or restart) a thread to process commands, or wake up an
      * existing thread if one is already running.  This method can be
      * invoked if the background thread crashed due to an
      * unrecoverable exception in an executed command.
      */
     public synchronized void restart()
     {
         if (enabled)
         {
             log.info("Starting job scheduler");
             if (thread == null)
             {
                 // Create the the housekeeping thread of the scheduler. It will wait
                 // for the time when the next task needs to be started, and then
                 // launch a worker thread to execute the task.
                 thread = new Thread(mainLoop, ScheduleService.SERVICE_NAME);
                 // Indicate that this is a system thread. JVM will quit only when there
                 // are no more enabled user threads. Settings threads spawned internally
                 // by Turbine as daemons allows commandline applications using Turbine
                 // to terminate in an orderly manner.
                 thread.setDaemon(true);
                 thread.start();
             }
             else
             {
                 notify();
             }
         }
     }
 
     /***
      *  Return the next Job to execute, or null if thread is
      *  interrupted.
      *
      * @return A JobEntry.
      * @exception TurbineException a generic exception.
      */
     private synchronized JobEntry nextJob()
             throws TurbineException
     {
         try
         {
             while (!Thread.interrupted())
             {
                 // Grab the next job off the queue.
                 JobEntry je = scheduleQueue.getNext();
 
                 if (je == null)
                 {
                     // Queue must be empty. Wait on it.
                     wait();
                 }
                 else
                 {
                     long now = System.currentTimeMillis();
                     long when = je.getNextRuntime();
 
                     if (when > now)
                     {
                         // Wait till next runtime.
                         wait(when - now);
                     }
                     else
                     {
                         // Update the next runtime for the job.
                         scheduleQueue.updateQueue(je);
                         // Return the job to run it.
                         return je;
                     }
                 }
             }
         }
         catch (InterruptedException ex)
         {
         }
 
         // On interrupt.
         return null;
     }
 
     /***
      * Inner class.  This is isolated in its own Runnable class just
      * so that the main class need not implement Runnable, which would
      * allow others to directly invoke run, which is not supported.
      */
     protected class MainLoop
             implements Runnable
     {
         /***
          * Method to run the class.
          */
         public void run()
         {
             String taskName = null;
             try
             {
                 while (enabled)
                 {
                     JobEntry je = nextJob();
                     if (je != null)
                     {
                         taskName = je.getTask();
 
                         // Start the thread to run the job.
                         Runnable wt = new WorkerThread(je);
                         Thread helper = new Thread(wt);
                         helper.start();
                     }
                     else
                     {
                         break;
                     }
                 }
             }
             catch (Exception e)
             {
                 log.error("Error running a Scheduled Job: " + taskName, e);
                 enabled = false;
             }
             finally
             {
                 clearThread();
             }
         }
     }
 }