staxprocessaction.java

Software Testing Automation Framework (STAF)的开发代码

            }
                
            if (!fStatichandlename.equals(""))
            {
                evalElem = "statichandlename";
                evalAttr = "if";

                if (fThread.pyBoolEval(fStatichandlenameIf))
                {
                    evalAttr = "";
                    fStatichandlename = fThread.pyStringEval(
                                        fUnevalStatichandlename);
                    request.append(" STATICHANDLENAME ");
                    request.append(STAFUtil.wrapData(fStatichandlename));
                }
                else
                    fStatichandlename = "";
            }
                
            if (!fStdin.equals(""))
            {
                evalElem = "stdin";
                evalAttr = "if";

                if (fThread.pyBoolEval(fStdinIf))
                {
                    evalAttr = "";
                    fStdin = fThread.pyStringEval(fUnevalStdin);
                    request.append(" STDIN ");
                    request.append(STAFUtil.wrapData(fStdin));
                }
                else
                    fStdin = "";
            }
                
            if (!fStdout.equals(""))
            {
                evalElem = "stdout";
                evalAttr = "if";

                if (fThread.pyBoolEval(fStdoutIf))
                {
                    evalAttr = "mode";
                    fStdoutMode = fThread.pyStringEval(fUnevalStdoutMode);
 
                    evalAttr = "";
                    if (fStdoutMode.equalsIgnoreCase("replace"))
                    {
                        fStdout = fThread.pyStringEval(fUnevalStdout);
                        request.append(" STDOUT ");
                        request.append(STAFUtil.wrapData(fStdout));
                    }
                    else if (fStdoutMode.equalsIgnoreCase("append"))
                    {
                        fStdout = fThread.pyStringEval(fUnevalStdout);
                        request.append(" STDOUTAPPEND ");
                        request.append(STAFUtil.wrapData(fStdout));
                    } 
                    else
                    {
                        // Raise a StartProcessError signal
                        fState = COMPLETE;
                        fThread.popAction();
 
                        String msg = "<process>\n" +
                            "\n  Name       : " + fName +
                            "\n  Location   : " + fLocation +
                            "\n  Command    : " + fCommand;

                        if (!fParms.equals(""))
                            msg += "\n  Parms      : " + fParms;

                        msg += "\n  Stdout Mode: " + fStdoutMode +
                            "\n\n  Invalid value for stdout element's mode " +
                            "attribute: " + fStdoutMode +
                            "\n  Must be 'replace' or 'append'.";

                        fThread.setSignalMsgVar("STAXProcessStartErrorMsg",
                                                msg);
                        fThread.raiseSignal("STAXProcessStartError");
                        return 1;        

                    }
                }
                else
                {
                    fStdout = "";
                    fStdoutMode = "";
                }
            }
                
            if (!fStderr.equals("") || !fUnevalStderrMode.equals(""))
            {
                evalElem = "stderr";
                evalAttr = "if";

                if (fThread.pyBoolEval(fStderrIf)) 
                {
                    evalAttr = "mode";
                    fStderrMode = fThread.pyStringEval(fUnevalStderrMode);
                    evalAttr = "";

                    if (! fStderrMode.equalsIgnoreCase("stdout"))
                    {
                        // Check if EXACT same file name was specified
                        // for stdout and stderr and if so, set mode=stdout
                        fStderr = fThread.pyStringEval(fUnevalStderr);
                        if (fStderr.equals(fStdout))
                            fStderrMode = "stdout";
                    }
                        
                    if (fStderrMode.equalsIgnoreCase("replace"))
                    {
                        request.append(" STDERR ");
                        request.append(STAFUtil.wrapData(fStderr));
                    }                
                    else if (fStderrMode.equalsIgnoreCase("append"))
                    {
                        request.append(" STDERRAPPEND ");
                        request.append(STAFUtil.wrapData(fStderr));
                    }
                    else if (fStderrMode.equalsIgnoreCase("stdout"))
                    {
                        fStderr = "";
                        request.append(" STDERRTOSTDOUT");
                    }
                    else
                    {
                        // Raise a StartProcessError signal
                        fState = COMPLETE;
                        fThread.popAction();
 
                        String msg = "<process>\n" +
                            "\n  Name       : " + fName +
                            "\n  Location   : " + fLocation +
                            "\n  Command    : " + fCommand;

                        if (!fParms.equals(""))
                            msg += "\n  Parms      : " + fParms;

                        msg += "\n  Stderr Mode: " + fStderrMode +
                            "\n\n  Invalid value for stderr element's mode " +
                            "attribute: " + fStderrMode +
                            "\n  Must be 'replace' or 'append' or 'stdout'.";

                        fThread.setSignalMsgVar("STAXProcessStartErrorMsg",
                                                msg);
                        fThread.raiseSignal("STAXProcessStartError");
                        
                        return 1;
                    }
                }
                else
                {
                    fStderr = "";
                    fStderrMode = "";
                }
            }
            
            if (!fReturnStdout.equals(""))
            {
                evalElem = "returnstdout";
                evalAttr = "if";

                if (fThread.pyBoolEval(fReturnStdoutIf)) 
                    request.append(" RETURNSTDOUT");
                else
                    fReturnStdout = "";
            }
             
            if (!fReturnStderr.equals(""))
            {
                evalElem = "returnstderr";
                evalAttr = "if";

                if (fThread.pyBoolEval(fReturnStderrIf)) 
                    request.append(" RETURNSTDERR");
                else
                    fReturnStderr = "";
            }
                
            evalElem = "returnfile";

            for (int i = 0; i < fUnevalReturnFiles.size(); i++)
            {
                evalAttr = "if";
                String returnFilesIf = fThread.pyStringEval(
                    (String)fReturnFilesIf.elementAt(i));

                if (fThread.pyBoolEval(returnFilesIf))
                {
                    // Evaluate as a list; each list item is a single file
                        
                    evalAttr = "";
                    List fileList = fThread.pyListEval(
                        (String)fUnevalReturnFiles.elementAt(i));

                    for (int j = 0; j < fileList.size(); j++)
                    {
                        String file = ((Object)fileList.get(j)).toString();
                        fReturnFiles.add(file);
                        request.append(" RETURNFILE ");
                        request.append(STAFUtil.wrapData(file));
                    }
                }
            }

            if (fProcessAction != null)
            {
                evalElem = "process-action";
                evalAttr = "if";
                fProcessActionFlag = fThread.pyBoolEval(fProcessActionIf);
            }

            if (!fOther.equals(""))
            {
                evalElem = "other";
                evalAttr = "if";

                if (fThread.pyBoolEval(fOtherIf))
                {
                    fOther = fThread.pyStringEval(fUnevalOther);
                    request.append(" ");
                    request.append(fOther);
                }
                else
                    fOther = "";      
            }
        }
        catch (STAXPythonEvaluationException e)
        {
            fState = COMPLETE;
            fThread.popAction();

            StringBuffer msg = new StringBuffer();
            msg.append("<process>\n").
                append("\n  Name    : ").append(fUnevalName).
                append("\n  Location: ").append(fUnevalLocation).
                append("\n  Command : ").append(fUnevalCommand);

            if (!fUnevalParms.equals(""))
                msg.append("\n  Parms   : ").append(fUnevalParms);

            if (evalElem.equals("process"))
            {
                msg.append("\n\n  Process 'name' attribute in error");
            }
            else
            {
                msg.append("\n\n  Process sub-element in error: <").
                    append(evalElem).append(">");
                 
                if (!evalAttr.equals(""))
                {
                    msg.append("\n  Attribute in error: ").append(evalAttr);
                }
            }

            fThread.setSignalMsgVar("STAXPythonEvalMsg", msg.toString(), e);
            fThread.raiseSignal("STAXPythonEvaluationError");

            return 1;
        }
                  
        fRequest = request.toString();

        return 0;
    }


    private void generateProcessStartEvent()
    {
        // Generate a start process event

        HashMap processMap = new HashMap();
        processMap.put("type", "process");
        processMap.put("block", fCurrentBlockName);
        processMap.put("status", "start");
        processMap.put("location", fLocation);
        processMap.put("command", STAFUtil.maskPrivateData(fCommand));
        processMap.put("handle", String.valueOf(fProcessHandle));
        processMap.put("parms", STAFUtil.maskPrivateData(fParms));
        processMap.put("name", fName);
        processMap.put("mode", fCommandMode);
        processMap.put("workload", fWorkload);
        processMap.put("title", fTitle);
        processMap.put("workdir", fWorkdir);

        if (!fCommandShell.equals(""))
        {    
            processMap.put("shell", fCommandShell);
        }

        // Convert the fVars vector to a list

        List varList = new ArrayList();

        for (int i = 0; i < fVars.size(); i++)
        {
            varList.add((String)fVars.elementAt(i));
        }

        processMap.put("varList", STAFMarshallingContext.marshall(
            varList, new STAFMarshallingContext()));

        // Convert the fEnvs vector to a list

        List envList = new ArrayList();

        for (int i = 0; i < fEnvs.size(); i++)
        {
            envList.add((String)fEnvs.elementAt(i));
        }

        processMap.put("envList", STAFMarshallingContext.marshall(
            envList, new STAFMarshallingContext()));
        
        if (!fUseprocessvars.equals(""))
        {
            processMap.put("useprocessvars", "");
        }

        processMap.put("stopusing", fStopusing);

        if (fConsole.equalsIgnoreCase("new"))
        {
            processMap.put("newconsole", "");
        }
        else if (fConsole.equalsIgnoreCase("same"))
        {
            processMap.put("sameconsole", "");
        }

        if (!fFocus.equals(""))
        {
            processMap.put("focus", fFocus);
        }

        processMap.put("username", fUsername);

        if (!fPassword.equals(""))
        {
            processMap.put("password", "*******");
        }

        if (fDisabledauth.equalsIgnoreCase("error"))
        {
            processMap.put("disabledauthiserror", "");
        }
        else if (fDisabledauth.equalsIgnoreCase("ignore"))
        {
            processMap.put("ignoredisabledauth", "");
        }

        processMap.put("stdin", fStdin);       

        if (fStdoutMode.equalsIgnoreCase("replace"))
        {
            processMap.put("stdout", fStdout);
        }
        else if (fStdoutMode.equalsIgnoreCase("append"))
        {
            processMap.put("stdoutappend", fStdout);
        }

        if (fStderrMode.equa