Back to index

nordugrid-arc-nox  1.1.0~rc6
Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes
Arc::AREXClient Class Reference

A client class for the A-REX service. More...

#include <AREXClient.h>

Collaboration diagram for Arc::AREXClient:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 AREXClient (const URL &url, const MCCConfig &cfg, int timeout, bool arex_features=true)
 The constructor for the AREXClient class.
 ~AREXClient ()
 The destructor.
bool submit (const std::string &jobdesc, std::string &jobid, bool delegate=false)
 Submit a job.
bool stat (const std::string &jobid, Job &job)
 Query the status of a job.
bool kill (const std::string &jobid)
 Terminates a job.
bool clean (const std::string &jobid)
 Removes a job.
bool sstat (XMLNode &status)
 Query the status of a service.
bool getdesc (const std::string &jobid, std::string &jobdesc)
 Query the description of a job.
bool migrate (const std::string &jobid, const std::string &jobdesc, bool forcemigration, std::string &newjobid, bool delegate=false)
 Migrate a job.
bool listServicesFromISIS (std::list< std::pair< URL, ServiceType > > &services)
bool resume (const std::string &jobid)
ClientSOAPSOAP (void)

Static Public Member Functions

static void createActivityIdentifier (const URL &jobid, std::string &activityIdentifier)
 Create a activity identifier.

Static Public Attributes

static const std::string mainStateModel = "nordugrid"

Private Member Functions

bool process (PayloadSOAP &req, bool delegate, XMLNode &response)

Private Attributes

ClientSOAPclient
NS arex_ns
 Namespaces.
URL rurl
std::string action
bool arex_enabled

Static Private Attributes

static Logger logger
 A logger for the A-REX client.

Detailed Description

A client class for the A-REX service.

This class is a client for the A-REX service (Arc Resource-coupled EXecution service). It provides methods for three operations on an A-REX service:

Definition at line 30 of file AREXClient.h.


Constructor & Destructor Documentation

Arc::AREXClient::AREXClient ( const URL url,
const MCCConfig cfg,
int  timeout,
bool  arex_features = true 
)

The constructor for the AREXClient class.

This is the constructor for the AREXClient class. It creates an A-REX client that corresponds to a specific A-REX service.

Parameters:
urlThe URL of the A-REX service.
cfgAn MCC configuration object.

Definition at line 58 of file AREXClient.cpp.

    : client(NULL),
      rurl(url),
      arex_enabled(arex_extensions) {

    logger.msg(DEBUG, "Creating an A-REX client");
    client = new ClientSOAP(cfg, url, timeout);
    if (!client)
      logger.msg(VERBOSE, "Unable to create SOAP client used by AREXClient.");
    if(arex_enabled) {
      set_arex_namespaces(arex_ns);
    } else {
      set_bes_namespaces(arex_ns);
    }
  }

Here is the call graph for this function:

The destructor.

This is the destructor. It does what destructors usually do, cleans up...

Definition at line 77 of file AREXClient.cpp.

                          {
    if (client)
      delete client;
  }

Member Function Documentation

bool Arc::AREXClient::clean ( const std::string &  jobid)

Removes a job.

This method sends a request to the A-REX service to remove a job from it's pool. If job is running it will be killed by service as well.

Parameters:
jobidThe Job ID of the job to remove.
Returns:
true on success

Definition at line 414 of file AREXClient.cpp.

                                               {
    if(!arex_enabled) return false;

    action = "ChangeActivityStatus";
    logger.msg(VERBOSE, "Creating and sending clean request to %s", rurl.str());

    PayloadSOAP req(arex_ns);
    XMLNode op = req.NewChild("a-rex:" + action);
    op.NewChild(XMLNode(jobid));
    XMLNode jobstate = op.NewChild("a-rex:NewStatus");
    jobstate.NewAttribute("bes-factory:state") = "Finished";
    jobstate.NewChild("a-rex:state") = "Deleted";

    // Send clean request
    XMLNode response;
    if (!process(req, false, response))
      return false;

/*
 * It is not clear how (or if) the response should be interpreted.
 * Currently response contains status of job before invoking requst. It is
 * unclear if this is the desired behaviour.
 * See trunk/src/services/a-rex/change_activity_status.cpp
    ????if ((std::string)response["NewStatus"]["state"] != "Deleted") {????
      logger.msg(VERBOSE, "Job cleaning failed: Wrong response???");
      return false;
    }
*/

    return true;
  }

Here is the call graph for this function:

