XrdCtaFile.cpp

/*
 * The CERN Tape Archive (CTA) project
 * Copyright (C) 2015  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 "scheduler/SchedulerDatabase.hpp"
#include "xroot_plugins/XrdCtaFile.hpp"

#include "XrdSec/XrdSecEntity.hh"

#include "catalogue/TapeFileSearchCriteria.hpp"
#include "common/Configuration.hpp"
#include "common/utils/utils.hpp"
#include "common/Timer.hpp"
#include "common/utils/GetOptThreadSafe.hpp"
#include "common/exception/UserError.hpp"
#include "common/exception/NonRetryableError.hpp"
#include "common/exception/RetryableError.hpp"

#include <cryptopp/base64.h>
#include <cryptopp/osrng.h>
#include <iomanip>
#include <iostream>
#include <memory>
#include <pwd.h>
#include <sstream>
#include <string>
#include <time.h>

namespace cta { namespace xrootPlugins {

//------------------------------------------------------------------------------
// checkClient
//------------------------------------------------------------------------------
void XrdCtaFile::checkClient(const XrdSecEntity *client) {
  if(client==nullptr || client->name==nullptr || client->host==nullptr || client->prot==nullptr) {
    throw cta::exception::Exception(std::string(__FUNCTION__)+": [ERROR] XrdSecEntity from xroot contains invalid information (nullptr pointer detected!)");
  }
  std::cerr << "Client request-> Username: " << client->name << " Host: " << client->host << " Prot: " << client->prot << std::endl;
  /**
   * The username here has two meanings depending on the protocol used:
   * 
   * 1) Kerberos 5: in this case it is the actual username of the administrator issuing the command
   * 2) Simple Shared Secret (SSS): in this case it is the name of the instance
   * 
   * It is important to remember that we are using kerberos authentication only for admin commands, while for user (EOS)
   * commands we use SSS. Each EOS instance will receive a separate SSS key which will be named (this means that a
   * username will be associated to it), for example all the cms EOS instances (1 or more) will receive the same SSS key
   * with the username "cms" associated to it. Having named keys is important to identify instances and limit crosstalk
   * as much as possible: a client having a "cms" SSS key will only be authorized to archive/retrieve/update/delete
   * cms files, or list cms storageclasses.
   */
  m_cliIdentity.username=client->name;
  m_cliIdentity.host=client->host;
  m_protocol=client->prot;
}

//------------------------------------------------------------------------------
// checkOptions
//------------------------------------------------------------------------------
void XrdCtaFile::checkOptions(const std::string &helpString) {
  if(!m_missingRequiredOptions.empty()||(!m_missingOptionalOptions.empty() && m_optionalOptions.empty())) {
    throw cta::exception::UserError(helpString);
  }
}

//------------------------------------------------------------------------------
// logRequestAndSetCmdlineResult
//------------------------------------------------------------------------------
void XrdCtaFile::logRequestAndSetCmdlineResult(const cta::common::dataStructures::FrontendReturnCode rc, const std::string &returnString) {
  // The return code of teh executed command is the first character of the
  // result sent back to the cta command-line tool
  //
  // Please note return codes can only be between "0" and "9".
  m_cmdlineOutput = std::to_string(rc);

  if(!m_missingRequiredOptions.empty()) {
    m_cmdlineOutput += "The following required options are missing:\n";
    for(auto it=m_missingRequiredOptions.cbegin(); it!=m_missingRequiredOptions.cend(); it++) {
      m_cmdlineOutput += "Missing option: ";
      m_cmdlineOutput += *it;
      m_cmdlineOutput += "\n";
    }
  }
  if(!m_missingOptionalOptions.empty() && m_optionalOptions.empty() && !m_suppressOptionalOptionsWarning) {
    m_cmdlineOutput += "At least one of the following options is required:\n";
    for(auto it=m_missingOptionalOptions.cbegin(); it!=m_missingOptionalOptions.cend(); it++) {
      m_cmdlineOutput += "Missing option: ";
      m_cmdlineOutput += *it;
      m_cmdlineOutput += "\n";
    }
  }
  m_cmdlineOutput += returnString;

  std::list<cta::log::Param> params;
  params.push_back({"Username", m_cliIdentity.username});
  params.push_back({"Host", m_cliIdentity.host});
  params.push_back({"ReturnCode", toString(rc)});
  params.push_back({"CommandOutput", m_cmdlineOutput});
  std::stringstream originalRequest;
  for(auto it=m_requestTokens.begin(); it!=m_requestTokens.end(); it++) {
    originalRequest << *it << " ";
  }
  params.push_back(cta::log::Param("REQUEST", originalRequest.str()));
  
  switch(rc) {
    case cta::common::dataStructures::FrontendReturnCode::ok:
      m_log(log::INFO, "Successful Request", params);
      break;
    case cta::common::dataStructures::FrontendReturnCode::userErrorNoRetry:
      m_log(log::USERERR, "Syntax error or missing argument(s) in request", params);
      break;
    default:
      params.push_back(cta::log::Param("ERROR", returnString));
      m_log(log::ERR, "Unsuccessful Request", params);
      break;
  }
}

