stafserviceservice.cpp

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

/*****************************************************************************/
/* Software Testing Automation Framework (STAF)                              */
/* (C) Copyright IBM Corp. 2001, 2005                                        */
/*                                                                           */
/* This software is licensed under the Common Public License (CPL) V1.0.     */
/*****************************************************************************/

#include "STAFOSTypes.h"
#include "STAFProc.h"
#include "STAFProcUtil.h"
#include "STAFError.h"
#include "STAFServiceService.h"
#include "STAFCommandParser.h"
#include "STAFServiceManager.h"
#include "STAFRequestManager.h"
#include "STAFExternalService.h"

// XXX: This file needs some cleanup.
//      1) Some parse results are named after the command instead of just
//         a generic name
//      2) resolveXXXIfExists isn't leveraged, so there are extra checks
//      3) Lot's of redundant empty STAFString declarations

typedef STAFRefPtr<STAFCommandParser> STAFCommandParserPtr;

STAFCommandParserPtr fListParser;
STAFCommandParserPtr fFreeParser;
STAFCommandParserPtr fQueryParser;
STAFCommandParserPtr fAddParser;
STAFCommandParserPtr fReplaceParser;
STAFCommandParserPtr fRenameParser;
STAFCommandParserPtr fRemoveParser;
STAFCommandParserPtr fHelpParser;

static STAFString sList("list");
static STAFString sQuery("query");
static STAFString sFree("free");
static STAFString sAdd("add");
static STAFString sReplace("replace");
static STAFString sRename("rename");
static STAFString sRemove("remove");
static STAFString sForce("force");
static STAFString sHelp("help");
static STAFString sServices("services");
static STAFString sServiceLoaders("serviceloaders");
static STAFString sAuthenticators("authenticators");
static STAFString sRequests("requests");
static STAFString sPending("Pending");
static STAFString sComplete("Complete");
static STAFString sStatus("status");
static STAFString sResult("result");
static STAFString sRequest("request");

static const STAFString sServiceInfoClassName =
    "STAF/Service/Service/ServiceInfo";
static const STAFString sRequestInfoClassName =
    "STAF/Service/Service/RequestInfo";
static const STAFString sPendingRequestClassName =
    "STAF/Service/Service/RequestInfo";
static const STAFString sCompleteRequestClassName =
    "STAF/Service/Service/RequestInfo";
static const STAFString sRequestInfoLongClassName =
    "STAF/Service/Service/RequestInfo";
static const STAFString sQueryRequestClassName =
    "STAF/Service/Service/QueryRequest";
static const STAFString sQueryServiceClassName =
    "STAF/Service/Service/QueryService";
static const STAFString sFreeRequestInfoClassName =
    "STAF/Service/Service/FreeRequestInfo";

STAFMapClassDefinitionPtr fServiceInfoClass;
STAFMapClassDefinitionPtr fRequestInfoClass;
STAFMapClassDefinitionPtr fPendingRequestClass;
STAFMapClassDefinitionPtr fCompleteRequestClass;
STAFMapClassDefinitionPtr fRequestInfoLongClass;
STAFMapClassDefinitionPtr fQueryRequestClass;
STAFMapClassDefinitionPtr fQueryServiceClass;
STAFMapClassDefinitionPtr fFreeRequestInfoClass;

