    001    package org.apache.turbine.services.schedule;
    002
    003    /*
    004     * Licensed to the Apache Software Foundation (ASF) under one
    005     * or more contributor license agreements.  See the NOTICE file
    006     * distributed with this work for additional information
    007     * regarding copyright ownership.  The ASF licenses this file
    008     * to you under the Apache License, Version 2.0 (the
    009     * "License"); you may not use this file except in compliance
    010     * with the License.  You may obtain a copy of the License at
    011     *
    012     *   http://www.apache.org/licenses/LICENSE-2.0
    013     *
    014     * Unless required by applicable law or agreed to in writing,
    015     * software distributed under the License is distributed on an
    016     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    017     * KIND, either express or implied.  See the License for the
    018     * specific language governing permissions and limitations
    019     * under the License.
    020     */
    021
    022    import java.util.Collections;
    023    import java.util.Comparator;
    024    import java.util.List;
    025    import java.util.Vector;
    026
    027    import org.apache.turbine.util.TurbineException;
    028
    029    /**
    030     * Queue for the scheduler.
    031     *
    032     * @author <a href="mailto:mbryson@mont.mindspring.com">Dave Bryson</a>
    033     * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
    034     * @version $Id: JobQueue.java 615328 2008-01-25 20:25:05Z tv $
    035     */
    036    public class JobQueue
    037    {
    038        /**
    039         * The queue of <code>JobEntry</code> objects.
    040         */
    041        private Vector<JobEntry> queue = null;
    042
    043        /**
    044         * Creates a new instance.
    045         */
    046        public JobQueue()
    047        {
    048            queue = new Vector<JobEntry>(10);
    049        }
    050
    051        /**
    052         * Return the next job off the top of the queue, or <code>null</code> if
    053         * there are no jobs in the queue.
    054         *
    055         * @return The next job in the queue.
    056         */
    057        public JobEntry getNext()
    058        {
    059            if (queue.size() > 0)
    060            {
    061                return queue.elementAt(0);
    062            }
    063            else
    064            {
    065                return null;
    066            }
    067        }
    068
    069        /**
    070         * Return a specific job.
    071         *
    072         * @param je The JobEntry we are looking for.
    073         * @return A JobEntry.
    074         */
    075        public JobEntry getJob(JobEntry je)
    076        {
    077            int index = -1;
    078
    079            if (je != null)
    080            {
    081                index = queue.indexOf(je);
    082            }
    083
    084            if (index < 0)
    085            {
    086                return null;
    087            }
    088            else
    089            {
    090                return queue.elementAt(index);
    091            }
    092        }
    093
    094        /**
    095         * List jobs in the queue.  This is used by the scheduler UI.
    096         *
    097         * @return A Vector of <code>JobEntry</code> objects.
    098         */
    099        @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    }