stafperlservicehelper.xs

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

    // Note: The request type has already been read
    unsigned int totalLength = connection->readUInt();
    STAFBuffer<char> buffer(new char[totalLength], STAFBuffer<char>::INIT,
                            STAFBuffer<char>::ARRAY);
    unsigned int *uintBuffer = reinterpret_cast<unsigned int *>((char *)buffer);

    // IMPORTANT:  Increase the numFields value if add a field to the
    //             ServiceRequest class for a new STAFServiceInterfaceLevel.
    //             Note:  This value is 2 less than the numFields value in
    //                    STAFPerlService.cpp.

    unsigned int numFields = 14;  // # of fields in buffer

    // uintBuffer[0] = Service name length
    // uintBuffer[1] = Handle
    // uintBuffer[2] = Trust level
    // uintBuffer[3] = Machine length
    // uintBuffer[4] = Machine Nickname length
    // uintBuffer[5] = Handle name length
    // uintBuffer[6] = Request length
    // uintBuffer[7] = Diagnostics Enabled Flag
    // uinrBuffer[8] = Request Number
    // uintBuffer[9] = userLength;
    // uintBuffer[10] = endpointLength;
    // uintBuffer[11] = STAF Instance UUID length
    // uintBuffer[12] = Is Local Request Flag
    // uintBuffer[13] = Physical Interface ID length
    
    connection->read(buffer, totalLength);
    
    char *serviceNameBuffer = buffer + (numFields * sizeof(unsigned int));
    char *machineBuffer = serviceNameBuffer + uintBuffer[0];
    char *machineNicknameBuffer = machineBuffer +  uintBuffer[3];
    char *handleNameBuffer = machineNicknameBuffer + uintBuffer[4];
    char *requestBuffer = handleNameBuffer + uintBuffer[5];
    char *userBuffer = requestBuffer + uintBuffer[6];
    char *endpointBuffer = userBuffer + uintBuffer[9];
    char *stafInstanceUUIDBuffer = endpointBuffer + uintBuffer[10];
    char *physicalInterfaceIDBuffer = stafInstanceUUIDBuffer + uintBuffer[11];

    if (serviceNameBuffer == 0 || machineBuffer == 0 ||
        machineNicknameBuffer == 0 || handleNameBuffer == 0 ||
        requestBuffer == 0 || userBuffer == 0 || 
        endpointBuffer == 0 || stafInstanceUUIDBuffer == 0 ||
        physicalInterfaceIDBuffer == 0)
    {
        cout << "Memory allocation failure in "
             << "PLSTAFSH.HandleServiceRequest()" << endl;
        /* XXX: Shouldn't be a kSTAFJavaError - it's a Perl error */
        connection->writeUInt(kSTAFJavaError);
        connection->writeString("Memory allocation failure in "
                                "PLSTAFSH.HandleServiceRequest");
        return;
    }

    STAFString serviceName(serviceNameBuffer, uintBuffer[0], STAFString::kCurrent);
    unsigned int handle = uintBuffer[1];
    unsigned int trustLevel = uintBuffer[2];
    STAFString machine(machineBuffer, uintBuffer[3], STAFString::kCurrent);
    STAFString machineNickname(machineNicknameBuffer, uintBuffer[4],
                                STAFString::kCurrent);
    STAFString handleName(handleNameBuffer, uintBuffer[5], STAFString::kCurrent);
    STAFString request(requestBuffer, uintBuffer[6], STAFString::kCurrent);
    unsigned int diagEnabled = uintBuffer[7];
    unsigned int requestNumber = uintBuffer[8];
    STAFString user(userBuffer, uintBuffer[9], STAFString::kCurrent);
    STAFString endpoint(endpointBuffer, uintBuffer[10], STAFString::kCurrent);
    STAFString stafInstanceUUID(stafInstanceUUIDBuffer, uintBuffer[11],
                                STAFString::kCurrent);
    unsigned int isLocalRequest = uintBuffer[12];
    STAFString physicalInterfaceID(physicalInterfaceIDBuffer, uintBuffer[13],
                                   STAFString::kCurrent);
    
    /*cout << "Debug: " << endl;
    cout << "Total length         : " << totalLength << endl
         << "Service name         : " << serviceName << endl
         << "Machine              : " << machine << endl
         << "Machine nickname     : " << machineNickname << endl
         << "Handle name length   : " << uintBuffer[5] << endl
         << "Handle name          : " << handleName << endl
         << "Handle               : " << handle << endl
         << "Trust level          : " << trustLevel << endl
         << "Request length       : " << uintBuffer[6] << endl
         << "Request              : " << request << endl
         << "Diag enabled         : " << diagEnabled << endl
         << "User                 : " << user << endl
         << "Endpoint             : " << endpoint << endl
         << "STAF Instance UUID   : " << stafInstanceUUID << endl
         << "Local request        : " << isLocalRequest << endl
         << "Physical Interface ID: " << physicalInterfaceID << endl;

    cout << endl << "Buffer: " << endl;

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

    cout << endl; */

    PerlServiceRequestDataPtr reqData = PerlServiceRequestDataPtr(new PerlServiceRequestData(),
                                              PerlServiceRequestDataPtr::INIT);

    {
        STAFMutexSemLock lock(gReqCountMutex);
        reqData->fReqNum = reqCount++;
    }
    reqData->fReqType = PERL_SERVICE_ACCEPT_REQUEST;
    reqData->fServiceName = serviceName;
    reqData->fMachine = machine;
    reqData->fMachineNickname = machineNickname;
    reqData->fHandleName = handleName;
    reqData->fHandle = handle;
    reqData->fTrustLevel = trustLevel;
    reqData->fRequest = request;
    reqData->fDiagEnabled = diagEnabled;
    reqData->fUser = user;
    reqData->fEndpoint = endpoint;
    reqData->fSTAFInstanceUUID = stafInstanceUUID;
    reqData->fIsLocalRequest = isLocalRequest;
    reqData->fConnPtr = connection;

    {
        STAFMutexSemLock lock(gRequestQueueMutex);
        requestQueue.push(reqData);
    }
}


