stafjavaservice.cpp

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

        STAFShutdownJVM(jvmName);

    return kSTAFUnknownError;
}

STAFRC_t STAFServiceDestruct(STAFServiceHandle_t *serviceHandle,
                             void *pDestructInfo,
                             unsigned int destructLevel,
                             STAFString_t *pErrorBuffer)
{
    if (destructLevel != 0) return kSTAFInvalidAPILevel;

    STAFProcJavaServiceData *pData =
        static_cast<STAFProcJavaServiceData *>(*serviceHandle);

    try
    {
        STAFMutexSemLock lock(sJVMDataSem);

        // Debug: cout << "Destructing service: " << pData->fName << endl;
        // Debug: cout << "Service pData->fJVM: " << pData->fJVM << endl;
        // Debug: cout << "Service JVMName: " << pData->fJVM->fName << endl;

        if (--pData->fJVM->fNumServices == 0)
            STAFShutdownJVM(pData->fJVM->fName);

        delete pData;
        *serviceHandle = 0;

        return kSTAFOk;
    }
    catch (STAFException &e)
    {
        STAFString error = STAFString(
            "JSTAF.STAFServiceDestruct(), Service: ") + pData->fName;

        e.trace(error.toCurrentCodePage()->buffer());
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in JSTAF.STAFServiceDestruct() while "
            "destructing service " + pData->fName);
    }

    return kSTAFUnknownError;
}


STAFRC_t STAFServiceInit(STAFServiceHandle_t serviceHandle,
                         void *pInitInfo, unsigned int initLevel,
                         STAFString_t *pErrorBuffer)
{
    if (initLevel != 30) return kSTAFInvalidAPILevel;

    STAFProcJavaServiceData *pData =
        static_cast<STAFProcJavaServiceData *>(serviceHandle);

    try
    {
        STAFServiceInitLevel30 *pInfo =
            static_cast<STAFServiceInitLevel30 *>(pInitInfo);
        STAFConnectionPtr connPtr = pData->fJVM->fConnProv->connect(sLocal);

        connPtr->writeUInt(JAVA_SERVICE_INIT);
        connPtr->writeString(pData->fName);
        connPtr->writeString(pInfo->parms);
        connPtr->writeString(pInfo->writeLocation);

        unsigned int initRC = connPtr->readUInt();
        STAFString initResult = connPtr->readString();

        if (initRC != kSTAFOk)
        {
            *pErrorBuffer = initResult.adoptImpl();
            return initRC;
        }

        return kSTAFOk;
    }
    catch (STAFException &e)
    {
        STAFString error = STAFString("JSTAF.STAFServiceInit(), Service: ") +
            pData->fName;

        e.trace(error.toCurrentCodePage()->buffer());
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in JSTAF.STAFServiceInit() "
            "while initializing service: " + pData->fName);
    }

    return kSTAFUnknownError;
}

STAFRC_t STAFServiceTerm(STAFServiceHandle_t serviceHandle,
                         void *pTermInfo, unsigned int termLevel,
                         STAFString_t *pErrorBuffer)
{
    if (termLevel != 0) return kSTAFInvalidAPILevel;
    
    STAFProcJavaServiceData *pData =
        static_cast<STAFProcJavaServiceData *>(serviceHandle);

    try
    {
        STAFConnectionPtr connPtr = pData->fJVM->fConnProv->connect(sLocal);

        connPtr->writeUInt(JAVA_SERVICE_TERM);
        connPtr->writeString(pData->fName);

        unsigned int termRC = connPtr->readUInt();
        STAFString termResult = connPtr->readString();

        if (termRC != kSTAFOk)
        {
            *pErrorBuffer = termResult.adoptImpl();
            return termRC;
        }

        return kSTAFOk;
    }
    catch (STAFException &e)
    {
        STAFString error = STAFString("JSTAF.STAFServiceTerm(), Service: ") +
            pData->fName;

        e.trace(error.toCurrentCodePage()->buffer());
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in JSTAF.STAFServiceTerm() "
            "while terminating service: " + pData->fName);
    }

    return kSTAFUnknownError;
}


