/*
 * Copyright 2006 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.io.IOException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 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
 * managagement (babysitting) 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. 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. 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.
 * </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.
   */

  /**
   * Manages one web browser child process. This class contains a TimerTask
   * which tries to kill the managed process.
   * 
   * Invariants:
   * <ul>
   * <li> If process is alive, this manager is in <code>processByToken</code>.
   * </li>
   * <li> If process is dead, this manager <i>might</i> be in
   * <code>processByToken</code>. It will be observed to be dead next time
   * {@link #keepAlive(long)} or {@link #doKill()} are called. </li>
   * <li> Calling {@link #keepAlive(long)} and {@link #doKill()} require the
   * lock on <code>processByToken</code> to be held, so they cannot be called
   * at the same time. </li>
   * </ul>
   */
  private final class ProcessManager {

    /**
     * Kills the child process when fired, unless it is no longer the active
     * {@link ProcessManager#killTask} in its outer ProcessManager.
     */
    private final class KillTask extends TimerTask {
      /*
       * @see java.lang.Runnable#run()
       */
      public void run() {
        synchronized (processByToken) {
          /*
           * CORNER CASE: Verify we're still the active KillTask, because it's
           * possible we were bumped out by a keepAlive call after our execution
           * started but before we could grab the lock on processByToken.
           */
          if (killTask == this) {
            doKill();
          }
        }
      }
    }

    /**
     * The key associated with <code>process</code> in
     * <code>processByToken</code>.
     */
    private Object key;

    /**
     * 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;

    /**
     * Constructs a new ProcessManager for the specified process, and adds
     * itself to <code>processByToken</code> using the supplied key. You must
     * hold the lock on <code>processByToken</code> to call this method.
     * 
     * @param key the key to be used when adding the new object to
     *          <code>processByToken</code>
     * @param process the process being managed
     * @param initKeepAliveMs the initial time to wait before killing
     *          <code>process</code>
     */
    ProcessManager(Object key, Process process, long initKeepAliveMs) {
      this.process = process;
      this.key = key;
      schedule(initKeepAliveMs);
      processByToken.put(key, this);
    }

    /**
     * Kills the managed process. You must hold the lock on
     * <code>processByToken</code> to call this method.
     */
    public void doKill() {
      Object removed = processByToken.remove(key);
      assert (removed == this);
      process.destroy();
      schedule(0);
    }

    /**
     * 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. You must hold the lock on
     * <code>processByToken</code> to call this method.
     * 
     * @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 boolean keepAlive(long keepAliveMs) {
      try {
        /*
         * See if the managed process is still alive. WEIRD: The only way to
         * check the process's liveness appears to be asking for its exit status
         * and seeing whether it throws an IllegalThreadStateException.
         */
        process.exitValue();
      } catch (IllegalThreadStateException e) {
        // The process is still alive.
        schedule(keepAliveMs);
        return true;
      }

      // The process is dead already; perform cleanup.
      doKill();
      return false;
    }

    /**
     * Cancels any existing kill task and optionally schedules a new one to run
     * <code>keepAliveMs</code> from now. You must hold the lock on
     * <code>processByToken</code> to call this method.
     * 
     * @param keepAliveMs if > 0, schedules a new kill task to run in
     *          keepAliveMs milliseconds; if <= 0, a new kill task is not
     *          scheduled.
     */
    private void schedule(long keepAliveMs) {
      if (killTask != null) {
        killTask.cancel();
        killTask = null;
      }
      if (keepAliveMs > 0) {
        killTask = new KillTask();
        timer.schedule(killTask, keepAliveMs);
      }
    }
  }

  /**
   * Starts up and registers one or more browser servers. Command-line entry
   * point.
   */
  public static void main(String[] args) throws Exception {
    if (args.length == 0) {
      System.err.println(""
          + "Manages local browser windows for a remote client using RMI.\n"
          + "\n"
          + "Pass in an even number of args, at least 2. The first argument\n"
          + "is a short registration name, and the second argument is the\n"
          + "executable to run when that name is used; for example,\n" + "\n"
          + "\tie6 \"C:\\Program Files\\Internet Explorer\\IEXPLORE.EXE\"\n"
          + "\n"
          + "would register Internet Explorer to \"rmi://localhost/ie6\".\n"
          + "The third and fourth arguments make another pair, and so on.\n");
      System.exit(1);
    }

    if (args.length < 2) {
      throw new IllegalArgumentException("Need at least 2 arguments");
    }

    if (args.length % 2 != 0) {
      throw new IllegalArgumentException("Need an even number of arguments");
    }

    // Create an RMI registry so we don't need an external process.
    // Uses the default RMI port.
    // TODO(scottb): allow user to override the port via command line option.
    LocateRegistry.createRegistry(Registry.REGISTRY_PORT);
    System.out.println("RMI registry ready.");

    for (int i = 0; i < args.length; i += 2) {
      BrowserManagerServer bms = new BrowserManagerServer(args[i + 1]);
      Naming.rebind(args[i], bms);
      System.out.println(args[i] + " started and awaiting connections");
    }
  }

  /**
   * The shell command to launch when a new browser is requested.
   */
  private final String launchCmd;

  /**
   * 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 processByToken = new HashMap();

  /**
   * A single shared Timer used by all instances of
   * {@link ProcessManager.KillTask}.
   */
  private final Timer timer = new Timer();

  /**
   * Constructs a manager for a particular shell command.
   * 
   * @param launchCmd the path to a browser's executable, suitable for passing
   *          to {@link Runtime#exec(java.lang.String)}. The invoked process
   *          must accept a URL as a command line argument.
   */
  public BrowserManagerServer(String launchCmd) throws RemoteException {
    this.launchCmd = launchCmd;
  }

  /*
   * @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();
      }
      Integer intTok = new Integer(token);
      ProcessManager process = (ProcessManager) processByToken.get(intTok);
      if (process != null) {
        if (process.keepAlive(keepAliveMs)) {
          // The process was successfully kept alive.
          return;
        } else {
          // 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();
      }
      Integer intTok = new Integer(token);
      ProcessManager process = (ProcessManager) processByToken.get(intTok);
      if (process != null) {
        process.doKill();
      }
    }
  }

  /*
   * @see BrowserManager#launchNewBrowser(java.lang.String, long)
   */
  public int launchNewBrowser(String url, long keepAliveMs) {

    if (url == null || keepAliveMs <= 0) {
      throw new IllegalArgumentException();
    }

    try {
      Process child = Runtime.getRuntime().exec(new String[] {launchCmd, url});
      synchronized (processByToken) {
        int myToken = nextToken++;
        Integer intTok = new Integer(myToken);
        // Adds self to processByToken.
        new ProcessManager(intTok, child, keepAliveMs);
        return myToken;
      }
    } catch (IOException e) {
      throw new RuntimeException("Error launching browser '" + launchCmd
          + "' for '" + url + "'", e);
    }
  }
}