JProcessManager.java

package javaforce;

import java.net.*;
import java.awt.Window;
import java.util.*;
import java.security.Permission;

/**
 * JProcessManager is used to manage multiple processes within one JVM.<br> You
 * can create new processes and kill running processes.<br>
 *
 * @see JProcess
 */
public class JProcessManager {

  private ArrayList<JProcess> list;
  private int nextpid = 1;
  private JSecurityManager sm;
  private SecurityManager orgsm;
  private ThreadGroup rootThreadGroup;
  private Object lock;
  private Thread mainThread;

  public JProcessManager() {
    list = new ArrayList<JProcess>();
    orgsm = System.getSecurityManager();
    sm = new JSecurityManager();
    System.setSecurityManager(sm);
    rootThreadGroup = new ThreadGroup("JProcessManager");
    lock = new Object();
  }

  /**
   * Create a new instance of JProcess.<br>
   *
   * @param className the name of the class that contains the main(String [])
   * method.
   * @param args a list of arguments to pass to main(String []).
   * @param paths a list of URLs for the classpath. ie:
   * "file:///c:/path/file.jar".
   * @return JProcess an unstarted process.
   */
  public JProcess createJProcess(String className, String[] args, URL[] paths, String user_dir) {
    JProcess process;
    synchronized (lock) {
      process = JProcess.createInstance(className, args, paths, rootThreadGroup, nextpid++, user_dir);
      if (process == null) {
        return null;
      }
      list.add(process);
    }
    return process;
  }

  /**
   * Returns a list of running process.
   */
  public ArrayList<JProcess> getList() {
    return list;
  }

  /**
   * Kills a process based on its pid.
   *
   * @see JProcess.getPid
   */
  public synchronized boolean kill(int pid) {
    JProcess process = getProcessFor(pid);
    if (process == null) {
      return false;
    }
    synchronized (lock) {
      list.remove(process);
    }
    process.kill();
    System.gc();
    return false;
  }

  /**
   * Returns the current JProcess that is running in the current thread.
   */
  public JProcess getCurrentProcess() {
    return sm.getCurrentProcess();
  }

  private class JSecurityManager extends SecurityManager {

    public void checkExit(int status) {
      JProcess process = getCurrentProcess();
      if (process != null) {
        kill(process.getPid());
        throw new SecurityException();
      }
    }

    public void checkPermission(Permission perm) {
    }

    public void checkPermission(Permission perm, Object ctx) {
    }

    public boolean checkTopLevelWindow(Object obj) {
      if (!(obj instanceof Window)) {
        return true;
      }
      JProcess process = getCurrentProcess();
      if (process == null) {
        return true;
      }
      process.addWindow((Window) obj);
      return true;
    }

    public JProcess getCurrentProcess() {
      ThreadGroup group = getThreadGroup();
      JProcess match = null;
      match = getProcessFor(group);
      if (match != null) {
        return match;
      }
      Class[] class_context = getClassContext();
      for (int i = 0; i < class_context.length; i++) {
        ClassLoader loader = class_context[i].getClassLoader();
        if (loader != null) {
          match = getProcessFor(loader);
          if (match != null) {
            return match;
          }
        }
      }
      return null;
    }
  }

  /**
   * Returns a JProcess for the specified ThreadGroup
   *
   * @see JProcess.getThreadGroup
   */
  JProcess getProcessFor(ThreadGroup threadGroup) {
    JProcess process;
    synchronized (lock) {
      for (int a = 0; a < list.size(); a++) {
        process = list.get(a);
        if (process.getThreadGroup().parentOf(threadGroup)) {
          return process;
        }
      }
    }
    return null;
  }

  /**
   * Returns a JProcess for the specified ClassLoader
   *
   * @see JProcess.getClassLoader
   */
  JProcess getProcessFor(ClassLoader classLoader) {
    JProcess process;
    synchronized (lock) {
      for (int a = 0; a < list.size(); a++) {
        process = list.get(a);
        if (process.getClassLoader() == classLoader) {
          return process;
        }
      }
    }
    return null;
  }

  /**
   * Returns a JProcess for the specified pid
   *
   * @see JProcess.getPid
   */
  JProcess getProcessFor(int pid) {
    JProcess process;
    synchronized (lock) {
      for (int a = 0; a < list.size(); a++) {
        process = list.get(a);
        if (process.getPid() == pid) {
          return process;
        }
      }
    }
    return null;
  }
};