diff --git a/catalogue/Catalogue.hpp b/catalogue/Catalogue.hpp
index 9a5e844b5fd464da9ed747e142179d8025b1eb83..50a57f44315f3bb38da3305f0080f72ede56214e 100644
--- a/catalogue/Catalogue.hpp
+++ b/catalogue/Catalogue.hpp
@@ -70,6 +70,7 @@
 #include "common/optional.hpp"
 #include "disk/DiskSystem.hpp"
 #include "RecyleTapeFileSearchCriteria.hpp"
+#include "CreateMountPolicyAttributes.hpp"
 
 #include <list>
 #include <map>
@@ -656,15 +657,7 @@ public:
   virtual void modifyRequesterGroupMountRulePolicy(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterGroupName, const std::string &mountPolicy) = 0;
   virtual void modifyRequesterGroupMountRuleComment(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterGroupName, const std::string &comment) = 0;
 
-   virtual void createMountPolicy(
-    const common::dataStructures::SecurityIdentity &admin,
-    const std::string &name, 
-    const uint64_t archivePriority, 
-    const uint64_t minArchiveRequestAge, 
-    const uint64_t retrievePriority, 
-    const uint64_t minRetrieveRequestAge, 
-    const uint64_t maxDrivesAllowed, 
-    const std::string &comment) = 0;
+   virtual void createMountPolicy(const common::dataStructures::SecurityIdentity &admin, const CreateMountPolicyAttributes & mountPolicy) = 0;
 
   /**
    * Returns the list of all existing mount policies.
diff --git a/catalogue/CatalogueRetryWrapper.hpp b/catalogue/CatalogueRetryWrapper.hpp
index cd07bd8b2194f7f5d2879ac54cff70a419057d58..95ee77155e7adf340a98c9fc2e2ca85331f9f68e 100644
--- a/catalogue/CatalogueRetryWrapper.hpp
+++ b/catalogue/CatalogueRetryWrapper.hpp
@@ -396,8 +396,8 @@ public:
     return retryOnLostConnection(m_log, [&]{return m_catalogue->modifyRequesterGroupMountRuleComment(admin, instanceName, requesterGroupName, comment);}, m_maxTriesToConnect);
   }
 
-  void createMountPolicy(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t archivePriority, const uint64_t minArchiveRequestAge, const uint64_t retrievePriority, const uint64_t minRetrieveRequestAge, const uint64_t maxDrivesAllowed, const std::string &comment) override {
-    return retryOnLostConnection(m_log, [&]{return m_catalogue->createMountPolicy(admin, name, archivePriority, minArchiveRequestAge, retrievePriority, minRetrieveRequestAge, maxDrivesAllowed, comment);}, m_maxTriesToConnect);
+  void createMountPolicy(const common::dataStructures::SecurityIdentity &admin, const CreateMountPolicyAttributes & mountPolicy) override {
+    return retryOnLostConnection(m_log, [&]{return m_catalogue->createMountPolicy(admin, mountPolicy);}, m_maxTriesToConnect);
   }
 
   std::list<common::dataStructures::MountPolicy> getMountPolicies() const override {
diff --git a/catalogue/CatalogueTest.cpp b/catalogue/CatalogueTest.cpp
index a44b8fe29d44bfab86f7ff9786ce80f9e9679013..75aedb37207627c9969680963a7337dbb60b2704 100644
--- a/catalogue/CatalogueTest.cpp
+++ b/catalogue/CatalogueTest.cpp
@@ -140,6 +140,21 @@ namespace {
     tape.comment = "Creation of tape two";
     return tape;
   }
+  
+  cta::catalogue::CreateMountPolicyAttributes getMountPolicy1() {
+    using namespace cta;
+    
+    catalogue::CreateMountPolicyAttributes mountPolicy;
+    mountPolicy.name = "mount_policy";
+    mountPolicy.archivePriority = 1;
+    mountPolicy.minArchiveRequestAge = 2;
+    mountPolicy.retrievePriority = 3;
+    mountPolicy.minRetrieveRequestAge = 4;
+    mountPolicy.maxDrivesAllowed = 5;
+    mountPolicy.maxDrivesAllowedPerVo = 6;
+    mountPolicy.comment = "Create mount policy";
+    return mountPolicy;
+  }
 }
 
 //------------------------------------------------------------------------------
@@ -6408,24 +6423,10 @@ TEST_P(cta_catalogue_CatalogueTest, createMountPolicy) {
   using namespace cta;
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
-
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
+  
+  catalogue::CreateMountPolicyAttributes mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin, mountPolicyToAdd);
 
   const std::list<common::dataStructures::MountPolicy> mountPolicies =
     m_catalogue->getMountPolicies();
@@ -6434,17 +6435,19 @@ TEST_P(cta_catalogue_CatalogueTest, createMountPolicy) {
 
   const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-  ASSERT_EQ(name, mountPolicy.name);
+  ASSERT_EQ(mountPolicyName, mountPolicy.name);
 
-  ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-  ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
+  ASSERT_EQ(mountPolicyToAdd.archivePriority, mountPolicy.archivePriority);
+  ASSERT_EQ(mountPolicyToAdd.minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
 
-  ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-  ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
+  ASSERT_EQ(mountPolicyToAdd.retrievePriority, mountPolicy.retrievePriority);
+  ASSERT_EQ(mountPolicyToAdd.minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
 
-  ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
+  ASSERT_EQ(mountPolicyToAdd.maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
+  
+  ASSERT_EQ(mountPolicyToAdd.maxDrivesAllowedPerVo,mountPolicy.maxDrivesAllowedPerVo);
 
-  ASSERT_EQ(comment, mountPolicy.comment);
+  ASSERT_EQ(mountPolicyToAdd.comment, mountPolicy.comment);
 
   const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
   ASSERT_EQ(m_admin.username, creationLog.username);
@@ -6460,33 +6463,11 @@ TEST_P(cta_catalogue_CatalogueTest, createMountPolicy_same_twice) {
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
-
-  ASSERT_THROW(m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment), exception::UserError);
+  auto mountPolicy = getMountPolicy1();
+
+  m_catalogue->createMountPolicy(m_admin,mountPolicy);
+
+  ASSERT_THROW(m_catalogue->createMountPolicy(m_admin, mountPolicy),cta::exception::UserError);
 }
 
 TEST_P(cta_catalogue_CatalogueTest, deleteMountPolicy) {
@@ -6494,50 +6475,15 @@ TEST_P(cta_catalogue_CatalogueTest, deleteMountPolicy) {
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
 
   ASSERT_EQ(1, mountPolicies.size());
 
-  const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-  ASSERT_EQ(name, mountPolicy.name);
-
-  ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-  ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-  ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-  ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-  ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-  ASSERT_EQ(comment, mountPolicy.comment);
-
-  const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-  ASSERT_EQ(m_admin.username, creationLog.username);
-  ASSERT_EQ(m_admin.host, creationLog.host);
-
-  const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-  ASSERT_EQ(creationLog, lastModificationLog);
-
-  m_catalogue->deleteMountPolicy(name);
+  m_catalogue->deleteMountPolicy(mountPolicyName);
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 }
@@ -6554,52 +6500,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyArchivePriority) {
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
-
-  {
-    const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
-    ASSERT_EQ(1, mountPolicies.size());
-
-    const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
-
-  const uint64_t modifiedArchivePriority = archivePriority + 10;
-  m_catalogue->modifyMountPolicyArchivePriority(m_admin, name, modifiedArchivePriority);
+  auto mountPolicyToAdd = getMountPolicy1();
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
+  
+  const uint64_t modifiedArchivePriority = mountPolicyToAdd.archivePriority + 10;
+  m_catalogue->modifyMountPolicyArchivePriority(m_admin, mountPolicyToAdd.name, modifiedArchivePriority);
 
   {
     const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
@@ -6607,21 +6512,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyArchivePriority) {
 
     const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-    ASSERT_EQ(name, mountPolicy.name);
-
     ASSERT_EQ(modifiedArchivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
 
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
+    const common::dataStructures::EntryLog modificationLog = mountPolicy.lastModificationLog;
+    ASSERT_EQ(m_admin.username, modificationLog.username);
+    ASSERT_EQ(m_admin.host, modificationLog.host);
   }
 }
 
@@ -6640,53 +6535,13 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyArchiveMinRequestAge) {
   using namespace cta;
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
+  
+  auto mountPolicyToAdd = getMountPolicy1();
+  
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
-
-  {
-    const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
-    ASSERT_EQ(1, mountPolicies.size());
-
-    const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
-
-  const uint64_t modifiedMinArchiveRequestAge = minArchiveRequestAge + 10;
-  m_catalogue->modifyMountPolicyArchiveMinRequestAge(m_admin, name, modifiedMinArchiveRequestAge);
+  const uint64_t modifiedMinArchiveRequestAge = mountPolicyToAdd.minArchiveRequestAge + 10;
+  m_catalogue->modifyMountPolicyArchiveMinRequestAge(m_admin, mountPolicyToAdd.name, modifiedMinArchiveRequestAge);
 
   {
     const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
@@ -6694,21 +6549,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyArchiveMinRequestAge) {
 
     const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
     ASSERT_EQ(modifiedMinArchiveRequestAge, mountPolicy.archiveMinRequestAge);
 
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
+    const common::dataStructures::EntryLog modificationLog = mountPolicy.lastModificationLog;
+    ASSERT_EQ(m_admin.username, modificationLog.username);
+    ASSERT_EQ(m_admin.host, modificationLog.host);
   }
 }
 
@@ -6723,57 +6568,16 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyArchiveMinRequestAge_nonExi
   ASSERT_THROW(m_catalogue->modifyMountPolicyArchiveMinRequestAge(m_admin, name, minArchiveRequestAge), exception::UserError);
 }
 
-TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyRetreivePriority) {
+TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyRetrievePriority) {
   using namespace cta;
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
-
-  {
-    const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
-    ASSERT_EQ(1, mountPolicies.size());
-
-    const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
+  auto mountPolicyToAdd = getMountPolicy1();
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
-
-  const uint64_t modifiedRetrievePriority = retrievePriority + 10;
-  m_catalogue->modifyMountPolicyRetrievePriority(m_admin, name, modifiedRetrievePriority);
+  const uint64_t modifiedRetrievePriority = mountPolicyToAdd.retrievePriority + 10;
+  m_catalogue->modifyMountPolicyRetrievePriority(m_admin, mountPolicyToAdd.name, modifiedRetrievePriority);
 
   {
     const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
@@ -6781,21 +6585,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyRetreivePriority) {
 
     const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
     ASSERT_EQ(modifiedRetrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
+    
+    const common::dataStructures::EntryLog modificationLog = mountPolicy.lastModificationLog;
+    ASSERT_EQ(m_admin.username, modificationLog.username);
+    ASSERT_EQ(m_admin.host, modificationLog.host);
   }
 }
 
@@ -6815,52 +6609,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyRetrieveMinRequestAge) {
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
+  auto mountPolicyToAdd = getMountPolicy1();
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
-  {
-    const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
-    ASSERT_EQ(1, mountPolicies.size());
-
-    const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
-
-  const uint64_t modifiedMinRetrieveRequestAge = minRetrieveRequestAge + 10;
-  m_catalogue->modifyMountPolicyRetrieveMinRequestAge(m_admin, name, modifiedMinRetrieveRequestAge);
+  const uint64_t modifiedMinRetrieveRequestAge = mountPolicyToAdd.minRetrieveRequestAge + 10;
+  m_catalogue->modifyMountPolicyRetrieveMinRequestAge(m_admin, mountPolicyToAdd.name, modifiedMinRetrieveRequestAge);
 
   {
     const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
@@ -6868,21 +6621,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyRetrieveMinRequestAge) {
 
     const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
     ASSERT_EQ(modifiedMinRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
 
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
+    const common::dataStructures::EntryLog modificationLog = mountPolicy.lastModificationLog;
+    ASSERT_EQ(m_admin.username, modificationLog.username);
+    ASSERT_EQ(m_admin.host, modificationLog.host);
   }
 }
 
@@ -6902,52 +6645,12 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyMaxDrivesAllowed) {
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
-
-  {
-    const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
-    ASSERT_EQ(1, mountPolicies.size());
-
-    const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
-
-  const uint64_t modifiedMaxDrivesAllowed = maxDrivesAllowed + 10;
-  m_catalogue->modifyMountPolicyMaxDrivesAllowed(m_admin, name, modifiedMaxDrivesAllowed);
+  const uint64_t modifiedMaxDrivesAllowed = mountPolicyToAdd.maxDrivesAllowed + 10;
+  m_catalogue->modifyMountPolicyMaxDrivesAllowed(m_admin, mountPolicyName, modifiedMaxDrivesAllowed);
 
   {
     const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
@@ -6955,21 +6658,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyMaxDrivesAllowed) {
 
     const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
     ASSERT_EQ(modifiedMaxDrivesAllowed, mountPolicy.maxDrivesAllowed);
 
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
+    const common::dataStructures::EntryLog modificationLog = mountPolicy.lastModificationLog;
+    ASSERT_EQ(m_admin.username, modificationLog.username);
+    ASSERT_EQ(m_admin.host, modificationLog.host);
   }
 }
 
@@ -6989,52 +6682,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyComment) {
 
   ASSERT_TRUE(m_catalogue->getMountPolicies().empty());
 
-  const std::string name = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-  const std::string &comment = "Create mount policy";
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    name,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    comment);
-
-  {
-    const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
-    ASSERT_EQ(1, mountPolicies.size());
-
-    const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
-
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
-    ASSERT_EQ(comment, mountPolicy.comment);
-
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
-
-    const common::dataStructures::EntryLog lastModificationLog = mountPolicy.lastModificationLog;
-    ASSERT_EQ(creationLog, lastModificationLog);
-  }
+  auto mountPolicyToAdd = getMountPolicy1();
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string modifiedComment = "Modified comment";
-  m_catalogue->modifyMountPolicyComment(m_admin, name, modifiedComment);
+  m_catalogue->modifyMountPolicyComment(m_admin, mountPolicyToAdd.name, modifiedComment);
 
   {
     const std::list<common::dataStructures::MountPolicy> mountPolicies = m_catalogue->getMountPolicies();
@@ -7042,21 +6694,11 @@ TEST_P(cta_catalogue_CatalogueTest, modifyMountPolicyComment) {
 
     const common::dataStructures::MountPolicy mountPolicy = mountPolicies.front();
 
-    ASSERT_EQ(name, mountPolicy.name);
-
-    ASSERT_EQ(archivePriority, mountPolicy.archivePriority);
-    ASSERT_EQ(minArchiveRequestAge, mountPolicy.archiveMinRequestAge);
-
-    ASSERT_EQ(retrievePriority, mountPolicy.retrievePriority);
-    ASSERT_EQ(minRetrieveRequestAge, mountPolicy.retrieveMinRequestAge);
-
-    ASSERT_EQ(maxDrivesAllowed, mountPolicy.maxDrivesAllowed);
-
     ASSERT_EQ(modifiedComment, mountPolicy.comment);
 
-    const common::dataStructures::EntryLog creationLog = mountPolicy.creationLog;
-    ASSERT_EQ(m_admin.username, creationLog.username);
-    ASSERT_EQ(m_admin.host, creationLog.host);
+    const common::dataStructures::EntryLog modificationLog = mountPolicy.lastModificationLog;
+    ASSERT_EQ(m_admin.username, modificationLog.username);
+    ASSERT_EQ(m_admin.host, modificationLog.host);
   }
 }
 
@@ -7076,22 +6718,9 @@ TEST_P(cta_catalogue_CatalogueTest, createRequesterMountRule) {
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
@@ -7116,28 +6745,15 @@ TEST_P(cta_catalogue_CatalogueTest, createRequesterMountRule_same_twice) {
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
   const std::string requesterName = "requester_name";
   m_catalogue->createRequesterMountRule(m_admin, mountPolicyName, diskInstanceName, requesterName, comment);
-  ASSERT_THROW(m_catalogue->createRequesterMountRule(m_admin, mountPolicyName, diskInstanceName, requesterName,
+  ASSERT_THROW(m_catalogue->createRequesterMountRule(m_admin, mountPolicyToAdd.name, diskInstanceName, requesterName,
     comment), exception::UserError);
 }
 
@@ -7159,22 +6775,9 @@ TEST_P(cta_catalogue_CatalogueTest, deleteRequesterMountRule) {
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
@@ -7183,17 +6786,7 @@ TEST_P(cta_catalogue_CatalogueTest, deleteRequesterMountRule) {
 
   const std::list<common::dataStructures::RequesterMountRule> rules = m_catalogue->getRequesterMountRules();
   ASSERT_EQ(1, rules.size());
-
-  const common::dataStructures::RequesterMountRule rule = rules.front();
-
-  ASSERT_EQ(diskInstanceName, rule.diskInstance);
-  ASSERT_EQ(requesterName, rule.name);
-  ASSERT_EQ(mountPolicyName, rule.mountPolicy);
-  ASSERT_EQ(comment, rule.comment);
-  ASSERT_EQ(m_admin.username, rule.creationLog.username);
-  ASSERT_EQ(m_admin.host, rule.creationLog.host);
-  ASSERT_EQ(rule.creationLog, rule.lastModificationLog);
-
+  
   m_catalogue->deleteRequesterMountRule(diskInstanceName, requesterName);
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 }
@@ -7211,34 +6804,16 @@ TEST_P(cta_catalogue_CatalogueTest, modifyRequesterMountRulePolicy) {
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string anotherMountPolicyName = "another_mount_policy";
 
-  m_catalogue->createMountPolicy(
-    m_admin,
-    anotherMountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create another mount policy");
+  auto anotherMountPolicy = getMountPolicy1();
+  anotherMountPolicy.name = anotherMountPolicyName;
+  m_catalogue->createMountPolicy(m_admin,anotherMountPolicy);
+
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
@@ -7280,22 +6855,9 @@ TEST_P(cta_catalogue_CatalogueTest, modifyRequesterMountRulePolicy_nonExistentRe
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string diskInstanceName = "disk_instance";
   const std::string requesterName = "requester_name";
@@ -7309,22 +6871,9 @@ TEST_P(cta_catalogue_CatalogueTest, modifyRequesteMountRuleComment) {
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
@@ -7380,34 +6929,16 @@ TEST_P(cta_catalogue_CatalogueTest, modifyRequesterGroupMountRulePolicy) {
 
   ASSERT_TRUE(m_catalogue->getRequesterGroupMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  
   const std::string anotherMountPolicyName = "another_mount_policy";
 
-  m_catalogue->createMountPolicy(
-    m_admin,
-    anotherMountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create another mount policy");
+  auto anotherMountPolicy = getMountPolicy1();
+  anotherMountPolicy.name = anotherMountPolicyName;
+  m_catalogue->createMountPolicy(m_admin,anotherMountPolicy);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
@@ -7449,22 +6980,9 @@ TEST_P(cta_catalogue_CatalogueTest, modifyRequesterGroupMountRulePolicy_nonExist
 
   ASSERT_TRUE(m_catalogue->getRequesterGroupMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string diskInstanceName = "disk_instance";
   const std::string requesterGroupName = "requester_group_name";
@@ -7478,22 +6996,9 @@ TEST_P(cta_catalogue_CatalogueTest, modifyRequesterGroupMountRuleComment) {
 
   ASSERT_TRUE(m_catalogue->getRequesterGroupMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance";
@@ -7549,22 +7054,9 @@ TEST_P(cta_catalogue_CatalogueTest, createRequesterGroupMountRule) {
 
   ASSERT_TRUE(m_catalogue->getRequesterGroupMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester group";
   const std::string diskInstanceName = "disk_instance_name";
@@ -7590,22 +7082,9 @@ TEST_P(cta_catalogue_CatalogueTest, createRequesterGroupMountRule_same_twice) {
 
   ASSERT_TRUE(m_catalogue->getRequesterGroupMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester group";
   const std::string diskInstanceName = "disk_instance";
@@ -7633,22 +7112,9 @@ TEST_P(cta_catalogue_CatalogueTest, deleteRequesterGroupMountRule) {
 
   ASSERT_TRUE(m_catalogue->getRequesterGroupMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 4;
-  const uint64_t retrievePriority = 5;
-  const uint64_t minRetrieveRequestAge = 8;
-  const uint64_t maxDrivesAllowed = 9;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester group";
   const std::string diskInstanceName = "disk_instance";
@@ -7685,22 +7151,9 @@ TEST_P(cta_catalogue_CatalogueTest, checkAndGetNextArchiveFileId_no_archive_rout
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -7782,22 +7235,9 @@ TEST_P(cta_catalogue_CatalogueTest, checkAndGetNextArchiveFileId_after_cached_an
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -7872,22 +7312,9 @@ TEST_P(cta_catalogue_CatalogueTest, checkAndGetNextArchiveFileId_requester_mount
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -7956,22 +7383,9 @@ TEST_P(cta_catalogue_CatalogueTest, checkAndGetNextArchiveFileId_requester_group
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester group";
   const std::string diskInstanceName = "disk_instance";
@@ -8038,22 +7452,9 @@ TEST_P(cta_catalogue_CatalogueTest, checkAndGetNextArchiveFileId_after_cached_an
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester group";
   const std::string diskInstanceName = "disk_instance";
@@ -8127,22 +7528,9 @@ TEST_P(cta_catalogue_CatalogueTest, checkAndGetNextArchiveFileId_requester_mount
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string requesterRuleComment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -8228,22 +7616,9 @@ TEST_P(cta_catalogue_CatalogueTest, getArchiveFileQueueCriteria_no_archive_route
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -8278,22 +7653,9 @@ TEST_P(cta_catalogue_CatalogueTest, getArchiveFileQueueCriteria_requester_mount_
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -8354,22 +7716,9 @@ TEST_P(cta_catalogue_CatalogueTest, getArchiveFileQueueCriteria_requester_group_
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester group";
   const std::string diskInstanceName = "disk_instance";
@@ -8429,22 +7778,9 @@ TEST_P(cta_catalogue_CatalogueTest, getArchiveFileQueueCriteria_requester_mount_
 
   ASSERT_TRUE(m_catalogue->getRequesterMountRules().empty());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string requesterRuleComment = "Create mount rule for requester";
   const std::string diskInstanceName = "disk_instance_name";
@@ -8698,22 +8034,12 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId) {
     ASSERT_EQ(file2Written.checksumBlob, tapeFile2.checksumBlob);
   }
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  uint64_t minArchiveRequestAge = mountPolicyToAdd.minArchiveRequestAge;
+  uint64_t maxDrivesAllowed = mountPolicyToAdd.maxDrivesAllowed;
+  uint64_t archivePriority = mountPolicyToAdd.archivePriority;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string requesterName = "requester_name";
@@ -8935,22 +8261,12 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId_disa
     ASSERT_EQ(file2Written.checksumBlob, tapeFile2.checksumBlob);
   }
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  uint64_t minArchiveRequestAge = mountPolicyToAdd.minArchiveRequestAge;
+  uint64_t maxDrivesAllowed = mountPolicyToAdd.maxDrivesAllowed;
+  uint64_t archivePriority = mountPolicyToAdd.archivePriority;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string requesterName = "requester_name";
@@ -9104,22 +8420,12 @@ TEST_P(cta_catalogue_CatalogueTest, prepareToRetrieveFileUsingArchiveFileId_retu
   
   ASSERT_TRUE(m_catalogue->getFileRecycleLogItor().hasMore());
 
-  const std::string mountPolicyName = "mount_policy";
-  const uint64_t archivePriority = 1;
-  const uint64_t minArchiveRequestAge = 2;
-  const uint64_t retrievePriority = 3;
-  const uint64_t minRetrieveRequestAge = 4;
-  const uint64_t maxDrivesAllowed = 5;
-
-  m_catalogue->createMountPolicy(
-    m_admin,
-    mountPolicyName,
-    archivePriority,
-    minArchiveRequestAge,
-    retrievePriority,
-    minRetrieveRequestAge,
-    maxDrivesAllowed,
-    "Create mount policy");
+  auto mountPolicyToAdd = getMountPolicy1();
+  std::string mountPolicyName = mountPolicyToAdd.name;
+  uint64_t minArchiveRequestAge = mountPolicyToAdd.minArchiveRequestAge;
+  uint64_t maxDrivesAllowed = mountPolicyToAdd.maxDrivesAllowed;
+  uint64_t archivePriority = mountPolicyToAdd.archivePriority;
+  m_catalogue->createMountPolicy(m_admin,mountPolicyToAdd);
 
   const std::string comment = "Create mount rule for requester";
   const std::string requesterName = "requester_name";
diff --git a/catalogue/CreateMountPolicyAttributes.hpp b/catalogue/CreateMountPolicyAttributes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..30df6799b028fb58846dee1c4dbe0c64fc1071d0
--- /dev/null
+++ b/catalogue/CreateMountPolicyAttributes.hpp
@@ -0,0 +1,40 @@
+/*
+ * The CERN Tape Archive (CTA) project
+ * Copyright (C) 2019  CERN
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/optional.hpp"
+#include "common/dataStructures/Tape.hpp"
+
+#include <string>
+
+namespace cta {
+namespace catalogue {
+  
+  struct CreateMountPolicyAttributes {
+    std::string name;
+    uint64_t archivePriority;
+    uint64_t minArchiveRequestAge;
+    uint64_t retrievePriority;
+    uint64_t minRetrieveRequestAge;
+    uint64_t maxDrivesAllowed;
+    uint64_t maxDrivesAllowedPerVo;
+    std::string comment;
+  };
+  
+}}
\ No newline at end of file
diff --git a/catalogue/DummyCatalogue.hpp b/catalogue/DummyCatalogue.hpp
index a37a9052a58207eed5fbd465264a3ef165ef0b5f..445e168b916d5a52c7af72e9fad4462fa3992cb4 100644
--- a/catalogue/DummyCatalogue.hpp
+++ b/catalogue/DummyCatalogue.hpp
@@ -38,7 +38,7 @@ public:
   void createAdminUser(const common::dataStructures::SecurityIdentity& admin, const std::string& username, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createArchiveRoute(const common::dataStructures::SecurityIdentity& admin, const std::string& storageClassName, const uint32_t copyNb, const std::string& tapePoolName, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createLogicalLibrary(const common::dataStructures::SecurityIdentity& admin, const std::string& name, const bool isDisabled, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
-  void createMountPolicy(const common::dataStructures::SecurityIdentity& admin, const std::string& name, const uint64_t archivePriority, const uint64_t minArchiveRequestAge, const uint64_t retrievePriority, const uint64_t minRetrieveRequestAge, const uint64_t maxDrivesAllowed, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
+  void createMountPolicy(const common::dataStructures::SecurityIdentity& admin, const CreateMountPolicyAttributes & mountPolicy) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createRequesterGroupMountRule(const common::dataStructures::SecurityIdentity& admin, const std::string& mountPolicyName, const std::string& diskInstanceName, const std::string& requesterGroupName, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createRequesterMountRule(const common::dataStructures::SecurityIdentity& admin, const std::string& mountPolicyName, const std::string& diskInstance, const std::string& requesterName, const std::string& comment) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
   void createStorageClass(const common::dataStructures::SecurityIdentity& admin, const common::dataStructures::StorageClass& storageClass) override { throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented"); }
diff --git a/catalogue/RdbmsCatalogue.cpp b/catalogue/RdbmsCatalogue.cpp
index 4f5f00e2dfc9e40bd15921fd79bd311c153f57f8..41211e0858aacf3dfbcb81eae106b2c40e751ad3 100644
--- a/catalogue/RdbmsCatalogue.cpp
+++ b/catalogue/RdbmsCatalogue.cpp
@@ -4931,15 +4931,8 @@ void RdbmsCatalogue::modifyRequesterGroupMountRuleComment(const common::dataStru
 //------------------------------------------------------------------------------
 // createMountPolicy
 //------------------------------------------------------------------------------
-void RdbmsCatalogue::createMountPolicy(
-  const common::dataStructures::SecurityIdentity &admin,
-  const std::string &name,
-  const uint64_t archivePriority,
-  const uint64_t minArchiveRequestAge,
-  const uint64_t retrievePriority,
-  const uint64_t minRetrieveRequestAge,
-  const uint64_t maxDrivesAllowed,
-  const std::string &comment) {
+void RdbmsCatalogue::createMountPolicy(const common::dataStructures::SecurityIdentity &admin, const CreateMountPolicyAttributes & mountPolicy) {
+  std::string name = mountPolicy.name;
   try {
     auto conn = m_connPool.getConn();
     if(mountPolicyExists(conn, name)) {
@@ -4958,6 +4951,7 @@ void RdbmsCatalogue::createMountPolicy(
         "RETRIEVE_MIN_REQUEST_AGE,"
 
         "MAX_DRIVES_ALLOWED,"
+        "MAX_DRIVES_ALLOWED_PER_VO,"
 
         "USER_COMMENT,"
 
@@ -4978,6 +4972,7 @@ void RdbmsCatalogue::createMountPolicy(
         ":RETRIEVE_MIN_REQUEST_AGE,"
 
         ":MAX_DRIVES_ALLOWED,"
+        ":MAX_DRIVES_ALLOWED_PER_VO,"
 
         ":USER_COMMENT,"
 
@@ -4992,15 +4987,16 @@ void RdbmsCatalogue::createMountPolicy(
 
     stmt.bindString(":MOUNT_POLICY_NAME", name);
 
-    stmt.bindUint64(":ARCHIVE_PRIORITY", archivePriority);
-    stmt.bindUint64(":ARCHIVE_MIN_REQUEST_AGE", minArchiveRequestAge);
+    stmt.bindUint64(":ARCHIVE_PRIORITY", mountPolicy.archivePriority);
+    stmt.bindUint64(":ARCHIVE_MIN_REQUEST_AGE", mountPolicy.minArchiveRequestAge);
 
-    stmt.bindUint64(":RETRIEVE_PRIORITY", retrievePriority);
-    stmt.bindUint64(":RETRIEVE_MIN_REQUEST_AGE", minRetrieveRequestAge);
-
-    stmt.bindUint64(":MAX_DRIVES_ALLOWED", maxDrivesAllowed);
+    stmt.bindUint64(":RETRIEVE_PRIORITY", mountPolicy.retrievePriority);
+    stmt.bindUint64(":RETRIEVE_MIN_REQUEST_AGE", mountPolicy.minRetrieveRequestAge);
 
-    stmt.bindString(":USER_COMMENT", comment);
+    stmt.bindUint64(":MAX_DRIVES_ALLOWED", mountPolicy.maxDrivesAllowed);
+    stmt.bindUint64(":MAX_DRIVES_ALLOWED_PER_VO",mountPolicy.maxDrivesAllowedPerVo);
+    
+    stmt.bindString(":USER_COMMENT", mountPolicy.comment);
 
     stmt.bindString(":CREATION_LOG_USER_NAME", admin.username);
     stmt.bindString(":CREATION_LOG_HOST_NAME", admin.host);
@@ -5570,6 +5566,7 @@ optional<common::dataStructures::MountPolicy> RdbmsCatalogue::getRequesterMountP
       policy.retrieveMinRequestAge = rset.columnUint64("RETRIEVE_MIN_REQUEST_AGE");
 
       policy.maxDrivesAllowed = rset.columnUint64("MAX_DRIVES_ALLOWED");
+      policy.maxDrivesAllowedPerVo = rset.columnUint64("MAX_DRIVES_ALLOWED_PER_VO");
 
       policy.comment = rset.columnString("USER_COMMENT");
 
@@ -5680,6 +5677,7 @@ try {
         "RETRIEVE_MIN_REQUEST_AGE AS RETRIEVE_MIN_REQUEST_AGE,"
 
         "MAX_DRIVES_ALLOWED AS MAX_DRIVES_ALLOWED,"
+        "MAX_DRIVES_ALLOWED_PER_VO AS MAX_DRIVES_ALLOWED_PER_VO,"
 
         "USER_COMMENT AS USER_COMMENT,"
 
diff --git a/catalogue/RdbmsCatalogue.hpp b/catalogue/RdbmsCatalogue.hpp
index 849d98bea9817bd775a7cfb7dc4d081d9d2e5010..5b7308c26709c6189cce8f638385a1930629e8f4 100644
--- a/catalogue/RdbmsCatalogue.hpp
+++ b/catalogue/RdbmsCatalogue.hpp
@@ -609,15 +609,7 @@ public:
   void modifyRequesterGroupMountRulePolicy(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterGroupName, const std::string &mountPolicy) override;
   void modifyRequesterGroupMountRuleComment(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterGroupName, const std::string &comment) override;
 
-  void createMountPolicy(
-    const common::dataStructures::SecurityIdentity &admin,
-    const std::string &name,
-    const uint64_t archivePriority,
-    const uint64_t minArchiveRequestAge,
-    const uint64_t retrievePriority,
-    const uint64_t minRetrieveRequestAge,
-    const uint64_t maxDrivesAllowed,
-    const std::string &comment) override;
+  void createMountPolicy(const common::dataStructures::SecurityIdentity &admin, const CreateMountPolicyAttributes & mountPolicy) override;
 
   /**
    * Returns the list of all existing mount policies.
diff --git a/common/dataStructures/MountPolicy.cpp b/common/dataStructures/MountPolicy.cpp
index eaf612cf90a82ab66be4889597f2ee28e10d961a..6c82e6808d1f66642713d026a60e638cbb0ae3e1 100644
--- a/common/dataStructures/MountPolicy.cpp
+++ b/common/dataStructures/MountPolicy.cpp
@@ -33,12 +33,13 @@ MountPolicy::MountPolicy():
   archiveMinRequestAge(0),
   retrievePriority(0),
   retrieveMinRequestAge(0),
-  maxDrivesAllowed(0) {}
+  maxDrivesAllowed(0),
+  maxDrivesAllowedPerVo(0){}
 
 MountPolicy::MountPolicy(const std::string name, const uint64_t archivePriority,const uint64_t archiveMinRequestAge, const uint64_t retrievePriority, 
-        const uint64_t retrieveMinRequestAge, const uint64_t maxDrivesAllowed):
+        const uint64_t retrieveMinRequestAge, const uint64_t maxDrivesAllowed, const uint64_t maxDrivesAllowedPerVo):
         name(name), archivePriority(archivePriority), archiveMinRequestAge(archiveMinRequestAge), retrievePriority(retrievePriority), 
-        retrieveMinRequestAge(retrieveMinRequestAge), maxDrivesAllowed(maxDrivesAllowed) {}
+        retrieveMinRequestAge(retrieveMinRequestAge), maxDrivesAllowed(maxDrivesAllowed), maxDrivesAllowedPerVo(maxDrivesAllowedPerVo) {}
 //------------------------------------------------------------------------------
 // operator==
 //------------------------------------------------------------------------------
@@ -49,6 +50,7 @@ bool MountPolicy::operator==(const MountPolicy &rhs) const {
       && retrievePriority==rhs.retrievePriority
       && retrieveMinRequestAge==rhs.retrieveMinRequestAge
       && maxDrivesAllowed==rhs.maxDrivesAllowed
+      && maxDrivesAllowedPerVo==rhs.maxDrivesAllowedPerVo
       && creationLog==rhs.creationLog
       && lastModificationLog==rhs.lastModificationLog
       && comment==rhs.comment;
@@ -69,6 +71,7 @@ MountPolicy MountPolicy::operator=(const MountPolicy& other){
     this->creationLog = other.creationLog;
     this->lastModificationLog = other.lastModificationLog;
     this->maxDrivesAllowed = other.maxDrivesAllowed;
+    this->maxDrivesAllowedPerVo = other.maxDrivesAllowedPerVo;
     this->name = other.name;
     this->retrieveMinRequestAge = other.retrieveMinRequestAge;
     this->retrievePriority = other.retrievePriority;
@@ -85,13 +88,14 @@ std::ostream &operator<<(std::ostream &os, const MountPolicy &obj) {
      << " retrieve_priority=" << obj.retrievePriority
      << " retrieve_minRequestAge=" << obj.retrieveMinRequestAge
      << " maxDrivesAllowed=" << obj.maxDrivesAllowed
+     << " maxDrivesAllowedPerVo=" << obj.maxDrivesAllowedPerVo
      << " creationLog=" << obj.creationLog
      << " lastModificationLog=" << obj.lastModificationLog
      << " comment=" << obj.comment << ")";
   return os;
 }
 
-MountPolicy MountPolicy::s_defaultMountPolicyForRepack("default_mount_policy_repack",1,1,1,1,1);
+MountPolicy MountPolicy::s_defaultMountPolicyForRepack("default_mount_policy_repack",1,1,1,1,1,1);
 
 } // namespace dataStructures
 } // namespace common
diff --git a/common/dataStructures/MountPolicy.hpp b/common/dataStructures/MountPolicy.hpp
index b8e85b34578d9453ec047abde73f7747bfa4104d..29aee97c9848097c0dac7673bcf36d6055b7e593 100644
--- a/common/dataStructures/MountPolicy.hpp
+++ b/common/dataStructures/MountPolicy.hpp
@@ -48,6 +48,7 @@ struct MountPolicy {
   uint64_t retrievePriority;
   uint64_t retrieveMinRequestAge;
   uint64_t maxDrivesAllowed;
+  uint64_t maxDrivesAllowedPerVo;
   EntryLog creationLog;
   EntryLog lastModificationLog;
   std::string comment;
@@ -56,7 +57,7 @@ struct MountPolicy {
   static struct MountPolicy s_defaultMountPolicyForRepack;
   
 private:
-  MountPolicy(const std::string name,const uint64_t archivePriority,const uint64_t archiveMinRequestAge, const uint64_t retrievePriority, const uint64_t retrieveMinRequestAge, const uint64_t maxDrivesAllowed);
+  MountPolicy(const std::string name,const uint64_t archivePriority,const uint64_t archiveMinRequestAge, const uint64_t retrievePriority, const uint64_t retrieveMinRequestAge, const uint64_t maxDrivesAllowed, const uint64_t maxDrivesAllowedPerVo);
 
 }; // struct MountPolicy
 
diff --git a/objectstore/MountPolicySerDeser.hpp b/objectstore/MountPolicySerDeser.hpp
index f64950c60294f52faf17be7672f5de2b7e85181d..51e705d5af9a6fa4b55dd77a90fdb9bd0fd308f6 100644
--- a/objectstore/MountPolicySerDeser.hpp
+++ b/objectstore/MountPolicySerDeser.hpp
@@ -43,6 +43,7 @@ public:
     osmp.set_retrievepriority(retrievePriority);
     osmp.set_retieveminrequestage(retrieveMinRequestAge);
     osmp.set_maxdrivesallowed(maxDrivesAllowed);
+    osmp.set_max_drives_allowed_per_vo(maxDrivesAllowedPerVo);
     EntryLogSerDeser(creationLog).serialize(*osmp.mutable_creationlog());
     EntryLogSerDeser(lastModificationLog).serialize(*osmp.mutable_lastmodificationlog());
     osmp.set_comment(comment);
@@ -54,6 +55,7 @@ public:
     retrievePriority=osmp.retrievepriority();
     retrieveMinRequestAge=osmp.retieveminrequestage();
     maxDrivesAllowed=osmp.maxdrivesallowed();
+    maxDrivesAllowedPerVo=osmp.max_drives_allowed_per_vo();
     EntryLogSerDeser el;
     el.deserialize(osmp.creationlog());
     creationLog=el;
diff --git a/objectstore/cta.proto b/objectstore/cta.proto
index e7e0f65ca0717d6792f5f2ca3bc9e86df1fff194..482e2376acd0c7a7cfdade7b9a4fdc233f1cb002 100644
--- a/objectstore/cta.proto
+++ b/objectstore/cta.proto
@@ -300,6 +300,7 @@ message MountPolicy {
   required EntryLog creationlog = 8986;
   required EntryLog lastmodificationlog = 8987;
   required string comment = 8988;
+  optional uint64 max_drives_allowed_per_vo = 8989;
 }
 
 // ------------- Archive Jobs --------------------------------------------------
diff --git a/scheduler/SchedulerTest.cpp b/scheduler/SchedulerTest.cpp
index 5e047710c432ae1838c07e78f719e0dde0468a8c..ae92e8e4673cd7e960394fa31d59d677ab103c93 100644
--- a/scheduler/SchedulerTest.cpp
+++ b/scheduler/SchedulerTest.cpp
@@ -168,19 +168,24 @@ public:
     const uint64_t retrievePriority = s_retrievePriority;
     const uint64_t minRetrieveRequestAge = s_minRetrieveRequestAge;
     const uint64_t maxDrivesAllowed = s_maxDrivesAllowed;
+    const uint64_t maxDrivesAllowedPerVo = s_maxDrivesAllowedPerVo;
     const std::string mountPolicyComment = "create mount group";
+    
+    catalogue::CreateMountPolicyAttributes mountPolicy;
+    mountPolicy.name = mountPolicyName;
+    mountPolicy.archivePriority = archivePriority;
+    mountPolicy.minArchiveRequestAge = minArchiveRequestAge;
+    mountPolicy.retrievePriority = retrievePriority;
+    mountPolicy.minRetrieveRequestAge = minRetrieveRequestAge;
+    mountPolicy.maxDrivesAllowed = maxDrivesAllowed;
+    mountPolicy.maxDrivesAllowedPerVo = maxDrivesAllowedPerVo;
+    mountPolicy.comment = mountPolicyComment;
 
     ASSERT_TRUE(catalogue.getMountPolicies().empty());
 
     catalogue.createMountPolicy(
       s_adminOnAdminHost,
-      mountPolicyName,
-      archivePriority,
-      minArchiveRequestAge,
-      retrievePriority,
-      minRetrieveRequestAge,
-      maxDrivesAllowed,
-      mountPolicyComment);
+      mountPolicy);
 
     const std::list<common::dataStructures::MountPolicy> groups = catalogue.getMountPolicies();
     ASSERT_EQ(1, groups.size());
@@ -289,6 +294,7 @@ protected:
   const uint64_t s_retrievePriority = 3;
   const uint64_t s_minRetrieveRequestAge = 4; 
   const uint64_t s_maxDrivesAllowed = 50;
+  const uint64_t s_maxDrivesAllowedPerVo = 50;
   const uint64_t s_mediaTypeCapacityInBytes = 10;
   const std::string s_vo = "vo";
   //TempFile m_tempSqliteFile;
diff --git a/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp b/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
index 682ab590ea20507c29241585f379772e97403ae1..a7f40c4373765ad7d202a0543e18263866f4cf6a 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
@@ -252,29 +252,52 @@ public:
     return tape;
   }
   
+  cta::catalogue::CreateMountPolicyAttributes getDefaultMountPolicy() {
+    cta::catalogue::CreateMountPolicyAttributes mountPolicy;
+    mountPolicy.name = "mount_group";
+    mountPolicy.archivePriority = 1;
+    mountPolicy.minArchiveRequestAge = 2;
+    mountPolicy.retrievePriority = 3;
+    mountPolicy.minRetrieveRequestAge = 4;
+    mountPolicy.maxDrivesAllowed = 5;
+    mountPolicy.maxDrivesAllowedPerVo = 6;
+    mountPolicy.comment = "create mount group";
+    return mountPolicy; 
+  }
+  
+  cta::catalogue::CreateMountPolicyAttributes getImmediateMountMountPolicy() {
+    cta::catalogue::CreateMountPolicyAttributes mountPolicy;
+    mountPolicy.name = "immediateMount";
+    mountPolicy.archivePriority = 1000;
+    mountPolicy.minArchiveRequestAge = 0;
+    mountPolicy.retrievePriority = 1000;
+    mountPolicy.minRetrieveRequestAge = 0;
+    mountPolicy.maxDrivesAllowed = 1;
+    mountPolicy.maxDrivesAllowedPerVo = 1;
+    mountPolicy.comment = "Immediate mount";
+    return mountPolicy; 
+  }
+  
   void setupDefaultCatalogue() {
     using namespace cta;
     auto & catalogue=getCatalogue();
 
-    const std::string mountPolicyName = "mount_group";
-    const uint64_t archivePriority = 1;
-    const uint64_t minArchiveRequestAge = 2;
-    const uint64_t retrievePriority = 3;
-    const uint64_t minRetrieveRequestAge = 4;
-    const uint64_t maxDrivesAllowed = 5;
+    auto mountPolicy = getDefaultMountPolicy();
+    
+    const std::string mountPolicyName = mountPolicy.name;
+    const uint64_t archivePriority = mountPolicy.archivePriority;
+    const uint64_t minArchiveRequestAge = mountPolicy.minArchiveRequestAge;
+    const uint64_t retrievePriority = mountPolicy.retrievePriority;
+    const uint64_t minRetrieveRequestAge = mountPolicy.minRetrieveRequestAge;
+    const uint64_t maxDrivesAllowed = mountPolicy.maxDrivesAllowed;
+    const uint64_t maxDrivesAllowedPerVo = mountPolicy.maxDrivesAllowedPerVo;
     const std::string mountPolicyComment = "create mount group";
 
     ASSERT_TRUE(catalogue.getMountPolicies().empty());
 
     catalogue.createMountPolicy(
       s_adminOnAdminHost,
-      mountPolicyName,
-      archivePriority,
-      minArchiveRequestAge,
-      retrievePriority,
-      minRetrieveRequestAge,
-      maxDrivesAllowed,
-      mountPolicyComment);
+      mountPolicy);
 
     const std::list<common::dataStructures::MountPolicy> groups = catalogue.getMountPolicies();
     ASSERT_EQ(1, groups.size());
@@ -285,6 +308,7 @@ public:
     ASSERT_EQ(retrievePriority, group.retrievePriority);
     ASSERT_EQ(minRetrieveRequestAge, group.retrieveMinRequestAge);
     ASSERT_EQ(maxDrivesAllowed, group.maxDrivesAllowed);
+    ASSERT_EQ(maxDrivesAllowedPerVo,group.maxDrivesAllowedPerVo);
     ASSERT_EQ(mountPolicyComment, group.comment);
 
     const std::string ruleComment = "create requester mount-rule";
@@ -1882,8 +1906,10 @@ TEST_P(DataTransferSessionTest, DataTransferSessionGooddayMigration) {
   }
 
   // Create the mount criteria
-  catalogue.createMountPolicy(requester, "immediateMount", 1000, 0, 1000, 0, 1, "Policy comment");
-  catalogue.createRequesterMountRule(requester, "immediateMount", s_diskInstance, requester.username, "Rule comment");
+  auto mountPolicy = getImmediateMountMountPolicy();
+  catalogue.createMountPolicy(requester, mountPolicy);
+  std::string mountPolicyName = mountPolicy.name;
+  catalogue.createRequesterMountRule(requester, mountPolicyName, s_diskInstance, requester.username, "Rule comment");
 
   //delete is unnecessary
   //pointer with ownership will be passed to the application,
@@ -2029,8 +2055,10 @@ TEST_P(DataTransferSessionTest, DataTransferSessionMissingFilesMigration) {
   }
 
   // Create the mount criteria
-  catalogue.createMountPolicy(requester, "immediateMount", 1000, 0, 1000, 0, 1, "Policy comment");
-  catalogue.createRequesterMountRule(requester, "immediateMount", s_diskInstance, requester.username, "Rule comment");
+  auto mountPolicy = getImmediateMountMountPolicy();
+  catalogue.createMountPolicy(requester, mountPolicy);
+  std::string mountPolicyName = mountPolicy.name;
+  catalogue.createRequesterMountRule(requester, mountPolicyName, s_diskInstance, requester.username, "Rule comment");
 
   //delete is unnecessary
   //pointer with ownership will be passed to the application,
@@ -2190,9 +2218,10 @@ TEST_P(DataTransferSessionTest, DataTransferSessionTapeFullMigration) {
     catalogue.createTape(s_adminOnAdminHost, tape);
   }
   
-  // Create the mount criteria
-  catalogue.createMountPolicy(requester, "immediateMount", 1000, 0, 1000, 0, 1, "Policy comment");
-  catalogue.createRequesterMountRule(requester, "immediateMount", s_diskInstance, requester.username, "Rule comment");
+  auto mountPolicy = getImmediateMountMountPolicy();
+  catalogue.createMountPolicy(requester, mountPolicy);
+  std::string mountPolicyName = mountPolicy.name;
+  catalogue.createRequesterMountRule(requester, mountPolicyName, s_diskInstance, requester.username, "Rule comment");
 
   //delete is unnecessary
   //pointer with ownership will be passed to the application,
@@ -2351,8 +2380,10 @@ TEST_P(DataTransferSessionTest, DataTransferSessionTapeFullOnFlushMigration) {
   }
 
   // Create the mount criteria
-  catalogue.createMountPolicy(requester, "immediateMount", 1000, 0, 1000, 0, 1, "Policy comment");
-  catalogue.createRequesterMountRule(requester, "immediateMount", s_diskInstance, requester.username, "Rule comment");
+  auto mountPolicy = getImmediateMountMountPolicy();
+  catalogue.createMountPolicy(requester, mountPolicy);
+  std::string mountPolicyName = mountPolicy.name;
+  catalogue.createRequesterMountRule(requester, mountPolicyName, s_diskInstance, requester.username, "Rule comment");
 
   //delete is unnecessary
   //pointer with ownership will be passed to the application,
diff --git a/xroot_plugins/XrdSsiCtaRequestMessage.cpp b/xroot_plugins/XrdSsiCtaRequestMessage.cpp
index b39eb9e13a4061d9fac0f941dd442771cfe606e1..d1070a5b04be854a5081a1648cfbb029f566ee87 100644
--- a/xroot_plugins/XrdSsiCtaRequestMessage.cpp
+++ b/xroot_plugins/XrdSsiCtaRequestMessage.cpp
@@ -1392,10 +1392,20 @@ void RequestMessage::processMountPolicy_Add(cta::xrd::Response &response)
    auto &minretrieverequestage = getRequired(OptionUInt64::MIN_RETRIEVE_REQUEST_AGE);
    auto &maxdrivesallowed      = getRequired(OptionUInt64::MAX_DRIVES_ALLOWED);
    auto &comment               = getRequired(OptionString::COMMENT);
-
-   m_catalogue.createMountPolicy(m_cliIdentity, group, archivepriority, minarchiverequestage, retrievepriority,
-                                 minretrieverequestage, maxdrivesallowed, comment);
-
+   
+   cta::catalogue::CreateMountPolicyAttributes mountPolicy;
+   mountPolicy.name = group;
+   mountPolicy.archivePriority = archivepriority;
+   mountPolicy.minArchiveRequestAge = minarchiverequestage;
+   mountPolicy.retrievePriority = retrievepriority;
+   mountPolicy.minRetrieveRequestAge = minretrieverequestage;
+   mountPolicy.maxDrivesAllowed = maxdrivesallowed;
+   //TODO: Add the OptionUint64::MAX_DRIVES_ALLOWED_PER_VO
+   mountPolicy.maxDrivesAllowedPerVo = maxdrivesallowed;
+   mountPolicy.comment = comment;
+
+   m_catalogue.createMountPolicy(m_cliIdentity, mountPolicy);
+      
    response.set_type(cta::xrd::Response::RSP_SUCCESS);
 }