XrdHttpTapeApiStore Class Reference

#include <XrdHttpTapeApiStore.hh>

Collaboration diagram for XrdHttpTapeApiStore:

Classes
struct	Status

Public Member Functions
	XrdHttpTapeApiStore (std::filesystem::path root)
Status	ArchiveInfo (const nlohmann::json &paths, nlohmann::json &response)
Status	CancelStage (const std::string &requestId, const nlohmann::json &paths)
Status	CreateStage (const nlohmann::json &files, std::string &requestId)
Status	DeleteStage (const std::string &requestId)
Status	GetStage (const std::string &requestId, nlohmann::json &response)
Status	Initialize ()
Status	Release (const std::string &requestId, const nlohmann::json &paths)

Detailed Description

Definition at line 21 of file XrdHttpTapeApiStore.hh.

Constructor & Destructor Documentation

XrdHttpTapeApiStore()

XrdHttpTapeApiStore::XrdHttpTapeApiStore ( std::filesystem::path  root )

explicit

Definition at line 60 of file XrdHttpTapeApiStore.cc.

  : m_root(std::move(root)),
    m_archiveRoot(m_root / "archive"),
    m_diskRoot(m_root / "disk"),
    m_requestsRoot(m_root / "requests")
{
}

Member Function Documentation

ArchiveInfo()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::ArchiveInfo	(	const nlohmann::json &	paths,
		nlohmann::json &	response
	)

Definition at line 381 of file XrdHttpTapeApiStore.cc.

{
  std::lock_guard<std::mutex> lock(m_mutex);
  response = Json::array();
  for(const auto &path : paths)
  {
    Json item;
    std::string normalized;
    fs::path archivePath;
    Status status = ResolvePath(m_archiveRoot, path.get<std::string>(),
                                normalized, archivePath);
    item["path"] = status ? normalized : path.get<std::string>();
 
    fs::path diskPath;
    if(status) status = ResolvePath(m_diskRoot, normalized,
                                    normalized, diskPath);
    bool archived = false;
    if(status && !IsRegularFile(archivePath, archived))
    {
      status = Error(500, "could not inspect the archived file");
    }
    bool onDisk = false;
    if(status && !IsRegularFile(diskPath, onDisk))
    {
      status = Error(500, "could not inspect the disk file");
    }
 
    if(!status)
    {
      item["error"] = status.message;
    }
    else if(archived && onDisk)
    {
      item["locality"] = "DISK_AND_TAPE";
    }
    else if(archived)
    {
      item["locality"] = "TAPE";
    }
    else if(onDisk)
    {
      item["locality"] = "DISK";
    }
    else
    {
      item["error"] = "file does not exist";
    }
    response.push_back(std::move(item));
  }
  return {};
}

References Error, and XrdHttpTapeApiStore::Status::message.

CancelStage()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::CancelStage	(	const std::string &	requestId,
		const nlohmann::json &	paths
	)

Definition at line 329 of file XrdHttpTapeApiStore.cc.

{
  std::lock_guard<std::mutex> lock(m_mutex);
  Json request;
  Status status = ReadRequest(requestId, request);
  if(!status) return status;
  std::vector<std::string> normalized;
  return ValidateRequestPaths(request, paths, normalized);
}

CreateStage()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::CreateStage	(	const nlohmann::json &	files,
		std::string &	requestId
	)

Definition at line 219 of file XrdHttpTapeApiStore.cc.

