XrdClHttp::TapeOperation Class Reference

#include <XrdClHttpTape.hh>

Collaboration diagram for XrdClHttp::TapeOperation:

Classes
struct	Impl

Public Member Functions
	TapeOperation (const std::string &url, const std::vector< std::string > &fileList, XrdCl::PrepareFlags::Flags flags)
	TapeOperation (const std::string &url, XrdCl::QueryCode::Code queryCode, const XrdCl::Buffer &arg)
	TapeOperation (const TapeOperation &)=delete
	~TapeOperation ()
XrdCl::XRootDStatus	Advance (CURL *curl, long statusCode, const std::string &body, TapeHttpRequest &request, std::string &response, bool &complete)
TapeOperation &	operator= (const TapeOperation &)=delete
XrdCl::XRootDStatus	Start (TapeHttpRequest &request)

Detailed Description

Definition at line 51 of file XrdClHttpTape.hh.

Constructor & Destructor Documentation

TapeOperation() [1/3]

XrdClHttp::TapeOperation::TapeOperation	(	const std::string &	url,
		const std::vector< std::string > &	fileList,
		XrdCl::PrepareFlags::Flags	flags
	)

Definition at line 829 of file XrdClHttpTape.cc.

                                  :
    pImpl(std::make_unique<Impl>())
  {
    pImpl->storageUrl = url;
    pImpl->initialStatus = ValidateTapePrepareFlags(flags);
    if(!pImpl->initialStatus.IsOK()) return;
 
    if(flags & XrdCl::PrepareFlags::Stage)
    {
      pImpl->kind = Impl::Kind::Stage;
      pImpl->initialStatus = PrepareStageFiles(fileList, pImpl->stageFiles);
      return;
    }
 
    if(fileList.size() < 2)
    {
      pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
        "cancel and evict require a request id and at least one path");
      return;
    }
 
    pImpl->requestId = fileList.front();
    if(!IsValidRequestId(pImpl->requestId))
    {
      pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
        "cancel and evict require a non-empty request id");
      return;
    }
    pImpl->initialStatus = PathsFromInputs(
      std::vector<std::string>(fileList.begin() + 1, fileList.end()),
      pImpl->paths);
    if(!pImpl->initialStatus.IsOK()) return;
    pImpl->kind = (flags & XrdCl::PrepareFlags::Cancel)
      ? Impl::Kind::StageCancel : Impl::Kind::Release;
  }

References XrdCl::PrepareFlags::Cancel, XrdCl::errInvalidArgs, and XrdCl::PrepareFlags::Stage.

TapeOperation() [2/3]

XrdClHttp::TapeOperation::TapeOperation	(	const std::string &	url,
		XrdCl::QueryCode::Code	queryCode,
		const XrdCl::Buffer &	arg
	)

Definition at line 868 of file XrdClHttpTape.cc.

                            :
    pImpl(std::make_unique<Impl>())
  {
    pImpl->storageUrl = url;
    std::vector<std::string> args;
    XrdCl::Utils::splitString(args, arg.ToString(), "\n");
    if(queryCode == XrdCl::QueryCode::Prepare)
    {
      if(args.size() != 1 || !IsValidRequestId(args.front()))
      {
        pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
          "prepare query expects a single request id");
        return;
      }
      pImpl->kind = Impl::Kind::StageStatus;
      pImpl->requestId = args.front();
      return;
    }
 
    if(queryCode != XrdCl::QueryCode::Opaque)
    {
      pImpl->initialStatus = ErrorStatus(XrdCl::errNotSupported,
        "unsupported HTTP query");
      return;
    }
    if(args.empty() || args.front().find('\r') != std::string::npos)
    {
      pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
        "missing opaque query command");
      return;
    }
 
    if(args.front() == "tape.discover")
    {
      pImpl->kind = Impl::Kind::Discover;
      return;
    }
    if(args.front() == "tape.stage_delete")
    {
      if(args.size() != 2 || !IsValidRequestId(args[1]))
      {
        pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
          "tape.stage_delete expects a request id");
        return;
      }
      pImpl->kind = Impl::Kind::StageDelete;
      pImpl->requestId = args[1];
      return;
    }
    if(args.front() == "tape.archiveinfo")
    {
      if(args.size() < 2)
      {
        pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
          "tape.archiveinfo expects non-empty URLs");
        return;
      }
      pImpl->urls.assign(args.begin() + 1, args.end());
      for(const auto &archiveUrl : pImpl->urls)
      {
        if(archiveUrl.find('\r') != std::string::npos)
        {
          pImpl->initialStatus = ErrorStatus(XrdCl::errInvalidArgs,
            "tape.archiveinfo expects non-empty URLs");
          return;
        }
      }
      pImpl->initialStatus = ValidateArchiveUrls(pImpl->urls, pImpl->paths);
      if(pImpl->initialStatus.IsOK()) pImpl->kind = Impl::Kind::ArchiveInfo;
      return;
    }
 
    pImpl->initialStatus = ErrorStatus(XrdCl::errNotSupported,
      "unsupported HTTP opaque query");
  }

