fsext.java

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

}

/*****************************************************************************/
/*                                                                           */
/* Method: registerHelp                                                      */
/* Description: registers all FSEXT return codes with the HELP service       */
/* Parameters: serviceName - name which this service is registered as        */
/* Returns: int representation of STAFResult                                 */
/*                                                                           */
/*****************************************************************************/

private int registerHelp(String serviceName)
{
    try
    {
        String request = "REGISTER SERVICE "+serviceName+" ERROR "+COMPAREFAIL+
          " INFO "+COMPAREFAILInfo+" DESCRIPTION "+COMPAREFAILDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+NOTDIRECTORY+
          " INFO "+NOTDIRECTORYInfo+" DESCRIPTION "+NOTDIRECTORYDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+FILENOTFOUND+
          " INFO "+FILENOTFOUNDInfo+" DESCRIPTION "+FILENOTFOUNDDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+FILEEXISTS+
          " INFO "+FILEEXISTSInfo+" DESCRIPTION "+FILEEXISTSDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+EXTRAFILES+
          " INFO "+EXTRAFILESInfo+" DESCRIPTION "+EXTRAFILESDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+STRINGNOTFOUND+
          " INFO "+STRINGNOTFOUNDInfo+" DESCRIPTION "+STRINGNOTFOUNDDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+STRINGFOUND+
          " INFO "+STRINGFOUNDInfo+" DESCRIPTION "+STRINGFOUNDDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+LINEDOESNOTEXIST+
          " INFO "+LINEDOESNOTEXISTInfo+" DESCRIPTION "+LINEDOESNOTEXISTDesc;
        sHandle.submit("local", "HELP", request);

        request = "REGISTER SERVICE "+serviceName+" ERROR "+IOERROR+
          " INFO "+IOERRORInfo+" DESCRIPTION "+IOERRORDesc;
        sHandle.submit("local", "HELP", request);

    }
    catch(STAFException se)
    {
        return se.rc;
    }

    return STAFResult.Ok;

}

/*****************************************************************************/
/*                                                                           */
/* Method: substitute                                                        */
/* Description: performs substitute service function                         */
/* Parameters: info - RequestInfo passed to acceptRequest                    */
/* Returns: STAFResult                                                       */
/*                                                                           */
/*****************************************************************************/

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

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

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

    /* Parse request string */

    STAFCommandParseResult pResult = substituteParser.parse(info.request);

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

    /* Get source file */

    STAFResult res = STAFUtil.resolveRequestVar(
        pResult.optionValue(FILE), sHandle, info.requestNumber);

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

    String inputFile = res.result;

    /* Read file and resolve VARS then write out to tempFile */

    BufferedReader in = null;
    BufferedWriter out = null;
    File tempFile = null;

    try
    {
        tempFile = File.createTempFile("fsext", null);
        in = new BufferedReader(new FileReader(inputFile));
        out = new BufferedWriter(new FileWriter(tempFile));

        while(true)
        {
            //outside loop to parse file line by line

            String line = in.readLine();

            if (line == null)
            {
                //end of file

                break;
            }

            while(true)
            {
                //inside loop to resolve multiple vars per line
                int beginIndex = line.indexOf("%{");

                if (beginIndex == -1)
                {
                    //no vars to resolve

                    break;
                }

                int endIndex = line.indexOf("}%", beginIndex);
                String varToResolve = line.substring(beginIndex+1, endIndex+1);
                String resolvedVar;

                // Resolve using resolve request

                resolvedVar = sHandle.submit(
                    "local", "VAR", "RESOLVE REQUEST " +
                    String.valueOf(info.requestNumber) + " STRING " +
                    varToResolve);
                
                StringBuffer modString = new StringBuffer(line);
                modString = modString.replace(beginIndex, endIndex+2,
                    resolvedVar);
                line = modString.toString();
            }

            out.write(line);
            out.newLine();
        }
    }
    catch(STAFException se)
    {
        return new STAFResult(se.rc, se.getMessage());
    }
    catch(IOException ioe)
    {
        return new STAFResult(IOERROR, ioe.getMessage());
    }
    finally
    {
        try
        {
            out.close();
            in.close();
        }
        catch(Exception e) {} //don't care
    }

    // Resolve variables that will be required to call FS & generate FS request
    // string

    StringBuffer fsReq = new StringBuffer("COPY FILE "+tempFile.getPath());
    boolean toFileSet = false;

    if ((pResult.optionTimes(TOFILE)) == 1)
    {
        fsReq.append(" TOFILE "+pResult.optionValue(TOFILE));
        toFileSet = true;
    }

    if ((pResult.optionTimes(TOMACHINE)) == 1)
    {
        fsReq.append(" TOMACHINE "+pResult.optionValue(TOMACHINE));
        toFileSet = true;
    }

    if (!toFileSet)
    {
        fsReq.append(" TOFILE "+inputFile);
    }

    if ((pResult.optionTimes(FAILIFEXISTS)) == 1)
    {
        fsReq.append(" FAILIFEXISTS");
    }

    if ((pResult.optionTimes(FAILIFNEW)) == 1)
    {
        fsReq.append(" FAILIFNEW");
    }

    /* Send STAF FS Command */

    try
    {
        String result = sHandle.submit("local", "FS", fsReq.toString());
        return new STAFResult(STAFResult.Ok, result);
    }
    catch(STAFException se)
    {
        return new STAFResult(se.rc, se.getMessage());
    }
    finally
    {
        tempFile.delete();
    }
}

