diff --git a/catalogue/Catalogue.hpp b/catalogue/Catalogue.hpp
index cd4995efbf6a64ccc3e79d90765b9907390432f3..bf9e48cef6ea570e53ed6dee64610a218dac03ce 100644
--- a/catalogue/Catalogue.hpp
+++ b/catalogue/Catalogue.hpp
@@ -58,6 +58,7 @@
 #include "common/dataStructures/UserIdentity.hpp"
 #include "common/dataStructures/VerifyInfo.hpp"
 #include "common/dataStructures/WriteTestResult.hpp"
+#include "TapeFileWritten.hpp"
 
 namespace cta {
 
@@ -212,15 +213,10 @@ public:
   /**
    * Notifies the catalogue that a file has been written to tape.
    *
-   * @param archiveRequest The request to archive the file.
-   * @param archiveFileId The identifier of the archive file.
-   * @param tapeFile The file written to tape.
+   * @param event The tape file written event.
    */
-  virtual void fileWrittenToTape(
-    const common::dataStructures::ArchiveRequest &archiveRequest,
-    const uint64_t archiveFileId,
-    const common::dataStructures::TapeFile &tapeFile) = 0;
-  
+  virtual void fileWrittenToTape(const TapeFileWritten &event) = 0;
+
   virtual common::dataStructures::TapeCopyToPoolMap getTapeCopyToPoolMap(const std::string &storageClass) const = 0;
 
   /**
diff --git a/catalogue/SqliteCatalogue.cpp b/catalogue/SqliteCatalogue.cpp
index 737fb8f5a0fcfd8f6feb674cdf8e4d276e460e03..e1e2ef1dd6a815aa576a060dfda8c2affe45f7d5 100644
--- a/catalogue/SqliteCatalogue.cpp
+++ b/catalogue/SqliteCatalogue.cpp
@@ -1706,13 +1706,10 @@ void SqliteCatalogue::setDriveStatus(const common::dataStructures::SecurityIdent
 //------------------------------------------------------------------------------
 // fileWrittenToTape
 //------------------------------------------------------------------------------
-void SqliteCatalogue::fileWrittenToTape(
-  const cta::common::dataStructures::ArchiveRequest &archiveRequest,
-  const uint64_t archiveFileId,
-  const cta::common::dataStructures::TapeFile &tapeFileLocation) {
+void SqliteCatalogue::fileWrittenToTape(const TapeFileWritten &event) {
   std::lock_guard<std::mutex> m_lock(m_mutex);
 
-  std::unique_ptr<common::dataStructures::ArchiveFile> file = getArchiveFile(archiveFileId);
+  std::unique_ptr<common::dataStructures::ArchiveFile> file = getArchiveFile(event.archiveFileId);
   // If the archive file exists
   if(NULL != file.get()) {
 
@@ -1807,7 +1804,7 @@ uint64_t SqliteCatalogue::getExpectedNbArchiveRoutes(const std::string &storageC
 // getArchiveMountPolicy
 //------------------------------------------------------------------------------
 cta::common::dataStructures::MountPolicy SqliteCatalogue::
-  getMountPolicyForAUser(const cta::common::dataStructures::UserIdentity &user) const {
+  getMountPolicyForAUser(const common::dataStructures::UserIdentity &user) const {
   const char *const sql =
     "SELECT "
       "MOUNT_POLICY.MOUNT_POLICY_NAME AS MOUNT_POLICY_NAME,"
diff --git a/catalogue/SqliteCatalogue.hpp b/catalogue/SqliteCatalogue.hpp
index da5cb5c08378df2aedd2390e4085fa4291a2eed0..8680c32662d3f70caf7fa6e418e03e4cb7a1c641 100644
--- a/catalogue/SqliteCatalogue.hpp
+++ b/catalogue/SqliteCatalogue.hpp
@@ -173,14 +173,9 @@ public:
   /**
    * Notifies the catalogue that a file has been written to tape.
    *
-   * @param archiveRequest The request to archive the file.
-   * @param archiveFileId The identifier of the archive file.
-   * @param tapeFile The file written to tape.
+   * @param event The tape file written event.
    */
-  virtual void fileWrittenToTape(
-    const common::dataStructures::ArchiveRequest &archiveRequest,
-    const uint64_t archiveFileId,
-    const common::dataStructures::TapeFile &tapeFile);
+  virtual void fileWrittenToTape(const TapeFileWritten &event);
 
   /**
    * Prepares the catalogue for a new archive file and returns the information
diff --git a/catalogue/SqliteCatalogueTest.cpp b/catalogue/SqliteCatalogueTest.cpp
index 816efa89e3a6c8d4c624e322686a0d445a395c29..5b1d9215fd498a9f1c0a98681a57b0ab383379e5 100644
--- a/catalogue/SqliteCatalogueTest.cpp
+++ b/catalogue/SqliteCatalogueTest.cpp
@@ -1219,6 +1219,8 @@ TEST_F(cta_catalogue_SqliteCatalogueTest, getArchiveFile) {
     ASSERT_EQ(file.drData.drGroup, frontFile.drData.drGroup);
     ASSERT_EQ(file.drData.drBlob, frontFile.drData.drBlob);
 
+    ASSERT_TRUE(file.tapeCopies.empty());
+
     ASSERT_TRUE(catalogue.getTapeFiles().empty());
   }
 
@@ -1239,8 +1241,124 @@ TEST_F(cta_catalogue_SqliteCatalogueTest, getArchiveFile) {
     ASSERT_EQ(file.drData.drGroup, retrievedFile->drData.drGroup);
     ASSERT_EQ(file.drData.drBlob, retrievedFile->drData.drBlob);
 
+    ASSERT_TRUE(file.tapeCopies.empty());
+
     ASSERT_TRUE(catalogue.getTapeFiles().empty());
   }
 }
 
+TEST_F(cta_catalogue_SqliteCatalogueTest, file1WrittenToTape) {
+  using namespace cta;
+
+  catalogue::TestingSqliteCatalogue catalogue;
+  const uint64_t archiveFileId = 1234;
+
+  ASSERT_TRUE(catalogue.getArchiveFiles("", "", "", "", "", "", "", "", "").empty());
+  ASSERT_TRUE(NULL == catalogue.getArchiveFile(archiveFileId).get());
+
+  const std::string storageClassName = "storage_class";
+  const uint64_t nbCopies = 2;
+  catalogue.createStorageClass(m_cliSI, storageClassName, nbCopies,
+    "create storage class");
+
+  common::dataStructures::ArchiveFile file;
+  file.archiveFileID = archiveFileId;
+  file.diskFileID = "EOS_file_ID";
+  file.fileSize = 1;
+  file.checksumType = "checksum_type";
+  file.checksumValue = "checksum_value";
+  file.storageClass = storageClassName;
+
+  file.diskInstance = "recovery_instance";
+  file.drData.drPath = "recovery_path";
+  file.drData.drOwner = "recovery_owner";
+  file.drData.drGroup = "recovery_group";
+  file.drData.drBlob = "recovery_blob";
+
+  catalogue.createArchiveFile(file);
+
+  {
+    std::list<common::dataStructures::ArchiveFile> files;
+    files = catalogue.getArchiveFiles("", "", "", "", "", "", "", "", "");
+    ASSERT_EQ(1, files.size());
+
+    const common::dataStructures::ArchiveFile frontFile = files.front();
+
+    ASSERT_EQ(file.archiveFileID, frontFile.archiveFileID);
+    ASSERT_EQ(file.diskFileID, frontFile.diskFileID);
+    ASSERT_EQ(file.fileSize, frontFile.fileSize);
+    ASSERT_EQ(file.checksumType, frontFile.checksumType);
+    ASSERT_EQ(file.checksumValue, frontFile.checksumValue);
+    ASSERT_EQ(file.storageClass, frontFile.storageClass);
+
+    ASSERT_EQ(file.diskInstance, frontFile.diskInstance);
+    ASSERT_EQ(file.drData.drPath, frontFile.drData.drPath);
+    ASSERT_EQ(file.drData.drOwner, frontFile.drData.drOwner);
+    ASSERT_EQ(file.drData.drGroup, frontFile.drData.drGroup);
+    ASSERT_EQ(file.drData.drBlob, frontFile.drData.drBlob);
+
+    ASSERT_TRUE(file.tapeCopies.empty());
+
+    ASSERT_TRUE(catalogue.getTapeFiles().empty());
+  }
+
+  {
+    std::unique_ptr<common::dataStructures::ArchiveFile> retrievedFile = catalogue.getArchiveFile(archiveFileId);
+    ASSERT_TRUE(NULL != retrievedFile.get());
+
+    ASSERT_EQ(file.archiveFileID, retrievedFile->archiveFileID);
+    ASSERT_EQ(file.diskFileID, retrievedFile->diskFileID);
+    ASSERT_EQ(file.fileSize, retrievedFile->fileSize);
+    ASSERT_EQ(file.checksumType, retrievedFile->checksumType);
+    ASSERT_EQ(file.checksumValue, retrievedFile->checksumValue);
+    ASSERT_EQ(file.storageClass, retrievedFile->storageClass);
+
+    ASSERT_EQ(file.diskInstance, retrievedFile->diskInstance);
+    ASSERT_EQ(file.drData.drPath, retrievedFile->drData.drPath);
+    ASSERT_EQ(file.drData.drOwner, retrievedFile->drData.drOwner);
+    ASSERT_EQ(file.drData.drGroup, retrievedFile->drData.drGroup);
+    ASSERT_EQ(file.drData.drBlob, retrievedFile->drData.drBlob);
+
+    ASSERT_TRUE(file.tapeCopies.empty());
+
+    ASSERT_TRUE(catalogue.getTapeFiles().empty());
+  }
+
+  catalogue::TapeFileWritten file1Written;
+  file1Written.archiveFileId        = file.archiveFileID;
+  file1Written.diskInstance         = "PUBLIC";
+  file1Written.diskFileId           = "5678";
+  file1Written.diskFilePath         = "/public_dir/public_file";
+  file1Written.diskFileUser         = "public_disk_user";
+  file1Written.diskFileGroup        = "public_disk_group";
+  file1Written.diskFileRecoveryBlob = "opaque_disk_file_recovery_contents";
+  file1Written.size                 = file.fileSize;
+  file1Written.checksum             = Checksum(std::string("adler32:0X") + file.checksumValue);
+  file1Written.storageClassName     = file.storageClass;
+  file1Written.vid                  = "VID123";
+  file1Written.fSeq                 = 1;
+  file1Written.blockId              = 4321;
+  file1Written.compressedSize       = 1;
+  file1Written.copyNb               = 1;
+  catalogue.fileWrittenToTape(file1Written);
+
+  catalogue::TapeFileWritten file2Written;
+  file2Written.archiveFileId        = file.archiveFileID;
+  file2Written.diskInstance         = "PUBLIC";
+  file2Written.diskFileId           = "5678";
+  file2Written.diskFilePath         = "/public_dir/public_file";
+  file2Written.diskFileUser         = "public_disk_user";
+  file2Written.diskFileGroup        = "public_disk_group";
+  file2Written.diskFileRecoveryBlob = "opaque_disk_file_recovery_contents";
+  file2Written.size                 = file.fileSize;
+  file2Written.checksum             = Checksum(std::string("adler32:0X") + file.checksumValue);
+  file2Written.storageClassName     = file.storageClass;
+  file2Written.vid                  = "VID123";
+  file2Written.fSeq                 = 1;
+  file2Written.blockId              = 4321;
+  file2Written.compressedSize       = 1;
+  file2Written.copyNb               =2 ;
+  catalogue.fileWrittenToTape(file2Written);
+}
+
 } // namespace unitTests
diff --git a/catalogue/TapeFileWritten.hpp b/catalogue/TapeFileWritten.hpp
index 3d0e13db8e25374deb3df26bba981e75332c3a51..8d52bb686b46972cfa20bee17a5c291a34597f1c 100644
--- a/catalogue/TapeFileWritten.hpp
+++ b/catalogue/TapeFileWritten.hpp
@@ -91,7 +91,7 @@ struct TapeFileWritten {
   uint64_t size;
 
   /**
-   * The checksum of the tape file.
+   * Checksum of the tape file contents.
    */
   Checksum checksum;
 
diff --git a/common/UserIdentity.hpp b/common/UserIdentity.hpp
index be100e09671ad4403d55629b8ac0569ff4bc2b49..fae4e09de3a46dd72128827202349f4251c7c9ce 100644
--- a/common/UserIdentity.hpp
+++ b/common/UserIdentity.hpp
@@ -18,13 +18,14 @@
 
 #pragma once
 
+#include <ostream>
 #include <stdint.h>
 #include <string>
 
 namespace cta {
 
 /**
- * Class reprsenting the identity of a user.
+ * Class representing the identity of a user.
  */
 struct UserIdentity {
 
diff --git a/common/checksum/Checksum.hpp b/common/checksum/Checksum.hpp
index d618a8537f95876ffe41879fdf59d97307750227..d881a2b588af120797cf6b695511137a156e51a7 100644
--- a/common/checksum/Checksum.hpp
+++ b/common/checksum/Checksum.hpp
@@ -103,6 +103,8 @@ public:
    * Returns the checksum as a byte array that can be used for storing in a
    * database.
    *
+   * The bytes of the bytes array are in little-endian order.
+   *
    * @return The checksum as a byte array that can be used for storing in a
    * database.
    */
diff --git a/common/dataStructures/UserIdentity.cpp b/common/dataStructures/UserIdentity.cpp
index a939c4643cb89bb4c456df788192cdccb2a4b292..bafdfd0296bb736705e09108fb8014c40e4c8d5c 100644
--- a/common/dataStructures/UserIdentity.cpp
+++ b/common/dataStructures/UserIdentity.cpp
@@ -20,32 +20,39 @@
 #include "common/dataStructures/utils.hpp"
 #include "common/exception/Exception.hpp"
 
+namespace cta {
+namespace common {
+namespace dataStructures {
+
 //------------------------------------------------------------------------------
 // constructor
 //------------------------------------------------------------------------------
-cta::common::dataStructures::UserIdentity::UserIdentity() {}
+UserIdentity::UserIdentity() {}
 
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::UserIdentity::operator==(const UserIdentity &rhs) const {
-  return name==rhs.name
-      && group==rhs.group;
+bool UserIdentity::operator==(const UserIdentity &rhs) const {
+  return name==rhs.name && group==rhs.group;
 }
 
 //------------------------------------------------------------------------------
 // operator!=
 //------------------------------------------------------------------------------
-bool cta::common::dataStructures::UserIdentity::operator!=(const UserIdentity &rhs) const {
+bool UserIdentity::operator!=(const UserIdentity &rhs) const {
   return !operator==(rhs);
 }
 
 //------------------------------------------------------------------------------
 // operator<<
 //------------------------------------------------------------------------------
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UserIdentity &obj) {
+std::ostream &operator<<(std::ostream &os, const UserIdentity &obj) {
   os << "(name=" << obj.name
-     << " group=" << obj.group << ")";
+  << " group=" << obj.group << ")";
   return os;
 }
 
+} // namespace dataStructures
+} // namespace common
+} // namespace cta
+
diff --git a/common/dataStructures/UserIdentity.hpp b/common/dataStructures/UserIdentity.hpp
index 27c872f081b78f6d6c74370e622e40b334b30c46..12e831a47ff03ce5aee002aea8cdab67bfb2afff 100644
--- a/common/dataStructures/UserIdentity.hpp
+++ b/common/dataStructures/UserIdentity.hpp
@@ -18,9 +18,7 @@
 
 #pragma once
 
-#include <list>
-#include <map>
-#include <stdint.h>
+#include <ostream>
 #include <string>
 
 
@@ -44,8 +42,8 @@ struct UserIdentity {
 
 }; // struct UserIdentity
 
+std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UserIdentity &obj);
+
 } // namespace dataStructures
 } // namespace common
 } // namespace cta
-
-std::ostream &operator<<(std::ostream &os, const cta::common::dataStructures::UserIdentity &obj);
diff --git a/common/utils/utils.cpp b/common/utils/utils.cpp
index dbaa8f6dc82fed438701372ecd053bd62e55a9ca..23c0fe502db62462d81d77be523d227eb4b191c0 100644
--- a/common/utils/utils.cpp
+++ b/common/utils/utils.cpp
@@ -98,10 +98,13 @@ static void assertPathContainsValidChars(const std::string &path) {
 //  }
 //}
 
+namespace cta {
+namespace utils {
+
 //------------------------------------------------------------------------------
 // assertAbsolutePathSyntax
 //------------------------------------------------------------------------------
-void cta::utils::assertAbsolutePathSyntax(const std::string &path) {
+void assertAbsolutePathSyntax(const std::string &path) {
   try {
     assertPathStartsWithASlash(path);
     assertPathContainsValidChars(path);
@@ -117,7 +120,7 @@ void cta::utils::assertAbsolutePathSyntax(const std::string &path) {
 //------------------------------------------------------------------------------
 // getEnclosingPath
 //------------------------------------------------------------------------------
-std::string cta::utils::getEnclosingPath(const std::string &path) {
+std::string getEnclosingPath(const std::string &path) {
   if(path == "/") {
     throw Exception("Root directory does not have a parent");
   }
@@ -132,7 +135,7 @@ std::string cta::utils::getEnclosingPath(const std::string &path) {
 //------------------------------------------------------------------------------
 // getEnclosedName
 //------------------------------------------------------------------------------
-std::string cta::utils::getEnclosedName(const std::string &path) {
+std::string getEnclosedName(const std::string &path) {
   const std::string::size_type last_slash_idx = path.find_last_of('/');
   if(std::string::npos == last_slash_idx) {
     return path;
@@ -148,7 +151,7 @@ std::string cta::utils::getEnclosedName(const std::string &path) {
 //-----------------------------------------------------------------------------
 // getEnclosedNames
 //-----------------------------------------------------------------------------
-std::list<std::string> cta::utils::getEnclosedNames(
+std::list<std::string> getEnclosedNames(
   const std::list<std::string> &paths) {
   std::list<std::string> names;
 
@@ -163,7 +166,7 @@ std::list<std::string> cta::utils::getEnclosedNames(
 //-----------------------------------------------------------------------------
 // trimSlashes
 //-----------------------------------------------------------------------------
-std::string cta::utils::trimSlashes(const std::string &s) {
+std::string trimSlashes(const std::string &s) {
   // Find first non slash character
   size_t beginpos = s.find_first_not_of("/");
   std::string::const_iterator it1;
@@ -188,7 +191,7 @@ std::string cta::utils::trimSlashes(const std::string &s) {
 //-----------------------------------------------------------------------------
 // trimFinalSlashes
 //-----------------------------------------------------------------------------
-std::string cta::utils::trimFinalSlashes(const std::string &s) {
+std::string trimFinalSlashes(const std::string &s) {
   // Find last non slash chararacter
   std::string::const_iterator it2;
   size_t endpos = s.find_last_not_of("/");
@@ -204,7 +207,7 @@ std::string cta::utils::trimFinalSlashes(const std::string &s) {
 //-----------------------------------------------------------------------------
 // splitString
 //-----------------------------------------------------------------------------
-void cta::utils::splitString(const std::string &str, const char separator,
+void splitString(const std::string &str, const char separator,
   std::vector<std::string> &result) {
 
   if(str.empty()) {
@@ -230,7 +233,7 @@ void cta::utils::splitString(const std::string &str, const char separator,
 //-----------------------------------------------------------------------------
 // trimString
 //-----------------------------------------------------------------------------
-std::string cta::utils::trimString(const std::string &s) throw() {
+std::string trimString(const std::string &s) throw() {
   const std::string& spaces="\t\n\v\f\r ";
 
   // Find first non white character
@@ -257,7 +260,7 @@ std::string cta::utils::trimString(const std::string &s) throw() {
 //------------------------------------------------------------------------------
 // singleSpaceString
 //------------------------------------------------------------------------------
-std::string cta::utils::singleSpaceString(const std::string &str) throw() {
+std::string singleSpaceString(const std::string &str) throw() {
   bool inWhitespace = false;
   bool strContainsNonWhiteSpace = false;
 
@@ -309,7 +312,7 @@ std::string cta::utils::singleSpaceString(const std::string &str) throw() {
 //-----------------------------------------------------------------------------
 // generateUuid
 //-----------------------------------------------------------------------------
-std::string cta::utils::generateUuid() {
+std::string generateUuid() {
   uuid_t uuid;
   char str[36 + 1];
 
@@ -322,7 +325,7 @@ std::string cta::utils::generateUuid() {
 //-----------------------------------------------------------------------------
 // endsWith
 //-----------------------------------------------------------------------------
-bool cta::utils::endsWith(const std::string &str, const char c) {
+bool endsWith(const std::string &str, const char c) {
   if(str.empty()) {
     return false;
   } else {
@@ -333,7 +336,7 @@ bool cta::utils::endsWith(const std::string &str, const char c) {
 //------------------------------------------------------------------------------
 // setXattr
 //------------------------------------------------------------------------------
-void cta::utils::setXattr(const std::string &path, const std::string &name,
+void setXattr(const std::string &path, const std::string &name,
   const std::string &value) {
   if(setxattr(path.c_str(), name.c_str(), value.c_str(), value.length(), 0)) {
     const int savedErrno = errno;
@@ -347,7 +350,7 @@ void cta::utils::setXattr(const std::string &path, const std::string &name,
 //------------------------------------------------------------------------------
 // getXattr
 //------------------------------------------------------------------------------
-std::string cta::utils::getXattr(const std::string &path,
+std::string getXattr(const std::string &path,
   const std::string &name) {
   const auto sizeOfValue = getxattr(path.c_str(), name.c_str(), NULL, 0);
   if(0 > sizeOfValue) {
@@ -380,7 +383,7 @@ std::string cta::utils::getXattr(const std::string &path,
 //------------------------------------------------------------------------------
 // errnoToString
 //------------------------------------------------------------------------------
-std::string cta::utils::errnoToString(const int errnoValue) throw() {
+std::string errnoToString(const int errnoValue) throw() {
   char buf[100];
 
   if(!strerror_r_wrapper(errnoValue, buf, sizeof(buf))) {
@@ -414,7 +417,7 @@ std::string cta::utils::errnoToString(const int errnoValue) throw() {
 //------------------------------------------------------------------------------
 // toUint16
 //------------------------------------------------------------------------------
-uint16_t cta::utils::toUint16(const std::string &str) {
+uint16_t toUint16(const std::string &str) {
   if(str.empty()) {
     std::ostringstream msg;
     msg << "Failed to convert empty string to uint16_t: An empty string is not"
@@ -450,7 +453,7 @@ uint16_t cta::utils::toUint16(const std::string &str) {
 //------------------------------------------------------------------------------
 // toUid
 //------------------------------------------------------------------------------
-uid_t cta::utils::toUid(const std::string &str) {
+uid_t toUid(const std::string &str) {
   if(str.empty()) {
     std::ostringstream msg;
     msg << "Failed to convert empty string to uid_t: An empty string is not"
@@ -486,7 +489,7 @@ uid_t cta::utils::toUid(const std::string &str) {
 //------------------------------------------------------------------------------
 // toGid
 //------------------------------------------------------------------------------
-gid_t cta::utils::toGid(const std::string &str) {
+gid_t toGid(const std::string &str) {
   if(str.empty()) {
     std::ostringstream msg;
     msg << "Failed to convert empty string to gid_t: An empty string is not"
@@ -522,7 +525,7 @@ gid_t cta::utils::toGid(const std::string &str) {
 //------------------------------------------------------------------------------
 // isValidUInt
 //------------------------------------------------------------------------------
-bool cta::utils::isValidUInt(const std::string &str)
+bool isValidUInt(const std::string &str)
   throw() {
   // An empty string is not a valid unsigned integer
   if(str.empty()) {
@@ -542,10 +545,19 @@ bool cta::utils::isValidUInt(const std::string &str)
   return true;
 }
 
+//------------------------------------------------------------------------------
+// toUpper
+//------------------------------------------------------------------------------
+void toUpper(std::string &str) {
+  for(std::string::iterator itor=str.begin(); itor!=str.end(); itor++) {
+    *itor = toupper(*itor);
+  }
+}
+
 //------------------------------------------------------------------------------
 // getAdler32
 //------------------------------------------------------------------------------
-uint32_t cta::utils::getAdler32(const uint8_t *buf, const uint32_t len)
+uint32_t getAdler32(const uint8_t *buf, const uint32_t len)
   throw() {
   const uint32_t checksum = adler32(0L, Z_NULL, 0);
   return adler32(checksum, (const Bytef*)buf, len);
@@ -554,7 +566,7 @@ uint32_t cta::utils::getAdler32(const uint8_t *buf, const uint32_t len)
 //------------------------------------------------------------------------------
 // getShortHostname
 //------------------------------------------------------------------------------
-std::string cta::utils::getShortHostname() {
+std::string getShortHostname() {
   struct utsname un;
   exception::Errnum::throwOnMinusOne(uname (&un));
   std::vector<std::string> snn;
@@ -565,7 +577,7 @@ std::string cta::utils::getShortHostname() {
 //------------------------------------------------------------------------------
 // getDumpableProcessAttribute
 //------------------------------------------------------------------------------
-bool cta::utils::getDumpableProcessAttribute() {
+bool getDumpableProcessAttribute() {
   const int rc = prctl(PR_GET_DUMPABLE);
   switch(rc) {
   case -1:
@@ -593,7 +605,7 @@ bool cta::utils::getDumpableProcessAttribute() {
 //------------------------------------------------------------------------------
 // setDumpableProcessAttribute
 //------------------------------------------------------------------------------
- void cta::utils::setDumpableProcessAttribute(const bool dumpable) {
+void setDumpableProcessAttribute(const bool dumpable) {
   const int rc = prctl(PR_SET_DUMPABLE, dumpable ? 1 : 0);
   switch(rc) {
   case -1:
@@ -615,3 +627,6 @@ bool cta::utils::getDumpableProcessAttribute() {
     }
   }
 }
+
+} // namespace utils
+} // namespace cta
diff --git a/common/utils/utils.hpp b/common/utils/utils.hpp
index 4d6eb3b9d42d796becf9d387c1b0df9b62311897..9fa197023997cb356b14834f1b7681a9b192bacb 100644
--- a/common/utils/utils.hpp
+++ b/common/utils/utils.hpp
@@ -211,7 +211,14 @@ namespace utils {
    * @returns true if the string is a valid unsigned integer, else false.
    */
   bool isValidUInt(const std::string &str) throw();
-  
+
+  /**
+   * Converts the specified string to uppercase.
+   *
+   * @param In/out parameter: The string to be converted.
+   */
+  void toUpper(std::string &str);
+
   /**
    * Gets the short host name from the system
    *