eventservice.java

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

        }

        // PRIORITY is an undocumented service parameter

        if (parsedResult.optionTimes("PRIORITY") > 0)
        {
            resolvedResult = STAFUtil.resolveInitVarAndCheckInt(
                "PRIORITY", parsedResult.optionValue("PRIORITY"), fHandle);

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

            fPriority = Integer.parseInt(resolvedResult.result);
        }

        // PRIORITYDELTA is an undocumented service parameter

        if (parsedResult.optionTimes("PRIORITYDELTA") > 0)
        {
            resolvedResult = STAFUtil.resolveInitVarAndCheckInt(
                "PRIORITYDELTA", parsedResult.optionValue("PRIORITYDELTA"),
                fHandle);

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

            fPriorityDelta = Integer.parseInt(resolvedResult.result);
        }

        return new STAFResult(STAFResult.Ok);
    }

    public STAFResult term()
    {
        // Un-register Help Data

        unregisterHelpData(kNoAckPending);
        unregisterHelpData(kNoSuchID);
        unregisterHelpData(kNotRegisteredForType);
        unregisterHelpData(kNotRegisteredForSubtype);
        unregisterHelpData(kNoClientsForEvent);

        // Un-register the service handle

        try
        {
            fHandle.unRegister();
        }
        catch (STAFException ex)
        {
            return new STAFResult(STAFResult.STAFRegistrationError,
                                  "Error unregistering handle.");
        }

        return new STAFResult(STAFResult.Ok);
    }

    /***************************************************************************/
    /* acceptRequest- Calls appropriate methods to process a request from a    */
    /*                client process.                                          */
    /*                                                                         */
    /* accepts: STAFServiceInterfaceLevel30 request information                */
    /*                                                                         */
    /* returns: STAFResult.rc = STAFResult.Ok, if successful; STAFResult.      */
    /*          InvalidRequestString, if unsuccessful;                         */
    /*                                                                         */
    /*          STAFResult.result contains the result returned by the called   */
    /*          method, if successful;                                         */
    /*          STAFResult.result contains the command, if unsuccessful        */
    /***************************************************************************/
    public STAFResult acceptRequest(STAFServiceInterfaceLevel30.RequestInfo info)
    {
        String resolveString;
        String lowerRequest = info.request.toLowerCase();

        // call the appropriate method to handle the command
        if (lowerRequest.startsWith("register"))
            return handleRegister(info);
        else if (lowerRequest.startsWith("generate"))
            return handleGenerate(info);
        else if (lowerRequest.startsWith("acknowledge"))
            return handleAck(info);
        else if (lowerRequest.startsWith("reset"))
            return handleReset(info);
        else if (lowerRequest.startsWith("unregister"))
            return handleUnRegister(info);
        else if (lowerRequest.startsWith("query"))
            return handleQuery(info);
        else if (lowerRequest.startsWith("list"))
            return handleList(info);
        else if (lowerRequest.startsWith("help"))
            return handleHelp(info);
        else if (lowerRequest.startsWith("version"))
            return handleVersion(info);
        else
            return new STAFResult(STAFResult.InvalidRequestString,
                                  info.request);
    }

    /***********************************************************************/
    /* serialize- object serializer that writes structured data to a file  */
    /* using the ObjectOutputStream.writeObject method().                  */
    /*                                                                     */
    /* accepts: the file name.                                             */
    /* returns: void.                                                      */
    /***********************************************************************/

    synchronized private void serialize(String theFileName)
    {
        try
        {
            if (theFileName == null) theFileName = fRegManagerFileName;

            if (theFileName.equals(fRegManagerFileName))
            {
                ObjectOutputStream out = new ObjectOutputStream(
                                         new FileOutputStream(theFileName));
                out.writeObject(fRegManager);
                out.close();
            }
            else fGenManager.serialize();
        }
        catch(Exception e)
        {
           if (DEBUG) e.printStackTrace();
        }
    }

    /***********************************************************************/
    /* deSerialize- object deSerializer that reads fGenManager.fEventID    */
    /* from a file using the ObjectInputStream.readObject method().        */
    /*                                                                     */
    /* accepts: the file name.                                             */
    /* returns: void.                                                      */
    /***********************************************************************/

    synchronized private void deSerialize(String theFileName)
    {
        try
        {
            ObjectInputStream in = new ObjectInputStream(
                                   new FileInputStream(theFileName));

            if (theFileName == null) theFileName = fRegManagerFileName;

            if (theFileName.equals(fRegManagerFileName))
                fRegManager = (RegistrationManager)in.readObject();
            else
                fGenManager.deSerialize();
        }
        catch(Exception e)
        {
            if (theFileName.equals(fRegManagerFileName))
                fRegManager = new RegistrationManager();

            if (DEBUG) e.printStackTrace();
        }
    }


    // Register error codes for the Event Service with the HELP service

    private void registerHelpData(int errorNumber, String info,
                                 String description)
    {
        STAFResult res = fHandle.submit2("local", "HELP",
                         "REGISTER SERVICE " + fServiceName +
                         " ERROR " + errorNumber +
                         " INFO " + STAFUtil.wrapData(info) +
                         " DESCRIPTION " + STAFUtil.wrapData(description));
    }

    // Un-register error codes for the Event Service with the HELP service

    private void unregisterHelpData(int errorNumber)
    {
        STAFResult res = fHandle.submit2("local", "HELP",
                         "UNREGISTER SERVICE " + fServiceName +
                         " ERROR " + errorNumber);
    }
    
    /***************************************************************************/
    /* getRegClientMap - Returns a map containing the information for an entry */
    /*                   in a LIST REGISTRATIONS request                       */
    /*                   (Called by the handleList method)                     */
    /*                                                                         */
    /* accepts: the event type, event subtype, client, and whether long format */
    /*          was specified                                                  */
    /*                                                                         */
    /* returns: a Map to be added to the marshalled list of registrations      */
    /***************************************************************************/

    private Map getRegClientMap(String type, String subtype, Client client,
                                boolean longFormat)
    {
        if (!longFormat)
        {
            // Short format for LIST REGISTRATIONS request

            Map regClientMap = fListRegMapClass.createInstance();
            Map clientMap = client.getClientMap(fListRegLongMapClass);

            regClientMap.put("type", type);
            regClientMap.put("subtype", subtype);
            regClientMap.put("machine", clientMap.get("machine"));
            regClientMap.put("notifyBy", clientMap.get("notifyBy"));
            regClientMap.put("notifiee", clientMap.get("notifiee"));

            return regClientMap;
        }
        else
        {
            // Long format for LIST REGISTRATIONS request

            Map regClientMap = fListRegLongMapClass.createInstance();
            Map clientMap = client.getClientMap(fListRegLongMapClass);

            regClientMap.putAll(clientMap);
            regClientMap.put("type", type);
            regClientMap.put("subtype", subtype);

            return regClientMap;
        }
    }

    /***************************************************************************/
    /* handleRegister - calls fRegManager.registerClient() to register a       */
    /*                  process for future notification when events occur.     */
    /*                                                                         */
    /* accepts: STAFServiceInterfaceLevel30 request information                */
    /*          (including the submitting machine name, the submitting process,*/
    /*          the submitting process handle, a string containing any command */
    /*          options & option values).                                      */
    /*                                                                         */
    /* returns: if successful, STAFResult.rc = STAFResult.Ok (0);              */
    /*                         STAFResult.result is empty;                     */
    /*          if unsuccessful, STAFResult.rc   = error code > 0;             */
    /*                           STAFResult.result contains message            */
    /*                           correspond to error code in STAFResult.rc     */
    /***************************************************************************/

    private STAFResult handleRegister(
        STAFServiceInterfaceLevel30.RequestInfo info)
    {

        String type = "";
        String subtype = "";

        // Set to default values for the service
        int maxAttempts = fMaxAttempts;
        int timeout = fAckTimeout;
        int priority = fPriority;
        int priorityDelta = fPriorityDelta;

        STAFResult sResult = new STAFResult(STAFResult.Ok, "");
        STAFResult resolvedResult = null;
        STAFResult resolvedValue = null;

        try
        {
            // Verify the requesting machine/user has at least trust level 3

            STAFResult trustResult = STAFUtil.validateTrust(
                3, fServiceName, "REGISTER", fLocalMachineName, info);

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

            // Parse the request

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

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

            resolvedValue = STAFUtil.resolveRequestVar(
                parsedRequest.optionValue("type"), fHandle, info.requestNumber);

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

            type = resolvedValue.result;

            if (parsedRequest.optionTimes("maxAttempts") > 0)
            {
                resolvedResult = STAFUtil.resolveRequestVarAndCheckInt(
                    "maxAttempts", parsedRequest.optionValue("maxAttempts"),
                    fHandle, info.requestNumber);

                if (resolvedResult.rc != 0) return resolvedResult;

                maxAttempts = Integer.parseInt(resolvedResult.result);
            }

            if (parsedRequest.optionTimes("acknowledgeTimeout") > 0)
            {
                resolvedResult = STAFUtil.resolveRequestVarAndCheckInt(
                    "acknowledgeTimeout",
                    parsedRequest.optionValue("acknowledgeTimeout"),
                    fHandle, info.requestNumber);