Commit b551b0ff authored by Eric Cano's avatar Eric Cano
Browse files

Homogeneize the naming: removed mixtures of archival and archive in favor of...

Homogeneize the naming: removed mixtures of archival and archive in favor of the latter. Same the retriv{e,al}.
Renamed file transfers to tape jobs as a single file can required several jobs (in the case of nultiple copies).
parent 084c8a39
......@@ -21,7 +21,7 @@ The data and storage services (DSS) group of the CERN IT department currently pr
The CTA project is a prototype for a very good reason. The DSS group needs to investigate and learn what it means to provide a tape archive service that does not have its own internal disk-based staging area. The project also needs to keep its options open in order to give the DSS group the best opportunities to identify the best ways forward for reducing application complexity, easing code maintenance, reducing operation overheads and improving tape efficiency.
The CTA project currently has no constraints that go against collecting a global view of all tape , drive and user request states. This means the CTA project should be able to implement intuitive and effective tape scheduling policies. For example it should be possible to schedule a tape archival mount at the point in time when there is both a free drive and a free tape. The architecture of the CASTOR system does not facilitate such simple solutions due to its history of having separate staging areas per experiment and dividing the mount scheduling problem between these separate staging areas and the central tape system responsible for issuing tape mount requests for all experiments.
The CTA project currently has no constraints that go against collecting a global view of all tape , drive and user request states. This means the CTA project should be able to implement intuitive and effective tape scheduling policies. For example it should be possible to schedule a tape archive mount at the point in time when there is both a free drive and a free tape. The architecture of the CASTOR system does not facilitate such simple solutions due to its history of having separate staging areas per experiment and dividing the mount scheduling problem between these separate staging areas and the central tape system responsible for issuing tape mount requests for all experiments.
\chapter{The Command Line Interface}
......@@ -107,10 +107,10 @@ These are the commands that only administrators are allowed to use to operate CT
\item cta ll/logicallibrary
\item cta ta/tape
\item cta sc/storageclass{\normalfont \footnote{storage classes should be as static as possible, no change nor deletion if there is at least 1 directory using it}}
\item cta loa/listongoingarchivals
\item cta lor/listongoingretrievals
\item cta lpa/listpendingarchivals
\item cta lpr/listpendingretrievals
\item cta loa/listongoingarchives
\item cta lor/listongoingretrieves
\item cta lpa/listpendingarchives
\item cta lpr/listpendingretrieves
\item cta lds/listdrivestates{\normalfont \footnote{more or less the ``drive'' part of the current showqueues -x}}
\end{itemize}
\normalfont
......@@ -231,15 +231,15 @@ This command is used to manage the storage classes. These can be associated with
\normalfont
\subsection{\tt cta list\ldots}
This set of commands is used to list the ongoing archivals and retrievals as well the pending ones. The last command lists the state of each tape drive (its status --up or down--, its contents, etc.).
This set of commands is used to list the ongoing archives and retrieves as well the pending ones. The last command lists the state of each tape drive (its status --up or down--, its contents, etc.).
\tt
\begin{center}
\begin{tabular}{ l l }
\rowcolor[gray]{0.9}{\normalfont\it Command} & {\normalfont\it Parameters} \\ \hline
cta loa/listongoingarchivals & -{}-tapepool/-t <\textit{tapepool\_name}> \\ \hline
cta lor/listongoingretrievals & -{}-vid/-v <\textit{vid}> \\ \hline
cta lpa/listpendingarchivals & -{}-tapepool/-t <\textit{tapepool\_name}> \\ \hline
cta lpr/listpendingretrievals & -{}-vid/-v <\textit{vid}> \\ \hline
cta loa/listongoingarchives & -{}-tapepool/-t <\textit{tapepool\_name}> \\ \hline
cta lor/listongoingretrieves & -{}-vid/-v <\textit{vid}> \\ \hline
cta lpa/listpendingarchives & -{}-tapepool/-t <\textit{tapepool\_name}> \\ \hline
cta lpr/listpendingretrieves & -{}-vid/-v <\textit{vid}> \\ \hline
cta lds/listdrivestates & \\ \hline
\end{tabular}
\end{center}
......@@ -269,8 +269,8 @@ For most commands there is a short version and a long one. Due to the limited nu
\item cta ls <dirpath>
\item cta a/archive <src1> [<src2> [<src3> [...]]] <dst>
\item cta r/retrieve <src1> [<src2> [<src3> [...]]] <dst>
\item cta da/deletearchive <dst>{\normalfont \footnote{this works both on ongoing and finished archivals, that is why it's called ``delete''}}
\item cta cr/cancelretrieval <dst>{\normalfont \footnote{this clearly works only on ongoing retrievals, obviously does not delete destination files, that's why it's called ``cancel''}}
\item cta da/deletearchive <dst>{\normalfont \footnote{this works both on ongoing and finished archives, that is why it's called ``delete''}}
\item cta cr/cancelretrieve <dst>{\normalfont \footnote{this clearly works only on ongoing retrieves, obviously does not delete destination files, that's why it's called ``cancel''}}
\end{itemize}
\normalfont
......
......@@ -167,7 +167,7 @@ cta::objectstore::RootEntry::dumpAdminUsers() {
}
// =============================================================================
// ========== Storage Class and archival routes manipulations ==================
// ========== Storage Class and archive routes manipulations ===================
// =============================================================================
// This operator will be used in the following usage of the templated
......@@ -247,39 +247,39 @@ uint16_t cta::objectstore::RootEntry::getStorageClassCopyCount (
// removeOccurences
namespace {
bool operator==(uint16_t copyNb,
const cta::objectstore::serializers::ArchivalRoute & ar) {
const cta::objectstore::serializers::ArchiveRoute & ar) {
return ar.copynb() == copyNb;
}
}
void cta::objectstore::RootEntry::addArchivalRoute(const std::string& storageClass,
void cta::objectstore::RootEntry::addArchiveRoute(const std::string& storageClass,
uint16_t copyNb, const std::string& tapePool, const CreationLog& cl) {
checkPayloadWritable();
// Find the storageClass entry
if (copyNb > maxCopyCount || copyNb <= 0) {
std::stringstream ss;
ss << "In RootEntry::addArchivalRoute: invalid copy number: " <<
ss << "In RootEntry::addArchiveRoute: invalid copy number: " <<
copyNb << " > " << maxCopyCount;
throw InvalidCopyNumber(ss.str());
}
auto & sc = serializers::findElement(m_payload.mutable_storageclasses(), storageClass);
if (copyNb > sc.copycount() || copyNb <= 0) {
std::stringstream ss;
ss << "In RootEntry::addArchivalRoute: copy number out of range: " <<
ss << "In RootEntry::addArchiveRoute: copy number out of range: " <<
copyNb << " >= " << sc.copycount();
throw InvalidCopyNumber(ss.str());
}
// Find the archival route (if it exists)
// Find the archive route (if it exists)
try {
// It does: update is not allowed.
auto &ar = serializers::findElement(sc.mutable_routes(), copyNb);
throw ArchivalRouteAlreadyExists("In RootEntry::addArchivalRoute: route already exists");
throw ArchiveRouteAlreadyExists("In RootEntry::addArchiveRoute: route already exists");
// Sanity check: is it the right route?
if (ar.copynb() != copyNb) {
throw exception::Exception(
"In RootEntry::addArchivalRoute: internal error: extracted wrong route");
"In RootEntry::addArchiveRoute: internal error: extracted wrong route");
}
throw ArchivalRouteAlreadyExists("In RootEntry::addArchivalRoute: trying to add an existing route");
throw ArchiveRouteAlreadyExists("In RootEntry::addArchiveRoute: trying to add an existing route");
cl.serialize(*ar.mutable_log());
ar.set_tapepool(tapePool);
} catch (serializers::NotFound &) {
......@@ -288,7 +288,7 @@ void cta::objectstore::RootEntry::addArchivalRoute(const std::string& storageCla
auto & routes = sc.routes();
for (auto r=routes.begin(); r != routes.end(); r++) {
if (r->tapepool() == tapePool) {
throw TapePoolUsedInOtherRoute ("In RootEntry::addArchivalRoute: cannot add a second route to the same tape pool");
throw TapePoolUsedInOtherRoute ("In RootEntry::addArchiveRoute: cannot add a second route to the same tape pool");
}
}
auto *ar = sc.mutable_routes()->Add();
......@@ -298,19 +298,19 @@ void cta::objectstore::RootEntry::addArchivalRoute(const std::string& storageCla
}
}
void cta::objectstore::RootEntry::removeArchivalRoute(
void cta::objectstore::RootEntry::removeArchiveRoute(
const std::string& storageClass, uint16_t copyNb) {
checkPayloadWritable();
// Find the storageClass entry
auto & sc = serializers::findElement(m_payload.mutable_storageclasses(), storageClass);
if (!serializers::isElementPresent(sc.routes(), copyNb))
throw NoSuchArchivalRoute(
"In RootEntry::removeArchivalRoute: trying to delete non-existing archival route.");
throw NoSuchArchiveRoute(
"In RootEntry::removeArchiveRoute: trying to delete non-existing archive route.");
serializers::removeOccurences(sc.mutable_routes(), copyNb);
}
std::vector<std::string> cta::objectstore::RootEntry::getArchivalRoutes(const std::string storageClass) {
std::vector<std::string> cta::objectstore::RootEntry::getArchiveRoutes(const std::string storageClass) {
checkPayloadReadable();
auto & sc = serializers::findElement(m_payload.storageclasses(), storageClass);
std::vector<std::string> ret;
......@@ -344,7 +344,7 @@ auto cta::objectstore::RootEntry::dumpStorageClasses() -> std::list<StorageClass
ret.back().log.deserialize(i->log());
auto & arl = i->routes();
for (auto j=arl.begin(); j!= arl.end(); j++) {
ret.back().routes.push_back(StorageClassDump::ArchivalRouteDump());
ret.back().routes.push_back(StorageClassDump::ArchiveRouteDump());
auto &r = ret.back().routes.back();
r.copyNumber = j->copynb();
r.tapePool = j->tapepool();
......@@ -365,7 +365,7 @@ auto cta::objectstore::RootEntry::dumpStorageClass(const std::string& name)
ret.storageClass = i->name();
auto & arl = i->routes();
for (auto j=arl.begin(); j!= arl.end(); j++) {
ret.routes.push_back(StorageClassDump::ArchivalRouteDump());
ret.routes.push_back(StorageClassDump::ArchiveRouteDump());
auto &r = ret.routes.back();
r.copyNumber = j->copynb();
r.tapePool = j->tapepool();
......@@ -498,7 +498,7 @@ void cta::objectstore::RootEntry::removeTapePoolAndCommit(const std::string& tap
for (auto r=rl.begin(); r!=rl.end(); r++) {
if (r->tapepool() == tapePool)
throw TapePoolUsedInRoute(
"In RootEntry::removeTapePoolAndCommit: trying to remove a tape pool used in archival route");
"In RootEntry::removeTapePoolAndCommit: trying to remove a tape pool used in archive route");
}
}
// Open the tape pool object
......
......@@ -73,7 +73,7 @@ public:
};
std::list<AdminUserDump> dumpAdminUsers();
// Manipulations of Storage Classes and archival routes ======================
// Manipulations of Storage Classes and archive routes =======================
CTA_GENERATE_EXCEPTION_CLASS(MissingEntry);
CTA_GENERATE_EXCEPTION_CLASS(IncompleteEntry);
CTA_GENERATE_EXCEPTION_CLASS(NoSuchStorageClass);
......@@ -91,18 +91,18 @@ public:
void setStorageClassCopyCount(const std::string & storageClass,
uint16_t copyCount, const CreationLog & cl);
uint16_t getStorageClassCopyCount(const std::string & storageClass);
CTA_GENERATE_EXCEPTION_CLASS(ArchivalRouteAlreadyExists);
CTA_GENERATE_EXCEPTION_CLASS(ArchiveRouteAlreadyExists);
CTA_GENERATE_EXCEPTION_CLASS(TapePoolUsedInOtherRoute);
void addArchivalRoute(const std::string & storageClass, uint16_t copyNb,
void addArchiveRoute(const std::string & storageClass, uint16_t copyNb,
const std::string & tapePool, const CreationLog & cl);
CTA_GENERATE_EXCEPTION_CLASS(NoSuchArchivalRoute);
void removeArchivalRoute(const std::string & storageClass, uint16_t copyNb);
CTA_GENERATE_EXCEPTION_CLASS(NoSuchArchiveRoute);
void removeArchiveRoute(const std::string & storageClass, uint16_t copyNb);
/** Ordered vector of archive routes */
std::vector<std::string> getArchivalRoutes (const std::string storageClass);
std::vector<std::string> getArchiveRoutes (const std::string storageClass);
class StorageClassDump {
public:
class ArchivalRouteDump {
class ArchiveRouteDump {
public:
uint16_t copyNumber;
std::string tapePool;
......@@ -110,7 +110,7 @@ public:
};
std::string storageClass;
uint16_t copyCount;
std::list<ArchivalRouteDump> routes;
std::list<ArchiveRouteDump> routes;
CreationLog log;
};
std::list<StorageClassDump> dumpStorageClasses();
......
......@@ -212,7 +212,7 @@ TEST(ObjectStore, RootEntryAdminUsers) {
ASSERT_EQ(false, re.exists());
}
TEST(ObjectStore, RootEntryStorageClassesAndArchivalRoutes) {
TEST(ObjectStore, RootEntryStorageClassesAndArchiveRoutes) {
cta::objectstore::BackendVFS be;
{
// Try to create the root entry
......@@ -285,8 +285,8 @@ TEST(ObjectStore, RootEntryStorageClassesAndArchivalRoutes) {
cta::objectstore::RootEntry re(be);
cta::objectstore::ScopedExclusiveLock lock(re);
re.fetch();
ASSERT_NO_THROW(re.addArchivalRoute("class1", 1, "pool1_0", cl));
ASSERT_NO_THROW(re.addArchivalRoute("class3", 3, "pool3_2", cl));
ASSERT_NO_THROW(re.addArchiveRoute("class1", 1, "pool1_0", cl));
ASSERT_NO_THROW(re.addArchiveRoute("class3", 3, "pool3_2", cl));
re.commit();
}
{
......@@ -297,8 +297,8 @@ TEST(ObjectStore, RootEntryStorageClassesAndArchivalRoutes) {
cta::objectstore::RootEntry re(be);
cta::objectstore::ScopedSharedLock lock(re);
re.fetch();
ASSERT_NO_THROW(re.getArchivalRoutes("class1"));
ASSERT_THROW(re.getArchivalRoutes("class3"),
ASSERT_NO_THROW(re.getArchiveRoutes("class1"));
ASSERT_THROW(re.getArchiveRoutes("class3"),
cta::objectstore::RootEntry::IncompleteEntry);
}
{
......@@ -306,12 +306,12 @@ TEST(ObjectStore, RootEntryStorageClassesAndArchivalRoutes) {
cta::objectstore::RootEntry re(be);
cta::objectstore::ScopedExclusiveLock lock(re);
re.fetch();
ASSERT_NO_THROW(re.addArchivalRoute("class3", 1, "pool3_0", cl));
ASSERT_NO_THROW(re.addArchivalRoute("class3", 2, "pool3_1", cl));
ASSERT_THROW(re.addArchivalRoute("class3", 3, "pool3_2b", cl), cta::objectstore::RootEntry::ArchivalRouteAlreadyExists);
ASSERT_NO_THROW(re.addArchiveRoute("class3", 1, "pool3_0", cl));
ASSERT_NO_THROW(re.addArchiveRoute("class3", 2, "pool3_1", cl));
ASSERT_THROW(re.addArchiveRoute("class3", 3, "pool3_2b", cl), cta::objectstore::RootEntry::ArchiveRouteAlreadyExists);
re.commit();
re.fetch();
ASSERT_NO_THROW(re.getArchivalRoutes("class3"));
ASSERT_NO_THROW(re.getArchiveRoutes("class3"));
}
{
// Check that resizing storage classes down and up work as expected
......@@ -323,10 +323,10 @@ TEST(ObjectStore, RootEntryStorageClassesAndArchivalRoutes) {
ASSERT_NO_THROW(re.setStorageClassCopyCount("class3", 2, cl));
re.commit();
re.fetch();
ASSERT_THROW(re.getArchivalRoutes("class1"),
ASSERT_THROW(re.getArchiveRoutes("class1"),
cta::objectstore::RootEntry::IncompleteEntry);
ASSERT_NO_THROW(re.getArchivalRoutes("class3"));
ASSERT_EQ(2,re.getArchivalRoutes("class3").size());
ASSERT_NO_THROW(re.getArchiveRoutes("class3"));
ASSERT_EQ(2,re.getArchiveRoutes("class3").size());
}
{
// Check that dump works in all circumstances
......@@ -347,9 +347,9 @@ TEST(ObjectStore, RootEntryStorageClassesAndArchivalRoutes) {
cta::objectstore::RootEntry re(be);
cta::objectstore::ScopedExclusiveLock lock(re);
re.fetch();
re.removeArchivalRoute("class1", 1);
re.removeArchivalRoute("class3", 1);
re.removeArchivalRoute("class3", 2);
re.removeArchiveRoute("class1", 1);
re.removeArchiveRoute("class3", 1);
re.removeArchiveRoute("class3", 2);
re.removeStorageClass("class1");
re.removeStorageClass("class3");
re.commit();
......
......@@ -42,13 +42,13 @@ void cta::objectstore::Tape::initialize(const std::string &name) {
bool cta::objectstore::Tape::isEmpty() {
checkPayloadReadable();
return !m_payload.retrievaljobs_size();
return !m_payload.retrievejobs_size();
}
void cta::objectstore::Tape::removeIfEmpty() {
checkPayloadWritable();
if (!isEmpty()) {
throw NotEmpty("In Tape::removeIfEmpty: trying to remove an tape with retrievals queued");
throw NotEmpty("In Tape::removeIfEmpty: trying to remove an tape with retrieves queued");
}
remove();
}
......@@ -74,7 +74,7 @@ std::string cta::objectstore::Tape::dump() {
ret << "<<<< Tape dump start: vid=" << m_payload.vid() << std::endl;
ret << " lastFseq=" << m_payload.lastfseq()
<< " bytesStored=" << m_payload.bytesstored() << std::endl;
ret << " Retrieval jobs queued: " << m_payload.retrievaljobs_size() << std::endl;
ret << " Retrieve jobs queued: " << m_payload.retrievejobs_size() << std::endl;
if (m_payload.readmounts_size()) {
auto lrm = m_payload.readmounts(0);
ret << " Latest read for mount: " << lrm.host() << " " << lrm.time() << " "
......@@ -94,7 +94,7 @@ std::string cta::objectstore::Tape::dump() {
void cta::objectstore::Tape::addJob(const RetrieveToFileRequest::JobDump& job,
const std::string & retrieveToFileAddress, uint64_t size) {
checkPayloadWritable();
auto * j = m_payload.add_retrievaljobs();
auto * j = m_payload.add_retrievejobs();
j->set_address(retrieveToFileAddress);
j->set_size(size);
}
......@@ -39,7 +39,7 @@ public:
void removeIfEmpty();
std::string dump();
// Retrieval jobs management ==================================================
// Retrieve jobs management ==================================================
void addJob(const RetrieveToFileRequest::JobDump & job,
const std::string & retrieveToFileAddress, uint64_t size);
......
......@@ -40,7 +40,7 @@ void cta::objectstore::TapePool::initialize(const std::string& name) {
ObjectOps<serializers::TapePool>::initialize();
// Setup the object so it's valid
m_payload.set_name(name);
// set the archival jobs counter to zero
// set the archive jobs counter to zero
m_payload.set_archivejobstotalsize(0);
// This object is good to go (to storage)
m_payloadInterpreted = true;
......@@ -147,7 +147,7 @@ bool cta::objectstore::TapePool::isEmpty() {
// Check we have no tapes in pool
if (m_payload.tapes_size())
return false;
// Check we have no archival jobs pending
// Check we have no archive jobs pending
if (m_payload.pendingarchivejobs_size()
|| m_payload.orphanedarchivejobsnscreation_size()
|| m_payload.orphanedarchivejobsnsdeletion_size())
......
......@@ -64,7 +64,7 @@ public:
};
std::list<TapeDump> dumpTapes();
// Archival jobs management ==================================================
// Archive jobs management ===================================================
void addJob(const ArchiveToFileRequest::JobDump & job,
const std::string & archiveToFileAddress, const std::string & path,
uint64_t size);
......
......@@ -66,8 +66,8 @@ message AdminUser {
required CreationLog log = 41;
}
// The Archival route
message ArchivalRoute {
// The Archive route
message ArchiveRoute {
required uint32 copynb = 50;
required string tapepool = 51;
required CreationLog log = 52;
......@@ -77,7 +77,7 @@ message ArchivalRoute {
message StorageClass {
required string name = 60;
required uint32 copycount = 61;
repeated ArchivalRoute routes = 62;
repeated ArchiveRoute routes = 62;
required CreationLog log = 63;
}
......@@ -197,7 +197,7 @@ message Tape {
required uint64 bytesstored = 4302;
repeated MountInfo readmounts = 4303;
repeated MountInfo writemounts = 4304;
repeated RetrieveJobPointer retrievaljobs = 4305;
repeated RetrieveJobPointer retrievejobs = 4305;
}
// ------------- Archive Jobs --------------------------------------------------
......
......@@ -16,36 +16,36 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "scheduler/ArchivalFileTransfer.hpp"
#include "scheduler/ArchiveJob.hpp"
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
cta::ArchivalFileTransfer::ArchivalFileTransfer() {
cta::ArchiveJob::ArchiveJob() {
}
//------------------------------------------------------------------------------
// destructor
//------------------------------------------------------------------------------
cta::ArchivalFileTransfer::~ArchivalFileTransfer() throw() {
cta::ArchiveJob::~ArchiveJob() throw() {
}
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
cta::ArchivalFileTransfer::ArchivalFileTransfer(
cta::ArchiveJob::ArchiveJob(
const std::string &tapePoolName,
const std::string &id,
const std::string &userRequestId,
const uint32_t copyNb,
const std::string &remoteFile):
FileTransfer(id, userRequestId, copyNb, remoteFile),
TapeJob(id, userRequestId, copyNb, remoteFile),
m_tapePoolName(tapePoolName) {
}
//------------------------------------------------------------------------------
// getTapePoolName
//------------------------------------------------------------------------------
const std::string &cta::ArchivalFileTransfer::getTapePoolName() const throw() {
const std::string &cta::ArchiveJob::getTapePoolName() const throw() {
return m_tapePoolName;
}
......@@ -18,7 +18,7 @@
#pragma once
#include "scheduler/FileTransfer.hpp"
#include "scheduler/TapeJob.hpp"
#include <stdint.h>
#include <string>
......@@ -28,29 +28,29 @@ namespace cta {
/**
* Class representing the transfer of a single copy of a remote file to tape.
*/
class ArchivalFileTransfer: public FileTransfer {
class ArchiveJob: public TapeJob {
public:
/**
* Constructor.
*/
ArchivalFileTransfer();
ArchiveJob();
/**
* Destructor.
*/
~ArchivalFileTransfer() throw();
~ArchiveJob() throw();
/**
* Constructor.
*
* @param tapePoolName The name of the destination tape pool.
* @param id The identifier of the file transfer.
* @param id The identifier of the tape job.
* @param userRequestId The identifier of the associated user request.
* @param copyNb The copy number.
* @param remoteFile The URL of the remote source file.
*/
ArchivalFileTransfer(
ArchiveJob(
const std::string &tapePoolName,
const std::string &id,
const std::string &userRequestId,
......@@ -71,6 +71,6 @@ private:
*/
std::string m_tapePoolName;
}; // class ArchivalFileTransfer
}; // class ArchiveJob
} // namespace cta
......@@ -16,25 +16,25 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "scheduler/ArchivalRoute.hpp"
#include "scheduler/ArchiveRoute.hpp"
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
cta::ArchivalRoute::ArchivalRoute():
cta::ArchiveRoute::ArchiveRoute():
copyNb(0) {
}
//------------------------------------------------------------------------------
// destructor
//------------------------------------------------------------------------------
cta::ArchivalRoute::~ArchivalRoute() throw() {
cta::ArchiveRoute::~ArchiveRoute() throw() {
}
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
cta::ArchivalRoute::ArchivalRoute(
cta::ArchiveRoute::ArchiveRoute(
const std::string &storageClassName,
const uint16_t copyNb,
const std::string &tapePoolName,
......
......@@ -28,19 +28,19 @@
namespace cta {
/**
* An archival route.
* An archive route.
*/
struct ArchivalRoute {
struct ArchiveRoute {
/**
* Constructor.
*/
ArchivalRoute();
ArchiveRoute();
/**
* Destructor.
*/
~ArchivalRoute() throw();
~ArchiveRoute() throw();
/**
* Constructor.
......@@ -52,7 +52,7 @@ struct ArchivalRoute {
* @param creationLog The who, where, when an why of this modification.
* time is used.
*/
ArchivalRoute(
ArchiveRoute(
const std::string &storageClassName,
const uint16_t copyNb,
const std::string &tapePoolName,
......@@ -78,6 +78,6 @@ struct ArchivalRoute {
*/
CreationLog creationLog;
}; // class ArchivalRoute
}; // class ArchiveRoute
} // namespace cta
......@@ -16,19 +16,19 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "scheduler/ArchivalRouteId.hpp"
#include "scheduler/ArchiveRouteId.hpp"
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
cta::ArchivalRouteId::ArchivalRouteId():
cta::ArchiveRouteId::ArchiveRouteId():
m_copyNb(0) {
}
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
cta::ArchivalRouteId::ArchivalRouteId(
cta::ArchiveRouteId::ArchiveRouteId(
const std::string &storageClassName,
const uint16_t copyNb):
m_storageClassName(storageClassName),
......@@ -38,7 +38,7 @@ cta::ArchivalRouteId::ArchivalRouteId(
//------------------------------------------------------------------------------
// operator<
//------------------------------------------------------------------------------
bool cta::ArchivalRouteId::operator<(const ArchivalRouteId &rhs) const {
bool cta::ArchiveRouteId::operator<(const ArchiveRouteId &rhs) const {
if(m_storageClassName != rhs.m_storageClassName) {
return m_storageClassName < rhs.m_storageClassName;
} else {
......@@ -49,13 +49,13 @@ bool cta::ArchivalRouteId::operator<(const ArchivalRouteId &rhs) const {
//------------------------------------------------------------------------------
// getStorageClassName
//------------------------------------------------------------------------------
const std::string &cta::ArchivalRouteId::getStorageClassName() const throw() {
const std::string &cta::ArchiveRouteId::getStorageClassName() const throw() {
return m_storageClassName;
}
//------------------------------------------------------------------------------
// getCopyNb
//------------------------------------------------------------------------------
uint16_t cta::ArchivalRouteId::getCopyNb() const throw() {
uint16_t cta::ArchiveRouteId::getCopyNb() const throw() {
return m_copyNb;
}
......@@ -24,15 +24,15 @@
namespace cta {
/**
* Class used to identify an archival route.