{
  std::lock_guard<std::mutex> lock(m_mutex);
  requestId = GenerateRequestId();
  const std::uint64_t createdAt = Now();
  Json request = {
    {"id", requestId},
    {"createdAt", createdAt},
    {"startedAt", createdAt},
    {"files", Json::array()}
  };
 
  for(const auto &input : files)
  {
    Json file = input;
    std::string normalized;
    fs::path archivePath;
    Status status = ResolvePath(m_archiveRoot,
                                input.at("path").get<std::string>(),
                                normalized, archivePath);
    file["path"] = normalized;
    file["startedAt"] = createdAt;
 
    fs::path diskPath;
    if(status) status = ResolvePath(m_diskRoot, normalized,
                                    normalized, diskPath);
    bool archived = false;
    if(status && !IsRegularFile(archivePath, archived))
    {
      status = Error(500, "could not inspect the archived file");
    }
    std::error_code error;
    if(status && archived && fs::file_size(archivePath, error) == 0)
    {
      status = Error(400, "zero-length files cannot be staged from tape");
    }
    if(error) status = Error(500, "could not inspect the archived file");
 
    bool onDisk = false;
    if(status && !IsRegularFile(diskPath, onDisk))
    {
      status = Error(500, "could not inspect the disk file");
    }
    if(status && archived && !onDisk)
    {
      error.clear();
      fs::create_directories(diskPath.parent_path(), error);
      if(!error)
      {
        fs::copy_file(archivePath, diskPath, fs::copy_options::overwrite_existing,
                      error);
      }
      if(error) status = Error(500, "could not stage the archived file");
    }
    file["finishedAt"] = Now();
    if(status && archived)
    {
      file["state"] = "COMPLETED";
    }
    else
    {
      file["state"] = "FAILED";
      file["error"] = status ? "file is not stored on tape" : status.message;
    }
    request["files"].push_back(std::move(file));
  }
 
  request["completedAt"] = Now();
  return WriteRequest(request);
}

References Error, and XrdHttpTapeApiStore::Status::message.

DeleteStage()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::DeleteStage

(

const std::string &

requestId

)

Definition at line 340 of file XrdHttpTapeApiStore.cc.

{
  std::lock_guard<std::mutex> lock(m_mutex);
  Json request;
  Status status = ReadRequest(requestId, request);
  if(!status) return status;
 
  std::error_code error;
  if(!fs::remove(m_requestsRoot / (requestId + ".json"), error) || error)
  {
    return Error(500, "could not delete the stage request");
  }
  return {};
}

References Error.

GetStage()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::GetStage	(	const std::string &	requestId,
		nlohmann::json &	response
	)

Definition at line 291 of file XrdHttpTapeApiStore.cc.

{
  std::lock_guard<std::mutex> lock(m_mutex);
  Json request;
  const Status status = ReadRequest(requestId, request);
  if(!status) return status;
  response = StatusResponse(request);
  return {};
}

Initialize()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::Initialize

(

)

Definition at line 68 of file XrdHttpTapeApiStore.cc.

{
  std::error_code error;
  fs::create_directories(m_archiveRoot, error);
  if(error) return Error(500, "could not create the tape archive directory");
  fs::create_directories(m_diskRoot, error);
  if(error) return Error(500, "could not create the disk directory");
  fs::create_directories(m_requestsRoot, error);
  if(error) return Error(500, "could not create the request directory");
 
  m_root = fs::weakly_canonical(m_root, error);
  if(error) return Error(500, "could not resolve the Tape API directory");
  m_archiveRoot = m_root / "archive";
  m_diskRoot = m_root / "disk";
  m_requestsRoot = m_root / "requests";
  return {};
}

References Error.

Release()

XrdHttpTapeApiStore::Status XrdHttpTapeApiStore::Release	(	const std::string &	requestId,
		const nlohmann::json &	paths
	)

Definition at line 356 of file XrdHttpTapeApiStore.cc.

{
  std::lock_guard<std::mutex> lock(m_mutex);
  Json request;
  Status status = ReadRequest(requestId, request);
  if(!status) return status;
 
  std::vector<std::string> normalized;
  status = ValidateRequestPaths(request, paths, normalized);
  if(!status) return status;
 
  for(const auto &path : normalized)
  {
    std::string ignored;
    fs::path diskPath;
    status = ResolvePath(m_diskRoot, path, ignored, diskPath);
    if(!status) return status;
    std::error_code error;
    fs::remove(diskPath, error);
    if(error) return Error(500, "could not release the disk replica");
  }
  return {};
}

References Error.

---

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

• XrdHttpTapeApiStore.hh
• XrdHttpTapeApiStore.cc