jasenautoupdatereaper.java

来自「spam source codejasen-0.9jASEN - java An」· Java 代码 · 共 172 行

/*
 * @(#)JasenAutoUpdateReaper.java	7/01/2005
 *
 * Copyright (c) 2005 jASEN.org
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *
 *   3. The names of the authors may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 *   4. Any modification or additions to the software must be contributed back
 *      to the project.
 *
 *   5. Any investigation or reverse engineering of source code or binary to
 *      enable emails to bypass the filters, and hence inflict spam and or viruses
 *      onto users who use or do not use jASEN could subject the perpetrator to
 *      criminal and or civil liability.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JASEN.ORG,
 * OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
package org.jasen.update;

import org.apache.log4j.Logger;
import org.jasen.thread.StoppableThread;

/**
 * <p>
 * The reaper monitors the auto updater thread and will kill it if it thinks it's stuck in an update cycle.
 * </p>
 * <p>
 * The auto updater may deadlock if it cannot receive data from the update site, or (more likely) the update
 * contains an executor (AutoUpdateExecutor) which has not exited
 * </p>
 * @see org.jasen.interfaces.AutoUpdateExecutor
 * @author Jason Polites
 */
public class JasenAutoUpdateReaper extends StoppableThread {

    static final Logger logger = Logger.getLogger(JasenAutoUpdateReaper.class);

    private JasenAutoUpdater updater;
    private JasenAutoUpdateManager manager;

    private boolean running;
    private long timeout = 120000L; // 2 minutes
    public static long killTimeout = 10000L; // 10 seconds


    /**
     *
     */
    public JasenAutoUpdateReaper(JasenAutoUpdater updater, JasenAutoUpdateManager manager) {
        super();
        this.updater = updater;
        this.manager = manager;
    }

    /**
     * @param name
     */
    public JasenAutoUpdateReaper(JasenAutoUpdater updater, JasenAutoUpdateManager manager, String name) {
        super(name);
        this.updater = updater;
        this.manager = manager;
    }

    public void run () {
        running = true;

        long currentTime;
        long lastTime = -1L;

        while(running) {


            synchronized (this) {

                currentTime = System.currentTimeMillis();

                if(!updater.isIdle()) {
                    // The updater is running, check the time...
                    if(lastTime < 0) {
                        // First non-idle report, just record the time
                        lastTime = currentTime;
                    }
                    else
                    {
                        // We have been idle before...
                        if(currentTime - lastTime >= timeout) {
                            // We have to kill the updater and restart it...
                            restartAutoUpdater();
                        }

                        lastTime = currentTime;
                    }
                }
                else
                {
                    // reset
                    lastTime = -1L;
                }

                if(running) {
                    try {
                        // Wait until notified or we loop again
                        wait(timeout);
                    }
                    catch (InterruptedException ignore) {}
                }
            }
        }
    }

    /**
     * Stops the reaper.
     */
    public synchronized void finish() {
        running = false;
        notifyAll();
    }

    /**
     * Force kills the updater and starts it again...
     */
    void restartAutoUpdater() {

        logger.warn("Reaper is restarting auto updater");

        // Request a finish
        updater.finish();

        try {
            updater.join(killTimeout);
        } catch (InterruptedException ignore) {}

        if(updater.isAlive()) {
            // Kill it!
            updater.interrupt();
        }

        // Make sure we notify any waiting scans
        if(manager.isUpdating()) {
            JasenAutoUpdateReport report = new JasenAutoUpdateReport();
            report.setUpdateAborted(true);
            manager.notifyUpdateComplete(report);
        }

        // And restart
        updater = new JasenAutoUpdater(manager, updater.getName());
        updater.start();
    }
}