[lto_rao] InterpolationFilePositionEstimator WIP

cta.spec.in

@@ -295,6 +295,7 @@ Unit tests and system tests with virtual tape drives
 %{_libdir}/libctamediachangerunittests.so*
 %{_libdir}/libctadiskunittests.so*
 %{_libdir}/libctatapelabelunittests.so*
+%{_libdir}/libctatapeserverraounittests.so*
 %{_bindir}/cta-systemTests
 %{_libdir}/libctadaemonunittests-multiprocess.so*
 %attr(0644,root,root) %{_datadir}/%{name}-%{ctaVersion}/unittest/*.suppr

tapeserver/castor/tape/tapeserver/RAO/CMakeLists.txt

@@ -4,7 +4,7 @@ include_directories(${PROJECT_SOURCE_DIR}/tapeserver)
 include_directories(${PROJECT_SOURCE_DIR}/tapeserver/h)
 
 set(CTARAO_LIBRARY_SRCS
-  RAOConfigurationData.cpp
+  RAOParams.cpp
   RAOManager.cpp
   RAOAlgorithm.cpp
   EnterpriseRAOAlgorithm.cpp
@@ -22,9 +22,18 @@ set(CTARAO_LIBRARY_SRCS
   Position.cpp
   FilePositionEstimator.cpp
   InterpolationFilePositionEstimator.cpp
+  RAOHelpers.cpp
 )
 
 add_library (ctarao SHARED
   ${CTARAO_LIBRARY_SRCS})
 
-install(TARGETS ctarao DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
\ No newline at end of file
+install(TARGETS ctarao DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
+
+add_library(ctatapeserverraounittests SHARED
+  RAOTest.cpp)
+
+set_property(TARGET ctatapeserverraounittests PROPERTY SOVERSION "${CTA_SOVERSION}")
+set_property(TARGET ctatapeserverraounittests PROPERTY   VERSION "${CTA_LIBVERSION}")
+
+install(TARGETS ctatapeserverraounittests DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
\ No newline at end of file

tapeserver/castor/tape/tapeserver/RAO/ConfigurableRAOAlgorithmFactory.cpp

@@ -22,17 +22,17 @@
 
 namespace castor { namespace tape { namespace tapeserver { namespace rao {
 
-ConfigurableRAOAlgorithmFactory::ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOConfigurationData & raoConfigurationData):m_drive(drive),
-    m_catalogue(catalogue), m_raoConfigurationData(raoConfigurationData){}
+ConfigurableRAOAlgorithmFactory::ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOParams & raoParams):m_drive(drive),
+    m_catalogue(catalogue), m_raoParams(raoParams){}
 
 ConfigurableRAOAlgorithmFactory::~ConfigurableRAOAlgorithmFactory() {
 }
 
 std::unique_ptr<RAOAlgorithm> ConfigurableRAOAlgorithmFactory::createRAOAlgorithm() {
   std::unique_ptr<RAOAlgorithm> ret;
-  switch(m_raoConfigurationData.getAlgorithmType()){
-    case RAOConfigurationData::RAOAlgorithmType::sltf:{
-      SLTFRAOAlgorithm::Builder builder(m_raoConfigurationData,m_drive,m_catalogue);
+  switch(m_raoParams.getAlgorithmType()){
+    case RAOParams::RAOAlgorithmType::sltf:{
+      SLTFRAOAlgorithm::Builder builder(m_raoParams,m_drive,m_catalogue);
       ret.reset(builder.build().release());
       break;
     }

tapeserver/castor/tape/tapeserver/RAO/ConfigurableRAOAlgorithmFactory.hpp

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RAOConfigurationData.hpp"
+#include "RAOParams.hpp"
 #include "RAOAlgorithmFactory.hpp"
 #include "castor/tape/tapeserver/drive/DriveInterface.hpp"
 #include "RAOManager.hpp"
@@ -27,13 +27,13 @@ namespace castor { namespace tape { namespace tapeserver { namespace rao {
   
 class ConfigurableRAOAlgorithmFactory : public RAOAlgorithmFactory{
 public:
-  ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOConfigurationData & raoConfigurationData);
+  ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOParams & raoParams);
   std::unique_ptr<RAOAlgorithm> createRAOAlgorithm() override;
   virtual ~ConfigurableRAOAlgorithmFactory();
 private:
   drive::DriveInterface * m_drive;
   cta::catalogue::Catalogue * m_catalogue;
-  RAOConfigurationData m_raoConfigurationData;
+  RAOParams m_raoParams;
 };
 
 }}}}

tapeserver/castor/tape/tapeserver/RAO/InterpolationFilePositionEstimator.cpp

@@ -28,7 +28,62 @@ InterpolationFilePositionEstimator::~InterpolationFilePositionEstimator() {
 }
 
 FilePosition InterpolationFilePositionEstimator::getFilePosition(const cta::RetrieveJob& job) const {
-  return FilePosition();
+  FilePosition ret;
+  cta::common::dataStructures::TapeFile tapeFile = job.selectedTapeFile();
+  uint64_t startBlock = tapeFile.blockId;
+  Position startPosition = getPhysicalPosition(startBlock);
+  ret.setStartPosition(startPosition);
+  
+  return ret;
+}
+
+Position InterpolationFilePositionEstimator::getPhysicalPosition(const uint64_t blockId) const {
+  Position ret;
+  ret.setWrap(determineWrapNb(blockId));
+  ret.setLPos(determineLPos(blockId,ret.getWrap()));
+  return ret;
+}
+
+uint64_t InterpolationFilePositionEstimator::determineWrapNb(const uint64_t blockId) const {
+  if(m_endOfWrapPositions.empty()){
+    std::string errorMsg = "In InterpolationFilePositionEstimator::determineWrapNb(), unable to find the wrap number of the blockId " + std::to_string(blockId) + " because no EOWP informations have been found.";
+    throw cta::exception::Exception(errorMsg);
+  }
+  auto eowpItor = m_endOfWrapPositions.begin();
+  while(eowpItor != m_endOfWrapPositions.end() && blockId > eowpItor->blockId){
+    eowpItor++;
+  }
+  if(eowpItor == m_endOfWrapPositions.end()){
+    eowpItor--;
+    std::string errorMsg = "In InterpolationFilePositionEstimator::determineWrapNb(), the blockId " + std::to_string(blockId) + " is greater than the last wrap EOWP blockId ("+std::to_string(eowpItor->blockId)+")"; 
+    throw cta::exception::Exception(errorMsg);
+  }
+  return eowpItor->wrapNumber;
+}
+
+uint64_t InterpolationFilePositionEstimator::determineLPos(const uint64_t blockId, const uint64_t wrapNumber) const {
+  uint64_t fileLpos;
+  cta::optional<uint64_t> minTapeLpos = m_mediaType.minLPos;
+  cta::optional<uint64_t> maxTapeLpos = m_mediaType.maxLPos;
+  uint64_t fileBlockId = blockId;
+  if(!minTapeLpos || !maxTapeLpos){
+    std::string errorMsg = "In InterpolationFilePositionEstimator::determineLPos(), the media type (" + m_mediaType.name + ") associated to the tape tape does not give informations about the minLPos and maxLPos.";
+    throw cta::exception::Exception(errorMsg);
+  }
+  uint64_t minLpos = minTapeLpos.value();
+  uint64_t maxLpos = maxTapeLpos.value();
+  uint64_t b_max = m_endOfWrapPositions.at(wrapNumber).blockId;
+  if(wrapNumber > 0){
+    drive::endOfWrapPosition previousWrapPositionInfos = m_endOfWrapPositions.at(wrapNumber-1); 
+    b_max -= previousWrapPositionInfos.blockId;
+    fileBlockId -= previousWrapPositionInfos.blockId;
+  }
+  if(wrapNumber % 2 == 0){
+    fileLpos = minLpos + fileBlockId * (maxLpos - minLpos) / b_max;
+  } else {
+    fileLpos = maxLpos - fileBlockId * (maxLpos - minLpos) / b_max;
+  }
+  return fileLpos;
 }
 
 

tapeserver/castor/tape/tapeserver/RAO/InterpolationFilePositionEstimator.hpp

@@ -31,6 +31,9 @@ public:
   FilePosition getFilePosition(const cta::RetrieveJob& job) const override;
   virtual ~InterpolationFilePositionEstimator();
 private:
+  Position getPhysicalPosition(const uint64_t blockId) const;
+  uint64_t determineWrapNb(const uint64_t blockId) const;
+  uint64_t determineLPos(const uint64_t blockId, const uint64_t wrapNumber) const;
   std::vector<drive::endOfWrapPosition> m_endOfWrapPositions;
   cta::catalogue::MediaType m_mediaType;
 };

tapeserver/castor/tape/tapeserver/RAO/LinearRAOAlgorithm.hpp

@@ -23,16 +23,13 @@
 
 
 namespace castor { namespace tape { namespace tapeserver { namespace rao {
-
-class NonConfigurableRAOAlgorithmFactory;
   
 /**
  * This class represents a LinearRAOAlgorithm 
  */
 class LinearRAOAlgorithm : public RAOAlgorithm {
 public:
-  friend NonConfigurableRAOAlgorithmFactory;
-  
+  LinearRAOAlgorithm();
   /**
    * This method will return the indexes of the jobs that are reoreded in a linear way (sorted by fseq ascendant)
    * Example : if the fseqs of jobs in parameter are arranged like this [2, 3, 1, 4] the 
@@ -42,8 +39,7 @@ public:
    */
   std::vector<uint64_t> performRAO(const std::vector<std::unique_ptr<cta::RetrieveJob> >& jobs) override;
   virtual ~LinearRAOAlgorithm();
-private:
-  LinearRAOAlgorithm();
+
 };
 
 }}}}