void Arc::AREXClient::createActivityIdentifier ( const URL jobid,
std::string &  activityIdentifier 
) [static]

Create a activity identifier.

This is a convenience method to construct a activity identifier used in BES requests.

Parameters:
jobidThe URL of the job to construct the activity identifier from.
activityIdentifierThe created activity identifier will be stored in this object.

Definition at line 531 of file AREXClient.cpp.

                                                                                           {
    PathIterator pi(jobid.Path(), true);
    URL url(jobid);
    url.ChangePath(*pi);
    NS ns;
    ns["a-rex"] = "http://www.nordugrid.org/schemas/a-rex";
    ns["bes-factory"] = "http://schemas.ggf.org/bes/2006/08/bes-factory";
    ns["wsa"] = "http://www.w3.org/2005/08/addressing";
    ns["jsdl"] = "http://schemas.ggf.org/jsdl/2005/11/jsdl";
    ns["jsdl-posix"] = "http://schemas.ggf.org/jsdl/2005/11/jsdl-posix";
    ns["jsdl-arc"] = "http://www.nordugrid.org/ws/schemas/jsdl-arc";
    ns["jsdl-hpcpa"] = "http://schemas.ggf.org/jsdl/2006/07/jsdl-hpcpa";
    XMLNode id(ns, "ActivityIdentifier");
    id.NewChild("wsa:Address") = url.str();
    id.NewChild("wsa:ReferenceParameters").NewChild("a-rex:JobID") = pi.Rest();
    id.GetXML(activityIdentifier);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Arc::AREXClient::getdesc ( const std::string &  jobid,
std::string &  jobdesc 
)

Query the description of a job.

This method queries the A-REX service about the description of a job.

Parameters:
jobidThe Job ID of the job.
jobdescThe description of the job.
Returns:
true on success

Definition at line 446 of file AREXClient.cpp.

                                                                     {
    action = "GetActivityDocuments";
    logger.msg(VERBOSE, "Creating and sending job description retrieval request to %s", rurl.str());

    PayloadSOAP req(arex_ns);
    req.NewChild("bes-factory:" + action).NewChild(XMLNode(jobid));
    WSAHeader(req).Action(BES_FACTORY_ACTIONS_BASE_URL + action);

    XMLNode response;
    if (!process(req, false, response))
      return false;

    XMLNode xmlJobDesc;
    response["Response"]["JobDefinition"].New(xmlJobDesc);
    xmlJobDesc.GetDoc(jobdesc);
    return true;
  }

Here is the call graph for this function:

bool Arc::AREXClient::kill ( const std::string &  jobid)

Terminates a job.

This method sends a request to the A-REX service to terminate a job.

Parameters:
jobidThe Job ID of the job to terminate.
Returns:
true on success

Definition at line 394 of file AREXClient.cpp.

                                              {
    action = "TerminateActivities";
    logger.msg(VERBOSE, "Creating and sending terminate request to %s", rurl.str());

    PayloadSOAP req(arex_ns);
    XMLNode jobref = req.NewChild("bes-factory:" + action).NewChild(XMLNode(jobid));
    WSAHeader(req).Action(BES_FACTORY_ACTIONS_BASE_URL + action);

    XMLNode response;
    if (!process(req, false, response))
      return false;

    if ((std::string)response["Response"]["Terminated"] != "true") {
      logger.msg(ERROR, "Job termination failed");
      return false;
    }

    return true;
  }

Here is the call graph for this function:

bool Arc::AREXClient::listServicesFromISIS ( std::list< std::pair< URL, ServiceType > > &  services)

Definition at line 366 of file AREXClient.cpp.

                                                                                      {
    if(!arex_enabled) return false;

    action = "Query";
    logger.msg(VERBOSE, "Creating and sending ISIS information query request to %s", rurl.str());

    PayloadSOAP req(NS("isis", "http://www.nordugrid.org/schemas/isis/2007/06"));
    req.NewChild("isis:" + action).NewChild("isis:QueryString") = "/RegEntry/SrcAdv[Type=\"org.nordugrid.execution.arex\"]";
    WSAHeader(req).Action("http://www.nordugrid.org/schemas/isis/2007/06/Query/QueryRequest");

    XMLNode response;
    if (!process(req, false, response))
      return false;

    if (XMLNode n = response["RegEntry"])
      for (; n; ++n) {
        if ((std::string)n["SrcAdv"]["Type"] == "org.nordugrid.execution.arex") {
          //This check is right now superfluos but in the future a wider query might be used
          services.push_back(std::pair<URL, ServiceType>(URL((std::string)n["SrcAdv"]["EPR"]["Address"]), COMPUTING));
        }
        else
          logger.msg(DEBUG, "Service %s of type %s ignored", (std::string)n["MetaSrcAdv"]["ServiceID"], (std::string)n["SrcAdv"]["Type"]);
      }
    else
      logger.msg(VERBOSE, "No execution services registered in the index service");
    return true;
  }

Here is the call graph for this function:

bool Arc::AREXClient::migrate ( const std::string &  jobid,
const std::string &  jobdesc,
bool  forcemigration,
std::string &  newjobid,
bool  delegate = false 
)

Migrate a job.

This method submits a migrate request and the corresponding job to the AREX-service.

Parameters:
jobidThe Job ID of the job to migrate.
jobdescThe job description of the job to migrate.
newjobidThe Job ID of returned by the AREX-client on success.
Returns:
true on success

Definition at line 464 of file AREXClient.cpp.

                                                                                                                                    {
    if(!arex_enabled) return false;

    action = "MigrateActivity";
    logger.msg(VERBOSE, "Creating and sending job migrate request to %s", rurl.str());

    // Create migrate request
    /*
       bes-factory:MigrateActivity
        bes-factory:ActivityIdentifier
        bes-factory:ActivityDocument
          jsdl:JobDefinition
     */

    PayloadSOAP req(arex_ns);
    XMLNode op = req.NewChild("a-rex:" + action);
    XMLNode act_doc = op.NewChild("bes-factory:ActivityDocument");
    op.NewChild(XMLNode(jobid));
    op.NewChild("a-rex:ForceMigration") = (forcemigration ? "true" : "false");
    act_doc.NewChild(XMLNode(jobdesc));
    act_doc.Child(0).Namespaces(arex_ns); // Unify namespaces

    logger.msg(DEBUG, "Job description to be sent: %s", jobdesc);

    XMLNode response;
    if (!process(req, delegate, response))
      return false;

    XMLNode xmlNewJobId;
    response["ActivityIdentifier"].New(xmlNewJobId);
    xmlNewJobId.GetDoc(newjobid);
    return true;
  }

Here is the call graph for this function:

bool Arc::AREXClient::process ( PayloadSOAP req,
bool  delegate,
XMLNode response 
) [private]

Definition at line 82 of file AREXClient.cpp.

                                                                             {
    if (!client) {
      logger.msg(VERBOSE, "AREXClient was not created properly."); // Should not happen. Happens if client = null (out of memory?)
      return false;
    }

    logger.msg(VERBOSE, "Processing a %s request", req.Child(0).FullName());

    if (delegate) {
      // Try to figure out which credentials are used
      // TODO: Method used is unstable beacuse it assumes some predefined
      // structure of configuration file. Maybe there should be some
      // special methods of ClientTCP class introduced.
      std::string deleg_cert;
      std::string deleg_key;

      client->Load(); // Make sure chain is ready
      XMLNode tls_cfg = find_xml_node((client->GetConfig())["Chain"],
                                      "Component", "name", "tls.client");
      if (tls_cfg) {
        deleg_cert = (std::string)(tls_cfg["ProxyPath"]);
        if (deleg_cert.empty()) {
          deleg_cert = (std::string)(tls_cfg["CertificatePath"]);
          deleg_key = (std::string)(tls_cfg["KeyPath"]);
        }
        else
          deleg_key = deleg_cert;
      }
      if (deleg_cert.empty() || deleg_key.empty()) {
        logger.msg(VERBOSE, "Failed locating delegation credentials in chain configuration");
        return false;
      }

      DelegationProviderSOAP deleg(deleg_cert, deleg_key);
      logger.msg(VERBOSE, "Initiating delegation procedure");
      if (!deleg.DelegateCredentialsInit(*(client->GetEntry()),
                                         &(client->GetContext()))) {
        logger.msg(VERBOSE, "Failed to initiate delegation credentials");
        return false;
      }
      XMLNode op = req.Child(0);
      deleg.DelegatedToken(op);
    }

    WSAHeader header(req);
    header.To(rurl.str());
    PayloadSOAP* resp = NULL;
    if (!client->process(header.Action(), &req, &resp)) {
      logger.msg(VERBOSE, "%s request failed", action);
      return false;
    }

    if (resp == NULL) {
      logger.msg(VERBOSE, "No response from %s", rurl.str());
      return false;
    }

    if (resp->IsFault()) {
      logger.msg(VERBOSE, "%s request to %s failed with response: %s", action, rurl.str(), resp->Fault()->Reason());
      std::string s;
      resp->GetXML(s);
      logger.msg(DEBUG, "XML response: %s", s);
      delete resp;
      return false;
    }

    if (!(*resp)[action + "Response"]) {
      logger.msg(VERBOSE, "%s request to %s failed. Empty response.", action, rurl.str());
      delete resp;
      return false;
    }

    (*resp)[action + "Response"].New(response);
    delete resp;
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Arc::AREXClient::resume ( const std::string &  jobid)

Definition at line 498 of file AREXClient.cpp.

                                                {
    if(!arex_enabled) return false;

    action = "ChangeActivityStatus";
    logger.msg(VERBOSE, "Creating and sending job resume request to %s", rurl.str());

    bool delegate = true;
    PayloadSOAP req(arex_ns);
    XMLNode op = req.NewChild("a-rex:" + action);
    op.NewChild(XMLNode(jobid));
    XMLNode jobstate = op.NewChild("a-rex:NewStatus");
    jobstate.NewAttribute("bes-factory:state") = "Running";
    // Not supporting resume into user-defined state
    jobstate.NewChild("a-rex:state") = "";

    XMLNode response;
    if (!process(req, true, response))
      return false;

/*
 * It is not clear how (or if) the response should be interpreted.
 * Currently response contains status of job before invoking requst. It is
 * unclear if this is the desired behaviour.
 * See trunk/src/services/a-rex/change_activity_status.cpp
    ????if ((std::string)response["NewStatus"]["state"] != "Running") {????
      logger.msg(VERBOSE, "Job resuming failed: Wrong response???");
      return false;
    }
*/

    return true;
  }

Here is the call graph for this function:

ClientSOAP* Arc::AREXClient::SOAP ( void  ) [inline]

Definition at line 128 of file AREXClient.h.

                           {
      return client;
    }

Here is the caller graph for this function:

bool Arc::AREXClient::sstat ( XMLNode status)

Query the status of a service.

This method queries the A-REX service about it's status.

Parameters:
statusThe XML document representing status of the service.
Returns:
true on success

Definition at line 352 of file AREXClient.cpp.

                                          {
    if(!arex_enabled) return false;

    action = "QueryResourceProperties";
    logger.msg(VERBOSE, "Creating and sending service information query request to %s", rurl.str());

    PayloadSOAP req(*InformationRequest(XMLNode("<XPathQuery>//glue:Services/glue:ComputingService</XPathQuery>")).SOAP());

    if (!process(req, false, response))
      return false;

    return true;
  }

Here is the call graph for this function:

bool Arc::AREXClient::stat ( const std::string &  jobid,
Job job 
)

Query the status of a job.

This method queries the A-REX service about the status of a job.

Parameters:
jobidThe Job ID of the job.
statusThe status of the job.
Returns:
true on success

Definition at line 190 of file AREXClient.cpp.

                                                        {
    std::string faultstring;
    logger.msg(VERBOSE, "Creating and sending job information query request to %s", rurl.str());

    PayloadSOAP req(arex_ns);
    if(arex_enabled) {
      // TODO: use wsrf classes
      // AREX service
      action = "QueryResourceProperties";
      std::string xpathquery = "//glue:Services/glue:ComputingService/glue:ComputingEndpoint/glue:ComputingActivities/glue:ComputingActivity/glue:ID[contains(.,'" + (std::string)(XMLNode(jobid)["ReferenceParameters"]["JobID"]) + "')]/..";
      req = *InformationRequest(XMLNode("<XPathQuery>" + xpathquery + "</XPathQuery>")).SOAP();
    } else {
      // Simple BES service
      // GetActivityStatuses
      //  ActivityIdentifier
      action = "GetActivityStatuses";
      XMLNode jobref =
        req.NewChild("bes-factory:" + action).
        NewChild(XMLNode(jobid));
      jobref.Child(0).Namespaces(arex_ns); // Unify namespaces
      WSAHeader(req).Action(BES_FACTORY_ACTIONS_BASE_URL + action);
    }

    XMLNode response;
    if (!process(req, false, response))
      return false;

    if(arex_enabled) {
      // Fetch the proper state.
      for (int i = 0; response["ComputingActivity"]["State"][i]; i++) {
        const std::string rawState = (std::string)response["ComputingActivity"]["State"][i];
        const std::size_t pos = rawState.find_first_of(':');
        if (pos == std::string::npos) {
          logger.msg(VERBOSE, "Found malformed job state string: %s", rawState);
          continue;
        }
        const std::string model = rawState.substr(0, pos);
        const std::string state = rawState.substr(pos + 1);
        if (model == mainStateModel)
          job.State = JobStateARC1(state);
        job.AuxStates[model] = state;
      }
    } else {
      XMLNode activity = response["Response"]["ActivityStatus"];
      if(activity) {
        NS ns("a-rex","http://www.nordugrid.org/schemas/a-rex");
        activity.Namespaces(ns);
        std::string state = activity.Attribute("state");
        if(!state.empty()) {
          job.State = JobStateBES(state);
          XMLNode nstate = activity["a-rex:State"];
          std::string nstates;
          for(;nstate;++nstate) {
            if(nstates.empty()) {
              nstates = (std::string)nstate;
            } else {
              nstates = (std::string)nstate + ":" + nstates;
            }
          }
          if(!nstates.empty()) {
            job.State = JobStateARC1(nstates);
            job.AuxStates["nordugrid"] = nstates;
            job.AuxStates["bes"] = state;
          }
        }
      }
    }

    if (!job.State) {
      if(arex_enabled) {
        // If failed to fetch through Glue2 try through BES
        arex_enabled = false;
        bool r = stat(jobid,job);
        arex_enabled = true;
        return r;
      } else {
        logger.msg(VERBOSE, "Unable to retrieve status of job (%s)", job.JobID.str());
      }
      return false;
    }
    if(!arex_enabled) return true;

    // The following elements (except the 'State' element) seem to be published by A-REX, for more info see the ARC1ClusterInfo.pm script.
    XMLNode jobNode = response["ComputingActivity"];
    if (jobNode["CreationTime"])
      job.CreationTime = Time((std::string)jobNode["CreationTime"]);
    if (jobNode["Type"])
      job.Type = (std::string)jobNode["Type"];
    if (jobNode["IDFromEndpoint"])
      job.IDFromEndpoint = URL((std::string)jobNode["IDFromEndpoint"]);
    if (jobNode["LocalIDFromManager"])
      job.LocalIDFromManager = (std::string)jobNode["LocalIDFromManager"];
    if (jobNode["Name"])
      job.Name = (std::string)jobNode["Name"];
    if (jobNode["JobDescription"])
      job.JobDescription = (std::string)jobNode["JobDescription"];
    if (jobNode["RestartState"])
      job.RestartState = (std::string)jobNode["RestartState"];
    if (jobNode["ExitCode"])
      job.ExitCode = stringtoi(jobNode["ExitCode"]);
    if (jobNode["ComputingManagerExitCode"])
      job.ComputingManagerExitCode = (std::string)jobNode["ComputingManagerExitCode"];
    for (XMLNode errorXML = jobNode["Error"]; errorXML; ++errorXML)
      job.Error.push_back((std::string)errorXML);
    if (jobNode["WaitingPosition"])
      job.WaitingPosition = stringtoi((std::string)jobNode["WaitingPosition"]);
    if (jobNode["Owner"])
      job.Owner = (std::string)jobNode["Owner"];
    if (jobNode["LocalOwner"])
      job.LocalOwner = (std::string)jobNode["LocalOwner"];
    if (jobNode["RequestedTotalWallTime"])
      job.RequestedTotalWallTime = Period((std::string)jobNode["RequestedTotalWallTime"]);
    if (jobNode["RequestedTotalCPUTime"])
      job.RequestedTotalCPUTime = Period((std::string)jobNode["RequestedTotalCPUTime"]);
    for (XMLNode appEnvXML = jobNode["RequestedApplicationEnvironment"]; appEnvXML; ++appEnvXML)
      job.RequestedApplicationEnvironment.push_back((std::string)appEnvXML);
    if (jobNode["RequestedSlots"])
      job.RequestedSlots = stringtoi((std::string)jobNode["RequestedSlots"]);
    if (jobNode["LogDir"])
      job.LogDir = (std::string)jobNode["LogDir"];
    if (jobNode["StdIn"])
      job.StdIn = (std::string)jobNode["StdIn"];
    if (jobNode["StdOut"])
      job.StdOut = (std::string)jobNode["StdOut"];
    if (jobNode["StdErr"])
      job.StdErr = (std::string)jobNode["StdErr"];
    for (XMLNode exeNodeXML = jobNode["ExecutionNode"]; exeNodeXML; ++exeNodeXML)
      job.ExecutionNode.push_back((std::string)exeNodeXML);
    if (jobNode["Queue"])
      job.Queue = (std::string)jobNode["Queue"];
    if (jobNode["UsedTotalWallTime"])
      job.UsedTotalWallTime = Period((std::string)jobNode["UsedTotalWallTime"]);
    if (jobNode["UsedTotalCPUTime"])
      job.UsedTotalCPUTime = Period((std::string)jobNode["UsedTotalCPUTime"]);
    if (jobNode["UsedMainMemory"])
      job.UsedMainMemory = stringtoi((std::string)jobNode["UsedMainMemory"]);
    if (jobNode["SubmissionTime"])
      job.SubmissionTime = Time((std::string)jobNode["SubmissionTime"]);
    if (jobNode["EndTime"])
      job.EndTime = (std::string)jobNode["EndTime"];
    if (jobNode["WorkingAreaEraseTime"])
      job.WorkingAreaEraseTime = Time((std::string)jobNode["WorkingAreaEraseTime"]);
    if (jobNode["ProxyExpirationTime"])
      job.ProxyExpirationTime = Time((std::string)jobNode["ProxyExpirationTime"]);
    if (jobNode["SubmissionHost"])
      job.SubmissionHost = (std::string)jobNode["SubmissionHost"];
    if (jobNode["SubmissionClientName"])
      job.SubmissionClientName = (std::string)jobNode["SubmissionClientName"];

    // The following elements do not seem to be published by A-REX (they are not in ARC1ClusterInfo.om). They are kept here for consistency.
    if (jobNode["ComputingManagerEndTime"])
      job.ComputingManagerEndTime = Time((std::string)jobNode["ComputingManagerEndTime"]);
    if (jobNode["ComputingManagerSubmissionTime"])
      job.ComputingManagerSubmissionTime = Time((std::string)jobNode["ComputingManagerSubmissionTime"]);
    if (jobNode["LocalSubmissionTime"])
      job.LocalSubmissionTime = Time((std::string)jobNode["LocalSubmissionTime"]);
    if (jobNode["StartTime"])
      job.StartTime = Time((std::string)jobNode["StartTime"]);

    return true;
  }

Here is the call graph for this function:

bool Arc::AREXClient::submit ( const std::string &  jobdesc,
std::string &  jobid,
bool  delegate = false 
)

Submit a job.

This method submits a job to the A-REX service corresponding to this client instance.

Parameters:
jobdescA string containing the job description.
jobidThe Job ID of the the submitted job.
Returns:
true on success

Definition at line 159 of file AREXClient.cpp.

                                         {
    action = "CreateActivity";
    logger.msg(VERBOSE, "Creating and sending submit request to %s", rurl.str());

    // Create job request
    /*
       bes-factory:CreateActivity
         bes-factory:ActivityDocument
           jsdl:JobDefinition
     */

    PayloadSOAP req(arex_ns);
    XMLNode op = req.NewChild("bes-factory:" + action);
    XMLNode act_doc = op.NewChild("bes-factory:ActivityDocument");
    WSAHeader(req).Action(BES_FACTORY_ACTIONS_BASE_URL + action);
    act_doc.NewChild(XMLNode(jobdesc));
    act_doc.Child(0).Namespaces(arex_ns); // Unify namespaces

    logger.msg(DEBUG, "Job description to be sent: %s", jobdesc);

    XMLNode response;
    if (!process(req, delegate, response))
      return false;

    XMLNode xmlJobId;
    response["ActivityIdentifier"].New(xmlJobId);
    xmlJobId.GetDoc(jobid);
    return true;
  }

Here is the call graph for this function:


Member Data Documentation

std::string Arc::AREXClient::action [private]

Definition at line 146 of file AREXClient.h.

Definition at line 148 of file AREXClient.h.

Namespaces.

A map containing namespaces.

Definition at line 142 of file AREXClient.h.

Definition at line 137 of file AREXClient.h.

Logger Arc::AREXClient::logger [static, private]

A logger for the A-REX client.

This is a logger to which all logging messages from the A-REX client are sent.

Definition at line 154 of file AREXClient.h.

const std::string Arc::AREXClient::mainStateModel = "nordugrid" [static]

Definition at line 132 of file AREXClient.h.

Definition at line 144 of file AREXClient.h.


The documentation for this class was generated from the following files: