stafperlservice.cpp

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

        connPtr->writeUInt(pInfo->serviceType);

        unsigned int constructRC = connPtr->readUInt();
        STAFString constructResult = connPtr->readString();

        if (constructRC != kSTAFOk)
        {
            if (data.fPerlInterpreter->fNumServices == 0)
                STAFShutdownPerlInterpreter(perlServiceName);

            *pErrorBuffer = constructResult.adoptImpl();
            return constructRC;
        }

        // The service is now loaded

        STAFProcPerlServiceData *pService = new STAFProcPerlServiceData(data);

        *pServiceHandle = pService;
        ++pService->fPerlInterpreter->fNumServices;

        return kSTAFOk;
    }
    catch (STAFException &e)
    {
        e.trace("PLSTAF.STAFServiceConstruct()"); // Should do something here
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in PLSTAF.STAFServiceConstruct()");
    }

    return kSTAFUnknownError;
}

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

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

        STAFMutexSemLock lock(sPerlInterpreterDataSem);

        if (--pData->fPerlInterpreter->fNumServices == 0)
            STAFShutdownPerlInterpreter(pData->fPerlInterpreter->fName);

        delete pData;
        *serviceHandle = 0;

        return kSTAFOk;
    }
    catch (STAFException &e)
    {
        e.trace("PLSTAF.STAFServiceDestruct()");
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in PLSTAF.STAFServiceDestruct()");
    }

    return kSTAFUnknownError;
}


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

        STAFProcPerlServiceData *pData =
            static_cast<STAFProcPerlServiceData *>(serviceHandle);
        STAFServiceInitLevel30 *pInfo =
            static_cast<STAFServiceInitLevel30 *>(pInitInfo);
        STAFConnectionPtr connPtr =
            pData->fPerlInterpreter->fConnProv->connect(sLocal);

        connPtr->writeUInt(PERL_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)
    {
        e.trace("PLSTAF.STAFServiceInit()");
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in PLSTAF.STAFServiceInit()");
    }

    return kSTAFUnknownError;
}

STAFRC_t STAFServiceTerm(STAFServiceHandle_t serviceHandle,
                         void *pTermInfo, unsigned int termLevel,
                         STAFString_t *pErrorBuffer)
{
    try
    {
        if (termLevel != 0) return kSTAFInvalidAPILevel;

        STAFProcPerlServiceData *pData =
            static_cast<STAFProcPerlServiceData *>(serviceHandle);
        STAFConnectionPtr connPtr =
            pData->fPerlInterpreter->fConnProv->connect(sLocal);

        connPtr->writeUInt(PERL_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)
    {
        e.trace("PLSTAF.STAFServiceTerm()");
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in PLSTAF.STAFServiceTerm()");
    }

    return kSTAFUnknownError;
}


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

        STAFProcPerlServiceData *pData =
            static_cast<STAFProcPerlServiceData *>(serviceHandle);
        STAFServiceRequestLevel30 *pInfo =
            static_cast<STAFServiceRequestLevel30 *>(pRequestInfo);
        STAFConnectionPtr connPtr =
            pData->fPerlInterpreter->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(PERL_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)
    {
        e.trace("PLSTAF.STAFServiceAcceptRequest");
    }
    catch (...)
    {
        STAFTrace::trace(
            kSTAFTraceError,
            "Caught unknown exception in PLSTAF.STAFServiceAcceptRequest()");
    }

    *pResultBuffer = STAFString().adoptImpl();

    return kSTAFUnknownError;
}