//------------------------------------------------------------------------------
// authorizeAdmin
//------------------------------------------------------------------------------
void XrdCtaFile::authorizeAdmin(){
  if(m_protocol!="krb5") {
    throw cta::exception::Exception(std::string("[ERROR] Admin commands are possible only through Kerberos 5 protocol authentication. Protocol used for this connection: ")+m_protocol);
  }
  m_scheduler->authorizeAdmin(m_cliIdentity);
}

//------------------------------------------------------------------------------
// commandDispatcher
//------------------------------------------------------------------------------
std::string XrdCtaFile::dispatchCommand() {
  std::string command(m_requestTokens.at(1));
  
  if     ("ad"   == command || "admin"                  == command) {authorizeAdmin(); return xCom_admin();}
  else if("ah"   == command || "adminhost"              == command) {authorizeAdmin(); return xCom_adminhost();}
  else if("tp"   == command || "tapepool"               == command) {authorizeAdmin(); return xCom_tapepool();}
  else if("ar"   == command || "archiveroute"           == command) {authorizeAdmin(); return xCom_archiveroute();}
  else if("ll"   == command || "logicallibrary"         == command) {authorizeAdmin(); return xCom_logicallibrary();}
  else if("ta"   == command || "tape"                   == command) {authorizeAdmin(); return xCom_tape();}
  else if("sc"   == command || "storageclass"           == command) {authorizeAdmin(); return xCom_storageclass();}
  else if("rmr"  == command || "requestermountrule"     == command) {authorizeAdmin(); return xCom_requestermountrule();}
  else if("gmr"  == command || "groupmountrule"         == command) {authorizeAdmin(); return xCom_groupmountrule();}
  else if("mp"   == command || "mountpolicy"            == command) {authorizeAdmin(); return xCom_mountpolicy();}
  else if("re"   == command || "repack"                 == command) {authorizeAdmin(); return xCom_repack();}
  else if("sh"   == command || "shrink"                 == command) {authorizeAdmin(); return xCom_shrink();}
  else if("ve"   == command || "verify"                 == command) {authorizeAdmin(); return xCom_verify();}
  else if("af"   == command || "archivefile"            == command) {authorizeAdmin(); return xCom_archivefile();}
  else if("te"   == command || "test"                   == command) {authorizeAdmin(); return xCom_test();}
  else if("dr"   == command || "drive"                  == command) {authorizeAdmin(); return xCom_drive();}
  else if("lpa"  == command || "listpendingarchives"    == command) {authorizeAdmin(); return xCom_listpendingarchives();}
  else if("lpr"  == command || "listpendingretrieves"   == command) {authorizeAdmin(); return xCom_listpendingretrieves();}
  else if("sq"   == command || "showqueues"             == command) {authorizeAdmin(); return xCom_showqueues();}
  
  else if("a"    == command || "archive"                == command) {return xCom_archive();}
  else if("r"    == command || "retrieve"               == command) {return xCom_retrieve();}
  else if("da"   == command || "deletearchive"          == command) {return xCom_deletearchive();}
  else if("cr"   == command || "cancelretrieve"         == command) {return xCom_cancelretrieve();}
  else if("ufi"  == command || "updatefileinfo"         == command) {return xCom_updatefileinfo();}
  else if("ufsc" == command || "updatefilestorageclass" == command) {return xCom_updatefilestorageclass();}
  else if("lsc"  == command || "liststorageclass"       == command) {return xCom_liststorageclass();}
  
  else {
    throw cta::exception::UserError(getGenericHelp(m_requestTokens.at(0)));
  }
}

//------------------------------------------------------------------------------
// decode
//------------------------------------------------------------------------------
std::string XrdCtaFile::decode(const std::string msg) const {
  std::string ret;
  CryptoPP::StringSource ss1(msg, true, new CryptoPP::Base64Decoder(new CryptoPP::StringSink(ret)));
  return ret;
}