/*****************************************************************************/
/*                                                                           */
/* Method: term                                                              */
/* Description: required by interface STAFServiceInterfaceLevel30            */
/*                                                                           */
/*****************************************************************************/

public STAFResult term()
{
    // Un-register the service handle

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

    return new STAFResult(STAFResult.Ok);
}

/*****************************************************************************/
/*                                                                           */
/* Method: version                                                           */
/* Description: returns service version information                          */
/* Parameters: none                                                          */
/* Returns: STAFResult.OK                                                    */
/*                                                                           */
/*****************************************************************************/

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;

    // Return the service's version
    
    return new STAFResult(STAFResult.Ok, FSEXTVERSION);
}

/*****************************************************************************/
/*                                                                           */
/* Method: waitForFile                                                       */
/* Description: performs waitForFile service function                        */
/* Parameters: info - RequestInfo passed to acceptRequest                    */
/* Returns: STAFResult                                                       */
/*                                                                           */
/*****************************************************************************/

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

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

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

    /* Parse request string */

    STAFCommandParseResult pResult = waitForFileParser.parse(info.request);

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

    /* Parse FILE, POLL, & TIMEOUT parameters */

    File file;
    String poll = "15000"; //default value
    long timeout =
        Long.MAX_VALUE; // set to max value, for default infinite (almost) wait

    try
    {
        STAFResult res = STAFUtil.resolveRequestVar(
            pResult.optionValue(FILE), sHandle, info.requestNumber);

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

        String filename = res.result;
        file = new File(filename);

        if (pResult.optionTimes(TIMEOUT) == 1)
        {   
            res = STAFUtil.resolveRequestVar(
                pResult.optionValue(TIMEOUT), sHandle, info.requestNumber);

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

            timeout = Long.parseLong(res.result);
        }
        if (pResult.optionTimes(POLL) == 1)
        {
            res = STAFUtil.resolveRequestVarAndCheckInt(
                POLL, pResult.optionValue(POLL), sHandle, info.requestNumber);

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

            poll = res.result;
        }
    }
    catch(NumberFormatException nfe)
    {
        return new STAFResult(STAFResult.InvalidValue, nfe.toString());
    }

    /* Get not parameter */

    boolean not = false;

    if (pResult.optionTimes(NOT) == 1)
    {
        not = true;
    }

    /* Get starting time */

    long start = (new Date()).getTime();
    Date current;

    /* Perform appropriate file check, if failed wait POLL ms and try again */
    /* Quit after TIMEOUT ms has passed */

    do
    {
        if ((file.exists() && !not) || (!file.exists() && not))
        {
            return new STAFResult(STAFResult.Ok);
        }

        sHandle.submit2("local", "DELAY", "DELAY "+poll);
        current = new Date();

    }
    while ((current.getTime() - start) < timeout);

    /* If we get here timed out without finding file */

    if (not)
    {
        return new STAFResult(FILEEXISTS, file.getPath());
    }
    else
    {
        return new STAFResult(FILENOTFOUND, file.getPath());
    }

}
}