View Javadoc

    1   package org.apache.turbine.services.schedule;
    2
    3   /*
    4    * Licensed to the Apache Software Foundation (ASF) under one
    5    * or more contributor license agreements.  See the NOTICE file
    6    * distributed with this work for additional information
    7    * regarding copyright ownership.  The ASF licenses this file
    8    * to you under the Apache License, Version 2.0 (the
    9    * "License"); you may not use this file except in compliance
    10   * with the License.  You may obtain a copy of the License at
    11   *
    12   *   http://www.apache.org/licenses/LICENSE-2.0
    13   *
    14   * Unless required by applicable law or agreed to in writing,
    15   * software distributed under the License is distributed on an
    16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    17   * KIND, either express or implied.  See the License for the
    18   * specific language governing permissions and limitations
    19   * under the License.
    20   */
    21
    22  import java.util.Collections;
    23  import java.util.Comparator;
    24  import java.util.List;
    25  import java.util.Vector;
    26
    27  import org.apache.turbine.util.TurbineException;
    28
    29  /**
    30   * Queue for the scheduler.
    31   *
    32   * @author <a href="mailto:mbryson@mont.mindspring.com">Dave Bryson</a>
    33   * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
    34   * @version $Id: JobQueue.java 615328 2008-01-25 20:25:05Z tv $
    35   */
    36  public class JobQueue
    37  {
    38      /**
    39       * The queue of <code>JobEntry</code> objects.
    40       */
    41      private Vector<JobEntry> queue = null;
    42
    43      /**
    44       * Creates a new instance.
    45       */
    46      public JobQueue()
    47      {
    48          queue = new Vector<JobEntry>(10);
    49      }
    50
    51      /**
    52       * Return the next job off the top of the queue, or <code>null</code> if
    53       * there are no jobs in the queue.
    54       *
    55       * @return The next job in the queue.
    56       */
    57      public JobEntry getNext()
    58      {
    59          if (queue.size() > 0)
    60          {
    61              return queue.elementAt(0);
    62          }
    63          else
    64          {
    65              return null;
    66          }
    67      }
    68
    69      /**
    70       * Return a specific job.
    71       *
    72       * @param je The JobEntry we are looking for.
    73       * @return A JobEntry.
    74       */
    75      public JobEntry getJob(JobEntry je)
    76      {
    77          int index = -1;
    78
    79          if (je != null)
    80          {
    81              index = queue.indexOf(je);
    82          }
    83
    84          if (index < 0)
    85          {
    86              return null;
    87          }
    88          else
    89          {
    90              return queue.elementAt(index);
    91          }
    92      }
    93
    94      /**
    95       * List jobs in the queue.  This is used by the scheduler UI.
    96       *
    97       * @return A Vector of <code>JobEntry</code> objects.
    98       */
    99      @SuppressWarnings("unchecked")
    100     public Vector<JobEntry> list()
    101     {
    102         if (queue != null && queue.size() > 0)
    103         {
    104             return (Vector<JobEntry>) queue.clone();
    105         }
    106         else
    107         {
    108             return null;
    109         }
    110     }
    111
    112     /**
    113      * Add a job to the queue.
    114      *
    115      * @param je A JobEntry job.
    116      */
    117     public synchronized void add(JobEntry je)
    118     {
    119         queue.addElement(je);
    120         sortQueue();
    121     }
    122
    123     /**
    124      * Batch load jobs.  Retains any already enqueued jobs.  Called on
    125      * <code>SchedulerService</code> start-up.
    126      *
    127      * @param jobEntries A list of the <code>JobEntry</code> objects to load.
    128      */
    129     public synchronized void batchLoad(List<JobEntry> jobEntries)
    130     {
    131         if (jobEntries != null)
    132         {
    133             queue.addAll(jobEntries);
    134             sortQueue();
    135         }
    136
    137     }
    138
    139     /**
    140      * Remove a job from the queue.
    141      *
    142      * @param je A JobEntry with the job to remove.
    143      */
    144     public synchronized void remove(JobEntry je)
    145     {
    146         queue.removeElement(je);
    147         sortQueue();
    148     }
    149
    150     /**
    151      * Modify a job on the queue.
    152      *
    153      * @param je A JobEntry with the job to modify
    154      */
    155     public synchronized void modify(JobEntry je)
    156             throws TurbineException
    157     {
    158         remove(je);
    159         je.calcRunTime();
    160         this.add(je);
    161         sortQueue();
    162     }
    163
    164     /**
    165      * Update the job for its next run time.
    166      *
    167      * @param je A JobEntry to be updated.
    168      * @exception TurbineException a generic exception.
    169      */
    170     public synchronized void updateQueue(JobEntry je)
    171             throws TurbineException
    172     {
    173         je.calcRunTime();
    174         sortQueue();
    175     }
    176
    177     /**
    178      * Re-sort the existing queue.  Consumers of this method should be
    179      * <code>synchronized</code>.
    180      */
    181     private void sortQueue()
    182     {
    183         Comparator<JobEntry> aComparator = new Comparator<JobEntry>()
    184         {
    185             public int compare(JobEntry o1, JobEntry o2)
    186             {
    187                 Long time1 = new Long(o1.getNextRuntime());
    188                 Long time2 = new Long(o2.getNextRuntime());
    189                 return (time1.compareTo(time2));
    190             }
    191         };
    192
    193         Collections.sort(queue, aComparator);
    194     }
    195 }