STAFServiceService::STAFServiceService() : STAFService("SERVICE")
{

    //LIST Options
    fListParser = STAFCommandParserPtr(new STAFCommandParser,
                                       STAFCommandParserPtr::INIT);
    fListParser->addOption("LIST", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOption("SERVICES", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOption("SERVICELOADERS", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOption("AUTHENTICATORS", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOption("REQUESTS", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOptionGroup("SERVICES SERVICELOADERS AUTHENTICATORS REQUESTS", 0, 1);
    fListParser->addOption("PENDING", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOption("COMPLETE", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOption("LONG", 1,
                           STAFCommandParser::kValueNotAllowed);
    fListParser->addOptionNeed("PENDING COMPLETE LONG", "REQUESTS");

    //FREE Options
    fFreeParser = STAFCommandParserPtr(new STAFCommandParser,
                                       STAFCommandParserPtr::INIT);
    fFreeParser->addOption("FREE", 1,
                           STAFCommandParser::kValueNotAllowed);
    fFreeParser->addOption("REQUEST", 1,
                           STAFCommandParser::kValueRequired);
    fFreeParser->addOption("FORCE", 1,
                           STAFCommandParser::kValueNotAllowed);
    fFreeParser->addOptionNeed("FREE", "REQUEST");

    //QUERY Options
    fQueryParser = STAFCommandParserPtr(new STAFCommandParser,
                                        STAFCommandParserPtr::INIT);
    fQueryParser->addOption("QUERY", 1,
                           STAFCommandParser::kValueNotAllowed);
    fQueryParser->addOption("REQUEST", 1,
                           STAFCommandParser::kValueRequired);
    fQueryParser->addOption("STATUS", 1,
                           STAFCommandParser::kValueNotAllowed);
    fQueryParser->addOption("RESULT", 1,
                           STAFCommandParser::kValueNotAllowed);

    fQueryParser->addOption("SERVICE", 1,
                           STAFCommandParser::kValueRequired);
    fQueryParser->addOption("AUTHENTICATOR", 1,
                           STAFCommandParser::kValueRequired);
    fQueryParser->addOption("SERVICELOADER", 1,
                           STAFCommandParser::kValueRequired);

    fQueryParser->addOptionNeed("QUERY", "SERVICE SERVICELOADER AUTHENTICATOR REQUEST");
    fQueryParser->addOptionGroup("SERVICE SERVICELOADER AUTHENTICATOR REQUEST", 0, 1);
    fQueryParser->addOptionNeed("STATUS RESULT", "REQUEST");
    fQueryParser->addOptionGroup("STATUS RESULT", 0, 1);

    // ADD Options
    fAddParser = STAFCommandParserPtr(new STAFCommandParser,
                                      STAFCommandParserPtr::INIT);
    fAddParser->addOption("ADD", 1, STAFCommandParser::kValueNotAllowed);
    fAddParser->addOption("SERVICE", 1, STAFCommandParser::kValueRequired);
    fAddParser->addOption("LIBRARY", 1, STAFCommandParser::kValueRequired);
    fAddParser->addOption("EXECUTE", 1, STAFCommandParser::kValueRequired);
    fAddParser->addOption("OPTION", 0, STAFCommandParser::kValueRequired);
    fAddParser->addOption("PARMS", 1, STAFCommandParser::kValueRequired);
    fAddParser->addOptionNeed("ADD", "SERVICE");
    fAddParser->addOptionNeed("ADD", "LIBRARY");

    // REPLACE Options
    fReplaceParser = STAFCommandParserPtr(new STAFCommandParser,
                                          STAFCommandParserPtr::INIT);
    fReplaceParser->addOption("REPLACE", 1,
                              STAFCommandParser::kValueNotAllowed);
    fReplaceParser->addOption("SERVICE", 1, STAFCommandParser::kValueRequired);
    fReplaceParser->addOption("LIBRARY", 1, STAFCommandParser::kValueRequired);
    fReplaceParser->addOption("EXECUTE", 1, STAFCommandParser::kValueRequired);
    fReplaceParser->addOption("OPTION", 0, STAFCommandParser::kValueRequired);
    fReplaceParser->addOption("PARMS", 1, STAFCommandParser::kValueRequired);
    fReplaceParser->addOption("RENAME", 1, STAFCommandParser::kValueRequired);
    fReplaceParser->addOptionNeed("REPLACE", "SERVICE");
    fReplaceParser->addOptionNeed("REPLACE", "LIBRARY");

    // RENAME Options
    fRenameParser = STAFCommandParserPtr(new STAFCommandParser,
                                      STAFCommandParserPtr::INIT);
    fRenameParser->addOption("RENAME", 1, STAFCommandParser::kValueNotAllowed);
    fRenameParser->addOption("SERVICE", 1, STAFCommandParser::kValueRequired);
    fRenameParser->addOption("TO", 1, STAFCommandParser::kValueRequired);

    // REMOVE Options
    fRemoveParser = STAFCommandParserPtr(new STAFCommandParser,
                                         STAFCommandParserPtr::INIT);
    fRemoveParser->addOption("REMOVE", 1, STAFCommandParser::kValueNotAllowed);
    fRemoveParser->addOption("SERVICE", 1, STAFCommandParser::kValueRequired);
    fRemoveParser->addOptionNeed("REMOVE", "SERVICE");

    // HELP Options
    fHelpParser = STAFCommandParserPtr(new STAFCommandParser,
                                       STAFCommandParserPtr::INIT);
    fHelpParser->addOption("HELP", 1, STAFCommandParser::kValueNotAllowed);

    // Construct map class for list services/authenticators/serviceloaders

    fServiceInfoClass = STAFMapClassDefinition::create(sServiceInfoClassName);
    fServiceInfoClass->addKey("name", "Name");
    fServiceInfoClass->addKey("library", "Library");
    fServiceInfoClass->addKey("executable", "Executable");

    // Construct map class for list requests

    fRequestInfoClass = STAFMapClassDefinition::create(sRequestInfoClassName);
    fRequestInfoClass->addKey("requestNumber", "Request#");
    fRequestInfoClass->setKeyProperty("requestNumber",
                                      "display-short-name", "Req#");
    fRequestInfoClass->addKey("startTimestamp", "Start Date-Time");
    fRequestInfoClass->setKeyProperty("startTimestamp",
                                      "display-short-name", "Date-Time");
    fRequestInfoClass->addKey("service", "Service");
    fRequestInfoClass->addKey("request", "Request");

    // Construct map class for listing pending requests in detailed form (LONG)

    fPendingRequestClass = STAFMapClassDefinition::create(
        sPendingRequestClassName);
    fPendingRequestClass->addKey("requestNumber", "Request#");
    fPendingRequestClass->setKeyProperty("requestNumber",
                                          "display-short-name", "Req#");
    fPendingRequestClass->addKey("sourceMachine", "Source Machine");
    fPendingRequestClass->setKeyProperty("sourceMachine",
                                         "display-short-name", "Source");
    fPendingRequestClass->addKey("sourceHandleName", "Handle Name");
    fPendingRequestClass->setKeyProperty("sourceHandleName",
                                          "display-short-name", "HName");
    fPendingRequestClass->addKey("sourceHandle", "Handle#");
    fPendingRequestClass->setKeyProperty("sourceHandle",
                                          "display-short-name", "H#");
    fPendingRequestClass->addKey("startTimestamp", "Start Date-Time");
    fPendingRequestClass->setKeyProperty("startTimestamp",
                                          "display-short-name", "Date-Time");
    fPendingRequestClass->addKey("targetMachine", "Target Machine");
    fPendingRequestClass->setKeyProperty("targetMachine",
                                          "display-short-name", "Target");
    fPendingRequestClass->addKey("service", "Service");
    fPendingRequestClass->addKey("request", "Request");

    // Construct map class for listing complete requests in detailed form (LONG)

    fCompleteRequestClass = STAFMapClassDefinition::create(
        sCompleteRequestClassName);
    fCompleteRequestClass->addKey("requestNumber", "Request#");
    fCompleteRequestClass->setKeyProperty("requestNumber",
                                          "display-short-name", "Req#");
    fCompleteRequestClass->addKey("sourceMachine", "Source Machine");
    fCompleteRequestClass->setKeyProperty("sourceMachine",
                                          "display-short-name", "Source");
    fCompleteRequestClass->addKey("sourceHandleName", "Handle Name");
    fCompleteRequestClass->setKeyProperty("sourceHandleName",
                                          "display-short-name", "HName");
    fCompleteRequestClass->addKey("sourceHandle", "Handle#");
    fCompleteRequestClass->setKeyProperty("sourceHandle",
                                          "display-short-name", "H#");
    fCompleteRequestClass->addKey("startTimestamp", "Start Date-Time");
    fCompleteRequestClass->setKeyProperty("startTimestamp",
                                          "display-short-name", "Date-Time");
    fCompleteRequestClass->addKey("targetMachine", "Target Machine");
    fCompleteRequestClass->setKeyProperty("targetMachine",
                                          "display-short-name", "Target");
    fCompleteRequestClass->addKey("service", "Service");
    fCompleteRequestClass->addKey("request", "Request");
    fCompleteRequestClass->addKey("rc", "Return Code");
    fCompleteRequestClass->setKeyProperty("rc", "display-short-name", "RC");
    fCompleteRequestClass->addKey("result", "Result");

    // Construct map class for listing pending and complete requests in
    // detailed form (LONG)

    fRequestInfoLongClass = STAFMapClassDefinition::create(
        sRequestInfoLongClassName);
    fRequestInfoLongClass->addKey("requestNumber", "Request#");
    fRequestInfoLongClass->setKeyProperty("requestNumber",
                                          "display-short-name", "Req#");
    fRequestInfoLongClass->addKey("state", "Status");
    fRequestInfoLongClass->addKey("sourceMachine", "Source Machine");
    fRequestInfoLongClass->setKeyProperty("sourceMachine",
                                          "display-short-name", "Source");
    fRequestInfoLongClass->addKey("sourceHandleName", "Handle Name");
    fRequestInfoLongClass->setKeyProperty("sourceHandleName",
                                          "display-short-name", "HName");
    fRequestInfoLongClass->addKey("sourceHandle", "Handle#");
    fRequestInfoLongClass->setKeyProperty("sourceHandle",
                                          "display-short-name", "H#");
    fRequestInfoLongClass->addKey("startTimestamp", "Start Date-Time");
    fRequestInfoLongClass->setKeyProperty("startTimestamp",
                                          "display-short-name", "Date-Time");
    fRequestInfoLongClass->addKey("targetMachine", "Target Machine");
    fRequestInfoLongClass->setKeyProperty("targetMachine",
                                          "display-short-name", "Target");
    fRequestInfoLongClass->addKey("service", "Service");
    fRequestInfoLongClass->addKey("request", "Request");
    fRequestInfoLongClass->addKey("rc", "Return Code");
    fRequestInfoLongClass->setKeyProperty("rc", "display-short-name", "RC");
    fRequestInfoLongClass->addKey("result", "Result");

    // Construct map class for query request

    fQueryRequestClass = STAFMapClassDefinition::create(sQueryRequestClassName);
    fQueryRequestClass->addKey("requestNumber", "Request Number");
    fQueryRequestClass->addKey("state", "Request Status");
    fQueryRequestClass->addKey("sourceMachine", "Source Machine");
    fQueryRequestClass->addKey("sourceHandleName", "Source Handle Name");
    fQueryRequestClass->addKey("sourceHandle", "Source Handle#");
    fQueryRequestClass->addKey("startTimestamp", "Start Date-Time");
    fQueryRequestClass->addKey("targetMachine", "Target Machine");
    fQueryRequestClass->addKey("service", "Service");
    fQueryRequestClass->addKey("request", "Request");
    fQueryRequestClass->addKey("rc", "Return Code");
    fQueryRequestClass->addKey("result", "Result");
    
    // Construct map class for QUERY SERVICE request

    fQueryServiceClass = STAFMapClassDefinition::create(sQueryServiceClassName);
    fQueryServiceClass->addKey("name", "Name");
    fQueryServiceClass->addKey("library", "Library");
    fQueryServiceClass->addKey("executable", "Executable");
    fQueryServiceClass->addKey("options", "Options");
    fQueryServiceClass->addKey("parameters", "Parameters");

    // Construct map class for free request

    fFreeRequestInfoClass = STAFMapClassDefinition::create(
        sFreeRequestInfoClassName);
    fFreeRequestInfoClass->addKey("rc", "Return Code");
    fFreeRequestInfoClass->addKey("result", "Result");
}


STAFServiceService::~STAFServiceService()
{
    /* Do Nothing */
}


STAFString STAFServiceService::info(unsigned int) const
{
    return name() + ": Internal";
}


STAFServiceResult STAFServiceService::acceptRequest(
    const STAFServiceRequest &requestInfo)
{
    STAFString action = requestInfo.fRequest.subWord(0, 1).toLowerCase();

    if      (action == sList)    return handleList(requestInfo);
    else if (action == sHelp)    return handleHelp(requestInfo);
    else if (action == sQuery)   return handleQuery(requestInfo);
    else if (action == sFree)    return handleFree(requestInfo);
    else if (action == sAdd)     return handleAdd(requestInfo);
    // XXX: Commented out Replace and Rename options
    // else if (action == sReplace) return handleReplace(requestInfo);
    // else if (action == sRename)  return handleRename(requestInfo);
    else if (action == sRemove)  return handleRemove(requestInfo);
    else return STAFServiceResult(kSTAFInvalidRequestString);
}

STAFServiceResult STAFServiceService::handleList(
    const STAFServiceRequest &requestInfo)
{
    // Verify that the requesting machine/user has at least trust level 2

    IVALIDATE_TRUST(2, "LIST");

    // Parse the request

    STAFCommandParseResultPtr parsedListResult = fListParser->parse(
        requestInfo.fRequest);

    if (parsedListResult->rc != kSTAFOk)
    {
        return STAFServiceResult(kSTAFInvalidRequestString,
                                 parsedListResult->errorBuffer, 0);
    }

    STAFRC_t rc = kSTAFOk;
    STAFObjectPtr mc = STAFObject::createMarshallingContext();
    STAFObjectPtr outputList = STAFObject::createList();

    if (parsedListResult->optionTimes(sServiceLoaders) > 0)
    {
        // LIST SERVICELOADERSS

        STAFServiceManager::ServiceList serviceLoaderList =
            gServiceManagerPtr->getSLSListCopy();

        // Create a marshalled list of maps for service loaders
        
        mc->setMapClassDefinition(fServiceInfoClass->reference());
        
        STAFServiceManager::ServiceList::iterator iter;

        for(iter = serviceLoaderList.begin();
            iter != serviceLoaderList.end(); iter++)
        {
            STAFObjectPtr serviceLoaderMap = 
                fServiceInfoClass->createInstance();
            serviceLoaderMap->put("name", (*iter)->name());
            serviceLoaderMap->put(
                "library", STAFString((*iter)->getLibName()));

            STAFString exec = STAFString((*iter)->getExecutable());

            if (exec != STAFString(""))
                serviceLoaderMap->put("executable", exec);
            
            outputList->append(serviceLoaderMap);