stax.java

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

            StringBuffer taskEntitySection =
                new StringBuffer("<!ENTITY % task       '");
            StringBuffer elemDTDsection = new StringBuffer();
            int numTasks = 0;

            synchronized (fActionFactoryMap)
            {
                Iterator factory_iter = fActionFactoryMap.keySet().iterator();
                while (factory_iter.hasNext())
                {
                    String actionFactoryName = (String)factory_iter.next();
                    STAXActionFactory factory = (STAXActionFactory)
                        fActionFactoryMap.get(actionFactoryName);

                    elemDTDsection.append(factory.getDTDInfo());

                    String taskName = factory.getDTDTaskName();

                    if (taskName != null)
                    {
                        // Put 3 actions in each line for the task entity.
                        if (numTasks == 0)
                            taskEntitySection.append(factory.getDTDTaskName());
                        else if (numTasks % 3 == 0)
                            taskEntitySection.append(" | \n" +
                                                 "                       " +
                                                 factory.getDTDTaskName());
                        else
                            taskEntitySection.append(" | " +
                                                 factory.getDTDTaskName());
                        numTasks++;
                    }
                }
            }

            taskEntitySection.append("'>\n");

            StringBuffer dtdBuff = new StringBuffer(fDTD);
            dtdBuff.append(taskEntitySection);
            dtdBuff.append(staxDTDsection);
            dtdBuff.append(elemDTDsection);
            fDTD = dtdBuff.toString();

            // Register Help Data

            registerHelpData(
                ErrorSubmittingExecuteRequest,
                "Error submitting execute request",
                "Additional information about the error is put into the " +
                "STAF Result.");

            registerHelpData(
                BlockNotHeld,
                "Block not held",
                "Requested to release a block that is not held.");

            registerHelpData(
                BlockAlreadyHeld,
                "Block already held",
                "Requested to hold a block that is already held.");
        }
        catch (STAFException e)
        {
            return new STAFResult(STAFResult.ServiceConfigurationError,
                                  e.toString());
        }
        catch (Throwable t)
        {
            rc = STAFResult.ServiceConfigurationError;
            t.printStackTrace();
            return new STAFResult(rc, t.toString());
        }

        return new STAFResult(rc);
    }

    public String getDTD() { return fDTD; }

    public String getServiceName() { return fServiceName; }

    public String getEventServiceMachine() { return fEventServiceMachine; }

    public String getEventServiceName() { return fEventServiceName; }

    public String getLocalMachineName() { return fLocalMachineName; }

    public String getLocalMachineNickname() { return fLocalMachineNickname; }

    public String getDataDir() { return fDataDir; }

    public String getInstanceUUID() { return fInstanceUUID; }

    public int getProcessTimeout() { return fProcessTimeout; }

    public boolean getClearlogs() { return fClearLogs; }

    public String getClearLogsAsString()
    {
        if (fClearLogs)
            return "Enabled";
        else
            return "Disabled";
    }

    public boolean getLogTCElapsedTime() { return fLogTCElapsedTime; }

    public String getLogTCElapsedTimeAsString()
    {
        if (fLogTCElapsedTime)
            return "Enabled";
        else
            return "Disabled";
    }

    public boolean getLogTCNumStarts() { return fLogTCNumStarts; }

    public String getLogTCNumStartsAsString()
    {
        if (fLogTCNumStarts)
            return "Enabled";
        else
            return "Disabled";
    }

    public boolean getLogTCStartStop() { return fLogTCStartStop; }

    public String getLogTCStartStopAsString()
    {
        if (fLogTCStartStop)
            return "Enabled";
        else
            return "Disabled";
    }

    public int getNextJobNumber()
    {
        synchronized (fNextJobNumberSynch)
        {
            return fNextJobNumber++;
        }
    }
    public STAFHandle getSTAFHandle() { return fHandle; }

    public STAXActionFactory getActionFactory(String elementName)
    {
        return (STAXActionFactory)fActionFactoryMap.get(elementName);
    }

    public TreeMap getJobMap()
    {
        synchronized(this)
        {
            return fJobMap;
        }
    }

    public void setExtension(STAXExtension ext)
    {
        synchronized(fExtensionsJarList)
        {
            fExtensionsJarList.add(ext);
        }
    }

    public STAXThreadQueue getThreadQueue() { return fThreadQueue; }

    public STAXTimedEventQueue getTimedEventQueue() { return fTimedEventQueue; }

    public STAFResult acceptRequest(STAFServiceInterfaceLevel30.RequestInfo info)
    {
        String lowerRequest = info.request.toLowerCase();

        if (lowerRequest.startsWith("execute"))
            return handleExecute(info, null);
        else if (lowerRequest.startsWith("list"))
            return handleList(info);
        else if (lowerRequest.startsWith("query"))
            return handleQuery(info);
        else if (lowerRequest.startsWith("help"))
            return handleHelp(info);
        else if (lowerRequest.startsWith("version"))
            return handleVersion(info);
        else if (lowerRequest.startsWith("get"))
            return handleGet(info);
        else if (lowerRequest.startsWith("set"))
            return handleSet(info);
        else if (lowerRequest.startsWith("notify"))
            return handleNotify(info);
        else
            return handleGenericRequest(info);
    }

    public STAFResult term()
    {
        // Issue a STAX TERMINATE JOB request for each job still running

        synchronized (fJobMap)
        {
            Iterator iter = fJobMap.values().iterator();

            while (iter.hasNext())
            {
                STAXJob thisJob = (STAXJob)iter.next();

                STAFResult result = acceptRequest(
                    new STAFServiceInterfaceLevel30.RequestInfo(
                    "",  // XXX: Default UUID to what?
                    fLocalMachineName, fLocalMachineName,
                    "STAF/Service/" + fServiceName, 1, 5, true,
                    0,  // XXX: diagEnable flag is not available
                    "TERMINATE JOB " + thisJob.getJobNumber(),
                    0, // XXX: requestNumber is not available
                    "none://anonymous",// Default user
                    "local://local",   // Default endpoint to local://local
                    "local"            // Default physicalInterfaceID to local
                    ));

                if (result.rc != 0)
                {
                    System.out.println("Error terminating STAX Job " +
                        thisJob.getJobNumber() + ".  RC=" + result.rc +
                        ", result=" + result.result);
                }
            }
        }

        // Wait until all jobs are terminated or maximum wait time exceeded

        int maxLoops = 60;  // 60 seconds is the maximum wait time

        for (int i = 0; fJobMap.size() != 0 && i < maxLoops; i++)
        {
            try
            {
                Thread.sleep(1000);   // Sleep 1 second
            }
            catch (InterruptedException ex)
            { }
        }

        // Un-register Help Data

        unregisterHelpData(ErrorSubmittingExecuteRequest);
        unregisterHelpData(BlockNotHeld);
        unregisterHelpData(BlockAlreadyHeld);

        // Un-register the service handle

        try
        {
            fHandle.unRegister();
        }
        catch (STAFException ex)
        {
            return new STAFResult(STAFResult.STAFRegistrationError,
                                  ex.toString());
        }

        return new STAFResult(STAFResult.Ok);
    }

    private STAFResult handleExecute(STAFServiceInterfaceLevel30.RequestInfo info,
                                     STAXJobCompleteListener listener)
    {
        // Verify the requesting machine/user has at least trust level 4

        STAFResult trustResult = STAFUtil.validateTrust(
            4, fServiceName, "EXECUTE", fLocalMachineName, info);

        if (trustResult.rc != STAFResult.Ok) return trustResult;

        STAXSubmitResult res = execute(info, listener);

        return res.getResult();
    }

    public STAXSubmitResult execute(STAFServiceInterfaceLevel30.RequestInfo info,
                                    STAXJobCompleteListener listener)
    {
        STAXParser parser = null;
        STAXJob job = null;

        STAFCommandParseResult parseResult= fExecuteParser.parse(info.request);

        if (parseResult.rc != STAFResult.Ok)
        {
            return new STAXSubmitResult(new STAFResult(
                STAFResult.InvalidRequestString, parseResult.errorBuffer));
        }

        try
        {
            parser = new STAXParser(this);

            // Parse and resolve the MACHINE value

            String machName;
            STAFResult resolvedValue;

            if (parseResult.optionTimes("MACHINE") > 0)
            {
                resolvedValue = STAFUtil.resolveRequestVar(
                    parseResult.optionValue("MACHINE"),
                    fHandle, info.requestNumber);

                if (resolvedValue.rc != 0)
                    return new STAXSubmitResult(resolvedValue);

                machName = resolvedValue.result;
            }
            else
                machName = info.endpoint;

            // Parse an XML document from a file.

            String fileName = "";
            if (parseResult.optionTimes("FILE") > 0)