appinfo.java

SRI international 发布的OAA框架软件

    initializeWaitForOutput();    

  }


  public void initializeWaitFor() {
    // fill in agentsToWaitFor, given waitfor Strings;
    for (Iterator i = waitfor.iterator(); i.hasNext(); ) {
      String name = (String) i.next();
      AppInfo w = sinfo.findAppByName(name);
      if (w == null) {
	System.err.println("ERROR: can't find app by the name of \"" + name +
			   "\" in the waitfor list of \"" + appid + "\"");
      }
      else {
	if (findWaitForLoop(w)) {
	  System.err.println("ERROR: waitfor loop detected in \"" + appid + "\"");
	}
	else {
	  agentsToWaitFor.add(w);
	  w.appsWaitingForMe.add(this);
	}
      }	
    }
  }

  public void initializeWaitForOutput() {
    for (Iterator i = waitforoutput.iterator(); i.hasNext(); ) {
	OutputFlag flag = (OutputFlag) i.next();
	flag.resolveApp();
	if (flag.app == null) {
	  System.err.println("ERROR: cannot resolve appID \"" + flag.appname + 
			     "\"in waitfor line of \""+ flag.app.appid + "\"");
	}
	else {
	  if (findWaitForLoop(flag.app)) {
	    System.err.println("ERROR: waitfor loop (waitforoutput) detected in \"" + appid + "\"");
	  }
	  else {
	    flag.install();
	  }
	}
    }
  }

  public boolean findWaitForLoop(AppInfo w) {
    return false; // FOR NOW!!!
  }

  public StartitProcess getProcess() {
    return sprocess;
  }

  public boolean isInProject(String p) {
    // If my project list (projects) is null, then I'm in all projects.
    // If p is null, then it's the global project, so everyone's in it.
    if (projects == null || p == null) return true;

    return (projects.contains(p));
  }

  public void printStartCommands() {
    LoginInfo login = updateToStart();
    System.out.println("Exec: " + login.getLocalShellCommand());
    Vector cmds = sprocess.getStartCommands();
    for(Iterator i = cmds.iterator(); i.hasNext(); ) {
      String s = (String) i.next();
      if (s != null) System.out.println("Send: " + s);
    }
    System.out.println();
  }

  public void start() {
    if (sprocess.isStarted()) return;
    sprocess.start(); // this calls updateToStart() back, when it really starts
    if (getFacilitator() != null) {
      getFacilitator().start(); // ensure my facilitator is started (even if
				// it's hidden!)
    }
  }

  protected LoginInfo updateToStart() {
    if (portOption != null) {
      try {
	port = Integer.parseInt(portOption.getValue());
      }
      catch (NumberFormatException e) {
	port = DEFAULT_PORT;
	// MUST update GUI!!!
      }
    }

    // assume remote machine is unix for now
    // (if shell is LOCAL, though, it will ignore that and use the local machine type)
    LoginInfo login = new LoginInfo(getHost(), user, null, shell, Environment.UNIX);
    // MUST update GUI!!

    String dir = resolve(appdir);
    Vector env = resolve(environment);
    String line = resolve(appline);

    sprocess.setLoginInfo(login);
    sprocess.setEnvironment(env);
    sprocess.setDirectory(dir);
    sprocess.setCommand(line);

    StartitInfo.debugPrint(this, "****************** START " + appname + " ***************");
    StartitInfo.debugPrint(this, "Working directory: " + dir);
    StartitInfo.debugPrint(this, "      Environment: " + env);
    StartitInfo.debugPrint(this, "      Application: " + line);
    StartitInfo.debugPrint(this, "****************** START " + appname + " ***************");
    return login;
  }

  public String getHost() {
    if (shell == LoginInfo.LOCAL) return "localhost";
    return LoginInfo.fixupHostname(resolve(host));
  }

  public boolean isAgent() {
    return !(oaaname == null);
  }

  public boolean isFacilitator() {
    return facilitator;
  }

  public AppInfo getFacilitator() {
    return (isAgent() ? sinfo.facilitator : null);
  }

  public Vector resolve(Vector/*String*/ v) {
    Vector out = new Vector();
    for (Iterator i = v.iterator(); i.hasNext(); ) {
      out.add(resolve((String) i.next()));
    }
    return out;
  }

  public String resolve(String s) {
    if (s == null) return null;

    String r;
    int num = 0;
    do {
      r = s;
      s = resolveOnce(s);
      num++;
    }
    while (!r.equals(s) && num < MAX_NESTING);
    if (num >= MAX_NESTING) {
      System.err.println("WARNING: probable recursion in variable expansion for " +
			 appname);
    }
    return r;
  }

  // recursive method, expands all variable names
  public String resolveOnce(String s) {
    Matcher m = Pattern.compile("\\$\\{[^}]+\\}").matcher(s);
    boolean found = m.find();
    
    if (!found) {		// no variable to expand:
      return s;			// just return the input string
    }
    else if (m.start() == 0 && m.end() == s.length()) { // variable was the whole string
      String var = s.substring(2, s.length()-1); // strip "${" off front and "}" off end
      
      return resolveVariable(var, true);
    }
    else {			// variable was embedded
      String pre = s.substring(0, m.start());
      String post = s.substring(m.end());

      // append string before first var, expansion of var, expansion of rest of line
      return (pre + resolveOnce(m.group()) + resolveOnce(post));
    }
  }

  public String resolveVariable(String v, boolean globally) {
    String s;

    // 1: check for special cases
    if (VAR_HOST.equals(v)) return getHost();
    if (VAR_OAACONNECT.equals(v)) {
      if (isAgent()) {
	return sprocess.getOAAConnectString();
      }
      else {
	System.err.println("WARNING: non-agent (" + appname + ") can't use ${" + VAR_OAACONNECT + "}");
	return null;
      }
    }

    // 2: try to resolve v from my set of options
    for(Iterator i = options.iterator(); i.hasNext(); ) {
      OptionInfo opt = (OptionInfo) i.next();
      if (opt.tag.equals(v)) {
	return opt.getValue();
      }
    }
    if (!globally) return null;

    // 3: try to resolve v globally (this will check ${var:app} syntax
    s = sinfo.resolveVariable(v);
    if (s != null) {
      StartitInfo.debugPrint(this, "Resolved global app variable: ${" + v + "}");
      return s;
    }

    // 4: try it as an Environment var
    s = Environment.get(v);
    if (s != null) {
      StartitInfo.debugPrint(this, "Resolved Environment variable: ${" + v + "}");
      return s;
    }

    // finally: give up - return it verbatim
    StartitInfo.warningPrint(this, "Can't resolve variable: ${" + v + "}");
    return "$" + v;
  }

  public class OutputFlag {
    public final Pattern regexp;
    public final String appname;
    public AppInfo app;

    public OutputFlag(String a, String s) {
      regexp = Pattern.compile(s);
      appname = a;
    }

    public void resolveApp() {
      app = sinfo.findAppByName(appname);
    }

    public void install() {
      if (app == null) return;
      app.sprocess.addOutputFlag(this);
    }

    public boolean hasSeenOutput() {
      return app.sprocess.hasSeenOutput(this);
    }
  }

}