Problems with WLST embedded in java app.

Question

Hi,
I have a problem with the WLST embedded in a java app.
I want to programatically create or reconfigure a domain from a java application. Following is a simple example of what I want to do.
import weblogic.management.scripting.utils.WLSTInterpreter;
public class DomainTester {
  static WLSTInterpreter interpreter = new WLSTInterpreter();
  private void processDomain() {
    if(domainExists()) {
      System.out.println("Should now UPDATE the domain");
    } else {
      System.out.println("Should now CREATE the domain");
  private boolean domainExists() {
    try {
      interpreter.exec("readDomain('d:/myDomains/newDomain')");
      return true;
    }catch(Exception e) {
      return false;
}The output of this should be one of two possibles.
1. If the domain exists already it should output
"Should now UPDATE the domain"
2. If the domain does not exist it should output
"Should now CREATE the domain"
However, if the domain does not exist the output is always :
Error: readDomain() failed. Do dumpStack() to see details.
Should now UPDATE the domain
It never returns false from the domainExists() method therefor always states that the exec() worked.
It seams that the exec() method does not throw ANY exceptions from the WLST commands. The catch clause is never executed and the return value from domainExists() is always true.
None of the VERY limited number of examples using embedded WLST in java has exception or error handling in so I need to know what is the policy to detect failures in a WLST command executed in java??? i.e. How does my java application know when a command succeeds or not??
Regards
Steve

Answer 1

Hi,
I did some creative wrapping for the WLSTInterpreter and I now have very good programatic access to the WLST python commands.
I will put this on dev2dev somewhere and release it into the open source community.
Don't know the best place to put it yet, so if anybody sees this and has any good ideas please feel free to pass them on.
Here is the wrapper class. It can be used as a direct replacement for the weblogic WLSTInterpreter. As I can't overload the actual exec() calls because I want to return a String from this call I created an exec1(String command) that will return a String and throw my WLSTException which is a RuntimeException which you can handle if you like.
It sets up stderr and stdout streams to interpret the results both from the Python interpreter level and at the JVM level where dumpStack() just seem to do a printStackTrace(). It also calls the dumpStack() command should the result contain this in its text. If either an exception is thrown from the lower level interpreter or dumpStack() is in the response I throw my WLSTException containing this information.
package eu.medsea.WLST;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import weblogic.management.scripting.utils.WLSTInterpreter;
public class WLSTInterpreterWrapper extends WLSTInterpreter {
     // For interpreter stdErr and stdOut
     private ByteArrayOutputStream baosErr = new ByteArrayOutputStream();
     private ByteArrayOutputStream baosOut = new ByteArrayOutputStream();
     private PrintStream stdErr = new PrintStream(baosErr);
     private PrintStream stdOut = new PrintStream(baosOut);
     // For redirecting JVM stderr/stdout when calling dumpStack()
     static PrintStream errSaveStream = System.err;
     static PrintStream outSaveStream = System.out;
     public WLSTInterpreterWrapper() {
          setErr(stdErr);
          setOut(stdOut);
     // Wrapper function for the WLSTInterpreter.exec()
     // This will throw an Exception if a failure or exception occures in
     // The WLST command or if the response containes the dumpStack() command
     public String exec1(String command) {
          String output = null;
          try {
               output = exec2(command);
          }catch(Exception e) {
               try {
                    synchronized(this) {
                         stdErr.flush();
                         baosErr.reset();
                         e.printStackTrace(stdErr);
                         output = baosErr.toString();
                         baosErr.reset();
               }catch(Exception ex) {
                    output = null;
               if(output == null) {
                    throw new WLSTException(e);
               if(!output.contains(" dumpStack() ")) {
                    // A real exception any way
                    throw new WLSTException(output);
          if (output.length() != 0) {
               if(output.contains(" dumpStack() ")) {
                    // redirect the JVM stderr for the durration of this next call
                    synchronized(this) {
                         System.setErr(stdErr);
                         System.setOut(stdOut);
                         String _return = exec2("dumpStack()");
                         System.setErr(errSaveStream);
                         System.setOut(outSaveStream);
                         throw new WLSTException(_return);
          return stripCRLF(output);
     private String exec2(String command) {
          // Call down to the interpreter exec method
          exec(command);
          String err = baosErr.toString();
          String out = baosOut.toString();
          if(err.length() == 0 && out.length() == 0) {
               return "";
          baosErr.reset();
          baosOut.reset();
          StringBuffer buf = new StringBuffer("");
          if (err.length() != 0) {
               buf.append(err);
          if (out.length() != 0) {
               buf.append(out);
          return buf.toString();
     // Utility to remove the end of line sequences from the result if any.
     // Many of the response are terminated with either \r or \n or both and
     // some responses can contain more than one of them i.e. \n\r\n
     private String stripCRLF(String line) {
          if(line == null || line.length() == 0) {
               return line;
          int offset = line.length();          
          while(true && offset > 0) {
               char c = line.charAt(offset-1);
               // Check other EOL terminators here
               if(c == '\r' || c == '\n') {
                    offset--;
               } else {
                    break;
          return line.substring(0, offset);
}Next here is the WLSTException class
package eu.medsea.WLST;
public class WLSTException extends RuntimeException {
     private static final long serialVersionUID = 1102103857178387601L;
     public WLSTException() {
          super();
     public WLSTException(String message) {
          super(message);
     public WLSTException(Throwable t) {
          super(t);
     public WLSTException(String s, Throwable t) {
          super(s, t);
}And here is the start of a wrapper class for so that you can use the WLST commands directly. I will flesh this out later with proper var arg capabilities as well as create a whole Exception hierarchy that better suites the calls.
package eu.medsea.WLST;
// Provides methods for the WLSTInterpreter
// just to make life a little easier.
// Also provides access to the more generic exec(...) call
public class WLSTCommands {
     public void cd(String path) {
          exec("cd('" + path + "')");
     public void edit() {
          exec("edit()");
     public void startEdit() {
          exec("startEdit()");
     public void save() {
          exec("save()");
     public void activate() {
          exec("activate(block='true')");
     public void updateDomain() {
          exec("updateDomain()");
     public String state(String serverName) {
          return exec("state('" + serverName + "')");
     public String ls(String dir) {
          return exec("ls('" + dir + "')");
     // The generic wrapper for the interpreter exec() call
     public String exec(String command) {
          return interpreter.exec1(command);
     private WLSTInterpreterWrapper interpreter = new WLSTInterpreterWrapper();
}Lastly here is some example code using these classes:
its using both the exec(...) and cd(...) wrapper commands from the WLSTCommand.class shown above.
    String machineName = ...; // get name from somewhere
    try {
     exec("machine=create('" + machineName + "','Machine')");
     cd("/Machines/" + machineName + "/NodeManager/" + machineName);
     exec("set('ListenAddress','10.42.60.232')");
     exec("set('ListenPort', 5557)");
    }catch(WLSTException e) {
        // Possibly the machine object already exists so
        // lets just try to look it up.
     exec("machine=lookup('" + machineName + "','Machine')");
...After this call a machine object is setup that can be allocated later like so:
     exec("set('Machine',machine)");Regards
Steve