STAFRC_t STAFServiceAcceptRequest(STAFServiceHandle_t serviceHandle,
                                  void *pRequestInfo, unsigned int reqLevel,
                                  STAFString_t *pResultBuffer)
{
    if (reqLevel != 30) return kSTAFInvalidAPILevel;

    STAFProcJavaServiceData *pData =
        static_cast<STAFProcJavaServiceData *>(serviceHandle);
    STAFServiceRequestLevel30 *pInfo =
        static_cast<STAFServiceRequestLevel30 *>(pRequestInfo);

    try
    {
        STAFConnectionPtr connPtr = pData->fJVM->fConnProv->connect(sLocal);

        unsigned int  machineLength             = 0;
        const char   *machineBuffer             = 0;
        unsigned int  machineNicknameLength     = 0;
        const char   *machineNicknameBuffer     = 0;
        unsigned int  handleNameLength          = 0;
        const char   *handleNameBuffer          = 0;
        unsigned int  requestLength             = 0;
        const char   *requestBuffer             = 0;
        unsigned int  userLength                = 0;
        const char   *userBuffer                = 0;
        unsigned int  endpointLength            = 0;
        const char   *endpointBuffer            = 0;
        unsigned int  stafInstanceUUIDLength    = 0;
        const char   *stafInstanceUUIDBuffer    = 0;
        unsigned int  physicalInterfaceIDLength  = 0;
        const char   *physicalInterfaceIDBuffer  = 0;


        STAFStringGetBuffer(pInfo->machine, &machineBuffer,
                            &machineLength, 0);
        STAFStringGetBuffer(pInfo->machineNickname, &machineNicknameBuffer,
                            &machineNicknameLength, 0);
        STAFStringGetBuffer(pInfo->handleName, &handleNameBuffer,
                            &handleNameLength, 0);
        STAFStringGetBuffer(pInfo->request, &requestBuffer,
                            &requestLength, 0);
        STAFStringGetBuffer(pInfo->user, &userBuffer, &userLength, 0);
        STAFStringGetBuffer(pInfo->endpoint, &endpointBuffer,
                            &endpointLength, 0);
        STAFStringGetBuffer(pInfo->stafInstanceUUID, &stafInstanceUUIDBuffer,
                            &stafInstanceUUIDLength, 0);
        STAFStringGetBuffer(pInfo->physicalInterfaceID,
                            &physicalInterfaceIDBuffer,
                            &physicalInterfaceIDLength, 0);

        // IMPORTANT:  Increase the numFields value if add a field to the
        // ServiceRequest class for a new STAFServiceInterfaceLevel.

        unsigned int numFields = 16;

        unsigned int bufferLength = (numFields * sizeof(unsigned int)) +
            pData->fName.length() + machineLength + machineNicknameLength +
            handleNameLength + requestLength + userLength +
            endpointLength + stafInstanceUUIDLength +
            physicalInterfaceIDLength;

        STAFBuffer<char> buffer(new char[bufferLength], STAFBuffer<char>::INIT,
                                STAFBuffer<char>::ARRAY);
        unsigned int *uintBuffer = 
                     reinterpret_cast<unsigned int *>((char *)buffer);

        uintBuffer[0] = 
            STAFUtilConvertNativeUIntToLE(JAVA_SERVICE_ACCEPT_REQUEST);
        uintBuffer[1] = STAFUtilConvertNativeUIntToLE(
            bufferLength - (2 * sizeof(unsigned int)));
        uintBuffer[2] = pData->fName.length();
        uintBuffer[3] = pInfo->handle;
        uintBuffer[4] = pInfo->trustLevel;
        uintBuffer[5] = machineLength;
        uintBuffer[6] = machineNicknameLength;
        uintBuffer[7] = handleNameLength;
        uintBuffer[8] = requestLength;
        uintBuffer[9] = pInfo->diagEnabled;
        uintBuffer[10] = pInfo->requestNumber;
        uintBuffer[11] = userLength;
        uintBuffer[12] = endpointLength;
        uintBuffer[13] = stafInstanceUUIDLength;
        uintBuffer[14] = pInfo->isLocalRequest;
        uintBuffer[15] = physicalInterfaceIDLength;
        
        char *currBuffer = buffer + (numFields * sizeof(unsigned int));

        memcpy(currBuffer, pData->fName.buffer(), pData->fName.length());
        currBuffer += pData->fName.length();
        memcpy(currBuffer, machineBuffer, machineLength);
        currBuffer += machineLength;
        memcpy(currBuffer, machineNicknameBuffer, machineNicknameLength);
        currBuffer += machineNicknameLength;
        memcpy(currBuffer, handleNameBuffer, handleNameLength);
        currBuffer += handleNameLength;
        memcpy(currBuffer, requestBuffer, requestLength);
        currBuffer += requestLength;
        memcpy(currBuffer, userBuffer, userLength);
        currBuffer += userLength;
        memcpy(currBuffer, endpointBuffer, endpointLength);
        currBuffer += endpointLength;
        memcpy(currBuffer, stafInstanceUUIDBuffer, stafInstanceUUIDLength);
        currBuffer += stafInstanceUUIDLength;
        memcpy(currBuffer, physicalInterfaceIDBuffer,
               physicalInterfaceIDLength);
        currBuffer += physicalInterfaceIDLength;
        
        /* Debug:
        cout << "Buffer length: " << bufferLength << endl;
        cout << endl << "Buffer: " << endl;

        for (unsigned int i = 0; i < (bufferLength - 8); ++i)
        {
            if ((i != 0) && (i % 24 == 0)) cout << endl;
            unsigned int currChar = buffer[i + 8];
            if (currChar < 16) cout << "0";
            cout << hex << currChar << dec << " ";
        }

        cout << endl;
        */

        connPtr->write(buffer, bufferLength);

        unsigned int reqRC = connPtr->readUInt();
        STAFString reqResult = connPtr->readString();

        *pResultBuffer = reqResult.adoptImpl();
        return reqRC;
    }
    catch (STAFException &e)
    {
        STAFString error = STAFString("JSTAF.STAFServiceAcceptRequest()") +
            ", Endpoint: " + pInfo->endpoint +
            ", Service: " + pData->fName +
            ", Request: " + pInfo->request;
        
        try
        {
            e.trace(error.toCurrentCodePage()->buffer());
        }
        catch (...)
        {
            e.write(error.toCurrentCodePage()->buffer());
        }
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            STAFString("Caught unknown exception in ") +
            "JSTAF.STAFServiceAcceptRequest(), Endpoint: " + pInfo->endpoint +
            ", Service: " + pData->fName + ", Request: " + pInfo->request);
    }

    *pResultBuffer = STAFString().adoptImpl();

    return kSTAFUnknownError;
}