//------------------------------------------------------------------------------
// open
//------------------------------------------------------------------------------
int XrdCtaFile::open(const char *fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity *client, const char *opaque) {
  try {
    checkClient(client);
    if(!strlen(fileName)) { //this should never happen
      throw cta::exception::UserError(getGenericHelp(""));
    }
    
    std::stringstream ss(fileName+1); //let's skip the first slash which is always prepended since we are asking for an absolute path
    std::string item;
    while (std::getline(ss, item, '&')) {
      replaceAll(item, "_", "/"); 
      //need to add this because xroot removes consecutive slashes, and the 
      //cryptopp base64 algorithm may produce consecutive slashes. This is solved 
      //in cryptopp-5.6.3 (using Base64URLEncoder instead of Base64Encoder) but we 
      //currently have cryptopp-5.6.2. To be changed in the future...
      item = decode(item);
      m_requestTokens.push_back(item);
    }

    if(m_requestTokens.size() == 0) { //this should never happen
      throw cta::exception::UserError(getGenericHelp(""));
    }
    if(m_requestTokens.size() < 2) {
      throw cta::exception::UserError(getGenericHelp(m_requestTokens.at(0)));
    }    
    const std::string cmdlineOutput = dispatchCommand();
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::ok, cmdlineOutput);
  } catch (cta::exception::UserError &ex) {
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::userErrorNoRetry, ex.getMessageValue()+"\n");
  } catch (cta::exception::NonRetryableError &ex) {
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::ctaErrorNoRetry, ex.getMessageValue()+"\n");
  } catch (cta::exception::RetryableError &ex) {
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::ctaErrorRetry, ex.getMessageValue()+"\n");
  } catch (cta::exception::Exception &ex) {
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::ctaErrorNoRetry, ex.getMessageValue()+"\n");
  } catch (std::exception &ex) {
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::ctaErrorNoRetry, std::string(ex.what())+"\n");
  } catch (...) {
    logRequestAndSetCmdlineResult(cta::common::dataStructures::FrontendReturnCode::ctaErrorNoRetry, "Unknown exception caught!\n");
  }
  return SFS_OK;
}

//------------------------------------------------------------------------------
// close
//------------------------------------------------------------------------------
int XrdCtaFile::close() {
  return SFS_OK;
}

