/*
* 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 com.google.gwt.junit.remote.BrowserManagerProcess.ProcessExitCb;
import java.io.IOException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.Timer;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Manages instances of a web browser as child processes. This class is
* experimental and unsupported. An instance of this class can create browser
* windows using one specific shell-level command. It performs process
* management (baby sitting) on behalf of a remote client. This can be useful
* for running a GWTTestCase on a browser that cannot be run on the native
* platform. For example, a GWTTestCase test running on Linux could use a remote
* call to a Windows machine to test with Internet Explorer.
*
* <p>
* Calling {@link #main(String[])} can instantiate and register multiple
* instances of this class at given RMI namespace locations.
* </p>
*
* <p>
* This system has been tested on Internet Explorer 6 & 7. Firefox does not work
* in the general case; if an existing Firefox process is already running, new
* processes simply delegate to the existing process and terminate, which breaks
* the model. A shell script that sets MOZNOREMOTE=1 and cleans up
* locks/sessions is needed. Safari on MacOS requires very special treatment
* given Safari's poor command line support, but that is beyond the scope of
* this documentation.
* </p>
*
* <p>
* TODO(scottb): We technically need a watchdog thread to slurp up stdout and
* stderr from the child processes, or they might block. However, most browsers
* never write to stdout and stderr, so this is low priority. (There is now a
* thread that is spawned for each task to wait for an exit value - this might
* be adapted for that purpose one day.)
* </p>
*
* <p>
* This class is not actually serializable as-is, because timer is not
* serializable.
* </p>
*
* see http://bugs.sun.com/bugdatabase/view_bug.do;:YfiG?bug_id=4062587
*/
public class BrowserManagerServer extends UnicastRemoteObject implements
BrowserManager {
/**
* Implementation notes: <code>processByToken</code> must be locked before
* performing any state-changing operations.
*/
/**
* Entry in the launchCommandQueue to use when tasks are serialized.
*/
private static class LaunchCommand {
long keepAliveMsecs;
int token;
String url;
LaunchCommand(int tokenIn) {
this(tokenIn, null, 0);
}
LaunchCommand(int tokenIn, String urlIn, long keepAliveMsecsIn) {
token = tokenIn;
url = urlIn;
keepAliveMsecs = keepAliveMsecsIn;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof LaunchCommand && ((LaunchCommand) obj).token == token) {
return true;
}
return false;
}
@Override
public int hashCode() {
return token;
}
}
private static final Logger logger = Logger.getLogger(BrowserManagerServer.class.getName());
/**
* Starts up and registers one or more browser servers. Command-line entry
* point.
*/
public static void main(String[] args) throws Exception {
// Startup logic has been delegated to BrowserManagerServerLauncher
// class to facilitate use of the ToolBase class for
// argument handling.
BrowserManagerServerLauncher serverMain = new BrowserManagerServerLauncher();
if (serverMain.doProcessArgs(args)) {
serverMain.run();
}
}
/**
* Receives an event when a child process exits.
*/
private final ProcessExitCb childExitCallback = new ProcessExitCb() {
/**
* Called back from BrowserManagerProcess in a DIFFERENT THREAD than the
* main thread.
*
* @param token token value of browser that exited.
* @param exitValue exit status of the browser.
*/
public void childExited(int token, int exitValue) {
synchronized (processByToken) {
processByToken.remove(token);
// Start up any commands that were delayed.
launchDelayedCommand();
}
}
};
/**
* The shell command to launch when a new browser is requested.
*/
private final String launchCmd;
/**
* A queue of delayed commands. This is used if the serialized option is
* turned on.
*/
private Queue<LaunchCommand> launchCommandQueue = new LinkedList<LaunchCommand>();
/**
* The next token that will be returned from
* {@link #launchNewBrowser(String, long)}.
*/
private int nextToken = 1;
/**
* Master map of tokens onto ProcessManagers managing live processes. Also
* serves as a lock that must be held before any state-changing operations on
* this class may be performed.
*/
private final Map<Integer, BrowserManagerProcess> processByToken = new HashMap<Integer, BrowserManagerProcess>();
/**
* Flag that is set if the serialized option is turned on.
*/
private final boolean serializeFlag;
/**
* A single shared Timer used by all instances of
* {@link BrowserManagerProcess}.
*/
private final Timer timer = new Timer();
/**
* Constructs a manager for a particular shell command. The specified launch
* command should be a path to a browser's executable, suitable for passing to
* {@link Runtime#exec(java.lang.String)}. It may also include newline
* delimited arguments to pass to that executable. The invoked process must
* accept a URL as the final command line argument.
*
* @param launchCmd a command to launch a browser executable
* @param serializeFlag if <code>true</code>, serialize instance of browser
* processes to only run one at a time
*/
BrowserManagerServer(String launchCmd, boolean serializeFlag)
throws RemoteException {
// TODO: It would be nice to test to see if this file exists, but
// currently this mechanism allows you to pass in command line arguments
// and it will be a pain to accommodate this.
this.launchCmd = launchCmd;
this.serializeFlag = serializeFlag;
}
/**
* @see BrowserManager#keepAlive(int, long)
*/
public void keepAlive(int token, long keepAliveMs) {
if (keepAliveMs <= 0) {
throw new IllegalArgumentException();
}
synchronized (processByToken) {
// Is the token one we've issued?
if (token < 0 || token >= nextToken) {
throw new IllegalArgumentException();
}
BrowserManagerProcess process = processByToken.get(token);
if (process != null) {
if (process.keepAlive(keepAliveMs)) {
// The process was successfully kept alive.
return;
}
} else if (launchCommandQueue.contains(new LaunchCommand(token))) {
// Nothing to do, the command hasn't started yet.
return;
}
// The process is already dead. Fall through to failure.
}
throw new IllegalStateException("Process " + token + " already dead");
}
/**
* @see BrowserManager#killBrowser(int)
*/
public void killBrowser(int token) {
synchronized (processByToken) {
// Is the token one we've issued?
if (token < 0 || token >= nextToken) {
throw new IllegalArgumentException();
}
BrowserManagerProcess process = processByToken.get(token);
if (process != null) {
logger.info("Client kill for active browser: " + token);
process.killBrowser();
} else if (launchCommandQueue.contains(new LaunchCommand(token))) {
launchCommandQueue.remove(new LaunchCommand(token));
logger.info("Client kill for waiting browser: " + token);
} else {
logger.info("Client kill for inactive browser: " + token);
}
}
}
/**
* @see BrowserManager#launchNewBrowser(java.lang.String, long)
*/
public int launchNewBrowser(String url, long keepAliveMs) {
logger.info("Launching browser for url: " + url + " keepAliveMs: "
+ keepAliveMs);
if (url == null || keepAliveMs <= 0) {
throw new IllegalArgumentException();
}
try {
synchronized (processByToken) {
int myToken = nextToken++;
// Adds self to processByToken.
if (serializeFlag && !processByToken.isEmpty()) {
// Queue up a launch request if one is already running.
launchCommandQueue.add(new LaunchCommand(myToken, url, keepAliveMs));
logger.info("Queuing up request token: " + myToken + " for url: "
+ url + ". Another launch command is active.");
} else {
execChild(myToken, url, keepAliveMs);
}
return myToken;
}
} catch (IOException e) {
logger.log(Level.SEVERE, "Error launching browser '" + launchCmd
+ "' for '" + url + "'", e);
throw new RuntimeException("Error launching browser '" + launchCmd
+ "' for '" + url + "'", e);
}
}
/**
* This method is mainly in place for writing assertions in the unit test.
*
* @return number of tasks waiting to run if serialized option is enabled
*/
int numQueued() {
synchronized (processByToken) {
return launchCommandQueue.size();
}
}
/**
* This method is mainly in place for writing assertions in the unit test.
*
* @return number of launch commands running that have not yet exited.
*/
int numRunning() {
synchronized (processByToken) {
return processByToken.size();
}
}
/**
* Actually create a process and run a browser.
*
* (Assumes that code is already synchronized by processBytoken)
*
* @param token token value of browser that exited.
* @param url command line arguments to pass to the browser
* @param keepAliveMs inital keep alive interval in milliseconds
*/
private void execChild(int token, String url, long keepAliveMs)
throws IOException {
// Tokenize the launchCmd by carriage returns (used for unit testing).
StringTokenizer st = new StringTokenizer(launchCmd, "\n");
int userTokens = st.countTokens();
String[] cmdarray = new String[userTokens + 1];
for (int i = 0; st.hasMoreTokens(); i++) {
cmdarray[i] = st.nextToken();
}
// Append the user-specified URL.
cmdarray[userTokens] = url;
// Start the task.
Process child = Runtime.getRuntime().exec(cmdarray);
BrowserManagerProcess bmp = new BrowserManagerProcess(childExitCallback,
timer, token, child, keepAliveMs);
processByToken.put(token, bmp);
}
/**
* If serialization is enabled on the server, kicks off the next queued
* command on the delayed command queue.
*
* (Assumes that code is already synchronized by processBytoken)
*/
private void launchDelayedCommand() {
if (!serializeFlag || !processByToken.isEmpty()) {
// No need to launch if serialization is off or
// something is already running
return;
}
// Loop through the commands until we can launch one
// successfully.
while (!launchCommandQueue.isEmpty()) {
LaunchCommand lc = launchCommandQueue.remove();
try {
execChild(lc.token, lc.url, lc.keepAliveMsecs);
// No exception? Great!
logger.info("Started delayed browser: " + lc.token);
return;
} catch (IOException e) {
logger.log(Level.SEVERE, "Error launching browser '" + launchCmd
+ "' for '" + lc.url + "'", e);
throw new RuntimeException("Error launching browser '" + launchCmd
+ "' for '" + lc.url + "'", e);
}
// If an exception occurred, keep pulling cmds off the queue.
}
}
}
|