\ No newline at end of file

tapeserver/castor/tape/tapeserver/RAO/NonConfigurableRAOAlgorithmFactory.cpp

@@ -22,7 +22,7 @@
 
 namespace castor { namespace tape { namespace tapeserver { namespace rao {
 
-NonConfigurableRAOAlgorithmFactory::NonConfigurableRAOAlgorithmFactory(const RAOConfigurationData::RAOAlgorithmType & type) : m_type(type) {
+NonConfigurableRAOAlgorithmFactory::NonConfigurableRAOAlgorithmFactory(const RAOParams::RAOAlgorithmType & type) : m_type(type) {
 }
 
 NonConfigurableRAOAlgorithmFactory::~NonConfigurableRAOAlgorithmFactory() {
@@ -31,11 +31,11 @@ NonConfigurableRAOAlgorithmFactory::~NonConfigurableRAOAlgorithmFactory() {
 std::unique_ptr<RAOAlgorithm> NonConfigurableRAOAlgorithmFactory::createRAOAlgorithm() {
   std::unique_ptr<RAOAlgorithm> ret;
   switch(m_type){
-    case RAOConfigurationData::linear:{
+    case RAOParams::linear:{
       ret.reset(new LinearRAOAlgorithm());
       break;
     }
-    case RAOConfigurationData::random:{
+    case RAOParams::random:{
       ret.reset(new RandomRAOAlgorithm());
       break;
     }

tapeserver/castor/tape/tapeserver/RAO/NonConfigurableRAOAlgorithmFactory.hpp

@@ -18,7 +18,7 @@
 
 #pragma once 
 
-#include "RAOConfigurationData.hpp"
+#include "RAOParams.hpp"
 #include "RAOAlgorithmFactory.hpp"
 
 namespace castor { namespace tape { namespace tapeserver { namespace rao {
@@ -35,7 +35,7 @@ public:
    * @param type the type given will be used by the createRAOAlgorithm() method
    * to instanciate the correct algorithm regarding its type
    */
-  NonConfigurableRAOAlgorithmFactory(const RAOConfigurationData::RAOAlgorithmType & type);
+  NonConfigurableRAOAlgorithmFactory(const RAOParams::RAOAlgorithmType & type);
   /**
    * Returns the correct instance of RAO algorithm regarding the type
    * given while constructing this factory.
@@ -44,7 +44,7 @@ public:
   std::unique_ptr<RAOAlgorithm> createRAOAlgorithm() override;
   virtual ~NonConfigurableRAOAlgorithmFactory();
 private:
-  RAOConfigurationData::RAOAlgorithmType m_type;
+  RAOParams::RAOAlgorithmType m_type;
 };
 
 }}}}
\ No newline at end of file

tapeserver/castor/tape/tapeserver/RAO/Position.cpp

@@ -26,19 +26,19 @@ Position::Position():m_wrap(0),m_lpos(0) {
 Position::~Position() {
 }
 
-uint32_t Position::getLPos() const {
+uint64_t Position::getLPos() const {
   return m_lpos;
 }
 
-uint32_t Position::getWrap() const {
+uint64_t Position::getWrap() const {
   return m_wrap;
-        }
+}
 
-void Position::setLPos(const uint32_t lpos) {
+void Position::setLPos(const uint64_t lpos) {
   m_lpos = lpos;
 }
 
-void Position::setWrap(const uint32_t wrap) {
+void Position::setWrap(const uint64_t wrap) {
   m_wrap = wrap;
 }
 

tapeserver/castor/tape/tapeserver/RAO/Position.hpp

@@ -26,13 +26,13 @@ class Position {
 public:
   Position();
   virtual ~Position();
-  uint32_t getWrap() const;
-  uint32_t getLPos() const;
-  void setWrap(const uint32_t wrap);
-  void setLPos(const uint32_t lpos);
+  uint64_t getWrap() const;
+  uint64_t getLPos() const;
+  void setWrap(const uint64_t wrap);
+  void setLPos(const uint64_t lpos);
 private:
-  uint32_t m_wrap;
-  unsigned int m_lpos;
+  uint64_t m_wrap;
+  uint64_t m_lpos;
 };
 
 }}}}

tapeserver/castor/tape/tapeserver/RAO/RAOAlgorithmFactory.cpp

@@ -18,6 +18,7 @@
 
 
 #include "RAOAlgorithmFactory.hpp"
+#include "LinearRAOAlgorithm.hpp"
 
 namespace castor { namespace tape { namespace tapeserver { namespace rao {
 
@@ -26,4 +27,11 @@ namespace castor { namespace tape { namespace tapeserver { namespace rao {
 RAOAlgorithmFactory::~RAOAlgorithmFactory() {
 }
 
+std::unique_ptr<RAOAlgorithm> RAOAlgorithmFactory::createDefaultLinearAlgorithm() {
+  std::unique_ptr<RAOAlgorithm> ret;
+  ret.reset(new LinearRAOAlgorithm());
+  return ret;
+}
+
+
 }}}}
\ No newline at end of file

tapeserver/castor/tape/tapeserver/RAO/RAOAlgorithmFactory.hpp

@@ -34,6 +34,9 @@ public:
    * @return the RAO algorithm instance
    */
   virtual std::unique_ptr<RAOAlgorithm> createRAOAlgorithm() = 0;
+  
+  std::unique_ptr<RAOAlgorithm> createDefaultLinearAlgorithm();
+  
   virtual ~RAOAlgorithmFactory();
 private:
 

tapeserver/castor/tape/tapeserver/RAO/RAOAlgorithmFactoryFactory.cpp

@@ -37,9 +37,9 @@ std::unique_ptr<RAOAlgorithmFactory> RAOAlgorithmFactoryFactory::createAlgorithm
       ret.reset(new EnterpriseRAOAlgorithmFactory(m_raoManager.getDrive(),maxFilesSupported.value()));
     } 
   } else {
-    RAOConfigurationData raoData = m_raoManager.getRAODataConfig();
+    RAOParams raoData = m_raoManager.getRAODataConfig();
     //We will instanciate a CTA RAO algorithm
-    RAOConfigurationData::RAOAlgorithmType raoAlgoType;
+    RAOParams::RAOAlgorithmType raoAlgoType;
     try {
       raoAlgoType = raoData.getAlgorithmType();
     } catch (const cta::exception::Exception & ex) {
@@ -49,16 +49,16 @@ std::unique_ptr<RAOAlgorithmFactory> RAOAlgorithmFactoryFactory::createAlgorithm
         " in the tapeserver configuration is " + raoData.getRAOAlgorithmName() + " the available algorithm names are " + raoData.getCTARAOAlgorithmNameAvailable()
         + ". We will apply a linear algorithm instead.";
       m_lc.log(cta::log::WARNING, msg);
-      raoAlgoType = RAOConfigurationData::RAOAlgorithmType::linear;
+      raoAlgoType = RAOParams::RAOAlgorithmType::linear;
     }
     switch(raoAlgoType){
-      case RAOConfigurationData::RAOAlgorithmType::linear:
-      case RAOConfigurationData::RAOAlgorithmType::random:
+      case RAOParams::RAOAlgorithmType::linear:
+      case RAOParams::RAOAlgorithmType::random:
       {
         ret.reset(new NonConfigurableRAOAlgorithmFactory(raoAlgoType));
         break;
       }
-      case RAOConfigurationData::RAOAlgorithmType::sltf:
+      case RAOParams::RAOAlgorithmType::sltf:
       { 
         ret.reset(new ConfigurableRAOAlgorithmFactory(m_raoManager.getDrive(),m_raoManager.getCatalogue(), raoData));
         break;

tapeserver/castor/tape/tapeserver/RAO/RAOAlgorithmFactoryFactory.hpp

@@ -41,7 +41,6 @@ public:
   /**
    * Returns the correct RAOAlgorithmFactory according to the informations
    * stored in the RAO manager
-   * @return 
    */
   std::unique_ptr<RAOAlgorithmFactory> createAlgorithmFactory();
   virtual ~RAOAlgorithmFactoryFactory();

tapeserver/castor/tape/tapeserver/RAO/RAOHelpers.cpp

+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2019  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "RAOHelpers.hpp"
+#include "tapeserver/castor/tape/tapeserver/drive/DriveInterface.hpp"
+
+namespace castor { namespace tape { namespace tapeserver { namespace rao {
+
+  void RAOHelpers::improveEndOfLastWrapPositionIfPossible(std::vector<drive::endOfWrapPosition>& endOfWrapPositions) {
+    uint64_t nbBlocksPerWrap = 0;
+    auto nbEndOfWrapPositions = endOfWrapPositions.size();
+    if(nbEndOfWrapPositions < 2){
+      //No improvement possible
+      return;
+    }
+    for(uint64_t i = 0; i < nbEndOfWrapPositions - 1; ++i){
+      nbBlocksPerWrap += (endOfWrapPositions.at(i).blockId - endOfWrapPositions.at(i-1).blockId);
+    }
+    uint64_t meanNbBlocksPerWrap = nbBlocksPerWrap / nbEndOfWrapPositions;
+    endOfWrapPositions[nbEndOfWrapPositions-1].blockId = endOfWrapPositions.at(nbEndOfWrapPositions-2).blockId + meanNbBlocksPerWrap;
+  }
+
+}}}}
\ No newline at end of file

tapeserver/castor/tape/tapeserver/RAO/RAOHelpers.hpp

+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2019  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <vector>
+#include "castor/tape/tapeserver/drive/DriveInterface.hpp"
+
+namespace castor { namespace tape { namespace tapeserver { namespace rao {
+  
+class RAOHelpers {
+public:
+  /**
+   * In the LTO documentation, the Read End Of Wrap Position (REOWP) command will not give the last
+   * wrap correct EOWP. It will give the last blockId written by the drive
+   * on the tape
+   * This method will modify the last wrap EOWP (blockId) from the vector of EOWP passed in parameter
+   * to set it to the penultimate wrap EOWP + the mean of the number of blocks each wrap contains 
+   */
+  static void improveEndOfLastWrapPositionIfPossible(std::vector<drive::endOfWrapPosition> & endOfWrapPositions);
+
+};
+
+}}}}
\ No newline at end of file

tapeserver/castor/tape/tapeserver/RAO/RAOManager.cpp

@@ -23,6 +23,7 @@
 #include "NonConfigurableRAOAlgorithmFactory.hpp"
 #include "RAOAlgorithmFactoryFactory.hpp"
 #include "catalogue/Catalogue.hpp"
+#include "LinearRAOAlgorithm.hpp"
 
 namespace castor { namespace tape { namespace tapeserver { namespace rao {
   
@@ -30,7 +31,7 @@ RAOManager::RAOManager() {
 
 }
   
-RAOManager::RAOManager(const RAOConfigurationData & config, drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue):m_raoConfigurationData(config), 
+RAOManager::RAOManager(const RAOParams & config, drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue):m_raoParams(config), 
   m_drive(drive), m_catalogue(catalogue){}
 
 RAOManager::RAOManager(const RAOManager& manager){
@@ -41,7 +42,7 @@ RAOManager::RAOManager(const RAOManager& manager){
     m_hasUDS = manager.m_hasUDS;
     m_isDriveEnterpriseEnabled = manager.m_isDriveEnterpriseEnabled;
     m_maxFilesSupported = manager.m_maxFilesSupported;
-    m_raoConfigurationData = manager.m_raoConfigurationData;
+    m_raoParams = manager.m_raoParams;
   }
 }
 
@@ -53,7 +54,7 @@ RAOManager& RAOManager::operator=(const RAOManager& manager) {
     m_hasUDS = manager.m_hasUDS;
     m_isDriveEnterpriseEnabled = manager.m_isDriveEnterpriseEnabled;
     m_maxFilesSupported = manager.m_maxFilesSupported;
-    m_raoConfigurationData = manager.m_raoConfigurationData;
+    m_raoParams = manager.m_raoParams;
   }
   return *this;
 }
@@ -63,7 +64,7 @@ RAOManager::~RAOManager() {
 }
 
 bool RAOManager::useRAO() const{
-  return m_raoConfigurationData.useRAO();
+  return m_raoParams.useRAO();
 }
 
 bool RAOManager::hasUDS() const {
@@ -84,7 +85,7 @@ cta::catalogue::Catalogue* RAOManager::getCatalogue() const {
 
 
 void RAOManager::disableRAO(){
-  m_raoConfigurationData.disableRAO();
+  m_raoParams.disableRAO();
 }
 
 void RAOManager::setEnterpriseRAOUdsLimits(const SCSI::Structures::RAO::udsLimits& raoLimits) {
@@ -98,14 +99,41 @@ cta::optional<uint64_t> RAOManager::getMaxFilesSupported() const{
   return m_maxFilesSupported;
 }
 
-RAOConfigurationData RAOManager::getRAODataConfig() const {
-  return m_raoConfigurationData;
+RAOParams RAOManager::getRAODataConfig() const {
+  return m_raoParams;
 }
 
 std::vector<uint64_t> RAOManager::queryRAO(const std::vector<std::unique_ptr<cta::RetrieveJob>> & jobs, cta::log::LogContext & lc){
   RAOAlgorithmFactoryFactory raoAlgoFactoryFactory(*this,lc);
-  std::unique_ptr<RAOAlgorithm> raoAlgo = raoAlgoFactoryFactory.createAlgorithmFactory()->createRAOAlgorithm();
-  return raoAlgo->performRAO(jobs);
+  std::unique_ptr<RAOAlgorithmFactory> raoAlgoFactory = raoAlgoFactoryFactory.createAlgorithmFactory();
+  std::unique_ptr<RAOAlgorithm> raoAlgo;
+  std::vector<uint64_t> ret;
+  try {
+    raoAlgo = raoAlgoFactory->createRAOAlgorithm();
+  } catch(const cta::exception::Exception & ex){
+    cta::log::ScopedParamContainer spc(lc);
+    spc.add("errorMsg",ex.getMessageValue())
+       .add("raoAlgorithmName",m_raoParams.getRAOAlgorithmName())
+       .add("raoAlgorithmOptions",m_raoParams.getRAOAlgorithmOptions().getOptionsString())
+       .add("useRAO",m_raoParams.useRAO())
+       .add("vid",m_raoParams.getMountedVid());
+    lc.log(cta::log::WARNING,"In RAOManager::queryRAO(), failed to instanciate the RAO algorithm, will perform a linear RAO.");
+    raoAlgo = raoAlgoFactory->createDefaultLinearAlgorithm();
+  }
+  try {
+    ret = raoAlgo->performRAO(jobs);
+  } catch (const cta::exception::Exception & ex) {
+    cta::log::ScopedParamContainer spc(lc);
+    spc.add("errorMsg",ex.getMessageValue())
+       .add("raoAlgorithmName",m_raoParams.getRAOAlgorithmName())
+       .add("raoAlgorithmOptions",m_raoParams.getRAOAlgorithmOptions().getOptionsString())
+       .add("useRAO",m_raoParams.useRAO())
+       .add("vid",m_raoParams.getMountedVid());
+    lc.log(cta::log::WARNING,"In RAOManager::queryRAO(), failed to perform the RAO algorithm, will perform a linear RAO.");
+    raoAlgo = raoAlgoFactory->createDefaultLinearAlgorithm();
+    ret = raoAlgo->performRAO(jobs);
+  }
+  return ret;
 }
 
 

tapeserver/castor/tape/tapeserver/RAO/RAOManager.hpp

@@ -19,7 +19,7 @@
 #pragma once
 #include <vector>
 #include <memory>
-#include "castor/tape/tapeserver/RAO/RAOConfigurationData.hpp"
+#include "castor/tape/tapeserver/RAO/RAOParams.hpp"
 #include "castor/tape/tapeserver/drive/DriveInterface.hpp"
 #include "castor/tape/tapeserver/SCSI/Structures.hpp"
 #include "scheduler/RetrieveJob.hpp"
@@ -46,7 +46,7 @@ public:
    * @param drive the DriveInterface of the drive that is mounting.
    * @param catalogue the pointer to the CTA catalogue
    */
-  RAOManager(const RAOConfigurationData & config, castor::tape::tapeserver::drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue);
+  RAOManager(const RAOParams & config, castor::tape::tapeserver::drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue);
   
   /**
    * Copy constructor
@@ -101,7 +101,7 @@ public:
   
 private:
   //RAO Configuration Data
-  RAOConfigurationData m_raoConfigurationData;
+  RAOParams m_raoParams;
   /** Enterprise Drive-specific RAO parameters */
   SCSI::Structures::RAO::udsLimits m_enterpriseRaoLimits;
   //Is true if the drive have been able to get the RAO UDS limits numbers
@@ -132,7 +132,7 @@ private:
    /**
    * Returns the RAO data that is used by this RAOManager
    */
-  RAOConfigurationData getRAODataConfig() const;
+  RAOParams getRAODataConfig() const;
   
 };
 

tapeserver/castor/tape/tapeserver/RAO/RAOOptions.cpp

@@ -105,5 +105,9 @@ RAOOptions::FilePositionEstimatorType RAOOptions::getFilePositionEstimatorType()
   return RAOOptions::FilePositionEstimatorType::interpolation;
 }
 
+std::string RAOOptions::getOptionsString() {
+  return m_options;
+}
+
 
 }}}}
\ No newline at end of file