eventmanagerservice.java

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

            return new STAFResult(STAFResult.JavaError, "Internal Java error.");
        }

        return sResult;
    }

    private STAFResult handleVersion(
        STAFServiceInterfaceLevel30.RequestInfo info)
    {
        // Verify the requester has at least trust level 1

        STAFResult trustResult = STAFUtil.validateTrust(
            1, fServiceName, "VERSION", fLocalMachineName, info);

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

        // Parse the request

        STAFCommandParseResult parsedRequest = fVersionParser.parse(
            info.request);

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

        if (parsedRequest.optionTimes("JYTHON") == 0)
        {
            // Return the version of the service
            return new STAFResult(STAFResult.Ok, kVersion);
        }
        else
        {
            // Return the version of Python packaged with the service
            return new STAFResult(STAFResult.Ok, fJythonVersion);
        }
    }


    public void run()
    {
        STAFResult queueGetResult;

        for (;;)
        {
            queueGetResult = fHandle.submit2("local", "QUEUE", "GET WAIT");
                
            if (queueGetResult.rc != 0)
            {
                // XXX: Do anything?
                continue;
            }

            // Need a try/catch block so can catch any errors and continue
            // processing messages on the queue

            try
            {
                STAFQueueMessage queueMessage = new STAFQueueMessage(
                    queueGetResult.result);

                String queueType = queueMessage.type;
                
                STAFResult varRequest = fHandle.submit2(queueMessage.machine,
                    "VAR", "RESOLVE STRING {STAF/Config/Machine}");

                String queueMachineName = varRequest.result;

                if (queueType.equalsIgnoreCase("STAF/RequestComplete"))
                {
                    handleRequestCompleteMsg(queueMessage, queueMachineName);
                }
                else if (queueType.equalsIgnoreCase("STAF/PROCESS/END"))
                {
                    handleProcessEndMsg(queueMessage);
                }
                else if (queueType.equalsIgnoreCase("STAF/Service/Event"))
                {
                    if (!(queueMessage.message instanceof Map))
                    {
                        System.out.println(
                            "EventManagerService: Unsupported message " +
                            "format.  Ignoring this message.\n" +
                            "priority=" + queueMessage.priority +
                            ", timestamp=" + queueMessage.timestamp +
                            ", machine=" + queueMessage.machine +
                            ", handleName=" + queueMessage.handleName +
                            "\nqueueType=" + queueType +
                            "\nmessage=" + queueMessage.message.toString());

                        // Ignore this message
                        continue;
                    }

                    // Provide both the unmarshalled message and the
                    // marshalled message string because it needs to
                    // unmarshall it using Python
                    handleEventServiceMsg(queueMessage,
                                          queueGetResult.result);
                }
                else if (queueType.equalsIgnoreCase(sQueueTypeEnd))
                {
                    // This type of queue message indicates that the service
                    // is terminating

                    try
                    {
                        fHandle.unRegister();
                    }
                    catch (STAFException ex)
                    {
                        if (DEBUG)
                        {
                            ex.printStackTrace();
                        }
                    }

                    return;
                }
            }
            catch (Exception e)
            {
                // Log an error and continue processing messages on the queue

                fHandle.submit2(
                    "local", "LOG", "LOG MACHINE LOGNAME " + fServiceName +
                    " LEVEL Error MESSAGE " +
                    STAFUtil.wrapData(
                        "Exception handling queued message. Exception:\n" +
                        e + "\nQueued Message:\n" + queueGetResult.result));
            }
        }
    }

    private void handleRequestCompleteMsg(STAFQueueMessage queueMessage,
                                           String queueMachine)
    {
        // A STAF/RequestComplete message is a map containing keys:
        //   requestNumber, rc, result

        Map messageMap = (Map)queueMessage.message;
                
        String reqNum = (String)messageMap.get("requestNumber");
        String rc = (String)messageMap.get("rc");
        Object result = (Object)messageMap.get("result");

        // Log a message about the completed request

        String level = "";

        if (rc.equals("0"))
            level = "Pass";
        else
            level = "Fail";
                
        String request = (String)fSubmittedRequests.get(reqNum);

        String id = (String)(fRequestsAndIDs.get(queueMachine +
                             ":" + reqNum));

        fHandle.submit2(
            "local", "LOG", "LOG MACHINE LOGNAME " + fServiceName +
            " LEVEL " + level + " MESSAGE " +
            STAFUtil.wrapData("[ID=" + id + "] [" +
                              queueMachine + ":" + reqNum +
                              "] Completed a STAF command. RC=" + rc +
                              ", Result=" + result.toString()));

        // handle process service start requests

        String lowerRequest = request.toLowerCase();

        if ((lowerRequest.indexOf("service=process") > -1) &&
             (lowerRequest.indexOf("request=start") > -1)  &&
            (lowerRequest.indexOf("wait") == -1))
        {
            String machine = queueMessage.machine;

            String handle = result.toString();

            STAFResult notifyRegResult;

            STAFResult varRequest = fHandle.submit2(machine,
                    "VAR", "RESOLVE STRING {STAF/Config/Machine}");

            String queueMachineName = varRequest.result;

            fProcessHandlesAndRequests.put(queueMachineName + ":" + handle,
                                           queueMachineName + ":" + reqNum);

            notifyRegResult = fHandle.submit2(machine, "process",
                "notify register onendofhandle " + handle);

            if (notifyRegResult.rc != 0)
            {
                fHandle.submit2(
                    "local", "log", "log machine logname " + fServiceName +
                    " level error" + " message " +
                    STAFUtil.wrapData("[ID=" + id + "] [" +
                                      queueMachine + ":" + reqNum +
                                      "] Process completion notification to " +
                                      " machine " + machine + "failed for" +
                                      " handle " + handle + " RC=" +
                                      notifyRegResult.rc + " Result=" +
                                      notifyRegResult.result));
            }

            if (notifyRegResult.rc == STAFResult.ProcessAlreadyComplete)
            {
                STAFResult freeHandleResult;

                freeHandleResult = fHandle.submit2(
                    machine, "PROCESS", "FREE HANDLE " + handle);

                if (freeHandleResult.rc != 0)
                {
                    fHandle.submit2(
                        "local", "log", "log machine logname " + fServiceName +
                        " level error message " +
                        STAFUtil.wrapData(
                            "[ID=" + id + "] [" +
                            queueMachine + ":" + reqNum +
                            "] Free handle " + handle + " on machine " +
                            machine + " failed. RC=" + freeHandleResult.rc +
                            " Result=" + freeHandleResult.result));;
                }
            }
        }
        else
        {
            // Remove this for requests other than ansynchronous PROCESS START
            fRequestsAndIDs.remove(queueMachine + ":" + reqNum);
        }
        
        // Remove the request from the submitted request map

        fSubmittedRequests.remove(reqNum);
    }

    private void handleProcessEndMsg(STAFQueueMessage queueMessage)
    {
        Map messageMap = (Map)queueMessage.message;
        String handle = (String)messageMap.get("handle");
        String rc = (String)messageMap.get("rc");

        String machine = queueMessage.machine;
        
        STAFResult varRequest = fHandle.submit2(machine,
                "VAR", "RESOLVE STRING {STAF/Config/Machine}");

        String machineName = varRequest.result;
        
        String request = (String)(fProcessHandlesAndRequests.get(machineName +
                                                                 ":" + handle));

        String id = (String)(fRequestsAndIDs.get(request));

        String reqNum = request.substring(request.indexOf(":") + 1);

        String message = "[ID=" + id.toString() + "] " +
            "[" + machineName + ":" + reqNum + "] " +
            "Process completed.\nProcess info: " + messageMap.toString();

        String level = "";

        if (rc.equals("0"))
        {
            level = "Pass";
        }
        else
        {
            level = "Fail";
        }

        fHandle.submit2(
            "local", "log", "log machine logname " + fServiceName +
            " level " + level + " message " +
            STAFUtil.wrapData(message));

        STAFResult freeHandleResult;

        freeHandleResult = fHandle.submit2(
            machine, "PROCESS", "FREE HANDLE " + handle);

        if (freeHandleResult.rc != 0)
        {
            fHandle.submit2(
                "local", "log", "log machine logname " + fServiceName +
                " level info" + " message " +
                STAFUtil.wrapData(
                    "[ID=" + id.toString() + "] [" + 
                    machineName + ":" + reqNum + "] Free handle " + handle + 
                    "on machine " + machine + " failed. RC=" +
                    freeHandleResult.rc + " Result=" +
                    freeHandleResult.result));
        }
    }

    private void handleEventServiceMsg(STAFQueueMessage queueMessage,
                                       String marshalledQueuedMsg)
    {
        // A STAF/Service/Event message is a map containing keys: 
        // eventServiceName, eventID, machine, handleName, handle, timestamp,
        // type, subtype, and propertyMap (whose values could contain
        // marshalled data).

        // Assign the data in the message to Java variables

        Map messageMap = (Map)queueMessage.message;

        String eventService = (String)messageMap.get("eventServiceName");
        String eventID = (String)messageMap.get("eventID");
        String generatingMachine = (String)messageMap.get("machine");
        String generatingProcess = (String)messageMap.get("handleName");
        String generatingHandle = (String)messageMap.get("handle");
        String eventTimestamp = (String)messageMap.get("timestamp");
        String eventType = (String)messageMap.get("type");
        String eventSubtype = (String)messageMap.get("subtype");
        Map eventProperties = (Map)messageMap.get("propertyMap");

        String eventInfoMsg = "Event service message information:" +
            "\n  eventservice: " + eventService +
            "\n  eventid: " + eventID +
            "\n  type: " + eventType +
            "\n  subtype: " + eventSubtype +
            "\n  generatingmachine: " + generatingMachine +
            "\n  generatingprocess: " + generatingProcess +
            "\n  generatinghandle: " + generatingHandle +
            "\n  eventtimestamp: " + eventTimestamp +
            "\n  properties: " + eventProperties;
       
        // Process all EventManager registrations whose type/subtype
        // match that in the event message

        EventManagerData1 theData;

        for (Enumeration enumData = fRegTable.keys();
              enumData.hasMoreElements();)
        {
            Integer id = (Integer)enumData.nextElement();
            
            theData = (EventManagerData1)fRegTable.get(id);
            
            if (!eventType.equalsIgnoreCase(theData.fType))
            {
                // Event type does not match EventManager registration
                continue;
            }
            else if (!theData.fSubtype.equals("") &&
                     !eventSubtype.equalsIgnoreCase(theD