References XrdCl::errInvalidArgs, XrdCl::errNotSupported, XrdCl::QueryCode::Opaque, XrdCl::QueryCode::Prepare, XrdCl::Utils::splitString(), and XrdCl::Buffer::ToString().

Here is the call graph for this function:

~TapeOperation()

XrdClHttp::TapeOperation::~TapeOperation ( )

default

TapeOperation() [3/3]

XrdClHttp::TapeOperation::TapeOperation ( const TapeOperation &  )

delete

Member Function Documentation

Advance()

XrdCl::XRootDStatus XrdClHttp::TapeOperation::Advance	(	CURL *	curl,
		long	statusCode,
		const std::string &	body,
		TapeHttpRequest &	request,
		std::string &	response,
		bool &	complete
	)

Definition at line 973 of file XrdClHttpTape.cc.

  {
    complete = false;
    response.clear();
 
    if(pImpl->phase == Impl::Phase::Discovery)
    {
      if(statusCode != 200)
      {
        complete = true;
        return UnexpectedStatus(statusCode, body, "Tape REST discovery");
      }
 
      TapeEndpoint endpoint;
      XrdCl::XRootDStatus status = ParseDiscoveryResponse(body, endpoint);
      if(!status.IsOK())
      {
        complete = true;
        return status;
      }
      if(pImpl->kind == Impl::Kind::Discover)
      {
        Json result;
        result["uri"] = endpoint.uri;
        result["version"] = endpoint.version;
        result["sitename"] = endpoint.sitename;
        response = result.dump();
        complete = true;
        pImpl->phase = Impl::Phase::Complete;
        return XrdCl::XRootDStatus();
      }
 
      request = TapeHttpRequest();
      const std::string encodedRequestId = pImpl->requestId.empty()
        ? "" : PercentEncodeUrlPathSegment(pImpl->requestId, curl);
      switch(pImpl->kind)
      {
        case Impl::Kind::Stage:
        {
          std::string error;
          Json stageBody = StageRequestBody(pImpl->stageFiles, error);
          if(!error.empty())
          {
            complete = true;
            return ErrorStatus(XrdCl::errInvalidArgs, error);
          }
          request.method = HttpVerb::POST;
          request.url = XrdOucUtils::JoinUrl(endpoint.uri, "/stage");
          request.body = stageBody.dump();
          break;
        }
        case Impl::Kind::StageStatus:
          request.url = XrdOucUtils::JoinUrl(
            endpoint.uri, "/stage/" + encodedRequestId);
          break;
        case Impl::Kind::StageCancel:
          SetPathsPostRequest(request, endpoint.uri,
            "/stage/" + encodedRequestId + "/cancel", pImpl->paths);
          break;
        case Impl::Kind::StageDelete:
          request.method = HttpVerb::DELETE;
          request.url = XrdOucUtils::JoinUrl(
            endpoint.uri, "/stage/" + encodedRequestId);
          break;
        case Impl::Kind::Release:
          SetPathsPostRequest(request, endpoint.uri,
            "/release/" + encodedRequestId, pImpl->paths);
          break;
        case Impl::Kind::ArchiveInfo:
          SetPathsPostRequest(request, endpoint.uri, "/archiveinfo",
                              pImpl->paths);
          break;
        case Impl::Kind::Invalid:
        case Impl::Kind::Discover:
          complete = true;
          return ErrorStatus(XrdCl::errInternal,
            "invalid Tape REST operation state");
      }
      pImpl->phase = Impl::Phase::Request;
      return XrdCl::XRootDStatus();
    }
 
    if(pImpl->phase != Impl::Phase::Request)
    {
      complete = true;
      return ErrorStatus(XrdCl::errInternal,
        "invalid Tape REST response state");
    }
 
    complete = true;
    pImpl->phase = Impl::Phase::Complete;
    switch(pImpl->kind)
    {
      case Impl::Kind::Stage:
      {
        if(statusCode != 201)
          return UnexpectedStatus(statusCode, body, "stage request submission");
        Json json;
        XrdCl::XRootDStatus status =
          ParseJsonResponse(body, "stage submission", json);
        if(!status.IsOK()) return status;
        if(!json.contains("requestId") || !json["requestId"].is_string()
           || json["requestId"].get_ref<const std::string &>().empty())
        {
          return ErrorStatus(XrdCl::errInvalidResponse,
            "stage submission response does not contain a non-empty string "
            "requestId");
        }
        response = json["requestId"].get<std::string>();
        return XrdCl::XRootDStatus();
      }
      case Impl::Kind::StageStatus:
      {
        if(statusCode != 200)
          return UnexpectedStatus(statusCode, body, "stage request polling");
        Json json;
        XrdCl::XRootDStatus status =
          ParseJsonResponse(body, "stage polling", json);
        if(!status.IsOK()) return status;
        Json normalizedStatus;
        status = NormalizeStageStatusJson(json, normalizedStatus);
        if(status.IsOK()) response = normalizedStatus.dump();
        return status;
      }
      case Impl::Kind::StageCancel:
        return EmptyResponseStatus(statusCode, body,
          "stage request cancellation");
      case Impl::Kind::StageDelete:
        return EmptyResponseStatus(statusCode, body, "stage request deletion");
      case Impl::Kind::Release:
        return EmptyResponseStatus(statusCode, body, "stage request release");
      case Impl::Kind::ArchiveInfo:
        if(statusCode != 200)
          return UnexpectedStatus(statusCode, body, "archiveinfo call");
        return ParseArchiveInfoResponse(body, pImpl->urls, pImpl->paths,
                                        response);
      case Impl::Kind::Invalid:
      case Impl::Kind::Discover:
        return ErrorStatus(XrdCl::errInternal,
          "invalid Tape REST operation state");
    }
    return ErrorStatus(XrdCl::errInternal, "invalid Tape REST operation");
  }

