Commit 78f52207 authored by Eric Cano's avatar Eric Cano
Browse files

Completed changes so that archive and retrieves can be queued, mounts created...

Completed changes so that archive and retrieves can be queued, mounts created and jobs reported done.
parent 3462d8f3
......@@ -37,12 +37,12 @@ namespace unitTests {
ASSERT_EQ(1U, lc.size());
{
// Create an anonymous variable (for its scope)
LogContext::ScopedParam sp(lc, Param("NSFILEID", 12345));
LogContext::ScopedParam sp(lc, Param("archiveFileID", 12345));
ASSERT_EQ(2U, lc.size());
lc.log(DEBUG, "Two params message");
{
// Test that we do not allow duplicate params
LogContext::ScopedParam sp(lc, Param("NSFILEID", 123456));
LogContext::ScopedParam sp(lc, Param("archiveFileID", 123456));
ASSERT_EQ(2U, lc.size());
LogContext::ScopedParam sp2(lc, Param("TPVID", "T1234"));
ASSERT_EQ(3U, lc.size());
......@@ -62,16 +62,16 @@ namespace unitTests {
std::string first = sl.getLog();
ASSERT_NE(std::string::npos, first.find("MigrationRequestId"));
{
LogContext::ScopedParam sp(lc, Param("NSFILEID", 12345));
LogContext::ScopedParam sp(lc, Param("archiveFileID", 12345));
lc.log(INFO, "Second log");
}
std::string second = sl.getLog();
ASSERT_NE(std::string::npos, second.find("NSFILEID"));
ASSERT_NE(std::string::npos, second.find("archiveFileID"));
// We expect the NSFILEID parameter to show up only once (i.e, not after
// offset, which marks the end of its first occurrence).
lc.log(INFO, "Third log");
std::string third = sl.getLog();
size_t offset = third.find("NSFILEID") + strlen("NSFILEID");
ASSERT_EQ(std::string::npos, third.find("NSFILEID", offset));
size_t offset = third.find("archiveFileID") + strlen("archiveFileID");
ASSERT_EQ(std::string::npos, third.find("archiveFileID", offset));
}
}
......@@ -108,18 +108,22 @@ public:
}
void setOwner(const std::string & owner) {
checkHeaderWritable();
m_header.set_owner(owner);
}
std::string getOwner() {
checkHeaderReadable();
return m_header.owner();
}
void setBackupOwner(const std::string & owner) {
checkHeaderWritable();
m_header.set_backupowner(owner);
}
std::string getBackupOwner() {
checkHeaderReadable();
return m_header.backupowner();
}
......
......@@ -87,12 +87,17 @@ std::string cta::objectstore::RetrieveQueue::dump() {
return ret.str();
}
void cta::objectstore::RetrieveQueue::addJob(const RetrieveRequest::JobDump& job,
void cta::objectstore::RetrieveQueue::addJob(uint64_t copyNb,
const std::string & retrieveRequestAddress, uint64_t size,
const cta::common::dataStructures::MountPolicy & policy, time_t startTime) {
checkPayloadWritable();
// Keep track of the mounting criteria
ValueCountMap maxDriveAllowedMap(m_payload.mutable_maxdrivesallowedmap());
maxDriveAllowedMap.incCount(policy.maxDrivesAllowed);
ValueCountMap priorityMap(m_payload.mutable_prioritymap());
priorityMap.incCount(policy.retrievePriority);
ValueCountMap minRetrieveRequestAgeMap(m_payload.mutable_minretrieverequestagemap());
minRetrieveRequestAgeMap.incCount(policy.retrieveMinRequestAge);
if (m_payload.retrievejobs_size()) {
if (m_payload.oldestjobcreationtime() > (uint64_t)startTime) {
m_payload.set_oldestjobcreationtime(startTime);
......@@ -105,7 +110,7 @@ void cta::objectstore::RetrieveQueue::addJob(const RetrieveRequest::JobDump& job
auto * j = m_payload.add_retrievejobs();
j->set_address(retrieveRequestAddress);
j->set_size(size);
j->set_copynb(job.tapeFile.copyNb);
j->set_copynb(copyNb);
}
cta::objectstore::RetrieveQueue::JobsSummary cta::objectstore::RetrieveQueue::getJobsSummary() {
......@@ -114,6 +119,18 @@ cta::objectstore::RetrieveQueue::JobsSummary cta::objectstore::RetrieveQueue::ge
ret.bytes = m_payload.retrievejobstotalsize();
ret.files = m_payload.retrievejobs_size();
ret.oldestJobStartTime = m_payload.oldestjobcreationtime();
if (ret.files) {
ValueCountMap maxDriveAllowedMap(m_payload.mutable_maxdrivesallowedmap());
ret.maxDrivesAllowed = maxDriveAllowedMap.maxValue();
ValueCountMap priorityMap(m_payload.mutable_prioritymap());
ret.priority = priorityMap.maxValue();
ValueCountMap minArchiveRequestAgeMap(m_payload.mutable_minretrieverequestagemap());
ret.minArchiveRequestAge = minArchiveRequestAgeMap.minValue();
} else {
ret.maxDrivesAllowed = 0;
ret.priority = 0;
ret.minArchiveRequestAge = 0;
}
return ret;
}
......
......@@ -41,7 +41,7 @@ public:
std::string dump();
// Retrieve jobs management ==================================================
void addJob(const RetrieveRequest::JobDump & job,
void addJob(uint64_t copyNb,
const std::string & retrieveRequestAddress, uint64_t size,
const cta::common::dataStructures::MountPolicy & policy, time_t startTime);
struct JobsSummary {
......@@ -49,6 +49,8 @@ public:
uint64_t bytes;
time_t oldestJobStartTime;
uint64_t priority;
uint64_t minArchiveRequestAge;
uint64_t maxDrivesAllowed;
};
JobsSummary getJobsSummary();
std::list<RetrieveRequestDump> dumpAndFetchRetrieveRequests();
......
......@@ -21,6 +21,7 @@
#include "EntryLogSerDeser.hpp"
#include "MountPolicySerDeser.hpp"
#include "DiskFileInfoSerDeser.hpp"
#include "ArchiveFileSerDeser.hpp"
#include "objectstore/cta.pb.h"
#include <json-c/json.h>
......@@ -45,10 +46,10 @@ void RetrieveRequest::initialize() {
m_payloadInterpreted = true;
}
void RetrieveRequest::addJob(const cta::common::dataStructures::TapeFile & tapeFile, uint16_t maxRetiesWithinMount, uint16_t maxTotalRetries) {
void RetrieveRequest::addJob(uint64_t copyNb, uint16_t maxRetiesWithinMount, uint16_t maxTotalRetries) {
checkPayloadWritable();
auto *tf = m_payload.add_jobs();
TapeFileSerDeser(tapeFile).serialize(*tf->mutable_tapefile());
tf->set_copynb(copyNb);
tf->set_maxretrieswithinmount(maxRetiesWithinMount);
tf->set_maxtotalretries(maxTotalRetries);
tf->set_retrieswithinmount(0);
......@@ -60,7 +61,7 @@ bool RetrieveRequest::setJobSuccessful(uint16_t copyNumber) {
checkPayloadWritable();
auto * jl = m_payload.mutable_jobs();
for (auto j=jl->begin(); j!=jl->end(); j++) {
if (j->tapefile().copynb() == copyNumber) {
if (j->copynb() == copyNumber) {
j->set_status(serializers::RetrieveJobStatus::RJS_Complete);
for (auto j2=jl->begin(); j2!=jl->end(); j2++) {
if (j2->status()!= serializers::RetrieveJobStatus::RJS_Complete &&
......@@ -113,17 +114,29 @@ cta::common::dataStructures::RetrieveRequest RetrieveRequest::getSchedulerReques
return ret;
}
//------------------------------------------------------------------------------
// getArchiveFile
//------------------------------------------------------------------------------
cta::common::dataStructures::ArchiveFile RetrieveRequest::getArchiveFile() {
objectstore::ArchiveFileSerDeser af;
af.deserialize(m_payload.archivefile());
return af;
}
//------------------------------------------------------------------------------
// setRetrieveFileQueueCriteria
//------------------------------------------------------------------------------
void RetrieveRequest::setRetrieveFileQueueCriteria(const cta::common::dataStructures::RetrieveFileQueueCriteria& criteria) {
checkPayloadWritable();
ArchiveFileSerDeser(criteria.archiveFile).serialize(*m_payload.mutable_archivefile());
for (auto &tf: criteria.archiveFile.tapeFiles) {
MountPolicySerDeser(criteria.mountPolicy).serialize(*m_payload.mutable_mountpolicy());
const uint32_t hardcodedRetriesWithinMount = 3;
const uint32_t hardcodedTotalRetries = 6;
addJob(tf.second, hardcodedRetriesWithinMount, hardcodedTotalRetries);
addJob(tf.second.copyNb, hardcodedRetriesWithinMount, hardcodedTotalRetries);
}
}
......@@ -135,9 +148,7 @@ auto RetrieveRequest::dumpJobs() -> std::list<JobDump> {
std::list<JobDump> ret;
for (auto & j: m_payload.jobs()) {
ret.push_back(JobDump());
TapeFileSerDeser tf;
tf.deserialize(j.tapefile());
ret.back().tapeFile=tf;
ret.back().copyNb=j.copynb();
ret.back().maxRetriesWithinMount=j.maxretrieswithinmount();
ret.back().maxTotalRetries=j.maxtotalretries();
ret.back().retriesWithinMount=j.retrieswithinmount();
......@@ -154,15 +165,14 @@ auto RetrieveRequest::getJob(uint16_t copyNb) -> JobDump {
checkPayloadReadable();
// find the job
for (auto & j: m_payload.jobs()) {
if (j.tapefile().copynb()==copyNb) {
if (j.copynb()==copyNb) {
JobDump ret;
TapeFileSerDeser tf;
tf.deserialize(j.tapefile());
ret.tapeFile=tf;
ret.copyNb=copyNb;
ret.maxRetriesWithinMount=j.maxretrieswithinmount();
ret.maxTotalRetries=j.maxtotalretries();
ret.retriesWithinMount=j.retrieswithinmount();
ret.totalRetries=j.totalretries();
return ret;
}
}
throw NoSuchJob("In objectstore::RetrieveRequest::getJob(): job not found for this copyNb");
......@@ -173,9 +183,7 @@ auto RetrieveRequest::getJobs() -> std::list<JobDump> {
std::list<JobDump> ret;
for (auto & j: m_payload.jobs()) {
ret.push_back(JobDump());
TapeFileSerDeser tf;
tf.deserialize(j.tapefile());
ret.back().tapeFile=tf;
ret.back().copyNb=j.copynb();
ret.back().maxRetriesWithinMount=j.maxretrieswithinmount();
ret.back().maxTotalRetries=j.maxtotalretries();
ret.back().retriesWithinMount=j.retrieswithinmount();
......
......@@ -43,15 +43,13 @@ public:
RetrieveRequest(GenericObject & go);
void initialize();
// Job management ============================================================
void addJob(const cta::common::dataStructures::TapeFile & tapeFile, uint16_t maxRetiesWithinMount, uint16_t maxTotalRetries);
void setJobFailureLimits(uint16_t copyNumber,
uint16_t maxRetiesWithinMount, uint16_t maxTotalRetries);
void addJob(uint64_t copyNumber, uint16_t maxRetiesWithinMount, uint16_t maxTotalRetries);
void setJobSelected(uint16_t copyNumber, const std::string & owner);
void setJobPending(uint16_t copyNumber);
bool setJobSuccessful(uint16_t copyNumber); //< returns true if this is the last job
class JobDump {
public:
common::dataStructures::TapeFile tapeFile;
uint64_t copyNb;
uint32_t maxTotalRetries;
uint32_t maxRetriesWithinMount;
uint32_t retriesWithinMount;
......@@ -83,6 +81,9 @@ public:
void setSchedulerRequest(const cta::common::dataStructures::RetrieveRequest & retrieveRequest);
cta::common::dataStructures::RetrieveRequest getSchedulerRequest();
void setArchiveFile(const cta::common::dataStructures::ArchiveFile & archiveFile);
cta::common::dataStructures::ArchiveFile getArchiveFile();
void setRetrieveFileQueueCriteria(const cta::common::dataStructures::RetrieveFileQueueCriteria& criteria);
cta::common::dataStructures::RetrieveFileQueueCriteria getRetrieveFileQueueCriteria();
......
......@@ -132,11 +132,11 @@ std::string RootEntry::addOrGetArchiveQueueAndCommit(const std::string& tapePool
void RootEntry::removeArchiveQueueAndCommit(const std::string& tapePool) {
checkPayloadWritable();
// find the address of the tape pool object
// find the address of the archive queue object
try {
auto tpp = serializers::findElement(m_payload.archivequeuepointers(), tapePool);
auto aqp = serializers::findElement(m_payload.archivequeuepointers(), tapePool);
// Open the tape pool object
ArchiveQueue aq (tpp.address(), ObjectOps<serializers::RootEntry, serializers::RootEntry_t>::m_objectStore);
ArchiveQueue aq (aqp.address(), m_objectStore);
ScopedExclusiveLock aql;
try {
aql.lock(aq);
......@@ -156,16 +156,16 @@ void RootEntry::removeArchiveQueueAndCommit(const std::string& tapePool) {
// Verify this is the archive queue we're looking for.
if (aq.getTapePool() != tapePool) {
std::stringstream err;
err << "Unexpected tape pool name found in archive queue pointed to for tape pool: "
err << "In RootEntry::removeArchiveQueueAndCommit(): Unexpected tape pool name found in archive queue pointed to for tape pool: "
<< tapePool << " found: " << aq.getTapePool();
throw WrongArchiveQueue(err.str());
}
// Check the archive queue is empty
if (!aq.isEmpty()) {
throw ArchivelQueueNotEmpty ("In RootEntry::removeTapePoolQueueAndCommit: trying to "
throw ArchivelQueueNotEmpty ("In RootEntry::removeArchiveQueueAndCommit(): trying to "
"remove a non-empty tape pool");
}
// We can delete the pool
// We can delete the queue
aq.remove();
deleteFromRootEntry:
// ... and remove it from our entry
......@@ -174,7 +174,7 @@ void RootEntry::removeArchiveQueueAndCommit(const std::string& tapePool) {
commit();
} catch (serializers::NotFound &) {
// No such tape pool. Nothing to to.
throw NoSuchArchiveQueue("In RootEntry::removeTapePoolQueueAndCommit: trying to remove non-existing tape pool");
throw NoSuchArchiveQueue("In RootEntry::removeArchiveQueueAndCommit(): trying to remove non-existing archive queue");
}
}
......@@ -250,6 +250,55 @@ std::string RootEntry::addOrGetRetrieveQueueAndCommit(const std::string& vid, Ag
return retrieveQueueAddress;
}
void RootEntry::removeRetrieveQueueAndCommit(const std::string& vid) {
checkPayloadWritable();
// find the address of the retrieve queue object
try {
auto rqp=serializers::findElement(m_payload.retrievequeuepointers(), vid);
// Open the retrieve queue object
RetrieveQueue rq(rqp.address(), m_objectStore);
ScopedExclusiveLock rql;
try {
rql.lock(rq);
rq.fetch();
} catch (cta::exception::Exception & ex) {
// The archive queue seems to not be there. Make sure this is the case:
if (rq.exists()) {
// We failed to access the queue, yet it is present. This is an error.
// Let the exception pass through.
throw;
} else {
// The queue object is already gone. We can skip to removing the
// reference from the RootEntry
goto deleteFromRootEntry;
}
}
// Verify this is the retrieve queue we're looking for.
if (rq.getVid() != vid) {
std::stringstream err;
err << "Unexpected vid found in retrieve queue pointed to for vid: "
<< vid << " found: " << rq.getVid();
throw WrongArchiveQueue(err.str());
}
// Check the retrieve queue is empty
if (!rq.isEmpty()) {
throw RetrieveQueueNotEmpty("In RootEntry::removeTapePoolQueueAndCommit: trying to "
"remove a non-empty tape pool");
}
// We can now delete the queue
rq.remove();
deleteFromRootEntry:
// ... and remove it from our entry
serializers::removeOccurences(m_payload.mutable_retrievequeuepointers(), vid);
// We commit for safety and symmetry with the add operation
commit();
} catch (serializers::NotFound &) {
// No such tape pool. Nothing to to.
throw NoSuchRetrieveQueue("In RootEntry::addOrGetRetrieveQueueAndCommit: trying to remove non-existing retrieve queue");
}
}
std::string RootEntry::getRetrieveQueue(const std::string& vid) {
throw cta::exception::Exception(std::string("Not implemented: ") + __PRETTY_FUNCTION__);
}
......
......@@ -69,10 +69,12 @@ public:
std::list<ArchiveQueueDump> dumpArchiveQueues();
// RetrieveQueue handling ====================================================
CTA_GENERATE_EXCEPTION_CLASS(RetrieveQueueNotEmpty);
/** This function implicitly creates the retrieve queue structure and updates
* the pointer to it. It will implicitly commit the object to the store. */
std::string addOrGetRetrieveQueueAndCommit(const std::string & vid, Agent & agent);
CTA_GENERATE_EXCEPTION_CLASS(NoSuchRetrieveQueue);
void removeRetrieveQueueAndCommit(const std::string & vid);
std::string getRetrieveQueue(const std::string & vid);
struct RetrieveQueueDump {
std::string vid;
......
......@@ -88,7 +88,8 @@ void ValueCountMap::incCount(uint64_t value) {
}
uint64_t ValueCountMap::maxValue() {
if (!m_valueCountMap.size()) throw cta::exception::Exception("In ValueCountMap::maxValue: empty map");
if (!m_valueCountMap.size())
throw cta::exception::Exception("In ValueCountMap::maxValue: empty map");
uint64_t ret = std::numeric_limits<uint64_t>::min();
std::for_each(m_valueCountMap.begin(), m_valueCountMap.end(),
[&](decltype(*m_valueCountMap.begin()) pair) {
......
......@@ -180,13 +180,36 @@ message MountCriteria {
required uint32 quota = 3203;
}
message TapeFile {
required string vid = 9120;
required uint64 fseq = 9121;
required uint64 blockid = 9122;
required uint64 compressedsize = 9123;
required uint64 copynb = 9124;
required uint64 creationtime = 9125;
required string checksumtype = 9126;
required string checksumvalue = 9127;
}
message DiskFileInfo {
required string recoveryBlob = 8900;
required string group = 8910;
required string owner = 8930;
required string path = 8940;
}
message ArchiveFile {
required uint64 fileId = 4351;
required uint64 size = 4352;
required uint64 archivefileid = 4351;
required uint64 filesize = 4352;
required string diskfileid = 4353;
required string checksumtype = 4354;
required string checksumvalue = 4355;
required uint64 creationtime = 4356;
required string diskinstance= 4354;
required DiskFileInfo diskfileinfo= 4355;
required string checksumtype = 4356;
required string checksumvalue = 4357;
required uint64 creationtime = 4358;
repeated TapeFile tapefiles = 4359;
required uint64 reconciliationtime = 4360;
required string storageclass = 4361;
}
// ------------- Archive Jobs --------------------------------------------------
......@@ -307,13 +330,6 @@ message User {
required string group = 8810;
}
message DiskFileInfo {
required string recoveryBlob = 8900;
required string group = 8910;
required string owner = 8930;
required string path = 8940;
}
message EntryLog {
required string username = 8950;
required string host = 8960;
......@@ -362,19 +378,8 @@ message SchedulerRetrieveRequest {
required EntryLog entrylog = 9106;
}
message TapeFile {
required string vid = 9120;
required uint64 fseq = 9121;
required uint64 blockid = 9122;
required uint64 compressedsize = 9123;
required uint64 copynb = 9124;
required uint64 creationtime = 9125;
required string checksumtype = 9126;
required string checksumvalue = 9127;
}
message RetrieveJob {
required TapeFile tapefile = 9200;
required uint64 copynb = 9200;
required uint32 maxtotalretries = 9201;
required uint32 maxretrieswithinmount = 9202;
required uint32 retrieswithinmount = 9203;
......@@ -385,8 +390,9 @@ message RetrieveJob {
message RetrieveRequest {
required SchedulerRetrieveRequest schedulerrequest = 9150;
required MountPolicy mountpolicy = 9151;
required uint32 activecopynb = 9152;
repeated RetrieveJob jobs = 9153;
required ArchiveFile archivefile = 9152;
required uint32 activecopynb = 9153;
repeated RetrieveJob jobs = 9154;
}
message ValueCountPair {
......@@ -410,7 +416,7 @@ message RetrieveQueue {
required string vid = 10100;
repeated RetrieveJobPointer retrievejobs = 10110;
repeated ValueCountPair prioritymap = 10131;
repeated ValueCountPair minretrievequestagemap = 10132;
repeated ValueCountPair minretrieverequestagemap = 10132;
repeated ValueCountPair maxdrivesallowedmap = 10133;
required uint64 retrievejobstotalsize = 10140;
required uint64 oldestjobcreationtime = 10150;
......
This diff is collapsed.
......@@ -127,7 +127,7 @@ public:
/* === Retrieve Job handling ============================================== */
class RetrieveJob: public SchedulerDatabase::RetrieveJob {
friend class RetrieveMount;
friend class OStoreDB::RetrieveMount;
public:
CTA_GENERATE_EXCEPTION_CLASS(JobNowOwned);
CTA_GENERATE_EXCEPTION_CLASS(NoSuchJob);
......@@ -135,14 +135,14 @@ public:
virtual void fail() override;
virtual ~RetrieveJob() override;
private:
RetrieveJob(const std::string &, objectstore::Backend &, objectstore::Agent &);
RetrieveJob(const std::string &, objectstore::Backend &,
objectstore::Agent &, RetrieveMount &);
bool m_jobOwned;
uint16_t m_copyNb;
uint64_t m_mountId;
objectstore::Backend & m_objectStore;
objectstore::Agent & m_agent;
objectstore::RetrieveRequest m_retrieveRequest;
std::map<std::string, std::string> m_vidToAddress; /**< Cache of tape objects
* addresses filled up at queuing time */
RetrieveMount & m_retrieveMount;
};
/* === Archive requests handling ========================================= */
......
......@@ -28,14 +28,14 @@ cta::RetrieveJob::~RetrieveJob() throw() {
// constructor
//------------------------------------------------------------------------------
cta::RetrieveJob::RetrieveJob(RetrieveMount &mount,
const common::dataStructures::ArchiveFile &archiveFile,
const std::string &remotePath,
const common::dataStructures::TapeFile &tapeFile,
const common::dataStructures::RetrieveRequest &retrieveRequest,
const common::dataStructures::ArchiveFile & archiveFile,
const uint64_t selectedCopyNb,
const PositioningMethod positioningMethod):
m_mount(mount),
retrieveRequest(retrieveRequest),
archiveFile(archiveFile),
remotePath(remotePath),
tapeFile(tapeFile),
selectedCopyNb(selectedCopyNb),
positioningMethod(positioningMethod),
transferredSize(std::numeric_limits<decltype(transferredSize)>::max()) {}
......@@ -59,3 +59,28 @@ void cta::RetrieveJob::failed() {
void cta::RetrieveJob::retry() {
throw std::runtime_error("cta::RetrieveJob::retry(): not implemented");
}
//------------------------------------------------------------------------------
// selectedTapeFile
//------------------------------------------------------------------------------
cta::common::dataStructures::TapeFile& cta::RetrieveJob::selectedTapeFile() {
try {
return archiveFile.tapeFiles.at(selectedCopyNb);
} catch (std::out_of_range &ex) {
auto __attribute__((__unused__)) & debug=ex;
throw;
}
}
//------------------------------------------------------------------------------
// selectedTapeFile
//------------------------------------------------------------------------------
const cta::common::dataStructures::TapeFile& cta::RetrieveJob::selectedTapeFile() const {
try {
return archiveFile.tapeFiles.at(selectedCopyNb);
} catch (std::out_of_range &ex) {
auto __attribute__((__unused__)) & debug=ex;
throw;
}
}
......@@ -53,9 +53,9 @@ public:
* @param positioningMethod the positioning method
*/
RetrieveJob(RetrieveMount &mount,
const common::dataStructures::ArchiveFile &archiveFile,
const std::string &remotePath,
const common::dataStructures::TapeFile &tapeFileLocation,
const common::dataStructures::RetrieveRequest &retrieveRequest,
const common::dataStructures::ArchiveFile & archiveFile,
const uint64_t selectedCopyNb,
const PositioningMethod positioningMethod);
private:
......@@ -93,6 +93,16 @@ public:
*/
void retry();
/**
* Helper function returning a reference to the currently selected tape file.
*/
common::dataStructures::TapeFile & selectedTapeFile();
/**
* Helper function returning a reference to the currently selected tape file (const variant).
*/
const common::dataStructures::TapeFile & selectedTapeFile() const;
/**
* The mount to which the job belongs.
*/
......@@ -101,17 +111,17 @@ public:
/**
* The NS archive file information
*/
common::dataStructures::ArchiveFile archiveFile;
common::dataStructures::RetrieveRequest retrieveRequest;
/**
* The remote file path
* The full information about the file
*/
std::string remotePath;
common::dataStructures::ArchiveFile archiveFile;
/**
* The location of the tape file
* CopyNb of the selected tape file
*/
common::dataStructures::TapeFile tapeFile;
uint64_t selectedCopyNb;
/**