diff --git a/Doxyfile b/Doxyfile
index 0c6042293c13459d7219f3e4d319ff8a3315cbd6..e2d0d109f0adad6f16f5082a8fa333918cfa69b3 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -297,17 +297,17 @@ SYMBOL_CACHE_SIZE = 0
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
-EXTRACT_ALL = YES
+EXTRACT_ALL = NO
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.
-EXTRACT_PRIVATE = YES
+EXTRACT_PRIVATE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.
-EXTRACT_STATIC = YES
+EXTRACT_STATIC = NO
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
diff --git a/middletier/CMakeLists.txt b/middletier/CMakeLists.txt
index 8c50f34d7930d3a03204e9d597dfc90bb7cfafdc..bf665aff844110dc55ab21b04efb4177fa40e41a 100644
--- a/middletier/CMakeLists.txt
+++ b/middletier/CMakeLists.txt
@@ -17,14 +17,14 @@ set (MIDDLE_TIER_LIB_SRC_FILES
cta/ArchiveToDirRequest.cpp
cta/ArchiveToFileRequest.cpp
cta/ConfigurationItem.cpp
- cta/DirectoryEntry.cpp
- cta/DirectoryIterator.cpp
+ cta/DirEntry.cpp
+ cta/DirIterator.cpp
cta/DiskException.cpp
cta/DriveQuota.cpp
cta/EosRemoteStorage.cpp
cta/Exception.cpp
cta/FileAttribute.cpp
- cta/FileSystemDirectoryEntry.cpp
+ cta/FileSystemDirEntry.cpp
cta/FileSystemNode.cpp
cta/FileSystemStorageClass.cpp
cta/FileSystemStorageClasses.cpp
diff --git a/middletier/cta/DirectoryEntry.cpp b/middletier/cta/DirEntry.cpp
similarity index 79%
rename from middletier/cta/DirectoryEntry.cpp
rename to middletier/cta/DirEntry.cpp
index ee04a87ce1b0f13823e17442eaccc413e20eaeeb..53c5cb5ae8de1afdc2edcedc73409125c5a6ed71 100644
--- a/middletier/cta/DirectoryEntry.cpp
+++ b/middletier/cta/DirEntry.cpp
@@ -1,9 +1,9 @@
-#include "cta/DirectoryEntry.hpp"
+#include "cta/DirEntry.hpp"
//------------------------------------------------------------------------------
// entryTypeToStr
//------------------------------------------------------------------------------
-const char *cta::DirectoryEntry::entryTypeToStr(const EntryType enumValue)
+const char *cta::DirEntry::entryTypeToStr(const EntryType enumValue)
throw() {
switch(enumValue) {
case ENTRYTYPE_NONE : return "NONE";
@@ -16,7 +16,7 @@ const char *cta::DirectoryEntry::entryTypeToStr(const EntryType enumValue)
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-cta::DirectoryEntry::DirectoryEntry():
+cta::DirEntry::DirEntry():
m_ownerId(0),
m_groupId(0),
m_mode(0) {
@@ -25,7 +25,7 @@ cta::DirectoryEntry::DirectoryEntry():
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-cta::DirectoryEntry::DirectoryEntry(const EntryType entryType,
+cta::DirEntry::DirEntry(const EntryType entryType,
const std::string &name, const std::string &storageClassName):
m_entryType(entryType),
m_name(name),
@@ -37,7 +37,7 @@ cta::DirectoryEntry::DirectoryEntry(const EntryType entryType,
//------------------------------------------------------------------------------
// getType
//------------------------------------------------------------------------------
-cta::DirectoryEntry::EntryType cta::DirectoryEntry::getType()
+cta::DirEntry::EntryType cta::DirEntry::getType()
const throw() {
return m_entryType;
}
@@ -45,35 +45,35 @@ cta::DirectoryEntry::EntryType cta::DirectoryEntry::getType()
//------------------------------------------------------------------------------
// getName
//------------------------------------------------------------------------------
-const std::string &cta::DirectoryEntry::getName() const throw() {
+const std::string &cta::DirEntry::getName() const throw() {
return m_name;
}
//------------------------------------------------------------------------------
// getOwnerId
//------------------------------------------------------------------------------
-uint32_t cta::DirectoryEntry::getOwnerId() const throw() {
+uint32_t cta::DirEntry::getOwnerId() const throw() {
return m_ownerId;
}
//------------------------------------------------------------------------------
// getGroupId
//------------------------------------------------------------------------------
-uint32_t cta::DirectoryEntry::getGroupId() const throw() {
+uint32_t cta::DirEntry::getGroupId() const throw() {
return m_groupId;
}
//------------------------------------------------------------------------------
// getMode
//------------------------------------------------------------------------------
-uint16_t cta::DirectoryEntry::getMode() const throw() {
+uint16_t cta::DirEntry::getMode() const throw() {
return m_mode;
}
//------------------------------------------------------------------------------
// setStorageClassName
//------------------------------------------------------------------------------
-void cta::DirectoryEntry::setStorageClassName(
+void cta::DirEntry::setStorageClassName(
const std::string &storageClassName) {
m_storageClassName = storageClassName;
}
@@ -81,6 +81,6 @@ void cta::DirectoryEntry::setStorageClassName(
//------------------------------------------------------------------------------
// getStorageClassName
//------------------------------------------------------------------------------
-const std::string &cta::DirectoryEntry::getStorageClassName() const throw() {
+const std::string &cta::DirEntry::getStorageClassName() const throw() {
return m_storageClassName;
}
diff --git a/middletier/cta/DirectoryEntry.hpp b/middletier/cta/DirEntry.hpp
similarity index 95%
rename from middletier/cta/DirectoryEntry.hpp
rename to middletier/cta/DirEntry.hpp
index 4854cdcf3196bfb04b2941516f7a4a1b5ff0d16d..85e845ae02feaa4a5c76ac6ca9ce9ca4c610bd68 100644
--- a/middletier/cta/DirectoryEntry.hpp
+++ b/middletier/cta/DirEntry.hpp
@@ -9,7 +9,7 @@ namespace cta {
/**
* A directory entry.
*/
-class DirectoryEntry {
+class DirEntry {
public:
/**
@@ -31,7 +31,7 @@ public:
*
* Initialises all integer member-variables to 0.
*/
- DirectoryEntry();
+ DirEntry();
/**
* Constructor.
@@ -43,7 +43,7 @@ public:
* @param storageClassName The name of the directory's storage class or an
* empty string if the directory does not have a storage class.
*/
- DirectoryEntry(const EntryType entryType, const std::string &name,
+ DirEntry(const EntryType entryType, const std::string &name,
const std::string &storageClassName);
/**
@@ -130,6 +130,6 @@ private:
*/
std::string m_storageClassName;
-}; // class DirectoryEntry
+}; // class DirEntry
} // namespace cta
diff --git a/middletier/cta/DirectoryIterator.cpp b/middletier/cta/DirIterator.cpp
similarity index 73%
rename from middletier/cta/DirectoryIterator.cpp
rename to middletier/cta/DirIterator.cpp
index 68a95381c21b964921f7898753b63a77e3ebe4d0..890c74adbb0b3f595bde0971d5a55e667e637c06 100644
--- a/middletier/cta/DirectoryIterator.cpp
+++ b/middletier/cta/DirIterator.cpp
@@ -1,41 +1,41 @@
-#include "cta/DirectoryIterator.hpp"
+#include "cta/DirIterator.hpp"
#include "cta/Exception.hpp"
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-cta::DirectoryIterator::DirectoryIterator() {
+cta::DirIterator::DirIterator() {
}
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-cta::DirectoryIterator::DirectoryIterator(
- const std::list<DirectoryEntry> &entries): m_entries(entries) {
+cta::DirIterator::DirIterator(
+ const std::list<DirEntry> &entries): m_entries(entries) {
}
//------------------------------------------------------------------------------
// destructor
//------------------------------------------------------------------------------
-cta::DirectoryIterator::~DirectoryIterator() throw() {
+cta::DirIterator::~DirIterator() throw() {
}
//------------------------------------------------------------------------------
// hasMore
//------------------------------------------------------------------------------
-bool cta::DirectoryIterator::hasMore() {
+bool cta::DirIterator::hasMore() {
return !m_entries.empty();
}
//------------------------------------------------------------------------------
// next
//------------------------------------------------------------------------------
-const cta::DirectoryEntry cta::DirectoryIterator::next() {
+const cta::DirEntry cta::DirIterator::next() {
if(m_entries.empty()) {
throw Exception("Out of bounds: There are no more directory entries");
}
- DirectoryEntry entry = m_entries.front();
+ DirEntry entry = m_entries.front();
m_entries.pop_front();
return entry;
}
diff --git a/middletier/cta/DirectoryIterator.hpp b/middletier/cta/DirIterator.hpp
similarity index 69%
rename from middletier/cta/DirectoryIterator.hpp
rename to middletier/cta/DirIterator.hpp
index a4289324d86ce1ede5a890ff62fb577c3c9548ac..6dd52720543bd4e7642cfb443f351df445b58385 100644
--- a/middletier/cta/DirectoryIterator.hpp
+++ b/middletier/cta/DirIterator.hpp
@@ -1,6 +1,6 @@
#pragma once
-#include "cta/DirectoryEntry.hpp"
+#include "cta/DirEntry.hpp"
#include <list>
@@ -11,34 +11,34 @@ namespace cta {
* through the contents of a directory.
*
* \code
- * DirectoryIterator &itor = ...
+ * DirIterator &itor = ...
*
* while(itor.hasMore())) {
- * const DirectoryEntry &entry = itor.next();
+ * const DirEntry &entry = itor.next();
*
* // Do something with entry
* }
* \endcode
*/
-class DirectoryIterator {
+class DirIterator {
public:
/**
* Constructor.
*/
- DirectoryIterator();
+ DirIterator();
/**
* Constructor.
*
* @param entries The directory entries.
*/
- DirectoryIterator(const std::list<DirectoryEntry> &entries);
+ DirIterator(const std::list<DirEntry> &entries);
/**
* Destructor.
*/
- ~DirectoryIterator() throw();
+ ~DirIterator() throw();
/**
* Returns true if there are more directory entries.
@@ -53,15 +53,15 @@ public:
*
* @return The next directory entry.
*/
- const DirectoryEntry next();
+ const DirEntry next();
private:
/**
* The directory entries.
*/
- std::list<DirectoryEntry> m_entries;
+ std::list<DirEntry> m_entries;
-}; // DirectoryIterator
+}; // DirIterator
} // namespace cta
diff --git a/middletier/cta/FileSystemDirectoryEntry.cpp b/middletier/cta/FileSystemDirEntry.cpp
similarity index 78%
rename from middletier/cta/FileSystemDirectoryEntry.cpp
rename to middletier/cta/FileSystemDirEntry.cpp
index 7d37f6bc23974fd3d10e4be21ece8c85f994e488..1afbb9a5bbc33c46c2f0c4744c8294ad35227a6c 100644
--- a/middletier/cta/FileSystemDirectoryEntry.cpp
+++ b/middletier/cta/FileSystemDirEntry.cpp
@@ -1,17 +1,17 @@
-#include "cta/FileSystemDirectoryEntry.hpp"
+#include "cta/FileSystemDirEntry.hpp"
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-cta::FileSystemDirectoryEntry::FileSystemDirectoryEntry():
+cta::FileSystemDirEntry::FileSystemDirEntry():
m_storageClasses(NULL) {
}
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
-cta::FileSystemDirectoryEntry::FileSystemDirectoryEntry(
- FileSystemStorageClasses &storageClasses, const DirectoryEntry &entry):
+cta::FileSystemDirEntry::FileSystemDirEntry(
+ FileSystemStorageClasses &storageClasses, const DirEntry &entry):
m_storageClasses(&storageClasses),
m_entry(entry) {
setStorageClassName(entry.getStorageClassName());
@@ -20,7 +20,7 @@ cta::FileSystemDirectoryEntry::FileSystemDirectoryEntry(
//------------------------------------------------------------------------------
// getEntry
//------------------------------------------------------------------------------
-const cta::DirectoryEntry &cta::FileSystemDirectoryEntry::getEntry()
+const cta::DirEntry &cta::FileSystemDirEntry::getEntry()
const throw() {
return m_entry;
}
@@ -28,7 +28,7 @@ const cta::DirectoryEntry &cta::FileSystemDirectoryEntry::getEntry()
//------------------------------------------------------------------------------
// setStorageClassName
//------------------------------------------------------------------------------
-void cta::FileSystemDirectoryEntry::setStorageClassName(
+void cta::FileSystemDirEntry::setStorageClassName(
const std::string &storageClassName) {
const std::string previousStorageClassName = m_entry.getStorageClassName();
diff --git a/middletier/cta/FileSystemDirectoryEntry.hpp b/middletier/cta/FileSystemDirEntry.hpp
similarity index 73%
rename from middletier/cta/FileSystemDirectoryEntry.hpp
rename to middletier/cta/FileSystemDirEntry.hpp
index 250fab3d0deae3994bd31cce29b37cf33fa7361c..bb96d6ecd66698de2829fa500e283265653f78fa 100644
--- a/middletier/cta/FileSystemDirectoryEntry.hpp
+++ b/middletier/cta/FileSystemDirEntry.hpp
@@ -1,6 +1,6 @@
#pragma once
-#include "cta/DirectoryEntry.hpp"
+#include "cta/DirEntry.hpp"
#include "cta/FileSystemStorageClasses.hpp"
namespace cta {
@@ -9,13 +9,13 @@ namespace cta {
* Class used to store a directory entry and to provide other information and/or
* features required by the file system.
*/
-class FileSystemDirectoryEntry {
+class FileSystemDirEntry {
public:
/**
* Constructor.
*/
- FileSystemDirectoryEntry();
+ FileSystemDirEntry();
/**
* Constructor.
@@ -23,15 +23,15 @@ public:
* @param storageClasses The storage classes used by the file system.
* @param entry The directory entry.
*/
- FileSystemDirectoryEntry(FileSystemStorageClasses &storageClasses,
- const DirectoryEntry &entry);
+ FileSystemDirEntry(FileSystemStorageClasses &storageClasses,
+ const DirEntry &entry);
/**
* Returns the directory entry.
*
* @return The directory entry.
*/
- const DirectoryEntry &getEntry() const throw();
+ const DirEntry &getEntry() const throw();
/**
* Sets the name of the storage class.
@@ -50,8 +50,8 @@ private:
/**
* The directory entry.
*/
- DirectoryEntry m_entry;
+ DirEntry m_entry;
-}; // FileSystemDirectoryEntry
+}; // FileSystemDirEntry
} // namespace cta
diff --git a/middletier/cta/FileSystemNode.cpp b/middletier/cta/FileSystemNode.cpp
index e2588ae78bb0cbc6a9e9a2700d979b1e31b5e3e8..6a76235558fed8090488e9f7cafae0d463a3fec5 100644
--- a/middletier/cta/FileSystemNode.cpp
+++ b/middletier/cta/FileSystemNode.cpp
@@ -13,9 +13,9 @@ cta::FileSystemNode::FileSystemNode():
// constructor
//------------------------------------------------------------------------------
cta::FileSystemNode::FileSystemNode(FileSystemStorageClasses &storageclasses,
- const DirectoryEntry &entry):
+ const DirEntry &entry):
m_storageClasses(&storageclasses),
- m_entry(FileSystemDirectoryEntry(storageclasses, entry)) {
+ m_entry(FileSystemDirEntry(storageclasses, entry)) {
}
//------------------------------------------------------------------------------
@@ -64,7 +64,7 @@ const cta::FileSystemNode &cta::FileSystemNode::getParent() const {
//------------------------------------------------------------------------------
// getFileSystemEntry
//------------------------------------------------------------------------------
-cta::FileSystemDirectoryEntry &cta::FileSystemNode::getFileSystemEntry()
+cta::FileSystemDirEntry &cta::FileSystemNode::getFileSystemEntry()
throw() {
return m_entry;
}
@@ -72,24 +72,24 @@ cta::FileSystemDirectoryEntry &cta::FileSystemNode::getFileSystemEntry()
//------------------------------------------------------------------------------
// getFileSystemEntry
//------------------------------------------------------------------------------
-const cta::FileSystemDirectoryEntry &cta::FileSystemNode::getFileSystemEntry()
+const cta::FileSystemDirEntry &cta::FileSystemNode::getFileSystemEntry()
const throw() {
return m_entry;
}
//------------------------------------------------------------------------------
-// getDirectoryEntries
+// getDirEntries
//------------------------------------------------------------------------------
-std::list<cta::DirectoryEntry> cta::FileSystemNode::getDirectoryEntries()
+std::list<cta::DirEntry> cta::FileSystemNode::getDirEntries()
const {
- std::list<DirectoryEntry> entries;
+ std::list<DirEntry> entries;
for(std::map<std::string, FileSystemNode*>::const_iterator itor =
m_children.begin(); itor != m_children.end(); itor++) {
const FileSystemNode *const childNode = itor->second;
if(NULL == childNode) {
- throw(Exception("getDirectoryEntries encountered a NULL child pointer"));
+ throw(Exception("getDirEntries encountered a NULL child pointer"));
}
- const cta::FileSystemDirectoryEntry &childEntry =
+ const cta::FileSystemDirEntry &childEntry =
childNode->getFileSystemEntry();
entries.push_back(childEntry.getEntry());
}
diff --git a/middletier/cta/FileSystemNode.hpp b/middletier/cta/FileSystemNode.hpp
index 2250f86c6259ed82501d1eaf57be1995c49bfa87..fc1d5e9b97e336d0eaa70a6bd23c9ab85a799332 100644
--- a/middletier/cta/FileSystemNode.hpp
+++ b/middletier/cta/FileSystemNode.hpp
@@ -1,6 +1,6 @@
#pragma once
-#include "cta/FileSystemDirectoryEntry.hpp"
+#include "cta/FileSystemDirEntry.hpp"
#include "cta/FileSystemStorageClasses.hpp"
#include <map>
@@ -22,10 +22,10 @@ public:
* Constructor.
*
* @param storageclasses The storage classes used in the file system.
- * @param entry The description of the node in the form of a DirectoryEntry.
+ * @param entry The description of the node in the form of a DirEntry.
*/
FileSystemNode(FileSystemStorageClasses &storageclasses,
- const DirectoryEntry &entry);
+ const DirEntry &entry);
/**
* Destructor.
@@ -49,14 +49,14 @@ public:
*
* @return The file-system directory-entry.
*/
- FileSystemDirectoryEntry &getFileSystemEntry() throw();
+ FileSystemDirEntry &getFileSystemEntry() throw();
/**
* Returns the file-system directory-entry.
*
* @return The file-system directory-entry.
*/
- const FileSystemDirectoryEntry &getFileSystemEntry() const throw();
+ const FileSystemDirEntry &getFileSystemEntry() const throw();
/**
* Gets the contents of this file system node in the form of a list of
@@ -65,7 +65,7 @@ public:
* @return The contents of this file system node in the form of a list of
* DirectoryEntries.
*/
- std::list<DirectoryEntry> getDirectoryEntries() const;
+ std::list<DirEntry> getDirEntries() const;
/**
* Adds the specified node to the children of this node.
@@ -128,7 +128,7 @@ private:
/**
* The file-system diretcory-entry.
*/
- FileSystemDirectoryEntry m_entry;
+ FileSystemDirEntry m_entry;
/**
* The child nodes as a map from name to node.
diff --git a/middletier/cta/MiddleTierAdmin.hpp b/middletier/cta/MiddleTierAdmin.hpp
index 80ed9592c1ec91a1c613af73448ff9a37e88c593..c480a0436ff35a07568b4149d297de79b621476c 100644
--- a/middletier/cta/MiddleTierAdmin.hpp
+++ b/middletier/cta/MiddleTierAdmin.hpp
@@ -4,7 +4,7 @@
#include "cta/AdminUser.hpp"
#include "cta/ArchivalJob.hpp"
#include "cta/ArchivalRoute.hpp"
-#include "cta/DirectoryIterator.hpp"
+#include "cta/DirIterator.hpp"
#include "cta/LogicalLibrary.hpp"
#include "cta/SecurityIdentity.hpp"
#include "cta/StorageClass.hpp"
diff --git a/middletier/cta/MiddleTierUser.hpp b/middletier/cta/MiddleTierUser.hpp
index 4acf4825e5efc6b5a30dc68db410d79550af56ec..eba4a623b6d71f94737403aa930f8d8cce76625e 100644
--- a/middletier/cta/MiddleTierUser.hpp
+++ b/middletier/cta/MiddleTierUser.hpp
@@ -2,7 +2,7 @@
#include "cta/ArchivalJob.hpp"
#include "cta/ArchivalRoute.hpp"
-#include "cta/DirectoryIterator.hpp"
+#include "cta/DirIterator.hpp"
#include "cta/LogicalLibrary.hpp"
#include "cta/RetrievalJob.hpp"
#include "cta/SecurityIdentity.hpp"
@@ -36,7 +36,7 @@ public:
* directory.
* @param dirPath The absolute path of the directory.
*/
- virtual void createDirectory(
+ virtual void createDir(
const SecurityIdentity &requester,
const std::string &dirPath) = 0;
@@ -47,7 +47,7 @@ public:
* directory.
* @param dirPath The absolute path of the directory.
*/
- virtual void deleteDirectory(
+ virtual void deleteDir(
const SecurityIdentity &requester,
const std::string &dirPath) = 0;
@@ -59,7 +59,7 @@ public:
* @param dirPath The absolute path of the directory.
* @return An iterator over the contents of the directory.
*/
- virtual DirectoryIterator getDirectoryContents(
+ virtual DirIterator getDirContents(
const SecurityIdentity &requester,
const std::string &dirPath) const = 0;
@@ -73,7 +73,7 @@ public:
* @return The directory entry information for the specified directory or file
* within the archive namespace.
*/
- virtual DirectoryEntry stat(
+ virtual DirEntry stat(
const SecurityIdentity &requester,
const std::string path) const = 0;
@@ -85,7 +85,7 @@ public:
* @param dirPath The absolute path of the directory.
* @param storageClassName The name of the storage class.
*/
- virtual void setDirectoryStorageClass(
+ virtual void setDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath,
const std::string &storageClassName) = 0;
@@ -97,7 +97,7 @@ public:
* the directory to be cleared.
* @param dirPath The absolute path of the directory.
*/
- virtual void clearDirectoryStorageClass(
+ virtual void clearDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath) = 0;
@@ -111,7 +111,7 @@ public:
* @return The name of the storage class if the directory has one, else an
* empty string.
*/
- virtual std::string getDirectoryStorageClass(
+ virtual std::string getDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath) const = 0;
diff --git a/middletier/cta/SqliteMiddleTierAdminTest.cpp b/middletier/cta/SqliteMiddleTierAdminTest.cpp
index 14c8d6050d14d2efd8fc7bcafc0da5f7d99d781e..ac9912ea3a7acd74dbd10b69e7066923127b3e44 100644
--- a/middletier/cta/SqliteMiddleTierAdminTest.cpp
+++ b/middletier/cta/SqliteMiddleTierAdminTest.cpp
@@ -189,7 +189,7 @@ TEST_F(cta_client_SqliteMiddleTierAdminTest,
}
SqliteMiddleTierUser userApi(vfs,sqlitedb);
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, "/",
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, "/",
storageClassName));
ASSERT_THROW(adminApi.deleteStorageClass(requester, storageClassName),
@@ -206,7 +206,7 @@ TEST_F(cta_client_SqliteMiddleTierAdminTest,
ASSERT_EQ(nbCopies, storageClass.getNbCopies());
}
- ASSERT_NO_THROW(userApi.clearDirectoryStorageClass(requester, "/"));
+ ASSERT_NO_THROW(userApi.clearDirStorageClass(requester, "/"));
ASSERT_NO_THROW(adminApi.deleteStorageClass(requester, storageClassName));
diff --git a/middletier/cta/SqliteMiddleTierUser.cpp b/middletier/cta/SqliteMiddleTierUser.cpp
index 860619d879c1a80775f5511906e5d2e9331f66cf..467af32416968f943d97876f14f9031812ce2157 100644
--- a/middletier/cta/SqliteMiddleTierUser.cpp
+++ b/middletier/cta/SqliteMiddleTierUser.cpp
@@ -20,64 +20,64 @@ cta::SqliteMiddleTierUser::~SqliteMiddleTierUser() throw() {
}
//------------------------------------------------------------------------------
-// createDirectory
+// createDir
//------------------------------------------------------------------------------
-void cta::SqliteMiddleTierUser::createDirectory(const SecurityIdentity &requester,
+void cta::SqliteMiddleTierUser::createDir(const SecurityIdentity &requester,
const std::string &dirPath) {
- m_vfs.createDirectory(requester, dirPath, 0777);
+ m_vfs.createDir(requester, dirPath, 0777);
}
//------------------------------------------------------------------------------
-// deleteDirectory
+// deleteDir
//------------------------------------------------------------------------------
-void cta::SqliteMiddleTierUser::deleteDirectory(const SecurityIdentity &requester,
+void cta::SqliteMiddleTierUser::deleteDir(const SecurityIdentity &requester,
const std::string &dirPath) {
- m_vfs.deleteDirectory(requester, dirPath);
+ m_vfs.deleteDir(requester, dirPath);
}
//------------------------------------------------------------------------------
-// getDirectoryContents
+// getDirContents
//------------------------------------------------------------------------------
-cta::DirectoryIterator cta::SqliteMiddleTierUser::getDirectoryContents(
+cta::DirIterator cta::SqliteMiddleTierUser::getDirContents(
const SecurityIdentity &requester, const std::string &dirPath) const {
- return m_vfs.getDirectoryContents(requester, dirPath);
+ return m_vfs.getDirContents(requester, dirPath);
}
//------------------------------------------------------------------------------
// stat
//------------------------------------------------------------------------------
-cta::DirectoryEntry cta::SqliteMiddleTierUser::stat(
+cta::DirEntry cta::SqliteMiddleTierUser::stat(
const SecurityIdentity &requester,
const std::string path) const {
- return m_vfs.statDirectoryEntry(requester, path);
+ return m_vfs.statDirEntry(requester, path);
}
//------------------------------------------------------------------------------
-// setDirectoryStorageClass
+// setDirStorageClass
//------------------------------------------------------------------------------
-void cta::SqliteMiddleTierUser::setDirectoryStorageClass(
+void cta::SqliteMiddleTierUser::setDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath,
const std::string &storageClassName) {
- m_vfs.setDirectoryStorageClass(requester, dirPath, storageClassName);
+ m_vfs.setDirStorageClass(requester, dirPath, storageClassName);
}
//------------------------------------------------------------------------------
-// clearDirectoryStorageClass
+// clearDirStorageClass
//------------------------------------------------------------------------------
-void cta::SqliteMiddleTierUser::clearDirectoryStorageClass(
+void cta::SqliteMiddleTierUser::clearDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath) {
- m_vfs.clearDirectoryStorageClass(requester, dirPath);
+ m_vfs.clearDirStorageClass(requester, dirPath);
}
//------------------------------------------------------------------------------
-// getDirectoryStorageClass
+// getDirStorageClass
//------------------------------------------------------------------------------
-std::string cta::SqliteMiddleTierUser::getDirectoryStorageClass(
+std::string cta::SqliteMiddleTierUser::getDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath) const {
- return m_vfs.getDirectoryStorageClass(requester, dirPath);
+ return m_vfs.getDirStorageClass(requester, dirPath);
}
//------------------------------------------------------------------------------
@@ -85,28 +85,28 @@ std::string cta::SqliteMiddleTierUser::getDirectoryStorageClass(
//------------------------------------------------------------------------------
void cta::SqliteMiddleTierUser::archive(const SecurityIdentity &requester,
const std::list<std::string> &srcUrls, const std::string &dstPath) {
- if(m_vfs.isExistingDirectory(requester, dstPath)) {
- return archiveToDirectory(requester, srcUrls, dstPath);
+ if(m_vfs.isExistingDir(requester, dstPath)) {
+ return archiveToDir(requester, srcUrls, dstPath);
} else {
return archiveToFile(requester, srcUrls, dstPath);
}
}
//------------------------------------------------------------------------------
-// archiveToDirectory
+// archiveToDir
//------------------------------------------------------------------------------
-void cta::SqliteMiddleTierUser::archiveToDirectory(
+void cta::SqliteMiddleTierUser::archiveToDir(
const SecurityIdentity &requester,
const std::list<std::string> &srcUrls,
const std::string &dstDir) {
if(0 == srcUrls.size()) {
throw Exception("At least one source file should be provided");
}
- std::string storageClassName = m_vfs.getDirectoryStorageClass(requester, dstDir);
+ std::string storageClassName = m_vfs.getDirStorageClass(requester, dstDir);
cta::StorageClass storageClass = m_db.getStorageClassByName(requester, storageClassName);
if(storageClass.getNbCopies()==0) {
std::ostringstream message;
- message << "archiveToDirectory() - Storage class " << storageClassName << " has 0 copies";
+ message << "archiveToDir() - Storage class " << storageClassName << " has 0 copies";
throw(Exception(message.str()));
}
for(int i=1; i<=storageClass.getNbCopies(); i++) {
@@ -152,7 +152,7 @@ void cta::SqliteMiddleTierUser::archiveToFile(
}
const std::string &srcFileName = srcUrls.front();
- std::string storageClassName = m_vfs.getDirectoryStorageClass(requester, cta::Utils::getEnclosingDirPath(dstFile));
+ std::string storageClassName = m_vfs.getDirStorageClass(requester, cta::Utils::getEnclosingDirPath(dstFile));
cta::StorageClass storageClass = m_db.getStorageClassByName(requester, storageClassName);
if(storageClass.getNbCopies()==0) {
std::ostringstream message;
diff --git a/middletier/cta/SqliteMiddleTierUser.hpp b/middletier/cta/SqliteMiddleTierUser.hpp
index eebcd6cbec5ebd8e8fd6749b9eedd61ea57fd2db..085a347fbd6b2e54aaa363bcc0427556ab314470 100644
--- a/middletier/cta/SqliteMiddleTierUser.hpp
+++ b/middletier/cta/SqliteMiddleTierUser.hpp
@@ -35,7 +35,7 @@ public:
* directory.
* @param dirPath The absolute path of the directory.
*/
- void createDirectory(
+ void createDir(
const SecurityIdentity &requester,
const std::string &dirPath);
@@ -46,7 +46,7 @@ public:
* directory.
* @param dirPath The absolute path of the directory.
*/
- void deleteDirectory(
+ void deleteDir(
const SecurityIdentity &requester,
const std::string &dirPath);
@@ -58,7 +58,7 @@ public:
* @param dirPath The absolute path of the directory.
* @return An iterator over the contents of the directory.
*/
- DirectoryIterator getDirectoryContents(
+ DirIterator getDirContents(
const SecurityIdentity &requester,
const std::string &dirPath) const;
@@ -72,7 +72,7 @@ public:
* @return The directory entry information for the specified directory or file
* within the archive namespace.
*/
- DirectoryEntry stat(
+ DirEntry stat(
const SecurityIdentity &requester,
const std::string path) const;
@@ -84,7 +84,7 @@ public:
* @param dirPath The absolute path of the directory.
* @param storageClassName The name of the storage class.
*/
- void setDirectoryStorageClass(
+ void setDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath,
const std::string &storageClassName);
@@ -96,7 +96,7 @@ public:
* the directory to be cleared.
* @param dirPath The absolute path of the directory.
*/
- void clearDirectoryStorageClass(
+ void clearDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath);
@@ -110,7 +110,7 @@ public:
* @return The name of the storage class if the directory has one, else an
* empty string.
*/
- std::string getDirectoryStorageClass(
+ std::string getDirStorageClass(
const SecurityIdentity &requester,
const std::string &dirPath) const;
@@ -247,7 +247,7 @@ private:
* @return True if the specified absolute path is that of an existing
* directory within the archive namepsace.
*/
- bool isAnExistingDirectory(const std::string &path) const throw();
+ bool isAnExistingDir(const std::string &path) const throw();
/**
* Archives the specified list of source files to the specified destination
@@ -262,7 +262,7 @@ private:
* @param srcUrls List of one or more source files.
* @param dstDir Destination directory within the archive namespace.
*/
- void archiveToDirectory(
+ void archiveToDir(
const SecurityIdentity &requester,
const std::list<std::string> &srcUrls,
const std::string &dstDir);
diff --git a/middletier/cta/SqliteMiddleTierUserTest.cpp b/middletier/cta/SqliteMiddleTierUserTest.cpp
index ad5492143196cf30a5d6a9c9e5e0952a44b1852d..4bbdbe46aea68cced4a0572b6f14168d9d060777 100644
--- a/middletier/cta/SqliteMiddleTierUserTest.cpp
+++ b/middletier/cta/SqliteMiddleTierUserTest.cpp
@@ -17,7 +17,7 @@ protected:
};
TEST_F(cta_client_SqliteMiddleTierUserTest,
- getDirectoryContents_root_dir_is_empty) {
+ getDirContents_root_dir_is_empty) {
using namespace cta;
SqliteDatabase db;
@@ -26,12 +26,12 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
const SecurityIdentity requester;
const std::string dirPath = "/";
- DirectoryIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ DirIterator itor;
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_FALSE(itor.hasMore());
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_empty_string) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, createDir_empty_string) {
using namespace cta;
SqliteDatabase db;
@@ -40,11 +40,11 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_empty_string) {
const SecurityIdentity requester;
const std::string dirPath = "";
- ASSERT_THROW(userApi.createDirectory(requester, dirPath), std::exception);
+ ASSERT_THROW(userApi.createDir(requester, dirPath), std::exception);
}
TEST_F(cta_client_SqliteMiddleTierUserTest,
- createDirectory_consecutive_slashes) {
+ createDir_consecutive_slashes) {
using namespace cta;
SqliteDatabase db;
@@ -53,10 +53,10 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
const SecurityIdentity requester;
const std::string dirPath = "//";
- ASSERT_THROW(userApi.createDirectory(requester, dirPath), std::exception);
+ ASSERT_THROW(userApi.createDir(requester, dirPath), std::exception);
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_invalid_chars) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, createDir_invalid_chars) {
using namespace cta;
SqliteDatabase db;
@@ -65,10 +65,10 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_invalid_chars) {
const SecurityIdentity requester;
const std::string dirPath = "/grandparent/?parent";
- ASSERT_THROW(userApi.createDirectory(requester, dirPath), std::exception);
+ ASSERT_THROW(userApi.createDir(requester, dirPath), std::exception);
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_top_level) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, createDir_top_level) {
using namespace cta;
SqliteDatabase db;
@@ -77,22 +77,22 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_top_level) {
const SecurityIdentity requester;
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("grandparent"), entry.getName());
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_second_level) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, createDir_second_level) {
using namespace cta;
SqliteDatabase db;
@@ -100,44 +100,44 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_second_level) {
SqliteMiddleTierUser userApi(vfs, db);
const SecurityIdentity requester;
- ASSERT_TRUE(userApi.getDirectoryStorageClass(requester, "/").empty());
+ ASSERT_TRUE(userApi.getDirStorageClass(requester, "/").empty());
{
const std::string topLevelDirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, topLevelDirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, topLevelDirPath));
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("grandparent"), entry.getName());
}
- ASSERT_TRUE(userApi.getDirectoryStorageClass(requester, "/grandparent").empty());
+ ASSERT_TRUE(userApi.getDirStorageClass(requester, "/grandparent").empty());
{
const std::string secondLevelDirPath = "/grandparent/parent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, secondLevelDirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, secondLevelDirPath));
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -145,25 +145,25 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, createDirectory_second_level) {
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/grandparent"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/grandparent"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("parent"), entry.getName());
}
- ASSERT_TRUE(userApi.getDirectoryStorageClass(requester,
+ ASSERT_TRUE(userApi.getDirStorageClass(requester,
"/grandparent/parent").empty());
}
TEST_F(cta_client_SqliteMiddleTierUserTest,
- createDirectory_inherit_storage_class) {
+ createDir_inherit_storage_class) {
using namespace cta;
SqliteDatabase db;
@@ -171,7 +171,7 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
SqliteMiddleTierUser userApi(vfs, db);
const SecurityIdentity requester;
- ASSERT_TRUE(userApi.getDirectoryStorageClass(requester, "/").empty());
+ ASSERT_TRUE(userApi.getDirStorageClass(requester, "/").empty());
{
SqliteMiddleTierAdmin adminApi(vfs, db);
@@ -184,45 +184,45 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
{
const std::string topLevelDirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, topLevelDirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, topLevelDirPath));
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("grandparent"), entry.getName());
- ASSERT_TRUE(userApi.getDirectoryStorageClass(requester, "/grandparent").empty());
+ ASSERT_TRUE(userApi.getDirStorageClass(requester, "/grandparent").empty());
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, "/grandparent",
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, "/grandparent",
"TestStorageClass"));
}
ASSERT_EQ(std::string("TestStorageClass"),
- userApi.getDirectoryStorageClass(requester, "/grandparent"));
+ userApi.getDirStorageClass(requester, "/grandparent"));
{
const std::string secondLevelDirPath = "/grandparent/parent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, secondLevelDirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, secondLevelDirPath));
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -230,13 +230,13 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/grandparent"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/grandparent"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -244,10 +244,10 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
}
ASSERT_EQ(std::string("TestStorageClass"),
- userApi.getDirectoryStorageClass(requester, "/grandparent/parent"));
+ userApi.getDirStorageClass(requester, "/grandparent/parent"));
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, deleteDirectory_root) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, deleteDir_root) {
using namespace cta;
SqliteDatabase db;
@@ -256,10 +256,10 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, deleteDirectory_root) {
const SecurityIdentity requester;
const std::string dirPath = "/";
- ASSERT_THROW(userApi.deleteDirectory(requester, "/"), std::exception);
+ ASSERT_THROW(userApi.deleteDir(requester, "/"), std::exception);
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, deleteDirectory_existing_top_level) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, deleteDir_existing_top_level) {
using namespace cta;
SqliteDatabase db;
@@ -268,35 +268,35 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, deleteDirectory_existing_top_level)
const SecurityIdentity requester;
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("grandparent"), entry.getName());
}
- ASSERT_NO_THROW(userApi.deleteDirectory(requester, "/grandparent"));
+ ASSERT_NO_THROW(userApi.deleteDir(requester, "/grandparent"));
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_FALSE(itor.hasMore());
}
}
TEST_F(cta_client_SqliteMiddleTierUserTest,
- deleteDirectory_non_empty_top_level) {
+ deleteDir_non_empty_top_level) {
using namespace cta;
SqliteDatabase db;
@@ -307,15 +307,15 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
{
const std::string topLevelDirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, topLevelDirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, topLevelDirPath));
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -325,15 +325,15 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
{
const std::string secondLevelDirPath = "/grandparent/parent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, secondLevelDirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, secondLevelDirPath));
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -341,29 +341,29 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
}
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/grandparent"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/grandparent"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("parent"), entry.getName());
}
- ASSERT_THROW(userApi.deleteDirectory(requester, "/grandparent"), std::exception);
+ ASSERT_THROW(userApi.deleteDir(requester, "/grandparent"), std::exception);
{
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/grandparent"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/grandparent"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -372,7 +372,7 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
}
TEST_F(cta_client_SqliteMiddleTierUserTest,
- deleteDirectory_non_existing_top_level) {
+ deleteDir_non_existing_top_level) {
using namespace cta;
SqliteDatabase db;
@@ -380,10 +380,10 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
SqliteMiddleTierUser userApi(vfs, db);
const SecurityIdentity requester;
- ASSERT_THROW(userApi.deleteDirectory(requester, "/grandparent"), std::exception);
+ ASSERT_THROW(userApi.deleteDir(requester, "/grandparent"), std::exception);
}
-TEST_F(cta_client_SqliteMiddleTierUserTest, setDirectoryStorageClass_top_level) {
+TEST_F(cta_client_SqliteMiddleTierUserTest, setDirStorageClass_top_level) {
using namespace cta;
SqliteDatabase db;
@@ -392,15 +392,15 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, setDirectoryStorageClass_top_level)
const SecurityIdentity requester;
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -408,7 +408,7 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, setDirectoryStorageClass_top_level)
{
std::string name;
- ASSERT_NO_THROW(name = userApi.getDirectoryStorageClass(requester, dirPath));
+ ASSERT_NO_THROW(name = userApi.getDirStorageClass(requester, dirPath));
ASSERT_TRUE(name.empty());
}
@@ -421,18 +421,18 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, setDirectoryStorageClass_top_level)
nbCopies, comment));
}
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
{
std::string name;
- ASSERT_NO_THROW(name = userApi.getDirectoryStorageClass(requester, dirPath));
+ ASSERT_NO_THROW(name = userApi.getDirStorageClass(requester, dirPath));
ASSERT_EQ(storageClassName, name);
}
}
TEST_F(cta_client_SqliteMiddleTierUserTest,
- clearDirectoryStorageClass_top_level) {
+ clearDirStorageClass_top_level) {
using namespace cta;
SqliteDatabase db;
@@ -441,15 +441,15 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
const SecurityIdentity requester;
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
@@ -457,7 +457,7 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
{
std::string name;
- ASSERT_NO_THROW(name = userApi.getDirectoryStorageClass(requester, dirPath));
+ ASSERT_NO_THROW(name = userApi.getDirStorageClass(requester, dirPath));
ASSERT_TRUE(name.empty());
}
@@ -468,23 +468,23 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
ASSERT_NO_THROW(adminApi.createStorageClass(requester, storageClassName,
nbCopies, comment));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
{
std::string name;
- ASSERT_NO_THROW(name = userApi.getDirectoryStorageClass(requester, dirPath));
+ ASSERT_NO_THROW(name = userApi.getDirStorageClass(requester, dirPath));
ASSERT_EQ(storageClassName, name);
}
ASSERT_THROW(adminApi.deleteStorageClass(requester, storageClassName),
std::exception);
- ASSERT_NO_THROW(userApi.clearDirectoryStorageClass(requester, dirPath));
+ ASSERT_NO_THROW(userApi.clearDirStorageClass(requester, dirPath));
{
std::string name;
- ASSERT_NO_THROW(name = userApi.getDirectoryStorageClass(requester, dirPath));
+ ASSERT_NO_THROW(name = userApi.getDirStorageClass(requester, dirPath));
ASSERT_TRUE(name.empty());
}
@@ -507,8 +507,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, archive_to_new_file) {
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
const std::string tapePoolName = "TestTapePool";
@@ -528,32 +528,32 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, archive_to_new_file) {
ASSERT_NO_THROW(userApi.archive(requester, srcUrls, dstPath));
{
- DirectoryIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ DirIterator itor;
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("grandparent"), entry.getName());
- ASSERT_EQ(DirectoryEntry::ENTRYTYPE_DIRECTORY, entry.getType());
+ ASSERT_EQ(DirEntry::ENTRYTYPE_DIRECTORY, entry.getType());
ASSERT_EQ(storageClassName, entry.getStorageClassName());
}
{
- DirectoryIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester,
+ DirIterator itor;
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester,
"/grandparent"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("parent_file"), entry.getName());
- ASSERT_EQ(DirectoryEntry::ENTRYTYPE_FILE, entry.getType());
+ ASSERT_EQ(DirEntry::ENTRYTYPE_FILE, entry.getType());
ASSERT_EQ(storageClassName, entry.getStorageClassName());
}
{
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = userApi.stat(requester, dstPath));
- ASSERT_EQ(DirectoryEntry::ENTRYTYPE_FILE, entry.getType());
+ ASSERT_EQ(DirEntry::ENTRYTYPE_FILE, entry.getType());
ASSERT_EQ(storageClassName, entry.getStorageClassName());
}
@@ -612,7 +612,7 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
const SecurityIdentity requester;
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
std::list<std::string> srcUrls;
srcUrls.push_back("diskUrl");
@@ -637,8 +637,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
std::list<std::string> srcUrls;
@@ -663,8 +663,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, archive_to_new_file_with_no_route) {
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
const std::string tapePoolName = "TestTapePool";
@@ -696,8 +696,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
const std::string tapePoolName = "TestTapePool";
@@ -733,8 +733,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, archive_to_directory) {
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
const std::string tapePoolName = "TestTapePool";
@@ -757,23 +757,23 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, archive_to_directory) {
ASSERT_NO_THROW(userApi.archive(requester, srcUrls, dstPath));
{
- DirectoryIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester, "/"));
+ DirIterator itor;
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester, "/"));
ASSERT_TRUE(itor.hasMore());
- DirectoryEntry entry;
+ DirEntry entry;
ASSERT_NO_THROW(entry = itor.next());
ASSERT_EQ(std::string("grandparent"), entry.getName());
- ASSERT_EQ(DirectoryEntry::ENTRYTYPE_DIRECTORY, entry.getType());
+ ASSERT_EQ(DirEntry::ENTRYTYPE_DIRECTORY, entry.getType());
ASSERT_EQ(storageClassName, entry.getStorageClassName());
}
{
std::set<std::string> archiveFileNames;
- DirectoryIterator itor;
- ASSERT_NO_THROW(itor = userApi.getDirectoryContents(requester,
+ DirIterator itor;
+ ASSERT_NO_THROW(itor = userApi.getDirContents(requester,
"/grandparent"));
while(itor.hasMore()) {
- const DirectoryEntry entry = itor.next();
+ const DirEntry entry = itor.next();
archiveFileNames.insert(entry.getName());
}
ASSERT_EQ(4, archiveFileNames.size());
@@ -850,7 +850,7 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
const SecurityIdentity requester;
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
std::list<std::string> srcUrls;
srcUrls.push_back("diskUrl1");
@@ -878,8 +878,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
std::list<std::string> srcUrls;
@@ -907,8 +907,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest, archive_to_directory_with_no_route)
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
const std::string tapePoolName = "TestTapePool";
@@ -943,8 +943,8 @@ TEST_F(cta_client_SqliteMiddleTierUserTest,
nbCopies, storageClassComment));
const std::string dirPath = "/grandparent";
- ASSERT_NO_THROW(userApi.createDirectory(requester, dirPath));
- ASSERT_NO_THROW(userApi.setDirectoryStorageClass(requester, dirPath,
+ ASSERT_NO_THROW(userApi.createDir(requester, dirPath));
+ ASSERT_NO_THROW(userApi.setDirStorageClass(requester, dirPath,
storageClassName));
const std::string tapePoolName = "TestTapePool";
diff --git a/middletier/cta/Vfs.cpp b/middletier/cta/Vfs.cpp
index 793761ef96c9cae245af27c7c2fe618c67160661..e19a1c674ed8a183e6576ce439ffe885f41bc580 100644
--- a/middletier/cta/Vfs.cpp
+++ b/middletier/cta/Vfs.cpp
@@ -37,9 +37,9 @@ void cta::Vfs::checkDirectoryExists(const std::string &dirPath) {
}
//------------------------------------------------------------------------------
-// isExistingDirectory
+// isExistingDir
//------------------------------------------------------------------------------
-bool cta::Vfs::isExistingDirectory(const SecurityIdentity &requester, const std::string &dirPath) {
+bool cta::Vfs::isExistingDir(const SecurityIdentity &requester, const std::string &dirPath) {
cta::Utils::checkAbsolutePathSyntax(dirPath);
struct stat stat_result;
int rc;
@@ -75,7 +75,7 @@ void cta::Vfs::checkPathnameDoesNotExist(const std::string &dirPath) {
// checkStorageClassIsNotInUse
//------------------------------------------------------------------------------
void cta::Vfs::checkStorageClassIsNotInUse(const SecurityIdentity &requester, const std::string &storageClass, const std::string &dirPath) {
- if(getDirectoryStorageClass(requester, dirPath)==storageClass) {
+ if(getDirStorageClass(requester, dirPath)==storageClass) {
std::ostringstream message;
message << "checkStorageClassIsNotInUse() - " << dirPath << " has the " << storageClass << " storage class.";
throw(Exception(message.str()));
@@ -146,9 +146,9 @@ cta::Vfs::~Vfs() throw() {
}
//------------------------------------------------------------------------------
-// setDirectoryStorageClass
+// setDirStorageClass
//------------------------------------------------------------------------------
-void cta::Vfs::setDirectoryStorageClass(const SecurityIdentity &requester, const std::string &path, const std::string &storageClassName) {
+void cta::Vfs::setDirStorageClass(const SecurityIdentity &requester, const std::string &path, const std::string &storageClassName) {
cta::Utils::checkAbsolutePathSyntax(path);
checkDirectoryExists(m_fsDir+path);
@@ -156,15 +156,15 @@ void cta::Vfs::setDirectoryStorageClass(const SecurityIdentity &requester, const
if(rc != 0) {
char buf[256];
std::ostringstream message;
- message << "setDirectoryStorageClass() - " << m_fsDir+path << " setxattr error. Reason: " << strerror_r(errno, buf, 256);
+ message << "setDirStorageClass() - " << m_fsDir+path << " setxattr error. Reason: " << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
}
//------------------------------------------------------------------------------
-// clearDirectoryStorageClass
+// clearDirStorageClass
//------------------------------------------------------------------------------
-void cta::Vfs::clearDirectoryStorageClass(const SecurityIdentity &requester, const std::string &path) {
+void cta::Vfs::clearDirStorageClass(const SecurityIdentity &requester, const std::string &path) {
cta::Utils::checkAbsolutePathSyntax(path);
checkDirectoryExists(m_fsDir+path);
@@ -172,15 +172,15 @@ void cta::Vfs::clearDirectoryStorageClass(const SecurityIdentity &requester, con
if(rc != 0) {
char buf[256];
std::ostringstream message;
- message << "clearDirectoryStorageClass() - " << m_fsDir+path << " setxattr error. Reason: " << strerror_r(errno, buf, 256);
+ message << "clearDirStorageClass() - " << m_fsDir+path << " setxattr error. Reason: " << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
}
//------------------------------------------------------------------------------
-// getDirectoryStorageClass
+// getDirStorageClass
//------------------------------------------------------------------------------
-std::string cta::Vfs::getDirectoryStorageClass(const SecurityIdentity &requester, const std::string &path) {
+std::string cta::Vfs::getDirStorageClass(const SecurityIdentity &requester, const std::string &path) {
cta::Utils::checkAbsolutePathSyntax(path);
checkDirectoryExists(m_fsDir+path);
@@ -190,7 +190,7 @@ std::string cta::Vfs::getDirectoryStorageClass(const SecurityIdentity &requester
if(rc == -1) {
char buf[256];
std::ostringstream message;
- message << "getDirectoryStorageClass() - " << m_fsDir+path << " getxattr error. Reason: " << strerror_r(errno, buf, 256);
+ message << "getDirStorageClass() - " << m_fsDir+path << " getxattr error. Reason: " << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
return std::string(value);
@@ -222,24 +222,24 @@ void cta::Vfs::createFile(const SecurityIdentity &requester, const std::string &
}
//------------------------------------------------------------------------------
-// createDirectory
+// createDir
//------------------------------------------------------------------------------
-void cta::Vfs::createDirectory(const SecurityIdentity &requester, const std::string &pathname, const uint16_t mode) {
+void cta::Vfs::createDir(const SecurityIdentity &requester, const std::string &pathname, const uint16_t mode) {
cta::Utils::checkAbsolutePathSyntax(pathname);
std::string path = cta::Utils::getEnclosingDirPath(pathname);
std::string name = cta::Utils::getEnclosedName(pathname);
checkDirectoryExists(m_fsDir+path);
- std::string inheritedStorageClass = getDirectoryStorageClass(requester, path);
+ std::string inheritedStorageClass = getDirStorageClass(requester, path);
int rc = mkdir((m_fsDir+pathname).c_str(), mode);
if(rc != 0) {
char buf[256];
std::ostringstream message;
- message << "createDirectory() - mkdir " << m_fsDir+pathname << " error. Reason: \n" << strerror_r(errno, buf, 256);
+ message << "createDir() - mkdir " << m_fsDir+pathname << " error. Reason: \n" << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
- setDirectoryStorageClass(requester, pathname, inheritedStorageClass);
+ setDirStorageClass(requester, pathname, inheritedStorageClass);
}
//------------------------------------------------------------------------------
@@ -258,12 +258,12 @@ void cta::Vfs::deleteFile(const SecurityIdentity &requester, const std::string &
}
//------------------------------------------------------------------------------
-// deleteDirectory
+// deleteDir
//------------------------------------------------------------------------------
-void cta::Vfs::deleteDirectory(const SecurityIdentity &requester, const std::string &pathname) {
+void cta::Vfs::deleteDir(const SecurityIdentity &requester, const std::string &pathname) {
if(pathname=="/") {
std::ostringstream message;
- message << "deleteDirectory() - Cannot delete root directory";
+ message << "deleteDir() - Cannot delete root directory";
throw(Exception(message.str()));
}
cta::Utils::checkAbsolutePathSyntax(pathname);
@@ -272,15 +272,15 @@ void cta::Vfs::deleteDirectory(const SecurityIdentity &requester, const std::str
if(rc != 0) {
char buf[256];
std::ostringstream message;
- message << "deleteDirectory() - rmdir " << m_fsDir+pathname << " error. Reason: \n" << strerror_r(errno, buf, 256);
+ message << "deleteDir() - rmdir " << m_fsDir+pathname << " error. Reason: \n" << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
}
//------------------------------------------------------------------------------
-// statDirectoryEntry
+// statDirEntry
//------------------------------------------------------------------------------
-cta::DirectoryEntry cta::Vfs::statDirectoryEntry(const SecurityIdentity &requester, const std::string &pathname) {
+cta::DirEntry cta::Vfs::statDirEntry(const SecurityIdentity &requester, const std::string &pathname) {
std::string name = cta::Utils::getEnclosedName(pathname);
std::string path = cta::Utils::getEnclosingDirPath(pathname);
@@ -291,44 +291,44 @@ cta::DirectoryEntry cta::Vfs::statDirectoryEntry(const SecurityIdentity &request
if(rc != 0) {
char buf[256];
std::ostringstream message;
- message << "statDirectoryEntry() - " << m_fsDir+pathname << " stat error. Reason: " << strerror_r(errno, buf, 256);
+ message << "statDirEntry() - " << m_fsDir+pathname << " stat error. Reason: " << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
- cta::DirectoryEntry::EntryType entryType;
+ cta::DirEntry::EntryType entryType;
std::string storageClassName;
if(S_ISDIR(stat_result.st_mode)) {
- entryType = cta::DirectoryEntry::ENTRYTYPE_DIRECTORY;
- storageClassName = getDirectoryStorageClass(requester, pathname);
+ entryType = cta::DirEntry::ENTRYTYPE_DIRECTORY;
+ storageClassName = getDirStorageClass(requester, pathname);
}
else if(S_ISREG(stat_result.st_mode)) {
- entryType = cta::DirectoryEntry::ENTRYTYPE_FILE;
- storageClassName = getDirectoryStorageClass(requester, path);
+ entryType = cta::DirEntry::ENTRYTYPE_FILE;
+ storageClassName = getDirStorageClass(requester, path);
}
else {
std::ostringstream message;
- message << "statDirectoryEntry() - " << m_fsDir+pathname << " is not a directory nor a regular file";
+ message << "statDirEntry() - " << m_fsDir+pathname << " is not a directory nor a regular file";
throw(Exception(message.str()));
}
- return cta::DirectoryEntry(entryType, name, storageClassName);
+ return cta::DirEntry(entryType, name, storageClassName);
}
//------------------------------------------------------------------------------
-// getDirectoryEntries
+// getDirEntries
//------------------------------------------------------------------------------
-std::list<cta::DirectoryEntry> cta::Vfs::getDirectoryEntries(const SecurityIdentity &requester, const std::string &dirPath) {
+std::list<cta::DirEntry> cta::Vfs::getDirEntries(const SecurityIdentity &requester, const std::string &dirPath) {
DIR *dp;
dp = opendir((m_fsDir+dirPath).c_str());
if(dp == NULL) {
char buf[256];
std::ostringstream message;
- message << "getDirectoryEntries() - opendir " << m_fsDir+dirPath << " error. Reason: \n" << strerror_r(errno, buf, 256);
+ message << "getDirEntries() - opendir " << m_fsDir+dirPath << " error. Reason: \n" << strerror_r(errno, buf, 256);
throw(Exception(message.str()));
}
- std::list<DirectoryEntry> entries;
+ std::list<DirEntry> entries;
struct dirent *entry;
while((entry = readdir(dp))) {
@@ -340,7 +340,7 @@ std::list<cta::DirectoryEntry> cta::Vfs::getDirectoryEntries(const SecurityIdent
else {
dirEntryPathname = dirPath+"/"+(entry->d_name);
}
- entries.push_back(statDirectoryEntry(requester, dirEntryPathname));
+ entries.push_back(statDirEntry(requester, dirEntryPathname));
}
}
@@ -349,17 +349,17 @@ std::list<cta::DirectoryEntry> cta::Vfs::getDirectoryEntries(const SecurityIdent
}
//------------------------------------------------------------------------------
-// getDirectoryContents
+// getDirContents
//------------------------------------------------------------------------------
-cta::DirectoryIterator cta::Vfs::getDirectoryContents(const SecurityIdentity &requester, const std::string &dirPath) {
+cta::DirIterator cta::Vfs::getDirContents(const SecurityIdentity &requester, const std::string &dirPath) {
cta::Utils::checkAbsolutePathSyntax(dirPath);
checkDirectoryExists(m_fsDir+dirPath);
- cta::DirectoryIterator it = getDirectoryEntries(requester, dirPath);
+ cta::DirIterator it = getDirEntries(requester, dirPath);
return it;
}
//------------------------------------------------------------------------------
-// getDirectoryContents
+// getDirContents
//------------------------------------------------------------------------------
std::string cta::Vfs::getVidOfFile(const SecurityIdentity &requester, const std::string &pathname, uint16_t copyNb) {
return "T00001"; //everything is on one tape for the moment:)
diff --git a/middletier/cta/Vfs.hpp b/middletier/cta/Vfs.hpp
index c452aee6ac80b752545564030e032d3078487e59..3de20750402fc96d6b0fb79ae1227929809eeedc 100644
--- a/middletier/cta/Vfs.hpp
+++ b/middletier/cta/Vfs.hpp
@@ -1,6 +1,6 @@
#pragma once
-#include "cta/DirectoryIterator.hpp"
+#include "cta/DirIterator.hpp"
#include "cta/SecurityIdentity.hpp"
namespace cta {
@@ -22,25 +22,25 @@ public:
*/
~Vfs() throw();
- void setDirectoryStorageClass(const SecurityIdentity &requester, const std::string &path, const std::string &storageClassName);
+ void setDirStorageClass(const SecurityIdentity &requester, const std::string &path, const std::string &storageClassName);
- void clearDirectoryStorageClass(const SecurityIdentity &requester, const std::string &path);
+ void clearDirStorageClass(const SecurityIdentity &requester, const std::string &path);
- std::string getDirectoryStorageClass(const SecurityIdentity &requester, const std::string &path);
+ std::string getDirStorageClass(const SecurityIdentity &requester, const std::string &path);
void createFile(const SecurityIdentity &requester, const std::string &pathname, const uint16_t mode);
- void createDirectory(const SecurityIdentity &requester, const std::string &pathname, const uint16_t mode);
+ void createDir(const SecurityIdentity &requester, const std::string &pathname, const uint16_t mode);
void deleteFile(const SecurityIdentity &requester, const std::string &pathname);
- void deleteDirectory(const SecurityIdentity &requester, const std::string &pathname);
+ void deleteDir(const SecurityIdentity &requester, const std::string &pathname);
- cta::DirectoryEntry statDirectoryEntry(const SecurityIdentity &requester, const std::string &pathname);
+ cta::DirEntry statDirEntry(const SecurityIdentity &requester, const std::string &pathname);
- cta::DirectoryIterator getDirectoryContents(const SecurityIdentity &requester, const std::string &dirPath);
+ cta::DirIterator getDirContents(const SecurityIdentity &requester, const std::string &dirPath);
- bool isExistingDirectory(const SecurityIdentity &requester, const std::string &dirPath);
+ bool isExistingDir(const SecurityIdentity &requester, const std::string &dirPath);
std::string getVidOfFile(const SecurityIdentity &requester, const std::string &pathname, uint16_t copyNb);
@@ -56,7 +56,7 @@ private:
void checkPathnameDoesNotExist(const std::string &dirPath);
- std::list<cta::DirectoryEntry> getDirectoryEntries(const SecurityIdentity &requester, const std::string &dirPath);
+ std::list<cta::DirEntry> getDirEntries(const SecurityIdentity &requester, const std::string &dirPath);
}; // struct Vfs
diff --git a/middletier/cta/VfsTest.cpp b/middletier/cta/VfsTest.cpp
index 6958773c9fc709db3daf78e4f94b27114fdc3920..2cf4cce3b4efa0d63612ba10e8e6b0a15ec7579f 100644
--- a/middletier/cta/VfsTest.cpp
+++ b/middletier/cta/VfsTest.cpp
@@ -19,11 +19,11 @@ TEST_F(cta_VfsTest, constructor_consistency) {
Vfs vfs;
cta::SecurityIdentity requester;
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(itor = vfs.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = vfs.getDirContents(requester, "/"));
ASSERT_FALSE(itor.hasMore());
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/"));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/"));
}
TEST_F(cta_VfsTest, mkdir_functionality) {
@@ -31,11 +31,11 @@ TEST_F(cta_VfsTest, mkdir_functionality) {
Vfs vfs;
cta::SecurityIdentity requester;
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir1", 0777));
- ASSERT_THROW(vfs.createDirectory(requester, "/dir1", 0777), std::exception);
- ASSERT_NO_THROW(itor = vfs.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir1", 0777));
+ ASSERT_THROW(vfs.createDir(requester, "/dir1", 0777), std::exception);
+ ASSERT_NO_THROW(itor = vfs.getDirContents(requester, "/"));
ASSERT_EQ(itor.hasMore(), true);
ASSERT_EQ(itor.next().getName(), "dir1");
ASSERT_EQ(itor.hasMore(), false);
@@ -46,11 +46,11 @@ TEST_F(cta_VfsTest, createFile_functionality) {
Vfs vfs;
cta::SecurityIdentity requester;
- DirectoryIterator itor;
+ DirIterator itor;
ASSERT_NO_THROW(vfs.createFile(requester, "/file1", 0666));
ASSERT_THROW(vfs.createFile(requester, "/file1", 0666), std::exception);
- ASSERT_NO_THROW(itor = vfs.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(itor = vfs.getDirContents(requester, "/"));
ASSERT_EQ(itor.hasMore(), true);
ASSERT_EQ(itor.next().getName(), "file1");
ASSERT_EQ(itor.hasMore(), false);
@@ -61,19 +61,19 @@ TEST_F(cta_VfsTest, rmdir_functionality) {
Vfs vfs;
cta::SecurityIdentity requester;
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir1", 0777));
- ASSERT_NO_THROW(vfs.deleteDirectory(requester, "/dir1"));
- ASSERT_THROW(vfs.deleteDirectory(requester, "/dir1"), std::exception);
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir2", 0777));
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir1", 0777));
+ ASSERT_NO_THROW(vfs.deleteDir(requester, "/dir1"));
+ ASSERT_THROW(vfs.deleteDir(requester, "/dir1"), std::exception);
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir2", 0777));
ASSERT_NO_THROW(vfs.createFile(requester, "/dir2/file1", 0666));
- ASSERT_THROW(vfs.deleteDirectory(requester, "/dir2"), std::exception);
+ ASSERT_THROW(vfs.deleteDir(requester, "/dir2"), std::exception);
ASSERT_NO_THROW(vfs.deleteFile(requester, "/dir2/file1"));
- ASSERT_NO_THROW(vfs.deleteDirectory(requester, "/dir2"));
- ASSERT_NO_THROW(itor = vfs.getDirectoryContents(requester, "/"));
+ ASSERT_NO_THROW(vfs.deleteDir(requester, "/dir2"));
+ ASSERT_NO_THROW(itor = vfs.getDirContents(requester, "/"));
ASSERT_FALSE(itor.hasMore());
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/"));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/"));
}
TEST_F(cta_VfsTest, storageClass_functionality) {
@@ -81,16 +81,16 @@ TEST_F(cta_VfsTest, storageClass_functionality) {
Vfs vfs;
cta::SecurityIdentity requester;
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir1", 0777));
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/dir1"));
- ASSERT_NO_THROW(vfs.setDirectoryStorageClass(requester, "/dir1", "cms"));
- ASSERT_EQ(std::string("cms"), vfs.getDirectoryStorageClass(requester, "/dir1"));
- ASSERT_NO_THROW(vfs.clearDirectoryStorageClass(requester, "/dir1"));
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/dir1"));
- ASSERT_NO_THROW(vfs.setDirectoryStorageClass(requester, "/dir1", "atlas"));
- ASSERT_EQ(std::string("atlas"), vfs.getDirectoryStorageClass(requester, "/dir1"));
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir1", 0777));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/dir1"));
+ ASSERT_NO_THROW(vfs.setDirStorageClass(requester, "/dir1", "cms"));
+ ASSERT_EQ(std::string("cms"), vfs.getDirStorageClass(requester, "/dir1"));
+ ASSERT_NO_THROW(vfs.clearDirStorageClass(requester, "/dir1"));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/dir1"));
+ ASSERT_NO_THROW(vfs.setDirStorageClass(requester, "/dir1", "atlas"));
+ ASSERT_EQ(std::string("atlas"), vfs.getDirStorageClass(requester, "/dir1"));
}
TEST_F(cta_VfsTest, storageClass_inheritance) {
@@ -98,17 +98,17 @@ TEST_F(cta_VfsTest, storageClass_inheritance) {
Vfs vfs;
cta::SecurityIdentity requester;
- DirectoryIterator itor;
+ DirIterator itor;
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir1", 0777));
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/dir1"));
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir1/dir1_1", 0777));
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/dir1/dir1_1"));
- ASSERT_NO_THROW(vfs.setDirectoryStorageClass(requester, "/dir1", "cms"));
- ASSERT_EQ(std::string("cms"), vfs.getDirectoryStorageClass(requester, "/dir1"));
- ASSERT_NO_THROW(vfs.createDirectory(requester, "/dir1/dir1_2", 0777));
- ASSERT_EQ(std::string("cms"), vfs.getDirectoryStorageClass(requester, "/dir1/dir1_2"));
- ASSERT_EQ(std::string(""), vfs.getDirectoryStorageClass(requester, "/dir1/dir1_1"));
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir1", 0777));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/dir1"));
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir1/dir1_1", 0777));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/dir1/dir1_1"));
+ ASSERT_NO_THROW(vfs.setDirStorageClass(requester, "/dir1", "cms"));
+ ASSERT_EQ(std::string("cms"), vfs.getDirStorageClass(requester, "/dir1"));
+ ASSERT_NO_THROW(vfs.createDir(requester, "/dir1/dir1_2", 0777));
+ ASSERT_EQ(std::string("cms"), vfs.getDirStorageClass(requester, "/dir1/dir1_2"));
+ ASSERT_EQ(std::string(""), vfs.getDirStorageClass(requester, "/dir1/dir1_1"));
}
}
\ No newline at end of file
diff --git a/xroot_plugins/XrdProDir.cpp b/xroot_plugins/XrdProDir.cpp
index c31208a061d27de2f5f447f6ab26d2a523f37d7e..a90ad4ed8681e5d95176d9f5c9673544d1cc0877 100644
--- a/xroot_plugins/XrdProDir.cpp
+++ b/xroot_plugins/XrdProDir.cpp
@@ -62,7 +62,7 @@ int XrdProDir::open(const char *path, const XrdSecEntity *client, const char *op
if(SFS_OK!=checkResult) {
return checkResult;
}
- m_itor = m_userApi.getDirectoryContents(requester, path);
+ m_itor = m_userApi.getDirContents(requester, path);
return SFS_OK;
}
diff --git a/xroot_plugins/XrdProDir.hpp b/xroot_plugins/XrdProDir.hpp
index 8a75dc622e30d0e23154f0c9091c8c8b2809f62e..44eac7955a37eef941d5803bc3422adde1372136 100644
--- a/xroot_plugins/XrdProDir.hpp
+++ b/xroot_plugins/XrdProDir.hpp
@@ -21,7 +21,7 @@ protected:
/**
* Iterator holding contents of the directory
*/
- cta::DirectoryIterator m_itor;
+ cta::DirIterator m_itor;
/**
* Pointer to the user API object
diff --git a/xroot_plugins/XrdProFilesystem.cpp b/xroot_plugins/XrdProFilesystem.cpp
index 38f4bccb24b9d278d298203cf3326a9a92886a36..a1d64306213e7343220bc9ae01fa1e7de229bc00 100644
--- a/xroot_plugins/XrdProFilesystem.cpp
+++ b/xroot_plugins/XrdProFilesystem.cpp
@@ -343,7 +343,7 @@ int XrdProFilesystem::executeChdirclassCommand(const ParsedRequest &req, XrdOucE
return SFS_DATA;
}
try {
- m_userApi.setDirectoryStorageClass(requester, req.args.at(0), req.args.at(1));
+ m_userApi.setDirStorageClass(requester, req.args.at(0), req.args.at(1));
std::ostringstream responseSS;
responseSS << "[OK] Changed storage class of directory " << req.args.at(0) << " to " << req.args.at(1);
eInfo.setErrInfo(responseSS.str().length()+1, responseSS.str().c_str());
@@ -375,7 +375,7 @@ int XrdProFilesystem::executeCldirclassCommand(const ParsedRequest &req, XrdOucE
return SFS_DATA;
}
try {
- m_userApi.clearDirectoryStorageClass(requester, req.args.at(0));
+ m_userApi.clearDirStorageClass(requester, req.args.at(0));
std::ostringstream responseSS;
responseSS << "[OK] Cleared storage class of directory " << req.args.at(0);
eInfo.setErrInfo(responseSS.str().length()+1, responseSS.str().c_str());
@@ -407,7 +407,7 @@ int XrdProFilesystem::executeGetdirclassCommand(const ParsedRequest &req, XrdOuc
return SFS_DATA;
}
try {
- std::string stgClass = m_userApi.getDirectoryStorageClass(requester, req.args.at(0));
+ std::string stgClass = m_userApi.getDirStorageClass(requester, req.args.at(0));
std::ostringstream responseSS;
if(stgClass.empty()) {
responseSS << "[OK] Directory " << req.args.at(0) << " does not have a storage class";
@@ -513,7 +513,7 @@ int XrdProFilesystem::executeMkdirCommand(const ParsedRequest &req, XrdOucErrInf
return SFS_DATA;
}
try {
- m_userApi.createDirectory(requester, req.args.at(0));
+ m_userApi.createDir(requester, req.args.at(0));
std::ostringstream responseSS;
responseSS << "[OK] Directory " << req.args.at(0) << " created";
eInfo.setErrInfo(responseSS.str().length()+1, responseSS.str().c_str());
@@ -545,7 +545,7 @@ int XrdProFilesystem::executeRmdirCommand(const ParsedRequest &req, XrdOucErrInf
return SFS_DATA;
}
try {
- m_userApi.deleteDirectory(requester, req.args.at(0));
+ m_userApi.deleteDir(requester, req.args.at(0));
std::ostringstream responseSS;
responseSS << "[OK] Directory " << req.args.at(0) << " removed";
eInfo.setErrInfo(responseSS.str().length()+1, responseSS.str().c_str());
@@ -578,12 +578,12 @@ int XrdProFilesystem::executeLsCommand(const ParsedRequest &req, XrdOucErrInfo &
}
try {
std::ostringstream responseSS;
- cta::DirectoryIterator itor = m_userApi.getDirectoryContents(requester, req.args.at(0));
+ cta::DirIterator itor = m_userApi.getDirContents(requester, req.args.at(0));
while(itor.hasMore()) {
- const cta::DirectoryEntry &entry = itor.next();
+ const cta::DirEntry &entry = itor.next();
responseSS << "\n";
- responseSS << ((entry.getType() == cta::DirectoryEntry::ENTRYTYPE_DIRECTORY) ? "d" : "-");
+ responseSS << ((entry.getType() == cta::DirEntry::ENTRYTYPE_DIRECTORY) ? "d" : "-");
responseSS << ((entry.getMode() & S_IRUSR) ? "r" : "-");
responseSS << ((entry.getMode() & S_IWUSR) ? "w" : "-");
responseSS << ((entry.getMode() & S_IXUSR) ? "x" : "-");