References XrdClHttp::TapeHttpRequest::body, XrdCl::errInternal, XrdCl::errInvalidArgs, XrdCl::errInvalidResponse, XrdCl::Status::IsOK(), XrdOucUtils::JoinUrl(), XrdClHttp::TapeHttpRequest::method, and XrdClHttp::TapeHttpRequest::url.

Here is the call graph for this function:

operator=()

TapeOperation& XrdClHttp::TapeOperation::operator= ( const TapeOperation &  )

delete

Start()

XrdCl::XRootDStatus XrdClHttp::TapeOperation::Start

(

TapeHttpRequest &

request

)

Definition at line 949 of file XrdClHttpTape.cc.

  {
    if(!pImpl->initialStatus.IsOK()) return pImpl->initialStatus;
    if(pImpl->kind == Impl::Kind::Invalid)
    {
      return ErrorStatus(XrdCl::errNotSupported,
        "unsupported HTTP Tape REST operation");
    }
 
    std::string endpoint;
    std::string path;
    std::string error;
    if(!UrlEndpointAndPath(pImpl->storageUrl, endpoint, path, error))
    {
      return ErrorStatus(XrdCl::errInvalidArgs, error);
    }
 
    request = TapeHttpRequest();
    request.url = XrdOucUtils::JoinUrl(
      endpoint, "/.well-known/wlcg-tape-rest-api");
    pImpl->phase = Impl::Phase::Discovery;
    return XrdCl::XRootDStatus();
  }

References XrdCl::errInvalidArgs, XrdCl::errNotSupported, XrdOucUtils::JoinUrl(), and XrdClHttp::TapeHttpRequest::url.

Here is the call graph for this function:

---

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

• XrdClHttpTape.hh
• XrdClHttpTape.cc