void HandleServiceTerm(STAFConnectionPtr &connection)
{
    STAFString serviceName = connection->readString();

    PerlServiceRequestDataPtr reqData = PerlServiceRequestDataPtr(new PerlServiceRequestData(),
                                              PerlServiceRequestDataPtr::INIT);
    
    {
        STAFMutexSemLock lock(gReqCountMutex);
        reqData->fReqNum = reqCount++;
    }
    reqData->fReqType = PERL_SERVICE_TERM;
    reqData->fServiceName = serviceName;
    reqData->fConnPtr = connection;

    {
        STAFMutexSemLock lock(gRequestQueueMutex);
        requestQueue.push(reqData);
    }
}

MODULE = STAFPerlServiceHelper     PACKAGE = STAFPerlServiceHelper

HV *
getRequest()
PREINIT:
// this method is called by perl code.it gets a request off the queue, 
// puts it into a map for later use and returns the request to perl
    HV* hash;
    PerlServiceRequestDataPtr reqData = PerlServiceRequestDataPtr(new PerlServiceRequestData(),
                                              PerlServiceRequestDataPtr::INIT);
CODE:    
    // wait until something is in the queue
    if(requestQueue.size() == 0)
    {
        gReceivedRequestSem.wait();
    }
    
    // get the first item off the queue
    {
        STAFMutexSemLock lock(gRequestQueueMutex);
        //XXX: HACK HACK HACK until someone figures out why this crashes,
        // these next two lines make the problem harder
        // to reproduce
        unsigned int *rc = 0;
        STAFThreadSleepCurrentThread(3, rc);
        reqData = requestQueue.front();
        requestQueue.pop();
        gReceivedRequestSem.reset();
    }
    
    hash = newHV();

    /* copy struct contents into hash */
    hv_store(hash, "reqNum", STAFString("reqNum").length(), newSVuv(reqData->fReqNum), 0);
    hv_store(hash, "serviceName", STAFString("serviceName").length(), 
             newSVpv(reqData->fServiceName.buffer(), reqData->fServiceName.length()), 0);
    hv_store(hash, "execInfo", STAFString("execInfo").length(), 
             newSVpv(reqData->fExecInfo.buffer(), reqData->fExecInfo.length()), 0);
    hv_store(hash, "writeLocation", STAFString("writeLocation").length(), 
             newSVpv(reqData->fWriteLocation.buffer(), reqData->fWriteLocation.length()), 0);
    hv_store(hash, "parms", STAFString("parms").length(), 
             newSVpv(reqData->fParms.buffer(), reqData->fParms.length()), 0);
    hv_store(hash, "machine", STAFString("machine").length(), 
             newSVpv(reqData->fMachine.buffer(), reqData->fMachine.length()), 0);
    hv_store(hash, "machineNickname", STAFString("machineNickname").length(), 
             newSVpv(reqData->fMachineNickname.buffer(), reqData->fMachineNickname.length()), 0);
    hv_store(hash, "handleName", STAFString("handleName").length(), 
             newSVpv(reqData->fHandleName.buffer(), reqData->fHandleName.length()), 0);
    hv_store(hash, "request", STAFString("request").length(), 
             newSVpv(reqData->fRequest.buffer(), reqData->fRequest.length()), 0);
    hv_store(hash, "reqType", STAFString("reqType").length(), newSVuv(reqData->fReqType), 0);
    hv_store(hash, "handle", STAFString("handle").length(), newSVuv(reqData->fHandle), 0);
    hv_store(hash, "trustLevel", STAFString("trustLevel").length(), newSVuv(reqData->fTrustLevel), 0);
    hv_store(hash, "diagEnabled", STAFString("diagEnabled").length(), newSVuv(reqData->fDiagEnabled), 0);
    hv_store(hash, "user", STAFString("user").length(), 
             newSVpv(reqData->fUser.buffer(), reqData->fUser.length()), 0);
    hv_store(hash, "endpoint", STAFString("endpoint").length(), 
             newSVpv(reqData->fEndpoint.buffer(), reqData->fEndpoint.length()), 0);
    hv_store(hash, "stafInstanceUUID", STAFString("stafInstanceUUID").length(), 
             newSVpv(reqData->fSTAFInstanceUUID.buffer(), reqData->fSTAFInstanceUUID.length()), 0);
    hv_store(hash, "isLocalRequest", STAFString("isLocalRequest").length(),
             newSVuv(reqData->fIsLocalRequest), 0);
    
    // add reqData to the requestMap for future use
    {
        STAFMutexSemLock lock(gRequestMapMutex);
        requestMap[reqData->fReqNum] = reqData;
    }
    
    RETVAL = hash;
OUTPUT:
    RETVAL

void
initConnection(serviceName)
char* serviceName
CODE:
// this method is called from perl.  It sets up an inbound connection and tells
// the connection to pass all traffic to handleRequest().  See initConnection()
// above for details.

    // call initConnection above
    initConnection(serviceName); 

void
sendResults(reqNum, rc, result)
unsigned int reqNum
unsigned int rc
char* result
PREINIT:
// this is called by perl code.  It uses the connection pointer from request
// number 'reqNum' and sends the results back to STAFPerlService.cpp  It 
// also deletes the request from the map once it is done.
    PerlServiceRequestDataPtr reqData;
CODE:
    
    {
        STAFMutexSemLock lock(gRequestMapMutex);
        reqData = requestMap[reqNum];    
        requestMap.erase(reqNum);
    }
    reqData->fConnPtr->writeUInt(rc);
    reqData->fConnPtr->writeString(STAFString(result));