| /* | |
| * Copyright 2008 Google Inc. | |
| * | |
| * Licensed 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. | |
| */ | |
| package com.google.gwt.junit.remote; | |
| import java.text.NumberFormat; | |
| import java.util.Timer; | |
| import java.util.TimerTask; | |
| import java.util.logging.Level; | |
| import java.util.logging.Logger; | |
| /** | |
| * Manages one web browser child process. This class contains a TimerTask which | |
| * tries to kill the managed process. A thread is created for each task to wait | |
| * for the process to exit and give a callback. | |
| * | |
| * Invariants: | |
| * <ul> | |
| * <li> Most of this code executes in a separate thread per process. Thus, the | |
| * API entry points lock <code>this</code></li> | |
| * <li> The lock on this is removed before calling the <code>childExited</code> | |
| * callback. This prevents potential deadlock. | |
| * </ul> | |
| */ | |
| class BrowserManagerProcess { | |
| /** | |
| * Used to notify the caller of the constructor when a process exits. Note | |
| * that the childExited() method is called from a different thread than the | |
| * one that created the process. | |
| */ | |
| public interface ProcessExitCb { | |
| void childExited(int key, int exitValue); | |
| } | |
| /** | |
| * Kills the child process when fired, unless it is no longer the active | |
| * {@link BrowserManagerProcess#killTask}. | |
| */ | |
| private final class KillTask extends TimerTask { | |
| @Override | |
| public void run() { | |
| synchronized (BrowserManagerProcess.this) { | |
| /* | |
| * Verify we're still the active KillTask! If we're not the active | |
| * killTask, it means we've been rescheduled and a newer kill timer is | |
| * active. | |
| */ | |
| if (killTask == this && !deadOrDying) { | |
| logger.info("Timeout expired for: " + token); | |
| process.destroy(); | |
| deadOrDying = true; | |
| } | |
| } | |
| } | |
| } | |
| private static final Logger logger = Logger.getLogger(BrowserManagerProcess.class.getName()); | |
| /** | |
| * Compute elapsed time. | |
| * | |
| * @param startTime the time the process started | |
| * @return returns a string representing the number of seconds elapsed since | |
| * the process started. | |
| */ | |
| private static String getElapsed(long intervalMs) { | |
| NumberFormat nf = NumberFormat.getNumberInstance(); | |
| nf.setMaximumFractionDigits(3); | |
| return nf.format(intervalMs / 1000.0); | |
| } | |
| /** | |
| * Set to 'true' when the process exits or starts being killed. | |
| */ | |
| private boolean deadOrDying = false; | |
| /** | |
| * If non-null, the active TimerTask which will kill <code>process</code> | |
| * when it fires. | |
| */ | |
| private KillTask killTask; | |
| /** | |
| * The managed child process. | |
| */ | |
| private final Process process; | |
| /** | |
| * Timer instance passed in from BrowserManagerServer. | |
| */ | |
| private final Timer timer; | |
| /** | |
| * The key associated with <code>process</code>. | |
| */ | |
| private final int token; | |
| /** | |
| * Constructs a new ProcessManager for the specified process. | |
| * | |
| * @param timer timer passed in from BrowserManagerServer instance. | |
| * @param token the key to be used to identify this process. | |
| * @param process the process being managed | |
| * @param initKeepAliveMs the initial time to wait before killing | |
| * <code>process</code> | |
| */ | |
| public BrowserManagerProcess(final ProcessExitCb cb, Timer timer, | |
| final int token, final Process process, long initKeepAliveMs) { | |
| this.process = process; | |
| this.timer = timer; | |
| this.token = token; | |
| final long startTime = System.currentTimeMillis(); | |
| Thread cleanupThread = new Thread() { | |
| @Override | |
| public void run() { | |
| while (true) { | |
| try { | |
| int exitValue = process.waitFor(); | |
| doCleanup(cb, exitValue, token, System.currentTimeMillis() | |
| - startTime); | |
| return; | |
| } catch (InterruptedException e) { | |
| logger.log(Level.WARNING, | |
| "Interrupted waiting for process exit of: " + token, e); | |
| } | |
| } | |
| } | |
| }; | |
| cleanupThread.setDaemon(true); | |
| cleanupThread.setName("Browser-" + token + "-Wait"); | |
| cleanupThread.start(); | |
| keepAlive(initKeepAliveMs); | |
| } | |
| /** | |
| * Keeps the underlying process alive for <code>keepAliveMs</code> starting | |
| * now. If the managed process is already dead, cleanup is performed and the | |
| * method return false. | |
| * | |
| * @param keepAliveMs the time to wait before killing the underlying process | |
| * @return <code>true</code> if the process was successfully kept alive, | |
| * <code>false</code> if the process is already dead. | |
| */ | |
| public synchronized boolean keepAlive(long keepAliveMs) { | |
| assert (keepAliveMs > 0); | |
| if (!deadOrDying) { | |
| killTask = new KillTask(); | |
| timer.schedule(killTask, keepAliveMs); | |
| return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * Kills the underlying browser process. | |
| */ | |
| public synchronized void killBrowser() { | |
| if (!deadOrDying) { | |
| process.destroy(); | |
| deadOrDying = true; | |
| } | |
| } | |
| /** | |
| * Cleans up when the underlying process terminates. The lock must not be held | |
| * when calling this method or deadlock could result. | |
| * | |
| * @param cb the callback to fire | |
| * @param exitValue the exit value of the process | |
| * @param token the id of this browser instance | |
| * @param startTime the time the process started | |
| */ | |
| private void doCleanup(ProcessExitCb cb, int exitValue, int token, | |
| long intervalMs) { | |
| synchronized (this) { | |
| deadOrDying = true; | |
| } | |
| if (exitValue != 0) { | |
| logger.warning("Browser: " + token + " exited with bad status: " | |
| + exitValue); | |
| } else { | |
| logger.info("Browser: " + token + " process exited normally after " | |
| + getElapsed(intervalMs) + "s"); | |
| } | |
| cb.childExited(token, exitValue); | |
| } | |
| } |