//------------------------------------------------------------------------------
// fctl
//------------------------------------------------------------------------------
int XrdCtaFile::fctl(const int cmd, const char *args, XrdOucErrInfo &eInfo) {  
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// FName
//------------------------------------------------------------------------------
const char* XrdCtaFile::FName() {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return nullptr;
}

//------------------------------------------------------------------------------
// getMmap
//------------------------------------------------------------------------------
int XrdCtaFile::getMmap(void **Addr, off_t &Size) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// read
//------------------------------------------------------------------------------
XrdSfsXferSize XrdCtaFile::read(XrdSfsFileOffset offset, char *buffer, XrdSfsXferSize size) {
  if (nullptr != m_listArchiveFilesCmd.get()) {
    // Temporarily treat the "cta archive ls" command the same as all the others
    return m_listArchiveFilesCmd->read(offset, buffer, size);
  } else {
    return readFromCmdlineOutput(offset, buffer, size);
  }
}

//------------------------------------------------------------------------------
// readFromCmdlineOutput
//------------------------------------------------------------------------------
XrdSfsXferSize XrdCtaFile::readFromCmdlineOutput(XrdSfsFileOffset offset, char *buffer, XrdSfsXferSize size) {
  if(0 > offset) {
    error.setErrInfo(EINVAL, "The value of offset is negative");
    return SFS_ERROR;
  }

  if(offset >= (XrdSfsFileOffset)m_cmdlineOutput.length()) {
    return SFS_OK;
  }

  const XrdSfsXferSize remainingNbBytesToRead = m_cmdlineOutput.length() - offset;
  const XrdSfsXferSize actualNbBytesToRead = remainingNbBytesToRead >= size ? size : remainingNbBytesToRead;

  if(0 < actualNbBytesToRead) {
    strncpy(buffer, m_cmdlineOutput.c_str() + offset, actualNbBytesToRead);
    return actualNbBytesToRead;
  } else {
    return SFS_OK;
  }
}

//------------------------------------------------------------------------------
// read
//------------------------------------------------------------------------------
XrdSfsXferSize XrdCtaFile::read(XrdSfsFileOffset offset, XrdSfsXferSize size) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// read
//------------------------------------------------------------------------------
XrdSfsXferSize XrdCtaFile::read(XrdSfsAio *aioparm) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// write
//------------------------------------------------------------------------------
XrdSfsXferSize XrdCtaFile::write(XrdSfsFileOffset offset, const char *buffer, XrdSfsXferSize size) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// write
//------------------------------------------------------------------------------
int XrdCtaFile::write(XrdSfsAio *aioparm) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// stat
//------------------------------------------------------------------------------
int XrdCtaFile::stat(struct stat *buf) {
  buf->st_size=m_cmdlineOutput.length();
  return SFS_OK;
}

//------------------------------------------------------------------------------
// sync
//------------------------------------------------------------------------------
int XrdCtaFile::sync() {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// sync
//------------------------------------------------------------------------------
int XrdCtaFile::sync(XrdSfsAio *aiop) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// truncate
//------------------------------------------------------------------------------
int XrdCtaFile::truncate(XrdSfsFileOffset fsize) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// getCXinfo
//------------------------------------------------------------------------------
int XrdCtaFile::getCXinfo(char cxtype[4], int &cxrsz) {
  error.setErrInfo(ENOTSUP, "Not supported.");
  return SFS_ERROR;
}

//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
XrdCtaFile::XrdCtaFile(
  cta::catalogue::Catalogue *catalogue,
  cta::Scheduler *scheduler,
  cta::log::Logger *log,
  const char *user,
  int MonID):
  XrdSfsFile(user, MonID),
  m_catalogue(catalogue),
  m_scheduler(scheduler),
  m_log(*log),
  m_cmdlineOutput(""),
  m_suppressOptionalOptionsWarning(false){
}

//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
XrdCtaFile::~XrdCtaFile() {  
}

//------------------------------------------------------------------------------
// replaceAll
//------------------------------------------------------------------------------
void XrdCtaFile::replaceAll(std::string& str, const std::string& from, const std::string& to) const {
  if(from.empty() || str.empty())
    return;
  size_t start_pos = 0;
  while((start_pos = str.find(from, start_pos)) != std::string::npos) {
    str.replace(start_pos, from.length(), to);
    start_pos += to.length();
  }
}

//------------------------------------------------------------------------------
// getOption
//------------------------------------------------------------------------------
std::string XrdCtaFile::getOption(const std::string& optionShortName, const std::string& optionLongName) {
  bool encoded = false;
  for(auto it=m_requestTokens.cbegin(); it!=m_requestTokens.cend(); it++) {
    if(optionShortName == *it || optionLongName == *it || optionLongName+":base64" == *it) {
      if(optionLongName+":base64" == *it) {
        encoded = true;
      }
      auto it_next=it+1;
      if(it_next!=m_requestTokens.cend()) {
        std::string value = *it_next;
        if(!encoded) return value;
        else return decode(value.erase(0,7)); //erasing the first 7 characters "base64:" and decoding the rest
      }
      else {
        return "";
      }
    }
  }
  return "";
}

//------------------------------------------------------------------------------
// getOptionStringValue
//------------------------------------------------------------------------------
optional<std::string> XrdCtaFile::getOptionStringValue(const std::string& optionShortName, 
        const std::string& optionLongName,
        const bool required, 
        const bool useDefaultIfMissing, 
        const std::string& defaultValue) {
  std::string option = getOption(optionShortName, optionLongName);
  if(option.empty()&&useDefaultIfMissing) {
    option = defaultValue;
  }
  if(option.empty()) {
    if(required) {
      m_missingRequiredOptions.push_back(optionLongName);
    }
    else {
      m_missingOptionalOptions.push_back(optionLongName);
    }
    return optional<std::string>();
  }
  if(!required) {
    m_optionalOptions.push_back(optionLongName);
  }
  return optional<std::string>(option);
}

//------------------------------------------------------------------------------
// getOptionUint64Value
//------------------------------------------------------------------------------
optional<uint64_t> XrdCtaFile::getOptionUint64Value(const std::string& optionShortName, 
        const std::string& optionLongName,
        const bool required, 
        const bool useDefaultIfMissing, 
        const std::string& defaultValue) {
  std::string option = getOption(optionShortName, optionLongName);
  if(option.empty()&&useDefaultIfMissing) {
    option = defaultValue;
  }
  if(option.empty()) {
    if(required) {
      m_missingRequiredOptions.push_back(optionLongName);
    }
    else {
      m_missingOptionalOptions.push_back(optionLongName);
    }
    return optional<uint64_t>();
  }
  if(!required) {
    m_optionalOptions.push_back(optionLongName);
  }
  return optional<uint64_t>(stringParameterToUint64(optionLongName, option));
}

//------------------------------------------------------------------------------
// getOptionBoolValue
//------------------------------------------------------------------------------
optional<bool> XrdCtaFile::getOptionBoolValue(const std::string& optionShortName, 
        const std::string& optionLongName,
        const bool required, 
        const bool useDefaultIfMissing, 
        const std::string& defaultValue) {
  std::string option = getOption(optionShortName, optionLongName);
  if(option.empty()&&useDefaultIfMissing) {
    option = defaultValue;
  }
  if(option.empty()) {
    if(required) {
      m_missingRequiredOptions.push_back(optionLongName);
    }
    else {
      m_missingOptionalOptions.push_back(optionLongName);
    }
    return optional<bool>();
  }
  if(!required) {
    m_optionalOptions.push_back(optionLongName);
  }
  return optional<bool>(stringParameterToBool(optionLongName, option));
}

//------------------------------------------------------------------------------
// getOptionTimeValue
//------------------------------------------------------------------------------
optional<time_t> XrdCtaFile::getOptionTimeValue(const std::string& optionShortName, 
        const std::string& optionLongName,
        const bool required, 
        const bool useDefaultIfMissing, 
        const std::string& defaultValue) {
  std::string option = getOption(optionShortName, optionLongName);
  if(option.empty()&&useDefaultIfMissing) {
    option = defaultValue;
  }
  if(option.empty()) {
    if(required) {
      m_missingRequiredOptions.push_back(optionLongName);
    }
    else {
      m_missingOptionalOptions.push_back(optionLongName);
    }
    return optional<time_t>();
  }
  if(!required) {
    m_optionalOptions.push_back(optionLongName);
  }
  return optional<time_t>(stringParameterToTime(optionLongName, option));
}

//------------------------------------------------------------------------------
// hasOption
//------------------------------------------------------------------------------
bool XrdCtaFile::hasOption(const std::string& optionShortName, const std::string& optionLongName) {
  for(auto it=m_requestTokens.cbegin(); it!=m_requestTokens.cend(); it++) {
    if(optionShortName == *it || optionLongName == *it) {
      return true;
    }
  }
  return false;
}

//------------------------------------------------------------------------------
// timeToString
//------------------------------------------------------------------------------
std::string XrdCtaFile::timeToString(const time_t &time) {
  std::string timeString(ctime(&time));
  timeString=timeString.substr(0,timeString.size()-1); //remove newline
  return timeString;
}

//------------------------------------------------------------------------------
// formatResponse
//------------------------------------------------------------------------------
std::string XrdCtaFile::formatResponse(const std::vector<std::vector<std::string>> &responseTable, const bool withHeader) {
  if(responseTable.empty()||responseTable.at(0).empty()) {
    return "";
  }
  std::vector<int> columnSizes;
  for(uint j=0; j<responseTable.at(0).size(); j++) { //for each column j
    uint columnSize=0;
    for(uint i=0; i<responseTable.size(); i++) { //for each row i
      if(responseTable.at(i).at(j).size()>columnSize) {
        columnSize=responseTable.at(i).at(j).size();
      }
    }
    columnSizes.push_back(columnSize);//loops here
  }
  std::stringstream responseSS;
  for(auto row=responseTable.cbegin(); row!=responseTable.cend(); row++) {
    if(withHeader && row==responseTable.cbegin()) responseSS << "\x1b[31;1m";
    for(uint i=0; i<row->size(); i++) {
      responseSS << std::string(i?"  ":"")<< std::setw(columnSizes.at(i)) << row->at(i);
    }
    if(withHeader && row==responseTable.cbegin()) responseSS << "\x1b[0m" << std::endl;
    else responseSS << std::endl;
  }
  return responseSS.str();
}

//------------------------------------------------------------------------------
// addLogInfoToResponseRow
//------------------------------------------------------------------------------
void XrdCtaFile::addLogInfoToResponseRow(std::vector<std::string> &responseRow, const cta::common::dataStructures::EntryLog &creationLog, const cta::common::dataStructures::EntryLog &lastModificationLog) {
  responseRow.push_back(creationLog.username);
  responseRow.push_back(creationLog.host);
  responseRow.push_back(timeToString(creationLog.time));
  responseRow.push_back(lastModificationLog.username);
  responseRow.push_back(lastModificationLog.host);
  responseRow.push_back(timeToString(lastModificationLog.time));
}

//------------------------------------------------------------------------------
// stringParameterToUint64
//------------------------------------------------------------------------------
uint64_t XrdCtaFile::stringParameterToUint64(const std::string &parameterName, const std::string &parameterValue) const {
  try {
    return cta::utils::toUint64(parameterValue);
  } catch(cta::exception::Exception &ex) {
    throw cta::exception::Exception(std::string(__FUNCTION__)+" - Parameter: "+parameterName+" ("+parameterValue+
            ") could not be converted to uint64_t because: " + ex.getMessageValue());
  }
}

//------------------------------------------------------------------------------
// stringParameterToBool
//------------------------------------------------------------------------------
bool XrdCtaFile::stringParameterToBool(const std::string &parameterName, const std::string &parameterValue) const {
  if(parameterValue == "true") {
    return true;
  } 
  else if(parameterValue == "false") {
    return false;
  } 
  else {
    throw cta::exception::Exception(std::string(__FUNCTION__)+" - Parameter: "+parameterName+" ("+parameterValue+
            ") could not be converted to bool: the only values allowed are \"true\" and \"false\"");
  }
}

//------------------------------------------------------------------------------
// stringParameterToTime
//------------------------------------------------------------------------------
time_t XrdCtaFile::stringParameterToTime(const std::string &parameterName, const std::string &parameterValue) const {
  struct tm time;
  if(nullptr==strptime(parameterValue.c_str(), "%d/%m/%Y", &time)) {
    throw cta::exception::Exception(std::string(__FUNCTION__)+" - Parameter: "+parameterName+" ("+parameterValue+
            ") could not be interpreted as a time, the allowed format is: <DD/MM/YYYY>");
  }
  return mktime(&time);
}

//------------------------------------------------------------------------------
// EOS2CTAChecksumType
//------------------------------------------------------------------------------
optional<std::string> XrdCtaFile::EOS2CTAChecksumType(const optional<std::string> &EOSChecksumType) {
  if(EOSChecksumType && EOSChecksumType.value()=="adler") return optional<std::string>("ADLER32");
  return nullopt;
}

//------------------------------------------------------------------------------
// EOS2CTAChecksumValue
//------------------------------------------------------------------------------
optional<std::string> XrdCtaFile::EOS2CTAChecksumValue(const optional<std::string> &EOSChecksumValue) {
  if(EOSChecksumValue) {
    std::string CTAChecksumValue("0X");  
    CTAChecksumValue += EOSChecksumValue.value();
    cta::utils::toUpper(CTAChecksumValue);
    return optional<std::string>(CTAChecksumValue);
  }
  return nullopt;
}

//------------------------------------------------------------------------------
// xCom_admin
//------------------------------------------------------------------------------
std::string XrdCtaFile::xCom_admin() {
  std::stringstream cmdlineOutput;
  std::stringstream help;
  help << m_requestTokens.at(0) << " ad/admin add/ch/rm/ls:" << std::endl
       << "\tadd --username/-u <user_name> --comment/-m <\"comment\">" << std::endl
       << "\tch  --username/-u <user_name> --comment/-m <\"comment\">" << std::endl
       << "\trm  --username/-u <user_name>" << std::endl
       << "\tls  [--header/-h]" << std::endl;
  if(m_requestTokens.size() < 3) {
    throw cta::exception::UserError(help.str());
  }
  if("add" == m_requestTokens.at(2) || "ch" == m_requestTokens.at(2) || "rm" == m_requestTokens.at(2)) {
    optional<std::string> username = getOptionStringValue("-u", "--username", true, false);
    if("add" == m_requestTokens.at(2) || "ch" == m_requestTokens.at(2)) {
      optional<std::string> comment = getOptionStringValue("-m", "--comment", true, false);
      if("add" == m_requestTokens.at(2)) { //add
        checkOptions(help.str());
        m_catalogue->createAdminUser(m_cliIdentity, username.value(), comment.value());
      }
      else { //ch
        checkOptions(help.str());
        m_catalogue->modifyAdminUserComment(m_cliIdentity, username.value(), comment.value());
      }
    }
    else { //rm
      checkOptions(help.str());
      m_catalogue->deleteAdminUser(username.value());
    }
  }
  else if("ls" == m_requestTokens.at(2)) { //ls
    std::list<cta::common::dataStructures::AdminUser> list= m_catalogue->getAdminUsers();
    if(list.size()>0) {
      std::vector<std::vector<std::string>> responseTable;
      std::vector<std::string> header = {"user","c.user","c.host","c.time","m.user","m.host","m.time","comment"};
      if(hasOption("-h", "--header")) responseTable.push_back(header);    
      for(auto it = list.cbegin(); it != list.cend(); it++) {
        std::vector<std::string> currentRow;
        currentRow.push_back(it->name);
        addLogInfoToResponseRow(currentRow, it->creationLog, it->lastModificationLog);
        currentRow.push_back(it->comment);
        responseTable.push_back(currentRow);
      }
      cmdlineOutput << formatResponse(responseTable, hasOption("-h", "--header"));
    }
  }
  else {
    throw cta::exception::UserError(help.str());
  }
  return cmdlineOutput.str();
}

//------------------------------------------------------------------------------
// xCom_adminhost
//------------------------------------------------------------------------------
std::string XrdCtaFile::xCom_adminhost() {
  std::stringstream cmdlineOutput;
  std::stringstream help;
  help << m_requestTokens.at(0) << " ah/adminhost add/ch/rm/ls:" << std::endl
       << "\tadd --name/-n <host_name> --comment/-m <\"comment\">" << std::endl
       << "\tch  --name/-n <host_name> --comment/-m <\"comment\">" << std::endl
       << "\trm  --name/-n <host_name>" << std::endl
       << "\tls  [--header/-h]" << std::endl;  
  if(m_requestTokens.size() < 3) {
    throw cta::exception::UserError(help.str());
  }
  if("add" == m_requestTokens.at(2) || "ch" == m_requestTokens.at(2) || "rm" == m_requestTokens.at(2)) {
    optional<std::string> hostname = getOptionStringValue("-n", "--name", true, false);
    if("add" == m_requestTokens.at(2) || "ch" == m_requestTokens.at(2)) {
      optional<std::string> comment = getOptionStringValue("-m", "--comment", true, false);
      if("add" == m_requestTokens.at(2)) { //add
        checkOptions(help.str());
        m_catalogue->createAdminHost(m_cliIdentity, hostname.value(), comment.value());
      }
      else { //ch
        checkOptions(help.str());
        m_catalogue->modifyAdminHostComment(m_cliIdentity, hostname.value(), comment.value());
      }
    }
    else { //rm
      checkOptions(help.str());
      m_catalogue->deleteAdminHost(hostname.value());
    }
  }
  else if("ls" == m_requestTokens.at(2)) { //ls
    std::list<cta::common::dataStructures::AdminHost> list= m_catalogue->getAdminHosts();
    if(list.size()>0) {
      std::vector<std::vector<std::string>> responseTable;
      std::vector<std::string> header = {"hostname","c.user","c.host","c.time","m.user","m.host","m.time","comment"};
      if(hasOption("-h", "--header")) responseTable.push_back(header);
      for(auto it = list.cbegin(); it != list.cend(); it++) {
        std::vector<std::string> currentRow;
        currentRow.push_back(it->name);
        addLogInfoToResponseRow(currentRow, it->creationLog, it->lastModificationLog);
        currentRow.push_back(it->comment);
        responseTable.push_back(currentRow);
      }
      cmdlineOutput << formatResponse(responseTable, hasOption("-h", "--header"));
    }
  }
  else {
    throw cta::exception::UserError(help.str());
  }
  return cmdlineOutput.str();
}

//------------------------------------------------------------------------------
// xCom_tapepool
//------------------------------------------------------------------------------
std::string XrdCtaFile::xCom_tapepool() {
  std::stringstream cmdlineOutput;
  std::stringstream help;
  help << m_requestTokens.at(0) << " tp/tapepool add/ch/rm/ls:" << std::endl
       << "\tadd --name/-n <tapepool_name> --partialtapesnumber/-p <number_of_partial_tapes> --encrypted/-e <\"true\" or \"false\"> --comment/-m <\"comment\">" << std::endl
       << "\tch  --name/-n <tapepool_name> [--partialtapesnumber/-p <number_of_partial_tapes>] [--encrypted/-e <\"true\" or \"false\">] [--comment/-m <\"comment\">]" << std::endl
       << "\trm  --name/-n <tapepool_name>" << std::endl
       << "\tls  [--header/-h]" << std::endl;  
  if(m_requestTokens.size() < 3) {
    throw cta::exception::UserError(help.str());
  }
  if("add" == m_requestTokens.at(2) || "ch" == m_requestTokens.at(2) || "rm" == m_requestTokens.at(2)) {
    optional<std::string> name = getOptionStringValue("-n", "--name", true, false);
    if("add" == m_requestTokens.at(2)) { //add
      optional<uint64_t> ptn = getOptionUint64Value("-p", "--partialtapesnumber", true, false);
      optional<std::string> comment = getOptionStringValue("-m", "--comment", true, false);
      optional<bool> encrypted = getOptionBoolValue("-e", "--encrypted", true, false);
      checkOptions(help.str());
      m_catalogue->createTapePool(m_cliIdentity, name.value(), ptn.value(), encrypted.value(), comment.value());
    }
    else if("ch" == m_requestTokens.at(2)) { //ch
      optional<uint64_t> ptn = getOptionUint64Value("-p", "--partialtapesnumber", false, false);
      optional<std::string> comment = getOptionStringValue("-m", "--comment", false, false);
      optional<bool> encrypted = getOptionBoolValue("-e", "--encrypted", false, false);
      checkOptions(help.str());
      if(comment) {
        m_catalogue->modifyTapePoolComment(m_cliIdentity, name.value(), comment.value());
      }
      if(ptn) {
        m_catalogue->modifyTapePoolNbPartialTapes(m_cliIdentity, name.value(), ptn.value());
      }
      if(encrypted) {
        m_catalogue->setTapePoolEncryption(m_cliIdentity, name.value(), encrypted.value());
      }
    }
    else { //rm
      checkOptions(help.str());
      m_catalogue->deleteTapePool(name.value());
    }
  }
  else if("ls" == m_requestTokens.at(2)) { //ls
    std::list<cta::common::dataStructures::TapePool> list= m_catalogue->getTapePools();
    if(list.size()>0) {
      std::vector<std::vector<std::string>> responseTable;
      std::vector<std::string> header = {"name","# partial tapes","encrypt","c.user","c.host","c.time","m.user","m.host","m.time","comment"};
      if(hasOption("-h", "--header")) responseTable.push_back(header);    
      for(auto it = list.cbegin(); it != list.cend(); it++) {
        std::vector<std::string> currentRow;
        currentRow.push_back(it->name);
        currentRow.push_back(std::to_string((unsigned long long)it->nbPartialTapes));
        if(it->encryption) currentRow.push_back("true"); else currentRow.push_back("false");
        addLogInfoToResponseRow(currentRow, it->creationLog, it->lastModificationLog);
        currentRow.push_back(it->comment);
        responseTable.push_back(currentRow);
      }
      cmdlineOutput << formatResponse(responseTable, hasOption("-h", "--header"));
    }
  }
  else {
    throw cta::exception::UserError(help.str());
  }
  return cmdlineOutput.str();
}

//------------------------------------------------------------------------------
// xCom_archiveroute
//------------------------------------------------------------------------------
std::string XrdCtaFile::xCom_archiveroute() {
  std::stringstream cmdlineOutput;
  std::stringstream help;
  help << m_requestTokens.at(0) << " ar/archiveroute add/ch/rm/ls:" << std::endl
       << "\tadd --instance/-i <instance_name> --storageclass/-s <storage_class_name> --copynb/-c <copy_number> --tapepool/-t <tapepool_name> --comment/-m <\"comment\">" << std::endl
       << "\tch  --instance/-i <instance_name> --storageclass/-s <storage_class_name> --copynb/-c <copy_number> [--tapepool/-t <tapepool_name>] [--comment/-m <\"comment\">]" << std::endl
       << "\trm  --instance/-i <instance_name> --storageclass/-s <storage_class_name> --copynb/-c <copy_number>" << std::endl
       << "\tls  [--header/-h]" << std::endl;  
  if(m_requestTokens.size() < 3) {
    throw cta::exception::UserError(help.str());
  }
  if("add" == m_requestTokens.at(2) || "ch" == m_requestTokens.at(2) || "rm" == m_requestTokens.at(2)) {
    optional<std::string> scn = getOptionStringValue("-s", "--storageclass", true, false);
    optional<uint64_t> cn = getOptionUint64Value("-c", "--copynb", true, false);
    optional<std::string> in = getOptionStringValue("-i", "--instance", true, false);
    if("add" == m_requestTokens.at(2)) { //add