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.

common/log/LogContextTest.cpp

@@ -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));
   }
 }

objectstore/ObjectOps.hpp

@@ -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();
   }
 

objectstore/RetrieveQueue.cpp

@@ -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;
 }
 

objectstore/RetrieveQueue.hpp

@@ -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();

objectstore/RetrieveRequest.cpp

@@ -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();

objectstore/RetrieveRequest.hpp

@@ -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();
   

objectstore/RootEntry.cpp

@@ -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__);
 }

objectstore/RootEntry.hpp

@@ -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;

objectstore/ValueCountMap.cpp

@@ -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) {

objectstore/cta.proto

@@ -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;

scheduler/OStoreDB/OStoreDB.hpp

@@ -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  ========================================= */

scheduler/RetrieveJob.cpp

@@ -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;
+  }
+}
+

scheduler/RetrieveJob.hpp

@@ -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;
   
   /**