diff --git a/SConstruct b/SConstruct
index f8a0764a24..0789e08de3 100755
--- a/SConstruct
+++ b/SConstruct
@@ -82,7 +82,6 @@ main_env.Append(LIBPATH=[
     cwd+'/src/cluster',
     cwd+'/src/datastore',
     cwd+'/src/group',
-    cwd+'/src/mad',
     cwd+'/src/nebula',
     cwd+'/src/pool',
     cwd+'/src/template',
@@ -281,7 +280,6 @@ build_scripts = [
     'src/cluster/SConstruct',
     'src/datastore/SConstruct',
     'src/group/SConstruct',
-    'src/mad/SConstruct',
     'src/nebula/SConstruct',
     'src/pool/SConstruct',
     'src/vm/SConstruct',
diff --git a/include/AclManager.h b/include/AclManager.h
index c85f7c1e4b..eb312d3fc1 100644
--- a/include/AclManager.h
+++ b/include/AclManager.h
@@ -374,15 +374,6 @@ private:
      */
     SqlDB * db;
 
-    /**
-     *  Tablename for the ACL rules
-     */
-    static const char * table;
-
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
     /**
      *  Callback function to unmarshall the ACL rules
      *    @param num the number of columns read from the DB
diff --git a/include/AuthManager.h b/include/AuthManager.h
index 9021d335ef..cabcdaf8a0 100644
--- a/include/AuthManager.h
+++ b/include/AuthManager.h
@@ -19,17 +19,13 @@
 
 #include <time.h>
 
-#include "MadManager.h"
 #include "NebulaLog.h"
 #include "ActionManager.h"
-#include "AuthManagerDriver.h"
-#include "PoolObjectSQL.h"
-
-using namespace std;
+#include "ProtocolMessages.h"
+#include "DriverManager.h"
 
 //Forward definitions
 class AuthRequest;
-class PoolObjectAuth;
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -44,10 +40,10 @@ public:
     };
 
     AMAction(Actions a, AuthRequest *r):ActionRequest(ActionRequest::USER),
-        _action(a), _request(r){};
+        _action(a), _request(r) {}
 
     AMAction(const AMAction& o):ActionRequest(o._type), _action(o._action),
-        _request(o._request){};
+        _request(o._request) {}
 
     Actions action() const
     {
@@ -75,19 +71,22 @@ private:
 
 extern "C" void * authm_action_loop(void *arg);
 
-class AuthManager : public MadManager, public ActionListener
+class AuthManager :
+    public DriverManager<Driver<auth_msg_t>>,
+    public ActionListener
 {
 public:
 
     AuthManager(
         time_t                    timer,
-        vector<const VectorAttribute*>& _mads):
-            MadManager(_mads), timer_period(timer)
+        const std::string&        mads_location):
+            DriverManager(mads_location),
+            timer_period(timer)
     {
         am.addListener(this);
-    };
+    }
 
-    ~AuthManager(){};
+    ~AuthManager() {}
 
     /**
      *  Triggers specific actions to the Auth Manager. This function
@@ -116,15 +115,13 @@ public:
     void finalize()
     {
         am.finalize();
-    };
+    }
 
     /**
      *  Loads Virtual Machine Manager Mads defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Gets the thread identification.
@@ -133,7 +130,7 @@ public:
     pthread_t get_thread_id() const
     {
         return authm_thread;
-    };
+    }
 
     /**
      * Returns true if there is an authorization driver enabled
@@ -143,7 +140,7 @@ public:
     bool is_authz_enabled()
     {
         return authz_enabled;
-    };
+    }
 
 private:
     /**
@@ -164,12 +161,12 @@ private:
     /**
      *  Generic name for the Auth driver
      */
-     static const char *    auth_driver_name;
+    static const char *    auth_driver_name;
 
      /**
       * True if there is an authorization driver enabled
       */
-     bool                   authz_enabled;
+    bool                   authz_enabled;
 
     /**
      *  Returns a pointer to a Auth Manager driver.
@@ -178,13 +175,10 @@ private:
      *    @return the Auth driver with attribute name equal to value
      *    or 0 in not found
      */
-    const AuthManagerDriver * get(
-        const string&   name,
-        const string&   value)
+    const Driver<auth_msg_t> * get(const string&   name)
     {
-        return static_cast<const AuthManagerDriver *>
-               (MadManager::get(0,name,value));
-    };
+        return DriverManager::get_driver(name);
+    }
 
     /**
      *  Returns a pointer to a Auth Manager driver. The driver is
@@ -193,13 +187,10 @@ private:
      *    @return the TM driver owned by uid with attribute name equal to value
      *    or 0 in not found
      */
-    const AuthManagerDriver * get()
+    const Driver<auth_msg_t> * get()
     {
-        string name("NAME");
-
-        return static_cast<const AuthManagerDriver *>
-               (MadManager::get(0,name,auth_driver_name));
-    };
+        return DriverManager::get_driver(auth_driver_name);
+    }
 
     /**
      *  This function authenticates a user
@@ -217,20 +208,45 @@ private:
      */
     friend void * authm_action_loop(void *arg);
 
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    /**
+     *
+     */
+    static void _undefined(unique_ptr<auth_msg_t> msg);
+
+    /**
+     *
+     */
+    void _authorize(unique_ptr<auth_msg_t> msg);
+
+    /**
+     *
+     */
+    void _authenticate(unique_ptr<auth_msg_t> msg);
+
+    /**
+     *
+     */
+    static void _log(unique_ptr<auth_msg_t> msg);
+
     // -------------------------------------------------------------------------
     // Action Listener interface
     // -------------------------------------------------------------------------
     void timer_action(const ActionRequest& ar)
     {
         check_time_outs_action();
-    };
+    }
+
+    static const int drivers_timeout = 10;
 
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("AuM",Log::INFO,"Stopping Authorization Manager...");
 
-        MadManager::stop();
-    };
+        DriverManager::stop(drivers_timeout);
+    }
 
     void user_action(const ActionRequest& ar);
 };
diff --git a/include/AuthManagerDriver.h b/include/AuthManagerDriver.h
deleted file mode 100644
index 08ac656148..0000000000
--- a/include/AuthManagerDriver.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef AUTH_MANAGER_DRIVER_H_
-#define AUTH_MANAGER_DRIVER_H_
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include "Mad.h"
-
-using namespace std;
-
-//Forward definition of the AuthManager Class
-class AuthManager;
-
-/**
- *  AuthManagerDriver provides a base class to implement TM
- *  Drivers. This class implements the protocol and recover functions
- *  from the Mad interface.
- */
-class AuthManagerDriver : public Mad
-{
-public:
-
-    AuthManagerDriver(
-        int                         userid,
-        const map<string,string>&   attrs,
-        bool                        sudo,
-        AuthManager *               _authm):
-            Mad(userid,attrs,sudo), authm(_authm){};
-
-    virtual ~AuthManagerDriver(){};
-
-    /**
-     *  Implements the VM Manager driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const string& message) const;
-
-    /**
-     *  Re-starts the driver
-     */
-    void recover();
-
-private:
-    friend class AuthManager;
-
-    /**
-     *  The AuthManager to notify results.
-     */
-    AuthManager * authm;
-
-    /**
-     *  Sends an authorization request to the MAD:
-     *    "AUTHORIZE  OPERATION_ID USER_ID REQUEST1 REQUEST2..."
-     *    @param oid an id to identify the request.
-     *    @param uid the user id.
-     *    @param requests space separated list of requests in the form OP:OB:ID
-     *    @param acl is the authorization result using the ACL engine for
-     *           this request
-     */
-    void authorize(int oid, int uid, const string& requests, bool acl) const;
-
-    /**
-     *  Sends an authorization request to the MAD:
-     *  "AUTHENTICATE REQUEST_ID USER_ID USER_NAME PASSWORD XMLRPC_TOKEN"
-     *    @param oid an id to identify the request.
-     *    @param uid the user id.
-     *    @param auth_driver
-     *    @param username
-     *    @param password
-     *    @param session token from the xml-rpc parameter
-     */
-    void authenticate(int           oid,
-                      int           uid,
-                      const string& auth_driver,
-                      const string& username,
-                      const string& password,
-                      const string& session) const;
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-#endif /*AUTH_MANAGER_DRIVER_H_*/
-
diff --git a/include/AuthRequest.h b/include/AuthRequest.h
index 237cf9dc01..23094d2b11 100644
--- a/include/AuthRequest.h
+++ b/include/AuthRequest.h
@@ -17,7 +17,6 @@
 #ifndef AUTH_REQUEST_H_
 #define AUTH_REQUEST_H_
 
-#include <time.h>
 #include <set>
 
 #include "ActionManager.h"
@@ -27,8 +26,6 @@
 
 #include "SyncRequest.h"
 
-using namespace std;
-
 /**
  *  The AuthRequest class is used to pass an Authorization or Authentication
  *  request to the AuthManager. The result of the request will be stored
@@ -37,7 +34,11 @@ using namespace std;
 class AuthRequest : public SyncRequest
 {
 public:
-    AuthRequest(int _uid, set<int> _gids): uid(_uid),gids(_gids),self_authorize(true){};
+    AuthRequest(int _uid, const std::set<int>& _gids)
+        : uid(_uid)
+        , gids(_gids)
+        , self_authorize(true)
+    {}
 
     ~AuthRequest(){};
 
@@ -57,7 +58,7 @@ public:
         NONE          = 0x0LL
     };
 
-    static string operation_to_str(Operation op)
+    static std::string operation_to_str(Operation op)
     {
         switch (op)
         {
@@ -75,7 +76,7 @@ public:
         return "";
     };
 
-    static Operation str_to_operation(string str)
+    static Operation str_to_operation(std::string str)
     {
             if      (str == "USE")    return USE;
             else if (str == "MANAGE") return MANAGE;
@@ -88,10 +89,10 @@ public:
      *  Sets the challenge to authenticate an user
      *  @param challenge a driver specific authentication challenge
      */
-    void add_authenticate(const string &_driver,
-                          const string &_username,
-                          const string &_password,
-                          const string &_session)
+    void add_authenticate(const std::string &_driver,
+                          const std::string &_username,
+                          const std::string &_password,
+                          const std::string &_session)
     {
         username = _username;
         password = _password;
@@ -110,7 +111,8 @@ public:
      *    @param type of the object to be created
      *    @param txml template of the new object
      */
-    void add_create_auth(int uid, int gid, PoolObjectSQL::ObjectType type, const string& txml)
+    void add_create_auth(int uid, int gid, PoolObjectSQL::ObjectType type,
+                         const std::string& txml)
     {
         PoolObjectAuth perms; //oid & gid set to -1
 
@@ -140,14 +142,14 @@ public:
      *  @return a space separated list of auth requests, or an empty string if
      *          no auth requests were added
      */
-    string get_auths()
+    std::string get_auths()
     {
-        ostringstream oss;
+        std::ostringstream oss;
         unsigned int  i;
 
         if ( auths.empty() )
         {
-            return string();
+            return std::string();
         }
 
         for (i=0; i<auths.size()-1; i++)
@@ -167,8 +169,8 @@ public:
 
     bool core_authenticate()
     {
-        string sha1_session = one_util::sha1_digest(session);
-        string sha256_session = one_util::sha256_digest(session);
+        std::string sha1_session = one_util::sha1_digest(session);
+        std::string sha256_session = one_util::sha256_digest(session);
 
         return (password == sha1_session) || (password == sha256_session);
     }
@@ -185,32 +187,32 @@ private:
     /**
      *  The user groups ID set
      */
-    set<int> gids;
+    std::set<int> gids;
 
     /**
      *  Username to authenticate the user
      */
-    string username;
+    std::string username;
 
     /**
      *  User password to authenticate the user
      */
-    string password;
+    std::string password;
 
     /**
      *  Authentication token as sent in the XML-RPC call (user:session)
      */
-    string session;
+    std::string session;
 
     /**
      *  Authentication driver to be used with this request
      */
-    string driver;
+    std::string driver;
 
     /**
      *  A list of authorization requests
      */
-    vector<string> auths;
+    std::vector<std::string> auths;
 
     /**
      *  Plain authorization for the request
@@ -230,7 +232,7 @@ private:
      */
     void add_auth(Operation             op,
                   const PoolObjectAuth& ob_perms,
-                  string                ob_template);
+                  const std::string&    ob_template);
 };
 
 #endif
diff --git a/include/Cluster.h b/include/Cluster.h
index 004db41561..143a60aa79 100644
--- a/include/Cluster.h
+++ b/include/Cluster.h
@@ -18,7 +18,6 @@
 #define CLUSTER_H_
 
 #include "PoolObjectSQL.h"
-#include "ObjectCollection.h"
 #include "DatastorePool.h"
 #include "ClusterTemplate.h"
 #include "BitMap.h"
@@ -161,19 +160,7 @@ private:
     // *************************************************************************
     // DataBase implementation (Private)
     // *************************************************************************
-    static const char * db_names;
-    static const char * db_bootstrap;
-    static const char * table;
 
-    static const char * datastore_table;
-    static const char * datastore_db_names;
-    static const char * datastore_db_bootstrap;
-
-    static const char * network_table;
-    static const char * network_db_names;
-    static const char * network_db_bootstrap;
-
-    static const char * bitmap_table;
     /**
      *  Execute an INSERT or REPLACE Sql query.
      *    @param db The SQL DB
@@ -187,22 +174,7 @@ private:
      *  Bootstraps the database table(s) associated to the Cluster
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        int rc;
-        ostringstream oss;
-
-        oss.str(Cluster::db_bootstrap);
-        rc = db->exec_local_wr(oss);
-
-        oss.str(Cluster::datastore_db_bootstrap);
-        rc += db->exec_local_wr(oss);
-
-        oss.str(Cluster::network_db_bootstrap);
-        rc += db->exec_local_wr(oss);
-
-        return rc;
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the Cluster in the database.
diff --git a/include/ClusterPool.h b/include/ClusterPool.h
index 9a84b2095c..bda1f65134 100644
--- a/include/ClusterPool.h
+++ b/include/ClusterPool.h
@@ -19,6 +19,7 @@
 
 #include "Cluster.h"
 #include "PoolSQL.h"
+#include "OneDB.h"
 
 using namespace std;
 
@@ -190,7 +191,7 @@ public:
 
         rc  = Cluster::bootstrap(_db);
         rc += _db->exec_local_wr(
-                BitMap<0>::bootstrap(Cluster::bitmap_table, oss_bitmap));
+                BitMap<0>::bootstrap(one_db::cluster_bitmap_table, oss_bitmap));
 
         return rc;
     };
@@ -209,7 +210,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "CLUSTER_POOL", "body", Cluster::table, where,
+        return PoolSQL::dump(oss, "CLUSTER_POOL", "body",
+                             one_db::cluster_table, where,
                              sid, eid, desc);
     };
 
diff --git a/include/Datastore.h b/include/Datastore.h
index 5c9fd8daed..bae3394985 100644
--- a/include/Datastore.h
+++ b/include/Datastore.h
@@ -359,12 +359,6 @@ private:
     // DataBase implementation (Private)
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Execute an INSERT or REPLACE Sql query.
      *    @param db The SQL DB
@@ -378,12 +372,7 @@ private:
      *  Bootstraps the database table(s) associated to the Datastore
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(Datastore::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the Datastore in the database.
diff --git a/include/DatastorePool.h b/include/DatastorePool.h
index b29885cd5c..aa5ee26c64 100644
--- a/include/DatastorePool.h
+++ b/include/DatastorePool.h
@@ -19,6 +19,7 @@
 
 #include "Datastore.h"
 #include "PoolSQL.h"
+#include "OneDB.h"
 
 using namespace std;
 
@@ -152,7 +153,7 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "DATASTORE_POOL", "body", Datastore::table,
+        return PoolSQL::dump(oss, "DATASTORE_POOL", "body", one_db::ds_table,
                 where, sid, eid, desc);
     };
 
@@ -164,7 +165,7 @@ public:
      */
      int list(vector<int>& oids)
      {
-        return PoolSQL::list(oids, Datastore::table);
+        return PoolSQL::list(oids, one_db::ds_table);
      }
 
      /**
diff --git a/include/Document.h b/include/Document.h
index d331f7c1ac..4f424698a6 100644
--- a/include/Document.h
+++ b/include/Document.h
@@ -103,12 +103,7 @@ private:
      *  Bootstraps the database table(s) associated to the Document
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(Document::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Rebuilds the object from an xml formatted string
@@ -138,12 +133,6 @@ protected:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Writes the Document in the database.
      *    @param db pointer to the db
diff --git a/include/DocumentPool.h b/include/DocumentPool.h
index de43719000..bdcff3d029 100644
--- a/include/DocumentPool.h
+++ b/include/DocumentPool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "Document.h"
+#include "OneDB.h"
 
 /**
  *  The Document Pool class.
@@ -27,7 +28,7 @@ class DocumentPool : public PoolSQL
 {
 public:
 
-    DocumentPool(SqlDB * db) : PoolSQL(db, Document::table){};
+    DocumentPool(SqlDB * db) : PoolSQL(db, one_db::doc_table) {};
 
     ~DocumentPool(){};
 
@@ -103,8 +104,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "DOCUMENT_POOL", "body", Document::table, where,
-                             sid, eid, desc);
+        return PoolSQL::dump(oss, "DOCUMENT_POOL", "body", one_db::doc_table,
+                             where, sid, eid, desc);
     };
 
     /**
diff --git a/src/monitor/include/EnumString.h b/include/EnumString.h
similarity index 96%
rename from src/monitor/include/EnumString.h
rename to include/EnumString.h
index 43c48a08aa..8cc3a39342 100644
--- a/src/monitor/include/EnumString.h
+++ b/include/EnumString.h
@@ -1,5 +1,5 @@
 /* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/* Copyright 2002-2019, OpenNebula Project, OpenNebula Systems                */
 /*                                                                            */
 /* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
 /* not use this file except in compliance with the License. You may obtain    */
@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <assert.h>
 #include <typeinfo>
+#include <sstream>
 
 /**
  * Converts string to enum and back
@@ -42,8 +43,10 @@ public:
         if (check_sanity && (int)T::ENUM_MAX != enum_map.size())
         {
             std::ostringstream oss;
+
             oss << " EString: Not all strings defined for enum "
                 << typeid(T).name();
+
             throw std::runtime_error(oss.str());
         }
     }
diff --git a/include/Group.h b/include/Group.h
index ecd9808019..96e4b2623c 100644
--- a/include/Group.h
+++ b/include/Group.h
@@ -177,17 +177,7 @@ private:
     // Constructor
     // *************************************************************************
 
-    Group(int id, const string& name):
-        PoolObjectSQL(id,GROUP,name,-1,-1,"","",table),
-        quota(),
-        users("USERS"),
-        admins("ADMINS")
-    {
-        // Allow users in this group to see it
-        group_u = 1;
-
-        obj_template = new GroupTemplate;
-    }
+    Group(int id, const string& name);
 
     virtual ~Group() = default;
 
@@ -217,12 +207,6 @@ private:
     // DataBase implementation (Private)
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Execute an INSERT or REPLACE Sql query.
      *    @param db The SQL DB
@@ -236,12 +220,7 @@ private:
      *  Bootstraps the database table(s) associated to the Group
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss_group(Group::db_bootstrap);
-
-        return db->exec_local_wr(oss_group);
-    }
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Reads the Group (identified with its OID) from the database.
diff --git a/include/History.h b/include/History.h
index e224399b53..3d898187f8 100644
--- a/include/History.h
+++ b/include/History.h
@@ -70,15 +70,6 @@ private:
     friend class VirtualMachine;
     friend class VirtualMachinePool;
 
-    // ----------------------------------------
-    // DataBase implementation variables
-    // ----------------------------------------
-    static const char * table;
-
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
     void non_persistent_data();
 
     // ----------------------------------------
diff --git a/include/Hook.h b/include/Hook.h
index b2f68e1f39..b77b233a8c 100644
--- a/include/Hook.h
+++ b/include/Hook.h
@@ -93,18 +93,7 @@ private:
     // Constructor/Destructor
     // *************************************************************************
 
-    Hook(Template * tmpl): PoolObjectSQL(-1, HOOK, "", -1, -1, "", "", table),
-        type(HookType::UNDEFINED), cmd(""), remote(false), _hook(0)
-    {
-        if (tmpl != 0)
-        {
-            obj_template = tmpl;
-        }
-        else
-        {
-            obj_template = new Template();
-        }
-    };
+    Hook(Template * tmpl);
 
     ~Hook();
 
@@ -164,12 +153,6 @@ private:
     // Database implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Construct the XML representation of the hook
      *  @param xml the resulting XML string
@@ -183,12 +166,7 @@ private:
      *  Bootstraps the database table(s) associated to the Host
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        std::ostringstream oss_hook(Hook::db_bootstrap);
-
-        return db->exec_local_wr(oss_hook);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes/updates the Hosts data fields in the database.
diff --git a/include/HookLog.h b/include/HookLog.h
index c4b55214b6..1d147f93c0 100644
--- a/include/HookLog.h
+++ b/include/HookLog.h
@@ -106,11 +106,6 @@ private:
     // ----------------------------------------
     // DataBase implementation variables
     // ----------------------------------------
-    static const char * table;
-
-    static const char * db_names;
-
-    static const char * db_bootstrap;
 
     /**
      *  Pointer to the database.
diff --git a/include/HookManager.h b/include/HookManager.h
index 852739ed1b..24d6cae26f 100644
--- a/include/HookManager.h
+++ b/include/HookManager.h
@@ -17,9 +17,9 @@
 #ifndef HOOK_MANAGER_H_
 #define HOOK_MANAGER_H_
 
-#include "MadManager.h"
+#include "ProtocolMessages.h"
+#include "DriverManager.h"
 #include "ActionManager.h"
-#include "HookManagerDriver.h"
 
 #include <vector>
 
@@ -67,14 +67,16 @@ private:
 
 extern "C" void * hm_action_loop(void *arg);
 
-class HookManager : public MadManager, public ActionListener
+class HookManager :
+    public DriverManager<Driver<hook_msg_t>>,
+    public ActionListener
 {
 public:
 
-    HookManager(std::vector<const VectorAttribute*>& _mads):MadManager(_mads)
+    HookManager(const std::string& mad_location): DriverManager(mad_location)
     {
         am.addListener(this);
-    };
+    }
 
     virtual ~HookManager() = default;
 
@@ -97,11 +99,9 @@ public:
 
     /**
      *  Loads Hook Manager Mads defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid=0);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Triggers specific actions to the Hook Manager.
@@ -121,7 +121,7 @@ public:
     void finalize()
     {
         am.finalize();
-    };
+    }
 
     /**
      *  Returns a pointer to a Information Manager MAD. The driver is
@@ -130,13 +130,10 @@ public:
      *    @return the Hook driver owned by uid 0, with attribute "NAME" equal to
      *    name or 0 in not found
      */
-    const HookManagerDriver * get()
+    const Driver<hook_msg_t> * get()
     {
-        std::string name("NAME");
-
-        return static_cast<const HookManagerDriver *>
-               (MadManager::get(0, name,hook_driver_name));
-    };
+        return DriverManager::get_driver(hook_driver_name);
+    }
 
     static std::string * format_message(const string& args, const string&remote_host,
                                         int hook_id);
@@ -151,7 +148,7 @@ private:
     /**
      *  Generic name for the Hook driver
      */
-     static const char *  hook_driver_name;
+    static const char *  hook_driver_name;
 
     /**
      *  Thread id for the HookManager
@@ -175,14 +172,39 @@ private:
      */
     void retry_action(const std::string& message);
 
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    /**
+     *
+     */
+    static void _undefined(unique_ptr<hook_msg_t> msg);
+
+    /**
+     *
+     */
+    void _execute(unique_ptr<hook_msg_t> msg);
+
+    /**
+     *
+     */
+    void _retry(unique_ptr<hook_msg_t> msg);
+
+    /**
+     *
+     */
+    static void _log(unique_ptr<hook_msg_t> msg);
+
     // -------------------------------------------------------------------------
     // Action Listener interface
     // -------------------------------------------------------------------------
+    static const int drivers_timeout = 10;
+
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("HKM",Log::INFO,"Stopping Hook Manager...");
 
-        MadManager::stop();
+        DriverManager::stop(drivers_timeout);
     };
 
     void user_action(const ActionRequest& ar);
diff --git a/include/HookManagerDriver.h b/include/HookManagerDriver.h
deleted file mode 100644
index 9646075d52..0000000000
--- a/include/HookManagerDriver.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef HOOK_MANAGER_DRIVER_H_
-#define HOOK_MANAGER_DRIVER_H_
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include "Mad.h"
-#include "VirtualMachinePool.h"
-#include "HookLog.h"
-
-using namespace std;
-
-/**
- *  HookManagerDriver provides a base class to implement Hook (Execution)
- *  Drivers. This class implements the protocol and recover functions
- *  from the Mad interface. This class may be used to further specialize
- *  the Execution driver.
- */
-class HookManagerDriver : public Mad
-{
-public:
-
-    HookManagerDriver(
-        int                       userid,
-        const map<string,string>& attrs,
-        bool                      sudo)
-            : Mad(userid,attrs,sudo) {};
-
-    virtual ~HookManagerDriver(){};
-
-    /**
-     *  Implements the Hook driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const string& message) const;
-
-    /**
-     *  TODO: What do we need here? just poll the Hosts to recover..
-     */
-    void recover();
-
-    /**<id> <hook_name> <LOCAL|host> <script> <args|->
-     *  Sends an execution request to the MAD: "EXECUTE id name local cmd args"
-     *    @param oid the virtual machine id.
-     *    @param hook_name the name of the hook
-     *    @param command to be executed
-     *    @param arguments for the command
-     */
-    void execute(
-        int             oid,
-        const string&   hook_name,
-        const string&   command,
-        const string&   arguments ) const;
-
-    /**
-     *  Sends an execution request to the MAD: "EXECUTE id name host cmd args"
-     *    @param oid the virtual machine id.
-     *    @param hook_name the name of the hook
-     *    @param host_name the name of the host to execute the hook
-     *    @param command to be executed
-     *    @param arguments for the command
-     */
-    void execute(
-        int             oid,
-        const string&   hook_name,
-        const string&   host_name,
-        const string&   command,
-        const string&   arguments ) const;
-
-    void execute(
-        const string&   message ) const;
-
-    void retry(
-        const string&   message ) const;
-
-private:
-
-    friend class            HookManager;
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-#endif /*HOOK_MANAGER_DRIVER_H_*/
diff --git a/include/HookPool.h b/include/HookPool.h
index fe4257c19a..481e8c68b3 100644
--- a/include/HookPool.h
+++ b/include/HookPool.h
@@ -20,6 +20,7 @@
 #include "PoolSQL.h"
 #include "Hook.h"
 #include "HookAPI.h"
+#include "OneDB.h"
 
 using namespace std;
 
@@ -27,7 +28,7 @@ class HookPool : public PoolSQL
 {
 public:
 
-    HookPool(SqlDB * db) : PoolSQL(db, Hook::table){};
+    HookPool(SqlDB * db) : PoolSQL(db, one_db::hook_table){};
 
     ~HookPool(){};
 
@@ -83,8 +84,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "HOOK_POOL", "body", Hook::table, where,
-                sid, eid, desc);
+        return PoolSQL::dump(oss, "HOOK_POOL", "body", one_db::hook_table,
+                             where, sid, eid, desc);
     };
 
     /**
diff --git a/include/IPAMManager.h b/include/IPAMManager.h
index 34cd4b0f32..94b86eaefc 100644
--- a/include/IPAMManager.h
+++ b/include/IPAMManager.h
@@ -19,14 +19,14 @@
 
 #include <time.h>
 
-#include "MadManager.h"
+#include "ProtocolMessages.h"
+#include "DriverManager.h"
 #include "ActionManager.h"
-#include "IPAMManagerDriver.h"
-#include "Attribute.h"
 #include "NebulaLog.h"
 
 //Forward definitions
 class IPAMRequest;
+class VectorAttribute;
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -75,12 +75,14 @@ private:
 
 extern "C" void * ipamm_action_loop(void *arg);
 
-class IPAMManager : public MadManager, public ActionListener
+class IPAMManager :
+    public DriverManager<Driver<ipam_msg_t>>,
+    public ActionListener
 {
 public:
 
-    IPAMManager(time_t timer, std::vector<const VectorAttribute*>& _mads):
-            MadManager(_mads), timer_period(timer)
+    IPAMManager(time_t timer, const std::string mad_location):
+            DriverManager(mad_location), timer_period(timer)
     {
         am.addListener(this);
     };
@@ -110,11 +112,9 @@ public:
 
     /**
      *  Loads IPAM Manager Mads defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Gets the thread identification.
@@ -154,20 +154,6 @@ private:
      */
     static const char *    ipam_driver_name;
 
-    /**
-     *  Returns a pointer to a IPAM Manager driver.
-     *    @param name of an attribute of the driver (e.g. its type)
-     *    @param value of the attribute
-     *    @return the IPAM driver with attribute name equal to value
-     *    or 0 in not found
-     */
-    const IPAMManagerDriver * get(const std::string& name,
-        const std::string& value)
-    {
-        return static_cast<const IPAMManagerDriver *>
-               (MadManager::get(0, name, value));
-    };
-
     /**
      *  Returns a pointer to a IPAM Manager driver. The driver is
      *  searched by its name.
@@ -175,12 +161,9 @@ private:
      *    @return the IPAM driver owned by uid with attribute name equal to value
      *    or 0 in not found
      */
-    const IPAMManagerDriver * get()
+    const Driver<ipam_msg_t> * get()
     {
-        std::string name("NAME");
-
-        return static_cast<const IPAMManagerDriver *>
-               (MadManager::get(0, name, ipam_driver_name));
+        return DriverManager::get_driver(ipam_driver_name);
     };
 
     /**
@@ -213,7 +196,7 @@ private:
      *    @param ir the IPAM request
      *    @return pointer to the IPAM driver to use, 0 on failure
      */
-    const IPAMManagerDriver * setup_request(IPAMRequest * ir);
+    void send_request(IPAMManagerMessages type, IPAMRequest * ir);
 
     /**
      *  Function to execute the Manager action loop method within a new pthread
@@ -221,6 +204,24 @@ private:
      */
     friend void * ipamm_action_loop(void *arg);
 
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    /**
+     *
+     */
+    static void _undefined(unique_ptr<ipam_msg_t> msg);
+
+    /**
+     *
+     */
+    void _notify_request(unique_ptr<ipam_msg_t> msg);
+
+    /**
+     *
+     */
+    static void _log(unique_ptr<ipam_msg_t> msg);
+
     // -------------------------------------------------------------------------
     // Action Listener interface
     // -------------------------------------------------------------------------
@@ -229,11 +230,13 @@ private:
         check_time_outs_action();
     };
 
+    static const int drivers_timeout = 10;
+
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("IPM",Log::INFO,"Stopping IPAM Manager...");
 
-        MadManager::stop();
+        DriverManager::stop(drivers_timeout);
     };
 
     void user_action(const ActionRequest& ar);
diff --git a/include/IPAMManagerDriver.h b/include/IPAMManagerDriver.h
deleted file mode 100644
index 36023a8591..0000000000
--- a/include/IPAMManagerDriver.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef IPAM_MANAGER_DRIVER_H_
-#define IPAM_MANAGER_DRIVER_H_
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include "Mad.h"
-
-//Forward definition of the IPAMManager Class
-class IPAMManager;
-
-/**
- *  IPAMManagerDriver provides a base class to implement IPAM
- *  Drivers. This class implements the protocol and recover functions
- *  from the Mad interface.
- */
-class IPAMManagerDriver : public Mad
-{
-public:
-
-    IPAMManagerDriver(int uid, const std::map<string,string>& attrs, bool sudo,
-        IPAMManager * _ipamm):Mad(uid,attrs,sudo), ipamm(_ipamm){};
-
-    virtual ~IPAMManagerDriver(){};
-
-    /**
-     *  Implements the IPAM Manager driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const string& message) const;
-
-    /**
-     *  Re-starts the driver
-     */
-    void recover();
-
-private:
-    friend class IPAMManager;
-
-    /**
-     *  The IPAMManager to notify results.
-     */
-    IPAMManager * ipamm;
-
-    /**
-     *  Register or requests a new AddressRange (network) into the IPAM
-     */
-    void register_address_range(int id, const std::string& arg) const
-    {
-        send_message("REGISTER_ADDRESS_RANGE", id, arg);
-    }
-
-    /**
-     *  Unregister an AddressRange from the IPAM
-     */
-    void unregister_address_range(int id, const std::string& arg) const
-    {
-        send_message("UNREGISTER_ADDRESS_RANGE", id, arg);
-    }
-
-    /**
-     *  Get a free address (or range)
-     */
-    void get_address(int id, const std::string& arg) const
-    {
-        send_message("GET_ADDRESS", id, arg);
-    }
-
-    /**
-     *  Sets an address (or range) as used
-     */
-    void allocate_address(int id, const std::string& arg) const
-    {
-        send_message("ALLOCATE_ADDRESS", id, arg);
-    }
-
-    /**
-     * Free a previously requested or allocated address
-     */
-    void free_address(int id, const std::string& arg) const
-    {
-        send_message("FREE_ADDRESS", id, arg);
-    }
-
-    /**
-     *  Sends a generic message to the IPAM driver
-     */
-    void send_message(const char * name, int id, const std::string& arg) const
-    {
-        std::ostringstream os;
-
-        os << name << " " << id << " " << arg << endl;
-
-        write(os);
-    }
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-#endif /*IPAM_MANAGER_DRIVER_H_*/
-
diff --git a/include/Image.h b/include/Image.h
index d54ab81bdc..f56ce41144 100644
--- a/include/Image.h
+++ b/include/Image.h
@@ -699,12 +699,7 @@ private:
      *  Bootstraps the database table(s) associated to the Image
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss_image(Image::db_bootstrap);
-
-        return db->exec_local_wr(oss_image);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  "Encrypts" the password with SHA256 digest
@@ -732,12 +727,6 @@ protected:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Writes the Image in the database.
      *    @param db pointer to the db
diff --git a/include/ImageManager.h b/include/ImageManager.h
index f60d925ba6..5afc058d5f 100644
--- a/include/ImageManager.h
+++ b/include/ImageManager.h
@@ -17,20 +17,23 @@
 #ifndef IMAGE_MANAGER_H_
 #define IMAGE_MANAGER_H_
 
-#include "MadManager.h"
+#include "DriverManager.h"
+#include "ProtocolMessages.h"
 #include "ActionManager.h"
-#include "ImageManagerDriver.h"
 #include "NebulaLog.h"
 
-using namespace std;
-
 extern "C" void * image_action_loop(void *arg);
 
+class DatastorePool;
 class Image;
+class ImagePool;
 class Snapshots;
 class Template;
 
-class ImageManager : public MadManager, public ActionListener
+
+class ImageManager :
+    public DriverManager<Driver<image_msg_t>>,
+    public ActionListener
 {
 public:
 
@@ -38,9 +41,9 @@ public:
                  time_t                    _monitor_period,
                  ImagePool *               _ipool,
                  DatastorePool *           _dspool,
-                 vector<const VectorAttribute*>& _mads,
+                 const std::string&        _mads_location,
                  int                       _monitor_vm_disk):
-            MadManager(_mads),
+            DriverManager(_mads_location),
             timer_period(_timer_period),
             monitor_period(_monitor_period),
             monitor_vm_disk(_monitor_vm_disk),
@@ -62,11 +65,9 @@ public:
 
     /**
      *  Loads the Image Driver defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid=0);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Gets the thread identification.
@@ -99,7 +100,7 @@ public:
      *    @param attach true if attaching the image to a VM
      *    @return pointer to the image or 0 if could not be acquired
      */
-    Image * acquire_image(int vm_id, int image_id, bool attach, string& error);
+    Image * acquire_image(int vm_id, int image_id, bool attach, std::string& error);
 
     /**
      *  Try to acquire an image from the repository for a VM.
@@ -109,7 +110,8 @@ public:
      *    @param attach true if attaching the image to a VM
      *    @return pointer to the image or 0 if could not be acquired
      */
-    Image * acquire_image(int vm_id, const string& name, int uid, bool attach, string& error);
+    Image * acquire_image(int vm_id, const std::string& name,
+                          int uid, bool attach, std::string& error);
 
     /**
      *  Releases an image and triggers any needed operations in the repo
@@ -153,7 +155,7 @@ public:
      *    @param error_str Error reason, if any
      *    @return 0 on success
      */
-    int enable_image(int iid, bool to_enable, string& error_str);
+    int enable_image(int iid, bool to_enable, std::string& error_str);
 
     /**
      *  Adds a new image to the repository copying or creating it as needed
@@ -165,9 +167,9 @@ public:
      *    @return 0 on success
      */
     int register_image(int iid,
-                       const string& ds_data,
-                       const string& extra_data,
-                       string& error);
+                       const std::string& ds_data,
+                       const std::string& extra_data,
+                       std::string& error);
 
     /**
      * Checks if an image is ready to be cloned
@@ -177,7 +179,7 @@ public:
      *
      * @return 0 if the image can be cloned, -1 otherwise
      */
-    int can_clone_image(int cloning_id, ostringstream&  oss_error);
+    int can_clone_image(int cloning_id, std::ostringstream&  oss_error);
 
     /**
      * Sets the state to CLONE for the given image
@@ -225,9 +227,9 @@ public:
      */
     int clone_image(int new_id,
                     int cloning_id,
-                    const string& ds_data,
-                    const string& extra_data,
-                    string& error);
+                    const std::string& ds_data,
+                    const std::string& extra_data,
+                    std::string& error);
     /**
      *  Deletes an image from the repository and the DB. The Datastore image list
      *  is also updated
@@ -235,7 +237,7 @@ public:
      *    @param error_str Error reason, if any
      *    @return 0 on success
      */
-    int delete_image(int iid, string& error_str);
+    int delete_image(int iid, std::string& error_str);
 
     /**
      *  Gets the size of an image by calling the STAT action of the associated
@@ -247,7 +249,9 @@ public:
      *         occurred describing the error.
      *  @result 0 on success
      */
-     int stat_image(Template* img_tmpl, const string& ds_tmpl, string& res);
+     int stat_image(Template* img_tmpl,
+                    const std::string& ds_tmpl,
+                    std::string& res);
 
      /**
       *  Trigger a monitor action for the datastore.
@@ -284,7 +288,7 @@ public:
       *    @param error_str Error reason, if any
       *    @return 0 on success
       */
-     int delete_snapshot(int iid, int sid, string& error);
+     int delete_snapshot(int iid, int sid, std::string& error);
 
      /**
       *  Reverts image state to a previous snapshot
@@ -293,7 +297,7 @@ public:
       *    @param error_str Error reason, if any
       *    @return 0 on success
       */
-     int revert_snapshot(int iid, int sid, string& error);
+     int revert_snapshot(int iid, int sid, std::string& error);
 
      /**
       *  Flattens ths snapshot by commiting changes to base image.
@@ -302,13 +306,13 @@ public:
       *    @param error_str Error reason, if any
       *    @return 0 on success
       */
-     int flatten_snapshot(int iid, int sid, string& error);
+     int flatten_snapshot(int iid, int sid, std::string& error);
 
 private:
     /**
      *  Generic name for the Image driver
      */
-     static const char *  image_driver_name;
+    static const char *  image_driver_name;
 
     /**
      *  Thread id for the Image Manager
@@ -350,12 +354,9 @@ private:
      *  Returns a pointer to the Image Manager Driver used for the Repository
      *    @return the Image Manager driver or 0 in not found
      */
-    const ImageManagerDriver * get()
+    const Driver<image_msg_t> * get()
     {
-        string name("NAME");
-
-        return static_cast<const ImageManagerDriver *>
-               (MadManager::get(0,name,image_driver_name));
+        return DriverManager::get_driver(image_driver_name);
     };
 
     /**
@@ -369,7 +370,7 @@ private:
      *    @param action the name of the action
      *    @param arg arguments for the action function
      */
-    void do_action(const string& action, void * arg);
+    void do_action(const std::string& action, void * arg);
 
     /**
      *  Acquires an image updating its state.
@@ -377,14 +378,14 @@ private:
      *    @param attach true if attaching the image to a VM
      *    @return 0 on success
      */
-    int acquire_image(int vm_id, Image *img, bool attach, string& error);
+    int acquire_image(int vm_id, Image *img, bool attach, std::string& error);
 
     /**
      *  Moves a file to an image in the repository
      *    @param image to be updated (it's source attribute)
      *    @param source path of the disk file
      */
-    void move_image(Image *img, const string& source);
+    void move_image(Image *img, const std::string& source);
 
     /**
      * Formats an XML message for the MAD
@@ -394,9 +395,67 @@ private:
      *    @param extra_data additional XML formatted data for the driver
      *    @return the XML message
      */
-    static string * format_message(const string& img_data,
-            const string& ds_data,
-            const string& extra_data);
+    static std::string* format_message(const std::string& img_data,
+            const std::string& ds_data,
+            const std::string& extra_data);
+
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    /**
+     *
+     */
+    static void _undefined(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _stat(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _cp(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _clone(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _mkfs(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _rm(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _monitor(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _snap_delete(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _snap_revert(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    void _snap_flatten(unique_ptr<image_msg_t> msg);
+
+    /**
+     *
+     */
+    static void _log(unique_ptr<image_msg_t> msg);
 
     // -------------------------------------------------------------------------
     // Action Listener interface
@@ -406,10 +465,12 @@ private:
      */
     void timer_action(const ActionRequest& ar);
 
+    static const int drivers_timeout = 10;
+
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("ImM",Log::INFO,"Stopping Image Manager...");
-        MadManager::stop();
+        stop(drivers_timeout);
     };
 };
 
diff --git a/include/ImageManagerDriver.h b/include/ImageManagerDriver.h
deleted file mode 100644
index 36e9d1f800..0000000000
--- a/include/ImageManagerDriver.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef IMAGE_MANAGER_DRIVER_H_
-#define IMAGE_MANAGER_DRIVER_H_
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include "Mad.h"
-
-using namespace std;
-
-//Forward definition of related classes
-class ImagePool;
-class ImageManager;
-
-class DatastorePool;
-
-/**
- *  ImageManagerDriver represents the basic abstraction for Image Repository
- *  drivers. It implements the protocol and recover functions from the Mad
- *  interface.
- */
-class ImageManagerDriver : public Mad
-{
-public:
-
-    ImageManagerDriver(int        userid,
-                       const      map<string,string>& attrs,
-                       bool       sudo,
-                       ImagePool* _ipool,
-                       DatastorePool * _dspool):
-            Mad(userid,attrs,sudo),ipool(_ipool),dspool(_dspool){};
-
-    virtual ~ImageManagerDriver(){};
-
-    /**
-     *  Implements the Image Manager driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const string& message) const;
-
-    /**
-     *  TODO: What do we need here? Check on-going xfr?
-     */
-    void recover();
-
-private:
-    friend class ImageManager;
-
-    /**
-     *  Reference to the ImagePool
-     */
-    ImagePool * ipool;
-
-    /**
-     *  Reference to the DatastorePool
-     */
-    DatastorePool * dspool;
-
-    /**
-     * Sends a copy request to the MAD.
-     *    @param oid the image id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void cp(int oid, const string& drv_msg) const;
-
-    /**
-     * Sends a clone request to the MAD.
-     *    @param oid the image id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void clone(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a stat  request to the MAD.
-     *    @param oid the id of the stat request
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void stat(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a make filesystem request to the MAD.
-     *    @param oid the image id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void mkfs(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a delete request to the MAD: "DELETE IMAGE_ID PATH"
-     *    @param oid the image id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void rm(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a monitor request to the MAD: "MONITOR DS_ID DS_XML"
-     *    @param oid the datastore id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void monitor(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a delete snapshot command: "SNAP_DELETE DS_ID DS_XML"
-     *    @param oid the datastore id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void snapshot_delete(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a revert snapshot command: "SNAP_REVERT DS_ID DS_XML"
-     *    @param oid the datastore id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void snapshot_revert(int oid, const string& drv_msg) const;
-
-    /**
-     *  Sends a flatten snapshot command: "SNAP_FLATTEN DS_ID DS_XML"
-     *    @param oid the datastore id.
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void snapshot_flatten(int oid, const string& drv_msg) const;
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-#endif /*IMAGE_MANAGER_DRIVER_H_*/
-
diff --git a/include/ImagePool.h b/include/ImagePool.h
index 320b929a91..af72ccfd49 100644
--- a/include/ImagePool.h
+++ b/include/ImagePool.h
@@ -21,6 +21,7 @@
 #include "Image.h"
 #include "NebulaLog.h"
 #include "Datastore.h"
+#include "OneDB.h"
 
 #include <time.h>
 #include <sstream>
@@ -164,8 +165,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "IMAGE_POOL", "body", Image::table, where, sid,
-                eid, desc);
+        return PoolSQL::dump(oss, "IMAGE_POOL", "body", one_db::image_table,
+                             where, sid, eid, desc);
     }
 
     /**
diff --git a/include/InformationManager.h b/include/InformationManager.h
index 051ae7a178..88366d469d 100644
--- a/include/InformationManager.h
+++ b/include/InformationManager.h
@@ -19,7 +19,7 @@
 
 #include "DriverManager.h"
 #include "ActionManager.h"
-#include "OpenNebulaMessages.h"
+#include "ProtocolMessages.h"
 #include "RaftManager.h"
 
 class HostPool;
@@ -27,11 +27,10 @@ class Host;
 class VirtualMachinePool;
 
 class InformationManager :
-    public DriverManager<OpenNebulaMessages, Driver<OpenNebulaMessages>>,
+    public DriverManager<Driver<im_msg_t>>,
     public ActionListener
 {
 public:
-
     InformationManager(
         HostPool * _hpool,
         VirtualMachinePool * _vmpool,
@@ -104,22 +103,22 @@ protected:
     /**
      *  Received undefined message -> print error
      */
-    static void _undefined(unique_ptr<Message<OpenNebulaMessages>> msg);
+    static void _undefined(unique_ptr<im_msg_t> msg);
 
     /**
      *  Message HOST_STATE update from monitor
      */
-    void _host_state(unique_ptr<Message<OpenNebulaMessages>> msg);
+    void _host_state(unique_ptr<im_msg_t> msg);
 
     /**
      *  Message HOST_SYSTEM update from monitor
      */
-    void _host_system(unique_ptr<Message<OpenNebulaMessages>> msg);
+    void _host_system(unique_ptr<im_msg_t> msg);
 
     /**
      *  Message VM_STATE from monitor
      */
-    void _vm_state(unique_ptr<Message<OpenNebulaMessages>> msg);
+    void _vm_state(unique_ptr<im_msg_t> msg);
 
 private:
     /**
diff --git a/include/LibVirtDriver.h b/include/LibVirtDriver.h
index f8fc30f489..c80e7c4f68 100644
--- a/include/LibVirtDriver.h
+++ b/include/LibVirtDriver.h
@@ -19,22 +19,22 @@
 
 #include <map>
 #include <string>
-#include <sstream>
-
 #include "VirtualMachineManagerDriver.h"
 
 class LibVirtDriver : public VirtualMachineManagerDriver
 {
 public:
 
-    LibVirtDriver(int userid, const map<string,string> &attrs, bool sudo,
-        VirtualMachinePool * pool, const string& emu)
-        :VirtualMachineManagerDriver(userid, attrs,sudo,pool), emulator(emu)
-    {};
+    LibVirtDriver(const std::string& mad_location,
+                  const std::map<std::string, std::string> &attrs,
+                  const std::string& emu)
+        : VirtualMachineManagerDriver(mad_location, attrs), emulator(emu)
+    {}
 
-    ~LibVirtDriver(){};
+    ~LibVirtDriver() = default;
 
-    int validate_raw(const string& raw_section, string& error) const override;
+    int validate_raw(const std::string& raw_section,
+                     std::string& error) const override;
 
 private:
     static const float  CGROUP_BASE_CPU_SHARES;
@@ -47,7 +47,8 @@ private:
 
     static const char * XML_DOMAIN_RNG_PATH;
 
-    int deployment_description(const VirtualMachine * vm, const string& fn) const override
+    int deployment_description(const VirtualMachine * vm,
+                               const std::string& fn) const override
     {
         int   rc = -1;
 
@@ -59,9 +60,10 @@ private:
         return rc;
     }
 
-    int deployment_description_kvm(const VirtualMachine * v, const string& f) const;
+    int deployment_description_kvm(const VirtualMachine * v,
+                                   const std::string& f) const;
 
-    const string emulator;
+    const std::string emulator;
 };
 
 #endif /*LIBVIRT_DRIVER_H_*/
diff --git a/include/LogDB.h b/include/LogDB.h
index 2c911447c3..23558529ff 100644
--- a/include/LogDB.h
+++ b/include/LogDB.h
@@ -341,11 +341,6 @@ private:
     // -------------------------------------------------------------------------
     // DataBase implementation
     // -------------------------------------------------------------------------
-    static const char * table;
-
-    static const char * db_names;
-
-    static const char * db_bootstrap;
 
     /**
      *  Replicates writes in the followers and apply changes to DB state once
diff --git a/include/Mad.h b/include/Mad.h
deleted file mode 100644
index e060e28ed6..0000000000
--- a/include/Mad.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef MAD_H_
-#define MAD_H_
-
-#include <pthread.h>
-#include <sys/types.h>
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include <unistd.h>
-
-#include "Log.h"
-
-using namespace std;
-
-/**
- * Base class to build specific middleware access drivers (MAD).
- * This class provides generic MAD functionality.
- */
-class Mad
-{
-protected:
-    /**
-     *  The constructor initialize the class members but DOES NOT start the
-     *  driver. A subsequent call to the start() method is needed.
-     *    @param userid user running this MAD
-     *    @param attrs configuration attributes for the driver
-     *    @param sudo the driver is started through sudo if true
-     */
-    Mad(
-        int userid,
-        const map<string,string> &attrs,
-        bool sudo):
-            uid(userid),
-            attributes(attrs),
-            sudo_execution(sudo),
-            pid(-1)
-    {};
-
-    /**
-     *  The destructor of the class finalizes the driver process, and all its
-     *  associated resources (i.e. pipes)
-     */
-    virtual ~Mad();
-
-    /**
-     *  Send a command to the driver
-     *    @param os an output string stream with the message, it must be
-     *    terminated with the end of line character.
-     */
-    void write(
-        ostringstream&  os) const
-    {
-        string        str;
-        const char *  cstr;
-
-        str  = os.str();
-        cstr = str.c_str();
-
-        ::write(nebula_mad_pipe, cstr, str.size());
-    };
-
-    /**
-     *  Send a DRIVER_CANCEL command to the driver
-     *    @param oid identifies the action (that associated with oid)
-     */
-    void driver_cancel (const int oid) const
-    {
-        ostringstream os;
-
-        os << "DRIVER_CANCEL " << oid << endl;
-
-        write(os);
-    };
-
-    /**
-     *  Sets the log message type as specify by the driver.
-     *    @param first character of the type string
-     *    @return the message type
-     */
-    Log::MessageType log_type(const char r) const
-    {
-        Log::MessageType lt;
-
-        switch (r)
-        {
-            case 'E':
-                lt = Log::ERROR;
-                break;
-            case 'I':
-                lt = Log::INFO;
-                break;
-            case 'D':
-                lt = Log::DEBUG;
-                break;
-            default:
-                lt = Log::INFO;
-        }
-
-        return lt;
-    }
-
-    friend class MadManager;
-
-    /**
-     *  Communication pipe file descriptor. Represents the MAD to nebula
-     *  communication stream (nebula<-mad)
-     */
-    int                 mad_nebula_pipe;
-
-    /**
-     *  Communication pipe file descriptor. Represents the nebula to MAD
-     *  communication stream (nebula->mad)
-     */
-    int                 nebula_mad_pipe;
-
-private:
-    /**
-     *  User running this MAD as defined in the upool DB
-     */
-    int                 uid;
-
-    /**
-     *  Mad configuration attributes (e.g. executable, attributes...). Attribute
-     *  names MUST be lowecase.
-     */
-    map<string,string>  attributes;
-
-    /**
-     *  True if the mad is to be executed through sudo, with the identity of the
-     *  Mad owner (uid).
-     */
-    bool                sudo_execution;
-
-    /**
-     *  Process ID of the running MAD.
-     */
-    pid_t               pid;
-
-    /**
-     *  Starts the MAD. This function creates a new process, sets up the
-     *  communication pipes and sends the initialization command to the driver.
-     *    @return 0 on success
-     */
-    int start();
-
-    /**
-     *  Reloads the driver: sends the finalize command, "waits" for the
-     *  driver process and closes the communication pipes. Then the driver is
-     *  started again by calling the start() function
-     *    @return 0 on success
-     */
-    int reload();
-
-    /**
-     *  Implements the driver specific protocol, this function should trigger
-     *  actions on the associated manager.
-     *    @param message the string read from the driver
-     */
-    virtual void protocol(const string& message) const = 0;
-
-    /**
-     *  This function is called whenever the driver crashes. This function
-     *  should perform the actions needed to recover the VMs.
-     */
-    virtual void recover() = 0;
-};
-
-#endif /*MAD_H_*/
diff --git a/include/MadManager.h b/include/MadManager.h
deleted file mode 100644
index c7df34440d..0000000000
--- a/include/MadManager.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef MAD_MANAGER_H_
-#define MAD_MANAGER_H_
-
-#include <pthread.h>
-#include <sys/types.h>
-
-#include <string>
-#include <vector>
-#include <sstream>
-#include <vector>
-
-#include "Mad.h"
-#include "Attribute.h"
-
-using namespace std;
-
-class SyncRequest;
-
-extern "C" void * mad_manager_listener(void * _mm);
-
-/**
- * Provides general functionality for driver management. The MadManager serves
- * Nebula managers as base clase.
- */
-class MadManager
-{
-public:
-    /**
-     *  Function to initialize the MAD management system. This function
-     *  MUST be called once before using the MadManager class. This function
-     *  blocks the SIG_PIPE (broken pipe) signal that may occur when a driver
-     *  crashes
-     */
-    static void mad_manager_system_init();
-
-    /**
-     *  Loads Virtual Machine Manager Mads defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
-     */
-    virtual int load_mads(int uid) = 0;
-
-    /**
-     *  Notify the result of an auth request
-     */
-    void notify_request(int id, bool result, const string& message);
-
-protected:
-
-    MadManager(vector<const VectorAttribute *>& _mads);
-
-    virtual ~MadManager();
-
-    /**
-     *  Vector containing Mad configuration for this Manager, as described in
-     *  the nebula location
-     */
-    vector<const VectorAttribute *> mad_conf;
-
-    /**
-     *  This function initialize the communication pipes to register new MADs
-     *  in the manager, and starts a listener to wait for driver messages.
-     */
-    virtual int start();
-
-
-    /**
-     *  This function closes the communication pipes, stops the listener thread,
-     *  and finalize the associated drivers.
-     */
-    virtual void stop();
-
-    /**
-     *  Get a mad
-     */
-    virtual const Mad * get(int uid, const string& name, const string& value);
-
-    /**
-     *  Register a new mad in the manager. The Mad is previously started, and
-     *  then the listener thread is notified through the pipe_w stream. In case
-     *  of failure the calling function MUST free the Mad.
-     *    @param mad pointer to the mad to be added to the manager.
-     *    @return 0 on success.
-     */
-    int add(Mad *mad);
-
-    /**
-     *  This function can be periodically executed to check time_outs on
-     *  request. It will fail requests with an expired timeout and will notify
-     *  the clients.
-     */
-    void check_time_outs_action();
-
-    /**
-     *  Add a new request to the Request map
-     *    @param ar pointer to the request
-     *    @return the id for the request
-     */
-    void add_request(SyncRequest *ar);
-
-    /**
-     *  Gets request from the Request map
-     *    @param id for the request
-     *    @return pointer to the Request
-     */
-    SyncRequest * get_request(int id);
-
-private:
-    /**
-     *  Function to lock the Manager
-     */
-    void lock()
-    {
-        pthread_mutex_lock(&mutex);
-    };
-
-    /**
-     *  Function to unlock the Manager
-     */
-    void unlock()
-    {
-        pthread_mutex_unlock(&mutex);
-    };
-
-    /**
-     *  Function to execute the listener method within a new pthread (requires
-     *  C linkage)
-     */
-    friend void * mad_manager_listener(void * _mm);
-
-    /**
-     *  Synchronization mutex (listener & manager threads)
-     */
-    pthread_mutex_t         mutex;
-
-    /**
-     *  Thread id for the listener process
-     */
-    pthread_t               listener_thread;
-
-    /**
-     *  Communication pipe (read end) to link the Manager and the listener
-     *  thread
-     */
-    int                     pipe_r;
-
-    /**
-     *  Communication pipe (write end) to link the Manager and the listener
-     *  thread
-     */
-    int                     pipe_w;
-
-    /**
-     *  This vector contains the file descriptors of the driver pipes (to read
-     *  Mads responses)
-     */
-    vector<int>             fds;
-
-    /**
-     *  The sets of Mads managed by the MadManager
-     */
-    vector<Mad *>           mads;
-
-    /**
-     *  Read buffer for the listener. This variable is in the class so it
-     *  can be free upon listener thread cancellation.
-     */
-    ostringstream           buffer;
-
-    /**
-     *  List of pending requests
-     */
-    map<int, SyncRequest *> sync_requests;
-
-    /**
-     *  Listener thread implementation.
-     */
-    void listener();
-};
-
-#endif /*MAD_MANAGER_H_*/
diff --git a/include/MarketPlace.h b/include/MarketPlace.h
index 85b7cb6112..d8a9c50543 100644
--- a/include/MarketPlace.h
+++ b/include/MarketPlace.h
@@ -190,12 +190,6 @@ private:
     // DataBase implementation (Private)
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Builds the marketplace from the template. This function MUST be called
      *  with the template initialized
@@ -217,12 +211,7 @@ private:
      *  Bootstraps the database table(s) associated to the MarketPlace
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the MarketPlace in the database.
diff --git a/include/MarketPlaceApp.h b/include/MarketPlaceApp.h
index ba4ca6693c..9dc1990f95 100644
--- a/include/MarketPlaceApp.h
+++ b/include/MarketPlaceApp.h
@@ -361,12 +361,6 @@ private:
     // DataBase implementation (Private)
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Builds the market app from the template. This function MUST be called
      *  with apptemplate initialized
@@ -388,12 +382,7 @@ private:
      *  Bootstraps the database table(s) associated to the MarketPlace
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the MarketPlace in the database.
diff --git a/include/MarketPlaceAppPool.h b/include/MarketPlaceAppPool.h
index 0b842ca52f..d196bda453 100644
--- a/include/MarketPlaceAppPool.h
+++ b/include/MarketPlaceAppPool.h
@@ -18,13 +18,14 @@
 #define MARKETPLACEAPP_POOL_H_
 
 #include "MarketPlaceApp.h"
+#include "OneDB.h"
 
 class SqlDB;
 
 class MarketPlaceAppPool : public PoolSQL
 {
 public:
-    MarketPlaceAppPool(SqlDB * db):PoolSQL(db, MarketPlaceApp::table){};
+    MarketPlaceAppPool(SqlDB * db):PoolSQL(db, one_db::mp_app_table) {};
 
     ~MarketPlaceAppPool(){};
 
@@ -154,7 +155,7 @@ public:
         bool desc)
     {
         return PoolSQL::dump(oss, "MARKETPLACEAPP_POOL", "body",
-                MarketPlaceApp::table, where, sid, eid, desc);
+                             one_db::mp_app_table, where, sid, eid, desc);
     };
 
     /** Update a particular MarketPlaceApp
diff --git a/include/MarketPlaceManager.h b/include/MarketPlaceManager.h
index a53e61ff16..d811581231 100644
--- a/include/MarketPlaceManager.h
+++ b/include/MarketPlaceManager.h
@@ -17,9 +17,9 @@
 #ifndef MARKETPLACE_MANAGER_H_
 #define MARKETPLACE_MANAGER_H_
 
-#include "MadManager.h"
+#include "ProtocolMessages.h"
+#include "DriverManager.h"
 #include "ActionManager.h"
-#include "MarketPlaceManagerDriver.h"
 #include "NebulaLog.h"
 
 extern "C" void * marketplace_action_loop(void *arg);
@@ -32,7 +32,9 @@ class DatastorePool;
 class ImageManager;
 class RaftManager;
 
-class MarketPlaceManager : public MadManager, public ActionListener
+class MarketPlaceManager :
+    public DriverManager<Driver<market_msg_t>>,
+    public ActionListener
 {
 public:
 
@@ -42,7 +44,7 @@ public:
      *    @param m, monitor_period to monitor marketplaces
      *    @param mad, list of drivers for the manager
      */
-    MarketPlaceManager(time_t t, time_t m, std::vector<const VectorAttribute*>& mad);
+    MarketPlaceManager(time_t t, time_t m, const std::string& _mad_location);
 
     ~MarketPlaceManager(){};
 
@@ -62,11 +64,9 @@ public:
 
     /**
      *  Loads the MarketPlace Driver defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid=0);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Gets the thread identification.
@@ -190,12 +190,9 @@ private:
      *  Returns a pointer to the marketplace driver.
      *    @return the marketplace manager driver or 0 in not found
      */
-    const MarketPlaceManagerDriver * get()
+    const Driver<market_msg_t> * get()
     {
-        std::string name("NAME");
-
-        return static_cast<const MarketPlaceManagerDriver *>
-               (MadManager::get(0, name, market_driver_name));
+        return DriverManager::get_driver(market_driver_name);
     };
 
     /**
@@ -218,6 +215,15 @@ private:
             const std::string& market_data,
             const std::string& extra_data);
 
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    static void _undefined(unique_ptr<market_msg_t> msg);
+    void _import(unique_ptr<market_msg_t> msg);
+    void _delete(unique_ptr<market_msg_t> msg);
+    void _monitor(unique_ptr<market_msg_t> msg);
+    static void _log(unique_ptr<market_msg_t> msg);
+
     // -------------------------------------------------------------------------
     // Action Listener interface
     // -------------------------------------------------------------------------
@@ -226,10 +232,12 @@ private:
      */
     void timer_action(const ActionRequest& ar);
 
+    static const int drivers_timeout = 10;
+
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("MKP", Log::INFO, "Stopping Marketplace Manager...");
-        MadManager::stop();
+        DriverManager::stop(drivers_timeout);
     };
 };
 
diff --git a/include/MarketPlaceManagerDriver.h b/include/MarketPlaceManagerDriver.h
deleted file mode 100644
index d10b775712..0000000000
--- a/include/MarketPlaceManagerDriver.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef MARKETPLACE_MANAGER_DRIVER_H_
-#define MARKETPLACE_MANAGER_DRIVER_H_
-
-#include <map>
-#include <string>
-
-#include "Mad.h"
-
-class MarketPlacePool;
-class MarketPlaceAppPool;
-class MarketPlaceManager;
-
-/**
- *  ImageManagerDriver represents the basic abstraction for Image Repository
- *  drivers. It implements the protocol and recover functions from the Mad
- *  interface.
- */
-class MarketPlaceManagerDriver : public Mad
-{
-public:
-    MarketPlaceManagerDriver(int userid,
-        const std::map<string,string>& attrs,
-        bool sudo,
-        MarketPlacePool    * _marketpool,
-        MarketPlaceAppPool * _apppool,
-        MarketPlaceManager * _marketm
-       ):Mad(userid,attrs,sudo), marketpool(_marketpool), apppool(_apppool),
-         marketm(_marketm){};
-
-    virtual ~MarketPlaceManagerDriver(){};
-
-    /**
-     *  Implements the Image Manager driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const std::string& message) const;
-
-    /**
-     *  TODO: What do we need here? Check on-going xfr?
-     */
-    void recover();
-
-private:
-    friend class MarketPlaceManager;
-
-    /**
-     *  Reference to Marketplace related pools
-     */
-    MarketPlacePool    * marketpool;
-
-    MarketPlaceAppPool * apppool;
-
-    MarketPlaceManager * marketm;
-
-    /**
-     *  Imports a new object into the marketplace
-     *    @param oid of the app
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void importapp(int oid, const std::string& drv_msg) const;
-
-    /**
-     *  Deletes an app from the marketplace
-     *    @param oid of the app
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void deleteapp(int oid, const std::string& drv_msg) const;
-
-    /**
-     *  Monitors the marketplace
-     *    @param oid of the operation
-     *    @param drv_msg xml data for the mad operation.
-     */
-    void monitor(int oid, const std::string& drv_msg) const;
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-#endif /*MARKETPLACE_MANAGER_DRIVER_H_*/
-
diff --git a/include/MarketPlacePool.h b/include/MarketPlacePool.h
index 7214e72150..b2c8b3e595 100644
--- a/include/MarketPlacePool.h
+++ b/include/MarketPlacePool.h
@@ -19,6 +19,7 @@
 
 #include "MarketPlace.h"
 #include "PoolSQL.h"
+#include "OneDB.h"
 
 class MarketPlaceApp;
 
@@ -120,7 +121,7 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "MARKETPLACE_POOL", "body", MarketPlace::table,
+        return PoolSQL::dump(oss, "MARKETPLACE_POOL", "body", one_db::mp_table,
                 where, sid, eid, desc);
     };
 
@@ -132,7 +133,7 @@ public:
      */
      int list(std::vector<int>& oids)
      {
-        return PoolSQL::list(oids, MarketPlace::table);
+        return PoolSQL::list(oids, one_db::mp_table);
      }
 
     /**
diff --git a/src/monitor/include/Message.h b/include/Message.h
similarity index 67%
rename from src/monitor/include/Message.h
rename to include/Message.h
index af964492d1..04fd3bbbfe 100644
--- a/src/monitor/include/Message.h
+++ b/include/Message.h
@@ -14,8 +14,8 @@
 /* limitations under the License.                                             */
 /* -------------------------------------------------------------------------- */
 
-#ifndef MONITOR_MESSAGE_H
-#define MONITOR_MESSAGE_H
+#ifndef DRIVER_MESSAGE_H
+#define DRIVER_MESSAGE_H
 
 #include <unistd.h>
 
@@ -24,25 +24,7 @@
 #include <sstream>
 
 #include "EnumString.h"
-
-void base64_decode(const std::string& in, std::string& out);
-
-int base64_encode(const std::string& in, std::string &out);
-
-int zlib_decompress(const std::string& in, std::string& out);
-
-int zlib_compress(const std::string& in, std::string& out);
-
-/**
- *  Set path to public and private rsa keys
- */
-void init_rsa_keys(const std::string& pub_key, const std::string& pri_key);
-
-bool is_rsa_set();
-
-int rsa_public_encrypt(const std::string& in, std::string& out);
-
-int rsa_private_decrypt(const std::string& in, std::string& out);
+#include "SSLUtil.h"
 
 /**
  *  This class represents a generic message used by the Monitoring Protocol.
@@ -62,30 +44,40 @@ int rsa_private_decrypt(const std::string& in, std::string& out);
  *    '\n' End of message delimiter
  *
  */
-template<typename E>
+template<typename E, //Enum class for the message types
+         bool encode   = false, //Payload is base64 encoded
+         bool compress = false, //Payload is compressed
+         bool encrypt  = false, //Payload is encrypted
+         bool has_timestamp = false> //Message includes timestamp
 class Message
 {
 public:
+    using msg_enum = E;
+
+    Message() = default;
+
+    Message(E type, std::string &&status, int oid, const std::string& msg_payload);
+
     /**
      *  Parse the Message from an input string
      *    @param input string with the message
      */
-    int parse_from(const std::string& input, bool decrypt);
+    int parse_from(const std::string& input);
 
     /**
      *  Writes this object to the given string
      */
-    int write_to(std::string& out, bool encrypt) const;
+    int write_to(std::string& out) const;
 
     /**
      *  Writes this object to the given file descriptor
      */
-    int write_to(int fd, bool encrypt) const;
+    int write_to(int fd) const;
 
     /**
      *  Writes this object to the given output stream
      */
-    int write_to(std::ostream& oss, bool encrypt) const;
+    int write_to(std::ostream& oss) const;
 
     /**
      *
@@ -160,11 +152,13 @@ public:
      */
     time_t timestamp() const
     {
+        static_assert(has_timestamp == true, "Timestamp disabled");
         return _timestamp;
     }
 
     void timestamp(time_t ts)
     {
+        static_assert(has_timestamp == true, "Timestamp disabled");
         _timestamp = ts;
     }
 
@@ -187,15 +181,26 @@ private:
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
-/* Message Template Implementation                                             */
+/* Message Template Implementation                                            */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-int Message<E>::parse_from(const std::string& input, bool decrypt)
+template<typename E, bool compress, bool encode, bool encrypt, bool has_timestamp>
+Message<E, compress, encode, encrypt, has_timestamp>
+    ::Message(E type, std::string &&status, int oid, const std::string& payload)
+        : _type(type)
+        , _status(std::move(status))
+        , _oid(oid)
+        , _payload(payload)
+{
+}
+
+template<typename E, bool compress, bool encode, bool encrypt, bool has_timestamp>
+int Message<E, compress, encode, encrypt, has_timestamp>
+    ::parse_from(const std::string& input)
 {
     std::istringstream is(input);
-    std::string buffer, payloaz;
+    std::string buffer;
 
     if (!is.good())
     {
@@ -215,11 +220,14 @@ int Message<E>::parse_from(const std::string& input, bool decrypt)
 
     is >> _status;
 
-    is >> _oid;
+    is >> _oid >> std::ws;
 
-    is >> _timestamp;
+    if (has_timestamp)
+    {
+        is >> _timestamp >> std::ws;
+    }
 
-    is >> buffer;
+    getline(is, buffer);
 
     if (buffer.empty())
     {
@@ -227,19 +235,26 @@ int Message<E>::parse_from(const std::string& input, bool decrypt)
         return 0;
     }
 
-    base64_decode(buffer, payloaz);
-
-    if ( zlib_decompress(payloaz, _payload) == -1 )
+    if (encode)
     {
-        goto error;
-    }
+        ssl_util::base64_decode(buffer, _payload);
 
-    if ( decrypt && is_rsa_set() )
-    {
-        if ( rsa_private_decrypt(_payload, _payload) == -1 )
+        if ( compress && ssl_util::zlib_decompress(_payload, _payload) == -1 )
         {
             goto error;
         }
+
+        if ( encrypt && ssl_util::is_rsa_set() )
+        {
+            if ( ssl_util::rsa_private_decrypt(_payload, _payload) == -1 )
+            {
+                // Accept also not encrypted messages
+            }
+        }
+    }
+    else
+    {
+        _payload = buffer;
     }
 
     return 0;
@@ -253,49 +268,51 @@ error:
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-int Message<E>::write_to(std::string& out, bool encrypt) const
+template<typename E, bool compress, bool encode, bool encrypt, bool has_timestamp>
+int Message<E, compress, encode, encrypt, has_timestamp>
+    ::write_to(std::string& out) const
 {
     out.clear();
 
-    std::string secret;
-    std::string payloaz;
-    std::string payloaz64;
-
-    if (!_payload.empty())
-    {
-        if (encrypt)
-        {
-            if (rsa_public_encrypt(_payload, secret) != 0)
-            {
-                return -1;
-            }
-        }
-        else
-        {
-            secret = _payload;
-        }
-
-        if (zlib_compress(secret, payloaz) == -1)
-        {
-            return -1;
-        }
-
-        if ( base64_encode(payloaz, payloaz64) == -1)
-        {
-            return -1;
-        }
-    }
-
     out = _type_str._to_str(_type);
     out += ' ';
-    out += _status.empty() ? "-" : _status;
+    out += _status;
     out += ' ';
     out += std::to_string(_oid);
     out += ' ';
-    out += std::to_string(_timestamp);
-    out += ' ';
-    out += payloaz64;
+
+    if (has_timestamp)
+    {
+        out += std::to_string(_timestamp);
+        out += ' ';
+    }
+
+    if (!_payload.empty())
+    {
+        if (encode)
+        {
+            std::string msg;
+
+            msg = _payload;
+
+            if (compress && ssl_util::zlib_compress(msg, msg) == -1)
+            {
+                return -1;
+            }
+
+            if ( ssl_util::base64_encode(msg, msg) == -1)
+            {
+                return -1;
+            }
+
+            out += msg;
+        }
+        else
+        {
+            out += _payload;
+        }
+    }
+
     out += '\n';
 
     return 0;
@@ -304,12 +321,13 @@ int Message<E>::write_to(std::string& out, bool encrypt) const
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-int Message<E>::write_to(int fd, bool encrypt) const
+template<typename E, bool compress, bool encode, bool encrypt, bool has_timestamp>
+int Message<E, compress, encode, encrypt, has_timestamp>
+    ::write_to(int fd) const
 {
     std::string out;
 
-    if ( write_to(out, encrypt) == -1)
+    if ( write_to(out) == -1)
     {
         return -1;
     }
@@ -322,12 +340,13 @@ int Message<E>::write_to(int fd, bool encrypt) const
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-int Message<E>::write_to(std::ostream& oss, bool encrypt) const
+template<typename E, bool compress, bool encode, bool encrypt, bool has_timestamp>
+int Message<E, compress, encode, encrypt, has_timestamp>
+    ::write_to(std::ostream& oss) const
 {
     std::string out;
 
-    if ( write_to(out, encrypt) == -1)
+    if ( write_to(out) == -1)
     {
         return -1;
     }
@@ -337,4 +356,4 @@ int Message<E>::write_to(std::ostream& oss, bool encrypt) const
     return 0;
 }
 
-#endif /*MONITOR_MESSAGE_H_*/
+#endif /*DRIVER_MESSAGE_H_*/
diff --git a/include/OneDB.h b/include/OneDB.h
index 8d4556d9a3..5514e2c1f8 100644
--- a/include/OneDB.h
+++ b/include/OneDB.h
@@ -38,7 +38,7 @@ namespace one_db
     extern const char * host_monitor_db_bootstrap;
 
     /* ---------------------------------------------------------------------- */
-    /* VM TABLES                                                            */
+    /* VM TABLES                                                              */
     /* ---------------------------------------------------------------------- */
     extern const char * vm_table;
 
@@ -58,6 +58,18 @@ namespace one_db
 
     extern const char * vm_showback_db_bootstrap;
 
+    extern const char * vm_group_db_names;
+
+    extern const char * vm_group_db_bootstrap;
+
+    extern const char * vm_group_table;
+
+    extern const char * vm_template_db_names;
+
+    extern const char * vm_template_db_bootstrap;
+
+    extern const char * vm_template_table;
+
     // -------------------------------------------------------------------------
     // Virtual Machine ID - Deploy ID index for imported VMs
     // The index is managed by the VirtualMachinePool
@@ -67,6 +79,190 @@ namespace one_db
     extern const char * vm_import_db_names;
 
     extern const char * vm_import_db_bootstrap;
+
+    /* ---------------------------------------------------------------------- */
+    /* Cluster tables                                                         */
+    /* ---------------------------------------------------------------------- */
+    extern const char * cluster_db_names;
+    extern const char * cluster_db_bootstrap;
+    extern const char * cluster_table;
+
+    extern const char * cluster_datastore_table;
+    extern const char * cluster_datastore_db_names;
+    extern const char * cluster_datastore_db_bootstrap;
+
+    extern const char * cluster_network_table;
+    extern const char * cluster_network_db_names;
+    extern const char * cluster_network_db_bootstrap;
+
+    extern const char * cluster_bitmap_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* ACL tables                                                             */
+    /* ---------------------------------------------------------------------- */
+    extern const char * acl_table;
+
+    extern const char * acl_db_names;
+
+    extern const char * acl_db_bootstrap;
+
+    /* ---------------------------------------------------------------------- */
+    /* Datastore tables                                                       */
+    /* ---------------------------------------------------------------------- */
+    extern const char * ds_db_names;
+
+    extern const char * ds_db_bootstrap;
+
+    extern const char * ds_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Document tables                                                        */
+    /* ---------------------------------------------------------------------- */
+    extern const char * doc_db_names;
+
+    extern const char * doc_db_bootstrap;
+
+    extern const char * doc_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Group tables                                                           */
+    /* ---------------------------------------------------------------------- */
+    extern const char * group_db_names;
+
+    extern const char * group_db_bootstrap;
+
+    extern const char * group_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* History tables                                                         */
+    /* ---------------------------------------------------------------------- */
+    extern const char * history_table;
+
+    extern const char * history_db_names;
+
+    extern const char * history_db_bootstrap;
+
+    /* ---------------------------------------------------------------------- */
+    /* Hook tables                                                            */
+    /* ---------------------------------------------------------------------- */
+    extern const char * hook_db_names;
+
+    extern const char * hook_db_bootstrap;
+
+    extern const char * hook_table;
+
+    extern const char * hook_log_table;
+
+    extern const char * hook_log_db_names;
+
+    extern const char * hook_log_db_bootstrap;
+
+    /* ---------------------------------------------------------------------- */
+    /* Image tables                                                           */
+    /* ---------------------------------------------------------------------- */
+    extern const char * image_db_names;
+
+    extern const char * image_db_bootstrap;
+
+    extern const char * image_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Log tables                                                             */
+    /* ---------------------------------------------------------------------- */
+    extern const char * log_table;
+
+    extern const char * log_db_names;
+
+    extern const char * log_db_bootstrap;
+
+    /* ---------------------------------------------------------------------- */
+    /* Marketplace tables                                                     */
+    /* ---------------------------------------------------------------------- */
+    extern const char * mp_db_names;
+
+    extern const char * mp_db_bootstrap;
+
+    extern const char * mp_table;
+
+    extern const char * mp_app_db_names;
+
+    extern const char * mp_app_db_bootstrap;
+
+    extern const char * mp_app_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Quotas tables                                                          */
+    /* ---------------------------------------------------------------------- */
+    extern const char * group_quotas_db_names;
+    extern const char * group_quotas_db_bootstrap;
+    extern const char * group_quotas_db_table;
+    extern const char * group_quotas_db_oid_column;
+
+    extern const char * user_quotas_db_names;
+    extern const char * user_quotas_db_bootstrap;
+    extern const char * user_quotas_db_table;
+    extern const char * user_quotas_db_oid_column;
+
+    /* ---------------------------------------------------------------------- */
+    /* Security Group tables                                                  */
+    /* ---------------------------------------------------------------------- */
+    extern const char * sg_db_names;
+
+    extern const char * sg_db_bootstrap;
+
+    extern const char * sg_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* User tables                                                            */
+    /* ---------------------------------------------------------------------- */
+    extern const char * user_db_names;
+
+    extern const char * user_db_bootstrap;
+
+    extern const char * user_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* VDC tables                                                             */
+    /* ---------------------------------------------------------------------- */
+    extern const char * vdc_db_names;
+
+    extern const char * vdc_db_bootstrap;
+
+    extern const char * vdc_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Virtual Network tables                                                 */
+    /* ---------------------------------------------------------------------- */
+    extern const char * vn_table;
+
+    extern const char * vn_db_names;
+
+    extern const char * vn_db_bootstrap;
+
+    extern const char * vn_template_db_names;
+
+    extern const char * vn_template_db_bootstrap;
+
+    extern const char * vn_template_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Virtual Router tables                                                  */
+    /* ---------------------------------------------------------------------- */
+    extern const char * vr_db_names;
+
+    extern const char * vr_db_bootstrap;
+
+    extern const char * vr_table;
+
+    /* ---------------------------------------------------------------------- */
+    /* Zone tables                                                            */
+    /* ---------------------------------------------------------------------- */
+    extern const char * zone_db_names;
+
+    extern const char * zone_db_bootstrap;
+
+    extern const char * zone_table;
 }
 
+
 #endif /*ONE_DB_H_*/
diff --git a/include/QuotasSQL.h b/include/QuotasSQL.h
index a959510752..5221ef9931 100644
--- a/include/QuotasSQL.h
+++ b/include/QuotasSQL.h
@@ -19,6 +19,7 @@
 
 #include "Quotas.h"
 #include "ObjectSQL.h"
+#include "OneDB.h"
 
 class QuotasSQL : public Quotas, ObjectSQL
 {
@@ -165,7 +166,7 @@ public:
      */
     static int bootstrap(SqlDB * db)
     {
-        ostringstream oss_quota(GroupQuotas::db_bootstrap);
+        ostringstream oss_quota(one_db::group_quotas_db_bootstrap);
 
         return db->exec_local_wr(oss_quota);
     };
@@ -174,30 +175,23 @@ protected:
 
     const char * table() const
     {
-        return db_table;
+        return one_db::group_quotas_db_table;
     };
 
     const char * table_names() const
     {
-        return db_names;
+        return one_db::group_quotas_db_names;
     };
 
     const char * table_oid_column() const
     {
-        return db_oid_column;
+        return one_db::group_quotas_db_oid_column;
     };
 
 private:
 
     friend class GroupPool;
 
-    // *************************************************************************
-    // DataBase implementation
-    // *************************************************************************
-    static const char * db_names;
-    static const char * db_bootstrap;
-    static const char * db_table;
-    static const char * db_oid_column;
 };
 
 /* -------------------------------------------------------------------------- */
@@ -218,7 +212,7 @@ public:
      */
     static int bootstrap(SqlDB * db)
     {
-        ostringstream oss_quota(UserQuotas::db_bootstrap);
+        ostringstream oss_quota(one_db::user_quotas_db_bootstrap);
 
         return db->exec_local_wr(oss_quota);
     };
@@ -227,30 +221,22 @@ protected:
 
     const char * table() const
     {
-        return db_table;
+        return one_db::user_quotas_db_table;
     };
 
     const char * table_names() const
     {
-        return db_names;
+        return one_db::user_quotas_db_names;
     };
 
     const char * table_oid_column() const
     {
-        return db_oid_column;
+        return one_db::user_quotas_db_oid_column;
     };
 
 private:
 
     friend class UserPool;
-
-    // *************************************************************************
-    // DataBase implementation
-    // *************************************************************************
-    static const char * db_names;
-    static const char * db_bootstrap;
-    static const char * db_table;
-    static const char * db_oid_column;
 };
 
 #endif /*QUOTAS_SQL_H_*/
diff --git a/src/monitor/include/OpenNebulaMessages.h b/include/SSLUtil.h
similarity index 60%
rename from src/monitor/include/OpenNebulaMessages.h
rename to include/SSLUtil.h
index 2b638c8dbd..4b84b2c330 100644
--- a/src/monitor/include/OpenNebulaMessages.h
+++ b/include/SSLUtil.h
@@ -1,5 +1,5 @@
 /* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/* Copyright 2002-2019, OpenNebula Project, OpenNebula Systems                */
 /*                                                                            */
 /* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
 /* not use this file except in compliance with the License. You may obtain    */
@@ -14,31 +14,31 @@
 /* limitations under the License.                                             */
 /* -------------------------------------------------------------------------- */
 
-#ifndef OPENNEBULA_MESSAGES_H
-#define OPENNEBULA_MESSAGES_H
+#ifndef SSL_UTIL_H
+#define SSL_UTIL_H
 
-#include "StreamManager.h"
+#include <string>
 
-/**
- * Messages between the Monitor daemon and OpenNebula daemon
- */
-enum class OpenNebulaMessages : unsigned short int
+namespace ssl_util
 {
-    UNDEFINED = 0,
-    INIT,
-    FINALIZE,
-    HOST_LIST,
-    UPDATE_HOST,
-    DEL_HOST,
-    START_MONITOR,
-    STOP_MONITOR,
-    HOST_STATE,
-    VM_STATE,
-    HOST_SYSTEM,
-    RAFT_STATUS,
-    ENUM_MAX
-};
+    void base64_decode(const std::string& in, std::string& out);
 
-typedef StreamManager<OpenNebulaMessages> one_stream_t;
+    int base64_encode(const std::string& in, std::string &out);
 
-#endif /*OPENNEBULA_MESSAGES_H*/
+    int zlib_decompress(const std::string& in, std::string& out);
+
+    int zlib_compress(const std::string& in, std::string& out);
+
+    /**
+     *  Set path to public and private rsa keys
+     */
+    void init_rsa_keys(const std::string& pub_key, const std::string& pri_key);
+
+    bool is_rsa_set();
+
+    int rsa_public_encrypt(const std::string& in, std::string& out);
+
+    int rsa_private_decrypt(const std::string& in, std::string& out);
+} // namespace ssl_util
+
+#endif /*SSL_UTIL_H_*/
diff --git a/include/SecurityGroup.h b/include/SecurityGroup.h
index 9efd020008..13dac29dd3 100644
--- a/include/SecurityGroup.h
+++ b/include/SecurityGroup.h
@@ -194,12 +194,6 @@ private:
     // DataBase implementation (Private)
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Execute an INSERT or REPLACE Sql query.
      *    @param db The SQL DB
@@ -213,12 +207,7 @@ private:
      *  Bootstraps the database table(s) associated to the SecurityGroup
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(SecurityGroup::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the SecurityGroup in the database.
diff --git a/include/SecurityGroupPool.h b/include/SecurityGroupPool.h
index 2b4f2b10c1..d12670029f 100644
--- a/include/SecurityGroupPool.h
+++ b/include/SecurityGroupPool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "SecurityGroup.h"
+#include "OneDB.h"
 
 using namespace std;
 
@@ -115,7 +116,7 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "SECURITY_GROUP_POOL", "body", SecurityGroup::table,
+        return PoolSQL::dump(oss, "SECURITY_GROUP_POOL", "body", one_db::sg_table,
                 where, sid, eid, desc);
     };
 
diff --git a/include/SyncRequest.h b/include/SyncRequest.h
index c171262ad1..cba5c6e1b3 100644
--- a/include/SyncRequest.h
+++ b/include/SyncRequest.h
@@ -86,15 +86,13 @@ public:
         am.loop(t);
     };
 
-protected:
-
-    friend class MadManager;
-
     /**
      *  Time in seconds when this request will expire
      */
     time_t  time_out;
 
+protected:
+
     /**
      *  The ActionManager that will be notify when the request is ready.
      */
diff --git a/include/TransferManager.h b/include/TransferManager.h
index 80ccf33b10..a380165c60 100644
--- a/include/TransferManager.h
+++ b/include/TransferManager.h
@@ -17,17 +17,16 @@
 #ifndef TRANSFER_MANAGER_H_
 #define TRANSFER_MANAGER_H_
 
-#include "MadManager.h"
+#include "ProtocolMessages.h"
+#include "DriverManager.h"
 #include "ActionManager.h"
-#include "VirtualMachinePool.h"
-#include "LifeCycleManager.h"
-#include "TransferManagerDriver.h"
-
-using namespace std;
 
 extern "C" void * tm_action_loop(void *arg);
 
+class HostPool;
+class VirtualMachine;
 class VirtualMachineDisk;
+class VirtualMachinePool;
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -85,15 +84,17 @@ private:
     int     _vm_id;
 };
 
-class TransferManager : public MadManager, public ActionListener
+class TransferManager :
+    public DriverManager<Driver<transfer_msg_t>>,
+    public ActionListener
 {
 public:
 
     TransferManager(
         VirtualMachinePool * _vmpool,
         HostPool *           _hpool,
-        vector<const VectorAttribute*>& _mads):
-            MadManager(_mads),
+        const std::string&   _mad_location):
+            DriverManager(_mad_location),
             vmpool(_vmpool),
             hpool(_hpool)
     {
@@ -130,12 +131,10 @@ public:
     int start();
 
     /**
-     *  Loads Virtual Machine Manager Mads defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *  Loads Transfer Manager Drivers in configuration file
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Gets the thread identification.
@@ -162,10 +161,10 @@ public:
     int prolog_transfer_command(
             VirtualMachine *        vm,
             const VirtualMachineDisk* disk,
-            string&                 system_tm_mad,
-            string&                 opennebula_hostname,
-            ostream&                xfr,
-            ostringstream&          error);
+            std::string&            system_tm_mad,
+            std::string&            opennebula_hostname,
+            std::ostream&           xfr,
+            std::ostringstream&     error);
 
     /**
      * Inserts a context command in the xfs stream
@@ -180,10 +179,10 @@ public:
      */
     int prolog_context_command(
             VirtualMachine *        vm,
-            const string&           token_password,
-            string&                 system_tm_mad,
+            const std::string&      token_password,
+            std::string&            system_tm_mad,
             int&                    disk_id,
-            ostream&                xfr);
+            std::ostream&           xfr);
 
     /**
      * Inserts a transfer command in the xfs stream
@@ -196,9 +195,9 @@ public:
      */
     void epilog_transfer_command(
             VirtualMachine *        vm,
-            const string&           host,
+            const std::string&      host,
             const VirtualMachineDisk * disk,
-            ostream&                xfr);
+            std::ostream&           xfr);
     /**
      * Inserts a transfer command in the xfs stream, for live migration
      *
@@ -207,7 +206,7 @@ public:
      */
     void migrate_transfer_command(
         VirtualMachine *        vm,
-        ostream&                xfr);
+        std::ostream&           xfr);
 
     /**
      *  This function generates the epilog_delete sequence for current,
@@ -220,7 +219,7 @@ public:
      *    @return 0 on success
      */
     int epilog_delete_commands(VirtualMachine *vm,
-                               ostream&        xfr,
+                               std::ostream&   xfr,
                                bool            local,
                                bool            previous);
     /**
@@ -233,7 +232,7 @@ public:
      */
     int snapshot_transfer_command(VirtualMachine * vm,
                                   const char * snap_action,
-                                  ostream& xfr);
+                                  std::ostream& xfr);
 
     /**
      *  Inserts a resize command in the xfr stream
@@ -244,7 +243,7 @@ public:
     void resize_command(
             VirtualMachine *           vm,
             const VirtualMachineDisk * disk,
-            ostream&                   xfr);
+            std::ostream&              xfr);
 private:
     /**
      *  Thread id for the Transfer Manager
@@ -271,21 +270,6 @@ private:
      */
      static const char *  transfer_driver_name;
 
-    /**
-     *  Returns a pointer to a Transfer Manager driver.
-     *    @param name of an attribute of the driver (e.g. its type)
-     *    @param value of the attribute
-     *    @return the TM driver owned by uid with attribute name equal to value
-     *    or 0 in not found
-     */
-    const TransferManagerDriver * get(
-        const string&   name,
-        const string&   value)
-    {
-        return static_cast<const TransferManagerDriver *>
-               (MadManager::get(0,name,value));
-    };
-
     /**
      *  Returns a pointer to a Transfer Manager driver. The driver is
      *  searched by its name.
@@ -293,12 +277,9 @@ private:
      *    @return the TM driver owned by uid with attribute name equal to value
      *    or 0 in not found
      */
-    const TransferManagerDriver * get(
-        const string&   name)
+    const Driver<transfer_msg_t> * get(const std::string& name)
     {
-        string _name("NAME");
-        return static_cast<const TransferManagerDriver *>
-               (MadManager::get(0,_name,name));
+        return DriverManager::get_driver(name);
     };
 
     /**
@@ -306,11 +287,9 @@ private:
      *  searched by its name.
      *    @return the TM driver for the Transfer Manager
      */
-    const TransferManagerDriver * get()
+    const Driver<transfer_msg_t> * get()
     {
-        string _name("NAME");
-        return static_cast<const TransferManagerDriver *>
-               (MadManager::get(0,_name,transfer_driver_name));
+        return DriverManager::get_driver(transfer_driver_name);
     };
 
     /**
@@ -319,14 +298,23 @@ private:
      */
     friend void * tm_action_loop(void *arg);
 
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    static void _undefined(unique_ptr<transfer_msg_t> msg);
+    void _transfer(unique_ptr<transfer_msg_t> msg);
+    static void _log(unique_ptr<transfer_msg_t> msg);
+
     // -------------------------------------------------------------------------
     // Action Listener interface
     // -------------------------------------------------------------------------
+    static const int drivers_timeout = 10;
+
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("TM",Log::INFO,"Stopping Transfer Manager...");
 
-        MadManager::stop();
+        DriverManager::stop(drivers_timeout);
     };
 
     void user_action(const ActionRequest& ar);
diff --git a/include/TransferManagerDriver.h b/include/TransferManagerDriver.h
deleted file mode 100644
index a0ede7fe99..0000000000
--- a/include/TransferManagerDriver.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#ifndef TRANSFER_MANAGER_DRIVER_H_
-#define TRANSFER_MANAGER_DRIVER_H_
-
-#include <map>
-#include <string>
-#include <sstream>
-
-#include "Mad.h"
-#include "VirtualMachinePool.h"
-
-using namespace std;
-
-/**
- *  TransferManagerDriver provides a base class to implement TM
- *  Drivers. This class implements the protocol and recover functions
- *  from the Mad interface.
- */
-class TransferManagerDriver : public Mad
-{
-public:
-
-    TransferManagerDriver(
-        int                         userid,
-        const map<string,string>&   attrs,
-        bool                        sudo,
-        VirtualMachinePool *        pool):
-            Mad(userid,attrs,sudo), vmpool(pool){};
-
-    virtual ~TransferManagerDriver(){};
-
-    /**
-     *  Implements the VM Manager driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const string& message) const;
-
-    /**
-     *  TODO: What do we need here? Check on-going xfr?
-     */
-    void recover();
-
-private:
-    friend class TransferManager;
-
-    /**
-     *  Pointer to the Virtual Machine Pool, to access VMs
-     */
-    VirtualMachinePool * vmpool;
-
-    /**
-     *  Sends a transfer request to the MAD: "TRANSFER    ID    XFR_FILE"
-     *    @param oid the virtual machine id.
-     *    @param xfr_file is the path to the transfer script
-     */
-    void transfer (const int oid, const string& xfr_file) const;
-};
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-#endif /*TRANSFER_MANAGER_DRIVER_H_*/
-
diff --git a/include/User.h b/include/User.h
index 387e421b97..2c880910a0 100644
--- a/include/User.h
+++ b/include/User.h
@@ -323,7 +323,7 @@ private:
      */
     static int bootstrap(SqlDB * db)
     {
-        ostringstream oss_user(User::db_bootstrap);
+        ostringstream oss_user(one_db::user_db_bootstrap);
 
         return db->exec_local_wr(oss_user);
     }
@@ -382,7 +382,7 @@ protected:
          const string& _password,
          const string& _auth_driver,
          bool          _enabled):
-        PoolObjectSQL(id,USER,_uname,-1,_gid,"",_gname,table),
+        PoolObjectSQL(id,USER,_uname,-1,_gid,"",_gname,one_db::user_table),
         quota(),
         password(_password),
         auth_driver(_auth_driver),
@@ -399,12 +399,6 @@ protected:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Writes the User in the database.
      *    @param db pointer to the db
diff --git a/include/VMActions.h b/include/VMActions.h
index 7e4120d891..b769f11442 100644
--- a/include/VMActions.h
+++ b/include/VMActions.h
@@ -80,7 +80,7 @@ public:
         POFF_HARD_MIGRATE_ACTION = 49       // "one.vm.migrate"
     };
 
-    static string action_to_str(Action action);
+    static std::string action_to_str(Action action);
 
     static int action_from_str(const string& st, Action& action);
 
@@ -116,7 +116,7 @@ public:
     /**
      *  Sets the auth operations based on the provided template
      */
-    int set_auth_ops(const Template& tmpl, string& error);
+    int set_auth_ops(const Template& tmpl, std::string& error);
 
 private:
     /**
diff --git a/include/VMGroup.h b/include/VMGroup.h
index 26d7007894..95d8644b67 100644
--- a/include/VMGroup.h
+++ b/include/VMGroup.h
@@ -143,11 +143,6 @@ private:
     // -------------------------------------------------------------------------
     // DataBase implementation
     // -------------------------------------------------------------------------
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
 
     /**
      *  Execute an INSERT or REPLACE Sql query.
@@ -162,12 +157,7 @@ private:
      *  Bootstraps the database table(s) associated to the VMGroup
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(VMGroup::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the VMGroup in the database.
diff --git a/include/VMGroupPool.h b/include/VMGroupPool.h
index 7630f0b005..2ffd89ecd9 100644
--- a/include/VMGroupPool.h
+++ b/include/VMGroupPool.h
@@ -19,13 +19,14 @@
 
 #include "PoolSQL.h"
 #include "VMGroup.h"
+#include "OneDB.h"
 
 class AuthRequest;
 
 class VMGroupPool : public PoolSQL
 {
 public:
-    VMGroupPool(SqlDB * db):PoolSQL(db, VMGroup::table){};
+    VMGroupPool(SqlDB * db):PoolSQL(db, one_db::vm_group_table){};
 
     ~VMGroupPool(){};
 
@@ -108,8 +109,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "VM_GROUP_POOL", "body", VMGroup::table, where,
-                sid, eid, desc);
+        return PoolSQL::dump(oss, "VM_GROUP_POOL", "body",
+            one_db::vm_group_table, where, sid, eid, desc);
     };
 
     /**
diff --git a/include/VMTemplate.h b/include/VMTemplate.h
index 4cdd77aea9..4cc7a4e343 100644
--- a/include/VMTemplate.h
+++ b/include/VMTemplate.h
@@ -152,12 +152,7 @@ private:
      *  Bootstraps the database table(s) associated to the VMTemplate
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(VMTemplate::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Rebuilds the object from an xml formatted string
@@ -191,12 +186,6 @@ protected:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Writes the VMTemplate in the database.
      *    @param db pointer to the db
diff --git a/include/VMTemplatePool.h b/include/VMTemplatePool.h
index e013067705..a27dee0dd1 100644
--- a/include/VMTemplatePool.h
+++ b/include/VMTemplatePool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "VMTemplate.h"
+#include "OneDB.h"
 
 /**
  *  The VMTemplate Pool class.
@@ -27,7 +28,7 @@ class VMTemplatePool : public PoolSQL
 {
 public:
 
-    VMTemplatePool(SqlDB * db) : PoolSQL(db, VMTemplate::table){};
+    VMTemplatePool(SqlDB * db) : PoolSQL(db, one_db::vm_template_table){};
 
     ~VMTemplatePool(){};
 
@@ -93,8 +94,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "VMTEMPLATE_POOL", "body", VMTemplate::table,
-                where, sid, eid, desc);
+        return PoolSQL::dump(oss, "VMTEMPLATE_POOL", "body",
+            one_db::vm_template_table, where, sid, eid, desc);
     };
 
     /**
diff --git a/include/VNTemplate.h b/include/VNTemplate.h
index ab1f0f2247..307715886d 100644
--- a/include/VNTemplate.h
+++ b/include/VNTemplate.h
@@ -92,12 +92,7 @@ private:
      *  Bootstraps the database table(s) associated to the VNTemplate
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(VNTemplate::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Rebuilds the object from an xml formatted string
@@ -126,12 +121,6 @@ protected:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Writes the VNTemplate in the database.
      *    @param db pointer to the db
diff --git a/include/VNTemplatePool.h b/include/VNTemplatePool.h
index 57d0c92a95..035b49aed9 100644
--- a/include/VNTemplatePool.h
+++ b/include/VNTemplatePool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "VNTemplate.h"
+#include "OneDB.h"
 
 /**
  *  The VNetTemplate Pool class.
@@ -27,7 +28,7 @@ class VNTemplatePool : public PoolSQL
 {
 public:
 
-    VNTemplatePool(SqlDB * db) : PoolSQL(db, VNTemplate::table){};
+    VNTemplatePool(SqlDB * db) : PoolSQL(db, one_db::vn_template_table){};
 
     ~VNTemplatePool(){};
 
@@ -93,8 +94,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "VNTEMPLATE_POOL", "body", VNTemplate::table,
-                where, sid, eid, desc);
+        return PoolSQL::dump(oss, "VNTEMPLATE_POOL", "body",
+                             one_db::vn_template_table, where, sid, eid, desc);
     };
 
     /**
diff --git a/include/Vdc.h b/include/Vdc.h
index fb85135bc7..b2b8e120df 100644
--- a/include/Vdc.h
+++ b/include/Vdc.h
@@ -341,12 +341,6 @@ private:
     // DataBase implementation (Private)
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Execute an INSERT or REPLACE Sql query.
      *    @param db The SQL DB
@@ -360,12 +354,7 @@ private:
      *  Bootstraps the database table(s) associated to the Vdc
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(Vdc::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the Vdc in the database.
diff --git a/include/VdcPool.h b/include/VdcPool.h
index 076110acec..8a2cc2a92b 100644
--- a/include/VdcPool.h
+++ b/include/VdcPool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "Vdc.h"
+#include "OneDB.h"
 
 using namespace std;
 
@@ -99,8 +100,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "VDC_POOL", "body", Vdc::table, where, sid,
-                eid, desc);
+        return PoolSQL::dump(oss, "VDC_POOL", "body", one_db::vdc_table,
+                             where, sid, eid, desc);
     };
 
     /**
@@ -111,7 +112,7 @@ public:
      */
      int list(std::vector<int>& oids)
      {
-        return PoolSQL::list(oids, Vdc::table);
+        return PoolSQL::list(oids, one_db::vdc_table);
      }
 
     /**
diff --git a/include/VirtualMachineManager.h b/include/VirtualMachineManager.h
index fd2af01018..f9dabf5597 100644
--- a/include/VirtualMachineManager.h
+++ b/include/VirtualMachineManager.h
@@ -17,15 +17,13 @@
 #ifndef VIRTUAL_MACHINE_MANAGER_H_
 #define VIRTUAL_MACHINE_MANAGER_H_
 
-#include "MadManager.h"
-#include "ActionManager.h"
 #include "VirtualMachineManagerDriver.h"
-#include "VirtualMachinePool.h"
-#include "HostPool.h"
-#include "DatastorePool.h"
-#include "NebulaTemplate.h"
+#include "DriverManager.h"
+#include "ActionManager.h"
 
-using namespace std;
+class DatastorePool;
+class HostPool;
+class VirtualMachinePool;
 
 extern "C" void * vmm_action_loop(void *arg);
 
@@ -89,16 +87,18 @@ private:
     int     _vm_id;
 };
 
-class VirtualMachineManager : public MadManager, public ActionListener
+class VirtualMachineManager :
+    public DriverManager<VirtualMachineManagerDriver>,
+    public ActionListener
 {
 public:
 
     VirtualMachineManager(
         time_t                    _timer_period,
         int                       _vm_limit,
-        vector<const VectorAttribute*>& _mads);
+        const std::string&        _mads);
 
-    ~VirtualMachineManager(){};
+    ~VirtualMachineManager() = default;
 
     /**
      *  Triggers specific actions to the Virtual Machine Manager. This function
@@ -138,11 +138,9 @@ public:
 
     /**
      *  Loads Virtual Machine Manager Mads defined in configuration file
-     *   @param uid of the user executing the driver. When uid is 0 the nebula
-     *   identity will be used. Otherwise the Mad will be loaded through the
-     *   sudo application.
+     *   @param _mads configuration of drivers
      */
-    int load_mads(int uid);
+    int load_drivers(const std::vector<const VectorAttribute*>& _mads);
 
     /**
      *  Check if action is supported for imported VMs
@@ -154,7 +152,7 @@ public:
     {
         const VirtualMachineManagerDriver * vmd = get(mad);
 
-        if ( vmd == 0 )
+        if ( vmd == nullptr )
         {
             return false;
         }
@@ -212,9 +210,7 @@ public:
     const VirtualMachineManagerDriver * get(
         const string&   name)
     {
-        string _name("NAME");
-        return static_cast<const VirtualMachineManagerDriver *>
-               (MadManager::get(0,_name,name));
+        return DriverManager::get_driver(name);
     };
 
     /**
@@ -269,31 +265,160 @@ private:
      */
     friend void * vmm_action_loop(void *arg);
 
+    // -------------------------------------------------------------------------
+    // Protocol implementation, procesing messages from driver
+    // -------------------------------------------------------------------------
+    static void _undefined(unique_ptr<vm_msg_t> msg);
+
     /**
-     *  Returns a pointer to a Virtual Machine Manager driver.
-     *    @param uid of the owner of the driver
-     *    @param name of an attribute of the driver (e.g. its type)
-     *    @param value of the attribute
-     *    @return the VM driver owned by uid with attribute name equal to value
-     *    or 0 in not found
+     *
      */
-    const VirtualMachineManagerDriver * get(
-        const string&   name,
-        const string&   value)
-    {
-        return static_cast<const VirtualMachineManagerDriver *>
-               (MadManager::get(0,name,value));
-    };
+    void _deploy(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _shutdown(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _reset(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _reboot(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _cancel(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _cleanup(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _checkpoint(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _save(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _restore(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _migrate(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _attachdisk(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _detachdisk(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _attachnic(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _detachnic(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _snapshotcreate(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _snapshotrevert(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _snapshotdelete(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _disksnapshotcreate(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _disksnapshotrevert(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _resizedisk(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _updateconf(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _updatesg(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void _driver_cancel(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    static void _log(unique_ptr<vm_msg_t> msg);
+
+    /**
+     *
+     */
+    void log_error(VirtualMachine* vm_id,
+                   const std::string& payload,
+                   const char* msg);
+
+    /**
+     *
+     */
+    void log_error(int vm_id, const std::string& payload, const char* msg);
+
+
+    /**
+     *
+     */
+    bool check_vm_state(int vm_id, vm_msg_t* msg);
 
     // -------------------------------------------------------------------------
     // Action Listener interface
     // -------------------------------------------------------------------------
 
+    static const int drivers_timeout = 10;
+
     void finalize_action(const ActionRequest& ar)
     {
         NebulaLog::log("VMM",Log::INFO,"Stopping Virtual Machine Manager...");
 
-        MadManager::stop();
+        DriverManager::stop(drivers_timeout);
     };
 
     void user_action(const ActionRequest& ar);
diff --git a/include/VirtualMachineManagerDriver.h b/include/VirtualMachineManagerDriver.h
index 08680bf0e0..abb2a06696 100644
--- a/include/VirtualMachineManagerDriver.h
+++ b/include/VirtualMachineManagerDriver.h
@@ -21,14 +21,13 @@
 #include <string>
 #include <sstream>
 
-#include "Mad.h"
+#include "ProtocolMessages.h"
+#include "Driver.h"
 #include "ActionSet.h"
-#include "VirtualMachinePool.h"
 #include "VMActions.h"
 #include "Host.h"
 #include "Cluster.h"
-
-using namespace std;
+#include "VirtualMachine.h"
 
 /**
  *  VirtualMachineManagerDriver provides a base class to implement VM Manager
@@ -37,30 +36,15 @@ using namespace std;
  *  must implement the deployment function to generate specific VM
  *  deployment information for the unerlying MAD.
  */
-class VirtualMachineManagerDriver : public Mad
+class VirtualMachineManagerDriver : public Driver<vm_msg_t>
 {
 public:
 
-    VirtualMachineManagerDriver(
-        int                         userid,
-        const map<string,string>&   attrs,
-        bool                        sudo,
-        VirtualMachinePool *        pool);
+    VirtualMachineManagerDriver(const std::string& mad_location,
+            const std::map<std::string,std::string>& attrs);
 
     virtual ~VirtualMachineManagerDriver() = default;
 
-    /**
-     *  Implements the VM Manager driver protocol.
-     *    @param message the string read from the driver
-     */
-    void protocol(const string& message) const;
-
-    /**
-     *  TODO: What do we need here? just poll the active VMs to recover
-     *  connections? Or an specific recover action from the MAD?
-     */
-    void recover();
-
     /**
      *  Generates a driver-specific deployment file:
      *    @param vm pointer to a virtual machine
@@ -69,7 +53,7 @@ public:
      */
     virtual int deployment_description(
         const VirtualMachine *  vm,
-        const string&           file_name) const = 0;
+        const std::string&      file_name) const = 0;
 
     /**
      *  Validates de VM raws section
@@ -77,7 +61,7 @@ public:
      *    @param error description on error
      *    @return 0 on success
      */
-    virtual int validate_raw(const string& raw, string& error) const
+    virtual int validate_raw(const std::string& raw, std::string& error) const
     {
         return 0;
     }
@@ -123,7 +107,7 @@ protected:
      *    @param value of the attribute
      */
     template<typename T>
-    void get_default(const string& name, T& value) const
+    void get_default(const std::string& name, T& value) const
     {
         driver_conf.get(name, value);
     }
@@ -162,7 +146,7 @@ protected:
     bool get_attribute(const VirtualMachine * vm,
                        const Host * host,
                        const Cluster * cluster,
-                       const string& name,
+                       const std::string& name,
                        T& value) const
     {
         // Get value from VM
@@ -201,8 +185,8 @@ protected:
     bool get_attribute(const VirtualMachine * vm,
                        const Host * host,
                        const Cluster* cluster,
-                       const string& name,
-                       const string& vname,
+                       const std::string& name,
+                       const std::string& vname,
                        T& value) const
     {
         const VectorAttribute * vattr;
@@ -249,8 +233,8 @@ protected:
 private:
     friend class VirtualMachineManager;
 
-    static const string imported_actions_default;
-    static const string imported_actions_default_public;
+    static const std::string imported_actions_default;
+    static const std::string imported_actions_default_public;
 
     /**
      *  Configuration file for the driver
@@ -279,21 +263,16 @@ private:
     */
     bool cold_nic_attach;
 
-    /**
-     *  Pointer to the Virtual Machine Pool, to access VMs
-     */
-    VirtualMachinePool * vmpool;
-
     /**
      *  Sends a deploy request to the MAD: "DEPLOY ID XML_DRV_MSG"
      *    @param oid the virtual machine id.
      *    @param drv_msg xml data for the mad operation
      */
     void deploy(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("DEPLOY", oid, drv_msg);
+        write_drv(VMManagerMessages::DEPLOY, oid, drv_msg);
     }
 
     /**
@@ -302,10 +281,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void shutdown(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("SHUTDOWN", oid, drv_msg);
+        write_drv(VMManagerMessages::SHUTDOWN, oid, drv_msg);
     }
 
     /**
@@ -314,10 +293,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void reset(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("RESET", oid, drv_msg);
+        write_drv(VMManagerMessages::RESET, oid, drv_msg);
     }
 
     /**
@@ -326,10 +305,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void reboot(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("REBOOT", oid, drv_msg);
+        write_drv(VMManagerMessages::REBOOT, oid, drv_msg);
     }
 
     /**
@@ -338,10 +317,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void cancel(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("CANCEL", oid, drv_msg);
+        write_drv(VMManagerMessages::CANCEL, oid, drv_msg);
     }
 
     /**
@@ -350,10 +329,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void cleanup(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("CLEANUP", oid, drv_msg);
+        write_drv(VMManagerMessages::CLEANUP, oid, drv_msg);
     }
 
     /**
@@ -362,10 +341,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void checkpoint(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("CHECKPOINT", oid, drv_msg);
+        write_drv(VMManagerMessages::CHECKPOINT, oid, drv_msg);
     }
 
     /**
@@ -374,12 +353,20 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void save(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("SAVE", oid, drv_msg);
+        write_drv(VMManagerMessages::SAVE, oid, drv_msg);
     }
 
+    /**
+     *  Sends a save request to the MAD: "SAVE ID XML_DRV_MSG"
+     *    @param oid the virtual machine id.
+     */
+    void driver_cancel(const int     oid) const
+    {
+        write_drv(VMManagerMessages::DRIVER_CANCEL, oid, "");
+    }
 
     /**
      *  Sends a save request to the MAD: "RESTORE ID XML_DRV_MSG"
@@ -387,10 +374,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void restore(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("RESTORE", oid, drv_msg);
+        write_drv(VMManagerMessages::RESTORE, oid, drv_msg);
     }
 
 
@@ -400,22 +387,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void migrate(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("MIGRATE", oid, drv_msg);
-    }
-
-    /**
-     *  Sends a poll request to the MAD: "POLL ID XML_DRV_MSG"
-     *    @param oid the virtual machine id.
-     *    @param drv_msg xml data for the mad operation
-     */
-    void poll(
-        const int     oid,
-        const string& drv_msg) const
-    {
-        write_drv("POLL", oid, drv_msg);
+        write_drv(VMManagerMessages::MIGRATE, oid, drv_msg);
     }
 
     /**
@@ -424,10 +399,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void attach(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("ATTACHDISK", oid, drv_msg);
+        write_drv(VMManagerMessages::ATTACHDISK, oid, drv_msg);
     }
 
     /**
@@ -436,10 +411,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void detach(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("DETACHDISK", oid, drv_msg);
+        write_drv(VMManagerMessages::DETACHDISK, oid, drv_msg);
     }
 
     /**
@@ -448,10 +423,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void attach_nic(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("ATTACHNIC", oid, drv_msg);
+        write_drv(VMManagerMessages::ATTACHNIC, oid, drv_msg);
     }
 
     /**
@@ -460,10 +435,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void detach_nic(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("DETACHNIC", oid, drv_msg);
+        write_drv(VMManagerMessages::DETACHNIC, oid, drv_msg);
     }
 
     /**
@@ -473,10 +448,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void snapshot_create(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("SNAPSHOTCREATE", oid, drv_msg);
+        write_drv(VMManagerMessages::SNAPSHOTCREATE, oid, drv_msg);
     }
 
     /**
@@ -486,10 +461,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void snapshot_revert(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("SNAPSHOTREVERT", oid, drv_msg);
+        write_drv(VMManagerMessages::SNAPSHOTREVERT, oid, drv_msg);
     }
 
     /**
@@ -499,10 +474,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void snapshot_delete(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("SNAPSHOTDELETE", oid, drv_msg);
+        write_drv(VMManagerMessages::SNAPSHOTDELETE, oid, drv_msg);
     }
 
     /**
@@ -512,10 +487,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void disk_snapshot_create(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("DISKSNAPSHOTCREATE", oid, drv_msg);
+        write_drv(VMManagerMessages::DISKSNAPSHOTCREATE, oid, drv_msg);
     }
 
     /**
@@ -525,10 +500,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void disk_resize(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("RESIZEDISK", oid, drv_msg);
+        write_drv(VMManagerMessages::RESIZEDISK, oid, drv_msg);
     }
 
     /**
@@ -537,10 +512,10 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void update_conf(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("UPDATECONF", oid, drv_msg);
+        write_drv(VMManagerMessages::UPDATECONF, oid, drv_msg);
     }
 
     /**
@@ -550,22 +525,21 @@ private:
      *    @param drv_msg xml data for the mad operation
      */
     void updatesg(
-        const int     oid,
-        const string& drv_msg) const
+        const int          oid,
+        const std::string& drv_msg) const
     {
-        write_drv("UPDATESG", oid, drv_msg);
+        write_drv(VMManagerMessages::UPDATESG, oid, drv_msg);
     }
 
     /**
      *
      */
-    void write_drv(const char * aname, const int oid, const string& msg) const
+    void write_drv(VMManagerMessages type,
+                   const int oid,
+                   const std::string& msg) const
     {
-        ostringstream os;
-
-        os << aname << " " << oid << " " << msg << endl;
-
-        write(os);
+        vm_msg_t drv_msg(type, "", oid, msg);
+        write(drv_msg);
     }
 };
 
diff --git a/include/VirtualNetwork.h b/include/VirtualNetwork.h
index 1b999a6990..9916bb3c0c 100644
--- a/include/VirtualNetwork.h
+++ b/include/VirtualNetwork.h
@@ -753,12 +753,7 @@ private:
      *  Bootstraps the database table(s) associated to the Virtual Network
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss_vnet(VirtualNetwork::db_bootstrap);
-
-        return db->exec_local_wr(oss_vnet);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      * Function to print the VirtualNetwork object into a string in
@@ -805,12 +800,6 @@ private:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * table;
-
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
     /**
      *  Writes the Virtual Network and its associated template and leases in the database.
      *    @param db pointer to the db
diff --git a/include/VirtualNetworkPool.h b/include/VirtualNetworkPool.h
index 88970f9aef..ec7166daef 100644
--- a/include/VirtualNetworkPool.h
+++ b/include/VirtualNetworkPool.h
@@ -20,6 +20,7 @@
 #include "PoolSQL.h"
 #include "VirtualNetwork.h"
 #include "BitMap.h"
+#include "OneDB.h"
 
 #include <time.h>
 
@@ -166,7 +167,7 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "VNET_POOL", "body", VirtualNetwork::table,
+        return PoolSQL::dump(oss, "VNET_POOL", "body", one_db::vn_table,
                 where, sid, eid, desc);
     }
 
@@ -196,7 +197,7 @@ public:
      */
     int search(vector<int>& oids, const string& where)
     {
-        return PoolSQL::search(oids, VirtualNetwork::table, where);
+        return PoolSQL::search(oids, one_db::vn_table, where);
     };
 
     //--------------------------------------------------------------------------
diff --git a/include/VirtualRouter.h b/include/VirtualRouter.h
index 66475ca098..8cb6b65764 100644
--- a/include/VirtualRouter.h
+++ b/include/VirtualRouter.h
@@ -202,12 +202,7 @@ private:
      *  Bootstraps the database table(s) associated to the VirtualRouter
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(VirtualRouter::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Rebuilds the object from an xml formatted string
@@ -234,12 +229,6 @@ private:
     // DataBase implementation
     // *************************************************************************
 
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
-
     /**
      *  Writes the VirtualRouter in the database.
      *    @param db pointer to the db
diff --git a/include/VirtualRouterPool.h b/include/VirtualRouterPool.h
index b3693f9fdc..49b035a885 100644
--- a/include/VirtualRouterPool.h
+++ b/include/VirtualRouterPool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "VirtualRouter.h"
+#include "OneDB.h"
 
 /**
  *  The VirtualRouter Pool class.
@@ -27,7 +28,7 @@ class VirtualRouterPool : public PoolSQL
 {
 public:
 
-    VirtualRouterPool(SqlDB * db) : PoolSQL(db, VirtualRouter::table){};
+    VirtualRouterPool(SqlDB * db) : PoolSQL(db, one_db::vn_table){};
 
     ~VirtualRouterPool(){};
 
@@ -69,7 +70,7 @@ public:
      *
      *   @return a pointer to the object, 0 in case of failure
      */
-    VirtualRouter * get(int oid) 
+    VirtualRouter * get(int oid)
     {
         return static_cast<VirtualRouter *>(PoolSQL::get(oid));
     };
@@ -101,7 +102,7 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "VROUTER_POOL", "body", VirtualRouter::table,
+        return PoolSQL::dump(oss, "VROUTER_POOL", "body", one_db::vr_table,
                 where, sid, eid, desc);
     };
 
@@ -122,7 +123,7 @@ public:
      */
     int search(vector<int>& oids, const string& where)
     {
-        return PoolSQL::search(oids, VirtualRouter::table, where);
+        return PoolSQL::search(oids, one_db::vr_table, where);
     };
 
 private:
diff --git a/include/XMLDriver.h b/include/XMLDriver.h
index 2d007f2752..770d85ae81 100644
--- a/include/XMLDriver.h
+++ b/include/XMLDriver.h
@@ -19,11 +19,8 @@
 
 #include <map>
 #include <string>
-#include <sstream>
 #include "VirtualMachineManagerDriver.h"
 
-using namespace std;
-
 /**
  *  XML Driver class implements a Generic VM Manager Driver that uses a neutral
  *  XML representation for the VM templates.
@@ -32,15 +29,12 @@ class XMLDriver : public VirtualMachineManagerDriver
 {
 public:
 
-    XMLDriver(
-        int userid,
-        const map<string,string> &attrs,
-        bool sudo,
-        VirtualMachinePool *    pool):
-            VirtualMachineManagerDriver(userid, attrs,sudo,pool)
-    {};
+    XMLDriver(const std::string& mad_location,
+              const std::map<std::string, std::string> &attrs):
+        VirtualMachineManagerDriver(mad_location, attrs)
+    {}
 
-    ~XMLDriver(){};
+    ~XMLDriver() = default;
 
 private:
     /**
@@ -51,7 +45,7 @@ private:
      */
     int deployment_description(
         const VirtualMachine *  vm,
-        const string&           file_name) const override;
+        const std::string&      file_name) const override;
 };
 
 #endif /*XML_DRIVER_H_*/
diff --git a/include/XenDriver.h b/include/XenDriver.h
index 4903d43dae..a85043a378 100644
--- a/include/XenDriver.h
+++ b/include/XenDriver.h
@@ -19,11 +19,8 @@
 
 #include <map>
 #include <string>
-#include <sstream>
 #include "VirtualMachineManagerDriver.h"
 
-using namespace std;
-
 /**
  *  Xen Driver class implements a VM Manager Driver to interface with the Xen
  *  hypervisor.
@@ -32,15 +29,12 @@ class XenDriver : public VirtualMachineManagerDriver
 {
 public:
 
-    XenDriver(
-        int userid,
-        const map<string,string> &attrs,
-        bool sudo,
-        VirtualMachinePool *    pool):
-            VirtualMachineManagerDriver(userid, attrs,sudo,pool)
-    {};
+    XenDriver(const std::string& mad_location,
+              const std::map<std::string, std::string> &attrs):
+        VirtualMachineManagerDriver(mad_location, attrs)
+    {}
 
-    ~XenDriver(){};
+    ~XenDriver() = default;
 
 private:
     /**
@@ -51,7 +45,7 @@ private:
      */
     int deployment_description(
         const VirtualMachine *  vm,
-        const string&           file_name) const override;
+        const std::string&      file_name) const override;
 };
 
 #endif /*XEN_DRIVER_H_*/
diff --git a/include/Zone.h b/include/Zone.h
index f9d24f60bc..72576aa0ea 100644
--- a/include/Zone.h
+++ b/include/Zone.h
@@ -108,11 +108,6 @@ private:
     // -------------------------------------------------------------------------
     // DataBase implementation (Private)
     // -------------------------------------------------------------------------
-    static const char * db_names;
-
-    static const char * db_bootstrap;
-
-    static const char * table;
 
     /**
      *  Execute an INSERT or REPLACE Sql query.
@@ -127,12 +122,7 @@ private:
      *  Bootstraps the database table(s) associated to the Zone
      *    @return 0 on success
      */
-    static int bootstrap(SqlDB * db)
-    {
-        ostringstream oss(Zone::db_bootstrap);
-
-        return db->exec_local_wr(oss);
-    };
+    static int bootstrap(SqlDB * db);
 
     /**
      *  Writes the Zone in the database.
diff --git a/include/ZonePool.h b/include/ZonePool.h
index 922cbdd2a7..6cea7c845a 100644
--- a/include/ZonePool.h
+++ b/include/ZonePool.h
@@ -19,6 +19,7 @@
 
 #include "PoolSQL.h"
 #include "Zone.h"
+#include "OneDB.h"
 
 using namespace std;
 
@@ -100,8 +101,8 @@ public:
     int dump(std::string& oss, const std::string& where, int sid, int eid,
         bool desc)
     {
-        return PoolSQL::dump(oss, "ZONE_POOL", "body", Zone::table, where,
-                sid, eid, desc);
+        return PoolSQL::dump(oss, "ZONE_POOL", "body", one_db::zone_table,
+                where, sid, eid, desc);
     };
 
     /**
@@ -119,7 +120,7 @@ public:
      */
     int list_zones(vector<int>& zone_ids)
     {
-        return list( zone_ids, Zone::table);
+        return list( zone_ids, one_db::zone_table);
     }
 
     /**
diff --git a/src/acl/AclManager.cc b/src/acl/AclManager.cc
index 239d4a16ce..70e1aeab3f 100644
--- a/src/acl/AclManager.cc
+++ b/src/acl/AclManager.cc
@@ -19,17 +19,7 @@
 #include "AclManager.h"
 #include "PoolObjectAuth.h"
 #include "SqlDB.h"
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-const char * AclManager::table = "acl";
-
-const char * AclManager::db_names = "oid, userset, resource, rights, zone";
-
-const char * AclManager::db_bootstrap = "CREATE TABLE IF NOT EXISTS "
-    "acl (oid INT PRIMARY KEY, userset BIGINT, resource BIGINT, "
-    "rights BIGINT, zone BIGINT, UNIQUE(userset, resource, rights, zone))";
+#include "OneDB.h"
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -1135,7 +1125,7 @@ void AclManager::reverse_search(int                       uid,
 
 int AclManager::bootstrap(SqlDB * _db)
 {
-    ostringstream oss(db_bootstrap);
+    ostringstream oss(one_db::acl_db_bootstrap);
 
     return _db->exec_local_wr(oss);
 }
@@ -1206,7 +1196,7 @@ int AclManager::select()
     ostringstream   oss;
     int             rc;
 
-    oss << "SELECT " << db_names << " FROM " << table;
+    oss << "SELECT " << one_db::acl_db_names << " FROM " << one_db::acl_table;
 
     set_callback(static_cast<Callbackable::Callback>(&AclManager::select_cb));
 
@@ -1239,7 +1229,8 @@ int AclManager::insert(AclRule * rule, SqlDB * db)
 
     // Construct the SQL statement to Insert
 
-    oss <<  "INSERT INTO "  << table <<" ("<< db_names <<") VALUES ("
+    oss <<  "INSERT INTO "  << one_db::acl_table
+        << " (" << one_db::acl_db_names << ") VALUES ("
         <<  rule->oid       << ","
         <<  rule->user      << ","
         <<  rule->resource  << ","
@@ -1260,7 +1251,7 @@ int AclManager::drop(int oid)
     ostringstream   oss;
     int             rc;
 
-    oss << "DELETE FROM " << table << " WHERE "
+    oss << "DELETE FROM " << one_db::acl_table << " WHERE "
         << "oid=" << oid;
 
     rc = db->exec_wr(oss);
diff --git a/src/authm/AuthManager.cc b/src/authm/AuthManager.cc
index d47e2544d7..d27610a79d 100644
--- a/src/authm/AuthManager.cc
+++ b/src/authm/AuthManager.cc
@@ -21,6 +21,8 @@
 #include "PoolObjectAuth.h"
 #include "Nebula.h"
 
+using namespace std;
+
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
@@ -31,7 +33,7 @@ const char * AuthManager::auth_driver_name = "auth_exe";
 
 void AuthRequest::add_auth(Operation             op,
                            const PoolObjectAuth& ob_perms,
-                           string                ob_template)
+                           const string&         ob_template)
 {
     ostringstream oss;
     bool          auth;
@@ -43,7 +45,7 @@ void AuthRequest::add_auth(Operation             op,
     {
         string * encoded_id = one_util::base64_encode(ob_template);
 
-        if (encoded_id != 0)
+        if (encoded_id != nullptr)
         {
             oss << *encoded_id << ":";
             delete encoded_id;
@@ -123,7 +125,7 @@ extern "C" void * authm_action_loop(void *arg)
 {
     AuthManager *  authm;
 
-    if ( arg == 0 )
+    if ( arg == nullptr )
     {
         return 0;
     }
@@ -143,22 +145,37 @@ extern "C" void * authm_action_loop(void *arg)
 
 int AuthManager::start()
 {
-    int               rc;
     pthread_attr_t    pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(AuthManagerMessages::UNDEFINED,
+            &AuthManager::_undefined);
+
+    register_action(AuthManagerMessages::AUTHORIZE,
+            bind(&AuthManager::_authorize, this, _1));
+
+    register_action(AuthManagerMessages::AUTHENTICATE,
+            bind(&AuthManager::_authenticate, this, _1));
+
+    register_action(AuthManagerMessages::LOG,
+            &AuthManager::_log);
+
+    string error;
+
+    if (DriverManager::start(error) != 0)
     {
+        NebulaLog::error("AuM", error);
+
         return -1;
     }
 
     NebulaLog::log("AuM",Log::INFO,"Starting Auth Manager...");
 
-    pthread_attr_init (&pattr);
-    pthread_attr_setdetachstate (&pattr, PTHREAD_CREATE_JOINABLE);
+    pthread_attr_init(&pattr);
+    pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 
-    rc = pthread_create(&authm_thread,&pattr,authm_action_loop,(void *) this);
+    int rc = pthread_create(&authm_thread,&pattr,authm_action_loop,(void *) this);
 
     return rc;
 }
@@ -171,12 +188,12 @@ void AuthManager::user_action(const ActionRequest& ar)
     const AMAction& auth_ar = static_cast<const AMAction& >(ar);
     AuthRequest * request   = auth_ar.request();
 
-    if ( request == 0 )
+    if ( request == nullptr )
     {
         return;
     }
 
-    switch(auth_ar.action())
+    switch (auth_ar.action())
     {
         case AMAction::AUTHENTICATE:
             authenticate_action(request);
@@ -193,17 +210,19 @@ void AuthManager::user_action(const ActionRequest& ar)
 
 void AuthManager::authenticate_action(AuthRequest * ar)
 {
-    const AuthManagerDriver * authm_md;
-
     // ------------------------------------------------------------------------
     // Get the driver
     // ------------------------------------------------------------------------
 
-    authm_md = get();
+    auto authm_md = get();
 
-    if (authm_md == 0)
+    if (authm_md == nullptr)
     {
-        goto error_driver;
+        ar->result  = false;
+        ar->message = "Could not find Authorization driver";
+        ar->notify();
+
+        return;
     }
 
     // ------------------------------------------------------------------------
@@ -216,18 +235,17 @@ void AuthManager::authenticate_action(AuthRequest * ar)
     // Make the request to the driver
     // ---- --------------------------------------------------------------------
 
-    authm_md->authenticate(ar->id,
-                           ar->uid,
-                           ar->driver,
-                           ar->username,
-                           ar->password,
-                           ar->session);
-    return;
+    ostringstream oss;
 
-error_driver:
-    ar->result  = false;
-    ar->message = "Could not find Authorization driver";
-    ar->notify();
+    oss << ar->uid << " "
+        << ar->driver << " "
+        << ar->username << " "
+        << ar->password << " "
+        << ar->session << " " << endl;
+
+    auth_msg_t msg(AuthManagerMessages::AUTHENTICATE, "", ar->id, oss.str());
+
+    authm_md->write(msg);
 }
 
 /* -------------------------------------------------------------------------- */
@@ -235,19 +253,30 @@ error_driver:
 
 void AuthManager::authorize_action(AuthRequest * ar)
 {
-    const AuthManagerDriver * authm_md;
-    string auths;
-
     // ------------------------------------------------------------------------
     // Get the driver
     // ------------------------------------------------------------------------
 
-    authm_md = get();
+    auto authm_md = get();
 
-    if (authm_md == 0)
+    if (authm_md == nullptr)
     {
         ar->message = "Could not find Authorization driver";
-        goto error;
+        ar->result = false;
+        ar->notify();
+
+        return;
+    }
+
+    auto auths = ar->get_auths();
+
+    if (auths.empty())
+    {
+        ar->message = "Empty authorization string";
+        ar->result = false;
+        ar->notify();
+
+        return;
     }
 
     // ------------------------------------------------------------------------
@@ -260,47 +289,34 @@ void AuthManager::authorize_action(AuthRequest * ar)
     // Make the request to the driver
     // ------------------------------------------------------------------------
 
-    auths = ar->get_auths();
+    ostringstream oss;
 
-    if ( auths.empty() )
-    {
-        ar->message = "Empty authorization string";
-        goto error;
-    }
+    oss << ar->uid << " "
+        << auths << " "
+        << ar->self_authorize << endl;
 
-    authm_md->authorize(ar->id, ar->uid, auths, ar->self_authorize);
+    auth_msg_t msg(AuthManagerMessages::AUTHORIZE, "", ar->id, oss.str());
 
-    return;
-
-error:
-    ar->result = false;
-    ar->notify();
-
-    return;
+    authm_md->write(msg);
 }
 
 /* ************************************************************************** */
 /* MAD Loading                                                                */
 /* ************************************************************************** */
 
-int AuthManager::load_mads(int uid)
+int AuthManager::load_drivers(const std::vector<const VectorAttribute*>& _mads)
 {
     ostringstream                   oss;
-    const VectorAttribute *         vattr = 0;
-    int                             rc;
-    string                          name;
-    AuthManagerDriver *             authm_driver = 0;
+    const VectorAttribute *         vattr = nullptr;
 
-    oss << "Loading Auth. Manager driver.";
+    NebulaLog::log("AuM", Log::INFO, "Loading Auth. Manager driver.");
 
-    NebulaLog::log("AuM",Log::INFO,oss);
-
-    if ( mad_conf.size() > 0 )
+    if ( _mads.size() > 0 )
     {
-        vattr = static_cast<const VectorAttribute *>(mad_conf[0]);
+        vattr = _mads[0];
     }
 
-    if ( vattr == 0 )
+    if ( vattr == nullptr )
     {
         NebulaLog::log("AuM",Log::ERROR,"Failed to load Auth. Manager driver.");
         return -1;
@@ -333,17 +349,13 @@ int AuthManager::load_mads(int uid)
 
     auth_conf.replace("ARGUMENTS", oss.str());
 
-    authm_driver = new AuthManagerDriver(uid,auth_conf.value(),(uid!=0),this);
-
-    rc = add(authm_driver);
-
-    if ( rc == 0 )
+    if (load_driver(&auth_conf) != 0)
     {
-        oss.str("");
-        oss << "\tAuth Manager loaded";
-
-        NebulaLog::log("AuM",Log::INFO,oss);
+        NebulaLog::error("ImM", "Unable to load Auth Manager driver");
+        return -1;
     }
 
-    return rc;
+    NebulaLog::log("AuM", Log::INFO, "\tAuth Manager loaded");
+
+    return 0;
 }
diff --git a/src/authm/AuthManagerDriver.cc b/src/authm/AuthManagerDriver.cc
deleted file mode 100644
index b3b0f32c5a..0000000000
--- a/src/authm/AuthManagerDriver.cc
+++ /dev/null
@@ -1,131 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include "AuthManagerDriver.h"
-#include "AuthManager.h"
-#include "NebulaLog.h"
-
-#include "Nebula.h"
-#include <sstream>
-
-/* ************************************************************************** */
-/* Driver ASCII Protocol Implementation                                       */
-/* ************************************************************************** */
-
-void AuthManagerDriver::authorize(int           oid,
-                                  int           uid,
-                                  const string& reqs,
-                                  bool          acl) const
-{
-    ostringstream os;
-
-    os << "AUTHORIZE " << oid << " " << uid << " " << reqs << " " << acl <<endl;
-
-    write(os);
-}
-
-void AuthManagerDriver::authenticate(int           oid,
-                                     int           uid,
-                                     const string& driver,
-                                     const string& username,
-                                     const string& password,
-                                     const string& session) const
-{
-    ostringstream os;
-
-    os << "AUTHENTICATE " << oid << " "
-                          << uid << " "
-                          << driver << " "
-                          << username << " "
-                          << password << " "
-                          << session  << endl;
-
-    write(os);
-}
-
-/* ************************************************************************** */
-/* MAD Interface                                                              */
-/* ************************************************************************** */
-
-void AuthManagerDriver::protocol(const string& message) const
-{
-    istringstream is(message);
-    ostringstream os;
-
-    string        action;
-    string        result;
-    string        info="";
-
-    int           id;
-
-    os << "Message received: " << message;
-    NebulaLog::log("AuM", Log::DEBUG, os);
-
-    // Parse the driver message
-    if ( is.good() )
-        is >> action >> ws;
-    else
-        return;
-
-    if ( is.good() )
-        is >> result >> ws;
-    else
-        return;
-
-    if ( is.good() )
-    {
-        is >> id >> ws;
-
-        if ( is.fail() )
-        {
-            if ( action == "LOG" )
-            {
-                is.clear();
-                getline(is,info);
-                NebulaLog::log("AuM", log_type(result[0]), info.c_str());
-            }
-
-            return;
-        }
-    }
-    else
-        return;
-
-    getline(is,info);
-
-    if (action == "LOG")
-    {
-        NebulaLog::log("AuM",Log::INFO,info.c_str());
-    }
-    else if (result == "SUCCESS")
-    {
-        authm->notify_request(id,true,info);
-    }
-    else
-    {
-        authm->notify_request(id,false,info);
-    }
-
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void AuthManagerDriver::recover()
-{
-    NebulaLog::log("AuM",Log::INFO,"Recovering Authorization drivers");
-}
diff --git a/src/authm/AuthManagerProtocol.cc b/src/authm/AuthManagerProtocol.cc
new file mode 100644
index 0000000000..0f537fabb1
--- /dev/null
+++ b/src/authm/AuthManagerProtocol.cc
@@ -0,0 +1,66 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "AuthManager.h"
+#include "NebulaLog.h"
+
+/* ************************************************************************** */
+/* Driver Protocol Implementation                                             */
+/* ************************************************************************** */
+
+void AuthManager::_undefined(unique_ptr<auth_msg_t> msg)
+{
+    NebulaLog::warn("AuM", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void AuthManager::_authorize(unique_ptr<auth_msg_t> msg)
+{
+    NebulaLog::debug("AuM", "_authorize: " + msg->payload());
+
+    if (msg->status() == "SUCCESS")
+    {
+        notify_request(msg->oid(), true, msg->payload());
+    }
+    else
+    {
+        notify_request(msg->oid(), false, msg->payload());
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void AuthManager::_authenticate(unique_ptr<auth_msg_t> msg)
+{
+    NebulaLog::debug("AuM", "_authenticate: " + msg->payload());
+
+    if (msg->status() == "SUCCESS")
+    {
+        notify_request(msg->oid(), true, msg->payload());
+    }
+    else
+    {
+        notify_request(msg->oid(), false, msg->payload());
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void AuthManager::_log(unique_ptr<auth_msg_t> msg)
+{
+    NebulaLog::log("AuM", log_type(msg->status()[0]), msg->payload());
+}
diff --git a/src/authm/SConstruct b/src/authm/SConstruct
index 30b1263895..df80ed4169 100644
--- a/src/authm/SConstruct
+++ b/src/authm/SConstruct
@@ -23,7 +23,7 @@ lib_name='nebula_authm'
 # Sources to generate the library
 source_files=[
     'AuthManager.cc',
-    'AuthManagerDriver.cc'
+    'AuthManagerProtocol.cc'
 ]
 
 # Build library
diff --git a/src/cluster/Cluster.cc b/src/cluster/Cluster.cc
index e01196a675..feb2f9340c 100644
--- a/src/cluster/Cluster.cc
+++ b/src/cluster/Cluster.cc
@@ -17,33 +17,10 @@
 #include "Cluster.h"
 #include "GroupPool.h"
 #include "Nebula.h"
+#include "OneDB.h"
 
 #include <sstream>
 
-const char * Cluster::table = "cluster_pool";
-
-const char * Cluster::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * Cluster::db_bootstrap = "CREATE TABLE IF NOT EXISTS cluster_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name))";
-
-const char * Cluster::datastore_table = "cluster_datastore_relation";
-const char * Cluster::datastore_db_names = "cid, oid";
-const char * Cluster::datastore_db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS cluster_datastore_relation ("
-    "cid INTEGER, oid INTEGER, PRIMARY KEY(cid, oid))";
-
-const char * Cluster::network_table = "cluster_network_relation";
-const char * Cluster::network_db_names = "cid, oid";
-const char * Cluster::network_db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS cluster_network_relation ("
-    "cid INTEGER, oid INTEGER, PRIMARY KEY(cid, oid))";
-
-const char * Cluster::bitmap_table = "cluster_vnc_bitmap";
-
 /* ************************************************************************** */
 /* Cluster :: Constructor/Destructor                                          */
 /* ************************************************************************** */
@@ -53,11 +30,11 @@ Cluster::Cluster(
         const string& name,
         ClusterTemplate*  cl_template,
         const VectorAttribute& vnc_conf):
-            PoolObjectSQL(id,CLUSTER,name,-1,-1,"","",table),
+            PoolObjectSQL(id,CLUSTER,name,-1,-1,"","",one_db::cluster_table),
             hosts("HOSTS"),
             datastores("DATASTORES"),
             vnets("VNETS"),
-            vnc_bitmap(vnc_conf, id, bitmap_table)
+            vnc_bitmap(vnc_conf, id, one_db::cluster_bitmap_table)
 {
     if (cl_template != 0)
     {
@@ -184,7 +161,7 @@ int Cluster::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::cluster_table << " SET "
             << "name = '"   << sql_name << "', "
             << "body = '"   << sql_xml  << "', "
             << "uid =  "    << uid      << ", "
@@ -197,7 +174,8 @@ int Cluster::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::cluster_table
+            << " (" << one_db::cluster_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -239,6 +217,26 @@ error_common:
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
+int Cluster::bootstrap(SqlDB * db)
+{
+    int rc;
+    ostringstream oss;
+
+    oss.str(one_db::cluster_db_bootstrap);
+    rc = db->exec_local_wr(oss);
+
+    oss.str(one_db::cluster_datastore_db_bootstrap);
+    rc += db->exec_local_wr(oss);
+
+    oss.str(one_db::cluster_network_db_bootstrap);
+    rc += db->exec_local_wr(oss);
+
+    return rc;
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
 string& Cluster::to_xml(string& xml) const
 {
     ostringstream   oss;
diff --git a/src/cluster/ClusterPool.cc b/src/cluster/ClusterPool.cc
index bfa15f3704..3a2167a161 100644
--- a/src/cluster/ClusterPool.cc
+++ b/src/cluster/ClusterPool.cc
@@ -39,7 +39,7 @@ const int    ClusterPool::DEFAULT_CLUSTER_ID   = 0;
 ClusterPool::ClusterPool(SqlDB * db,
                          const VectorAttribute * _vnc_conf,
                          vector<const SingleAttribute *>& encrypted_attrs):
-    PoolSQL(db, Cluster::table), vnc_conf(_vnc_conf)
+    PoolSQL(db, one_db::cluster_table), vnc_conf(_vnc_conf)
 {
     ostringstream oss;
     string        error_str;
@@ -192,13 +192,13 @@ void ClusterPool::cluster_acl_filter(ostringstream& filter,
             break;
 
         case PoolObjectSQL::DATASTORE:
-            filter << " OR oid IN ( SELECT oid from " << Cluster::datastore_table
-                   << " WHERE ";
+            filter << " OR oid IN ( SELECT oid from "
+                   << one_db::cluster_datastore_table << " WHERE ";
             fc = ")";
             break;
 
         case PoolObjectSQL::NET:
-            filter << " OR oid IN ( SELECT oid from " << Cluster::network_table
+            filter << " OR oid IN ( SELECT oid from " << one_db::cluster_network_table
                    << " WHERE ";
             fc = ")";
             break;
@@ -230,8 +230,8 @@ int ClusterPool::query_datastore_clusters(int oid, set<int> &cluster_ids)
 
     cb.set_callback(&cluster_ids);
 
-    oss << "SELECT cid FROM " << Cluster::datastore_table << " WHERE oid = "
-        << oid;
+    oss << "SELECT cid FROM " << one_db::cluster_datastore_table
+        << " WHERE oid = " << oid;
 
     int rc = db->exec_rd(oss, &cb);
 
@@ -255,7 +255,7 @@ int ClusterPool::query_vnet_clusters(int oid, set<int> &cluster_ids)
 
     cb.set_callback(&cluster_ids);
 
-    oss << "SELECT cid FROM " << Cluster::network_table << " WHERE oid = "<<oid;
+    oss << "SELECT cid FROM " << one_db::cluster_network_table << " WHERE oid = "<<oid;
 
     int rc = db->exec_rd(oss, &cb);
 
@@ -280,12 +280,12 @@ int ClusterPool::add_to_cluster(PoolObjectSQL::ObjectType type, Cluster* cluster
     switch (type)
     {
         case PoolObjectSQL::DATASTORE:
-            table = cluster->datastore_table;
-            names = cluster->datastore_db_names;
+            table = one_db::cluster_datastore_table;
+            names = one_db::cluster_datastore_db_names;
             break;
         case PoolObjectSQL::NET:
-            table = cluster->network_table;
-            names = cluster->network_db_names;
+            table = one_db::cluster_network_table;
+            names = one_db::cluster_network_db_names;
             break;
         case PoolObjectSQL::HOST:
             break;
@@ -337,10 +337,10 @@ int ClusterPool::del_from_cluster(PoolObjectSQL::ObjectType type, Cluster* clust
     switch (type)
     {
         case PoolObjectSQL::DATASTORE:
-            table = cluster->datastore_table;
+            table = one_db::cluster_datastore_table;
             break;
         case PoolObjectSQL::NET:
-            table = cluster->network_table;
+            table = one_db::cluster_network_table;
             break;
         case PoolObjectSQL::HOST:
             break;
diff --git a/src/common/SConstruct b/src/common/SConstruct
index f4c0c25e8a..23d70edf85 100644
--- a/src/common/SConstruct
+++ b/src/common/SConstruct
@@ -26,7 +26,8 @@ source_files=[
     'Attribute.cc',
     'ExtendedAttribute.cc',
     'NebulaService.cc',
-    'NebulaUtil.cc'
+    'NebulaUtil.cc',
+    'SSLUtil.cc'
 ]
 
 # Build library
diff --git a/src/common/SSLUtil.cc b/src/common/SSLUtil.cc
new file mode 100644
index 0000000000..88ef873904
--- /dev/null
+++ b/src/common/SSLUtil.cc
@@ -0,0 +1,327 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "SSLUtil.h"
+
+#include <openssl/bio.h>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+#include <openssl/pem.h>
+#include <zlib.h>
+
+namespace ssl_util
+{
+
+    void base64_decode(const std::string& in, std::string& out)
+    {
+        BIO * bio_64  = BIO_new(BIO_f_base64());
+
+        BIO * bio_mem_in  = BIO_new(BIO_s_mem());
+        BIO * bio_mem_out = BIO_new(BIO_s_mem());
+
+        bio_64 = BIO_push(bio_64, bio_mem_in);
+
+        BIO_set_flags(bio_64, BIO_FLAGS_BASE64_NO_NL);
+
+        BIO_write(bio_mem_in, in.c_str(), in.length());
+
+        char inbuf[512];
+        int  inlen;
+
+        while ((inlen = BIO_read(bio_64, inbuf, 512)) > 0)
+        {
+            BIO_write(bio_mem_out, inbuf, inlen);
+        }
+
+        char * decoded_c;
+
+        long int size = BIO_get_mem_data(bio_mem_out, &decoded_c);
+
+        out.assign(decoded_c, size);
+
+        BIO_free_all(bio_64);
+        BIO_free_all(bio_mem_out);
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /* -------------------------------------------------------------------------- */
+
+    int base64_encode(const std::string& in, std::string &out)
+    {
+        BIO * bio_64  = BIO_new(BIO_f_base64());
+        BIO * bio_mem = BIO_new(BIO_s_mem());
+
+        BIO_push(bio_64, bio_mem);
+
+        BIO_set_flags(bio_64, BIO_FLAGS_BASE64_NO_NL);
+
+        BIO_write(bio_64, in.c_str(), in.length());
+
+        if (BIO_flush(bio_64) != 1)
+        {
+            return -1;
+        }
+
+        char * encoded_c;
+
+        long int size = BIO_get_mem_data(bio_mem, &encoded_c);
+
+        out.assign(encoded_c, size);
+
+        BIO_free_all(bio_64);
+
+        return 0;
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /* -------------------------------------------------------------------------- */
+
+    /**
+     *  Buffer length for zlib inflate/deflate
+     */
+    #define ZBUFFER 16384
+
+    int zlib_decompress(const std::string& in, std::string& out)
+    {
+        if ( in.empty() )
+        {
+            return -1;
+        }
+
+        z_stream zs;
+
+        zs.zalloc = Z_NULL;
+        zs.zfree  = Z_NULL;
+        zs.opaque = Z_NULL;
+
+        zs.avail_in = 0;
+        zs.next_in  = Z_NULL;
+
+        if ( inflateInit(&zs) != Z_OK)
+        {
+            return -1;
+        }
+
+        zs.avail_in = in.size();
+        zs.next_in  = (unsigned char *) const_cast<char *>(in.c_str());
+
+        if ( zs.avail_in <= 2 ) //At least 2 byte header
+        {
+            inflateEnd(&zs);
+
+            return -1;
+        }
+
+        unsigned char zbuf[ZBUFFER];
+        std::string result;
+        int rc;
+
+        do
+        {
+            zs.avail_out = ZBUFFER;
+            zs.next_out  = zbuf;
+
+            rc = inflate(&zs, Z_FINISH);
+
+            if ( rc != Z_STREAM_END && rc != Z_OK && rc != Z_BUF_ERROR )
+            {
+                inflateEnd(&zs);
+
+                return -1;
+            }
+
+            result.append((const char *) zbuf, (size_t) (ZBUFFER - zs.avail_out));
+        } while (rc != Z_STREAM_END);
+
+        inflateEnd(&zs);
+
+        out = result;
+
+        return 0;
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /* -------------------------------------------------------------------------- */
+
+    int zlib_compress(const std::string& in, std::string& out)
+    {
+        if ( in.empty() )
+        {
+            return -1;
+        }
+
+        z_stream zs;
+
+        zs.zalloc = Z_NULL;
+        zs.zfree  = Z_NULL;
+        zs.opaque = Z_NULL;
+
+        if ( deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK )
+        {
+            return -1;
+        }
+
+        zs.avail_in = in.size();
+        zs.next_in  = (unsigned char *) const_cast<char *>(in.c_str());
+
+        unsigned char zbuf[ZBUFFER];
+        std::string result;
+
+        do
+        {
+            zs.avail_out = ZBUFFER;
+            zs.next_out  = zbuf;
+
+            if ( deflate(&zs, Z_FINISH) == Z_STREAM_ERROR )
+            {
+                deflateEnd(&zs);
+                return -1;
+            }
+
+            result.append((const char *) zbuf, (size_t) (ZBUFFER - zs.avail_out));
+        } while (zs.avail_out == 0);
+
+        deflateEnd(&zs);
+
+        out = result;
+
+        return 0;
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /* -------------------------------------------------------------------------- */
+    static std::string pubk_path;
+    static std::string prik_path;
+
+    void init_rsa_keys(const std::string& pub_key, const std::string& pri_key)
+    {
+        pubk_path = pub_key;
+        prik_path = pri_key;
+    }
+
+    bool is_rsa_set()
+    {
+        return !prik_path.empty();
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /* -------------------------------------------------------------------------- */
+
+    int rsa_public_encrypt(const std::string& in, std::string& out)
+    {
+        static RSA * rsa = nullptr;
+
+        if ( rsa == nullptr) //initialize RSA structure
+        {
+            FILE * fp = fopen(pubk_path.c_str(), "r");
+
+            if ( fp == nullptr )
+            {
+                return -1;
+            }
+
+            rsa = PEM_read_RSAPublicKey(fp, &rsa, nullptr, nullptr);
+
+            if ( rsa == nullptr )
+            {
+                return -1;
+            }
+
+            fclose(fp);
+        }
+
+        char * out_c = (char *) malloc(sizeof(char) * RSA_size(rsa));
+
+        int rc = RSA_public_encrypt(in.length(), (const unsigned char *) in.c_str(),
+                (unsigned char *) out_c, rsa, RSA_PKCS1_PADDING);
+
+        if ( rc != -1 )
+        {
+            out.assign(out_c, rc);
+            rc = 0;
+        }
+
+        free(out_c);
+
+        return rc;
+    }
+
+    /* -------------------------------------------------------------------------- */
+    /* -------------------------------------------------------------------------- */
+
+    int rsa_private_decrypt(const std::string& in, std::string& out)
+    {
+        static RSA * rsa = nullptr;
+
+        if ( rsa == nullptr) //initialize RSA structure
+        {
+            FILE * fp = fopen(prik_path.c_str(), "r");
+
+            if ( fp == nullptr )
+            {
+                return -1;
+            }
+
+            rsa = PEM_read_RSAPrivateKey(fp, &rsa, nullptr, nullptr);
+
+            if ( rsa == nullptr )
+            {
+                return -1;
+            }
+
+            fclose(fp);
+        }
+
+        std::string result;
+
+        int key_size = RSA_size(rsa);
+        int in_size  = in.length();
+        char * out_c = (char *) malloc(sizeof(char) * RSA_size(rsa));
+
+        const char * in_c = in.c_str();
+
+        for (int index = 0; index < in_size; index += key_size)
+        {
+            int block_size = key_size;
+
+            if ( index + key_size > in_size )
+            {
+                block_size = in_size - index;
+            }
+
+            int rc = RSA_private_decrypt(block_size, (const unsigned char *)
+                    in_c + index, (unsigned char *) out_c, rsa, RSA_PKCS1_PADDING);
+
+            if ( rc != -1 )
+            {
+                result.append(out_c, rc);
+                rc = 0;
+            }
+            else
+            {
+                free(out_c);
+                return -1;
+            }
+        }
+
+        free(out_c);
+
+        out = result;
+
+        return 0;
+    }
+
+} // namespase ssl_util
\ No newline at end of file
diff --git a/src/datastore/Datastore.cc b/src/datastore/Datastore.cc
index 44d8ac6ddd..05efd787e7 100644
--- a/src/datastore/Datastore.cc
+++ b/src/datastore/Datastore.cc
@@ -20,16 +20,7 @@
 #include "NebulaLog.h"
 #include "Nebula.h"
 #include "VirtualMachineDisk.h"
-
-const char * Datastore::table = "datastore_pool";
-
-const char * Datastore::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * Datastore::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS datastore_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+#include "OneDB.h"
 
 /* ************************************************************************ */
 /* Datastore :: Constructor/Destructor                                      */
@@ -43,7 +34,7 @@ Datastore::Datastore(
         int                 umask,
         DatastoreTemplate*  ds_template,
         const set<int>      &cluster_ids):
-            PoolObjectSQL(-1,DATASTORE,"",uid,gid,uname,gname,table),
+            PoolObjectSQL(-1,DATASTORE,"",uid,gid,uname,gname,one_db::ds_table),
             Clusterable(cluster_ids),
             ds_mad(""),
             tm_mad(""),
@@ -704,7 +695,7 @@ int Datastore::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::ds_table << " SET "
             << "name = '"    << sql_name << "', "
             << "body = '"    << sql_xml  << "', "
             << "uid = "      << uid      << ", "
@@ -716,7 +707,8 @@ int Datastore::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table  << " ("<< db_names <<") VALUES ("
+        oss << "INSERT INTO " << one_db::ds_table
+            << " ("<< one_db::ds_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -758,6 +750,16 @@ error_common:
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
+int Datastore::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::ds_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
 string& Datastore::to_xml(string& xml) const
 {
     ostringstream   oss;
diff --git a/src/datastore/DatastorePool.cc b/src/datastore/DatastorePool.cc
index 5147c6448b..b957202634 100644
--- a/src/datastore/DatastorePool.cc
+++ b/src/datastore/DatastorePool.cc
@@ -45,7 +45,7 @@ DatastorePool::DatastorePool(
         SqlDB * db,
         const vector<const SingleAttribute *>& _inherit_attrs,
         vector<const SingleAttribute *>& encrypted_attrs) :
-    PoolSQL(db, Datastore::table)
+    PoolSQL(db, one_db::ds_table)
 
 {
     ostringstream oss;
diff --git a/src/dm/DispatchManagerActions.cc b/src/dm/DispatchManagerActions.cc
index 3d9d5c6374..2cd91b3fb7 100644
--- a/src/dm/DispatchManagerActions.cc
+++ b/src/dm/DispatchManagerActions.cc
@@ -20,6 +20,7 @@
 #include "VirtualMachineManager.h"
 #include "TransferManager.h"
 #include "ImageManager.h"
+#include "LifeCycleManager.h"
 #include "Quotas.h"
 #include "Request.h"
 #include "Nebula.h"
@@ -1311,7 +1312,7 @@ int DispatchManager::delete_vm_db(VirtualMachine * vm,
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-static void close_cp_history(VirtualMachinePool *vmpool, VirtualMachine *vm, 
+static void close_cp_history(VirtualMachinePool *vmpool, VirtualMachine *vm,
         VMActions::Action action, const RequestAttributes& ra)
 {
     time_t the_time = time(0);
diff --git a/src/document/Document.cc b/src/document/Document.cc
index ef279a3723..932adc102d 100644
--- a/src/document/Document.cc
+++ b/src/document/Document.cc
@@ -15,6 +15,7 @@
 /* ------------------------------------------------------------------------ */
 
 #include "Document.h"
+#include "OneDB.h"
 
 /* ************************************************************************ */
 /* Document :: Constructor/Destructor                                       */
@@ -27,8 +28,9 @@ Document::Document( int id,
                     const string& _gname,
                     int _umask,
                     int _type,
-                    Template * _template_contents):
-        PoolObjectSQL(id,DOCUMENT,"",_uid,_gid,_uname,_gname,table), type(_type)
+                    Template * _template_contents)
+    : PoolObjectSQL(id,DOCUMENT,"",_uid,_gid,_uname,_gname,one_db::doc_table)
+    , type(_type)
 {
     if (_template_contents != 0)
     {
@@ -46,19 +48,6 @@ Document::Document( int id,
 /* Document :: Database Access Functions                                    */
 /* ************************************************************************ */
 
-const char * Document::table = "document_pool";
-
-const char * Document::db_names =
-        "oid, name, body, type, uid, gid, owner_u, group_u, other_u";
-
-const char * Document::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS document_pool (oid INTEGER PRIMARY KEY, "
-    "name VARCHAR(128), body MEDIUMTEXT, type INTEGER, uid INTEGER, gid INTEGER, "
-    "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 int Document::insert(SqlDB *db, string& error_str)
 {
     int             rc;
@@ -126,7 +115,7 @@ int Document::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if(replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::doc_table << " SET "
             << "name = '"    << sql_name << "', "
             << "body = '"    << sql_xml  << "', "
             << "type = "     << type     << ", "
@@ -139,7 +128,8 @@ int Document::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::doc_table
+            << " (" << one_db::doc_db_names << ") VALUES ("
             <<            oid        << ","
             << "'"     << sql_name   << "',"
             << "'"     << sql_xml    << "',"
@@ -179,6 +169,16 @@ error_common:
     return -1;
 }
 
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+int Document::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::doc_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+}
+
 /* ************************************************************************ */
 /* Document :: Misc                                                         */
 /* ************************************************************************ */
diff --git a/src/group/Group.cc b/src/group/Group.cc
index 2f4f73a540..33a527af1b 100644
--- a/src/group/Group.cc
+++ b/src/group/Group.cc
@@ -17,18 +17,21 @@
 #include "Group.h"
 #include "Nebula.h"
 #include "AclManager.h"
+#include "OneDB.h"
 
 #include <sstream>
 
-const char * Group::table = "group_pool";
+Group::Group(int id, const string& name):
+    PoolObjectSQL(id,GROUP,name,-1,-1,"","",one_db::group_table),
+    quota(),
+    users("USERS"),
+    admins("ADMINS")
+{
+    // Allow users in this group to see it
+    group_u = 1;
 
-const char * Group::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * Group::db_bootstrap = "CREATE TABLE IF NOT EXISTS group_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name))";
+    obj_template = new GroupTemplate;
+}
 
 /* ************************************************************************ */
 /* Group :: Database Access Functions                                       */
@@ -138,7 +141,7 @@ int Group::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::group_table << " SET "
             << "name = '"    << sql_name << "', "
             << "body = '"    << sql_xml  << "', "
             << "uid = "      << uid      << ", "
@@ -150,15 +153,16 @@ int Group::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
-        <<          oid                 << ","
-        << "'" <<   sql_name            << "',"
-        << "'" <<   sql_xml             << "',"
-        <<          uid                 << ","
-        <<          gid                 << ","
-        <<          owner_u             << ","
-        <<          group_u             << ","
-        <<          other_u             << ")";
+        oss << "INSERT INTO " << one_db::group_table
+            << " (" << one_db::group_db_names << ") VALUES ("
+            <<          oid                 << ","
+            << "'" <<   sql_name            << "',"
+            << "'" <<   sql_xml             << "',"
+            <<          uid                 << ","
+            <<          gid                 << ","
+            <<          owner_u             << ","
+            <<          group_u             << ","
+            <<          other_u             << ")";
     }
 
     rc = db->exec_wr(oss);
@@ -242,6 +246,16 @@ string& Group::to_xml_extended(string& xml, bool extended) const
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
+int Group::bootstrap(SqlDB * db)
+{
+    ostringstream oss_group(one_db::group_db_bootstrap);
+
+    return db->exec_local_wr(oss_group);
+}
+
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
 int Group::from_xml(const string& xml)
 {
     int rc = 0;
diff --git a/src/group/GroupPool.cc b/src/group/GroupPool.cc
index e370c6951b..b3ca9f3bd0 100644
--- a/src/group/GroupPool.cc
+++ b/src/group/GroupPool.cc
@@ -17,6 +17,7 @@
 #include "GroupPool.h"
 #include "Nebula.h"
 #include "NebulaLog.h"
+#include "OneDB.h"
 
 #include <stdexcept>
 
@@ -38,7 +39,8 @@ const int    GroupPool::USERS_ID      = 1;
 /* -------------------------------------------------------------------------- */
 
 GroupPool::GroupPool(SqlDB * db, bool is_slave,
-        vector<const SingleAttribute *>& restricted_attrs):PoolSQL(db, Group::table)
+        vector<const SingleAttribute *>& restricted_attrs)
+    : PoolSQL(db, one_db::group_table)
 {
     ostringstream oss;
     string        error_str;
@@ -225,10 +227,10 @@ int GroupPool::dump(string& oss, const string& where, int sid, int eid, bool des
 
     ostringstream cmd;
 
-    cmd << "SELECT " << Group::table << ".body, "
-        << GroupQuotas::db_table << ".body" << " FROM " << Group::table
-        << " LEFT JOIN " << GroupQuotas::db_table << " ON "
-        << Group::table << ".oid=" << GroupQuotas::db_table << ".group_oid";
+    cmd << "SELECT " << one_db::group_table << ".body, "
+        << one_db::group_quotas_db_table << ".body" << " FROM " << one_db::group_table
+        << " LEFT JOIN " << one_db::group_quotas_db_table << " ON "
+        << one_db::group_table << ".oid=" << one_db::group_quotas_db_table << ".group_oid";
 
     if ( !where.empty() )
     {
diff --git a/src/hm/Hook.cc b/src/hm/Hook.cc
index f688458ed2..73e9515687 100644
--- a/src/hm/Hook.cc
+++ b/src/hm/Hook.cc
@@ -21,21 +21,26 @@
 #include "HookStateHost.h"
 #include "HookStateVM.h"
 #include "HookLog.h"
+#include "OneDB.h"
 
 #include <string>
 
-/* ************************************************************************ */
-/* Hook :: Database Access Functions                                        */
-/* ************************************************************************ */
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
 
-const char * Hook::table = "hook_pool";
-
-const char * Hook::db_names =
-    "oid, name, body, uid, gid, owner_u, group_u, other_u, type";
-
-const char * Hook::db_bootstrap = "CREATE TABLE IF NOT EXISTS hook_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER,"
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, type INTEGER)";
+Hook::Hook(Template * tmpl):
+    PoolObjectSQL(-1, HOOK, "", -1, -1, "", "", one_db::hook_table),
+    type(HookType::UNDEFINED), cmd(""), remote(false), _hook(0)
+{
+    if (tmpl != 0)
+    {
+        obj_template = tmpl;
+    }
+    else
+    {
+        obj_template = new Template();
+    }
+};
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -175,6 +180,16 @@ int Hook::post_update_template(string& error)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
+int Hook::bootstrap(SqlDB * db)
+{
+    std::ostringstream oss_hook(one_db::hook_db_bootstrap);
+
+    return db->exec_local_wr(oss_hook);
+};
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
 int Hook::insert(SqlDB *db, std::string& error_str)
 {
     std::string type_str;
@@ -286,7 +301,8 @@ int Hook::insert_replace(SqlDB *db, bool replace, std::string& error_str)
     }
 
     // Construct the SQL statement to Insert or Replace
-    oss <<" INTO "<<table <<" ("<< db_names <<") VALUES ("
+    oss <<" INTO "<<one_db::hook_table
+        << " (" <<  one_db::hook_db_names << ") VALUES ("
         <<          oid            << ","
         << "'" <<   sql_name       << "',"
         << "'" <<   sql_xml        << "',"
@@ -391,7 +407,7 @@ int Hook::drop(SqlDB *db)
     ostringstream oss;
     int rc;
 
-    oss << "DELETE FROM " << table << " WHERE oid=" << oid;
+    oss << "DELETE FROM " << one_db::hook_table << " WHERE oid=" << oid;
 
     rc = db->exec_wr(oss);
 
diff --git a/src/hm/HookLog.cc b/src/hm/HookLog.cc
index 127d626762..470fec9034 100644
--- a/src/hm/HookLog.cc
+++ b/src/hm/HookLog.cc
@@ -27,20 +27,9 @@
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-const char * HookLog::table = "hook_log";
-
-const char * HookLog::db_names = "hkid, exeid, timestamp, rc, body";
-
-const char * HookLog::db_bootstrap = "CREATE TABLE IF NOT EXISTS hook_log"
-    " (hkid INTEGER, exeid INTEGER, timestamp INTEGER, rc INTEGER,"
-    " body MEDIUMTEXT,PRIMARY KEY(hkid, exeid))";
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
 int HookLog::bootstrap(SqlDB * db)
 {
-    std::ostringstream oss_hook(HookLog::db_bootstrap);
+    std::ostringstream oss_hook(one_db::hook_log_db_bootstrap);
 
     return db->exec_local_wr(oss_hook);
 }
@@ -64,7 +53,7 @@ int HookLog::_dump_log(int hkid, int exec_id, std::string &xml_log)
 
     string_cb cb(1);
 
-    cmd << "SELECT body FROM "<< table;
+    cmd << "SELECT body FROM "<< one_db::hook_log_table;
 
     if ( hkid == -1 )
     {
@@ -99,7 +88,7 @@ int HookLog::dump_log(const std::string &where_clause, std::string &xml_log)
 
     string_cb cb(1);
 
-    cmd << "SELECT body FROM "<< table;
+    cmd << "SELECT body FROM "<< one_db::hook_log_table;
 
     if (!where_clause.empty())
     {
@@ -141,8 +130,9 @@ int HookLog::dump_log(std::string &xml_log)
 int HookLog::drop(SqlDB *db, const int hook_id)
 {
     ostringstream oss;
-    
-    oss << "DELETE FROM " << table << " WHERE hkid =" << hook_id;
+
+    oss << "DELETE FROM " << one_db::hook_log_table
+        << " WHERE hkid =" << hook_id;
 
     return db->exec_wr(oss);
 }
@@ -204,7 +194,8 @@ int HookLog::add(int hkid, int hkrc, std::string &xml_result)
 
     oss.str("");
 
-    oss <<"INSERT INTO "<< table <<" ("<< db_names <<") VALUES ("
+    oss << "INSERT INTO " << one_db::hook_log_table
+        << " (" << one_db::hook_log_db_names << ") VALUES ("
         << hkid       << ","
         << last_exeid << ","
         << the_time   << ","
@@ -217,7 +208,8 @@ int HookLog::add(int hkid, int hkrc, std::string &xml_result)
     {
         oss.str("");
 
-        oss << "DELETE FROM " << table << " WHERE hkid = " << hkid
+        oss << "DELETE FROM " << one_db::hook_log_table
+            << " WHERE hkid = " << hkid
             << " AND exeid <= " << last_exeid - log_retention;
 
         rc = db->exec_wr(oss);
diff --git a/src/hm/HookManager.cc b/src/hm/HookManager.cc
index 69cf9682a7..b7de3f6182 100644
--- a/src/hm/HookManager.cc
+++ b/src/hm/HookManager.cc
@@ -26,7 +26,7 @@ extern "C" void * hm_action_loop(void *arg)
 {
     HookManager *  hm;
 
-    if ( arg == 0 )
+    if ( arg == nullptr )
     {
         return 0;
     }
@@ -47,22 +47,35 @@ extern "C" void * hm_action_loop(void *arg)
 
 int HookManager::start()
 {
-    int               rc;
     pthread_attr_t    pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(HookManagerMessages::UNDEFINED,
+            &HookManager::_undefined);
+
+    register_action(HookManagerMessages::EXECUTE,
+            bind(&HookManager::_execute, this, _1));
+
+    register_action(HookManagerMessages::RETRY,
+            bind(&HookManager::_retry, this, _1));
+
+    register_action(HookManagerMessages::LOG,
+            &HookManager::_log);
+
+    string error;
+    if ( DriverManager::start(error) != 0 )
     {
+        NebulaLog::error("HKM", error);
         return -1;
     }
 
     NebulaLog::log("HKM",Log::INFO,"Starting Hook Manager...");
 
-    pthread_attr_init (&pattr);
-    pthread_attr_setdetachstate (&pattr, PTHREAD_CREATE_JOINABLE);
+    pthread_attr_init(&pattr);
+    pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 
-    rc = pthread_create(&hm_thread,&pattr,hm_action_loop,(void *) this);
+    int rc = pthread_create(&hm_thread,&pattr,hm_action_loop,(void *) this);
 
     return rc;
 }
@@ -70,21 +83,18 @@ int HookManager::start()
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-int HookManager::load_mads(int uid)
+int HookManager::load_drivers(const std::vector<const VectorAttribute*>& _mads)
 {
-    HookManagerDriver *     hm_mad;
-    ostringstream           oss;
-    const VectorAttribute * vattr = 0;
-    int                     rc;
+    const VectorAttribute * vattr = nullptr;
 
     NebulaLog::log("HKM",Log::INFO,"Loading Hook Manager driver.");
 
-    if ( mad_conf.size() > 0 )
+    if ( _mads.size() > 0 )
     {
-        vattr = static_cast<const VectorAttribute *>(mad_conf[0]);
+        vattr = static_cast<const VectorAttribute *>(_mads[0]);
     }
 
-    if ( vattr == 0 )
+    if ( vattr == nullptr )
     {
         NebulaLog::log("HKM",Log::INFO,"Failed to load Hook Manager driver.");
         return -1;
@@ -94,19 +104,15 @@ int HookManager::load_mads(int uid)
 
     hook_conf.replace("NAME",hook_driver_name);
 
-    hm_mad = new HookManagerDriver(0,hook_conf.value(),false);
-
-    rc = add(hm_mad);
-
-    if ( rc == 0 )
+    if ( load_driver(&hook_conf) != 0 )
     {
-        oss.str("");
-        oss << "\tHook Manager loaded";
-
-        NebulaLog::log("HKM",Log::INFO,oss);
+        NebulaLog::error("HKM", "Unable to load Hook Manager driver");
+        return -1;
     }
 
-    return rc;
+    NebulaLog::log("HKM",Log::INFO,"\tHook Manager loaded");
+
+    return 0;
 }
 
 /* -------------------------------------------------------------------------- */
@@ -133,14 +139,15 @@ void HookManager::user_action(const ActionRequest& ar)
 
 void HookManager::send_event_action(const std::string& message)
 {
-    const HookManagerDriver* hmd = get();
+    auto hmd = get();
 
     if ( hmd == nullptr )
     {
         return;
     }
 
-    hmd->execute(message);
+    hook_msg_t msg(HookManagerMessages::EXECUTE, "", -1, message);
+    hmd->write(msg);
 }
 
 /* -------------------------------------------------------------------------- */
@@ -148,14 +155,15 @@ void HookManager::send_event_action(const std::string& message)
 
 void HookManager::retry_action(const std::string& message)
 {
-    const HookManagerDriver* hmd = get();
+    auto hmd = get();
 
     if ( hmd == nullptr )
     {
         return;
     }
 
-    hmd->retry(message);
+    hook_msg_t msg(HookManagerMessages::RETRY, "", -1, message);
+    hmd->write(msg);
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/hm/HookManagerDriver.cc b/src/hm/HookManagerDriver.cc
deleted file mode 100644
index 7fd5b8c9bb..0000000000
--- a/src/hm/HookManagerDriver.cc
+++ /dev/null
@@ -1,159 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include "HookManagerDriver.h"
-#include "Nebula.h"
-#include "NebulaLog.h"
-#include <sstream>
-
-/* ************************************************************************** */
-/* Driver ASCII Protocol Implementation                                       */
-/* ************************************************************************** */
-
-void HookManagerDriver::execute(
-        const string&   message ) const
-{
-    ostringstream oss;
-
-    oss << "EXECUTE " << message << endl;
-
-    write(oss);
-}
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-void HookManagerDriver::retry(
-        const string&   message ) const
-{
-    ostringstream oss;
-
-    oss << "RETRY " << message << endl;
-
-    write(oss);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void HookManagerDriver::protocol(const string& message) const
-{
-    std::string error_str;
-    std::istringstream is(message);
-
-    //stores the action name
-    std::string action;
-    std::string result;
-
-    NebulaLog::log("HKM", Log::DEBUG, "Message received: " + message);
-
-    Nebula& nd  = Nebula::instance();
-    HookLog* hl = nd.get_hl();
-
-    // Parse the driver message
-    if ( is.good() )
-    {
-        is >> action >> ws;
-    }
-    else
-    {
-        error_str = "Error reading driver action.";
-        goto error_common;
-    }
-
-    if ( is.good() )
-    {
-        is >> result >> ws;
-    }
-    else
-    {
-        error_str = "Error reading action result.";
-        goto error_common;
-    }
-
-    // -------------------------------------------------------------------------
-    // Protocol implementation
-    // -------------------------------------------------------------------------
-
-    if ( action == "EXECUTE" )
-    {
-        std::ostringstream oss;
-
-        std::string info_b64;
-        std::string *info;
-
-        int hook_id;
-        int hook_rc;
-
-        // Parse the hook info
-        if ( is.good() )
-        {
-            is >> hook_id >> ws;
-        }
-        else
-        {
-            error_str = "Error reading hook id.";
-            goto error_common;
-        }
-
-        if ( is.good() )
-        {
-            is >> hook_rc >> ws;
-        }
-        else
-        {
-            error_str = "Error reading hook execution return code.";
-            goto error_common;
-        }
-
-        getline(is, info_b64);
-
-        if (result == "SUCCESS")
-        {
-            oss << "Success executing Hook " <<  hook_id;
-            NebulaLog::log("HKM",Log::INFO,oss);
-        }
-        else
-        {
-            oss << "Error executing Hook " << hook_id;
-            NebulaLog::log("HKM",Log::ERROR,oss);
-        }
-
-        info = one_util::base64_decode(info_b64);
-
-        if ( info != 0 )
-        {
-            hl->add(hook_id, hook_rc, *info);
-            delete info;
-        }
-
-    }
-
-    return;
-
-error_common:
-    NebulaLog::log("HKM", Log::ERROR, error_str);
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void HookManagerDriver::recover()
-{
-    NebulaLog::log("HKM", Log::ERROR, "Hook driver crashed, recovering...");
-
-}
diff --git a/src/hm/HookManagerProtocol.cc b/src/hm/HookManagerProtocol.cc
new file mode 100644
index 0000000000..b866b8fc92
--- /dev/null
+++ b/src/hm/HookManagerProtocol.cc
@@ -0,0 +1,99 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "HookManager.h"
+#include "HookLog.h"
+#include "Nebula.h"
+#include "NebulaLog.h"
+#include <sstream>
+
+static void log_msg(hook_msg_t *msg)
+{
+    ostringstream oss;
+
+    oss << "Message received: ";
+    msg->write_to(oss);
+
+    NebulaLog::log("HKM", Log::DEBUG, oss);
+}
+
+/* ************************************************************************** */
+/* Driver Protocol Implementation                                       */
+/* ************************************************************************** */
+
+void HookManager::_undefined(unique_ptr<hook_msg_t> msg)
+{
+    NebulaLog::warn("HKM", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void HookManager::_execute(unique_ptr<hook_msg_t> msg)
+{
+    log_msg(msg.get());
+
+    int hook_id = msg->oid();
+    int hook_rc;
+
+    istringstream is(msg->payload());
+
+    is >> hook_rc >> ws;
+
+    if (is.bad())
+    {
+        NebulaLog::error("HKM", "Error reading hook execution return code.");
+        return;
+    }
+
+    ostringstream oss;
+    if (msg->status() == "SUCCESS")
+    {
+        oss << "Success executing Hook " << hook_id;
+        NebulaLog::log("HKM", Log::INFO, oss);
+    }
+    else
+    {
+        oss << "Error executing Hook " << hook_id;
+        NebulaLog::log("HKM", Log::ERROR, oss);
+    }
+
+    std::string info_b64;
+    getline(is, info_b64);
+
+    string* info = one_util::base64_decode(info_b64);
+
+    if (info != nullptr)
+    {
+        HookLog* hl = Nebula::instance().get_hl();
+
+        hl->add(hook_id, hook_rc, *info);
+        delete info;
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void HookManager::_retry(unique_ptr<hook_msg_t> msg)
+{
+    log_msg(msg.get());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void HookManager::_log(unique_ptr<hook_msg_t> msg)
+{
+    NebulaLog::log("HKM", log_type(msg->status()[0]), msg->payload());
+}
diff --git a/src/hm/SConstruct b/src/hm/SConstruct
index 060f83fd76..1828f968af 100755
--- a/src/hm/SConstruct
+++ b/src/hm/SConstruct
@@ -28,7 +28,7 @@ source_files=[
     'HookStateVM.cc',
     'HookStateHost.cc',
     'HookManager.cc',
-    'HookManagerDriver.cc',
+    'HookManagerProtocol.cc',
     'ExecuteHook.cc',
     'HookLog.cc'
 ]
diff --git a/src/hm_mad/one_hm.rb b/src/hm_mad/one_hm.rb
index 1a6cf2fd1b..5e4cc2229b 100755
--- a/src/hm_mad/one_hm.rb
+++ b/src/hm_mad/one_hm.rb
@@ -83,7 +83,7 @@ class HookManagerDriver < OpenNebulaDriver
         end
     end
 
-    def action_execute(*arguments)
+    def action_execute(_not_used, *arguments)
         arg_xml = Nokogiri::XML(Base64.decode64(arguments.flatten[0]))
         type    = arg_xml.xpath('//HOOK_TYPE').text
 
@@ -97,7 +97,7 @@ class HookManagerDriver < OpenNebulaDriver
         end
     end
 
-    def action_retry(*arguments)
+    def action_retry(_not_used, *arguments)
         arguments.flatten!
 
         command = arguments[0]
diff --git a/src/im/InformationManager.cc b/src/im/InformationManager.cc
index 61d755a2d4..3f5e5575a7 100644
--- a/src/im/InformationManager.cc
+++ b/src/im/InformationManager.cc
@@ -16,7 +16,6 @@
 
 #include "InformationManager.h"
 #include "HostPool.h"
-#include "OpenNebulaMessages.h"
 #include "VirtualMachinePool.h"
 #include "Nebula.h"
 #include "LifeCycleManager.h"
@@ -30,16 +29,16 @@ int InformationManager::start()
 
     using namespace std::placeholders; // for _1
 
-    register_action(OpenNebulaMessages::UNDEFINED,
+    register_action(InformationManagerMessages::UNDEFINED,
             &InformationManager::_undefined);
 
-    register_action(OpenNebulaMessages::HOST_STATE,
+    register_action(InformationManagerMessages::HOST_STATE,
             bind(&InformationManager::_host_state, this, _1));
 
-    register_action(OpenNebulaMessages::HOST_SYSTEM,
+    register_action(InformationManagerMessages::HOST_SYSTEM,
             bind(&InformationManager::_host_system, this, _1));
 
-    register_action(OpenNebulaMessages::VM_STATE,
+    register_action(InformationManagerMessages::VM_STATE,
             bind(&InformationManager::_vm_state, this, _1));
 
     int rc = DriverManager::start(error);
@@ -85,9 +84,9 @@ void InformationManager::stop_monitor(int hid, const string& name, const string&
     data.add("IM_MAD", im_mad);
     string tmp;
 
-    Message<OpenNebulaMessages> msg;
+    im_msg_t msg;
 
-    msg.type(OpenNebulaMessages::STOP_MONITOR);
+    msg.type(InformationManagerMessages::STOP_MONITOR);
     msg.oid(hid);
     msg.payload(data.to_xml(tmp));
 
@@ -112,9 +111,9 @@ int InformationManager::start_monitor(Host * host, bool update_remotes)
         return -1;
     }
 
-    Message<OpenNebulaMessages> msg;
+    im_msg_t msg;
 
-    msg.type(OpenNebulaMessages::START_MONITOR);
+    msg.type(InformationManagerMessages::START_MONITOR);
     msg.oid(host->get_oid());
     msg.payload(to_string(update_remotes));
 
@@ -136,9 +135,9 @@ void InformationManager::update_host(Host *host)
     }
 
     string tmp;
-    Message<OpenNebulaMessages> msg;
+    im_msg_t msg;
 
-    msg.type(OpenNebulaMessages::UPDATE_HOST);
+    msg.type(InformationManagerMessages::UPDATE_HOST);
     msg.oid(host->get_oid());
     msg.payload(host->to_xml(tmp));
 
@@ -157,9 +156,9 @@ void InformationManager::delete_host(int hid)
         return;
     }
 
-    Message<OpenNebulaMessages> msg;
+    im_msg_t msg;
 
-    msg.type(OpenNebulaMessages::DEL_HOST);
+    msg.type(InformationManagerMessages::DEL_HOST);
     msg.oid(hid);
 
     imd->write(msg);
@@ -186,17 +185,17 @@ void InformationManager::raft_status(RaftManager::State state)
 
         hpool->dump(xml_hosts, "", 0, -1, false);
 
-        Message<OpenNebulaMessages> msg;
+        im_msg_t msg;
 
-        msg.type(OpenNebulaMessages::HOST_LIST);
+        msg.type(InformationManagerMessages::HOST_LIST);
         msg.payload(xml_hosts);
 
         imd->write(msg);
     }
 
-    Message<OpenNebulaMessages> msg;
+    im_msg_t msg;
 
-    msg.type(OpenNebulaMessages::RAFT_STATUS);
+    msg.type(InformationManagerMessages::RAFT_STATUS);
     msg.payload(RaftManager::state_to_str(state));
 
     imd->write(msg);
@@ -205,7 +204,7 @@ void InformationManager::raft_status(RaftManager::State state)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void InformationManager::_undefined(unique_ptr<Message<OpenNebulaMessages>> msg)
+void InformationManager::_undefined(unique_ptr<im_msg_t> msg)
 {
     NebulaLog::warn("InM", "Received undefined message: " + msg->payload() +
             "from host: " + to_string(msg->oid()));
@@ -215,7 +214,7 @@ void InformationManager::_undefined(unique_ptr<Message<OpenNebulaMessages>> msg)
 /* -------------------------------------------------------------------------- */
 /* HOST_STATE - <state_str> <optional_desciption>                             */
 
-void InformationManager::_host_state(unique_ptr<Message<OpenNebulaMessages>> msg)
+void InformationManager::_host_state(unique_ptr<im_msg_t> msg)
 {
     NebulaLog::ddebug("InM", "HOST_STATE update from host: " +
         to_string(msg->oid()) + ". Host information: " + msg->payload());
@@ -281,7 +280,7 @@ void InformationManager::_host_state(unique_ptr<Message<OpenNebulaMessages>> msg
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void InformationManager::_host_system(unique_ptr<Message<OpenNebulaMessages>> msg)
+void InformationManager::_host_system(unique_ptr<im_msg_t> msg)
 {
     NebulaLog::ddebug("InM", "HOST_SYSTEM update from host: " +
         to_string(msg->oid()) + ". Host information: " + msg->payload());
@@ -397,7 +396,7 @@ static LCMAction::Actions test_and_trigger(const string& state_str,
 }
 
 
-void InformationManager::_vm_state(unique_ptr<Message<OpenNebulaMessages>> msg)
+void InformationManager::_vm_state(unique_ptr<im_msg_t> msg)
 {
     LifeCycleManager* lcm = Nebula::instance().get_lcm();
 
diff --git a/src/im_mad/im_exec/one_im_exec.rb b/src/im_mad/im_exec/one_im_exec.rb
index b508eb84bf..3b8fd0aa93 100755
--- a/src/im_mad/im_exec/one_im_exec.rb
+++ b/src/im_mad/im_exec/one_im_exec.rb
@@ -213,7 +213,7 @@ class InformationManagerDriver < OpenNebulaDriver
             zline   = Zlib::Deflate.deflate(line.strip, Zlib::BEST_COMPRESSION)
             zline64 = Base64.strict_encode64(zline)
 
-            send_message('LOG', severity, id, zline64)
+            send_message('LOG', severity, id, "#{Time.now.to_i} #{zline64}")
         end
     end
 
diff --git a/src/image/Image.cc b/src/image/Image.cc
index 018fbc83ca..a2482abe78 100644
--- a/src/image/Image.cc
+++ b/src/image/Image.cc
@@ -40,7 +40,7 @@ Image::Image(int             _uid,
              const string&   _gname,
              int             _umask,
              ImageTemplate * _image_template):
-        PoolObjectSQL(-1,IMAGE,"",_uid,_gid,_uname,_gname,table),
+        PoolObjectSQL(-1,IMAGE,"",_uid,_gid,_uname,_gname,one_db::image_table),
         type(OS),
         disk_type(FILE),
         regtime(time(0)),
@@ -76,19 +76,6 @@ Image::Image(int             _uid,
 /* Image :: Database Access Functions                                       */
 /* ************************************************************************ */
 
-const char * Image::table = "image_pool";
-
-const char * Image::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * Image::db_bootstrap = "CREATE TABLE IF NOT EXISTS image_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name,uid) )";
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 int Image::insert(SqlDB *db, string& error_str)
 {
     int rc;
@@ -286,7 +273,7 @@ int Image::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if (replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::image_table << " SET "
             << "name = '"    << sql_name << "', "
             << "body = '"    << sql_xml  << "', "
             << "uid = "      << uid      << ", "
@@ -298,7 +285,8 @@ int Image::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::image_table
+            << " (" << one_db::image_db_names << ") VALUES ("
             <<          oid             << ","
             << "'" <<   sql_name        << "',"
             << "'" <<   sql_xml         << "',"
@@ -337,8 +325,18 @@ error_common:
     return -1;
 }
 
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+int Image::bootstrap(SqlDB * db)
+{
+    ostringstream oss_image(one_db::image_db_bootstrap);
+
+    return db->exec_local_wr(oss_image);
+};
+
 /* ************************************************************************ */
-/* Image :: Misc                                                             */
+/* Image :: Misc                                                            */
 /* ************************************************************************ */
 
 string& Image::to_xml(string& xml) const
diff --git a/src/image/ImageManager.cc b/src/image/ImageManager.cc
index 8e3864a0d8..5f052359be 100644
--- a/src/image/ImageManager.cc
+++ b/src/image/ImageManager.cc
@@ -48,21 +48,18 @@ extern "C" void * image_action_loop(void *arg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-int ImageManager::load_mads(int uid)
+int ImageManager::load_drivers(const std::vector<const VectorAttribute*>& _mads)
 {
-    ImageManagerDriver *    imagem_mad;
-    ostringstream           oss;
     const VectorAttribute * vattr = 0;
-    int                     rc;
 
     NebulaLog::log("ImM",Log::INFO,"Loading Image Manager driver.");
 
-    if ( mad_conf.size() > 0 )
+    if (_mads.size() > 0)
     {
-        vattr = static_cast<const VectorAttribute *>(mad_conf[0]);
+        vattr = _mads[0];
     }
 
-    if ( vattr == 0 )
+    if (vattr == nullptr)
     {
         NebulaLog::log("ImM",Log::INFO,"Failed to load Image Manager driver.");
         return -1;
@@ -70,21 +67,17 @@ int ImageManager::load_mads(int uid)
 
     VectorAttribute image_conf("IMAGE_MAD",vattr->value());
 
-    image_conf.replace("NAME",image_driver_name);
+    image_conf.replace("NAME", image_driver_name);
 
-    imagem_mad= new ImageManagerDriver(0,image_conf.value(),false,ipool,dspool);
-
-    rc = add(imagem_mad);
-
-    if ( rc == 0 )
+    if (load_driver(&image_conf) != 0)
     {
-        oss.str("");
-        oss << "\tImage Manager loaded";
-
-        NebulaLog::log("ImM",Log::INFO,oss);
+        NebulaLog::error("ImM", "Unable to load Image Manager driver");
+        return -1;
     }
 
-    return rc;
+    NebulaLog::info("ImM", "\tImage Manager loaded");
+
+    return 0;
 }
 
 /* -------------------------------------------------------------------------- */
@@ -95,17 +88,53 @@ int ImageManager::start()
     int               rc;
     pthread_attr_t    pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(ImageManagerMessages::UNDEFINED,
+            &ImageManager::_undefined);
+
+    register_action(ImageManagerMessages::STAT,
+            bind(&ImageManager::_stat, this, _1));
+
+    register_action(ImageManagerMessages::CP,
+            bind(&ImageManager::_cp, this, _1));
+
+    register_action(ImageManagerMessages::CLONE,
+            bind(&ImageManager::_clone, this, _1));
+
+    register_action(ImageManagerMessages::MKFS,
+            bind(&ImageManager::_mkfs, this, _1));
+
+    register_action(ImageManagerMessages::RM,
+            bind(&ImageManager::_rm, this, _1));
+
+    register_action(ImageManagerMessages::MONITOR,
+            bind(&ImageManager::_monitor, this, _1));
+
+    register_action(ImageManagerMessages::SNAP_DELETE,
+            bind(&ImageManager::_snap_delete, this, _1));
+
+    register_action(ImageManagerMessages::SNAP_REVERT,
+            bind(&ImageManager::_snap_revert, this, _1));
+
+    register_action(ImageManagerMessages::SNAP_FLATTEN,
+            bind(&ImageManager::_snap_flatten, this, _1));
+
+    register_action(ImageManagerMessages::LOG,
+            &ImageManager::_log);
+
+    NebulaLog::info("ImM", "Starting Image Manager...");
+
+    string error;
+    if (DriverManager::start(error) != 0)
     {
+        NebulaLog::error("ImM", "Unable to start Image Manager driver: "
+            + error);
         return -1;
     }
 
-    NebulaLog::log("ImM",Log::INFO,"Starting Image Manager...");
-
-    pthread_attr_init (&pattr);
-    pthread_attr_setdetachstate (&pattr, PTHREAD_CREATE_JOINABLE);
+    pthread_attr_init(&pattr);
+    pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 
     rc = pthread_create(&imagem_thread,&pattr,image_action_loop,(void *) this);
 
@@ -139,7 +168,6 @@ void ImageManager::timer_action(const ActionRequest& ar)
     int rc;
 
     vector<int>           datastores;
-    vector<int>::iterator it;
 
     Nebula& nd             = Nebula::instance();
     DatastorePool * dspool = nd.get_dspool();
@@ -157,9 +185,9 @@ void ImageManager::timer_action(const ActionRequest& ar)
         return;
     }
 
-    for(it = datastores.begin() ; it != datastores.end(); it++)
+    for (auto ds : datastores)
     {
-        monitor_datastore(*it);
+        monitor_datastore(ds);
     }
 
     return;
@@ -173,7 +201,6 @@ void ImageManager::monitor_datastore(int ds_id)
 {
     static map<int,int> monitor_vm_disk_counter;
     string  ds_data, ds_location, ds_name;
-    string* drv_msg;
 
     bool shared;
 
@@ -184,7 +211,7 @@ void ImageManager::monitor_datastore(int ds_id)
 
     ostringstream oss;
 
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
     if ( imd == 0 )
     {
@@ -245,14 +272,13 @@ void ImageManager::monitor_datastore(int ds_id)
             break;
     }
 
-    drv_msg = ImageManager::format_message("", ds_data, ds_location);
+    unique_ptr<string> drv_msg(ImageManager::format_message("", ds_data, ds_location));
 
     oss.str("");
     oss << "Monitoring datastore " << ds_name  << " (" << ds_id << ")";
 
     NebulaLog::log("InM", Log::DEBUG, oss);
 
-    imd->monitor(ds_id, *drv_msg);
-
-    delete drv_msg;
+    image_msg_t msg(ImageManagerMessages::MONITOR, "", ds_id, *drv_msg);
+    imd->write(msg);
 }
diff --git a/src/image/ImageManagerActions.cc b/src/image/ImageManagerActions.cc
index 460fc9955d..a52312f201 100644
--- a/src/image/ImageManagerActions.cc
+++ b/src/image/ImageManagerActions.cc
@@ -34,7 +34,7 @@ Image * ImageManager::acquire_image(int vm_id, int image_id, bool attach,
 
     img = ipool->get(image_id);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         ostringstream oss;
         oss << "Image with ID: " << image_id  << " does not exist";
@@ -48,7 +48,7 @@ Image * ImageManager::acquire_image(int vm_id, int image_id, bool attach,
     if ( rc != 0 )
     {
         img->unlock();
-        img = 0;
+        img = nullptr;
     }
 
     return img;
@@ -64,7 +64,7 @@ Image * ImageManager::acquire_image(int vm_id, const string& name, int uid,
 
     img = ipool->get(name,uid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         ostringstream oss;
         oss << "User " << uid << " does not own an image with name: " << name
@@ -79,7 +79,7 @@ Image * ImageManager::acquire_image(int vm_id, const string& name, int uid,
     if ( rc != 0 )
     {
         img->unlock();
-        img = 0;
+        img = nullptr;
     }
 
     return img;
@@ -209,7 +209,7 @@ void ImageManager::release_image(int vm_id, int iid, bool failed)
 
     Image * img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         return;
     }
@@ -321,7 +321,7 @@ void ImageManager::release_cloning_resource(
 {
     Image * img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         return;
     }
@@ -383,7 +383,7 @@ int ImageManager::enable_image(int iid, bool to_enable, string& error_str)
 
     img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         return -1;
     }
@@ -447,7 +447,6 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     string   source;
     string   img_tmpl;
-    string * drv_msg;
     string   ds_data;
 
     long long size;
@@ -462,7 +461,7 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     img = ipool->get_ro(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error_str = "Image does not exist";
         return -1;
@@ -474,7 +473,7 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     ds = dspool->get_ro(ds_id);
 
-    if ( ds == 0 )
+    if ( ds == nullptr )
     {
        error_str = "Datastore no longer exists cannot remove image";
        return -1;
@@ -486,7 +485,7 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error_str = "Image does not exist";
         return -1;
@@ -543,9 +542,9 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     /* ------------------- Send RM operation request to the DS -------------- */
 
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         error_str = "Error getting ImageManagerDriver";
 
@@ -553,7 +552,6 @@ int ImageManager::delete_image(int iid, string& error_str)
         return -1;
     }
 
-    drv_msg = format_message(img->to_xml(img_tmpl), ds_data, "");
     source  = img->get_source();
     size    = img->get_size();
     ds_id   = img->get_ds_id();
@@ -575,7 +573,12 @@ int ImageManager::delete_image(int iid, string& error_str)
     }
     else
     {
-        imd->rm(img->get_oid(), *drv_msg);
+        unique_ptr<string> drv_msg(format_message(img->to_xml(img_tmpl), ds_data, ""));
+
+        image_msg_t msg(ImageManagerMessages::RM, "", iid, *drv_msg);
+
+        imd->write(msg);
+
         img->set_state(Image::DELETE);
 
         img->clear_cloning_id();
@@ -587,8 +590,6 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     img->unlock();
 
-    delete drv_msg;
-
     /* -------------------- Update Group & User quota counters -------------- */
 
     Template img_usage;
@@ -607,7 +608,7 @@ int ImageManager::delete_image(int iid, string& error_str)
 
     ds = dspool->get(ds_id);
 
-    if ( ds != 0 )
+    if ( ds != nullptr )
     {
         ds->del_image(iid);
         dspool->update(ds);
@@ -649,7 +650,7 @@ int ImageManager::can_clone_image(int cloning_id, ostringstream&  oss_error)
 
     img = ipool->get_ro(cloning_id);
 
-    if (img == 0)
+    if (img == nullptr)
     {
         oss_error << "Cannot clone image, it does not exist";
         return -1;
@@ -693,7 +694,7 @@ int ImageManager::set_clone_state(
     int     rc  = 0;
     Image * img = ipool->get(cloning_id);
 
-    if (img == 0)
+    if (img == nullptr)
     {
         error = "Cannot clone image, it does not exist";
         return -1;
@@ -749,16 +750,15 @@ int ImageManager::clone_image(int   new_id,
                               const string& extra_data,
                               string& error)
 {
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
     ostringstream oss;
     Image *       img;
 
     string  path;
     string  img_tmpl;
-    string* drv_msg;
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         error = "Could not get datastore driver";
 
@@ -773,7 +773,7 @@ int ImageManager::clone_image(int   new_id,
 
     img = ipool->get_ro(new_id);
 
-    if (img == 0)
+    if (img == nullptr)
     {
         release_cloning_image(cloning_id, new_id);
 
@@ -781,9 +781,11 @@ int ImageManager::clone_image(int   new_id,
         return -1;
     }
 
-    drv_msg = format_message(img->to_xml(img_tmpl), ds_data, extra_data);
+    unique_ptr<string> drv_msg(format_message(img->to_xml(img_tmpl), ds_data, extra_data));
 
-    imd->clone(img->get_oid(), *drv_msg);
+    image_msg_t msg(ImageManagerMessages::CLONE, "", img->get_oid(), *drv_msg);
+
+    imd->write(msg);
 
     oss << "Cloning image " << img->get_path()
         <<" to repository as image "<<img->get_oid();
@@ -792,8 +794,6 @@ int ImageManager::clone_image(int   new_id,
 
     img->unlock();
 
-    delete drv_msg;
-
     return 0;
 }
 
@@ -805,17 +805,16 @@ int ImageManager::register_image(int iid,
                                  const string& extra_data,
                                  string& error)
 {
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
     ostringstream oss;
     Image *       img;
 
     string        path;
     string        img_tmpl;
-    string *      drv_msg;
 
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         error = "Could not get datastore driver";
         NebulaLog::log("ImM",Log::ERROR, error);
@@ -824,13 +823,13 @@ int ImageManager::register_image(int iid,
 
     img = ipool->get(iid);
 
-    if (img == 0)
+    if (img == nullptr)
     {
         error = "Image deleted during copy operation";
         return -1;
     }
 
-    drv_msg = format_message(img->to_xml(img_tmpl), ds_data, extra_data);
+    unique_ptr<string> drv_msg(format_message(img->to_xml(img_tmpl), ds_data, extra_data));
     path    = img->get_path();
 
     if ( path.empty() == true ) //NO PATH
@@ -848,7 +847,8 @@ int ImageManager::register_image(int iid,
         else if ( img->is_saving() || img->get_type() == Image::DATABLOCK
                 || img->get_type() == Image::OS)
         {
-            imd->mkfs(img->get_oid(), *drv_msg);
+            image_msg_t msg(ImageManagerMessages::MKFS, "", img->get_oid(), *drv_msg);
+            imd->write(msg);
 
             oss << "Creating disk at " << source << " of "<<  img->get_size()
                 << "Mb (type: " <<  img->get_fstype() << ")";
@@ -856,7 +856,9 @@ int ImageManager::register_image(int iid,
     }
     else //PATH -> COPY TO REPOSITORY AS SOURCE
     {
-        imd->cp(img->get_oid(), *drv_msg);
+        image_msg_t msg(ImageManagerMessages::CP, "", img->get_oid(), *drv_msg);
+        imd->write(msg);
+
         oss << "Copying " << path <<" to repository for image "<<img->get_oid();
     }
 
@@ -864,8 +866,6 @@ int ImageManager::register_image(int iid,
 
     img->unlock();
 
-    delete drv_msg;
-
     return 0;
 }
 /* -------------------------------------------------------------------------- */
@@ -875,18 +875,15 @@ int ImageManager::stat_image(Template*     img_tmpl,
                              const string& ds_data,
                              string&       res)
 {
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
-    string* drv_msg;
     string  type_att;
 
     ostringstream  img_data;
 
-    SyncRequest sr;
-
     int rc = 0;
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         res = "Could not get datastore driver";
         NebulaLog::log("ImM",Log::ERROR, res);
@@ -975,16 +972,17 @@ int ImageManager::stat_image(Template*     img_tmpl,
             break;
     }
 
+    SyncRequest sr;
+
     add_request(&sr);
 
-    drv_msg = format_message(img_data.str(), ds_data, "");
+    unique_ptr<string> drv_msg(format_message(img_data.str(), ds_data, ""));
 
-    imd->stat(sr.id, *drv_msg);
+    image_msg_t msg(ImageManagerMessages::STAT, "", sr.id, *drv_msg);
+    imd->write(msg);
 
     sr.wait();
 
-    delete drv_msg;
-
     res = sr.message;
 
     if ( sr.result != true )
@@ -998,7 +996,7 @@ int ImageManager::stat_image(Template*     img_tmpl,
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-string * ImageManager::format_message(
+string* ImageManager::format_message(
     const string& img_data,
     const string& ds_data,
     const string& extra_data)
@@ -1021,7 +1019,7 @@ void ImageManager::set_image_snapshots(int iid, const Snapshots& s)
 {
     Image * img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         return;
     }
@@ -1077,7 +1075,7 @@ void ImageManager::set_image_size(int iid, long long size)
 {
     Image * img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         return;
     }
@@ -1114,9 +1112,9 @@ void ImageManager::set_image_size(int iid, long long size)
 
 int ImageManager::delete_snapshot(int iid, int sid, string& error)
 {
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         error = "Could not get datastore driver";
         NebulaLog::log("ImM",Log::ERROR, error);
@@ -1126,7 +1124,7 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
 
     Image * img = ipool->get_ro(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error = "Image does not exist";
         return -1;
@@ -1143,7 +1141,7 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
 
     Datastore * ds = dspool->get_ro(ds_id);
 
-    if ( ds == 0 )
+    if ( ds == nullptr )
     {
        error = "Datastore no longer exists";
        return -1;
@@ -1160,7 +1158,7 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
     /* ---------------------------------------------------------------------- */
     img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error = "Image does not exist";
         return -1;
@@ -1187,9 +1185,11 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
     img->set_target_snapshot(sid);
 
     string img_tmpl;
-    string * drv_msg = format_message(img->to_xml(img_tmpl), ds_data, "");
+    unique_ptr<string> drv_msg(format_message(img->to_xml(img_tmpl), ds_data, ""));
 
-    imd->snapshot_delete(iid, *drv_msg);
+    image_msg_t msg(ImageManagerMessages::SNAP_DELETE, "", iid, *drv_msg);
+
+    imd->write(msg);
 
     img->set_state(Image::LOCKED);
 
@@ -1197,8 +1197,6 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
 
     img->unlock();
 
-    delete drv_msg;
-
     return 0;
 }
 
@@ -1207,9 +1205,9 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
 
 int ImageManager::revert_snapshot(int iid, int sid, string& error)
 {
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         error = "Could not get datastore driver";
         NebulaLog::log("ImM",Log::ERROR, error);
@@ -1219,7 +1217,7 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
 
     Image * img = ipool->get_ro(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error = "Image does not exist";
         return -1;
@@ -1236,7 +1234,7 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
 
     Datastore * ds = dspool->get_ro(ds_id);
 
-    if ( ds == 0 )
+    if ( ds == nullptr )
     {
        error = "Datastore no longer exists";
        return -1;
@@ -1254,7 +1252,7 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
     /* ---------------------------------------------------------------------- */
     img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error = "Image does not exist";
         return -1;
@@ -1291,9 +1289,11 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
     img->set_target_snapshot(sid);
 
     string   img_tmpl;
-    string * drv_msg = format_message(img->to_xml(img_tmpl), ds_data, "");
+    unique_ptr<string> drv_msg(format_message(img->to_xml(img_tmpl), ds_data, ""));
 
-    imd->snapshot_revert(iid, *drv_msg);
+    image_msg_t msg(ImageManagerMessages::SNAP_REVERT, "", iid, *drv_msg);
+
+    imd->write(msg);
 
     img->set_state(Image::LOCKED);
 
@@ -1301,8 +1301,6 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
 
     img->unlock();
 
-    delete drv_msg;
-
     return 0;
 }
 
@@ -1311,9 +1309,9 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
 
 int ImageManager::flatten_snapshot(int iid, int sid, string& error)
 {
-    const ImageManagerDriver* imd = get();
+    const auto* imd = get();
 
-    if ( imd == 0 )
+    if ( imd == nullptr )
     {
         error = "Could not get datastore driver";
         NebulaLog::log("ImM",Log::ERROR, error);
@@ -1323,7 +1321,7 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
 
     Image * img = ipool->get_ro(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error = "Image does not exist";
         return -1;
@@ -1340,7 +1338,7 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
 
     Datastore * ds = dspool->get_ro(ds_id);
 
-    if ( ds == 0 )
+    if ( ds == nullptr )
     {
        error = "Datastore no longer exists";
        return -1;
@@ -1358,7 +1356,7 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
 
     img = ipool->get(iid);
 
-    if ( img == 0 )
+    if ( img == nullptr )
     {
         error = "Image does not exist";
         return -1;
@@ -1388,9 +1386,11 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
     img->set_target_snapshot(sid);
 
     string   img_tmpl;
-    string * drv_msg = format_message(img->to_xml(img_tmpl), ds_data, "");
+    unique_ptr<string> drv_msg(format_message(img->to_xml(img_tmpl), ds_data, ""));
 
-    imd->snapshot_flatten(iid, *drv_msg);
+    image_msg_t msg(ImageManagerMessages::SNAP_FLATTEN, "", iid, *drv_msg);
+
+    imd->write(msg);
 
     img->set_state(Image::LOCKED);
 
@@ -1398,8 +1398,6 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
 
     img->unlock();
 
-    delete drv_msg;
-
     return 0;
 }
 
diff --git a/src/image/ImageManagerDriver.cc b/src/image/ImageManagerDriver.cc
deleted file mode 100644
index c6b17bf6fc..0000000000
--- a/src/image/ImageManagerDriver.cc
+++ /dev/null
@@ -1,1015 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include "ImageManagerDriver.h"
-#include "ImageManager.h"
-#include "ImagePool.h"
-
-#include "NebulaLog.h"
-#include "Quotas.h"
-#include "VirtualMachinePool.h"
-#include "VirtualMachineManagerDriver.h"
-#include "TransferManager.h"
-
-#include "Nebula.h"
-#include <sstream>
-
-/* ************************************************************************** */
-/* Driver ASCII Protocol Implementation                                       */
-/* ************************************************************************** */
-
-void ImageManagerDriver::cp(int           oid,
-                            const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "CP " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::clone(int           oid,
-                               const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "CLONE " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-void ImageManagerDriver::stat(int           oid,
-                              const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "STAT " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::mkfs(int           oid,
-                              const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "MKFS " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::rm(int oid, const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "RM " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::monitor(int oid, const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "MONITOR " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::snapshot_delete(int oid, const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "SNAP_DELETE " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::snapshot_revert(int oid, const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "SNAP_REVERT " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::snapshot_flatten(int oid, const string& drv_msg) const
-{
-    ostringstream os;
-
-    os << "SNAP_FLATTEN " << oid << " " << drv_msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-/* ************************************************************************** */
-/* MAD Interface                                                              */
-/* ************************************************************************** */
-
-static void stat_action(istringstream& is, int id, const string& result)
-{
-    string size_mb;
-    string info;
-
-    Nebula& nd        = Nebula::instance();
-    ImageManager * im = nd.get_imagem();
-
-    if ( result == "SUCCESS" )
-    {
-        if ( is.good() )
-        {
-            is >> size_mb >> ws;
-        }
-
-        if ( is.fail() )
-        {
-            im->notify_request(id, false, "Cannot get size from STAT");
-        }
-
-        im->notify_request(id, true, size_mb);
-    }
-    else
-    {
-        getline(is,info);
-
-        im->notify_request(id, false, info);
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static int cp_action(istringstream& is,
-                     ImagePool*     ipool,
-                     int            id,
-                     const string&  result)
-{
-    string  source;
-    string  info;
-    int     ds_id = -1;
-
-    Image * image;
-
-    ostringstream oss;
-
-    image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        if (result == "SUCCESS")
-        {
-            ostringstream oss;
-
-            if ( is.good())
-            {
-                is >> source >> ws;
-            }
-
-            if (!source.empty())
-            {
-                oss << "CP operation succeeded but image no longer exists."
-                    << " Source image: " << source << ", may be left in datastore";
-
-                NebulaLog::log("ImM", Log::ERROR, oss);
-            }
-        }
-
-        return ds_id;
-    }
-
-    ds_id = image->get_ds_id();
-
-    if ( result == "FAILURE" )
-    {
-       goto error;
-    }
-
-    if ( is.good() )
-    {
-        is >> source >> ws;
-    }
-
-    if ( is.fail() )
-    {
-        goto error;
-    }
-
-    image->set_source(source);
-
-    image->set_state_unlock();
-
-    ipool->update(image);
-
-    image->unlock();
-
-    oss << "Image (" << id << ") copied and ready to use.";
-    NebulaLog::log("ImM", Log::INFO, oss);
-
-    return ds_id;
-
-error:
-    oss << "Error copying image in the datastore";
-
-    getline(is, info);
-
-    if (!info.empty() && (info[0] != '-'))
-    {
-        oss << ": " << info;
-    }
-
-    NebulaLog::log("ImM", Log::ERROR, oss);
-
-    image->set_template_error_message(oss.str());
-    image->set_state(Image::ERROR);
-
-    ipool->update(image);
-
-    image->unlock();
-
-    return ds_id;
-}
-
-/* -------------------------------------------------------------------------- */
-
-static int clone_action(istringstream& is,
-                        ImagePool*     ipool,
-                        int            id,
-                        const string&  result)
-{
-    int     cloning_id;
-    int     ds_id = -1;
-    string  source;
-    string  info;
-
-    Image * image;
-
-    ostringstream oss;
-
-    Nebula& nd        = Nebula::instance();
-    ImageManager * im = nd.get_imagem();
-
-    image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        if (result == "SUCCESS")
-        {
-            ostringstream oss;
-
-            if ( is.good())
-            {
-                is >> source >> ws;
-            }
-
-            if (!source.empty())
-            {
-                oss << "CLONE operation succeeded but image no longer exists."
-                    << " Source image: " << source << ", may be left in datastore";
-
-                NebulaLog::log("ImM", Log::ERROR, oss);
-            }
-        }
-
-        return ds_id;
-    }
-
-    ds_id      = image->get_ds_id();
-    cloning_id = image->get_cloning_id();
-
-    if ( result == "FAILURE" )
-    {
-       goto error;
-    }
-
-    if ( is.good() )
-    {
-        is >> source >> ws;
-    }
-
-    if ( is.fail() )
-    {
-        goto error;
-    }
-
-    image->set_source(source);
-
-    image->set_state_unlock();
-
-    image->clear_cloning_id();
-
-    ipool->update(image);
-
-    image->unlock();
-
-    NebulaLog::log("ImM", Log::INFO, "Image cloned and ready to use.");
-
-    im->release_cloning_image(cloning_id, id);
-
-    return ds_id;
-
-error:
-    oss << "Error cloning from Image " << cloning_id;
-
-    getline(is, info);
-
-    if (!info.empty() && (info[0] != '-'))
-    {
-        oss << ": " << info;
-    }
-
-    NebulaLog::log("ImM", Log::ERROR, oss);
-
-    image->set_template_error_message(oss.str());
-    image->set_state(Image::ERROR);
-
-    image->clear_cloning_id();
-
-    ipool->update(image);
-
-    image->unlock();
-
-    im->release_cloning_image(cloning_id, id);
-
-    return ds_id;
-}
-
-/* -------------------------------------------------------------------------- */
-
-static int mkfs_action(istringstream& is,
-                       ImagePool*     ipool,
-                       int            id,
-                       const string&  result)
-{
-    string  source;
-    Image * image;
-    bool    is_saving = false;
-
-    string info;
-
-    int vm_id   = -1;
-    int ds_id   = -1;
-    int disk_id = -1;
-
-    VirtualMachine * vm;
-    ostringstream    oss;
-
-    Nebula& nd                  = Nebula::instance();
-    VirtualMachinePool * vmpool = nd.get_vmpool();
-    TransferManager *  tm       = nd.get_tm();
-
-    image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        if (result == "SUCCESS")
-        {
-            ostringstream oss;
-
-            if ( is.good())
-            {
-                is >> source >> ws;
-            }
-
-            if (!source.empty())
-            {
-                oss << "MkFS operation succeeded but image no longer exists."
-                    << " Source image: " << source << ", may be left in datastore";
-
-                NebulaLog::log("ImM", Log::ERROR, oss);
-            }
-        }
-
-        return ds_id;
-    }
-    else if ( image->get_state() == Image::DELETE )
-    {
-        NebulaLog::log("ImM", Log::INFO, "Ignoring mkfs callback, image is "
-                "being deleted");
-
-        image->unlock();
-        return ds_id;
-    }
-
-    is_saving = image->is_saving();
-    ds_id     = image->get_ds_id();
-
-    if ( is_saving )
-    {
-        image->get_template_attribute("SAVED_DISK_ID", disk_id);
-        image->get_template_attribute("SAVED_VM_ID", vm_id);
-    }
-
-    if ( result == "FAILURE" )
-    {
-        goto error_img;
-    }
-
-    if ( !is.fail() )
-    {
-        is >> source >> ws;
-    }
-    else
-    {
-        goto error_img;
-    }
-
-    image->set_source(source);
-
-    if (!is_saving)
-    {
-        image->set_state_unlock();
-    }
-
-    ipool->update(image);
-
-    image->unlock();
-
-    if ( !is_saving )
-    {
-        NebulaLog::log("ImM", Log::INFO, "Image created and ready to use");
-        return ds_id;
-    }
-
-    vm = vmpool->get(vm_id);
-
-    if ( vm == 0 )
-    {
-        goto error_save_get;
-    }
-
-    if ( vm->set_saveas_disk(disk_id, source, id) == -1 )
-    {
-        goto error_save_state;
-    }
-
-    tm->trigger(TMAction::SAVEAS_HOT, vm_id);
-
-    vmpool->update(vm);
-
-    vm->unlock();
-
-    return ds_id;
-
-error_img:
-    oss << "Error creating datablock";
-    goto error;
-
-error_save_get:
-    oss << "Image created to save as a disk but VM does not exist.";
-    goto error_save;
-
-error_save_state:
-    vm->unlock();
-    oss << "Image created to save as disk but VM is no longer running";
-
-error_save:
-    image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        NebulaLog::log("ImM", Log::ERROR, oss);
-        return ds_id;
-    }
-
-error:
-    getline(is,info);
-
-    if (!info.empty() && (info[0] != '-'))
-    {
-        oss << ": " << info;
-    }
-
-    NebulaLog::log("ImM", Log::ERROR, oss);
-
-    image->set_template_error_message(oss.str());
-    image->set_state(Image::ERROR);
-
-    ipool->update(image);
-
-    image->unlock();
-
-    if (is_saving && vm_id != -1)
-    {
-        if ((vm = vmpool->get(vm_id)) != 0)
-        {
-            vm->clear_saveas_state();
-
-            vm->clear_saveas_disk();
-
-            vmpool->update(vm);
-
-            vm->unlock();
-        }
-    }
-
-    return ds_id;
-}
-
-/* -------------------------------------------------------------------------- */
-
-static int rm_action(istringstream& is,
-                     ImagePool*     ipool,
-                     int            id,
-                     const string&  result)
-{
-    int rc;
-    int ds_id = -1;
-
-    string  tmp_error;
-    string  source;
-    string  info;
-    Image * image;
-
-    ostringstream oss;
-
-    image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        return ds_id;
-    }
-
-    ds_id  = image->get_ds_id();
-    source = image->get_source();
-
-    rc = ipool->drop(image, tmp_error);
-
-    image->unlock();
-
-    if ( result == "FAILURE" )
-    {
-       goto error;
-    }
-    else if ( rc < 0 )
-    {
-        goto error_drop;
-    }
-
-    NebulaLog::log("ImM", Log::INFO, "Image successfully removed.");
-
-    return ds_id;
-
-error_drop:
-    oss << "Error removing image from DB: " << tmp_error
-        << ". Remove image source " << source << " to completely delete image.";
-
-    NebulaLog::log("ImM", Log::ERROR, oss);
-    return ds_id;
-
-error:
-    oss << "Error removing image from datastore. Manually remove image source "
-        << source << " to completely delete the image";
-
-    getline(is,info);
-
-    if (!info.empty() && (info[0] != '-'))
-    {
-        oss << ": " << info;
-    }
-
-    NebulaLog::log("ImM", Log::ERROR, oss);
-
-    return ds_id;
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void monitor_action(istringstream& is,
-                           DatastorePool* dspool,
-                           int            id,
-                           const string&  result)
-{
-    string  dsinfo64;
-    string *dsinfo = 0;
-
-    ostringstream oss;
-
-    getline (is, dsinfo64);
-
-    if (is.fail())
-    {
-        oss << "Error monitoring datastore " << id << ". Bad monitor data: "
-            << dsinfo64;
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-        return;
-    }
-
-    dsinfo = one_util::base64_decode(dsinfo64);
-
-    if (dsinfo == 0)
-    {
-        oss << "Error monitoring datastore " << id << ". Bad monitor data: "
-            << dsinfo64;
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-        return;
-    }
-
-    if (result != "SUCCESS")
-    {
-        oss << "Error monitoring datastore " << id << ": " << dsinfo64;
-
-        if (!(*dsinfo).empty())
-        {
-            oss << ". Decoded info: " << *dsinfo;
-        }
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-
-        delete dsinfo;
-        return;
-    }
-
-    Template monitor_data;
-
-    char*  error_msg;
-    int    rc = monitor_data.parse(*dsinfo, &error_msg);
-
-    if ( rc != 0 )
-    {
-        oss << "Error parsing datastore information: " << error_msg
-            << ". Monitoring information: " << endl << *dsinfo;
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-
-        delete dsinfo;
-        free(error_msg);
-
-        return;
-    }
-
-    delete dsinfo;
-
-    float  total, free, used;
-    string ds_name;
-
-    monitor_data.get("TOTAL_MB", total);
-    monitor_data.get("FREE_MB", free);
-    monitor_data.get("USED_MB", used);
-
-    Datastore * ds = dspool->get(id);
-
-    if (ds == 0 )
-    {
-        return;
-    }
-
-    ds_name = ds->get_name();
-
-    ds->update_monitor(total, free, used);
-
-    dspool->update(ds);
-
-    ds->unlock();
-
-    oss << "Datastore " << ds_name << " (" << id << ") successfully monitored.";
-
-    NebulaLog::log("ImM", Log::DEBUG, oss);
-
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void snap_delete_action(istringstream& is,
-         ImagePool*     ipool,
-         int            id,
-         const string&  result)
-{
-    ostringstream oss;
-    string info;
-
-    long long   snap_size;
-    int         ds_id, uid, gid;
-
-    Image * image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        return;
-    }
-
-    image->set_state_unlock();
-
-    int snap_id = image->get_target_snapshot();
-
-    if (snap_id == -1)
-    {
-        NebulaLog::log("ImM", Log::ERROR, "No target snapshot in callback");
-
-        ipool->update(image);
-
-        image->unlock();
-        return;
-    }
-
-    if ( result == "SUCCESS")
-    {
-        ds_id     = image->get_ds_id();
-        uid       = image->get_uid();
-        gid       = image->get_gid();
-        snap_size = (image->get_snapshots()).get_snapshot_size(snap_id);
-
-        image->delete_snapshot(snap_id);
-    }
-    else
-    {
-        oss << "Error removing snapshot " << snap_id << " from image " << id;
-
-        getline(is, info);
-
-        if (!info.empty() && (info[0] != '-'))
-        {
-            oss << ": " << info;
-        }
-
-        image->set_template_error_message(oss.str());
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-    }
-
-    image->clear_target_snapshot();
-
-    ipool->update(image);
-
-    image->unlock();
-
-    if (result == "SUCCESS")
-    {
-        Template quotas;
-
-        quotas.add("DATASTORE", ds_id);
-        quotas.add("SIZE", snap_size);
-        quotas.add("IMAGES",0 );
-
-        Quotas::ds_del(uid, gid, &quotas);
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void snap_revert_action(istringstream& is,
-         ImagePool*     ipool,
-         int            id,
-         const string&  result)
-{
-    ostringstream oss;
-    string info;
-
-    Image * image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        return;
-    }
-
-    int snap_id = image->get_target_snapshot();
-
-    image->set_state_unlock();
-
-    if (snap_id == -1)
-    {
-        NebulaLog::log("ImM", Log::ERROR, "No target snapshot in callback");
-
-        ipool->update(image);
-
-        image->unlock();
-        return;
-    }
-
-    if ( result == "SUCCESS")
-    {
-        image->revert_snapshot(snap_id);
-    }
-    else
-    {
-        oss << "Error reverting image " << id << " to snapshot " << snap_id;
-
-        getline(is, info);
-
-        if (!info.empty() && (info[0] != '-'))
-        {
-            oss << ": " << info;
-        }
-
-        image->set_template_error_message(oss.str());
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-    }
-
-    image->clear_target_snapshot();
-
-    ipool->update(image);
-
-    image->unlock();
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void snap_flatten_action(istringstream& is,
-         ImagePool*     ipool,
-         int            id,
-         const string&  result)
-{
-    ostringstream oss;
-    string info;
-
-    long long   snap_size;
-    int         ds_id, uid, gid;
-
-    Image * image = ipool->get(id);
-
-    if ( image == 0 )
-    {
-        return;
-    }
-
-    if ( result == "SUCCESS")
-    {
-        ds_id     = image->get_ds_id();
-        uid       = image->get_uid();
-        gid       = image->get_gid();
-        snap_size = (image->get_snapshots()).get_total_size();
-
-        image->clear_snapshots();
-    }
-    else
-    {
-        oss << "Error flattening image snapshot";
-
-        getline(is, info);
-
-        if (!info.empty() && (info[0] != '-'))
-        {
-            oss << ": " << info;
-        }
-
-        image->set_template_error_message(oss.str());
-
-        NebulaLog::log("ImM", Log::ERROR, oss);
-    }
-
-    image->set_state_unlock();
-
-    image->clear_target_snapshot();
-
-    ipool->update(image);
-
-    image->unlock();
-
-    if (result == "SUCCESS")
-    {
-        Template quotas;
-
-        quotas.add("DATASTORE", ds_id);
-        quotas.add("SIZE", snap_size);
-        quotas.add("IMAGES",0 );
-
-        Quotas::ds_del(uid, gid, &quotas);
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::protocol(const string& message) const
-{
-    istringstream is(message);
-    ostringstream oss;
-
-    string action;
-    string result;
-    string source;
-    string info;
-
-    int id;
-    int ds_id = -1;
-
-    oss << "Message received: " << message;
-    NebulaLog::log("ImG", Log::DDEBUG, oss);
-
-    // --------------------- Parse the driver message --------------------------
-
-    if ( is.good() )
-        is >> action >> ws;
-    else
-        return;
-
-    if ( is.good() )
-        is >> result >> ws;
-    else
-        return;
-
-    if ( is.good() )
-    {
-        is >> id >> ws;
-
-        if ( is.fail() )
-        {
-            if ( action == "LOG" )
-            {
-                is.clear();
-                getline(is,info);
-
-                NebulaLog::log("ImG",log_type(result[0]), info.c_str());
-            }
-
-            return;
-        }
-    }
-    else
-        return;
-
-    if (action == "STAT")
-    {
-        stat_action(is, id, result);
-    }
-    else if (action == "CP")
-    {
-        ds_id = cp_action(is, ipool, id, result);
-    }
-    else if (action == "CLONE")
-    {
-        ds_id = clone_action(is, ipool, id, result);
-    }
-    else if (action == "MKFS")
-    {
-        ds_id = mkfs_action(is, ipool, id, result);
-    }
-    else if (action == "RM")
-    {
-        ds_id = rm_action(is, ipool, id, result);
-    }
-    else if (action == "MONITOR")
-    {
-        monitor_action(is, dspool, id, result);
-    }
-    else if (action == "SNAP_DELETE")
-    {
-        snap_delete_action(is, ipool, id, result);
-    }
-    else if (action == "SNAP_REVERT")
-    {
-        snap_revert_action(is, ipool, id, result);
-    }
-    else if (action == "SNAP_FLATTEN")
-    {
-        snap_flatten_action(is, ipool, id, result);
-    }
-    else if (action == "LOG")
-    {
-        getline(is,info);
-        NebulaLog::log("ImM", log_type(result[0]), info.c_str());
-    }
-
-    if (ds_id != -1)
-    {
-        Nebula& nd        = Nebula::instance();
-        ImageManager * im = nd.get_imagem();
-
-        im->monitor_datastore(ds_id);
-    }
-
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void ImageManagerDriver::recover()
-{
-    NebulaLog::log("ImG",Log::INFO,"Recovering Image Repository drivers");
-}
-
diff --git a/src/image/ImageManagerProtocol.cc b/src/image/ImageManagerProtocol.cc
new file mode 100644
index 0000000000..6bc1cac4d0
--- /dev/null
+++ b/src/image/ImageManagerProtocol.cc
@@ -0,0 +1,737 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "ImageManager.h"
+#include "ImagePool.h"
+#include "DatastorePool.h"
+#include "Quotas.h"
+#include "TransferManager.h"
+#include "VirtualMachine.h"
+#include "VirtualMachinePool.h"
+#include "Nebula.h"
+
+/* ************************************************************************** */
+/* Driver Protocol Implementation                                             */
+/* ************************************************************************** */
+
+void ImageManager::_undefined(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::warn("ImM", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_stat(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_stat: " + msg->payload());
+
+    if (msg->status() == "SUCCESS")
+    {
+        if (msg->payload().empty())
+        {
+            notify_request(msg->oid(), false, "Cannot get size from STAT");
+        }
+
+        notify_request(msg->oid(), true, msg->payload());
+    }
+    else
+    {
+        notify_request(msg->oid(), false, msg->payload());
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_cp(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_cp: " + msg->payload());
+
+    string  source;
+    int     ds_id = -1;
+
+    ostringstream oss;
+    istringstream is(msg->payload());
+
+    auto image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        if (msg->status() == "SUCCESS")
+        {
+            is >> source >> ws;
+
+            if (!source.empty())
+            {
+                oss << "CP operation succeeded but image no longer exists."
+                    << " Source image: " << source << ", may be left in datastore";
+
+                NebulaLog::log("ImM", Log::ERROR, oss);
+            }
+        }
+
+        return;
+    }
+
+    ds_id = image->get_ds_id();
+
+    if (msg->status() != "SUCCESS")
+    {
+       goto error;
+    }
+
+    is >> source >> ws;
+
+    if (is.fail())
+    {
+        goto error;
+    }
+
+    image->set_source(source);
+
+    image->set_state_unlock();
+
+    ipool->update(image);
+
+    image->unlock();
+
+    oss << "Image (" << msg->oid() << ") copied and ready to use.";
+    NebulaLog::log("ImM", Log::INFO, oss);
+
+    monitor_datastore(ds_id);
+
+    return;
+
+error:
+    oss << "Error copying image in the datastore";
+
+    const auto& info = msg->payload();
+
+    if (!info.empty() && (info[0] != '-'))
+    {
+        oss << ": " << info;
+    }
+
+    NebulaLog::log("ImM", Log::ERROR, oss);
+
+    image->set_template_error_message(oss.str());
+    image->set_state(Image::ERROR);
+
+    ipool->update(image);
+
+    image->unlock();
+
+    monitor_datastore(ds_id);
+
+    return;
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_clone(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_clone: " + msg->payload());
+
+    int     cloning_id;
+    int     ds_id = -1;
+
+    Image * image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        if (msg->status() == "SUCCESS")
+        {
+            ostringstream oss;
+
+            if (!msg->payload().empty())
+            {
+                oss << "CLONE operation succeeded but image no longer exists."
+                    << " Source image: " << msg->payload()
+                    << ", may be left in datastore";
+
+                NebulaLog::log("ImM", Log::ERROR, oss);
+            }
+        }
+
+        return;
+    }
+
+    ds_id      = image->get_ds_id();
+    cloning_id = image->get_cloning_id();
+
+    if (msg->status() != "SUCCESS")
+    {
+       goto error;
+    }
+
+    image->set_source(msg->payload());
+
+    image->set_state_unlock();
+
+    image->clear_cloning_id();
+
+    ipool->update(image);
+
+    image->unlock();
+
+    NebulaLog::info("ImM", "Image cloned and ready to use.");
+
+    release_cloning_image(cloning_id, msg->oid());
+
+    monitor_datastore(ds_id);
+
+    return;
+
+error:
+    ostringstream oss;
+
+    oss << "Error cloning from Image " << cloning_id;
+
+    const auto& info = msg->payload();
+
+    if (!info.empty() && (info[0] != '-'))
+    {
+        oss << ": " << info;
+    }
+
+    NebulaLog::log("ImM", Log::ERROR, oss);
+
+    image->set_template_error_message(oss.str());
+    image->set_state(Image::ERROR);
+
+    image->clear_cloning_id();
+
+    ipool->update(image);
+
+    image->unlock();
+
+    release_cloning_image(cloning_id, msg->oid());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_mkfs(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_mkfs: " + msg->payload());
+
+    int vm_id   = -1;
+    int disk_id = -1;
+
+    VirtualMachine * vm = nullptr;
+
+    ostringstream    oss;
+
+    Nebula& nd                  = Nebula::instance();
+    VirtualMachinePool * vmpool = nd.get_vmpool();
+    TransferManager *  tm       = nd.get_tm();
+
+    Image * image = ipool->get(msg->oid());
+    const string& source = msg->payload();
+
+    if (image == nullptr)
+    {
+        if (msg->status() == "SUCCESS")
+        {
+            ostringstream oss;
+
+            if (!source.empty())
+            {
+                oss << "MkFS operation succeeded but image no longer exists."
+                    << " Source image: " << source << ", may be left in datastore";
+
+                NebulaLog::log("ImM", Log::ERROR, oss);
+            }
+        }
+
+        return;
+    }
+    else if (image->get_state() == Image::DELETE)
+    {
+        NebulaLog::info("ImM", "Ignoring mkfs callback, image is "
+                "being deleted");
+
+        image->unlock();
+        return;
+    }
+
+    bool is_saving = image->is_saving();
+    int  ds_id     = image->get_ds_id();
+
+    if (is_saving)
+    {
+        image->get_template_attribute("SAVED_DISK_ID", disk_id);
+        image->get_template_attribute("SAVED_VM_ID", vm_id);
+    }
+
+    if (msg->status() != "SUCCESS")
+    {
+        goto error_img;
+    }
+
+    image->set_source(source);
+
+    if (!is_saving)
+    {
+        image->set_state_unlock();
+    }
+
+    ipool->update(image);
+
+    image->unlock();
+
+    if (!is_saving)
+    {
+        NebulaLog::info("ImM", "Image created and ready to use");
+
+        monitor_datastore(ds_id);
+
+        return;
+    }
+
+    vm = vmpool->get(vm_id);
+
+    if (vm == nullptr)
+    {
+        goto error_save_get;
+    }
+
+    if (vm->set_saveas_disk(disk_id, source, msg->oid()) == -1)
+    {
+        goto error_save_state;
+    }
+
+    tm->trigger(TMAction::SAVEAS_HOT, vm_id);
+
+    vmpool->update(vm);
+
+    vm->unlock();
+
+    monitor_datastore(ds_id);
+
+    return;
+
+error_img:
+    oss << "Error creating datablock";
+    goto error;
+
+error_save_get:
+    oss << "Image created to save as a disk but VM does not exist.";
+    goto error_save;
+
+error_save_state:
+    vm->unlock();
+    oss << "Image created to save as disk but VM is no longer running";
+
+error_save:
+    image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        NebulaLog::log("ImM", Log::ERROR, oss);
+        return;
+    }
+
+error:
+    const auto& info = msg->payload();
+
+    if (!info.empty() && (info[0] != '-'))
+    {
+        oss << ": " << info;
+    }
+
+    NebulaLog::log("ImM", Log::ERROR, oss);
+
+    image->set_template_error_message(oss.str());
+    image->set_state(Image::ERROR);
+
+    ipool->update(image);
+
+    image->unlock();
+
+    if (is_saving && vm_id != -1)
+    {
+        if ((vm = vmpool->get(vm_id)) != nullptr)
+        {
+            vm->clear_saveas_state();
+
+            vm->clear_saveas_disk();
+
+            vmpool->update(vm);
+
+            vm->unlock();
+        }
+    }
+
+    monitor_datastore(ds_id);
+
+    return;
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_rm(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_rm: " + msg->payload());
+
+    int ds_id = -1;
+
+    string  tmp_error;
+    Image * image;
+
+    ostringstream oss;
+
+    image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        return;
+    }
+
+    ds_id  = image->get_ds_id();
+    const auto& source = image->get_source();
+
+    int rc = ipool->drop(image, tmp_error);
+
+    image->unlock();
+
+    if (msg->status() != "SUCCESS")
+    {
+        goto error;
+    }
+    else if (rc < 0)
+    {
+        goto error_drop;
+    }
+
+    NebulaLog::info("ImM", "Image successfully removed.");
+
+    monitor_datastore(ds_id);
+
+    return;
+
+error_drop:
+    oss << "Error removing image from DB: " << tmp_error
+        << ". Remove image source " << source << " to completely delete image.";
+
+    NebulaLog::log("ImM", Log::ERROR, oss);
+    return;
+
+error:
+    oss << "Error removing image from datastore. Manually remove image source "
+        << source << " to completely delete the image";
+
+    const auto& info = msg->payload();
+
+    if (!info.empty() && (info[0] != '-'))
+    {
+        oss << ": " << info;
+    }
+
+    NebulaLog::log("ImM", Log::ERROR, oss);
+
+    return;
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_monitor(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_monitor: " + msg->payload());
+
+    ostringstream oss;
+
+    string  dsinfo64 = msg->payload();
+
+    if (dsinfo64.empty())
+    {
+        oss << "Error monitoring datastore " << msg->oid()
+            << ". Bad monitor data: " << dsinfo64;
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+        return;
+    }
+
+    unique_ptr<string> dsinfo(one_util::base64_decode(dsinfo64));
+
+    if (dsinfo == nullptr)
+    {
+        oss << "Error monitoring datastore " << msg->oid()
+            << ". Bad monitor data: " << dsinfo64;
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+        return;
+    }
+
+    if (msg->status() != "SUCCESS")
+    {
+        oss << "Error monitoring datastore " << msg->oid() << ": " << dsinfo64;
+
+        if (!(*dsinfo).empty())
+        {
+            oss << ". Decoded info: " << *dsinfo;
+        }
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+
+        return;
+    }
+
+    Template monitor_data;
+
+    char*  error_msg;
+    int    rc = monitor_data.parse(*dsinfo, &error_msg);
+
+    if (rc != 0)
+    {
+        oss << "Error parsing datastore information: " << error_msg
+            << ". Monitoring information: " << endl << *dsinfo;
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+
+        free(error_msg);
+
+        return;
+    }
+
+    float  total, free, used;
+    string ds_name;
+
+    monitor_data.get("TOTAL_MB", total);
+    monitor_data.get("FREE_MB", free);
+    monitor_data.get("USED_MB", used);
+
+    Datastore * ds = dspool->get(msg->oid());
+
+    if (ds == nullptr)
+    {
+        return;
+    }
+
+    ds_name = ds->get_name();
+
+    ds->update_monitor(total, free, used);
+
+    dspool->update(ds);
+
+    ds->unlock();
+
+    oss << "Datastore " << ds_name << " (" << msg->oid()
+        << ") successfully monitored.";
+
+    NebulaLog::debug("ImM", oss.str());
+
+    return;
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_snap_delete(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_snap_delete: " + msg->payload());
+
+    long long   snap_size;
+    int         ds_id, uid, gid;
+
+    Image * image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        return;
+    }
+
+    image->set_state_unlock();
+
+    int snap_id = image->get_target_snapshot();
+
+    if (snap_id == -1)
+    {
+        NebulaLog::error("ImM", "No target snapshot in callback");
+
+        ipool->update(image);
+
+        image->unlock();
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        ds_id     = image->get_ds_id();
+        uid       = image->get_uid();
+        gid       = image->get_gid();
+        snap_size = (image->get_snapshots()).get_snapshot_size(snap_id);
+
+        image->delete_snapshot(snap_id);
+    }
+    else
+    {
+        ostringstream oss;
+
+        oss << "Error removing snapshot " << snap_id
+            << " from image " << msg->oid();
+
+        const auto& info = msg->payload();
+
+        if (!info.empty() && (info[0] != '-'))
+        {
+            oss << ": " << info;
+        }
+
+        image->set_template_error_message(oss.str());
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+    }
+
+    image->clear_target_snapshot();
+
+    ipool->update(image);
+
+    image->unlock();
+
+    if (msg->status() == "SUCCESS")
+    {
+        Template quotas;
+
+        quotas.add("DATASTORE", ds_id);
+        quotas.add("SIZE", snap_size);
+        quotas.add("IMAGES", 0);
+
+        Quotas::ds_del(uid, gid, &quotas);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_snap_revert(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_snap_revert: " + msg->payload());
+
+    Image * image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        return;
+    }
+
+    int snap_id = image->get_target_snapshot();
+
+    image->set_state_unlock();
+
+    if (snap_id == -1)
+    {
+        NebulaLog::error("ImM", "No target snapshot in callback");
+
+        ipool->update(image);
+
+        image->unlock();
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        image->revert_snapshot(snap_id);
+    }
+    else
+    {
+        ostringstream oss;
+        oss << "Error reverting image " << msg->oid()
+            << " to snapshot " << snap_id;
+
+        const auto& info = msg->payload();
+
+        if (!info.empty() && (info[0] != '-'))
+        {
+            oss << ": " << info;
+        }
+
+        image->set_template_error_message(oss.str());
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+    }
+
+    image->clear_target_snapshot();
+
+    ipool->update(image);
+
+    image->unlock();
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_snap_flatten(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::dddebug("ImM", "_snap_flatten: " + msg->payload());
+
+    long long   snap_size;
+    int         ds_id, uid, gid;
+
+    Image * image = ipool->get(msg->oid());
+
+    if (image == nullptr)
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        ds_id     = image->get_ds_id();
+        uid       = image->get_uid();
+        gid       = image->get_gid();
+        snap_size = (image->get_snapshots()).get_total_size();
+
+        image->clear_snapshots();
+    }
+    else
+    {
+        ostringstream oss;
+        oss << "Error flattening image snapshot";
+
+        const auto& info = msg->payload();
+
+        if (!info.empty() && (info[0] != '-'))
+        {
+            oss << ": " << info;
+        }
+
+        image->set_template_error_message(oss.str());
+
+        NebulaLog::log("ImM", Log::ERROR, oss);
+    }
+
+    image->set_state_unlock();
+
+    image->clear_target_snapshot();
+
+    ipool->update(image);
+
+    image->unlock();
+
+    if (msg->status() == "SUCCESS")
+    {
+        Template quotas;
+
+        quotas.add("DATASTORE", ds_id);
+        quotas.add("SIZE", snap_size);
+        quotas.add("IMAGES", 0);
+
+        Quotas::ds_del(uid, gid, &quotas);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void ImageManager::_log(unique_ptr<image_msg_t> msg)
+{
+    NebulaLog::log("ImM", log_type(msg->status()[0]), msg->payload());
+}
diff --git a/src/image/ImagePool.cc b/src/image/ImagePool.cc
index e023a9e443..a7268ab5ff 100644
--- a/src/image/ImagePool.cc
+++ b/src/image/ImagePool.cc
@@ -43,7 +43,7 @@ ImagePool::ImagePool(
         const string&                    __default_cdrom_dev_prefix,
         vector<const SingleAttribute *>& restricted_attrs,
         const vector<const SingleAttribute *>& _inherit_attrs)
-    :PoolSQL(db, Image::table)
+    : PoolSQL(db, one_db::image_table)
 {
     // Init static defaults
     _default_type       = __default_type;
diff --git a/src/image/SConstruct b/src/image/SConstruct
index 3c3d3683bc..9a2c600d82 100644
--- a/src/image/SConstruct
+++ b/src/image/SConstruct
@@ -24,7 +24,7 @@ lib_name='nebula_image'
 source_files=[
     'Image.cc',
     'ImagePool.cc',
-    'ImageManagerDriver.cc',
+    'ImageManagerProtocol.cc',
     'ImageManager.cc',
     'ImageManagerActions.cc',
     'ImageTemplate.cc'
diff --git a/src/ipamm/IPAMManager.cc b/src/ipamm/IPAMManager.cc
index 48344c82d5..d114638e0a 100644
--- a/src/ipamm/IPAMManager.cc
+++ b/src/ipamm/IPAMManager.cc
@@ -29,7 +29,7 @@ extern "C" void * ipamm_action_loop(void *arg)
 {
     IPAMManager * ipamm;
 
-    if ( arg == 0 )
+    if ( arg == nullptr )
     {
         return 0;
     }
@@ -49,13 +49,35 @@ extern "C" void * ipamm_action_loop(void *arg)
 
 int IPAMManager::start()
 {
-    int            rc;
     pthread_attr_t pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(IPAMManagerMessages::UNDEFINED,
+            &IPAMManager::_undefined);
+
+    register_action(IPAMManagerMessages::REGISTER_ADDRESS_RANGE,
+            bind(&IPAMManager::_notify_request, this, _1));
+
+    register_action(IPAMManagerMessages::UNREGISTER_ADDRESS_RANGE,
+            bind(&IPAMManager::_notify_request, this, _1));
+
+    register_action(IPAMManagerMessages::GET_ADDRESS,
+            bind(&IPAMManager::_notify_request, this, _1));
+
+    register_action(IPAMManagerMessages::ALLOCATE_ADDRESS,
+            bind(&IPAMManager::_notify_request, this, _1));
+
+    register_action(IPAMManagerMessages::FREE_ADDRESS,
+            bind(&IPAMManager::_notify_request, this, _1));
+
+    register_action(IPAMManagerMessages::LOG,
+            &IPAMManager::_log);
+
+    string error;
+    if ( DriverManager::start(error) != 0 )
     {
+        NebulaLog::error("IPM", error);
         return -1;
     }
 
@@ -64,7 +86,7 @@ int IPAMManager::start()
     pthread_attr_init(&pattr);
     pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 
-    rc = pthread_create(&ipamm_thread, &pattr, ipamm_action_loop, (void *)this);
+    int rc = pthread_create(&ipamm_thread, &pattr, ipamm_action_loop, (void *)this);
 
     return rc;
 }
@@ -78,7 +100,7 @@ void IPAMManager::user_action(const ActionRequest& ar)
 
     IPAMRequest * request = ipam_ar.request();
 
-    if ( request == 0 )
+    if ( request == nullptr )
     {
         return;
     }
@@ -110,120 +132,79 @@ void IPAMManager::user_action(const ActionRequest& ar)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-const IPAMManagerDriver * IPAMManager::setup_request(IPAMRequest * ir)
+void IPAMManager::send_request(IPAMManagerMessages type, IPAMRequest * ir)
 {
-    const IPAMManagerDriver * ipammd = get();
+    auto ipammd = get();
 
-    if (ipammd == 0)
+    if (ipammd == nullptr)
     {
         ir->result  = false;
         ir->message = "Could not find the IPAM driver";
 
         ir->notify();
 
-        return 0;
+        return;
     }
 
     add_request(ir);
 
-    return ipammd;
+    string action_data;
+    ipam_msg_t msg(type, "", ir->id, ir->to_xml64(action_data));
+
+    ipammd->write(msg);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void IPAMManager::register_address_range_action(IPAMRequest * ir)
 {
-    std::string action_data;
-    const IPAMManagerDriver * ipammd = setup_request(ir);
-
-    if (ipammd == 0)
-    {
-        return;
-    }
-
-    ipammd->register_address_range(ir->id, ir->to_xml64(action_data));
+    send_request(IPAMManagerMessages::REGISTER_ADDRESS_RANGE, ir);
 }
 
-
 /* -------------------------------------------------------------------------- */
 
 void IPAMManager::unregister_address_range_action(IPAMRequest * ir)
 {
-    std::string action_data;
-    const IPAMManagerDriver * ipammd = setup_request(ir);
-
-    if (ipammd == 0)
-    {
-        return;
-    }
-
-    ipammd->unregister_address_range(ir->id, ir->to_xml64(action_data));
+    send_request(IPAMManagerMessages::UNREGISTER_ADDRESS_RANGE, ir);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void IPAMManager::get_address_action(IPAMRequest * ir)
 {
-    std::string action_data;
-    const IPAMManagerDriver * ipammd = setup_request(ir);
-
-    if (ipammd == 0)
-    {
-        return;
-    }
-
-    ipammd->get_address(ir->id, ir->to_xml64(action_data));
+    send_request(IPAMManagerMessages::GET_ADDRESS, ir);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void IPAMManager::allocate_address_action(IPAMRequest * ir)
 {
-    std::string action_data;
-    const IPAMManagerDriver * ipammd = setup_request(ir);
-
-    if (ipammd == 0)
-    {
-        return;
-    }
-
-    ipammd->allocate_address(ir->id, ir->to_xml64(action_data));
+    send_request(IPAMManagerMessages::ALLOCATE_ADDRESS, ir);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void IPAMManager::free_address_action(IPAMRequest * ir)
 {
-    std::string action_data;
-    const IPAMManagerDriver * ipammd = setup_request(ir);
-
-    if (ipammd == 0)
-    {
-        return;
-    }
-
-    ipammd->free_address(ir->id, ir->to_xml64(action_data));
+    send_request(IPAMManagerMessages::FREE_ADDRESS, ir);
 }
 
 /* ************************************************************************** */
 /* MAD Loading                                                                */
 /* ************************************************************************** */
 
-int IPAMManager::load_mads(int uid)
+int IPAMManager::load_drivers(const std::vector<const VectorAttribute*>& _mads)
 {
-    const VectorAttribute * vattr;
-    IPAMManagerDriver *     ipamm_driver;
-
-    if ( mad_conf.size() == 0 )
+    if ( _mads.size() == 0 )
     {
         return 0;
     }
 
     NebulaLog::log("IPM", Log::INFO, "Loading IPAM Manager driver.");
 
-    vattr = dynamic_cast<const VectorAttribute *>(mad_conf[0]);
+    const VectorAttribute * vattr = _mads[0];
 
-    if ( vattr == 0 )
+    if ( vattr == nullptr )
     {
         NebulaLog::log("IPM", Log::ERROR, "Failed to load IPAM Manager driver.");
         return -1;
@@ -233,10 +214,9 @@ int IPAMManager::load_mads(int uid)
 
     ipam_conf.replace("NAME", ipam_driver_name);
 
-    ipamm_driver = new IPAMManagerDriver(uid, ipam_conf.value(), false, this);
-
-    if ( add(ipamm_driver) != 0 )
+    if ( load_driver(&ipam_conf) != 0 )
     {
+        NebulaLog::error("ImM", "Unable to load IPAM Manager driver");
         return -1;
     }
 
diff --git a/src/ipamm/IPAMManagerDriver.cc b/src/ipamm/IPAMManagerProtocol.cc
similarity index 59%
rename from src/ipamm/IPAMManagerDriver.cc
rename to src/ipamm/IPAMManagerProtocol.cc
index 7bf6369de6..6a181be585 100644
--- a/src/ipamm/IPAMManagerDriver.cc
+++ b/src/ipamm/IPAMManagerProtocol.cc
@@ -14,84 +14,46 @@
 /* limitations under the License.                                             */
 /* -------------------------------------------------------------------------- */
 
-#include "IPAMManagerDriver.h"
 #include "IPAMManager.h"
 #include "NebulaLog.h"
 
 #include <sstream>
 
 /* ************************************************************************** */
-/* MAD Interface                                                              */
+/* Driver Protocol Implementation                                             */
 /* ************************************************************************** */
 
-void IPAMManagerDriver::protocol(const string& message) const
+void IPAMManager::_undefined(unique_ptr<ipam_msg_t> msg)
+{
+    NebulaLog::warn("IPM", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void IPAMManager::_notify_request(unique_ptr<ipam_msg_t> msg)
 {
-    istringstream is(message);
     ostringstream os;
 
-    string action;
-    string result;
-    string info="";
+    os << "Message received: ";
+    msg->write_to(os);
 
-    int id;
-
-    os << "Message received: " << message;
     NebulaLog::log("IPM", Log::DEBUG, os);
 
-    // Parse the driver message
-    if ( is.good() )
-        is >> action >> ws;
-    else
-        return;
-
-    if ( is.good() )
-        is >> result >> ws;
-    else
-        return;
-
-    if ( is.good() )
+    if (msg->status() == "SUCCESS")
     {
-        is >> id >> ws;
-
-        if ( is.fail() )
-        {
-            if ( action == "LOG" )
-            {
-                is.clear();
-                getline(is,info);
-
-                NebulaLog::log("IPM", log_type(result[0]), info.c_str());
-            }
-
-            return;
-        }
-    }
-    else
-        return;
-
-    getline(is, info);
-
-    if (action == "LOG")
-    {
-        NebulaLog::log("IPM", Log::INFO, info.c_str());
-    }
-    else if (result == "SUCCESS")
-    {
-        ipamm->notify_request(id, true, info);
+        notify_request(msg->oid(), true, msg->payload());
     }
     else
     {
-        ipamm->notify_request(id, false, info);
+        notify_request(msg->oid(), false, msg->payload());
     }
 
     return;
 }
 
-/* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void IPAMManagerDriver::recover()
+void IPAMManager::_log(unique_ptr<ipam_msg_t> msg)
 {
-    NebulaLog::log("IPM",Log::INFO,"Recovering IPAM drivers");
+    NebulaLog::log("IPM", log_type(msg->status()[0]), msg->payload());
 }
-
diff --git a/src/ipamm/SConstruct b/src/ipamm/SConstruct
index fd8a26cf51..76086fe136 100644
--- a/src/ipamm/SConstruct
+++ b/src/ipamm/SConstruct
@@ -23,7 +23,7 @@ lib_name='nebula_ipamm'
 # Sources to generate the library
 source_files=[
     'IPAMManager.cc',
-    'IPAMManagerDriver.cc',
+    'IPAMManagerProtocol.cc',
     'IPAMRequest.cc'
 ]
 
diff --git a/src/mad/Mad.cc b/src/mad/Mad.cc
deleted file mode 100644
index 80de4eb727..0000000000
--- a/src/mad/Mad.cc
+++ /dev/null
@@ -1,323 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include "Mad.h"
-#include "NebulaLog.h"
-
-#include "Nebula.h"
-
-#include <sstream>
-
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <cstring>
-#include <cerrno>
-
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-Mad::~Mad()
-{
-    char buf[]   = "FINALIZE\n";
-    bool success = false;
-
-    if ( pid==-1)
-    {
-        return;
-    }
-
-    // Finish the driver
-    ::write(nebula_mad_pipe, buf, strlen(buf));
-
-    close(mad_nebula_pipe);
-    close(nebula_mad_pipe);
-
-    for (int i=0; i < 2; ++i)
-    {
-        int status;
-
-        if ( waitpid(pid, &status, WNOHANG) != 0 )
-        {
-            success = true;
-            break;
-        }
-
-        sleep(1);
-    }
-
-    if (!success)
-    {
-        kill(pid, SIGKILL);
-    };
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int Mad::start()
-{
-    int                            ne_mad_pipe[2];
-    int                            mad_ne_pipe[2];
-
-    map<string,string>::iterator   it;
-
-    const char *                   owner = 0;
-    const char *                   executable = 0;
-    const char *                   arguments = 0;
-    string                         exec_path;
-
-    char                           buf[]="INIT\n";
-    char                           c;
-
-    stringbuf                      sbuf;
-    iostream                       mstream(&sbuf);
-    int                            rc;
-
-    string                         action;
-    string                         result;
-    string                         info;
-
-    ostringstream                  oss;
-
-    // Open communication pipes
-
-    if (pipe(ne_mad_pipe) == -1 ||
-        pipe(mad_ne_pipe) == -1)
-    {
-        goto error_pipes;
-    }
-
-    // Get the attributes for this driver
-
-    it = attributes.find("OWNER");
-
-    if ( it != attributes.end() )
-    {
-        owner = it->second.c_str();
-    }
-
-    it = attributes.find("EXECUTABLE");
-
-    if ( it != attributes.end() )
-    {
-        if ( it->second.empty() == false )
-        {
-            if (it->second[0] != '/') //Look in ONE_LOCATION/lib/mads or in "/usr/lib/one/mads"
-            {
-                Nebula& nd = Nebula::instance();
-
-                exec_path = nd.get_mad_location() + it->second;
-                executable= exec_path.c_str();
-            }
-            else //Absolute Path
-            {
-                executable = it->second.c_str();
-            }
-        }
-    }
-
-    it = attributes.find("ARGUMENTS");
-
-    if ( it != attributes.end() )
-    {
-        arguments = it->second.c_str();
-    }
-
-    if ( (sudo_execution == true && owner == 0) || executable == 0 )
-    {
-        goto error_attributes;
-    }
-
-    //Create a new process for the driver
-
-    pid = fork();
-
-    switch (pid)
-    {
-    case -1: // Error
-        goto error_fork;
-
-    case 0:  // Child process (MAD)
-
-        close(ne_mad_pipe[1]);
-        close(mad_ne_pipe[0]);
-
-        if (dup2(ne_mad_pipe[0], 0) != 0 || // stdin and stdout redirection
-            dup2(mad_ne_pipe[1], 1) != 1)
-        {
-            goto error_dup2;
-        }
-
-        close(ne_mad_pipe[0]);
-        close(mad_ne_pipe[1]);
-
-        close(2);
-
-        if ( sudo_execution == true )
-        {
-            rc = execlp("sudo","sudo","-H","-u",owner,executable,arguments,
-                     (char *) NULL);
-        }
-        else
-        {
-            rc = execlp(executable,executable,arguments,(char*)NULL);
-        }
-
-        goto error_exec;
-
-    default: // Parent process (SE)
-        fd_set          rfds;
-        struct timeval  tv;
-
-        close(ne_mad_pipe[0]);
-        close(mad_ne_pipe[1]);
-
-        nebula_mad_pipe = ne_mad_pipe[1];
-        mad_nebula_pipe = mad_ne_pipe[0];
-
-        // Close pipes in other MADs
-
-        fcntl(nebula_mad_pipe, F_SETFD, FD_CLOEXEC);
-        fcntl(mad_nebula_pipe, F_SETFD, FD_CLOEXEC);
-
-        ::write(nebula_mad_pipe, buf, strlen(buf));
-
-        do
-        {
-            FD_ZERO(&rfds);
-            FD_SET(mad_nebula_pipe, &rfds);
-
-            // Wait up to 30 seconds
-            tv.tv_sec  = 30;
-            tv.tv_usec = 0;
-
-            rc = select(mad_nebula_pipe+1,&rfds,0,0, &tv);
-
-            if ( rc <= 0 ) // MAD did not answered
-            {
-                goto error_mad_init;
-            }
-
-            rc = read(mad_nebula_pipe, (void *) &c, sizeof(char));
-            mstream.put(c);
-        }
-        while ( rc > 0 && c != '\n');
-
-        if ( rc <= 0 )
-        {
-            goto error_mad_init;
-        }
-
-        mstream >> action >> result >> ws;
-        getline(mstream,info);
-
-        if (action == "INIT")
-        {
-            if (result == "FAILURE")
-            {
-                goto error_mad_result;
-            }
-        }
-        else
-        {
-            goto error_mad_action;
-        }
-
-        break;
-    }
-
-    return 0;
-
-error_exec:
-    oss.str("");
-    oss << "Cannot load driver " << executable << ", " << strerror(errno);
-    NebulaLog::log("MAD", Log::ERROR, oss);
-    exit(-1);
-
-error_dup2:
-    oss.str("");
-    oss << "Cannot duplicate descriptors, " << strerror(errno);
-    NebulaLog::log("MAD", Log::ERROR, oss);
-    exit(-1);
-
-error_mad_result:
-    oss.str("");
-    oss << "MAD initialization failed, " << info;
-    NebulaLog::log("MAD", Log::ERROR, oss);
-    return -1;
-
-error_mad_action:
-    NebulaLog::log("MAD", Log::ERROR,"Wrong action in MAD response");
-    return -1;
-
-error_mad_init:
-    NebulaLog::log("MAD", Log::ERROR, "MAD did not answer INIT command");
-    return -1;
-
-error_fork:
-    oss.str("");
-    oss << "Error forking to start MAD, " << strerror(errno);
-    NebulaLog::log("MAD", Log::ERROR, oss);
-    return -1;
-
-error_attributes:
-    NebulaLog::log("MAD", Log::ERROR, "Wrong attributes for the driver");
-    return -1;
-
-error_pipes:
-    oss.str("");
-    oss << "Cannot create driver pipes, " << strerror(errno);
-    NebulaLog::log("MAD", Log::ERROR, oss);
-    return -1;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int Mad::reload()
-{
-    char    buf[]="FINALIZE\n";
-    int     status;
-    int     rc;
-    pid_t   rp;
-
-    // Finish the driver
-    ::write(nebula_mad_pipe, buf, strlen(buf));
-
-    close(nebula_mad_pipe);
-    close(mad_nebula_pipe);
-
-    rp = waitpid(pid, &status, WNOHANG);
-
-    if ( rp == 0 )
-    {
-        sleep(1);
-        waitpid(pid, &status, WNOHANG);
-    }
-
-    // Start the MAD again
-
-    rc = start();
-
-    return rc;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
diff --git a/src/mad/MadManager.cc b/src/mad/MadManager.cc
deleted file mode 100644
index b39682f1cb..0000000000
--- a/src/mad/MadManager.cc
+++ /dev/null
@@ -1,461 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include <signal.h>
-#include <fcntl.h>
-
-#include <string>
-#include <iostream>
-#include <sstream>
-
-#include "MadManager.h"
-#include "SyncRequest.h"
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-MadManager::MadManager(vector<const VectorAttribute*>& _mads):mad_conf(_mads)
-{
-    pthread_mutex_init(&mutex,0);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-MadManager::~MadManager()
-{
-    pthread_mutex_destroy(&mutex);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-extern "C" void * mad_manager_listener(
-        void *                  _mm)
-{
-    MadManager * mm;
-
-    mm = static_cast<MadManager *>(_mm);
-
-    mm->listener();
-
-    return 0;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MadManager::mad_manager_system_init()
-{
-    struct sigaction  act;
-
-    act.sa_handler = SIG_IGN;
-    act.sa_flags   = SA_RESTART;
-    sigemptyset(&act.sa_mask);
-
-    sigaction(SIGPIPE,&act,NULL);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int MadManager::start()
-{
-    int             rc;
-    int             pipes[2];
-
-    lock();
-
-    rc = pipe(pipes);
-
-    if ( rc == -1)
-    {
-        goto error_pipe;
-    }
-
-    pipe_r = pipes[0];
-    pipe_w = pipes[1];
-
-    fcntl(pipe_r, F_SETFD, FD_CLOEXEC);
-    fcntl(pipe_w, F_SETFD, FD_CLOEXEC);
-
-    fds.push_back(pipe_r);
-
-    rc = pthread_create(&listener_thread,
-                        0,
-                        mad_manager_listener,
-                        (void *) this);
-    if ( rc != 0 )
-    {
-        goto error_create;
-    }
-
-    unlock();
-
-    return 0;
-
-error_create:
-    close(pipe_r);
-    close(pipe_w);
-
-error_pipe:
-
-    unlock();
-
-    return -1;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MadManager::stop()
-{
-    pthread_cancel(listener_thread);
-
-    pthread_join(listener_thread,0);
-
-    lock();
-
-    close(pipe_r);
-
-    close(pipe_w);
-
-    for (unsigned int i=0;i<mads.size();i++)
-    {
-        delete mads[i];
-    }
-
-    unlock();
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int MadManager::add(Mad *mad)
-{
-    char    buf = 'A';
-    int     rc;
-
-    if ( mad == 0 )
-    {
-        return -1;
-    }
-
-    lock();
-
-    rc = mad->start();
-
-    if ( rc != 0 )
-    {
-        unlock();
-
-        return -1;
-    }
-
-    mads.push_back(mad);
-
-    write(pipe_w, &buf, sizeof(char));
-
-    unlock();
-
-    return 0;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-const Mad * MadManager::get(
-    int     uid,
-    const   string& name,
-    const   string& value)
-{
-    unsigned int                        i;
-    Mad *                               md = 0;
-    multimap<string,string>::iterator   it;
-
-    lock();
-
-    for (i=0;i<mads.size();i++)
-    {
-        if (uid == mads[i]->uid)
-        {
-            it = mads[i]->attributes.find(name);
-
-            if ((it != mads[i]->attributes.end()) &&
-                    (it->second == value))
-            {
-                md = mads[i];
-                break;
-            }
-        }
-    }
-
-    unlock();
-
-    return md;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MadManager::listener()
-{
-    int             greater;
-    unsigned int    i,j;
-    int             rc,mrc;
-
-    char            c;
-
-    Mad *           mad;
-    int             fd;
-    fd_set          in_pipes;
-    fd_set          rfds;
-    struct timeval  tv;
-
-    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
-
-    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,0);
-
-    while (1)
-    {
-        lock();
-
-        FD_ZERO(&in_pipes);
-
-        for (i=0,greater=0; i < fds.size() ; i++)
-        {
-            FD_SET(fds[i], &in_pipes);
-
-            if ( fds[i] > greater )
-            {
-                greater = fds[i];
-            }
-        }
-
-        unlock();
-
-        // Wait for a message
-        rc = select(greater+1, &in_pipes, NULL, NULL, NULL);
-
-        if ( rc <= 0 )
-        {
-            continue;
-        }
-
-        for (i=0; i< fds.size(); i++)
-        {
-            fd  = fds[i];
-
-            if ( FD_ISSET(fd, &in_pipes) )
-            {
-                if ( fd == pipe_r ) // Driver added, update the fd vector
-                {
-                    read(fd, (void *) &c, sizeof(char));
-
-                    lock();
-
-                    fds.clear();
-
-                    fds.push_back(pipe_r);
-
-                    for (j=0;j<mads.size();j++)
-                    {
-                        fds.push_back(mads[j]->mad_nebula_pipe);
-                    }
-
-                    unlock();
-
-                    continue;
-                }
-
-                mad = mads[i-1];
-
-                buffer.str("");
-
-                do
-                {
-                    FD_ZERO(&rfds);
-                    FD_SET(mad->mad_nebula_pipe, &rfds);
-
-                    tv.tv_sec  = 0;
-                    tv.tv_usec = 25000;
-
-                    rc = select(mad->mad_nebula_pipe+1,&rfds,0,0,&tv);
-
-                    if ( rc <= 0 )
-                    {
-                        break;
-                    }
-
-                    rc = read(mad->mad_nebula_pipe,(void *) &c,sizeof(char));
-                    buffer.put(c);
-                }
-                while ( rc > 0 && c != '\n');
-
-                if ( rc <= 0 ) // Error reload the driver and recover
-                {
-                    mrc = mad->reload();
-
-                    if ( mrc == 0 )
-                    {
-                        mad->recover();
-                    }
-                    else
-                    {
-                        lock();
-
-                        mads.erase(mads.begin() + i - 1);
-
-                        delete mad;
-
-                        unlock();
-
-                    }
-
-                    // Update the fd vector with the new pipe's
-
-                    lock();
-
-                    fds.clear();
-
-                    fds.push_back(pipe_r);
-
-                    for (j=0;j<mads.size();j++)
-                    {
-                        fds.push_back(mads[j]->mad_nebula_pipe);
-                    }
-
-                    unlock();
-
-                    continue;
-                }
-                else //MAD specific protocol
-                {
-                    string msg = buffer.str();
-
-                    mad->protocol(msg);
-                }
-            }
-        }
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MadManager::check_time_outs_action()
-{
-    map<int, SyncRequest *>::iterator it;
-
-    time_t the_time = time(0);
-
-    lock();
-
-    it = sync_requests.begin();
-
-    while ( it != sync_requests.end())
-    {
-        if ((it->second->time_out != 0) && (the_time > it->second->time_out))
-        {
-            SyncRequest * ar = it->second;
-            sync_requests.erase(it++);
-
-            ar->result  = false;
-            ar->timeout = true;
-            ar->message = "Request timeout";
-
-            ar->notify();
-        }
-        else
-        {
-            ++it;
-        }
-    }
-
-    unlock();
-
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MadManager::add_request(SyncRequest *ar)
-{
-    static int request_id = 0;
-
-    lock();
-
-    ar->id = request_id++;
-
-    sync_requests.insert(sync_requests.end(),make_pair(ar->id,ar));
-
-    unlock();
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-SyncRequest * MadManager::get_request(int id)
-{
-    SyncRequest * ar = 0;
-    map<int,SyncRequest *>::iterator it;
-    ostringstream oss;
-
-    lock();
-
-    it = sync_requests.find(id);
-
-    if ( it != sync_requests.end())
-    {
-        ar = it->second;
-
-        sync_requests.erase(it);
-    }
-
-    unlock();
-
-    return ar;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MadManager::notify_request(int id, bool result, const string& message)
-{
-
-    SyncRequest * ar;
-
-    ar = get_request(id);
-
-    if ( ar == 0 )
-    {
-        return;
-    }
-
-    ar->result = result;
-
-    if ( message != "-" )
-    {
-        if ( !ar->message.empty() )
-        {
-            ar->message.append("; ");
-        }
-
-        ar->message.append(message);
-    }
-
-    ar->notify();
-}
diff --git a/src/mad/SConstruct b/src/mad/SConstruct
deleted file mode 100644
index 1abb1ab0db..0000000000
--- a/src/mad/SConstruct
+++ /dev/null
@@ -1,30 +0,0 @@
-# SConstruct for src/mad
-
-# -------------------------------------------------------------------------- #
-# Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                #
-#                                                                            #
-# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
-# not use this file except in compliance with the License. You may obtain    #
-# a copy of the License at                                                   #
-#                                                                            #
-# http://www.apache.org/licenses/LICENSE-2.0                                 #
-#                                                                            #
-# Unless required by applicable law or agreed to in writing, software        #
-# distributed under the License is distributed on an "AS IS" BASIS,          #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
-# See the License for the specific language governing permissions and        #
-# limitations under the License.                                             #
-#--------------------------------------------------------------------------- #
-
-Import('env')
-
-lib_name='nebula_mad'
-
-# Sources to generate the library
-source_files=[
-    'Mad.cc',
-    'MadManager.cc'
-]
-
-# Build library
-env.StaticLibrary(lib_name, source_files)
diff --git a/src/market/MarketPlace.cc b/src/market/MarketPlace.cc
index d0427ac4a7..e734a9b810 100644
--- a/src/market/MarketPlace.cc
+++ b/src/market/MarketPlace.cc
@@ -19,20 +19,7 @@
 #include "NebulaLog.h"
 #include "NebulaUtil.h"
 #include "Nebula.h"
-
-/* ************************************************************************ */
-/* MarketPlace:: Database Definition                                        */
-/* ************************************************************************ */
-
-const char * MarketPlace::table = "marketplace_pool";
-
-const char * MarketPlace::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * MarketPlace::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS marketplace_pool (oid INTEGER PRIMARY KEY, "
-    "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
-    "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+#include "OneDB.h"
 
 /* ************************************************************************ */
 /* MarketPlace:: Constructor / Destructor                                   */
@@ -45,7 +32,7 @@ MarketPlace::MarketPlace(
     const std::string&    gname,
     int                   umask,
     MarketPlaceTemplate * mp_template):
-        PoolObjectSQL(-1, MARKETPLACE, "", uid, gid, uname, gname, table),
+        PoolObjectSQL(-1, MARKETPLACE, "", uid, gid, uname, gname, one_db::mp_table),
         market_mad(""),
         total_mb(0),
         free_mb(0),
@@ -159,6 +146,9 @@ error_common:
     return -1;
 }
 
+/* --------------------------------------------------------------------------- */
+/* --------------------------------------------------------------------------- */
+
 int MarketPlace::insert(SqlDB *db, string& error_str)
 {
     return insert_replace(db, false, error_str);
@@ -198,7 +188,7 @@ int MarketPlace::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::mp_table << " SET "
             << "name = '"   << sql_name << "', "
             << "body = '"   << sql_xml  << "', "
             << "gid = "     << gid      << ", "
@@ -210,7 +200,8 @@ int MarketPlace::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::mp_table
+            << " (" << one_db::mp_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -252,6 +243,13 @@ error_common:
 /* --------------------------------------------------------------------------- */
 /* --------------------------------------------------------------------------- */
 
+int MarketPlace::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::mp_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
 /* *************************************************************************** */
 /* MartketPlace :: Template Functions                                          */
 /* *************************************************************************** */
diff --git a/src/market/MarketPlaceApp.cc b/src/market/MarketPlaceApp.cc
index e9c9677fcc..7b6f5362d3 100644
--- a/src/market/MarketPlaceApp.cc
+++ b/src/market/MarketPlaceApp.cc
@@ -18,20 +18,7 @@
 #include "MarketPlaceApp.h"
 #include "NebulaLog.h"
 #include "NebulaUtil.h"
-
-/* ************************************************************************ */
-/* MarketPlaceApp:: Database Definition                                     */
-/* ************************************************************************ */
-
-const char * MarketPlaceApp::table = "marketplaceapp_pool";
-
-const char * MarketPlaceApp::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * MarketPlaceApp::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS marketplaceapp_pool (oid INTEGER PRIMARY KEY, "
-    "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
-    "owner_u INTEGER, group_u INTEGER, other_u INTEGER, UNIQUE(name,uid))";
+#include "OneDB.h"
 
 /* ************************************************************************ */
 /* MarketPlaceApp:: Constructor / Destructor                                */
@@ -44,7 +31,7 @@ MarketPlaceApp::MarketPlaceApp(
     const std::string&       gname,
     int                      umask,
     MarketPlaceAppTemplate * app_template):
-        PoolObjectSQL(-1, MARKETPLACEAPP, "", uid, gid, uname, gname, table),
+        PoolObjectSQL(-1, MARKETPLACEAPP, "", uid, gid, uname, gname, one_db::mp_app_table),
         source(""),
         md5(""),
         size_mb(0),
@@ -174,7 +161,7 @@ int MarketPlaceApp::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::mp_app_table << " SET "
             << "name = '"   << sql_name << "', "
             << "body = '"   << sql_xml  << "', "
             << "uid = "     << uid      << ", "
@@ -186,7 +173,8 @@ int MarketPlaceApp::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table <<" (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::mp_app_table
+            << " (" <<  one_db::mp_app_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -228,6 +216,16 @@ error_common:
 /* --------------------------------------------------------------------------- */
 /* --------------------------------------------------------------------------- */
 
+int MarketPlaceApp::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::mp_app_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
+/* --------------------------------------------------------------------------- */
+/* --------------------------------------------------------------------------- */
+
 /* *************************************************************************** */
 /* MartketPlaceApp :: Template Functions                                          */
 /* *************************************************************************** */
diff --git a/src/market/MarketPlaceManager.cc b/src/market/MarketPlaceManager.cc
index 2f70b03712..2d71bc4040 100644
--- a/src/market/MarketPlaceManager.cc
+++ b/src/market/MarketPlaceManager.cc
@@ -17,7 +17,6 @@
 #include "MarketPlaceManager.h"
 #include "MarketPlacePool.h"
 #include "MarketPlaceAppPool.h"
-#include "MarketPlaceManagerDriver.h"
 
 #include "Nebula.h"
 #include "RaftManager.h"
@@ -31,7 +30,7 @@ extern "C" void * marketplace_action_loop(void *arg)
 {
     MarketPlaceManager * mpm;
 
-    if ( arg == 0 )
+    if ( arg == nullptr )
     {
         return 0;
     }
@@ -52,8 +51,8 @@ extern "C" void * marketplace_action_loop(void *arg)
 MarketPlaceManager::MarketPlaceManager(
             time_t _timer_period,
             time_t _monitor_period,
-            std::vector<const VectorAttribute*>& _mads):
-        MadManager(_mads),
+            const string& _mad_location):
+        DriverManager(_mad_location),
         timer_period(_timer_period),
         monitor_period(_monitor_period),
         imagem(0),
@@ -72,23 +71,19 @@ MarketPlaceManager::MarketPlaceManager(
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-int MarketPlaceManager::load_mads(int uid)
+int MarketPlaceManager::load_drivers(const std::vector<const VectorAttribute*>& _mads)
 {
-    MarketPlaceManagerDriver * marketm_mad;
-
     std::ostringstream      oss;
-    const VectorAttribute * vattr = 0;
-
-    int rc;
+    const VectorAttribute * vattr = nullptr;
 
     NebulaLog::log("MKP", Log::INFO,"Loading Marketplace Manager driver.");
 
-    if ( mad_conf.size() > 0 )
+    if ( _mads.size() > 0 )
     {
-        vattr = static_cast<const VectorAttribute *>(mad_conf[0]);
+        vattr = _mads[0];
     }
 
-    if ( vattr == 0 )
+    if ( vattr == nullptr )
     {
         NebulaLog::log("MKP", Log::INFO,"Failed to load Marketplace Manager driver.");
         return -1;
@@ -98,20 +93,15 @@ int MarketPlaceManager::load_mads(int uid)
 
     market_conf.replace("NAME", market_driver_name);
 
-    marketm_mad= new MarketPlaceManagerDriver(0, market_conf.value(), false,
-            mppool, apppool, this);
-
-    rc = add(marketm_mad);
-
-    if ( rc == 0 )
+    if ( load_driver(&market_conf) != 0 )
     {
-        oss.str("");
-        oss << "\tMarketplace Manager loaded";
-
-        NebulaLog::log("MKP", Log::INFO, oss);
+        NebulaLog::error("MKP", "Unable to load IPAM Manager driver");
+        return -1;
     }
 
-    return rc;
+    NebulaLog::log("MKP", Log::INFO, "\tMarketplace Manager loaded");
+
+    return 0;
 }
 
 /* -------------------------------------------------------------------------- */
@@ -133,17 +123,34 @@ int MarketPlaceManager::start()
     int            rc;
     pthread_attr_t pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(MarketPlaceManagerMessages::UNDEFINED,
+            &MarketPlaceManager::_undefined);
+
+    register_action(MarketPlaceManagerMessages::IMPORT,
+            bind(&MarketPlaceManager::_import, this, _1));
+
+    register_action(MarketPlaceManagerMessages::DELETE,
+            bind(&MarketPlaceManager::_delete, this, _1));
+
+    register_action(MarketPlaceManagerMessages::MONITOR,
+            bind(&MarketPlaceManager::_monitor, this, _1));
+
+    register_action(MarketPlaceManagerMessages::LOG,
+            &MarketPlaceManager::_log);
+
+    string error;
+    if ( DriverManager::start(error) != 0 )
     {
+        NebulaLog::error("MKP", error);
         return -1;
     }
 
-    NebulaLog::log("ImM",Log::INFO,"Starting Marketplace Manager...");
+    NebulaLog::log("MKP",Log::INFO,"Starting Marketplace Manager...");
 
-    pthread_attr_init (&pattr);
-    pthread_attr_setdetachstate (&pattr, PTHREAD_CREATE_JOINABLE);
+    pthread_attr_init(&pattr);
+    pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 
     rc = pthread_create(&marketm_thread, &pattr, marketplace_action_loop,
             (void *) this);
@@ -194,7 +201,7 @@ void MarketPlaceManager::timer_action(const ActionRequest& ar)
 
     tics = 0;
 
-    if (raftm == 0 || (!raftm->is_leader() && !raftm->is_solo()))
+    if (raftm == nullptr || (!raftm->is_leader() && !raftm->is_solo()))
     {
         return;
     }
@@ -202,7 +209,6 @@ void MarketPlaceManager::timer_action(const ActionRequest& ar)
     int rc;
 
     std::vector<int> markets;
-    std::vector<int>::iterator it;
 
     rc = mppool->list(markets);
 
@@ -211,9 +217,9 @@ void MarketPlaceManager::timer_action(const ActionRequest& ar)
         return;
     }
 
-    for(it = markets.begin() ; it != markets.end(); it++)
+    for (auto m_id : markets)
     {
-        monitor_market(*it);
+        monitor_market(m_id);
     }
 
     return;
@@ -226,13 +232,12 @@ void MarketPlaceManager::monitor_market(int mp_id)
 {
     std::string  mp_data;
     std::string  mp_name;
-    std::string* drv_msg;
 
     std::ostringstream oss;
 
-    const MarketPlaceManagerDriver* mpmd = get();
+    auto mpmd = get();
 
-    if ( mpmd == 0 )
+    if ( mpmd == nullptr )
     {
         oss << "Error getting MarketPlaceManagerDriver";
 
@@ -242,7 +247,7 @@ void MarketPlaceManager::monitor_market(int mp_id)
 
     MarketPlace * mp = mppool->get(mp_id);
 
-    if ( mp == 0 )
+    if ( mp == nullptr )
     {
         return;
     }
@@ -269,13 +274,12 @@ void MarketPlaceManager::monitor_market(int mp_id)
 
     mp->unlock();
 
-    drv_msg = MarketPlaceManager::format_message("", mp_data, "");
+    unique_ptr<string> drv_msg(MarketPlaceManager::format_message("", mp_data, ""));
 
     oss << "Monitoring marketplace " << mp_name  << " (" << mp_id << ")";
 
     NebulaLog::log("MKP", Log::DEBUG, oss);
 
-    mpmd->monitor(mp_id, *drv_msg);
-
-    delete drv_msg;
+    market_msg_t msg(MarketPlaceManagerMessages::MONITOR, "", mp_id, *drv_msg);
+    mpmd->write(msg);
 }
diff --git a/src/market/MarketPlaceManagerActions.cc b/src/market/MarketPlaceManagerActions.cc
index 2b0b8666ee..7210851781 100644
--- a/src/market/MarketPlaceManagerActions.cc
+++ b/src/market/MarketPlaceManagerActions.cc
@@ -17,7 +17,6 @@
 #include "MarketPlaceManager.h"
 #include "MarketPlacePool.h"
 #include "MarketPlaceAppPool.h"
-#include "MarketPlaceManagerDriver.h"
 
 #include "ImagePool.h"
 #include "DatastorePool.h"
@@ -36,18 +35,18 @@ int MarketPlaceManager::import_app(
         std::string&       err)
 {
     std::string app_data, image_data, ds_data;
-	std::string * msg;
+    std::string * drv_msg;
 
-	Image * image;
-	Datastore * ds;
+    Image * image;
+    Datastore * ds;
 
-	int ds_id;
+    int ds_id;
 
-    const MarketPlaceManagerDriver* mpmd;
+    market_msg_t msg(MarketPlaceManagerMessages::IMPORT, "", appid, "");
 
     MarketPlaceApp * app = apppool->get_ro(appid);
 
-    if ( app == 0 )
+    if ( app == nullptr )
     {
         err = "Marketplace app no longer exists";
         return -1;
@@ -57,20 +56,27 @@ int MarketPlaceManager::import_app(
 
     MarketPlaceApp::Type type = app->get_type();
 
-	int app_id    = app->get_oid();
+    int app_id    = app->get_oid();
     int origin_id = app->get_origin_id();
 
     app->unlock();
 
+    auto mpmd = get();
+
+    if ( mpmd == nullptr )
+    {
+        goto error_driver;
+    }
+
     switch (type)
     {
         case MarketPlaceApp::IMAGE:
             image = ipool->get_ro(origin_id);
 
-			if ( image == 0 )
-			{
+            if ( image == nullptr )
+            {
                 goto error_noimage;
-			}
+            }
 
             image->to_xml(image_data);
 
@@ -80,20 +86,20 @@ int MarketPlaceManager::import_app(
 
             ds = dspool->get_ro(ds_id);
 
-			if ( ds == 0 )
-			{
+            if ( ds == nullptr )
+            {
                 goto error_nods;
-			}
+            }
 
             ds->to_xml(ds_data);
 
             ds->unlock();
 
-			if (imagem->set_app_clone_state(app_id, origin_id, err) != 0)
-			{
-				goto error_clone;
-			}
-			break;
+            if (imagem->set_app_clone_state(app_id, origin_id, err) != 0)
+            {
+                goto error_clone;
+            }
+            break;
 
         case MarketPlaceApp::VMTEMPLATE:
         case MarketPlaceApp::SERVICE_TEMPLATE:
@@ -101,18 +107,11 @@ int MarketPlaceManager::import_app(
             goto error_type;
     }
 
-    mpmd = get();
+    unique_ptr<string> drv_msg(format_message(app_data, market_data,
+                image_data + ds_data));
 
-    if ( mpmd == 0 )
-    {
-        goto error_driver;
-    }
-
-    msg = format_message(app_data, market_data, image_data + ds_data);
-
-    mpmd->importapp(appid, *msg);
-
-    delete msg;
+    msg.payload(*drv_msg);
+    mpmd->write(msg);
 
     return 0;
 
@@ -135,7 +134,7 @@ error_clone:
 error_common:
     app = apppool->get(appid);
 
-    if ( app == 0 )
+    if ( app == nullptr )
     {
         return -1;
     }
@@ -160,7 +159,7 @@ void MarketPlaceManager::release_app_resources(int appid)
 {
     MarketPlaceApp * app = apppool->get_ro(appid);
 
-    if (app == 0)
+    if (app == nullptr)
     {
         return;
     }
@@ -190,23 +189,19 @@ void MarketPlaceManager::release_app_resources(int appid)
 int MarketPlaceManager::delete_app(int appid, const std::string& market_data,
         std::string& error_str)
 {
-    MarketPlaceApp * app;
-    MarketPlace *    mp;
-
     std::string app_data;
-    std::string * msg;
 
-    const MarketPlaceManagerDriver* mpmd = get();
+    auto mpmd = get();
 
-    if ( mpmd == 0 )
+    if ( mpmd == nullptr )
     {
         error_str = "Error getting MarketPlaceManagerDriver";
         return -1;
     }
 
-    app = apppool->get_ro(appid);
+    MarketPlaceApp * app = apppool->get_ro(appid);
 
-    if (app == 0)
+    if (app == nullptr)
     {
         error_str = "Marketplace app no longer exists";
         return -1;
@@ -243,9 +238,9 @@ int MarketPlaceManager::delete_app(int appid, const std::string& market_data,
             return -1;
     }
 
-    mp = mppool->get(market_id);
+    MarketPlace * mp = mppool->get(market_id);
 
-    if ( mp != 0 )
+    if ( mp != nullptr )
     {
         mp->del_marketapp(appid);
 
@@ -254,11 +249,10 @@ int MarketPlaceManager::delete_app(int appid, const std::string& market_data,
         mp->unlock();
     }
 
-    msg = format_message(app_data, market_data, "");
+    unique_ptr<string> drv_msg(format_message(app_data, market_data, ""));
 
-    mpmd->deleteapp(appid, *msg);
-
-    delete msg;
+    market_msg_t msg(MarketPlaceManagerMessages::DELETE, "", appid, *drv_msg);
+    mpmd->write(msg);
 
     return 0;
 }
diff --git a/src/market/MarketPlaceManagerDriver.cc b/src/market/MarketPlaceManagerDriver.cc
deleted file mode 100644
index 32737dcb23..0000000000
--- a/src/market/MarketPlaceManagerDriver.cc
+++ /dev/null
@@ -1,526 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include "MarketPlaceManagerDriver.h"
-#include "MarketPlace.h"
-#include "MarketPlaceAppPool.h"
-#include "MarketPlaceManager.h"
-#include "MarketPlacePool.h"
-#include "NebulaLog.h"
-#include <sstream>
-
-/* ************************************************************************** */
-/* Driver ASCII Protocol Implementation                                       */
-/* ************************************************************************** */
-
-void MarketPlaceManagerDriver::importapp(int oid, const std::string& msg) const
-{
-    std::ostringstream os;
-
-    os << "IMPORT " << oid << " " << msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void MarketPlaceManagerDriver::deleteapp(int oid, const std::string& msg) const
-{
-    std::ostringstream os;
-
-    os << "DELETE " << oid << " " << msg << endl;
-
-    write(os);
-}
-
-/* -------------------------------------------------------------------------- */
-
-void MarketPlaceManagerDriver::monitor(int oid, const std::string& msg) const
-{
-    std::ostringstream os;
-
-    os << "MONITOR " << oid << " " << msg << endl;
-
-    write(os);
-}
-
-/* ************************************************************************** */
-/* MAD Interface                                                              */
-/* ************************************************************************** */
-
-static void monitor_action(
-        std::istringstream&  is,
-        MarketPlacePool *    marketpool,
-        MarketPlaceAppPool * apppool,
-        MarketPlaceManager * marketm,
-        int                  id,
-        const std::string&   result)
-{
-    std::string  info64;
-    std::string* info = 0;
-
-    std::ostringstream oss;
-
-    getline (is, info64);
-
-    if (is.fail())
-    {
-        oss << "Error monitoring marketplace " << id << ". Bad monitor data: "
-            << info64;
-
-        NebulaLog::log("MKP", Log::ERROR, oss);
-        return;
-    }
-
-    if (result != "SUCCESS")
-    {
-        oss << "Error monitoring marketplace " << id << ": " << info64;
-        NebulaLog::log("MKP", Log::ERROR, oss);
-
-        delete info;
-        return;
-    }
-
-    info = one_util::base64_decode(info64);
-
-    if (info == 0)
-    {
-        oss << "Error monitoring marketplace " << id << ". Bad monitor data: "
-            << info64;
-
-        NebulaLog::log("MKP", Log::ERROR, oss);
-        return;
-    }
-
-
-    Template monitor_data;
-
-    char * error_msg;
-    int    rc = monitor_data.parse(*info, &error_msg);
-
-    delete info;
-
-    if ( rc != 0 )
-    {
-        oss << "Error parsing marketplace information: " << error_msg
-            << ". Monitoring information: " << endl << info64;
-
-        NebulaLog::log("MKP", Log::ERROR, oss);
-
-        free(error_msg);
-        return;
-    }
-
-    MarketPlace * market = marketpool->get(id);
-
-    if (market == 0 )
-    {
-        return;
-    }
-
-    set<int> apps_mp = market->get_marketapp_ids();
-    std::string name = market->get_name();
-
-    market->update_monitor(monitor_data);
-
-    marketpool->update(market);
-
-    market->unlock();
-
-    std::vector<SingleAttribute *> apps;
-    std::string err;
-
-    int num = monitor_data.get("APP", apps);
-
-    for (int i=0; i< num ; i++)
-    {
-        int app_id;
-        int rc = apppool->import(apps[i]->value(), id, name, app_id, err);
-
-        if ( rc == -1 )
-        {
-            NebulaLog::log("MKP", Log::ERROR, "Error importing app: " + err);
-        }
-        else if ( rc >= 0 ) //-2 means app already imported
-        {
-            MarketPlace * market = marketpool->get(id);
-
-            if ( market != 0 )
-            {
-                market->add_marketapp(rc);
-
-                marketpool->update(market);
-
-                market->unlock();
-            }
-        }
-
-        apppool->reset_map_check(app_id);
-
-        apps_mp.erase(app_id);
-    }
-
-    if (num > 0) // num = 0 when no APP information in monitor data
-    {
-        for (set<int>::iterator i = apps_mp.begin(); i != apps_mp.end(); ++i)
-        {
-            if (apppool->test_map_check(*i)) //delete app
-            {
-                std::string error;
-
-                MarketPlaceApp * app = apppool->get(*i);
-
-                if ( app == 0 )
-                {
-                    continue;
-                }
-
-                rc = apppool->drop(app, error);
-
-                app->unlock();
-
-                market = marketpool->get(id);
-
-                market->del_marketapp(*i);
-
-                marketpool->update(market);
-
-                market->unlock();
-            }
-        }
-    }
-
-    oss << "Marketplace " << name << " (" << id << ") successfully monitored.";
-
-    NebulaLog::log("MKP", Log::DEBUG, oss);
-
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-/* Helper functions for failure and error conditions                          */
-/* -------------------------------------------------------------------------- */
-
-static void set_failure_response(
-        std::istringstream * is,
-        PoolObjectSQL *     obj,
-        const std::string&  msg)
-{
-    std::ostringstream oss;
-    std::string        info;
-
-    oss << msg;
-
-    getline(*is, info);
-
-    if (!info.empty() && (info[0] != '-'))
-    {
-        oss << ": " << info;
-    }
-
-    if (obj != 0)
-    {
-        obj->set_template_error_message(oss.str());
-    }
-
-    NebulaLog::log("MKP", Log::ERROR, oss);
-}
-
-static void app_failure_action(
-        std::istringstream * is,
-        MarketPlaceAppPool * apppool,
-        int                  id,
-        const std::string&   msg)
-{
-    MarketPlaceApp * app = apppool->get(id);
-
-    if (app == 0)
-    {
-        return;
-    }
-
-    if ( is == 0)
-    {
-        app->set_template_error_message(msg);
-
-        NebulaLog::log("MKP", Log::ERROR, msg);
-    }
-    else
-    {
-        set_failure_response(is, app, msg);
-    }
-
-    app->set_state(MarketPlaceApp::ERROR);
-
-    apppool->update(app);
-
-    app->unlock();
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-static int import_action(
-        std::istringstream&  is,
-        MarketPlaceAppPool * apppool,
-        MarketPlaceManager * marketm,
-        int                  id,
-        const std::string&   result)
-{
-    bool rc;
-    int  rci;
-
-    std::string   error;
-    std::string   info64;
-    std::string * info;
-
-    MarketPlaceApp *       app;
-    MarketPlaceAppTemplate tmpl;
-
-    std::string source;
-    std::string checksum;
-    std::string format;
-    long long   size_mb;
-
-    marketm->release_app_resources(id);
-
-    if ( result == "FAILURE" )
-    {
-        app_failure_action(&is, apppool, id, "Error importing app into marketplace");
-        return -1;
-    }
-
-    getline(is, info64);
-
-    if (is.fail())
-    {
-        goto error_parse;
-    }
-
-    info = one_util::base64_decode(info64);
-
-    if ( info == 0 )
-    {
-        goto error_decode64;
-    }
-
-    rci = tmpl.parse_str_or_xml(*info, error);
-
-    delete info;
-
-    if ( rci != 0 )
-    {
-        goto error_parse_template;
-    }
-
-    tmpl.get("SOURCE", source);
-    tmpl.get("MD5", checksum);
-    tmpl.get("FORMAT", format);
-    rc = tmpl.get("SIZE", size_mb);
-
-    if ( source.empty() || checksum.empty() || format.empty() || rc == false )
-    {
-        goto error_attributes;
-    }
-
-    app = apppool->get(id);
-
-    if (app == 0)
-    {
-        goto error_app;
-    }
-
-    app->set_source(source);
-    app->set_md5(checksum);
-    app->set_size(size_mb);
-    app->set_format(format);
-
-    app->set_state(MarketPlaceApp::READY);
-
-    apppool->update(app);
-
-    app->unlock();
-
-    NebulaLog::log("MKP", Log::INFO, "Marketplace app successfully imported");
-
-    return 0;
-
-error_parse:
-    app_failure_action(0, apppool, id,
-        "Error importing app into marketplace. Wrong message from driver.");
-    return -1;
-
-error_decode64:
-    app_failure_action(0, apppool, id,
-        "Error importing app into marketplace. Bad base64 encoding.");
-    return -1;
-
-error_parse_template:
-    app_failure_action(0, apppool, id,
-        "Error importing app into marketplace. Parse error: " + error);
-    return -1;
-
-error_attributes:
-    app_failure_action(0, apppool, id,
-        "Error importing app into marketplace. Missing app attributes.");
-    return -1;
-
-error_app:
-    NebulaLog::log("MKP", Log::ERROR, "Marketplace app successfully imported "
-        "but it no longer exists. You may need to manually remove: " + source);
-    return -1;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-static int delete_action(
-        std::istringstream&  is,
-        MarketPlaceAppPool * apppool,
-        MarketPlaceManager * marketm,
-        int                  id,
-        const std::string&   result)
-{
-    int rc;
-
-    std::string source;
-    std::string error;
-
-    std::ostringstream eoss("Error removing app from marketplace", std::ios::ate);
-
-    MarketPlaceApp * app = apppool->get(id);
-
-    if ( app == 0 )
-    {
-        return -1;
-    }
-
-    source = app->get_source();
-
-    rc = apppool->drop(app, error);
-
-    app->unlock();
-
-    if ( result == "FAILURE" )
-    {
-        std::string info;
-
-        getline(is, info);
-
-        if (!info.empty() && (info[0] != '-'))
-        {
-            eoss << ": " << info;
-        }
-
-        eoss << ".";
-    }
-
-    if ( rc < 0 )
-    {
-        eoss << " Error removing app from DB: " << error
-             << ". Remove app manually, source is: " << source;
-    }
-
-    if ( rc < 0 || result == "FAILURE" )
-    {
-        NebulaLog::log("MKP", Log::ERROR, eoss.str());
-    }
-    else
-    {
-        NebulaLog::log("MKP",Log::INFO,"Marketplace app successfully removed.");
-    }
-
-    return rc;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MarketPlaceManagerDriver::protocol(const string& message) const
-{
-    std::istringstream is(message);
-    std::ostringstream oss;
-
-    std::string action;
-    std::string result;
-    std::string info;
-
-    int id;
-
-    oss << "Message received: " << message;
-    NebulaLog::log("MKP", Log::DDEBUG, oss);
-
-    // --------------------- Parse the driver message --------------------------
-
-    if ( is.good() )
-        is >> action >> ws;
-    else
-        return;
-
-    if ( is.good() )
-        is >> result >> ws;
-    else
-        return;
-
-    if ( is.good() )
-    {
-        is >> id >> ws;
-
-        if ( is.fail() )
-        {
-            if ( action == "LOG" )
-            {
-                is.clear();
-                getline(is,info);
-
-                NebulaLog::log("MKP",log_type(result[0]), info.c_str());
-            }
-
-            return;
-        }
-    }
-    else
-        return;
-
-    if (action == "IMPORT")
-    {
-        import_action(is, apppool, marketm, id, result);
-    }
-    else if (action == "DELETE")
-    {
-        delete_action(is, apppool, marketm, id, result);
-    }
-    else if (action == "MONITOR")
-    {
-        monitor_action(is, marketpool, apppool, marketm, id, result);
-    }
-    else if (action == "LOG")
-    {
-        getline(is,info);
-        NebulaLog::log("MKP", log_type(result[0]), info.c_str());
-    }
-
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void MarketPlaceManagerDriver::recover()
-{
-    NebulaLog::log("MKP",Log::INFO,"Recovering MarketPlace drivers");
-}
-
diff --git a/src/market/MarketPlaceManagerProtocol.cc b/src/market/MarketPlaceManagerProtocol.cc
new file mode 100644
index 0000000000..a698f7409b
--- /dev/null
+++ b/src/market/MarketPlaceManagerProtocol.cc
@@ -0,0 +1,342 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "MarketPlaceManager.h"
+#include "MarketPlace.h"
+#include "MarketPlacePool.h"
+#include "MarketPlaceAppPool.h"
+#include "NebulaLog.h"
+// #include "Template.h"
+
+/* -------------------------------------------------------------------------- */
+/* Helper functions for failure and error conditions                          */
+/* -------------------------------------------------------------------------- */
+
+static void app_failure_action(
+        MarketPlaceAppPool * apppool,
+        int                  id,
+        const string&        msg)
+{
+    MarketPlaceApp * app = apppool->get(id);
+
+    if (app == nullptr)
+    {
+        return;
+    }
+
+    app->set_template_error_message(msg);
+
+    NebulaLog::error("MKP", msg);
+
+    app->set_state(MarketPlaceApp::ERROR);
+
+    apppool->update(app);
+
+    app->unlock();
+}
+
+/* ************************************************************************** */
+/* Driver Protocol Implementation                                             */
+/* ************************************************************************** */
+
+void MarketPlaceManager::_undefined(unique_ptr<market_msg_t> msg)
+{
+    NebulaLog::warn("MKP", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void MarketPlaceManager::_import(unique_ptr<market_msg_t> msg)
+{
+    string str_msg;
+    msg->write_to(str_msg);
+    NebulaLog::ddebug("MKP", "Message received: " + str_msg);
+
+    bool rc;
+    int  rci;
+
+    string   error;
+
+    MarketPlaceApp *       app;
+    MarketPlaceAppTemplate tmpl;
+
+    string source;
+    string checksum;
+    string format;
+    long long   size_mb;
+
+    int id = msg->oid();
+
+    release_app_resources(id);
+
+    if (msg->status() == "FAILURE")
+    {
+        app_failure_action(apppool, id, "Error importing app into marketplace: "
+            + msg->payload());
+        return;
+    }
+
+    unique_ptr<string> info(one_util::base64_decode(msg->payload()));
+
+    if (info.get() == nullptr)
+    {
+        app_failure_action(apppool, id,
+            "Error importing app into marketplace. Bad base64 encoding.");
+        return;
+    }
+
+    rci = tmpl.parse_str_or_xml(*info, error);
+
+    if (rci != 0)
+    {
+        app_failure_action(apppool, id,
+            "Error importing app into marketplace. Parse error: " + error);
+        return;
+    }
+
+    tmpl.get("SOURCE", source);
+    tmpl.get("MD5", checksum);
+    tmpl.get("FORMAT", format);
+    rc = tmpl.get("SIZE", size_mb);
+
+    if ( source.empty() || checksum.empty() || format.empty() || rc == false )
+    {
+        app_failure_action(apppool, id,
+            "Error importing app into marketplace. Missing app attributes.");
+        return;
+    }
+
+    app = apppool->get(id);
+
+    if (app == nullptr)
+    {
+        NebulaLog::error("MKP", "Marketplace app successfully imported "
+            "but it no longer exists. You may need to manually remove: " + source);
+        return;
+    }
+
+    app->set_source(source);
+    app->set_md5(checksum);
+    app->set_size(size_mb);
+    app->set_format(format);
+
+    app->set_state(MarketPlaceApp::READY);
+
+    apppool->update(app);
+
+    app->unlock();
+
+    NebulaLog::info("MKP", "Marketplace app successfully imported");
+}
+
+/* -------------------------------------------------------------------------- */
+
+void MarketPlaceManager::_delete(unique_ptr<market_msg_t> msg)
+{
+    string str_msg;
+    msg->write_to(str_msg);
+    NebulaLog::ddebug("MKP", "Message received: " + str_msg);
+
+    int rc;
+
+    string source;
+    string error;
+
+    ostringstream eoss("Error removing app from marketplace", ios::ate);
+
+    int id = msg->oid();
+    MarketPlaceApp * app = apppool->get(id);
+
+    if (app == nullptr)
+    {
+        return;
+    }
+
+    source = app->get_source();
+
+    rc = apppool->drop(app, error);
+
+    app->unlock();
+
+    if (msg->status() == "FAILURE")
+    {
+        const string& info = msg->payload();
+
+        if (!info.empty() && (info[0] != '-'))
+        {
+            eoss << ": " << info;
+        }
+
+        eoss << ".";
+    }
+
+    if (rc < 0)
+    {
+        eoss << " Error removing app from DB: " << error
+             << ". Remove app manually, source is: " << source;
+    }
+
+    if (rc < 0 || msg->status() == "FAILURE")
+    {
+        NebulaLog::error("MKP", eoss.str());
+    }
+    else
+    {
+        NebulaLog::info("MKP", "Marketplace app successfully removed.");
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void MarketPlaceManager::_monitor(unique_ptr<market_msg_t> msg)
+{
+    string str_msg;
+    msg->write_to(str_msg);
+    NebulaLog::ddebug("MKP", "Message received: " + str_msg);
+
+    ostringstream oss;
+
+    int id = msg->oid();
+
+    if (msg->status() != "SUCCESS")
+    {
+        oss << "Error monitoring marketplace " << id << ": " << msg->payload();
+        NebulaLog::log("MKP", Log::ERROR, oss);
+
+        return;
+    }
+
+    unique_ptr<string> info(one_util::base64_decode(msg->payload()));
+
+    if (info.get() == nullptr)
+    {
+        oss << "Error monitoring marketplace " << id << ". Bad monitor data: "
+            << msg->payload();
+
+        NebulaLog::log("MKP", Log::ERROR, oss);
+        return;
+    }
+
+    Template monitor_data;
+
+    char * error_msg;
+    int    rc = monitor_data.parse(*info, &error_msg);
+
+    if (rc != 0)
+    {
+        oss << "Error parsing marketplace information: " << error_msg
+            << ". Monitoring information: " << endl << *info;
+
+        NebulaLog::log("MKP", Log::ERROR, oss);
+
+        free(error_msg);
+        return;
+    }
+
+    MarketPlace * market = mppool->get(id);
+
+    if (market == nullptr)
+    {
+        return;
+    }
+
+    set<int> apps_mp = market->get_marketapp_ids();
+    string name = market->get_name();
+
+    market->update_monitor(monitor_data);
+
+    mppool->update(market);
+
+    market->unlock();
+
+    vector<SingleAttribute *> apps;
+    string err;
+
+    int num = monitor_data.get("APP", apps);
+
+    for (int i=0; i< num; i++)
+    {
+        int app_id;
+        int rc = apppool->import(apps[i]->value(), id, name, app_id, err);
+
+        if (rc == -1)
+        {
+            NebulaLog::error("MKP", "Error importing app: " + err);
+        }
+        else if (rc >= 0) //-2 means app already imported
+        {
+            MarketPlace * market = mppool->get(id);
+
+            if (market != nullptr)
+            {
+                market->add_marketapp(rc);
+
+                mppool->update(market);
+
+                market->unlock();
+            }
+        }
+
+        apppool->reset_map_check(app_id);
+
+        apps_mp.erase(app_id);
+    }
+
+    if (num > 0) // num = 0 when no APP information in monitor data
+    {
+        for (int i : apps_mp)
+        {
+            if (apppool->test_map_check(i)) //delete app
+            {
+                string error;
+
+                MarketPlaceApp * app = apppool->get(i);
+
+                if (app == nullptr)
+                {
+                    continue;
+                }
+
+                rc = apppool->drop(app, error);
+
+                app->unlock();
+
+                market = mppool->get(id);
+
+                market->del_marketapp(i);
+
+                mppool->update(market);
+
+                market->unlock();
+            }
+        }
+    }
+
+    oss << "Marketplace " << name << " (" << id << ") successfully monitored.";
+
+    NebulaLog::debug("MKP", oss.str());
+
+    return;
+}
+
+/* -------------------------------------------------------------------------- */
+
+void MarketPlaceManager::_log(unique_ptr<market_msg_t> msg)
+{
+    NebulaLog::log("MKP", log_type(msg->status()[0]), msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
diff --git a/src/market/MarketPlacePool.cc b/src/market/MarketPlacePool.cc
index f85ef1aff3..81dec8458c 100644
--- a/src/market/MarketPlacePool.cc
+++ b/src/market/MarketPlacePool.cc
@@ -22,7 +22,7 @@
 /* -------------------------------------------------------------------------- */
 
 MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
-    :PoolSQL(db, MarketPlace::table)
+    :PoolSQL(db, one_db::mp_table)
 {
     //Federation slaves do not need to init the pool
     if (is_federation_slave)
diff --git a/src/market/SConstruct b/src/market/SConstruct
index 24bdec0fbc..8dc73adff9 100644
--- a/src/market/SConstruct
+++ b/src/market/SConstruct
@@ -27,7 +27,7 @@ source_files=[
     'MarketPlaceApp.cc',
     'MarketPlaceAppPool.cc',
     'MarketPlaceManager.cc',
-    'MarketPlaceManagerDriver.cc',
+    'MarketPlaceManagerProtocol.cc',
     'MarketPlaceManagerActions.cc'
 ]
 
diff --git a/src/monitor/include/Driver.h b/src/monitor/include/Driver.h
index 9d07222336..f20ac58811 100644
--- a/src/monitor/include/Driver.h
+++ b/src/monitor/include/Driver.h
@@ -32,10 +32,12 @@
  *  This class wraps the execution of a driver and setups a pipe as communication
  *  channel
  */
-template <typename E>
+template <typename MSG>
 class Driver
 {
 public:
+    using message_t = MSG;
+
     /**
      *  A call to the start() method is needed to start the driver
      *    @param c the command to execute the driver
@@ -94,9 +96,9 @@ public:
     /**
      *  Send a message to the driver
      */
-    void write(const Message<E>& msg) const
+    void write(const MSG& msg) const
     {
-        msg.write_to(to_drv, false);
+        msg.write_to(to_drv);
     };
 
     /**
@@ -105,11 +107,21 @@ public:
      *    @param t message type
      *    @param a callback function
      */
-    void register_action(E t, std::function<void(std::unique_ptr<Message<E>>)> a)
+    void register_action(typename MSG::msg_enum t,
+                         std::function<void(std::unique_ptr<MSG>)> a)
     {
         streamer.register_action(t, a);
     };
 
+protected:
+    Driver() = default;
+
+    void cmd_(const std::string& c) { cmd = c; }
+
+    void arg_(const std::string& a) { arg = a; }
+
+    void concurency_(int c) { concurrency = c; }
+
 private:
     /**
      *  Communication pipe file descriptor (daemon <- driver)
@@ -138,7 +150,7 @@ private:
     /**
      *  Class to read lines from the stream
      */
-    StreamManager<E> streamer;
+    StreamManager<MSG> streamer;
 
     std::thread stream_thr;
 
@@ -174,8 +186,9 @@ private:
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-void Driver<E>::stop_driver(int secs)
+template<typename MSG>
+void Driver<MSG>
+    ::stop_driver(int secs)
 {
     if ( pid == -1 )
     {
@@ -213,8 +226,9 @@ void Driver<E>::stop_driver(int secs)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-int Driver<E>::start_driver(std::string& error)
+template<typename MSG>
+int Driver<MSG>
+    ::start_driver(std::string& error)
 {
     // Open communication pipes
     int to_drv_pipe[2];
@@ -319,8 +333,9 @@ int Driver<E>::start_driver(std::string& error)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-void Driver<E>::start_listener()
+template<typename MSG>
+void Driver<MSG>
+    ::start_listener()
 {
     streamer.fd(from_drv);
 
diff --git a/src/monitor/include/DriverManager.h b/src/monitor/include/DriverManager.h
index 582c3bdef6..8fbc66cf71 100644
--- a/src/monitor/include/DriverManager.h
+++ b/src/monitor/include/DriverManager.h
@@ -20,19 +20,22 @@
 #include "Driver.h"
 #include "Attribute.h"
 #include "NebulaLog.h"
+#include "SyncRequest.h"
 #include <string>
 
-template<typename E, typename D>
+template<typename D>
 class DriverManager
 {
 public:
-    explicit DriverManager(const string& mad_location)
+    explicit DriverManager(const std::string& mad_location)
         : mad_location(mad_location)
     {
     }
 
     virtual ~DriverManager() = default;
 
+    int load_driver(const VectorAttribute* mad_config);
+
     int load_drivers(const vector<const VectorAttribute*>& mads_config);
 
     D * get_driver(const std::string& name) const;
@@ -41,8 +44,8 @@ public:
      *  Register an action for a given message type. The action is registered
      *  for all installed drivers. Must be called after load_drivers method.
      */
-    void register_action(E t,
-        std::function<void(std::unique_ptr<Message<E>>)> a);
+    void register_action(typename D::message_t::msg_enum t,
+        std::function<void(std::unique_ptr<typename D::message_t>)> a);
 
     /**
      *  Start all drivers
@@ -55,60 +58,95 @@ public:
      */
     void stop(int secs);
 
+protected:
+    int add(const std::string& name, std::unique_ptr<D> driver);
+
+    /* SyncReqeust methods implementation */
+
+    /**
+     *  This function can be periodically executed to check time_outs on
+     *  request. It will fail requests with an expired timeout and will notify
+     *  the clients.
+     */
+    void check_time_outs_action();
+
+    /**
+     *  Add a new request to the Request map
+     *    @param ar pointer to the request
+     *    @return the id for the request
+     */
+    void add_request(SyncRequest *ar);
+
+    /**
+     *  Gets request from the Request map
+     *    @param id for the request
+     *    @return pointer to the Request
+     */
+    SyncRequest * get_request(int id);
+
+    /**
+     *  Notify the result of an auth request
+     */
+    void notify_request(int id, bool result, const std::string& message);
+
+    static Log::MessageType log_type(char type);
+
 private:
     std::map<std::string, std::unique_ptr<D>> drivers;
 
-    string mad_location;
+    std::string mad_location;
+
+    /**
+     *  List of pending requests
+     */
+    std::map<int, SyncRequest *> sync_requests;
+
+    std::mutex _mutex;
 };
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E, typename D>
-int DriverManager<E, D>::load_drivers(const vector<const VectorAttribute*>& mads_config)
+template<typename D>
+int DriverManager<D>::load_driver(const VectorAttribute* mad_config)
 {
-    NebulaLog::info("DrM", "Loading drivers.");
+    auto name = mad_config->vector_value("NAME");
+    auto exec = mad_config->vector_value("EXECUTABLE");
+    auto args = mad_config->vector_value("ARGUMENTS");
+    int  threads;
 
-    for (const auto& vattr : mads_config)
+    mad_config->vector_value("THREADS", threads, 0);
+
+    NebulaLog::info("DrM", "Loading driver: " + name);
+
+    if (exec.empty())
     {
-        auto name = vattr->vector_value("NAME");
-        auto exec = vattr->vector_value("EXECUTABLE");
-        auto args = vattr->vector_value("ARGUMENTS");
-        int  threads;
+        NebulaLog::error("DrM", "\tEmpty executable for driver: " + name);
+        return -1;
+    }
 
-        vattr->vector_value("THREADS", threads, 0);
+    if (exec[0] != '/') //Look in ONE_LOCATION/lib/mads or in "/usr/lib/one/mads"
+    {
+        exec = mad_location + exec;
+    }
 
-        NebulaLog::info("InM", "Loading driver: " + name);
+    if (access(exec.c_str(), F_OK) != 0)
+    {
+        NebulaLog::error("DrM", "File not exists: " + exec);
+        return -1;
+    }
 
-        if (exec.empty())
-        {
-            NebulaLog::error("InM", "\tEmpty executable for driver: " + name);
-            return -1;
-        }
+    auto rc = drivers.insert(std::make_pair(name,
+                std::unique_ptr<D>(new D(exec, args, threads))));
 
-        if (exec[0] != '/') //Look in ONE_LOCATION/lib/mads or in "/usr/lib/one/mads"
-        {
-            exec = mad_location + exec;
-        }
-
-        if (access(exec.c_str(), F_OK) != 0)
-        {
-            NebulaLog::error("InM", "File not exists: " + exec);
-            return -1;
-        }
-
-        auto rc = drivers.insert(std::make_pair(name,
-                    std::unique_ptr<D>(new D(exec, args, threads))));
-
-        if (rc.second)
-        {
-            NebulaLog::info("InM", "\tDriver loaded: " + name);
-        }
-        else
-        {
-            NebulaLog::error("InM", "\tDriver already exists: " + name);
-            return -1;
-        }
+    if (rc.second)
+    {
+        NebulaLog::info("DrM", "\tDriver loaded: " + name);
+    }
+    else
+    {
+        NebulaLog::error("DrM", "\tDriver already exists: " + name);
+        return -1;
     }
 
     return 0;
@@ -117,8 +155,26 @@ int DriverManager<E, D>::load_drivers(const vector<const VectorAttribute*>& mads
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E, typename D>
-D * DriverManager<E, D>::get_driver(const std::string& name) const
+template<typename D>
+int DriverManager<D>::load_drivers(const vector<const VectorAttribute*>& mads_config)
+{
+    NebulaLog::info("DrM", "Loading drivers.");
+
+    int rc = 0;
+
+    for (const auto& vattr : mads_config)
+    {
+        rc += load_driver(vattr);
+    }
+
+    return rc;
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
+template<typename D>
+D * DriverManager<D>::get_driver(const std::string& name) const
 {
     auto driver = drivers.find(name);
 
@@ -133,9 +189,9 @@ D * DriverManager<E, D>::get_driver(const std::string& name) const
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E, typename D>
-void DriverManager<E, D>::register_action(E t,
-    std::function<void(std::unique_ptr<Message<E>>)> a)
+template<typename D>
+void DriverManager<D>::register_action(typename D::message_t::msg_enum t,
+    std::function<void(std::unique_ptr<typename D::message_t>)> a)
 {
     for (auto& driver : drivers)
     {
@@ -146,15 +202,16 @@ void DriverManager<E, D>::register_action(E t,
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E, typename D>
-int DriverManager<E, D>::start(std::string& error)
+template<typename D>
+int DriverManager<D>::start(std::string& error)
 {
     for (auto& driver : drivers)
     {
         auto rc = driver.second->start(error);
         if (rc != 0)
         {
-            NebulaLog::error("DrM", "Unable to start driver: " + error);
+            NebulaLog::error("DrM", "Unable to start driver '" + driver.first
+                + "': " + error);
             return rc;
         }
     }
@@ -164,8 +221,8 @@ int DriverManager<E, D>::start(std::string& error)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E, typename D>
-void DriverManager<E, D>::stop(int secs)
+template<typename D>
+void DriverManager<D>::stop(int secs)
 {
     vector<thread> threads;
 
@@ -183,4 +240,141 @@ void DriverManager<E, D>::stop(int secs)
     }
 }
 
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+template<typename D>
+int DriverManager<D>::add(const std::string& name, std::unique_ptr<D> driver)
+{
+    auto rc = drivers.insert(std::make_pair(name, std::move(driver)));
+
+    if (!rc.second)
+    {
+        // Driver already exists
+        return -1;
+    }
+
+    return 0;
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
+template<typename D>
+void DriverManager<D>::check_time_outs_action()
+{
+    time_t the_time = time(0);
+
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    auto it = sync_requests.begin();
+
+    while (it != sync_requests.end())
+    {
+        if ((it->second->time_out != 0) && (the_time > it->second->time_out))
+        {
+            SyncRequest * ar = it->second;
+            sync_requests.erase(it++);
+
+            ar->result  = false;
+            ar->timeout = true;
+            ar->message = "Request timeout";
+
+            ar->notify();
+        }
+        else
+        {
+            ++it;
+        }
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
+template<typename D>
+void DriverManager<D>::add_request(SyncRequest *ar)
+{
+    static int request_id = 0;
+
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    ar->id = request_id++;
+
+    sync_requests.insert(sync_requests.end(),make_pair(ar->id,ar));
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
+template<typename D>
+SyncRequest * DriverManager<D>::get_request(int id)
+{
+    SyncRequest * ar = nullptr;
+
+    std::lock_guard<std::mutex> lock(_mutex);
+
+    auto it = sync_requests.find(id);
+
+    if (it != sync_requests.end())
+    {
+        ar = it->second;
+
+        sync_requests.erase(it);
+    }
+
+    return ar;
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
+template<typename D>
+void DriverManager<D>::notify_request(int id, bool result, const std::string& message)
+{
+    SyncRequest * ar = get_request(id);
+
+    if (ar == 0)
+    {
+        return;
+    }
+
+    ar->result = result;
+
+    if (message != "-")
+    {
+        if (!ar->message.empty())
+        {
+            ar->message.append("; ");
+        }
+
+        ar->message.append(message);
+    }
+
+    ar->notify();
+}
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
+template<typename D>
+Log::MessageType DriverManager<D>::log_type(char type)
+{
+    auto log_type = Log::INFO;
+
+    switch (type)
+    {
+        case 'E':
+            log_type = Log::ERROR;
+            break;
+        case 'W':
+            log_type = Log::WARNING;
+            break;
+        case 'D':
+            log_type = Log::DEBUG;
+            break;
+    }
+
+    return log_type;
+}
+
 #endif // DRIVER_MANAGER_H_
diff --git a/src/monitor/include/HostMonitorManager.h b/src/monitor/include/HostMonitorManager.h
index 8e25490f21..4dd034a8b3 100644
--- a/src/monitor/include/HostMonitorManager.h
+++ b/src/monitor/include/HostMonitorManager.h
@@ -25,7 +25,7 @@
 class Template;
 class VectorAttribute;
 
-template<typename E, typename D>
+template<typename D>
 class DriverManager;
 
 class VMRPCPool;
@@ -163,7 +163,7 @@ public:
     void timer_action();
 
 private:
-    using driver_manager_t = DriverManager<MonitorDriverMessages, MonitorDriver>;
+    using driver_manager_t = DriverManager<MonitorDriver>;
 
     driver_manager_t* driver_manager;
 
diff --git a/src/monitor/include/MonitorDriver.h b/src/monitor/include/MonitorDriver.h
index 64fe704261..d787365a9e 100644
--- a/src/monitor/include/MonitorDriver.h
+++ b/src/monitor/include/MonitorDriver.h
@@ -27,13 +27,11 @@
 #include <cstdarg>
 
 
-class MonitorDriver : public Driver<MonitorDriverMessages>
+class MonitorDriver : public Driver<monitor_msg_t>
 {
 public:
-    using message_t = Message<MonitorDriverMessages>;
-
     MonitorDriver(const std::string& c, const std::string& a, int ct):
-        Driver<MonitorDriverMessages>(c, a, ct)
+        Driver(c, a, ct)
     {
         register_action(MonitorDriverMessages::UNDEFINED,
                 &MonitorDriverProtocol::_undefined);
@@ -59,7 +57,7 @@ public:
 
     void start_monitor(int oid, const std::string& host_xml)
     {
-        message_t msg;
+        monitor_msg_t msg;
         NebulaService& ns = Monitor::instance();
 
         msg.type(MonitorDriverMessages::START_MONITOR);
@@ -71,7 +69,7 @@ public:
 
     void stop_monitor(int oid, const std::string& host_xml)
     {
-        message_t msg;
+        monitor_msg_t msg;
         NebulaService& ns = Monitor::instance();
 
         msg.type(MonitorDriverMessages::STOP_MONITOR);
diff --git a/src/monitor/include/MonitorDriverMessages.h b/src/monitor/include/MonitorDriverMessages.h
index acfdb7653a..6471e301cd 100644
--- a/src/monitor/include/MonitorDriverMessages.h
+++ b/src/monitor/include/MonitorDriverMessages.h
@@ -17,8 +17,7 @@
 #ifndef MONITOR_DRIVER_MESSAGES_H_
 #define MONITOR_DRIVER_MESSAGES_H_
 
-#include "UDPStream.h"
-#include "TCPStream.h"
+#include <Message.h>
 
 /**
  * Messages between the Monitor daemon and drivers
@@ -39,4 +38,6 @@ enum class MonitorDriverMessages : unsigned short int
     ENUM_MAX
 };
 
+using monitor_msg_t = Message<MonitorDriverMessages, true, true, true, true>;
+
 #endif /*MONITOR_DRIVER_MESSAGES_H_*/
diff --git a/src/monitor/include/MonitorDriverProtocol.h b/src/monitor/include/MonitorDriverProtocol.h
index 0eadd215d4..149badcd32 100644
--- a/src/monitor/include/MonitorDriverProtocol.h
+++ b/src/monitor/include/MonitorDriverProtocol.h
@@ -18,29 +18,30 @@
 #define MONITOR_DRIVER_PROTOCOL_H_
 
 #include "MonitorDriverMessages.h"
+#include "Message.h"
+
+#include <memory>
 
 class HostMonitorManager;
 
 struct MonitorDriverProtocol
 {
 public:
-    using message_t = std::unique_ptr<Message<MonitorDriverMessages>>;
+    static void _undefined(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _undefined(message_t msg);
+    static void _monitor_vm(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _monitor_vm(message_t msg);
+    static void _beacon_host(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _beacon_host(message_t msg);
+    static void _monitor_host(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _monitor_host(message_t msg);
+    static void _system_host(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _system_host(message_t msg);
+    static void _state_vm(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _state_vm(message_t msg);
+    static void _start_monitor(std::unique_ptr<monitor_msg_t> msg);
 
-    static void _start_monitor(message_t msg);
-
-    static void _log(message_t msg);
+    static void _log(std::unique_ptr<monitor_msg_t> msg);
 
     static HostMonitorManager * hm;
 };
diff --git a/src/monitor/include/OneMonitorDriver.h b/src/monitor/include/OneMonitorDriver.h
index da3ce9baa9..d41d4317ad 100644
--- a/src/monitor/include/OneMonitorDriver.h
+++ b/src/monitor/include/OneMonitorDriver.h
@@ -18,14 +18,15 @@
 #define ONE_MONITOR_DRIVER_H_
 
 #include "OpenNebulaDriver.h"
-#include "OpenNebulaMessages.h"
+#include "ProtocolMessages.h"
 
 class HostMonitorManager;
 
 /**
  *  This class implements the Monitor Driver interface for oned.
  */
-class OneMonitorDriver : public OpenNebulaDriver<OpenNebulaMessages>
+class OneMonitorDriver :
+    public OpenNebulaDriver<im_msg_t>
 {
 public:
     OneMonitorDriver(HostMonitorManager * _hm);
@@ -53,42 +54,40 @@ public:
     void host_system_info(int oid, const std::string& status, const std::string& payload);
 
 private:
-    using message_t = std::unique_ptr<Message<OpenNebulaMessages>>;
-
     //--------------------------------------------------------------------------
     // Message callbacks, implements the driver protocol
     //--------------------------------------------------------------------------
-    static void _undefined(message_t msg);
+    static void _undefined(std::unique_ptr<im_msg_t> msg);
 
     /**
      *  List of all hosts in xml format
      */
-    static void _host_list(message_t msg);
+    static void _host_list(std::unique_ptr<im_msg_t> msg);
 
     /**
      *  Update information from a host
      */
-    static void _update_host(message_t msg);
+    static void _update_host(std::unique_ptr<im_msg_t> msg);
 
     /**
      *  Remove host from the pool
      */
-    static void _del_host(message_t msg);
+    static void _del_host(std::unique_ptr<im_msg_t> msg);
 
     /**
      *  Start the monitor agent/ or active monitor the host
      */
-    static void _start_monitor(message_t msg);
+    static void _start_monitor(std::unique_ptr<im_msg_t> msg);
 
     /**
      *  Stop the monitor agent/ or stop monitor the host
      */
-    static void _stop_monitor(message_t msg);
+    static void _stop_monitor(std::unique_ptr<im_msg_t> msg);
 
     /**
      *  Raft status changed
      */
-    static void _raft_status(message_t msg);
+    static void _raft_status(std::unique_ptr<im_msg_t> msg);
 
 private:
     static HostMonitorManager * hm;
diff --git a/src/monitor/include/OpenNebulaDriver.h b/src/monitor/include/OpenNebulaDriver.h
index a5ed8c887b..bcb0ad136e 100644
--- a/src/monitor/include/OpenNebulaDriver.h
+++ b/src/monitor/include/OpenNebulaDriver.h
@@ -21,7 +21,8 @@
 #include <string>
 #include <unistd.h>
 
-#include "OpenNebulaMessages.h"
+#include "Message.h"
+#include "StreamManager.h"
 #include "NebulaLog.h"
 
 /**
@@ -42,16 +43,16 @@
  *   Template parameter is a enumeration of protocol message types that
  *   MUST include UNDEFINED, INIT and FINALIZE message types.
  */
-template <typename E>
+template <typename MSG>
 class OpenNebulaDriver
 {
 public:
 
     OpenNebulaDriver() : oned_reader(0, &OpenNebulaDriver::_undefined)
     {
-        register_action(E::INIT, &OpenNebulaDriver::_init);
+        register_action(MSG::msg_enum::INIT, &OpenNebulaDriver::_init);
 
-        register_action(E::FINALIZE, &OpenNebulaDriver::_finalize);
+        register_action(MSG::msg_enum::FINALIZE, &OpenNebulaDriver::_finalize);
     }
 
     virtual ~OpenNebulaDriver() = default;
@@ -66,19 +67,20 @@ public:
     }
 
 protected:
-    using message_t = std::unique_ptr<Message<E>>;
+    using message_t = MSG;
 
     /**
      *  Streamer for stdin
      */
-    StreamManager<E> oned_reader;
+    StreamManager<MSG> oned_reader;
 
     /**
      *  Register an action when a message is received in the driver stream
      *    @param m the OpenNebulaMessage recevied
      *    @param f the message callback
      */
-    void register_action(E m, std::function<void(message_t)> f)
+    void register_action(typename MSG::msg_enum m,
+                         std::function<void(std::unique_ptr<message_t>)> f)
     {
         oned_reader.register_action(m, f);
     }
@@ -86,7 +88,7 @@ protected:
     /**
      * Process INIT message from oned, send SUCCESS response
      */
-    static void _init(message_t msg)
+    static void _init(std::unique_ptr<message_t> msg)
     {
         write2one("INIT SUCCESS\n");
     }
@@ -95,7 +97,7 @@ protected:
      * Process FINALIZE message from oned, send SUCCESS response,
      * terminate execution loop
      */
-    static void _finalize(message_t msg)
+    static void _finalize(std::unique_ptr<message_t> msg)
     {
         write2one("FINALIZE SUCCESS\n");
 
@@ -105,7 +107,7 @@ protected:
     /**
      * Default action for undefined messages
      */
-    static void _undefined(message_t msg)
+    static void _undefined(std::unique_ptr<message_t> msg)
     {
         NebulaLog::warn("MON", "Undefined message: " + msg->payload());
     }
@@ -121,9 +123,9 @@ protected:
     /**
      * Write an OpenNebulaMessage to oned (stdout)
      */
-    static void write2one(const Message<E>& msg)
+    static void write2one(const message_t& msg)
     {
-        msg.write_to(1, false);
+        msg.write_to(1);
     }
 };
 
diff --git a/src/monitor/include/ProtocolMessages.h b/src/monitor/include/ProtocolMessages.h
new file mode 100644
index 0000000000..905da9a2ae
--- /dev/null
+++ b/src/monitor/include/ProtocolMessages.h
@@ -0,0 +1,196 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#ifndef PROTOCOL_MESSAGES_H
+#define PROTOCOL_MESSAGES_H
+
+#include "Message.h"
+
+/**
+ * Messages between the Monitor daemon and OpenNebula daemon
+ */
+enum class InformationManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    HOST_LIST,
+    UPDATE_HOST,
+    DEL_HOST,
+    START_MONITOR,
+    STOP_MONITOR,
+    HOST_STATE,
+    VM_STATE,
+    HOST_SYSTEM,
+    RAFT_STATUS,
+    ENUM_MAX
+};
+
+using im_msg_t = Message<InformationManagerMessages, true, true, false, false>;
+
+
+/**
+ * Image Manager Driver messages
+ */
+enum class ImageManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    CP,
+    CLONE,
+    STAT,
+    MKFS,
+    RM,
+    MONITOR,
+    SNAP_DELETE,
+    SNAP_REVERT,
+    SNAP_FLATTEN,
+    LOG,
+    ENUM_MAX
+};
+
+using image_msg_t = Message<ImageManagerMessages, false, false, false, false>;
+
+
+/**
+ * Auth Manager Driver messages
+ */
+enum class AuthManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    AUTHORIZE,
+    AUTHENTICATE,
+    LOG,
+    ENUM_MAX
+};
+
+using auth_msg_t = Message<AuthManagerMessages, false, false, false, false>;
+
+
+/**
+ * IPAM Manager Driver messages
+ */
+enum class IPAMManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    REGISTER_ADDRESS_RANGE,
+    UNREGISTER_ADDRESS_RANGE,
+    GET_ADDRESS,
+    ALLOCATE_ADDRESS,
+    FREE_ADDRESS,
+    LOG,
+    ENUM_MAX
+};
+
+using ipam_msg_t = Message<IPAMManagerMessages, false, false, false, false>;
+
+
+/**
+ * MarketPlace Manager Driver messages
+ */
+enum class MarketPlaceManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    IMPORT,
+    DELETE,
+    MONITOR,
+    LOG,
+    ENUM_MAX
+};
+
+using market_msg_t = Message<MarketPlaceManagerMessages, false, false, false, false>;
+
+
+/**
+ * Transfer Manager Driver messages
+ */
+enum class TransferManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    TRANSFER,
+    DRIVER_CANCEL,
+    LOG,
+    ENUM_MAX
+};
+
+using transfer_msg_t = Message<TransferManagerMessages, false, false, false, false>;
+
+
+/**
+ * Virtual Machine Driver messages
+ */
+enum class VMManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    DEPLOY,
+    SHUTDOWN,
+    RESET,
+    REBOOT,
+    CANCEL,
+    CLEANUP,
+    CHECKPOINT,
+    SAVE,
+    RESTORE,
+    MIGRATE,
+    ATTACHDISK,
+    DETACHDISK,
+    ATTACHNIC,
+    DETACHNIC,
+    SNAPSHOTCREATE,
+    SNAPSHOTREVERT,
+    SNAPSHOTDELETE,
+    DISKSNAPSHOTCREATE,
+    DISKSNAPSHOTREVERT,
+    RESIZEDISK,
+    UPDATECONF,
+    UPDATESG,
+    DRIVER_CANCEL,
+    LOG,
+    ENUM_MAX
+};
+
+using vm_msg_t = Message<VMManagerMessages, false, false, false, false>;
+
+
+/**
+ * Virtual Machine Driver messages
+ */
+enum class HookManagerMessages : unsigned short int
+{
+    UNDEFINED = 0,
+    INIT,
+    FINALIZE,
+    EXECUTE,
+    RETRY,
+    LOG,
+    ENUM_MAX
+};
+
+using hook_msg_t = Message<HookManagerMessages, false, false, false, false>;
+
+
+#endif /*PROTOCOL_MESSAGES_H*/
diff --git a/src/monitor/include/StreamManager.h b/src/monitor/include/StreamManager.h
index ae54a99257..4d9fcabcdd 100644
--- a/src/monitor/include/StreamManager.h
+++ b/src/monitor/include/StreamManager.h
@@ -39,11 +39,11 @@
  *  thread reads from the stream for input messages and executed the associated
  *  action in a separated (detached) thread.
  */
-template <typename E>
+template <typename MSG>
 class StreamManager
 {
 public:
-    using callback_t = std::function<void(std::unique_ptr<Message<E>>)>;
+    using callback_t = std::function<void(std::unique_ptr<MSG>)>;
 
     /* ---------------------------------------------------------------------- */
     /* ---------------------------------------------------------------------- */
@@ -53,12 +53,12 @@ public:
      */
     StreamManager(int __fd, callback_t error_cbk):_fd(__fd)
     {
-        register_action(E::UNDEFINED, error_cbk);
+        register_action(MSG::msg_enum::UNDEFINED, error_cbk);
     };
 
     StreamManager(callback_t error_cbk):StreamManager(-1, error_cbk){};
 
-    StreamManager():StreamManager(-1, [](std::unique_ptr<Message<E> > m){}){};
+    StreamManager():StreamManager(-1, [](std::unique_ptr<MSG> m){}){};
 
     ~StreamManager()
     {
@@ -71,7 +71,7 @@ public:
      *   @param t the message type
      *   @param a callback function to be executed
      */
-    void register_action(E t, callback_t a);
+    void register_action(typename MSG::msg_enum t, callback_t a);
 
     /**
      *  Reads messages from the stream and execute callbacks. This method should
@@ -94,7 +94,7 @@ public:
      *  Look for the associated callback for the message and execute it
      *    @param msg read from the stream
      */
-    void do_action(std::unique_ptr<Message<E> >& msg, bool threaded);
+    void do_action(std::unique_ptr<MSG>& msg, bool threaded);
 
 protected:
     /**
@@ -115,7 +115,7 @@ private:
 
     int _concurrency;
 
-    std::map<E, callback_t > actions;
+    std::map<typename MSG::msg_enum, callback_t > actions;
 
     StringBuffer buffer;
 };
@@ -126,8 +126,9 @@ private:
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-void StreamManager<E>::register_action(E t, callback_t a)
+template<typename MSG>
+void StreamManager<MSG>
+    ::register_action(typename MSG::msg_enum t, callback_t a)
 {
     auto ret = actions.insert({t, a});
 
@@ -140,8 +141,9 @@ void StreamManager<E>::register_action(E t, callback_t a)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-void StreamManager<E>::do_action(std::unique_ptr<Message<E> >& msg, bool thr)
+template<typename MSG>
+void StreamManager<MSG>
+    ::do_action(std::unique_ptr<MSG>& msg, bool thr)
 {
     const auto it = actions.find(msg->type());
 
@@ -151,7 +153,7 @@ void StreamManager<E>::do_action(std::unique_ptr<Message<E> >& msg, bool thr)
     }
 
     const auto action = it->second;
-    Message<E> * mptr = msg.release();
+    MSG * mptr = msg.release();
 
     if (thr)
     {
@@ -167,7 +169,7 @@ void StreamManager<E>::do_action(std::unique_ptr<Message<E> >& msg, bool thr)
         lock.unlock();
 
         std::thread action_thread([this, action, mptr]{
-            action(std::unique_ptr<Message<E>>{mptr});
+            action(std::unique_ptr<MSG>{mptr});
 
             std::unique_lock<std::mutex> lock(_mutex);
 
@@ -182,15 +184,16 @@ void StreamManager<E>::do_action(std::unique_ptr<Message<E> >& msg, bool thr)
     }
     else
     {
-        action(std::unique_ptr<Message<E>>{mptr});
+        action(std::unique_ptr<MSG>{mptr});
     }
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-template<typename E>
-int StreamManager<E>::action_loop(int concurrency)
+template<typename MSG>
+int StreamManager<MSG>
+    ::action_loop(int concurrency)
 {
     bool threaded = concurrency > 0;
     _concurrency  = concurrency;
@@ -209,9 +212,9 @@ int StreamManager<E>::action_loop(int concurrency)
             continue;
         }
 
-        std::unique_ptr<Message<E>> msg{new Message<E>};
+        std::unique_ptr<MSG> msg{new MSG};
 
-        msg->parse_from(line, false);
+        msg->parse_from(line);
 
         do_action(msg, threaded); //Errors are handled by the UNDEFINED action
     }
diff --git a/src/monitor/include/TCPMonitorDriver.h b/src/monitor/include/TCPMonitorDriver.h
index f84b679ccf..a1aebf6f68 100644
--- a/src/monitor/include/TCPMonitorDriver.h
+++ b/src/monitor/include/TCPMonitorDriver.h
@@ -19,13 +19,14 @@
 
 #include "MonitorDriverMessages.h"
 #include "MonitorDriverProtocol.h"
+#include "TCPStream.h"
 
-class TCPMonitorDriver : public TCPStream<MonitorDriverMessages>
+class TCPMonitorDriver : public TCPStream<monitor_msg_t>
 {
 public:
 
     TCPMonitorDriver(const std::string& a, unsigned int p)
-        :TCPStream<MonitorDriverMessages>(a, p)
+        :TCPStream(a, p)
     {
         register_action(MonitorDriverMessages::UNDEFINED,
                 &MonitorDriverProtocol::_undefined);
diff --git a/src/monitor/include/TCPStream.h b/src/monitor/include/TCPStream.h
index 374f373d38..1ea4d302c2 100644
--- a/src/monitor/include/TCPStream.h
+++ b/src/monitor/include/TCPStream.h
@@ -35,14 +35,17 @@
 /**
  *
  */
-template<typename E>
-class TCPStream : public StreamManager<E>
+template<typename MSG>
+class TCPStream : public StreamManager<MSG>
 {
 public:
-    using callback_t = std::function<void(std::unique_ptr<Message<E>>)>;
+    using callback_t = std::function<void(std::unique_ptr<MSG>)>;
 
     TCPStream(const std::string &address, unsigned int port, callback_t error):
-        StreamManager<E>(error), _socket(-1), _address(address), _port(port)
+        StreamManager<MSG>(error),
+        _socket(-1),
+        _address(address),
+        _port(port)
     {
     }
 
@@ -98,8 +101,9 @@ private:
 /* UDPStream Implementation                                                   */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
-template<typename E>
-int TCPStream<E>::action_loop(int threads, std::string& error)
+template<typename MSG>
+int TCPStream<MSG>
+    ::action_loop(int threads, std::string& error)
 {
     struct addrinfo hints;
     struct addrinfo *res;
@@ -157,7 +161,7 @@ int TCPStream<E>::action_loop(int threads, std::string& error)
         return -1;
     }
 
-    StreamManager<E>::fd(_socket);
+    this->fd(_socket);
 
     /* ---------------------------------------------------------------------- */
     /* Start a pool of threads to read incoming TCP driver messages           */
@@ -179,11 +183,11 @@ int TCPStream<E>::action_loop(int threads, std::string& error)
                     continue;
                 }
 
-                std::unique_ptr<Message<E>> msg{new Message<E>};
+                std::unique_ptr<MSG> msg{new MSG};
 
-                msg->parse_from(line, true);
+                msg->parse_from(line);
 
-                StreamManager<E>::do_action(msg, false);
+                this->do_action(msg, false);
             }
         });
 
@@ -197,8 +201,9 @@ int TCPStream<E>::action_loop(int threads, std::string& error)
 /* -------------------------------------------------------------------------- */
 #define BUFFER_SIZE 65536
 
-template<typename E>
-int TCPStream<E>::read_line(std::string& line)
+template<typename MSG>
+int TCPStream<MSG>
+    ::read_line(std::string& line)
 {
     char buffer[BUFFER_SIZE];
 
diff --git a/src/monitor/include/UDPMonitorDriver.h b/src/monitor/include/UDPMonitorDriver.h
index 698c1a8fa4..fa2c55d396 100644
--- a/src/monitor/include/UDPMonitorDriver.h
+++ b/src/monitor/include/UDPMonitorDriver.h
@@ -19,13 +19,14 @@
 
 #include "MonitorDriverMessages.h"
 #include "MonitorDriverProtocol.h"
+#include "UDPStream.h"
 
-class UDPMonitorDriver : public UDPStream<MonitorDriverMessages>
+class UDPMonitorDriver : public UDPStream<monitor_msg_t>
 {
 public:
 
     UDPMonitorDriver(const std::string& a, unsigned int p)
-        :UDPStream<MonitorDriverMessages>(a, p)
+        :UDPStream(a, p)
     {
         register_action(MonitorDriverMessages::UNDEFINED,
                 &MonitorDriverProtocol::_undefined);
diff --git a/src/monitor/include/UDPStream.h b/src/monitor/include/UDPStream.h
index e78bd530da..6ebcec964a 100644
--- a/src/monitor/include/UDPStream.h
+++ b/src/monitor/include/UDPStream.h
@@ -35,14 +35,17 @@
 /**
  *
  */
-template<typename E>
-class UDPStream : public StreamManager<E>
+template<typename MSG>
+class UDPStream : public StreamManager<MSG>
 {
 public:
-    using callback_t = std::function<void(std::unique_ptr<Message<E>>)>;
+    using callback_t = std::function<void(std::unique_ptr<MSG>)>;
 
     UDPStream(const std::string &address, unsigned int port, callback_t error):
-        StreamManager<E>(error), _socket(-1), _address(address), _port(port)
+        StreamManager<MSG>(error),
+        _socket(-1),
+        _address(address),
+        _port(port)
     {
     }
 
@@ -98,8 +101,9 @@ private:
 /* UDPStream Implementation                                                   */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
-template<typename E>
-int UDPStream<E>::action_loop(int threads, std::string& error)
+template<typename MSG>
+int UDPStream<MSG>
+    ::action_loop(int threads, std::string& error)
 {
     struct addrinfo hints;
     struct addrinfo *res;
@@ -138,7 +142,7 @@ int UDPStream<E>::action_loop(int threads, std::string& error)
         return -1;
     }
 
-    StreamManager<E>::fd(_socket);
+    this->fd(_socket);
 
     /* ---------------------------------------------------------------------- */
     /* Start a pool of threads to read incoming UDP driver messages           */
@@ -161,11 +165,11 @@ int UDPStream<E>::action_loop(int threads, std::string& error)
                     continue;
                 }
 
-                std::unique_ptr<Message<E>> msg{new Message<E>};
+                std::unique_ptr<MSG> msg{new MSG};
 
-                msg->parse_from(line, true);
+                msg->parse_from(line);
 
-                StreamManager<E>::do_action(msg, false);
+                this->do_action(msg, false);
             }
         });
 
@@ -179,8 +183,9 @@ int UDPStream<E>::action_loop(int threads, std::string& error)
 /* -------------------------------------------------------------------------- */
 #define MESSAGE_SIZE 65536
 
-template<typename E>
-int UDPStream<E>::read_line(std::string& line)
+template<typename MSG>
+int UDPStream<MSG>
+    ::read_line(std::string& line)
 {
     char   buffer[MESSAGE_SIZE];
 
diff --git a/src/monitor/src/monitor/HostMonitorManager.cc b/src/monitor/src/monitor/HostMonitorManager.cc
index 83cf084fcb..c05fb6419c 100644
--- a/src/monitor/src/monitor/HostMonitorManager.cc
+++ b/src/monitor/src/monitor/HostMonitorManager.cc
@@ -58,6 +58,9 @@ HostMonitorManager::HostMonitorManager(
     driver_manager = new driver_manager_t(driver_path);
 };
 
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
 HostMonitorManager::~HostMonitorManager()
 {
     delete oned_driver;
@@ -75,6 +78,9 @@ int HostMonitorManager::load_monitor_drivers(
     return driver_manager->load_drivers(mads_config);
 }
 
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
 int HostMonitorManager::start(std::string& error)
 {
     condition_variable end_cv;
diff --git a/src/monitor/src/monitor/Monitor.cc b/src/monitor/src/monitor/Monitor.cc
index 597187cf82..d819eb4864 100644
--- a/src/monitor/src/monitor/Monitor.cc
+++ b/src/monitor/src/monitor/Monitor.cc
@@ -189,7 +189,7 @@ void Monitor::start()
     config->get("MANAGER_TIMER", timer_period);
     config->get("MONITORING_INTERVAL_HOST", monitor_interval_host);
 
-    init_rsa_keys(pub_key, pri_key);
+    ssl_util::init_rsa_keys(pub_key, pri_key);
 
     // Replace the PUBKEY with the content of the PUBKEY file
     ifstream f(pub_key);
diff --git a/src/monitor/src/monitor/MonitorDriverProtocol.cc b/src/monitor/src/monitor/MonitorDriverProtocol.cc
index 314491218f..e8fe21c76f 100644
--- a/src/monitor/src/monitor/MonitorDriverProtocol.cc
+++ b/src/monitor/src/monitor/MonitorDriverProtocol.cc
@@ -19,22 +19,24 @@
 #include "NebulaLog.h"
 #include "HostMonitorManager.h"
 #include "OneMonitorDriver.h"
-
 #include "MonitorDriverMessages.h"
+#include "SSLUtil.h"
 
 #include <iomanip>
 
+using namespace std;
+
 HostMonitorManager * MonitorDriverProtocol::hm = nullptr;
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_undefined(message_t msg)
+void MonitorDriverProtocol::_undefined(unique_ptr<monitor_msg_t> msg)
 {
     NebulaLog::info("MDP", "Received UNDEFINED msg: " + msg->payload());
 }
 
-static void log_message(const std::unique_ptr<Message<MonitorDriverMessages>>& msg)
+static void log_message(const monitor_msg_t& msg)
 {
     if ( NebulaLog::log_level() < Log::DDEBUG )
     {
@@ -44,13 +46,13 @@ static void log_message(const std::unique_ptr<Message<MonitorDriverMessages>>& m
     ostringstream oss;
 
     struct tm tms;
-    time_t    ts = msg->timestamp();
+    time_t    ts = msg.timestamp();
 
     localtime_r(&ts, &tms);
 
     oss << "[" << tms.tm_hour << ":" << tms.tm_min << ":" << tms.tm_sec
-        << "] Recieved " << msg->type_str() << " message from host "
-        << msg->oid() << ":\n" << msg->payload();
+        << "] Recieved " << msg.type_str() << " message from host "
+        << msg.oid() << ":\n" << msg.payload();
 
     NebulaLog::ddebug("MDP", oss.str());
 }
@@ -58,9 +60,9 @@ static void log_message(const std::unique_ptr<Message<MonitorDriverMessages>>& m
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_monitor_vm(message_t msg)
+void MonitorDriverProtocol::_monitor_vm(unique_ptr<monitor_msg_t> msg)
 {
-    log_message(msg);
+    log_message(*msg);
 
     if (msg->status() != "SUCCESS")
     {
@@ -155,7 +157,7 @@ void MonitorDriverProtocol::_monitor_vm(message_t msg)
 
             if (it == vms_templ.end())
             {
-                vms_templ[id] = std::move(mon_tmpl);
+                vms_templ[id] = move(mon_tmpl);
             }
             else
             {
@@ -174,9 +176,9 @@ void MonitorDriverProtocol::_monitor_vm(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_beacon_host(message_t msg)
+void MonitorDriverProtocol::_beacon_host(unique_ptr<monitor_msg_t> msg)
 {
-    log_message(msg);
+    log_message(*msg);
 
     if (msg->status() != "SUCCESS")
     {
@@ -196,9 +198,9 @@ void MonitorDriverProtocol::_beacon_host(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_monitor_host(message_t msg)
+void MonitorDriverProtocol::_monitor_host(unique_ptr<monitor_msg_t> msg)
 {
-    log_message(msg);
+    log_message(*msg);
 
     if (msg->status() != "SUCCESS")
     {
@@ -241,9 +243,9 @@ void MonitorDriverProtocol::_monitor_host(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_system_host(message_t msg)
+void MonitorDriverProtocol::_system_host(unique_ptr<monitor_msg_t> msg)
 {
-    log_message(msg);
+    log_message(*msg);
 
     if (msg->status() != "SUCCESS")
     {
@@ -267,9 +269,9 @@ void MonitorDriverProtocol::_system_host(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_state_vm(message_t msg)
+void MonitorDriverProtocol::_state_vm(unique_ptr<monitor_msg_t> msg)
 {
-    log_message(msg);
+    log_message(*msg);
 
     if (msg->status() != "SUCCESS")
     {
@@ -303,9 +305,9 @@ void MonitorDriverProtocol::_state_vm(message_t msg)
  * It includes all messages that may be sent by probes, defined in
  * MonitorDriverMessages. This message is constructed in monitord_client.rb
  */
-void MonitorDriverProtocol::_start_monitor(message_t msg)
+void MonitorDriverProtocol::_start_monitor(unique_ptr<monitor_msg_t> msg)
 {
-    log_message(msg);
+    log_message(*msg);
 
     if (msg->status() != "SUCCESS")
     {
@@ -340,7 +342,7 @@ void MonitorDriverProtocol::_start_monitor(message_t msg)
 
     msg_xml.xpath(ts, "/MONITOR_MESSAGES/TIMESTAMP", static_cast<time_t>(0));
 
-    const std::vector<MonitorDriverMessages> stypes = {
+    const vector<MonitorDriverMessages> stypes = {
         MonitorDriverMessages::MONITOR_VM,
         MonitorDriverMessages::BEACON_HOST,
         MonitorDriverMessages::MONITOR_HOST,
@@ -350,19 +352,19 @@ void MonitorDriverProtocol::_start_monitor(message_t msg)
 
     for (const auto& it : stypes)
     {
-        std::string payload64, payload;
+        string payload64, payload;
 
-        std::string xpath = "/MONITOR_MESSAGES/" +
-            Message<MonitorDriverMessages>::type_str(it);
+        string xpath = "/MONITOR_MESSAGES/" +
+             monitor_msg_t::type_str(it);
 
         if ( msg_xml.xpath(payload64, xpath.c_str(), "") != 0 )
         {
             continue;
         }
 
-        base64_decode(payload64, payload);
+        ssl_util::base64_decode(payload64, payload);
 
-        message_t m(new Message<MonitorDriverMessages>);
+        unique_ptr<monitor_msg_t> m(new monitor_msg_t);
 
         m->type(it);
 
@@ -377,13 +379,13 @@ void MonitorDriverProtocol::_start_monitor(message_t msg)
         switch(it)
         {
             case MonitorDriverMessages::MONITOR_VM:
-                _monitor_vm(std::move(m));
+                _monitor_vm(move(m));
                 break;
             case MonitorDriverMessages::BEACON_HOST:
-                _beacon_host(std::move(m));
+                _beacon_host(move(m));
                 break;
             case MonitorDriverMessages::MONITOR_HOST:
-                _monitor_host(std::move(m));
+                _monitor_host(move(m));
                 break;
             case MonitorDriverMessages::SYSTEM_HOST:
                 _system_host(move(m));
@@ -402,7 +404,7 @@ void MonitorDriverProtocol::_start_monitor(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void MonitorDriverProtocol::_log(message_t msg)
+void MonitorDriverProtocol::_log(unique_ptr<monitor_msg_t> msg)
 {
     auto log_type = Log::INFO;
 
diff --git a/src/monitor/src/monitor/OneMonitorDriver.cc b/src/monitor/src/monitor/OneMonitorDriver.cc
index 6ead71a72d..3147adf070 100644
--- a/src/monitor/src/monitor/OneMonitorDriver.cc
+++ b/src/monitor/src/monitor/OneMonitorDriver.cc
@@ -25,25 +25,25 @@ OneMonitorDriver::OneMonitorDriver(HostMonitorManager * _hm)
 {
     hm = _hm;
 
-    register_action(OpenNebulaMessages::UNDEFINED,
+    register_action(InformationManagerMessages::UNDEFINED,
             &OneMonitorDriver::_undefined);
 
-    register_action(OpenNebulaMessages::HOST_LIST,
+    register_action(InformationManagerMessages::HOST_LIST,
             &OneMonitorDriver::_host_list);
 
-    register_action(OpenNebulaMessages::UPDATE_HOST,
+    register_action(InformationManagerMessages::UPDATE_HOST,
             &OneMonitorDriver::_update_host);
 
-    register_action(OpenNebulaMessages::DEL_HOST,
+    register_action(InformationManagerMessages::DEL_HOST,
             &OneMonitorDriver::_del_host);
 
-    register_action(OpenNebulaMessages::START_MONITOR,
+    register_action(InformationManagerMessages::START_MONITOR,
             &OneMonitorDriver::_start_monitor);
 
-    register_action(OpenNebulaMessages::STOP_MONITOR,
+    register_action(InformationManagerMessages::STOP_MONITOR,
             &OneMonitorDriver::_stop_monitor);
 
-    register_action(OpenNebulaMessages::RAFT_STATUS,
+    register_action(InformationManagerMessages::RAFT_STATUS,
             &OneMonitorDriver::_raft_status);
 }
 
@@ -52,9 +52,9 @@ OneMonitorDriver::OneMonitorDriver(HostMonitorManager * _hm)
 
 void OneMonitorDriver::host_state(int oid, const std::string& state)
 {
-    Message<OpenNebulaMessages> oned_msg;
+    im_msg_t oned_msg;
 
-    oned_msg.type(OpenNebulaMessages::HOST_STATE);
+    oned_msg.type(InformationManagerMessages::HOST_STATE);
     oned_msg.oid(oid);
     oned_msg.payload(state);
 
@@ -66,9 +66,9 @@ void OneMonitorDriver::host_state(int oid, const std::string& state)
 
 void OneMonitorDriver::vm_state(int oid, const std::string& state)
 {
-    Message<OpenNebulaMessages> oned_msg;
+    im_msg_t oned_msg;
 
-    oned_msg.type(OpenNebulaMessages::VM_STATE);
+    oned_msg.type(InformationManagerMessages::VM_STATE);
     oned_msg.oid(oid);
     oned_msg.payload(state);
 
@@ -81,9 +81,9 @@ void OneMonitorDriver::vm_state(int oid, const std::string& state)
 void OneMonitorDriver::host_system_info(int oid, const std::string& status,
         const std::string& payload)
 {
-    Message<OpenNebulaMessages> oned_msg;
+    im_msg_t oned_msg;
 
-    oned_msg.type(OpenNebulaMessages::HOST_SYSTEM);
+    oned_msg.type(InformationManagerMessages::HOST_SYSTEM);
     oned_msg.oid(oid);
     oned_msg.status(status);
     oned_msg.payload(payload);
@@ -94,7 +94,7 @@ void OneMonitorDriver::host_system_info(int oid, const std::string& status,
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_undefined(message_t msg)
+void OneMonitorDriver::_undefined(std::unique_ptr<im_msg_t> msg)
 {
     NebulaLog::info("MDR", "Received UNDEFINED msg: " + msg->payload());
 }
@@ -102,7 +102,7 @@ void OneMonitorDriver::_undefined(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_host_list(message_t msg)
+void OneMonitorDriver::_host_list(std::unique_ptr<im_msg_t> msg)
 {
     ObjectXML xml(msg->payload());
 
@@ -128,7 +128,7 @@ void OneMonitorDriver::_host_list(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_update_host(message_t msg)
+void OneMonitorDriver::_update_host(std::unique_ptr<im_msg_t> msg)
 {
     hm->update_host(msg->oid(), msg->payload());
 }
@@ -136,7 +136,7 @@ void OneMonitorDriver::_update_host(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_del_host(message_t msg)
+void OneMonitorDriver::_del_host(std::unique_ptr<im_msg_t> msg)
 {
     hm->delete_host(msg->oid());
 }
@@ -144,7 +144,7 @@ void OneMonitorDriver::_del_host(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_start_monitor(message_t msg)
+void OneMonitorDriver::_start_monitor(std::unique_ptr<im_msg_t> msg)
 {
     hm->start_host_monitor(msg->oid());
 }
@@ -152,7 +152,7 @@ void OneMonitorDriver::_start_monitor(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_stop_monitor(message_t msg)
+void OneMonitorDriver::_stop_monitor(std::unique_ptr<im_msg_t> msg)
 {
     hm->stop_host_monitor(msg->oid());
 }
@@ -160,7 +160,7 @@ void OneMonitorDriver::_stop_monitor(message_t msg)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-void OneMonitorDriver::_raft_status(message_t msg)
+void OneMonitorDriver::_raft_status(std::unique_ptr<im_msg_t> msg)
 {
     hm->raft_status(msg->payload());
 }
diff --git a/src/monitor/src/protocol/Message.cc b/src/monitor/src/protocol/Message.cc
index 3c85f43f92..dc663be73b 100644
--- a/src/monitor/src/protocol/Message.cc
+++ b/src/monitor/src/protocol/Message.cc
@@ -14,19 +14,12 @@
 /* limitations under the License.                                             */
 /* -------------------------------------------------------------------------- */
 
-#include <openssl/bio.h>
-#include <openssl/evp.h>
-#include <openssl/rsa.h>
-#include <openssl/pem.h>
-
-#include <zlib.h>
-
 #include "Message.h"
 #include "MonitorDriverMessages.h"
-#include "OpenNebulaMessages.h"
+#include "ProtocolMessages.h"
 
 template<>
-const EString<MonitorDriverMessages> Message<MonitorDriverMessages>::_type_str({
+const EString<MonitorDriverMessages> monitor_msg_t::_type_str({
     {"UNDEFINED", MonitorDriverMessages::UNDEFINED},
     {"INIT", MonitorDriverMessages::INIT},
     {"FINALIZE", MonitorDriverMessages::FINALIZE},
@@ -41,322 +34,119 @@ const EString<MonitorDriverMessages> Message<MonitorDriverMessages>::_type_str({
 });
 
 template<>
-const EString<OpenNebulaMessages> Message<OpenNebulaMessages>::_type_str({
-    {"UNDEFINED", OpenNebulaMessages::UNDEFINED},
-    {"INIT", OpenNebulaMessages::INIT},
-    {"FINALIZE", OpenNebulaMessages::FINALIZE},
-    {"HOST_LIST", OpenNebulaMessages::HOST_LIST},
-    {"UPDATE_HOST", OpenNebulaMessages::UPDATE_HOST},
-    {"DEL_HOST", OpenNebulaMessages::DEL_HOST},
-    {"START_MONITOR", OpenNebulaMessages::START_MONITOR},
-    {"STOP_MONITOR", OpenNebulaMessages::STOP_MONITOR},
-    {"HOST_STATE", OpenNebulaMessages::HOST_STATE},
-    {"VM_STATE", OpenNebulaMessages::VM_STATE},
-    {"HOST_SYSTEM", OpenNebulaMessages::HOST_SYSTEM},
-    {"RAFT_STATUS", OpenNebulaMessages::RAFT_STATUS},
+const EString<InformationManagerMessages> im_msg_t::_type_str({
+    {"UNDEFINED", InformationManagerMessages::UNDEFINED},
+    {"INIT", InformationManagerMessages::INIT},
+    {"FINALIZE", InformationManagerMessages::FINALIZE},
+    {"HOST_LIST", InformationManagerMessages::HOST_LIST},
+    {"UPDATE_HOST", InformationManagerMessages::UPDATE_HOST},
+    {"DEL_HOST", InformationManagerMessages::DEL_HOST},
+    {"START_MONITOR", InformationManagerMessages::START_MONITOR},
+    {"STOP_MONITOR", InformationManagerMessages::STOP_MONITOR},
+    {"HOST_STATE", InformationManagerMessages::HOST_STATE},
+    {"VM_STATE", InformationManagerMessages::VM_STATE},
+    {"HOST_SYSTEM", InformationManagerMessages::HOST_SYSTEM},
+    {"RAFT_STATUS", InformationManagerMessages::RAFT_STATUS},
 });
 
-/* ************************************************************************** */
-/* ************************************************************************** */
-/* Message helper functions                                                   */
-/* ************************************************************************** */
-/* ************************************************************************** */
-
-void base64_decode(const std::string& in, std::string& out)
-{
-    BIO * bio_64  = BIO_new(BIO_f_base64());
-
-    BIO * bio_mem_in  = BIO_new(BIO_s_mem());
-    BIO * bio_mem_out = BIO_new(BIO_s_mem());
-
-    bio_64 = BIO_push(bio_64, bio_mem_in);
-
-    BIO_set_flags(bio_64, BIO_FLAGS_BASE64_NO_NL);
-
-    BIO_write(bio_mem_in, in.c_str(), in.length());
-
-    char inbuf[512];
-    int  inlen;
-
-    while ((inlen = BIO_read(bio_64, inbuf, 512)) > 0)
-    {
-        BIO_write(bio_mem_out, inbuf, inlen);
-    }
-
-    char * decoded_c;
-
-    long int size = BIO_get_mem_data(bio_mem_out, &decoded_c);
-
-    out.assign(decoded_c, size);
-
-    BIO_free_all(bio_64);
-    BIO_free_all(bio_mem_out);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int base64_encode(const std::string& in, std::string &out)
-{
-    BIO * bio_64  = BIO_new(BIO_f_base64());
-    BIO * bio_mem = BIO_new(BIO_s_mem());
-
-    BIO_push(bio_64, bio_mem);
-
-    BIO_set_flags(bio_64, BIO_FLAGS_BASE64_NO_NL);
-
-    BIO_write(bio_64, in.c_str(), in.length());
-
-    if (BIO_flush(bio_64) != 1)
-    {
-        return -1;
-    }
-
-    char * encoded_c;
-
-    long int size = BIO_get_mem_data(bio_mem, &encoded_c);
-
-    out.assign(encoded_c, size);
-
-    BIO_free_all(bio_64);
-
-    return 0;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-/**
- *  Buffer length for zlib inflate/deflate
- */
-#define ZBUFFER 16384
-
-int zlib_decompress(const std::string& in, std::string& out)
-{
-    if ( in.empty() )
-    {
-        return -1;
-    }
-
-    z_stream zs;
-
-    zs.zalloc = Z_NULL;
-    zs.zfree  = Z_NULL;
-    zs.opaque = Z_NULL;
-
-    zs.avail_in = 0;
-    zs.next_in  = Z_NULL;
-
-    if ( inflateInit(&zs) != Z_OK)
-    {
-        return -1;
-    }
-
-    zs.avail_in = in.size();
-    zs.next_in  = (unsigned char *) const_cast<char *>(in.c_str());
-
-    if ( zs.avail_in <= 2 ) //At least 2 byte header
-    {
-        inflateEnd(&zs);
-
-        return -1;
-    }
-
-    unsigned char zbuf[ZBUFFER];
-    std::string result;
-    int rc;
-
-    do
-    {
-        zs.avail_out = ZBUFFER;
-        zs.next_out  = zbuf;
-
-        rc = inflate(&zs, Z_FINISH);
-
-        if ( rc != Z_STREAM_END && rc != Z_OK && rc != Z_BUF_ERROR )
-        {
-            inflateEnd(&zs);
-
-            return -1;
-        }
-
-        result.append((const char *) zbuf, (size_t) (ZBUFFER - zs.avail_out));
-    } while (rc != Z_STREAM_END);
-
-    inflateEnd(&zs);
-
-    out = result;
-
-    return 0;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int zlib_compress(const std::string& in, std::string& out)
-{
-    if ( in.empty() )
-    {
-        return -1;
-    }
-
-    z_stream zs;
-
-    zs.zalloc = Z_NULL;
-    zs.zfree  = Z_NULL;
-    zs.opaque = Z_NULL;
-
-    if ( deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK )
-    {
-        return -1;
-    }
-
-    zs.avail_in = in.size();
-    zs.next_in  = (unsigned char *) const_cast<char *>(in.c_str());
-
-    unsigned char zbuf[ZBUFFER];
-    std::string result;
-
-    do
-    {
-        zs.avail_out = ZBUFFER;
-        zs.next_out  = zbuf;
-
-        if ( deflate(&zs, Z_FINISH) == Z_STREAM_ERROR )
-        {
-            deflateEnd(&zs);
-            return -1;
-        }
-
-        result.append((const char *) zbuf, (size_t) (ZBUFFER - zs.avail_out));
-    } while (zs.avail_out == 0);
-
-    deflateEnd(&zs);
-
-    out = result;
-
-    return 0;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-static std::string pubk_path;
-static std::string prik_path;
-
-void init_rsa_keys(const std::string& pub_key, const std::string& pri_key)
-{
-    pubk_path = pub_key;
-    prik_path = pri_key;
-}
-
-bool is_rsa_set()
-{
-    return !prik_path.empty();
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int rsa_public_encrypt(const std::string& in, std::string& out)
-{
-    static RSA * rsa = nullptr;
-
-    if ( rsa == nullptr) //initialize RSA structure
-    {
-        FILE * fp = fopen(pubk_path.c_str(), "r");
-
-        if ( fp == nullptr )
-        {
-            return -1;
-        }
-
-        rsa = PEM_read_RSAPublicKey(fp, &rsa, nullptr, nullptr);
-
-        if ( rsa == nullptr )
-        {
-            return -1;
-        }
-
-        fclose(fp);
-    }
-
-    char * out_c = (char *) malloc(sizeof(char) * RSA_size(rsa));
-
-    int rc = RSA_public_encrypt(in.length(), (const unsigned char *) in.c_str(),
-            (unsigned char *) out_c, rsa, RSA_PKCS1_PADDING);
-
-    if ( rc != -1 )
-    {
-        out.assign(out_c, rc);
-        rc = 0;
-    }
-
-    free(out_c);
-
-    return rc;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-int rsa_private_decrypt(const std::string& in, std::string& out)
-{
-    static RSA * rsa = nullptr;
-
-    if ( rsa == nullptr) //initialize RSA structure
-    {
-        FILE * fp = fopen(prik_path.c_str(), "r");
-
-        if ( fp == nullptr )
-        {
-            return -1;
-        }
-
-        rsa = PEM_read_RSAPrivateKey(fp, &rsa, nullptr, nullptr);
-
-        if ( rsa == nullptr )
-        {
-            return -1;
-        }
-
-        fclose(fp);
-    }
-
-    std::string result;
-
-    int key_size = RSA_size(rsa);
-    int in_size  = in.length();
-    char * out_c = (char *) malloc(sizeof(char) * RSA_size(rsa));
-
-    const char * in_c = in.c_str();
-
-    for (int index = 0; index < in_size; index += key_size)
-    {
-        int block_size = key_size;
-
-        if ( index + key_size > in_size )
-        {
-            block_size = in_size - index;
-        }
-
-        int rc = RSA_private_decrypt(block_size, (const unsigned char *)
-                in_c + index, (unsigned char *) out_c, rsa, RSA_PKCS1_PADDING);
-
-        if ( rc != -1 )
-        {
-            result.append(out_c, rc);
-            rc = 0;
-        }
-        else
-        {
-            free(out_c);
-            return -1;
-        }
-    }
-
-    free(out_c);
-
-    out = result;
-
-    return 0;
-}
+template<>
+const EString<ImageManagerMessages> image_msg_t::_type_str({
+    {"UNDEFINED", ImageManagerMessages::UNDEFINED},
+    {"INIT", ImageManagerMessages::INIT},
+    {"FINALIZE", ImageManagerMessages::FINALIZE},
+    {"CP", ImageManagerMessages::CP},
+    {"CLONE", ImageManagerMessages::CLONE},
+    {"STAT", ImageManagerMessages::STAT},
+    {"MKFS", ImageManagerMessages::MKFS},
+    {"RM", ImageManagerMessages::RM},
+    {"MONITOR", ImageManagerMessages::MONITOR},
+    {"SNAP_DELETE", ImageManagerMessages::SNAP_DELETE},
+    {"SNAP_REVERT", ImageManagerMessages::SNAP_REVERT},
+    {"SNAP_FLATTEN", ImageManagerMessages::SNAP_FLATTEN},
+    {"LOG", ImageManagerMessages::LOG},
+});
+
+template<>
+const EString<AuthManagerMessages> auth_msg_t::_type_str({
+    {"UNDEFINED", AuthManagerMessages::UNDEFINED},
+    {"INIT", AuthManagerMessages::INIT},
+    {"FINALIZE", AuthManagerMessages::FINALIZE},
+    {"AUTHORIZE", AuthManagerMessages::AUTHORIZE},
+    {"AUTHENTICATE", AuthManagerMessages::AUTHENTICATE},
+    {"LOG", AuthManagerMessages::LOG},
+});
+
+template<>
+const EString<IPAMManagerMessages> ipam_msg_t::_type_str({
+    {"UNDEFINED", IPAMManagerMessages::UNDEFINED},
+    {"INIT", IPAMManagerMessages::INIT},
+    {"FINALIZE", IPAMManagerMessages::FINALIZE},
+    {"REGISTER_ADDRESS_RANGE", IPAMManagerMessages::REGISTER_ADDRESS_RANGE},
+    {"UNREGISTER_ADDRESS_RANGE", IPAMManagerMessages::UNREGISTER_ADDRESS_RANGE},
+    {"GET_ADDRESS", IPAMManagerMessages::GET_ADDRESS},
+    {"ALLOCATE_ADDRESS", IPAMManagerMessages::ALLOCATE_ADDRESS},
+    {"FREE_ADDRESS", IPAMManagerMessages::FREE_ADDRESS},
+    {"LOG", IPAMManagerMessages::LOG},
+});
+
+template<>
+const EString<MarketPlaceManagerMessages> market_msg_t::_type_str({
+    {"UNDEFINED", MarketPlaceManagerMessages::UNDEFINED},
+    {"INIT", MarketPlaceManagerMessages::INIT},
+    {"FINALIZE", MarketPlaceManagerMessages::FINALIZE},
+    {"IMPORT", MarketPlaceManagerMessages::IMPORT},
+    {"DELETE", MarketPlaceManagerMessages::DELETE},
+    {"MONITOR", MarketPlaceManagerMessages::MONITOR},
+    {"LOG", MarketPlaceManagerMessages::LOG},
+});
+
+template<>
+const EString<TransferManagerMessages> transfer_msg_t::_type_str({
+    {"UNDEFINED", TransferManagerMessages::UNDEFINED},
+    {"INIT", TransferManagerMessages::INIT},
+    {"FINALIZE", TransferManagerMessages::FINALIZE},
+    {"TRANSFER", TransferManagerMessages::TRANSFER},
+    {"DRIVER_CANCEL", TransferManagerMessages::DRIVER_CANCEL},
+    {"LOG", TransferManagerMessages::LOG},
+});
+
+template<>
+const EString<VMManagerMessages> vm_msg_t::_type_str({
+    {"UNDEFINED", VMManagerMessages::UNDEFINED},
+    {"INIT", VMManagerMessages::INIT},
+    {"FINALIZE", VMManagerMessages::FINALIZE},
+    {"DEPLOY", VMManagerMessages::DEPLOY},
+    {"SHUTDOWN", VMManagerMessages::SHUTDOWN},
+    {"RESET", VMManagerMessages::RESET},
+    {"REBOOT", VMManagerMessages::REBOOT},
+    {"CANCEL", VMManagerMessages::CANCEL},
+    {"CLEANUP", VMManagerMessages::CLEANUP},
+    {"CHECKPOINT", VMManagerMessages::CHECKPOINT},
+    {"SAVE", VMManagerMessages::SAVE},
+    {"RESTORE", VMManagerMessages::RESTORE},
+    {"MIGRATE", VMManagerMessages::MIGRATE},
+    {"ATTACHDISK", VMManagerMessages::ATTACHDISK},
+    {"DETACHDISK", VMManagerMessages::DETACHDISK},
+    {"ATTACHNIC", VMManagerMessages::ATTACHNIC},
+    {"DETACHNIC", VMManagerMessages::DETACHNIC},
+    {"SNAPSHOTCREATE", VMManagerMessages::SNAPSHOTCREATE},
+    {"SNAPSHOTREVERT", VMManagerMessages::SNAPSHOTREVERT},
+    {"SNAPSHOTDELETE", VMManagerMessages::SNAPSHOTDELETE},
+    {"DISKSNAPSHOTCREATE", VMManagerMessages::DISKSNAPSHOTCREATE},
+    {"DISKSNAPSHOTREVERT", VMManagerMessages::DISKSNAPSHOTREVERT},
+    {"RESIZEDISK", VMManagerMessages::RESIZEDISK},
+    {"UPDATECONF", VMManagerMessages::UPDATECONF},
+    {"UPDATESG", VMManagerMessages::UPDATESG},
+    {"DRIVER_CANCEL", VMManagerMessages::DRIVER_CANCEL},
+    {"LOG", VMManagerMessages::LOG},
+});
+
+template<>
+const EString<HookManagerMessages> hook_msg_t::_type_str({
+    {"UNDEFINED", HookManagerMessages::UNDEFINED},
+    {"INIT", HookManagerMessages::INIT},
+    {"FINALIZE", HookManagerMessages::FINALIZE},
+    {"EXECUTE", HookManagerMessages::EXECUTE},
+    {"RETRY", HookManagerMessages::RETRY},
+    {"LOG", HookManagerMessages::LOG},
+});
diff --git a/src/nebula/Nebula.cc b/src/nebula/Nebula.cc
index 4653a608b7..298f619bc6 100644
--- a/src/nebula/Nebula.cc
+++ b/src/nebula/Nebula.cc
@@ -605,8 +605,6 @@ void Nebula::start(bool bootstrap_only)
     //Managers
     // -----------------------------------------------------------
 
-    MadManager::mad_manager_system_init();
-
     time_t timer_period;
     time_t monitor_interval_datastore;
     time_t monitor_interval_market;
@@ -807,20 +805,18 @@ void Nebula::start(bool bootstrap_only)
     // ---- Hook Manager and log----
     if (!cache)
     {
-        try
-        {
-            vector<const VectorAttribute *> hm_mads;
-            const VectorAttribute * hl_conf;
+        vector<const VectorAttribute *> hm_mads;
+        const VectorAttribute * hl_conf;
 
-            nebula_configuration->get("HM_MAD", hm_mads);
-            hl_conf = nebula_configuration->get("HOOK_LOG_CONF");
+        nebula_configuration->get("HM_MAD", hm_mads);
+        hl_conf = nebula_configuration->get("HOOK_LOG_CONF");
 
-            hm = new HookManager(hm_mads);
-            hl = new HookLog(logdb, hl_conf);
-        }
-        catch (bad_alloc&)
+        hm = new HookManager(mad_location);
+        hl = new HookLog(logdb, hl_conf);
+
+        if (hm->load_drivers(hm_mads) != 0)
         {
-            throw;
+            goto error_mad;
         }
 
         rc = hm->start();
@@ -829,11 +825,6 @@ void Nebula::start(bool bootstrap_only)
         {
            throw runtime_error("Could not start the Hook Manager");
         }
-
-        if (hm->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
     }
 
     // ---- Raft Manager ----
@@ -893,23 +884,21 @@ void Nebula::start(bool bootstrap_only)
     // ---- Virtual Machine Manager ----
     if (!cache)
     {
-        try
+        vector<const VectorAttribute *> vmm_mads;
+        int    vm_limit;
+
+        nebula_configuration->get("VM_PER_INTERVAL", vm_limit);
+
+        nebula_configuration->get("VM_MAD", vmm_mads);
+
+        vmm = new VirtualMachineManager(
+            timer_period,
+            vm_limit,
+            mad_location);
+
+        if (vmm->load_drivers(vmm_mads) != 0)
         {
-            vector<const VectorAttribute *> vmm_mads;
-            int    vm_limit;
-
-            nebula_configuration->get("VM_PER_INTERVAL", vm_limit);
-
-            nebula_configuration->get("VM_MAD", vmm_mads);
-
-            vmm = new VirtualMachineManager(
-                timer_period,
-                vm_limit,
-                vmm_mads);
-        }
-        catch (bad_alloc&)
-        {
-            throw;
+            goto error_mad;
         }
 
         rc = vmm->start();
@@ -953,23 +942,20 @@ void Nebula::start(bool bootstrap_only)
         {
             goto error_mad;
         }
-
     }
 
     // ---- Transfer Manager ----
     if (!cache)
     {
-        try
-        {
-            vector<const VectorAttribute *> tm_mads;
+        vector<const VectorAttribute *> tm_mads;
 
-            nebula_configuration->get("TM_MAD", tm_mads);
+        nebula_configuration->get("TM_MAD", tm_mads);
 
-            tm = new TransferManager(vmpool, hpool, tm_mads);
-        }
-        catch (bad_alloc&)
+        tm = new TransferManager(vmpool, hpool, mad_location);
+
+        if (tm->load_drivers(tm_mads) != 0)
         {
-            throw;
+            goto error_mad;
         }
 
         rc = tm->start();
@@ -1001,7 +987,6 @@ void Nebula::start(bool bootstrap_only)
     }
 
     // ---- Auth Manager ----
-    try
     {
         vector<const VectorAttribute *> auth_mads;
 
@@ -1009,50 +994,46 @@ void Nebula::start(bool bootstrap_only)
 
         if (!auth_mads.empty())
         {
-            authm = new AuthManager(timer_period, auth_mads);
+            authm = new AuthManager(timer_period, mad_location);
+
+            if (authm->load_drivers(auth_mads) != 0)
+            {
+                goto error_mad;
+            }
+
+            rc = authm->start();
+
+            if (rc != 0)
+            {
+                throw runtime_error("Could not start the Auth Manager");
+            }
         }
         else
         {
             authm = 0; //Built-in authm/authz
         }
     }
-    catch (bad_alloc&)
-    {
-        throw;
-    }
-
-    if (authm != 0)
-    {
-        rc = authm->start();
-
-        if ( rc != 0 )
-        {
-          throw runtime_error("Could not start the Auth Manager");
-        }
-    }
 
     // ---- Image Manager ----
     if (!cache)
     {
-        try
+        vector<const VectorAttribute *> image_mads;
+
+        nebula_configuration->get("DATASTORE_MAD", image_mads);
+
+        int monitor_vm_disk;
+        nebula_configuration->get("DS_MONITOR_VM_DISK", monitor_vm_disk);
+
+        imagem = new ImageManager(timer_period,
+                                  monitor_interval_datastore,
+                                  ipool,
+                                  dspool,
+                                  mad_location,
+                                  monitor_vm_disk);
+
+        if (imagem->load_drivers(image_mads) != 0)
         {
-            vector<const VectorAttribute *> image_mads;
-
-            nebula_configuration->get("DATASTORE_MAD", image_mads);
-
-            int monitor_vm_disk;
-            nebula_configuration->get("DS_MONITOR_VM_DISK", monitor_vm_disk);
-
-            imagem = new ImageManager(timer_period,
-                                      monitor_interval_datastore,
-                                      ipool,
-                                      dspool,
-                                      image_mads,
-                                      monitor_vm_disk);
-        }
-        catch (bad_alloc&)
-        {
-            throw;
+            goto error_mad;
         }
 
         rc = imagem->start();
@@ -1066,17 +1047,16 @@ void Nebula::start(bool bootstrap_only)
     // ---- Marketplace Manager ----
     if (!cache)
     {
-        try
-        {
-            vector<const VectorAttribute *> mmads;
+        vector<const VectorAttribute *> mmads;
 
-            nebula_configuration->get("MARKET_MAD", mmads);
+        nebula_configuration->get("MARKET_MAD", mmads);
 
-            marketm = new MarketPlaceManager(timer_period, monitor_interval_market, mmads);
-        }
-        catch (bad_alloc&)
+        marketm = new MarketPlaceManager(timer_period, monitor_interval_market,
+                                         mad_location);
+
+        if (marketm->load_drivers(mmads) != 0)
         {
-            throw;
+            goto error_mad;
         }
 
         rc = marketm->start();
@@ -1090,17 +1070,15 @@ void Nebula::start(bool bootstrap_only)
     // ---- IPAM Manager ----
     if (!cache)
     {
-        try
-        {
-            vector<const VectorAttribute *> ipam_mads;
+        vector<const VectorAttribute *> ipam_mads;
 
-            nebula_configuration->get("IPAM_MAD", ipam_mads);
+        nebula_configuration->get("IPAM_MAD", ipam_mads);
 
-            ipamm = new IPAMManager(timer_period, ipam_mads);
-        }
-        catch (bad_alloc&)
+        ipamm = new IPAMManager(timer_period, mad_location);
+
+        if (ipamm->load_drivers(ipam_mads) != 0)
         {
-            throw;
+            goto error_mad;
         }
 
         rc = ipamm->start();
@@ -1119,42 +1097,6 @@ void Nebula::start(bool bootstrap_only)
 
     rc = 0;
 
-    if (!cache)
-    {
-        if (vmm->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
-
-        if (tm->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
-
-        if (imagem->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
-
-        if (marketm->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
-
-        if (ipamm->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
-    }
-
-    if ( authm != 0 )
-    {
-        if (authm->load_mads(0) != 0)
-        {
-            goto error_mad;
-        }
-    }
-
     // ---- Request Manager ----
     try
     {
diff --git a/src/nebula/SConstruct b/src/nebula/SConstruct
index b662df1e17..43636752eb 100644
--- a/src/nebula/SConstruct
+++ b/src/nebula/SConstruct
@@ -44,7 +44,6 @@ env.Prepend(LIBS=[
     'nebula_group',
     'nebula_authm',
     'nebula_acl',
-    'nebula_mad',
     'nebula_template',
     'nebula_image',
     'nebula_pool',
diff --git a/src/scheduler/src/sched/SConstruct b/src/scheduler/src/sched/SConstruct
index fb6c5c1357..cee0715f44 100644
--- a/src/scheduler/src/sched/SConstruct
+++ b/src/scheduler/src/sched/SConstruct
@@ -42,6 +42,7 @@ sched_env.Prepend(LIBS=[
     'nebula_vm',
     'nebula_host',
     'nebula_parsers',
+    'nebula_sql_const',
     'crypto',
     'xml2'
 ])
diff --git a/src/secgroup/SecurityGroup.cc b/src/secgroup/SecurityGroup.cc
index 506a136b40..c54c7b0229 100644
--- a/src/secgroup/SecurityGroup.cc
+++ b/src/secgroup/SecurityGroup.cc
@@ -18,20 +18,9 @@
 #include "NebulaUtil.h"
 #include "Nebula.h"
 #include "LifeCycleManager.h"
+#include "OneDB.h"
 #include <arpa/inet.h>
 
-/* ------------------------------------------------------------------------ */
-
-const char * SecurityGroup::table = "secgroup_pool";
-
-const char * SecurityGroup::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * SecurityGroup::db_bootstrap = "CREATE TABLE IF NOT EXISTS secgroup_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name,uid))";
-
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
@@ -42,12 +31,11 @@ SecurityGroup::SecurityGroup(
         const string&   _gname,
         int             _umask,
         Template*       sgroup_template):
-        PoolObjectSQL(-1, SECGROUP, "", _uid,_gid,_uname,_gname,table),
-        updated("UPDATED_VMS"),
-        outdated("OUTDATED_VMS"),
-        updating("UPDATING_VMS"),
-        error("ERROR_VMS")
-
+    PoolObjectSQL(-1, SECGROUP, "", _uid,_gid,_uname,_gname,one_db::sg_table),
+    updated("UPDATED_VMS"),
+    outdated("OUTDATED_VMS"),
+    updating("UPDATING_VMS"),
+    error("ERROR_VMS")
 {
     if (sgroup_template != 0)
     {
@@ -140,7 +128,7 @@ int SecurityGroup::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::sg_table << " SET "
             << "name = '"    << sql_name << "', "
             << "body = '"    << sql_xml  << "', "
             << "uid = "      <<  uid     << ", "
@@ -152,7 +140,8 @@ int SecurityGroup::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::sg_table
+            << " (" << one_db::sg_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -194,6 +183,16 @@ error_common:
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
+int SecurityGroup::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::sg_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
 string& SecurityGroup::to_xml(string& xml) const
 {
     ostringstream   oss;
diff --git a/src/secgroup/SecurityGroupPool.cc b/src/secgroup/SecurityGroupPool.cc
index 71230b3c83..2b14a533ff 100644
--- a/src/secgroup/SecurityGroupPool.cc
+++ b/src/secgroup/SecurityGroupPool.cc
@@ -22,7 +22,8 @@
 
 /* -------------------------------------------------------------------------- */
 
-SecurityGroupPool::SecurityGroupPool(SqlDB * db):PoolSQL(db,SecurityGroup::table)
+SecurityGroupPool::SecurityGroupPool(SqlDB * db)
+    : PoolSQL(db, one_db::sg_table)
 {
     //lastOID is set in PoolSQL::init_cb
     if (get_lastOID() == -1)
diff --git a/src/sql/LogDB.cc b/src/sql/LogDB.cc
index 9bcaa68975..faa5db2960 100644
--- a/src/sql/LogDB.cc
+++ b/src/sql/LogDB.cc
@@ -21,25 +21,16 @@
 #include "Callbackable.h"
 #include "RaftManager.h"
 #include "FedReplicaManager.h"
+#include "OneDB.h"
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-const char * LogDB::table = "logdb";
-
-const char * LogDB::db_names = "log_index, term, sqlcmd, timestamp, fed_index, applied";
-
-const char * LogDB::db_bootstrap = "CREATE TABLE IF NOT EXISTS "
-    "logdb (log_index BIGINT UNSIGNED PRIMARY KEY, term INTEGER, sqlcmd MEDIUMTEXT, "
-    "timestamp INTEGER, fed_index BIGINT UNSIGNED, applied BOOLEAN)";
-
-/* -------------------------------------------------------------------------- */
-
 int LogDB::bootstrap(SqlDB *_db)
 {
     int rc;
 
-    std::ostringstream oss(db_bootstrap);
+    std::ostringstream oss(one_db::log_db_bootstrap);
 
     rc = _db->exec_local_wr(oss);
 
@@ -337,13 +328,14 @@ int LogDB::insert(uint64_t index, unsigned int term, const std::string& sql,
         oss << "INSERT";
     }
 
-    oss << " INTO " << table << " ("<< db_names <<") VALUES ("
-            <<        index     << ","
-            <<        term      << ","
-            << "'" << sql_db    << "',"
-            <<        tstamp    << ","
-            <<        fed_index << ","
-            << "'" << applied   << "')";
+    oss << " INTO " << one_db::log_table
+        << " ("<< one_db::log_db_names <<") VALUES ("
+        <<        index     << ","
+        <<        term      << ","
+        << "'" << sql_db    << "',"
+        <<        tstamp    << ","
+        <<        fed_index << ","
+        << "'" << applied   << "')";
 
     int rc = db->exec_wr(oss);
 
@@ -565,7 +557,8 @@ int LogDB::delete_log_records(uint64_t start_index)
 
     pthread_mutex_lock(&mutex);
 
-    oss << "DELETE FROM " << table << " WHERE log_index >= " << start_index;
+    oss << "DELETE FROM " << one_db::log_table
+        << " WHERE log_index >= " << start_index;
 
     rc = db->exec_wr(oss);
 
@@ -825,7 +818,8 @@ void LogDB::build_federated_index()
 
     cb.set_callback(&fed_log);
 
-    oss << "SELECT fed_index FROM " << table << " WHERE fed_index != " << UINT64_MAX;
+    oss << "SELECT fed_index FROM " << one_db::log_table
+        << " WHERE fed_index != " << UINT64_MAX;
 
     db->exec_rd(oss, &cb);
 
diff --git a/src/sql/OneDB.cc b/src/sql/OneDB.cc
index b1e6473bde..fe3c9d0456 100644
--- a/src/sql/OneDB.cc
+++ b/src/sql/OneDB.cc
@@ -91,4 +91,286 @@ namespace one_db
     const char * vm_import_db_bootstrap =
         "CREATE TABLE IF NOT EXISTS vm_import "
         "(deploy_id VARCHAR(128), vmid INTEGER, PRIMARY KEY(deploy_id))";
+
+
+    const char * vm_group_table = "vmgroup_pool";
+
+    const char * vm_group_db_names = "oid, name, body, uid, gid, owner_u, group_u, "
+        "other_u";
+
+    const char * vm_group_db_bootstrap = "CREATE TABLE IF NOT EXISTS vmgroup_pool "
+        "(oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, "
+        "uid INTEGER, gid INTEGER, owner_u INTEGER, group_u INTEGER, "
+        "other_u INTEGER, UNIQUE(name,uid))";
+
+    const char * vm_template_table = "template_pool";
+
+    const char * vm_template_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * vm_template_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS template_pool (oid INTEGER PRIMARY KEY, "
+        "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
+        "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Cluster tables                                                         */
+    /* ---------------------------------------------------------------------- */
+    const char * cluster_table = "cluster_pool";
+
+    const char * cluster_db_names =
+        "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * cluster_db_bootstrap = "CREATE TABLE IF NOT EXISTS cluster_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name))";
+
+    const char * cluster_datastore_table = "cluster_datastore_relation";
+    const char * cluster_datastore_db_names = "cid, oid";
+    const char * cluster_datastore_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS cluster_datastore_relation ("
+        "cid INTEGER, oid INTEGER, PRIMARY KEY(cid, oid))";
+
+    const char * cluster_network_table = "cluster_network_relation";
+    const char * cluster_network_db_names = "cid, oid";
+    const char * cluster_network_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS cluster_network_relation ("
+        "cid INTEGER, oid INTEGER, PRIMARY KEY(cid, oid))";
+
+    const char * cluster_bitmap_table = "cluster_vnc_bitmap";
+
+    /* ---------------------------------------------------------------------- */
+    /* ACL tables                                                             */
+    /* ---------------------------------------------------------------------- */
+    const char * acl_table = "acl";
+
+    const char * acl_db_names = "oid, user, resource, rights, zone";
+
+    const char * acl_db_bootstrap = "CREATE TABLE IF NOT EXISTS "
+        "acl (oid INT PRIMARY KEY, user BIGINT, resource BIGINT, "
+        "rights BIGINT, zone BIGINT, UNIQUE(user, resource, rights, zone))";
+
+    /* ---------------------------------------------------------------------- */
+    /* Datastore tables                                                       */
+    /* ---------------------------------------------------------------------- */
+    const char * ds_table = "datastore_pool";
+
+    const char * ds_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * ds_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS datastore_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Document tables                                                        */
+    /* ---------------------------------------------------------------------- */
+    const char * doc_table = "document_pool";
+
+    const char * doc_db_names =
+            "oid, name, body, type, uid, gid, owner_u, group_u, other_u";
+
+    const char * doc_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS document_pool (oid INTEGER PRIMARY KEY, "
+        "name VARCHAR(128), body MEDIUMTEXT, type INTEGER, uid INTEGER, gid INTEGER, "
+        "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Group tables                                                           */
+    /* ---------------------------------------------------------------------- */
+    const char * group_table = "group_pool";
+
+    const char * group_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * group_db_bootstrap = "CREATE TABLE IF NOT EXISTS group_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name))";
+
+    /* ---------------------------------------------------------------------- */
+    /* History tables                                                         */
+    /* ---------------------------------------------------------------------- */
+    const char * history_table = "history";
+
+    const char * history_db_names = "vid, seq, body, stime, etime";
+
+    const char * history_db_bootstrap = "CREATE TABLE IF NOT EXISTS "
+        "history (vid INTEGER, seq INTEGER, body MEDIUMTEXT, "
+        "stime INTEGER, etime INTEGER,PRIMARY KEY(vid,seq))";
+
+    /* ---------------------------------------------------------------------- */
+    /* Hook tables                                                            */
+    /* ---------------------------------------------------------------------- */
+    const char * hook_table = "hook_pool";
+
+    const char * hook_db_names =
+        "oid, name, body, uid, gid, owner_u, group_u, other_u, type";
+
+    const char * hook_db_bootstrap = "CREATE TABLE IF NOT EXISTS hook_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER,"
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, type INTEGER)";
+
+    const char * hook_log_table = "hook_log";
+
+    const char * hook_log_db_names = "hkid, exeid, timestamp, rc, body";
+
+    const char * hook_log_db_bootstrap = "CREATE TABLE IF NOT EXISTS hook_log"
+        " (hkid INTEGER, exeid INTEGER, timestamp INTEGER, rc INTEGER,"
+        " body MEDIUMTEXT,PRIMARY KEY(hkid, exeid))";
+
+    /* ---------------------------------------------------------------------- */
+    /* Image tables                                                           */
+    /* ---------------------------------------------------------------------- */
+    const char * image_table = "image_pool";
+
+    const char * image_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * image_db_bootstrap = "CREATE TABLE IF NOT EXISTS image_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name,uid) )";
+
+    /* ---------------------------------------------------------------------- */
+    /* Log tables                                                             */
+    /* ---------------------------------------------------------------------- */
+    const char * log_table = "logdb";
+
+    const char * log_db_names = "log_index, term, sqlcmd, timestamp, fed_index, applied";
+
+    const char * log_db_bootstrap = "CREATE TABLE IF NOT EXISTS "
+        "logdb (log_index BIGINT UNSIGNED PRIMARY KEY, term INTEGER, sqlcmd MEDIUMTEXT, "
+        "timestamp INTEGER, fed_index BIGINT UNSIGNED, applied BOOLEAN)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Marketplace tables                                                     */
+    /* ---------------------------------------------------------------------- */
+    const char * mp_table = "marketplace_pool";
+
+    const char * mp_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * mp_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS marketplace_pool (oid INTEGER PRIMARY KEY, "
+        "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
+        "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+
+    const char * mp_app_table = "marketplaceapp_pool";
+
+    const char * mp_app_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * mp_app_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS marketplaceapp_pool (oid INTEGER PRIMARY KEY, "
+        "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
+        "owner_u INTEGER, group_u INTEGER, other_u INTEGER, UNIQUE(name,uid))";
+
+    /* ---------------------------------------------------------------------- */
+    /* Quotas tables                                                          */
+    /* ---------------------------------------------------------------------- */
+    const char * group_quotas_db_table = "group_quotas";
+    const char * group_quotas_db_names = "group_oid, body";
+    const char * group_quotas_db_oid_column = "group_oid";
+    const char * group_quotas_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS group_quotas ("
+        "group_oid INTEGER PRIMARY KEY, body MEDIUMTEXT)";
+
+    const char * user_quotas_db_table = "user_quotas";
+    const char * user_quotas_db_names = "user_oid, body";
+    const char * user_quotas_db_oid_column = "user_oid";
+    const char * user_quotas_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS user_quotas ("
+        "user_oid INTEGER PRIMARY KEY, body MEDIUMTEXT)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Security Group tables                                                  */
+    /* ---------------------------------------------------------------------- */
+    const char * sg_table = "secgroup_pool";
+
+    const char * sg_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * sg_db_bootstrap = "CREATE TABLE IF NOT EXISTS secgroup_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name,uid))";
+
+    /* ---------------------------------------------------------------------- */
+    /* User tables                                                            */
+    /* ---------------------------------------------------------------------- */
+    const char * user_table = "user_pool";
+
+    const char * user_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * user_db_bootstrap = "CREATE TABLE IF NOT EXISTS user_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name))";
+
+    /* ---------------------------------------------------------------------- */
+    /* VDC tables                                                             */
+    /* ---------------------------------------------------------------------- */
+    const char * vdc_table = "vdc_pool";
+
+    const char * vdc_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * vdc_db_bootstrap = "CREATE TABLE IF NOT EXISTS vdc_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name))";
+
+    /* ---------------------------------------------------------------------- */
+    /* Virtual Network tables                                                 */
+    /* ---------------------------------------------------------------------- */
+    const char * vn_table    = "network_pool";
+
+    const char * vn_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u, pid";
+
+    const char * vn_db_bootstrap = "CREATE TABLE IF NOT EXISTS"
+        " network_pool (oid INTEGER PRIMARY KEY, name VARCHAR(128),"
+        " body MEDIUMTEXT, uid INTEGER, gid INTEGER,"
+        " owner_u INTEGER, group_u INTEGER, other_u INTEGER,"
+        " pid INTEGER, UNIQUE(name,uid))";
+
+    const char * vn_template_table = "vn_template_pool";
+
+    const char * vn_template_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * vn_template_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS vn_template_pool (oid INTEGER PRIMARY KEY, "
+        "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
+        "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Virtual Router tables                                                  */
+    /* ---------------------------------------------------------------------- */
+    const char * vr_table = "vrouter_pool";
+
+    const char * vr_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * vr_db_bootstrap =
+        "CREATE TABLE IF NOT EXISTS vrouter_pool (oid INTEGER PRIMARY KEY, "
+        "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
+        "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
+
+    /* ---------------------------------------------------------------------- */
+    /* Zone tables                                                            */
+    /* ---------------------------------------------------------------------- */
+    const char * zone_table = "zone_pool";
+
+    const char * zone_db_names =
+            "oid, name, body, uid, gid, owner_u, group_u, other_u";
+
+    const char * zone_db_bootstrap = "CREATE TABLE IF NOT EXISTS zone_pool ("
+        "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
+        "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
+        "UNIQUE(name))";
 }
diff --git a/src/tm/SConstruct b/src/tm/SConstruct
index cd5fcb92a9..82543423b7 100644
--- a/src/tm/SConstruct
+++ b/src/tm/SConstruct
@@ -23,7 +23,7 @@ lib_name='nebula_tm'
 # Sources to generate the library
 source_files=[
     'TransferManager.cc',
-    'TransferManagerDriver.cc'
+    'TransferManagerProtocol.cc'
 ]
 
 # Build library
diff --git a/src/tm/TransferManager.cc b/src/tm/TransferManager.cc
index eb1da8b7bf..5e0df8d5a7 100644
--- a/src/tm/TransferManager.cc
+++ b/src/tm/TransferManager.cc
@@ -20,6 +20,8 @@
 #include "Nebula.h"
 #include "NebulaUtil.h"
 #include "VirtualMachineDisk.h"
+#include "VirtualMachinePool.h"
+#include "LifeCycleManager.h"
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -56,10 +58,21 @@ int TransferManager::start()
     int               rc;
     pthread_attr_t    pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(TransferManagerMessages::UNDEFINED,
+            &TransferManager::_undefined);
+
+    register_action(TransferManagerMessages::TRANSFER,
+            bind(&TransferManager::_transfer, this, _1));
+
+    register_action(TransferManagerMessages::LOG,
+            &TransferManager::_log);
+
+    string error;
+    if ( DriverManager::start(error) != 0 )
     {
+        NebulaLog::error("TrM", error);
         return -1;
     }
 
@@ -104,16 +117,18 @@ void TransferManager::user_action(const ActionRequest& ar)
 
     vm->unlock();
 
+    auto lcm = nd.get_lcm();
+
     switch (tm_ar.action())
     {
         case TMAction::PROLOG:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::PROLOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::PROLOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
+                lcm->trigger(LCMAction::PROLOG_FAILURE,vid);
             }
             else
             {
@@ -124,11 +139,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::PROLOG_MIGR:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::PROLOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::PROLOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
+                lcm->trigger(LCMAction::PROLOG_FAILURE,vid);
             }
             else
             {
@@ -139,11 +154,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::PROLOG_RESUME:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::PROLOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::PROLOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
+                lcm->trigger(LCMAction::PROLOG_FAILURE,vid);
             }
             else
             {
@@ -154,11 +169,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::PROLOG_ATTACH:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::ATTACH_SUCCESS,vid);
+                lcm->trigger(LCMAction::ATTACH_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::ATTACH_FAILURE,vid);
+                lcm->trigger(LCMAction::ATTACH_FAILURE,vid);
             }
             else
             {
@@ -169,11 +184,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -184,11 +199,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_LOCAL:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -199,11 +214,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_STOP:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -214,11 +229,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_DELETE:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -229,11 +244,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_DELETE_STOP:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -244,11 +259,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_DELETE_PREVIOUS:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -259,11 +274,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_DELETE_BOTH:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_SUCCESS,vid);
+                lcm->trigger(LCMAction::EPILOG_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
+                lcm->trigger(LCMAction::EPILOG_FAILURE,vid);
             }
             else
             {
@@ -274,11 +289,11 @@ void TransferManager::user_action(const ActionRequest& ar)
         case TMAction::EPILOG_DETACH:
             if (host_is_cloud)
             {
-                (nd.get_lcm())->trigger(LCMAction::DETACH_SUCCESS,vid);
+                lcm->trigger(LCMAction::DETACH_SUCCESS,vid);
             }
             else if (vm_no_history)
             {
-                (nd.get_lcm())->trigger(LCMAction::DETACH_FAILURE,vid);
+                lcm->trigger(LCMAction::DETACH_FAILURE,vid);
             }
             else
             {
@@ -352,7 +367,7 @@ int TransferManager::prolog_transfer_command(
         if ( size.empty() )
         {
             os << "No size in swap image";
-            vm->log("TM", Log::WARNING, "No size in swap image, skipping");
+            vm->log("TrM", Log::WARNING, "No size in swap image, skipping");
             return 0;
         }
 
@@ -382,7 +397,7 @@ int TransferManager::prolog_transfer_command(
         if ( size.empty() )
         {
             os << "No size in FS";
-            vm->log("TM", Log::WARNING, "No size in FS, skipping");
+            vm->log("TrM", Log::WARNING, "No size in FS, skipping");
             return 0;
         }
 
@@ -570,14 +585,12 @@ void TransferManager::prolog_action(int vid)
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     const VectorAttribute * os_attr;
 
     string token_password;
 
-    VirtualMachineDisks::disk_iterator disk;
-
     // -------------------------------------------------------------------------
     // Setup & Transfer script
     // -------------------------------------------------------------------------
@@ -622,9 +635,9 @@ void TransferManager::prolog_action(int vid)
     // Image Transfer Commands
     // -------------------------------------------------------------------------
 
-    for ( disk = disks.begin() ; disk != disks.end() ; ++disk )
+    for (auto disk : disks)
     {
-        rc = prolog_transfer_command(vm, *disk, vm_tm_mad, opennebula_hostname,
+        rc = prolog_transfer_command(vm, disk, vm_tm_mad, opennebula_hostname,
                 xfr, os);
 
         if ( rc != 0 )
@@ -681,9 +694,13 @@ void TransferManager::prolog_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -705,7 +722,7 @@ error_attributes:
 
 error_common:
     (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -727,12 +744,9 @@ void TransferManager::prolog_migr_action(int vid)
     int ds_id;
     int disk_id;
 
-    VirtualMachineDisks::disk_iterator disk;
-
     VirtualMachine *    vm;
-    Nebula&             nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     // -------------------------------------------------------------------------
     // Setup & Transfer script
@@ -771,19 +785,19 @@ void TransferManager::prolog_migr_action(int vid)
     // Move system directory and disks
     // ------------------------------------------------------------------------
 
-    for ( disk = disks.begin() ; disk != disks.end() ; ++disk )
+    for (auto disk : disks)
     {
-        disk_id = (*disk)->get_disk_id();
+        disk_id = disk->get_disk_id();
 
-        if ( (*disk)->is_volatile() == true )
+        if ( disk->is_volatile() == true )
         {
             tm_mad = vm_tm_mad;
             ds_id  = vm->get_ds_id();
         }
         else
         {
-            tm_mad    = (*disk)->vector_value("TM_MAD");
-            int vv_rc = (*disk)->vector_value("DATASTORE_ID", ds_id);
+            tm_mad    = disk->vector_value("TM_MAD");
+            int vv_rc = disk->vector_value("DATASTORE_ID", ds_id);
 
             if (tm_mad.empty() || vv_rc == -1)
             {
@@ -791,7 +805,7 @@ void TransferManager::prolog_migr_action(int vid)
             }
         }
 
-        string tsys = (*disk)->vector_value("TM_MAD_SYSTEM");
+        string tsys = disk->vector_value("TM_MAD_SYSTEM");
         if (!tsys.empty())
         {
             tm_mad_system = "." + tsys;
@@ -821,9 +835,13 @@ void TransferManager::prolog_migr_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -842,8 +860,8 @@ error_file:
     goto error_common;
 
 error_common:
-    (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
-    vm->log("TM", Log::ERROR, os);
+    (Nebula::instance().get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -866,12 +884,10 @@ void TransferManager::prolog_resume_action(int vid)
     int ds_id;
     int disk_id;
 
-    VirtualMachineDisks::disk_iterator disk;
-
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     // -------------------------------------------------------------------------
     // Setup & Transfer script
@@ -914,19 +930,19 @@ void TransferManager::prolog_resume_action(int vid)
     // ------------------------------------------------------------------------
     // Move system directory and disks
     // ------------------------------------------------------------------------
-    for (disk = disks.begin(); disk != disks.end(); ++disk)
+    for (auto disk : disks)
     {
-        disk_id = (*disk)->get_disk_id();
+        disk_id = disk->get_disk_id();
 
-        if ( (*disk)->is_volatile() == true )
+        if ( disk->is_volatile() == true )
         {
             tm_mad = vm_tm_mad;
             ds_id  = vm->get_ds_id();
         }
         else
         {
-            tm_mad    = (*disk)->vector_value("TM_MAD");
-            int vv_rc = (*disk)->vector_value("DATASTORE_ID", ds_id);
+            tm_mad    = disk->vector_value("TM_MAD");
+            int vv_rc = disk->vector_value("DATASTORE_ID", ds_id);
 
             if ( tm_mad.empty() || vv_rc == -1)
             {
@@ -934,7 +950,7 @@ void TransferManager::prolog_resume_action(int vid)
             }
         }
 
-        string tsys = (*disk)->vector_value("TM_MAD_SYSTEM");
+        string tsys = disk->vector_value("TM_MAD_SYSTEM");
         if (!tsys.empty())
         {
             tm_mad_system = "." + tsys;
@@ -962,9 +978,13 @@ void TransferManager::prolog_resume_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -985,7 +1005,7 @@ error_file:
 error_common:
     (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
 
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -1011,7 +1031,7 @@ void TransferManager::prolog_attach_action(int vid)
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     // -------------------------------------------------------------------------
     // Setup & Transfer script
@@ -1071,9 +1091,13 @@ void TransferManager::prolog_attach_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -1100,7 +1124,7 @@ error_attributes:
 
 error_common:
     (nd.get_lcm())->trigger(LCMAction::PROLOG_FAILURE,vid);
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -1127,13 +1151,13 @@ void TransferManager::epilog_transfer_command(
 
         if ( ds_id.empty() || tm_mad.empty() )
         {
-            vm->log("TM", Log::ERROR, "No DS_ID or TM_MAD to save disk image");
+            vm->log("TrM", Log::ERROR, "No DS_ID or TM_MAD to save disk image");
             return;
         }
 
         if (source.empty())
         {
-            vm->log("TM", Log::ERROR, "No SOURCE to save disk image");
+            vm->log("TrM", Log::ERROR, "No SOURCE to save disk image");
             return;
         }
 
@@ -1206,9 +1230,7 @@ void TransferManager::epilog_action(bool local, int vid)
     VirtualMachine *    vm;
     Nebula&             nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
-
-    VirtualMachineDisks::disk_iterator disk;
+    const Driver<transfer_msg_t> * tm_md;
 
     // ------------------------------------------------------------------------
     // Setup & Transfer script
@@ -1255,9 +1277,9 @@ void TransferManager::epilog_action(bool local, int vid)
     // -------------------------------------------------------------------------
     // copy back VM image (DISK with SAVE="yes")
     // -------------------------------------------------------------------------
-    for ( disk = disks.begin() ; disk != disks.end() ; ++disk )
+    for (auto disk : disks)
     {
-        epilog_transfer_command(vm, host, *disk, xfr);
+        epilog_transfer_command(vm, host, disk, xfr);
     }
 
     //DELETE vm_tm_mad hostname:remote_system_dir vmid ds_id
@@ -1269,9 +1291,14 @@ void TransferManager::epilog_action(bool local, int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
+
     return;
 
 error_history:
@@ -1291,7 +1318,7 @@ error_file:
 
 error_common:
     (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -1316,9 +1343,7 @@ void TransferManager::epilog_stop_action(int vid)
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
-
-    VirtualMachineDisks::disk_iterator disk;
+    const Driver<transfer_msg_t> * tm_md;
 
     // ------------------------------------------------------------------------
     // Setup & Transfer script
@@ -1356,19 +1381,19 @@ void TransferManager::epilog_stop_action(int vid)
     // ------------------------------------------------------------------------
     // Move system directory and disks
     // ------------------------------------------------------------------------
-    for (disk = disks.begin(); disk != disks.end(); ++disk)
+    for (auto disk : disks)
     {
-        disk_id = (*disk)->get_disk_id();
+        disk_id = disk->get_disk_id();
 
-        if ( (*disk)->is_volatile() == true )
+        if ( disk->is_volatile() == true )
         {
             tm_mad = vm_tm_mad;
             ds_id  = vm->get_ds_id();
         }
         else
         {
-            tm_mad    = (*disk)->vector_value("TM_MAD");
-            int vv_rc = (*disk)->vector_value("DATASTORE_ID", ds_id);
+            tm_mad    = disk->vector_value("TM_MAD");
+            int vv_rc = disk->vector_value("DATASTORE_ID", ds_id);
 
             if (tm_mad.empty() || vv_rc == -1)
             {
@@ -1376,7 +1401,7 @@ void TransferManager::epilog_stop_action(int vid)
             }
         }
 
-        string tsys = (*disk)->vector_value("TM_MAD_SYSTEM");
+        string tsys = disk->vector_value("TM_MAD_SYSTEM");
         if (!tsys.empty())
         {
             tm_mad_system = "." + tsys;
@@ -1404,10 +1429,13 @@ void TransferManager::epilog_stop_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
 
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -1427,7 +1455,7 @@ error_file:
 
 error_common:
     (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -1456,7 +1484,6 @@ int TransferManager::epilog_delete_commands(VirtualMachine *vm,
 
     Nebula& nd = Nebula::instance();
 
-    VirtualMachineDisks::disk_iterator disk;
     VirtualMachineDisks& disks = vm->get_disks();
 
     // ------------------------------------------------------------------------
@@ -1505,19 +1532,19 @@ int TransferManager::epilog_delete_commands(VirtualMachine *vm,
     // -------------------------------------------------------------------------
     // Delete disk images and the remote system Directory
     // -------------------------------------------------------------------------
-    for ( disk = disks.begin() ; disk != disks.end() ; ++disk )
+    for (auto disk : disks)
     {
-        disk_id = (*disk)->get_disk_id();
+        disk_id = disk->get_disk_id();
 
-        if ( (*disk)->is_volatile() == true )
+        if ( disk->is_volatile() == true )
         {
             tm_mad = vm_tm_mad;
             ds_id  = vm_ds_id;
         }
         else
         {
-            tm_mad    = (*disk)->vector_value("TM_MAD");
-            int vv_rc = (*disk)->vector_value("DATASTORE_ID", ds_id);
+            tm_mad    = disk->vector_value("TM_MAD");
+            int vv_rc = disk->vector_value("DATASTORE_ID", ds_id);
 
             if (tm_mad.empty() || vv_rc == -1)
             {
@@ -1525,7 +1552,7 @@ int TransferManager::epilog_delete_commands(VirtualMachine *vm,
             }
         }
 
-        string tsys = (*disk)->vector_value("TM_MAD_SYSTEM");
+        string tsys = disk->vector_value("TM_MAD_SYSTEM");
         if (!tsys.empty())
         {
            tm_mad_system = "." + tsys;
@@ -1562,7 +1589,7 @@ error_drivers:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
     return -1;
 }
 
@@ -1579,7 +1606,7 @@ void TransferManager::epilog_delete_action(bool local, int vid)
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     int rc;
 
@@ -1617,9 +1644,13 @@ void TransferManager::epilog_delete_action(bool local, int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_driver:
@@ -1632,7 +1663,7 @@ error_file:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
     (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE, vid);
 
     vm->unlock();
@@ -1652,7 +1683,7 @@ void TransferManager::epilog_delete_previous_action(int vid)
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     int rc;
 
@@ -1690,9 +1721,13 @@ void TransferManager::epilog_delete_previous_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid, xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_driver:
@@ -1705,7 +1740,7 @@ error_file:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
     (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE, vid);
 
     vm->unlock();
@@ -1725,7 +1760,7 @@ void TransferManager::epilog_delete_both_action(int vid)
     VirtualMachine * vm;
     Nebula&          nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     int rc;
 
@@ -1764,9 +1799,13 @@ void TransferManager::epilog_delete_both_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid, xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_driver:
@@ -1779,7 +1818,7 @@ error_file:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
     (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE, vid);
 
     vm->unlock();
@@ -1802,7 +1841,7 @@ void TransferManager::epilog_detach_action(int vid)
     VirtualMachine *    vm;
     Nebula&             nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
 
     // ------------------------------------------------------------------------
     // Setup & Transfer script
@@ -1850,9 +1889,13 @@ void TransferManager::epilog_detach_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid,xfr_name);
-
     vm->unlock();
+
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -1877,7 +1920,7 @@ error_disk:
 
 error_common:
     (nd.get_lcm())->trigger(LCMAction::EPILOG_FAILURE,vid);
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     vm->unlock();
     return;
@@ -1888,38 +1931,32 @@ error_common:
 
 void TransferManager::driver_cancel_action(int vid)
 {
-    ofstream        xfr;
-    ostringstream   os;
-    string          xfr_name;
-
-    VirtualMachine *    vm;
-
-    const TransferManagerDriver * tm_md;
-
     // ------------------------------------------------------------------------
     // Get the Driver for this host
     // ------------------------------------------------------------------------
-    tm_md = get();
+    auto tm_md = get();
 
-    if ( tm_md == nullptr )
+    if (tm_md == nullptr)
     {
         return;
     }
 
-    vm = vmpool->get(vid);
+    VirtualMachine * vm = vmpool->get(vid);
 
     if (vm == nullptr)
     {
         return;
     }
 
+    vm->unlock();
+
     // ------------------------------------------------------------------------
     // Cancel the current operation
     // ------------------------------------------------------------------------
 
-    tm_md->driver_cancel(vid);
+    transfer_msg_t msg(TransferManagerMessages::DRIVER_CANCEL, "", vid, "");
+    tm_md->write(msg);
 
-    vm->unlock();
     return;
 }
 
@@ -1951,7 +1988,7 @@ void TransferManager::saveas_hot_action(int vid)
     string   xfr_name;
 
     VirtualMachine * vm;
-    const TransferManagerDriver * tm_md;
+    const Driver<transfer_msg_t> * tm_md;
     VirtualMachineDisk * disk;
 
     Nebula& nd = Nebula::instance();
@@ -2015,10 +2052,13 @@ void TransferManager::saveas_hot_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid, xfr_name);
-
     vm->unlock();
 
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_history:
@@ -2039,7 +2079,7 @@ error_file:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     (nd.get_lcm())->trigger(LCMAction::SAVEAS_FAILURE, vid);
 
@@ -2082,7 +2122,7 @@ int TransferManager::snapshot_transfer_command(
 
     if (vm->get_snapshot_disk(ds_id, tm_mad, disk_id, snap_id) == -1)
     {
-        vm->log("TM", Log::ERROR, "Could not get disk information to "
+        vm->log("TrM", Log::ERROR, "Could not get disk information to "
                 "take snapshot");
         return -1;
     }
@@ -2124,11 +2164,9 @@ void TransferManager::do_snapshot_action(int vid, const char * snap_action)
     VirtualMachine * vm;
     int rc;
 
-    const TransferManagerDriver * tm_md;
-
     Nebula& nd = Nebula::instance();
 
-    tm_md = get();
+    auto tm_md = get();
 
     if (tm_md == nullptr)
     {
@@ -2164,10 +2202,13 @@ void TransferManager::do_snapshot_action(int vid, const char * snap_action)
         goto error_common;
     }
 
-    tm_md->transfer(vid, xfr_name);
-
     vm->unlock();
 
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_driver:
@@ -2183,7 +2224,7 @@ error_file:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     (nd.get_lcm())->trigger(LCMAction::DISK_SNAPSHOT_FAILURE, vid);
 
@@ -2259,7 +2300,7 @@ void TransferManager::resize_action(int vid)
 
     Nebula& nd = Nebula::instance();
 
-    const TransferManagerDriver * tm_md = get();
+    auto tm_md = get();
 
     if (tm_md == nullptr)
     {
@@ -2297,10 +2338,13 @@ void TransferManager::resize_action(int vid)
 
     xfr.close();
 
-    tm_md->transfer(vid, xfr_name);
-
     vm->unlock();
 
+    {
+        transfer_msg_t msg(TransferManagerMessages::TRANSFER, "", vid, xfr_name);
+        tm_md->write(msg);
+    }
+
     return;
 
 error_driver:
@@ -2320,7 +2364,7 @@ error_disk:
     goto error_common;
 
 error_common:
-    vm->log("TM", Log::ERROR, os);
+    vm->log("TrM", Log::ERROR, os);
 
     (nd.get_lcm())->trigger(LCMAction::DISK_RESIZE_FAILURE, vid);
 
@@ -2332,48 +2376,34 @@ error_common:
 /* MAD Loading                                                                */
 /* ************************************************************************** */
 
-int TransferManager::load_mads(int uid)
+int TransferManager::load_drivers(const std::vector<const VectorAttribute*>& _mads)
 {
-    ostringstream oss;
-
-    int    rc;
-    string name;
-
     const VectorAttribute * vattr = nullptr;
-    TransferManagerDriver * tm_driver = nullptr;
 
-    oss << "Loading Transfer Manager driver.";
+    NebulaLog::info("TrM", "Loading Transfer Manager driver.");
 
-    NebulaLog::log("TM",Log::INFO,oss);
-
-    if ( mad_conf.size() > 0 )
+    if ( _mads.size() > 0 )
     {
-        vattr = mad_conf[0];
+        vattr = _mads[0];
     }
 
     if ( vattr == nullptr )
     {
-        NebulaLog::log("TM",Log::ERROR,"Failed to load Transfer Manager driver.");
+        NebulaLog::log("TrM",Log::ERROR,"Failed to load Transfer Manager driver.");
         return -1;
     }
 
     VectorAttribute tm_conf("TM_MAD", vattr->value());
 
-    tm_conf.replace("NAME",transfer_driver_name);
+    tm_conf.replace("NAME", transfer_driver_name);
 
-    tm_driver = new TransferManagerDriver(uid,
-                                          tm_conf.value(),
-                                          (uid != 0),
-                                          vmpool);
-    rc = add(tm_driver);
-
-    if ( rc == 0 )
+    if ( load_driver(&tm_conf) != 0 )
     {
-        oss.str("");
-        oss << "\tTransfer manager driver loaded";
-
-        NebulaLog::log("TM",Log::INFO,oss);
+        NebulaLog::error("TrM", "Unable to load Transfer Manager driver");
+        return -1;
     }
 
-    return rc;
+    NebulaLog::info("TrM", "\tTransfer manager driver loaded");
+
+    return 0;
 }
diff --git a/src/tm/TransferManagerDriver.cc b/src/tm/TransferManagerDriver.cc
deleted file mode 100644
index 3e894564f7..0000000000
--- a/src/tm/TransferManagerDriver.cc
+++ /dev/null
@@ -1,273 +0,0 @@
-/* -------------------------------------------------------------------------- */
-/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
-/*                                                                            */
-/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
-/* not use this file except in compliance with the License. You may obtain    */
-/* a copy of the License at                                                   */
-/*                                                                            */
-/* http://www.apache.org/licenses/LICENSE-2.0                                 */
-/*                                                                            */
-/* Unless required by applicable law or agreed to in writing, software        */
-/* distributed under the License is distributed on an "AS IS" BASIS,          */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
-/* See the License for the specific language governing permissions and        */
-/* limitations under the License.                                             */
-/* -------------------------------------------------------------------------- */
-
-#include "TransferManagerDriver.h"
-#include "NebulaLog.h"
-#include "LifeCycleManager.h"
-
-#include "Nebula.h"
-#include <sstream>
-
-/* ************************************************************************** */
-/* Driver ASCII Protocol Implementation                                       */
-/* ************************************************************************** */
-
-void TransferManagerDriver::transfer (
-        const int oid,
-        const string& xfr_file) const
-{
-    ostringstream os;
-
-    os << "TRANSFER " << oid << " " << xfr_file << endl;
-
-    write(os);
-};
-
-
-/* ************************************************************************** */
-/* MAD Interface                                                              */
-/* ************************************************************************** */
-
-void TransferManagerDriver::protocol(const string& message) const
-{
-    istringstream           is(message);
-    ostringstream           os;
-
-    string                  action;
-    string                  result;
-
-    int                     id;
-    VirtualMachine *        vm;
-
-    os << "Message received: " << message;
-    NebulaLog::log("TM", Log::DEBUG, os);
-
-    // Parse the driver message
-    if ( is.good() )
-        is >> action >> ws;
-    else
-        return;
-
-    if ( is.good() )
-        is >> result >> ws;
-    else
-        return;
-
-    if ( is.good() )
-    {
-        is >> id >> ws;
-
-        if ( is.fail() )
-        {
-            if ( action == "LOG" )
-            {
-                string info;
-
-                is.clear();
-                getline(is,info);
-                NebulaLog::log("TM",log_type(result[0]), info.c_str());
-            }
-
-            return;
-        }
-    }
-    else
-        return;
-
-    // Get the VM from the pool
-    vm = vmpool->get(id);
-
-    if ( vm == 0 )
-    {
-        return;
-    }
-
-    if ( vm->get_lcm_state() == VirtualMachine::LCM_INIT )
-    {
-        os.str("");
-        os << "Ignored: " << message;
-        vm->log("TM",Log::WARNING,os);
-
-        vm->unlock();
-        return;
-    }
-
-    // Driver Actions
-    if (action == "TRANSFER")
-    {
-        Nebula              &ne = Nebula::instance();
-        LifeCycleManager *  lcm = ne.get_lcm();
-
-        LCMAction::Actions lcm_action;
-
-        if (result == "SUCCESS")
-        {
-            switch (vm->get_lcm_state())
-            {
-                case VirtualMachine::PROLOG:
-                case VirtualMachine::PROLOG_MIGRATE:
-                case VirtualMachine::PROLOG_RESUME:
-                case VirtualMachine::PROLOG_UNDEPLOY:
-                case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
-                case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
-                case VirtualMachine::PROLOG_MIGRATE_UNKNOWN:
-                    lcm_action = LCMAction::PROLOG_SUCCESS;
-                    break;
-
-                case VirtualMachine::EPILOG:
-                case VirtualMachine::EPILOG_STOP:
-                case VirtualMachine::EPILOG_UNDEPLOY:
-                case VirtualMachine::CLEANUP_RESUBMIT:
-                    lcm_action = LCMAction::EPILOG_SUCCESS;
-                    break;
-
-                case VirtualMachine::HOTPLUG_SAVEAS:
-                case VirtualMachine::HOTPLUG_SAVEAS_POWEROFF:
-                case VirtualMachine::HOTPLUG_SAVEAS_SUSPENDED:
-                    lcm_action = LCMAction::SAVEAS_SUCCESS;
-                    break;
-
-                case VirtualMachine::HOTPLUG_PROLOG_POWEROFF:
-                    lcm_action = LCMAction::ATTACH_SUCCESS;
-                    break;
-
-                case VirtualMachine::HOTPLUG_EPILOG_POWEROFF:
-                    lcm_action = LCMAction::DETACH_SUCCESS;
-                    break;
-
-                case VirtualMachine::DISK_SNAPSHOT_POWEROFF:
-                case VirtualMachine::DISK_SNAPSHOT_REVERT_POWEROFF:
-                case VirtualMachine::DISK_SNAPSHOT_DELETE_POWEROFF:
-                case VirtualMachine::DISK_SNAPSHOT_SUSPENDED:
-                case VirtualMachine::DISK_SNAPSHOT_REVERT_SUSPENDED:
-                case VirtualMachine::DISK_SNAPSHOT_DELETE_SUSPENDED:
-                case VirtualMachine::DISK_SNAPSHOT_DELETE:
-                    lcm_action = LCMAction::DISK_SNAPSHOT_SUCCESS;
-                    break;
-
-                case VirtualMachine::DISK_RESIZE_POWEROFF:
-                case VirtualMachine::DISK_RESIZE_UNDEPLOYED:
-                    lcm_action = LCMAction::DISK_RESIZE_SUCCESS;
-                    break;
-
-                default:
-                    goto error_state;
-            }
-        }
-        else
-        {
-            string info;
-
-            getline(is,info);
-
-            os.str("");
-            os << "Error executing image transfer script";
-
-            if (!info.empty() && info[0] != '-')
-            {
-                os << ": " << info;
-
-                vm->set_template_error_message(os.str());
-                vmpool->update(vm);
-            }
-
-            vm->log("TM",Log::ERROR,os);
-
-            switch (vm->get_lcm_state())
-            {
-                case VirtualMachine::PROLOG:
-                case VirtualMachine::PROLOG_MIGRATE:
-                case VirtualMachine::PROLOG_RESUME:
-                case VirtualMachine::PROLOG_UNDEPLOY:
-                case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
-                case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
-                case VirtualMachine::PROLOG_MIGRATE_UNKNOWN:
-                    lcm_action = LCMAction::PROLOG_FAILURE;
-                    break;
-
-                case VirtualMachine::EPILOG:
-                case VirtualMachine::EPILOG_STOP:
-                case VirtualMachine::EPILOG_UNDEPLOY:
-                case VirtualMachine::CLEANUP_RESUBMIT:
-                    lcm_action = LCMAction::EPILOG_FAILURE;
-                    break;
-
-                case VirtualMachine::HOTPLUG_SAVEAS:
-                case VirtualMachine::HOTPLUG_SAVEAS_POWEROFF:
-                case VirtualMachine::HOTPLUG_SAVEAS_SUSPENDED:
-                    lcm_action = LCMAction::SAVEAS_FAILURE;
-                    break;
-
-                case VirtualMachine::HOTPLUG_PROLOG_POWEROFF:
-                    lcm_action = LCMAction::ATTACH_FAILURE;
-                    break;
-
-                case VirtualMachine::HOTPLUG_EPILOG_POWEROFF:
-                    lcm_action = LCMAction::DETACH_FAILURE;
-                    break;
-
-                case VirtualMachine::DISK_SNAPSHOT_POWEROFF:
-                case VirtualMachine::DISK_SNAPSHOT_REVERT_POWEROFF:
-                case VirtualMachine::DISK_SNAPSHOT_DELETE_POWEROFF:
-                case VirtualMachine::DISK_SNAPSHOT_SUSPENDED:
-                case VirtualMachine::DISK_SNAPSHOT_REVERT_SUSPENDED:
-                case VirtualMachine::DISK_SNAPSHOT_DELETE_SUSPENDED:
-                case VirtualMachine::DISK_SNAPSHOT_DELETE:
-                    lcm_action = LCMAction::DISK_SNAPSHOT_FAILURE;
-                    break;
-
-                case VirtualMachine::DISK_RESIZE_POWEROFF:
-                case VirtualMachine::DISK_RESIZE_UNDEPLOYED:
-                    lcm_action = LCMAction::DISK_RESIZE_FAILURE;
-                    break;
-
-                default:
-                    goto error_state;
-            }
-        }
-
-        lcm->trigger(lcm_action, id);
-    }
-    else if (action == "LOG")
-    {
-        string info;
-
-        getline(is,info);
-        vm->log("TM",log_type(result[0]),info.c_str());
-    }
-
-    vm->unlock();
-
-    return;
-
-error_state:
-    os.str("");
-    os << "Wrong state in TM answer for VM " << id;
-
-    vm->log("TM",Log::ERROR,os);
-
-    vm->unlock();
-
-    return;
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void TransferManagerDriver::recover()
-{
-    NebulaLog::log("TM",Log::INFO,"Recovering TM drivers");
-}
diff --git a/src/tm/TransferManagerProtocol.cc b/src/tm/TransferManagerProtocol.cc
new file mode 100644
index 0000000000..c39fba7583
--- /dev/null
+++ b/src/tm/TransferManagerProtocol.cc
@@ -0,0 +1,223 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "TransferManager.h"
+#include "LifeCycleManager.h"
+#include "Nebula.h"
+#include "NebulaLog.h"
+
+/* ************************************************************************** */
+/* Driver Protocol Implementation                                             */
+/* ************************************************************************** */
+
+void TransferManager::_undefined(unique_ptr<transfer_msg_t> msg)
+{
+    NebulaLog::warn("TrM", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void TransferManager::_transfer(unique_ptr<transfer_msg_t> msg)
+{
+    string msg_str;
+
+    msg->write_to(msg_str);
+    NebulaLog::debug("TrM", "Message received: " + msg_str);
+
+    ostringstream oss;
+
+    LifeCycleManager * lcm = Nebula::instance().get_lcm();
+
+    LCMAction::Actions lcm_action;
+
+    int id = msg->oid();
+
+    // Get the VM from the pool
+    auto vm = vmpool->get(id);
+
+    if (vm == nullptr)
+    {
+        return;
+    }
+
+    if (vm->get_lcm_state() == VirtualMachine::LCM_INIT)
+    {
+        oss.str("");
+        oss << "Ignored: " << msg_str;
+        vm->log("TrM", Log::WARNING, oss);
+
+        vm->unlock();
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        switch (vm->get_lcm_state())
+        {
+            case VirtualMachine::PROLOG:
+            case VirtualMachine::PROLOG_MIGRATE:
+            case VirtualMachine::PROLOG_RESUME:
+            case VirtualMachine::PROLOG_UNDEPLOY:
+            case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
+            case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
+            case VirtualMachine::PROLOG_MIGRATE_UNKNOWN:
+                lcm_action = LCMAction::PROLOG_SUCCESS;
+                break;
+
+            case VirtualMachine::EPILOG:
+            case VirtualMachine::EPILOG_STOP:
+            case VirtualMachine::EPILOG_UNDEPLOY:
+            case VirtualMachine::CLEANUP_RESUBMIT:
+                lcm_action = LCMAction::EPILOG_SUCCESS;
+                break;
+
+            case VirtualMachine::HOTPLUG_SAVEAS:
+            case VirtualMachine::HOTPLUG_SAVEAS_POWEROFF:
+            case VirtualMachine::HOTPLUG_SAVEAS_SUSPENDED:
+                lcm_action = LCMAction::SAVEAS_SUCCESS;
+                break;
+
+            case VirtualMachine::HOTPLUG_PROLOG_POWEROFF:
+                lcm_action = LCMAction::ATTACH_SUCCESS;
+                break;
+
+            case VirtualMachine::HOTPLUG_EPILOG_POWEROFF:
+                lcm_action = LCMAction::DETACH_SUCCESS;
+                break;
+
+            case VirtualMachine::DISK_SNAPSHOT_POWEROFF:
+            case VirtualMachine::DISK_SNAPSHOT_REVERT_POWEROFF:
+            case VirtualMachine::DISK_SNAPSHOT_DELETE_POWEROFF:
+            case VirtualMachine::DISK_SNAPSHOT_SUSPENDED:
+            case VirtualMachine::DISK_SNAPSHOT_REVERT_SUSPENDED:
+            case VirtualMachine::DISK_SNAPSHOT_DELETE_SUSPENDED:
+            case VirtualMachine::DISK_SNAPSHOT_DELETE:
+                lcm_action = LCMAction::DISK_SNAPSHOT_SUCCESS;
+                break;
+
+            case VirtualMachine::DISK_RESIZE_POWEROFF:
+            case VirtualMachine::DISK_RESIZE_UNDEPLOYED:
+                lcm_action = LCMAction::DISK_RESIZE_SUCCESS;
+                break;
+
+            default:
+                goto error_state;
+        }
+    }
+    else
+    {
+        const string& info = msg->payload();
+
+        oss.str("");
+        oss << "Error executing image transfer script";
+
+        if (!info.empty() && info[0] != '-')
+        {
+            oss << ": " << info;
+
+            vm->set_template_error_message(oss.str());
+            vmpool->update(vm);
+        }
+
+        vm->log("TrM", Log::ERROR, oss);
+
+        switch (vm->get_lcm_state())
+        {
+            case VirtualMachine::PROLOG:
+            case VirtualMachine::PROLOG_MIGRATE:
+            case VirtualMachine::PROLOG_RESUME:
+            case VirtualMachine::PROLOG_UNDEPLOY:
+            case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
+            case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
+            case VirtualMachine::PROLOG_MIGRATE_UNKNOWN:
+                lcm_action = LCMAction::PROLOG_FAILURE;
+                break;
+
+            case VirtualMachine::EPILOG:
+            case VirtualMachine::EPILOG_STOP:
+            case VirtualMachine::EPILOG_UNDEPLOY:
+            case VirtualMachine::CLEANUP_RESUBMIT:
+                lcm_action = LCMAction::EPILOG_FAILURE;
+                break;
+
+            case VirtualMachine::HOTPLUG_SAVEAS:
+            case VirtualMachine::HOTPLUG_SAVEAS_POWEROFF:
+            case VirtualMachine::HOTPLUG_SAVEAS_SUSPENDED:
+                lcm_action = LCMAction::SAVEAS_FAILURE;
+                break;
+
+            case VirtualMachine::HOTPLUG_PROLOG_POWEROFF:
+                lcm_action = LCMAction::ATTACH_FAILURE;
+                break;
+
+            case VirtualMachine::HOTPLUG_EPILOG_POWEROFF:
+                lcm_action = LCMAction::DETACH_FAILURE;
+                break;
+
+            case VirtualMachine::DISK_SNAPSHOT_POWEROFF:
+            case VirtualMachine::DISK_SNAPSHOT_REVERT_POWEROFF:
+            case VirtualMachine::DISK_SNAPSHOT_DELETE_POWEROFF:
+            case VirtualMachine::DISK_SNAPSHOT_SUSPENDED:
+            case VirtualMachine::DISK_SNAPSHOT_REVERT_SUSPENDED:
+            case VirtualMachine::DISK_SNAPSHOT_DELETE_SUSPENDED:
+            case VirtualMachine::DISK_SNAPSHOT_DELETE:
+                lcm_action = LCMAction::DISK_SNAPSHOT_FAILURE;
+                break;
+
+            case VirtualMachine::DISK_RESIZE_POWEROFF:
+            case VirtualMachine::DISK_RESIZE_UNDEPLOYED:
+                lcm_action = LCMAction::DISK_RESIZE_FAILURE;
+                break;
+
+            default:
+                goto error_state;
+        }
+    }
+
+    lcm->trigger(lcm_action, id);
+
+    vm->unlock();
+
+    return;
+
+error_state:
+    oss.str("");
+    oss << "Wrong state in TrM answer for VM " << id;
+
+    vm->log("TrM", Log::ERROR, oss);
+
+    vm->unlock();
+
+    return;
+
+}
+
+/* -------------------------------------------------------------------------- */
+
+void TransferManager::_log(unique_ptr<transfer_msg_t> msg)
+{
+    if (msg->oid() < 0)
+    {
+        NebulaLog::log("TrM", log_type(msg->status()[0]), msg->payload());
+    }
+    else
+    {
+        auto vm = Nebula::instance().get_vmpool()->get_ro(msg->oid());
+        vm->log("TrM", log_type(msg->status()[0]), msg->payload());
+
+        vm->unlock();
+    }
+}
diff --git a/src/um/QuotasSQL.cc b/src/um/QuotasSQL.cc
index 6f6041bd65..9c5c849836 100644
--- a/src/um/QuotasSQL.cc
+++ b/src/um/QuotasSQL.cc
@@ -170,31 +170,3 @@ int QuotasSQL::drop(SqlDB *db)
 
     return rc;
 }
-
-/* ************************************************************************** */
-/* UserQuotas :: Database Access Functions                                    */
-/* ************************************************************************** */
-
-const char * UserQuotas::db_table = "user_quotas";
-
-const char * UserQuotas::db_names = "user_oid, body";
-
-const char * UserQuotas::db_oid_column = "user_oid";
-
-const char * UserQuotas::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS user_quotas ("
-    "user_oid INTEGER PRIMARY KEY, body MEDIUMTEXT)";
-
-/* ************************************************************************** */
-/* GroupQuotas :: Database Access Functions                                   */
-/* ************************************************************************** */
-
-const char * GroupQuotas::db_table = "group_quotas";
-
-const char * GroupQuotas::db_names = "group_oid, body";
-
-const char * GroupQuotas::db_oid_column = "group_oid";
-
-const char * GroupQuotas::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS group_quotas ("
-    "group_oid INTEGER PRIMARY KEY, body MEDIUMTEXT)";
diff --git a/src/um/User.cc b/src/um/User.cc
index cedadbbaa0..c3f191dca5 100644
--- a/src/um/User.cc
+++ b/src/um/User.cc
@@ -28,19 +28,6 @@ const string User::INVALID_PASS_CHARS = " \t\n\v\f\r";
 /* User :: Database Access Functions                                          */
 /* ************************************************************************** */
 
-const char * User::table = "user_pool";
-
-const char * User::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * User::db_bootstrap = "CREATE TABLE IF NOT EXISTS user_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name))";
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
 int User::select(SqlDB * db)
 {
     int rc;
@@ -145,7 +132,7 @@ int User::insert_replace(SqlDB *db, bool replace, string& error_str)
     // Construct the SQL statement to Insert or Replace
     if (replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::user_table << " SET "
             << "name = '"    <<   sql_username    << "', "
             << "body = '"    <<   sql_xml         << "', "
             << "uid = "      <<   uid             << ", "
@@ -157,7 +144,8 @@ int User::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::user_table
+            << " (" << one_db::user_db_names << ") VALUES ("
             <<          oid             << ","
             << "'" <<   sql_username    << "',"
             << "'" <<   sql_xml         << "',"
diff --git a/src/um/UserPool.cc b/src/um/UserPool.cc
index 8ab136f11e..dc42e6677d 100644
--- a/src/um/UserPool.cc
+++ b/src/um/UserPool.cc
@@ -52,7 +52,8 @@ string UserPool::oneadmin_name;
 /* -------------------------------------------------------------------------- */
 
 UserPool::UserPool(SqlDB * db, time_t __session_expiration_time, bool is_slave,
-        vector<const SingleAttribute *>& restricted_attrs):PoolSQL(db, User::table)
+        vector<const SingleAttribute *>& restricted_attrs)
+    : PoolSQL(db, one_db::user_table)
 {
     int one_uid    = -1;
     int server_uid = -1;
@@ -1442,10 +1443,10 @@ int UserPool::dump(string& oss, const string& where, int sid, int eid, bool desc
 
     ostringstream cmd;
 
-    cmd << "SELECT " << User::table << ".body, "
-        << UserQuotas::db_table << ".body"<< " FROM " << User::table
-        << " LEFT JOIN " << UserQuotas::db_table << " ON "
-        << User::table << ".oid=" << UserQuotas::db_table << ".user_oid";
+    cmd << "SELECT " << one_db::user_table << ".body, "
+        << one_db::user_quotas_db_table << ".body"<< " FROM " << one_db::user_table
+        << " LEFT JOIN " << one_db::user_quotas_db_table << " ON "
+        << one_db::user_table << ".oid=" << one_db::user_quotas_db_table << ".user_oid";
 
     if ( !where.empty() )
     {
diff --git a/src/vdc/Vdc.cc b/src/vdc/Vdc.cc
index 9d0546291d..4d9c2a3871 100644
--- a/src/vdc/Vdc.cc
+++ b/src/vdc/Vdc.cc
@@ -22,21 +22,11 @@
 
 const int    Vdc::ALL_RESOURCES = -10;
 
-const char * Vdc::table = "vdc_pool";
-
-const char * Vdc::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * Vdc::db_bootstrap = "CREATE TABLE IF NOT EXISTS vdc_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name))";
-
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 Vdc::Vdc(int id, Template* vdc_template):
-        PoolObjectSQL(id, VDC, "", -1, -1, "", "", table),
+        PoolObjectSQL(id, VDC, "", -1, -1, "", "", one_db::vdc_table),
         clusters(PoolObjectSQL::CLUSTER),
         hosts(PoolObjectSQL::HOST),
         datastores(PoolObjectSQL::DATASTORE),
@@ -124,7 +114,7 @@ int Vdc::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::vdc_table << " SET "
             << "name = '"    <<   sql_name   << "', "
             << "body = '"    <<   sql_xml    << "', "
             << "uid = "      <<   uid        << ", "
@@ -136,7 +126,8 @@ int Vdc::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::vdc_table
+            << " (" << one_db::vdc_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -175,6 +166,15 @@ error_common:
     return -1;
 }
 
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+int Vdc::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::vdc_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
diff --git a/src/vdc/VdcPool.cc b/src/vdc/VdcPool.cc
index ce6bd8264b..7749f6b4e9 100644
--- a/src/vdc/VdcPool.cc
+++ b/src/vdc/VdcPool.cc
@@ -25,7 +25,8 @@ const int    VdcPool::DEFAULT_ID   = 0;
 
 /* -------------------------------------------------------------------------- */
 
-VdcPool::VdcPool(SqlDB * db, bool is_federation_slave): PoolSQL(db, Vdc::table)
+VdcPool::VdcPool(SqlDB * db, bool is_federation_slave)
+    : PoolSQL(db, one_db::vdc_table)
 {
     string error_str;
 
diff --git a/src/vm/History.cc b/src/vm/History.cc
index 37a138b14c..2d9c4d2c07 100644
--- a/src/vm/History.cc
+++ b/src/vm/History.cc
@@ -16,6 +16,7 @@
 
 #include "VirtualMachine.h"
 #include "Nebula.h"
+#include "OneDB.h"
 
 #include <iostream>
 #include <sstream>
@@ -23,17 +24,6 @@
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-const char * History::table = "history";
-
-const char * History::db_names = "vid, seq, body, stime, etime";
-
-const char * History::db_bootstrap = "CREATE TABLE IF NOT EXISTS "
-    "history (vid INTEGER, seq INTEGER, body MEDIUMTEXT, "
-    "stime INTEGER, etime INTEGER,PRIMARY KEY(vid,seq))";
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
 History::History(
     int _oid,
     int _seq):
@@ -177,7 +167,7 @@ int History::insert_replace(SqlDB *db, bool replace)
 
     if(replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::history_table << " SET "
             << "body = '"  <<  sql_xml  << "', "
             << "stime = "  <<  stime    << ", "
             << "etime = "  <<  etime
@@ -185,7 +175,8 @@ int History::insert_replace(SqlDB *db, bool replace)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::history_table
+            << " (" << one_db::history_db_names << ") VALUES ("
             <<          oid             << ","
             <<          seq             << ","
             << "'" <<   sql_xml         << "',"
@@ -266,7 +257,7 @@ int History::drop(SqlDB * db)
 {
     ostringstream   oss;
 
-    oss << "DELETE FROM " << table << " WHERE vid= "<< oid;
+    oss << "DELETE FROM " << one_db::history_table << " WHERE vid= "<< oid;
 
     return db->exec_wr(oss);
 }
diff --git a/src/vm/VirtualMachine.cc b/src/vm/VirtualMachine.cc
index 53967cf9f6..00307d137f 100644
--- a/src/vm/VirtualMachine.cc
+++ b/src/vm/VirtualMachine.cc
@@ -469,7 +469,7 @@ int VirtualMachine::bootstrap(SqlDB * db)
     }
 
     ostringstream oss_monit(one_db::vm_monitor_db_bootstrap);
-    ostringstream oss_hist(History::db_bootstrap);
+    ostringstream oss_hist(one_db::history_db_bootstrap);
     ostringstream oss_showback(one_db::vm_showback_db_bootstrap);
 
     ostringstream oss_index("CREATE INDEX state_oid_idx on vm_pool (state, oid);");
diff --git a/src/vm/VirtualMachinePool.cc b/src/vm/VirtualMachinePool.cc
index 3152b4bf7e..f6f32c1a92 100644
--- a/src/vm/VirtualMachinePool.cc
+++ b/src/vm/VirtualMachinePool.cc
@@ -261,7 +261,8 @@ int VirtualMachinePool::dump_acct(string& oss, const string&  where,
 {
     ostringstream cmd;
 
-    cmd << "SELECT " << History::table << ".body FROM " << History::table
+    cmd << "SELECT " << one_db::history_table << ".body FROM "
+        << one_db::history_table
         << " INNER JOIN " << one_db::vm_table << " ON vid=oid";
 
     if ( !where.empty() )
@@ -549,7 +550,7 @@ int VirtualMachinePool::calculate_showback(
 
         cb.set_callback(&start_time);
 
-        oss << "SELECT MIN(stime) FROM " << History::table;
+        oss << "SELECT MIN(stime) FROM " << one_db::history_table;
 
         rc = db->exec_rd(oss, &cb);
 
diff --git a/src/vm_group/VMGroup.cc b/src/vm_group/VMGroup.cc
index 1815c04ce6..4255731b00 100644
--- a/src/vm_group/VMGroup.cc
+++ b/src/vm_group/VMGroup.cc
@@ -17,6 +17,7 @@
 #include "VMGroup.h"
 #include "VMGroupRole.h"
 #include "VMGroupRule.h"
+#include "OneDB.h"
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -24,21 +25,9 @@
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-const char * VMGroup::table = "vmgroup_pool";
-
-const char * VMGroup::db_names = "oid, name, body, uid, gid, owner_u, group_u, "
-    "other_u";
-
-const char * VMGroup::db_bootstrap = "CREATE TABLE IF NOT EXISTS vmgroup_pool "
-    "(oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, "
-    "uid INTEGER, gid INTEGER, owner_u INTEGER, group_u INTEGER, "
-    "other_u INTEGER, UNIQUE(name,uid))";
-
-/* ------------------------------------------------------------------------ */
-
 VMGroup::VMGroup(int _uid, int _gid, const string& _uname, const string& _gname,
         int _umask, Template * group_template):
-    PoolObjectSQL(-1, VMGROUP, "", _uid, _gid, _uname, _gname, table)
+    PoolObjectSQL(-1, VMGROUP, "", _uid, _gid, _uname, _gname, one_db::vm_group_table)
 {
     if (group_template != 0)
     {
@@ -174,7 +163,7 @@ int VMGroup::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::vm_group_table << " SET "
             << "name = '"    <<  sql_name  << "', "
             << "body = '"    <<  sql_xml   << "', "
             << "uid = "      <<  uid       << ", "
@@ -186,7 +175,8 @@ int VMGroup::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::vm_group_table
+            << " (" << one_db::vm_group_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -228,6 +218,16 @@ error_common:
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
+int VMGroup::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::vm_group_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+
 int VMGroup::check_rule_names(VMGroupPolicy policy, std::string& error)
 {
     vector<const SingleAttribute *> affined;
diff --git a/src/vm_template/VMTemplate.cc b/src/vm_template/VMTemplate.cc
index bfd769a909..11c742adc6 100644
--- a/src/vm_template/VMTemplate.cc
+++ b/src/vm_template/VMTemplate.cc
@@ -18,6 +18,7 @@
 #include "Nebula.h"
 #include "VirtualMachineManager.h"
 #include "ScheduledAction.h"
+#include "OneDB.h"
 
 /* ************************************************************************ */
 /* VMTemplate :: Constructor/Destructor                                     */
@@ -30,8 +31,8 @@ VMTemplate::VMTemplate(int id,
                        const string& _gname,
                        int umask,
                        VirtualMachineTemplate * _template_contents):
-        PoolObjectSQL(id,TEMPLATE,"",_uid,_gid,_uname,_gname,table),
-        regtime(time(0))
+    PoolObjectSQL(id,TEMPLATE,"",_uid,_gid,_uname,_gname,one_db::vm_template_table),
+    regtime(time(0))
 {
     if (_template_contents != 0)
     {
@@ -49,19 +50,6 @@ VMTemplate::VMTemplate(int id,
 /* VMTemplate :: Database Access Functions                                  */
 /* ************************************************************************ */
 
-const char * VMTemplate::table = "template_pool";
-
-const char * VMTemplate::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * VMTemplate::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS template_pool (oid INTEGER PRIMARY KEY, "
-    "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
-    "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 int VMTemplate::insert(SqlDB *db, string& error_str)
 {
     // ---------------------------------------------------------------------
@@ -131,7 +119,7 @@ int VMTemplate::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if(replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::vm_template_table << " SET "
             << "name = '"      << sql_name   << "', "
             << "body = '"      << sql_xml    << "', "
             << "uid = "        << uid        << ", "
@@ -143,7 +131,8 @@ int VMTemplate::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::vm_template_table
+            << " (" << one_db::vm_template_db_names << ") VALUES ("
             <<            oid        << ","
             << "'"     << sql_name   << "',"
             << "'"     << sql_xml    << "',"
@@ -182,6 +171,19 @@ error_common:
     return -1;
 }
 
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+int VMTemplate::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::vm_template_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
 int VMTemplate::parse_sched_action(string& error_str)
 {
     SchedActions sactions(obj_template);
diff --git a/src/vmm/SConstruct b/src/vmm/SConstruct
index c67420c2f5..a3adc76f25 100644
--- a/src/vmm/SConstruct
+++ b/src/vmm/SConstruct
@@ -24,6 +24,7 @@ lib_name='nebula_vmm'
 source_files=[
     'VirtualMachineManager.cc',
     'VirtualMachineManagerDriver.cc',
+    'VirtualMachineManagerProtocol.cc',
     'XenDriver.cc',
     'LibVirtDriverKVM.cc',
     'XMLDriver.cc'
diff --git a/src/vmm/VirtualMachineManager.cc b/src/vmm/VirtualMachineManager.cc
index c0da7e5343..9734b2b9d7 100644
--- a/src/vmm/VirtualMachineManager.cc
+++ b/src/vmm/VirtualMachineManager.cc
@@ -34,8 +34,8 @@
 VirtualMachineManager::VirtualMachineManager(
     time_t                          _timer_period,
     int                             _vm_limit,
-    vector<const VectorAttribute*>&       _mads):
-        MadManager(_mads),
+    const string&                   _mad_location):
+        DriverManager(_mad_location),
         timer_period(_timer_period),
         vm_limit(_vm_limit)
 {
@@ -76,12 +76,81 @@ extern "C" void * vmm_action_loop(void *arg)
 
 int VirtualMachineManager::start()
 {
-    int               rc;
     pthread_attr_t    pattr;
 
-    rc = MadManager::start();
+    using namespace std::placeholders; // for _1
 
-    if ( rc != 0 )
+    register_action(VMManagerMessages::UNDEFINED,
+            &VirtualMachineManager::_undefined);
+
+    register_action(VMManagerMessages::DEPLOY,
+            bind(&VirtualMachineManager::_deploy, this, _1));
+
+    register_action(VMManagerMessages::SHUTDOWN,
+            bind(&VirtualMachineManager::_shutdown, this, _1));
+
+    register_action(VMManagerMessages::RESET,
+            bind(&VirtualMachineManager::_reboot, this, _1));
+
+    register_action(VMManagerMessages::CANCEL,
+            bind(&VirtualMachineManager::_cancel, this, _1));
+
+    register_action(VMManagerMessages::CLEANUP,
+            bind(&VirtualMachineManager::_cleanup, this, _1));
+
+    register_action(VMManagerMessages::CHECKPOINT,
+            bind(&VirtualMachineManager::_checkpoint, this, _1));
+
+    register_action(VMManagerMessages::SAVE,
+            bind(&VirtualMachineManager::_save, this, _1));
+
+    register_action(VMManagerMessages::RESTORE,
+            bind(&VirtualMachineManager::_restore, this, _1));
+
+    register_action(VMManagerMessages::MIGRATE,
+            bind(&VirtualMachineManager::_migrate, this, _1));
+
+    register_action(VMManagerMessages::ATTACHDISK,
+            bind(&VirtualMachineManager::_attachdisk, this, _1));
+
+    register_action(VMManagerMessages::DETACHDISK,
+            bind(&VirtualMachineManager::_detachdisk, this, _1));
+
+    register_action(VMManagerMessages::ATTACHNIC,
+            bind(&VirtualMachineManager::_attachnic, this, _1));
+
+    register_action(VMManagerMessages::DETACHNIC,
+            bind(&VirtualMachineManager::_detachnic, this, _1));
+
+    register_action(VMManagerMessages::SNAPSHOTCREATE,
+            bind(&VirtualMachineManager::_snapshotcreate, this, _1));
+
+    register_action(VMManagerMessages::SNAPSHOTREVERT,
+            bind(&VirtualMachineManager::_snapshotrevert, this, _1));
+
+    register_action(VMManagerMessages::SNAPSHOTDELETE,
+            bind(&VirtualMachineManager::_snapshotdelete, this, _1));
+
+    register_action(VMManagerMessages::DISKSNAPSHOTCREATE,
+            bind(&VirtualMachineManager::_disksnapshotcreate, this, _1));
+
+    register_action(VMManagerMessages::RESIZEDISK,
+            bind(&VirtualMachineManager::_resizedisk, this, _1));
+
+    register_action(VMManagerMessages::UPDATECONF,
+            bind(&VirtualMachineManager::_updateconf, this, _1));
+
+    register_action(VMManagerMessages::UPDATESG,
+            bind(&VirtualMachineManager::_updatesg, this, _1));
+
+    register_action(VMManagerMessages::DRIVER_CANCEL,
+            bind(&VirtualMachineManager::_driver_cancel, this, _1));
+
+    register_action(VMManagerMessages::LOG,
+            &VirtualMachineManager::_log);
+
+    string error;
+    if ( DriverManager::start(error) != 0 )
     {
         return -1;
     }
@@ -91,7 +160,7 @@ int VirtualMachineManager::start()
     pthread_attr_init(&pattr);
     pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE);
 
-    rc = pthread_create(&vmm_thread,&pattr,vmm_action_loop,(void *) this);
+    int rc = pthread_create(&vmm_thread,&pattr,vmm_action_loop,(void *) this);
 
     return rc;
 };
@@ -197,7 +266,7 @@ int VirtualMachineManager::validate_raw(const Template * vmt, string& error_str)
 
     const VirtualMachineManagerDriver * vmd = get(value);
 
-    if ( vmd == 0 )
+    if ( vmd == nullptr )
     {
         error_str = "Invalid RAW section: unsupported TYPE";
         return -1;
@@ -2477,28 +2546,22 @@ int VirtualMachineManager::updatesg(VirtualMachine * vm, int sgid)
 /* MAD Loading                                                                */
 /* ************************************************************************** */
 
-int VirtualMachineManager::load_mads(int uid)
+int VirtualMachineManager::load_drivers(const vector<const VectorAttribute*>& _mads)
 {
-    unsigned int                    i;
-    ostringstream                   oss;
-    const VectorAttribute *         vattr;
-    int                             rc;
-    string                          name;
-    string                          type;
-    VirtualMachineManagerDriver *   vmm_driver = nullptr;
+    int           rc;
+    const string& mad_location = Nebula::instance().get_mad_location();
 
-    oss << "Loading Virtual Machine Manager drivers.";
+    NebulaLog::info("VMM", "Loading Virtual Machine Manager drivers.");
 
-    NebulaLog::log("VMM",Log::INFO,oss);
-
-    for (i=0, oss.str(""); i<mad_conf.size(); i++, oss.str(""), vmm_driver=0)
+    for (auto vattr : _mads)
     {
-        vattr = static_cast<const VectorAttribute *>(mad_conf[i]);
+        ostringstream                   oss;
+        VirtualMachineManagerDriver *   vmm_driver = nullptr;
 
-        name  = vattr->vector_value("NAME");
-        type  = vattr->vector_value("TYPE");
+        string name  = vattr->vector_value("NAME");
+        string type  = vattr->vector_value("TYPE");
 
-        transform(type.begin(), type.end(), type.begin(), (int(*)(int))toupper);
+        one_util::toupper(type);
 
         oss << "\tLoading driver: " << name << " (" << type << ")";
 
@@ -2506,21 +2569,19 @@ int VirtualMachineManager::load_mads(int uid)
 
         if ( type == "XEN" )
         {
-            vmm_driver = new XenDriver(uid, vattr->value(),(uid != 0),vmpool);
+            vmm_driver = new XenDriver(mad_location, vattr->value());
         }
         else if ( type == "KVM" )
         {
-            vmm_driver = new LibVirtDriver(uid, vattr->value(),
-                                           (uid != 0),vmpool,"kvm");
+            vmm_driver = new LibVirtDriver(mad_location, vattr->value(), "kvm");
         }
         else if ( type == "QEMU" )
         {
-            vmm_driver = new LibVirtDriver(uid, vattr->value(),
-                                           (uid != 0),vmpool,"qemu");
+            vmm_driver = new LibVirtDriver(mad_location, vattr->value(), "qemu");
         }
         else if ( type == "XML" )
         {
-            vmm_driver = new XMLDriver(uid, vattr->value(),(uid != 0),vmpool);
+            vmm_driver = new XMLDriver(mad_location, vattr->value());
         }
         else
         {
@@ -2532,19 +2593,17 @@ int VirtualMachineManager::load_mads(int uid)
             continue;
         }
 
-        rc = add(vmm_driver);
+        rc = add(name, unique_ptr<VirtualMachineManagerDriver>(vmm_driver));
 
-        if ( rc == 0 )
-        {
-            oss.str("");
-            oss << "\tDriver " << name << " loaded.";
-
-            NebulaLog::log("VMM",Log::INFO,oss);
-        }
-        else
+        if ( rc != 0 )
         {
             return rc;
         }
+
+        oss.str("");
+        oss << "\tDriver " << name << " loaded.";
+
+        NebulaLog::log("VMM",Log::INFO,oss);
     }
 
     return 0;
diff --git a/src/vmm/VirtualMachineManagerDriver.cc b/src/vmm/VirtualMachineManagerDriver.cc
index 0d3d9d3c4c..423e773177 100644
--- a/src/vmm/VirtualMachineManagerDriver.cc
+++ b/src/vmm/VirtualMachineManagerDriver.cc
@@ -34,21 +34,21 @@ const string VirtualMachineManagerDriver::imported_actions_default_public =
     "nic-detach, snap-create, snap-delete, poweroff, poweroff-hard";
 
 VirtualMachineManagerDriver::VirtualMachineManagerDriver(
-    int                         userid,
-    const map<string,string>&   attrs,
-    bool                        sudo,
-    VirtualMachinePool *        pool):
-        Mad(userid,attrs,sudo), driver_conf(true), keep_snapshots(false),
-        ds_live_migration(false), cold_nic_attach(false), vmpool(pool)
+    const string             &mad_location,
+    const map<string,string> &attrs):
+        Driver(),
+        driver_conf(true),
+        keep_snapshots(false),
+        ds_live_migration(false),
+        cold_nic_attach(false)
 {
-    map<string,string>::const_iterator  it;
     char *          error_msg = nullptr;
     const char *    cfile;
     string          file;
     int             rc;
     string          action_defaults;
 
-    it = attrs.find("DEFAULT");
+    auto it = attrs.find("DEFAULT");
 
     if ( it != attrs.end() )
     {
@@ -139,16 +139,14 @@ VirtualMachineManagerDriver::VirtualMachineManagerDriver(
     }
 
     vector<string> actions;
-    vector<string>::iterator vit;
 
-    string action;
     VMActions::Action id;
 
     actions = one_util::split(action_defaults, ',');
 
-    for (vit = actions.begin() ; vit != actions.end() ; ++vit)
+    for (auto action : actions)
     {
-        action = one_util::trim(*vit);
+        action = one_util::trim(action);
 
         if ( VMActions::action_from_str(action, id) != 0 )
         {
@@ -159,535 +157,33 @@ VirtualMachineManagerDriver::VirtualMachineManagerDriver(
         imported_actions.set(id);
     }
 
-}
-
-/* ************************************************************************** */
-/* MAD Interface                                                              */
-/* ************************************************************************** */
-
-/* -------------------------------------------------------------------------- */
-/* Helpers for the protocol function                                          */
-/* -------------------------------------------------------------------------- */
-
-static void log_error(VirtualMachine* vm,
-                      ostringstream&  os,
-                      istringstream&  is,
-                      const char *    msg)
-{
-    string info;
-
-    getline(is,info);
-
-    os.str("");
-    os << msg;
-
-    if (!info.empty() && info[0] != '-')
-    {
-        os << ": " << info;
-        vm->set_template_error_message(os.str());
-    }
-
-    vm->log("VMM",Log::ERROR,os);
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void VirtualMachineManagerDriver::protocol(const string& message) const
-{
-    istringstream is(message);
-    ostringstream os;
-
-    string action;
-    string result;
-
-    int              id;
-    VirtualMachine * vm;
-
-    Nebula              &ne = Nebula::instance();
-    LifeCycleManager *  lcm = ne.get_lcm();
-
-    os << "Message received: " << message;
-    NebulaLog::log("VMM", Log::DEBUG, os);
-
-    // -------------------------------------------------------------------------
-    // Parse the driver message: action, result and VM id
-    // -------------------------------------------------------------------------
-    if ( is.good() )
-    {
-        is >> action >> ws;
-    }
-    else
-    {
-        return;
-    }
-
-    if ( is.good() )
-    {
-        is >> result >> ws;
-    }
-    else
-    {
-        return;
-    }
-
-    if ( is.good() )
-    {
-        is >> id >> ws;
-
-        if ( is.fail() )
-        {
-            if ( action == "LOG" )
-            {
-                string info;
-
-                is.clear();
-                getline(is,info);
-                NebulaLog::log("VMM", log_type(result[0]), info.c_str());
-            }
-
-            return;
-        }
-    }
-    else
-    {
-        return;
-    }
-
-    // -------------------------------------------------------------------------
-    // VMM actions not associated to a single VM: UPDATESG
-    // -------------------------------------------------------------------------
-    if ( action == "UPDATESG" )
-    {
-        int sgid;
-
-        is >> sgid >> ws;
-
-        if ( is.fail() )
-        {
-            NebulaLog::log("VMM", Log::ERROR, "Missing or wrong security group"
-                    " id in driver message");
-            return;
-        }
-
-        SecurityGroupPool* sgpool = ne.get_secgrouppool();
-        SecurityGroup*     sg     = sgpool->get(sgid);
-
-        if ( sg != nullptr )
-        {
-            sg->del_updating(id);
-
-            if ( result == "SUCCESS" )
-            {
-                sg->add_vm(id);
-            }
-            else
-            {
-                sg->add_error(id);
-            }
-
-            sgpool->update(sg);
-
-            sg->unlock();
-        }
-
-        vm = vmpool->get(id);
-
-        if ( vm != nullptr )
-        {
-            if ( result == "SUCCESS" )
-            {
-                vm->log("VMM", Log::INFO, "VM security group updated.");
-            }
-            else
-            {
-                log_error(vm, os, is, "Error updating security groups.");
-
-                vmpool->update(vm);
-            }
-
-            vm->unlock();
-        }
-
-        lcm->trigger(LCMAction::UPDATESG, sgid);
-        return;
-    }
-
-    // -------------------------------------------------------------------------
-    // VMM actions associated to a single VM
-    // -------------------------------------------------------------------------
-    vm = vmpool->get(id);
-
-    if ( vm == nullptr )
-    {
-        return;
-    }
-
-    if ( vm->get_lcm_state() == VirtualMachine::LCM_INIT )
-    {
-        os.str("");
-        os << "Ignored: " << message;
-        vm->log("VMM",Log::WARNING,os);
-
-        vm->unlock();
-        return;
-    }
-
-    if ( action == "DEPLOY" )
-    {
-        LCMAction::Actions action = LCMAction::DEPLOY_SUCCESS;
-
-        if (result == "SUCCESS")
-        {
-            string deploy_id;
-
-            is >> deploy_id;
-
-            if ( !deploy_id.empty() )
-            {
-                vm->set_deploy_id(deploy_id);
-            }
-            else
-            {
-                action = LCMAction::DEPLOY_FAILURE;
-                log_error(vm,os,is,"Empty deploy ID for virtual machine");
-            }
-        }
-        else
-        {
-            action = LCMAction::DEPLOY_FAILURE;
-            log_error(vm,os,is,"Error deploying virtual machine");
-        }
-
-        vmpool->update(vm);
-
-        lcm->trigger(action, id);
-    }
-    else if (action == "SHUTDOWN" )
-    {
-        if (result == "SUCCESS")
-        {
-            lcm->trigger(LCMAction::SHUTDOWN_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error shutting down VM");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::SHUTDOWN_FAILURE, id);
-        }
-    }
-    else if ( action == "CANCEL" )
-    {
-        if (result == "SUCCESS")
-        {
-            lcm->trigger(LCMAction::CANCEL_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error canceling VM");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::CANCEL_FAILURE, id);
-        }
-    }
-    else if ( action == "SAVE" )
-    {
-        if (result == "SUCCESS")
-        {
-            lcm->trigger(LCMAction::SAVE_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error saving VM state");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::SAVE_FAILURE, id);
-        }
-    }
-    else if ( action == "RESTORE" )
-    {
-        if (result == "SUCCESS")
-        {
-            lcm->trigger(LCMAction::DEPLOY_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error restoring VM");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DEPLOY_FAILURE, id);
-        }
-    }
-    else if ( action == "MIGRATE" )
-    {
-        if (result == "SUCCESS")
-        {
-            lcm->trigger(LCMAction::DEPLOY_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error live migrating VM");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DEPLOY_FAILURE, id);
-        }
-    }
-    else if ( action == "REBOOT" )
-    {
-        if (result == "SUCCESS")
-        {
-            vm->log("VMM",Log::INFO,"VM successfully rebooted.");
-        }
-        else
-        {
-            log_error(vm,os,is,"Error rebooting VM, assume it's still running");
-            vmpool->update(vm);
-        }
-    }
-    else if ( action == "RESET" )
-    {
-        if (result == "SUCCESS")
-        {
-            vm->log("VMM",Log::INFO,"VM successfully rebooted-hard.");
-        }
-        else
-        {
-            log_error(vm,os,is,"Error rebooting-hard VM, assume it's still running");
-            vmpool->update(vm);
-        }
-    }
-    else if ( action == "ATTACHDISK" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "VM Disk successfully attached.");
-
-            lcm->trigger(LCMAction::ATTACH_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error attaching new VM Disk");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::ATTACH_FAILURE, id);
-        }
-    }
-    else if ( action == "DETACHDISK" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM",Log::INFO,"VM Disk successfully detached.");
-
-            lcm->trigger(LCMAction::DETACH_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error detaching VM Disk");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DETACH_FAILURE, id);
-        }
-    }
-    else if ( action == "ATTACHNIC" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "VM NIC Successfully attached.");
-
-            lcm->trigger(LCMAction::ATTACH_NIC_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error attaching new VM NIC");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::ATTACH_NIC_FAILURE, id);
-        }
-    }
-    else if ( action == "DETACHNIC" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM",Log::INFO, "VM NIC Successfully detached.");
-
-            lcm->trigger(LCMAction::DETACH_NIC_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error detaching VM NIC");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DETACH_NIC_FAILURE, id);
-        }
-    }
-    else if ( action == "SNAPSHOTCREATE" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            string hypervisor_id;
-
-            is >> hypervisor_id;
-
-            vm->update_snapshot_id(hypervisor_id);
-
-            vmpool->update(vm);
-
-            vm->log("VMM", Log::INFO, "VM Snapshot successfully created.");
-
-            lcm->trigger(LCMAction::SNAPSHOT_CREATE_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error creating new VM Snapshot");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::SNAPSHOT_CREATE_FAILURE, id);
-        }
-    }
-    else if ( action == "SNAPSHOTREVERT" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM",Log::INFO,"VM Snapshot successfully reverted.");
-
-            lcm->trigger(LCMAction::SNAPSHOT_REVERT_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error reverting VM Snapshot");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::SNAPSHOT_REVERT_FAILURE, id);
-        }
-    }
-    else if ( action == "SNAPSHOTDELETE" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM",Log::INFO,"VM Snapshot successfully deleted.");
-
-            lcm->trigger(LCMAction::SNAPSHOT_DELETE_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm,os,is,"Error deleting VM Snapshot");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::SNAPSHOT_DELETE_FAILURE, id);
-        }
-    }
-    else if ( action == "DISKSNAPSHOTCREATE" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "VM disk snapshot successfully created.");
-
-            lcm->trigger(LCMAction::DISK_SNAPSHOT_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error creating new disk snapshot");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DISK_SNAPSHOT_FAILURE, id);
-        }
-    }
-    else if ( action == "DISKSNAPSHOTREVERT" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "VM disk state reverted.");
-
-            lcm->trigger(LCMAction::DISK_SNAPSHOT_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error reverting disk snapshot");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DISK_SNAPSHOT_FAILURE, id);
-        }
-    }
-    else if ( action == "RESIZEDISK" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "VM disk successfully resized");
-
-            lcm->trigger(LCMAction::DISK_RESIZE_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error resizing disk");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::DISK_RESIZE_FAILURE, id);
-        }
-    }
-    else if ( action == "UPDATECONF" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "VM update conf succesfull.");
-
-            lcm->trigger(LCMAction::UPDATE_CONF_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error updating conf for VM");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::UPDATE_CONF_FAILURE, id);
-        }
-    }
-    else if ( action == "CLEANUP" )
-    {
-        if ( result == "SUCCESS" )
-        {
-            vm->log("VMM", Log::INFO, "Host successfully cleaned.");
-
-            lcm->trigger(LCMAction::CLEANUP_SUCCESS, id);
-        }
-        else
-        {
-            log_error(vm, os, is, "Error cleaning Host");
-            vmpool->update(vm);
-
-            lcm->trigger(LCMAction::CLEANUP_FAILURE, id);
-        }
-    }
-    else if ( action == "POLL" )
-    {
-        // if (result == "SUCCESS")
-        // {
-        //     string monitor_str;
-        //     getline(is, monitor_str);
-
-        //     process_poll(vm, monitor_str);
-        // }
-        // else
-        // {
-        //     log_monitor_error(vm, os, is, "Error monitoring VM");
-
-        //     lcm->trigger(LCMAction::MONITOR_DONE, vm->get_oid());
-        // }
-    }
-    else if (action == "LOG")
-    {
-        string info;
-
-        getline(is,info);
-        vm->log("VMM",log_type(result[0]),info.c_str());
-    }
-
-    vm->unlock();
-}
-
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-
-void VirtualMachineManagerDriver::recover()
-{
-    NebulaLog::log("VMM",Log::INFO,"Recovering VMM drivers");
+    string name, exec, args;
+    driver_conf.get("NAME", name);
+    driver_conf.get("EXECUTABLE", exec);
+    driver_conf.get("ARGUMENTS", args);
+    int  threads;
+
+    driver_conf.get("THREADS", threads);
+
+    //NebulaLog::info("DrM", "Loading driver: " + name);
+
+    if (exec.empty())
+    {
+        NebulaLog::error("VMM", "\tEmpty executable for driver: " + name);
+        return;
+    }
+
+    if (exec[0] != '/') //Look in ONE_LOCATION/lib/mads or in "/usr/lib/one/mads"
+    {
+        exec = mad_location + exec;
+    }
+
+    if (access(exec.c_str(), F_OK) != 0)
+    {
+        NebulaLog::error("VMM", "File not exists: " + exec);
+    }
+
+    cmd_(exec);
+    arg_(args);
+    concurency_(threads);
 }
diff --git a/src/vmm/VirtualMachineManagerProtocol.cc b/src/vmm/VirtualMachineManagerProtocol.cc
new file mode 100644
index 0000000000..81c181ff57
--- /dev/null
+++ b/src/vmm/VirtualMachineManagerProtocol.cc
@@ -0,0 +1,838 @@
+/* -------------------------------------------------------------------------- */
+/* Copyright 2002-2020, OpenNebula Project, OpenNebula Systems                */
+/*                                                                            */
+/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
+/* not use this file except in compliance with the License. You may obtain    */
+/* a copy of the License at                                                   */
+/*                                                                            */
+/* http://www.apache.org/licenses/LICENSE-2.0                                 */
+/*                                                                            */
+/* Unless required by applicable law or agreed to in writing, software        */
+/* distributed under the License is distributed on an "AS IS" BASIS,          */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
+/* See the License for the specific language governing permissions and        */
+/* limitations under the License.                                             */
+/* -------------------------------------------------------------------------- */
+
+#include "VirtualMachineManager.h"
+#include "VirtualMachinePool.h"
+#include "LifeCycleManager.h"
+#include "Nebula.h"
+#include "NebulaLog.h"
+
+
+/* -------------------------------------------------------------------------- */
+/* Helpers for the protocol function                                          */
+/* -------------------------------------------------------------------------- */
+
+static void log_message(vm_msg_t* msg)
+{
+    ostringstream oss;
+
+    oss << "Message received: ";
+    msg->write_to(oss);
+
+    NebulaLog::log("IPM", Log::DEBUG, oss);
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::log_error(VirtualMachine* vm,
+                                      const string&   payload,
+                                      const char *    msg)
+{
+    ostringstream oss;
+
+    oss << msg;
+
+    if (!payload.empty() && payload[0] != '-')
+    {
+        oss << ": " << payload;
+        vm->set_template_error_message(oss.str());
+    }
+
+    vm->log("VMM", Log::ERROR, oss);
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::log_error(int           vm_id,
+                                      const string& payload,
+                                      const char *  msg)
+{
+    ostringstream oss;
+
+    oss << msg;
+
+    auto vm = vmpool->get(vm_id);
+
+    if (!payload.empty() && payload[0] != '-')
+    {
+        oss << ": " << payload;
+        vm->set_template_error_message(oss.str());
+        vmpool->update(vm);
+    }
+
+    vm->log("VMM", Log::ERROR, oss);
+
+    vm->unlock();
+}
+
+/* -------------------------------------------------------------------------- */
+
+bool VirtualMachineManager::check_vm_state(int vm_id, vm_msg_t* msg)
+{
+    auto vm = vmpool->get_ro(vm_id);
+
+    if (vm == nullptr)
+    {
+        return false;
+    }
+
+    if (vm->get_lcm_state() == VirtualMachine::LCM_INIT)
+    {
+        ostringstream oss;
+        oss.str("");
+        oss << "Ignored: ";
+        msg->write_to(oss);
+        vm->log("VMM", Log::WARNING, oss);
+
+        vm->unlock();
+
+        return false;
+    }
+
+    vm->unlock();
+
+    return true;
+}
+
+/* ************************************************************************** */
+/* Driver Protocol Interface                                                  */
+/* ************************************************************************** */
+
+void VirtualMachineManager::_undefined(unique_ptr<vm_msg_t> msg)
+{
+    NebulaLog::warn("VMM", "Received UNDEFINED msg: " + msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_deploy(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    LCMAction::Actions action = LCMAction::DEPLOY_SUCCESS;
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get(id);
+
+        istringstream is(msg->payload());
+
+        string deploy_id;
+
+        is >> deploy_id;
+
+        if (!deploy_id.empty())
+        {
+            vm->set_deploy_id(deploy_id);
+        }
+        else
+        {
+            action = LCMAction::DEPLOY_FAILURE;
+            log_error(vm, msg->payload(), "Empty deploy ID for virtual machine");
+        }
+
+        vmpool->update(vm);
+
+        vm->unlock();
+    }
+    else
+    {
+        action = LCMAction::DEPLOY_FAILURE;
+        log_error(id, msg->payload(), "Error deploying virtual machine");
+    }
+
+    LifeCycleManager * lcm = Nebula::instance().get_lcm();
+
+    lcm->trigger(action, msg->oid());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_shutdown(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        lcm->trigger(LCMAction::SHUTDOWN_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error shutting down VM");
+
+        lcm->trigger(LCMAction::SHUTDOWN_FAILURE, msg->oid());
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_reset(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+        vm->log("VMM", Log::INFO, "VM successfully rebooted-hard.");
+        vm->unlock();
+    }
+    else
+    {
+        log_error(id, msg->payload(),
+                  "Error rebooting-hard VM, assume it's still running");
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_reboot(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+        vm->log("VMM", Log::INFO, "VM successfully rebooted.");
+        vm->unlock();
+    }
+    else
+    {
+        log_error(id, msg->payload(),
+                  "Error rebooting VM, assume it's still running");
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_cancel(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        lcm->trigger(LCMAction::CANCEL_SUCCESS, id);
+    }
+    else
+    {
+        log_error(msg->oid(), msg->payload(), "Error canceling VM");
+
+        lcm->trigger(LCMAction::CANCEL_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_cleanup(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "Host successfully cleaned.");
+
+        lcm->trigger(LCMAction::CLEANUP_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error cleaning Host");
+
+        lcm->trigger(LCMAction::CLEANUP_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_checkpoint(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_save(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        lcm->trigger(LCMAction::SAVE_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error saving VM state");
+
+        lcm->trigger(LCMAction::SAVE_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_restore(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        lcm->trigger(LCMAction::DEPLOY_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error restoring VM");
+
+        lcm->trigger(LCMAction::DEPLOY_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_migrate(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        lcm->trigger(LCMAction::DEPLOY_SUCCESS, id);
+    }
+    else
+    {
+        log_error(msg->oid(), msg->payload(), "Error live migrating VM");
+
+        lcm->trigger(LCMAction::DEPLOY_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+// void VirtualMachineManager::_poll(unique_ptr<vm_msg_t> msg)
+// {
+
+// }
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_attachdisk(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "VM Disk successfully attached.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::ATTACH_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error attaching new VM Disk");
+
+        lcm->trigger(LCMAction::ATTACH_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_detachdisk(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM",Log::INFO,"VM Disk successfully detached.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::DETACH_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error detaching VM Disk");
+
+        lcm->trigger(LCMAction::DETACH_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_attachnic(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "VM NIC Successfully attached.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::ATTACH_NIC_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error attaching new VM NIC");
+
+        lcm->trigger(LCMAction::ATTACH_NIC_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_detachnic(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM",Log::INFO, "VM NIC Successfully detached.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::DETACH_NIC_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error detaching VM NIC");
+
+        lcm->trigger(LCMAction::DETACH_NIC_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_snapshotcreate(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        string hypervisor_id;
+
+        istringstream is(msg->payload());
+
+        is >> hypervisor_id;
+
+        auto vm = vmpool->get(id);
+        vm->update_snapshot_id(hypervisor_id);
+
+        vmpool->update(vm);
+
+        vm->log("VMM", Log::INFO, "VM Snapshot successfully created.");
+
+        lcm->trigger(LCMAction::SNAPSHOT_CREATE_SUCCESS, id);
+    }
+    else
+    {
+        log_error(msg->oid(), msg->payload(), "Error creating new VM Snapshot");
+
+        lcm->trigger(LCMAction::SNAPSHOT_CREATE_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_snapshotrevert(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM",Log::INFO,"VM Snapshot successfully reverted.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::SNAPSHOT_REVERT_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error reverting VM Snapshot");
+
+        lcm->trigger(LCMAction::SNAPSHOT_REVERT_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_snapshotdelete(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM",Log::INFO,"VM Snapshot successfully deleted.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::SNAPSHOT_DELETE_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error deleting VM Snapshot");
+
+        lcm->trigger(LCMAction::SNAPSHOT_DELETE_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_disksnapshotcreate(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS" )
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "VM disk snapshot successfully created.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::DISK_SNAPSHOT_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error creating new disk snapshot");
+
+        lcm->trigger(LCMAction::DISK_SNAPSHOT_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_disksnapshotrevert(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS")
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "VM disk state reverted.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::DISK_SNAPSHOT_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error reverting disk snapshot");
+
+        lcm->trigger(LCMAction::DISK_SNAPSHOT_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_resizedisk(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS" )
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "VM disk successfully resized");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::DISK_RESIZE_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error resizing disk");
+
+        lcm->trigger(LCMAction::DISK_RESIZE_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_updateconf(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    if (msg->status() == "SUCCESS" )
+    {
+        auto vm = vmpool->get_ro(id);
+
+        vm->log("VMM", Log::INFO, "VM update conf succesfull.");
+
+        vm->unlock();
+
+        lcm->trigger(LCMAction::UPDATE_CONF_SUCCESS, id);
+    }
+    else
+    {
+        log_error(id, msg->payload(), "Error updating conf for VM");
+
+        lcm->trigger(LCMAction::UPDATE_CONF_FAILURE, id);
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_updatesg(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+
+    int id = msg->oid();
+    auto lcm = Nebula::instance().get_lcm();
+
+    if (!check_vm_state(id, msg.get()))
+    {
+        return;
+    }
+
+    int sgid;
+
+    istringstream is(msg->payload());
+
+    is >> sgid >> ws;
+
+    if (is.fail())
+    {
+        NebulaLog::log("VMM", Log::ERROR, "Missing or wrong security group"
+                " id in driver message");
+        return;
+    }
+
+    SecurityGroupPool* sgpool = Nebula::instance().get_secgrouppool();
+    SecurityGroup*     sg     = sgpool->get(sgid);
+
+    if (sg != nullptr)
+    {
+        sg->del_updating(id);
+
+        if (msg->status() == "SUCCESS")
+        {
+            sg->add_vm(id);
+        }
+        else
+        {
+            sg->add_error(id);
+        }
+
+        sgpool->update(sg);
+
+        sg->unlock();
+    }
+
+    auto vm = vmpool->get(id);
+
+    if (vm != nullptr)
+    {
+        if (msg->status() == "SUCCESS")
+        {
+            vm->log("VMM", Log::INFO, "VM security group updated.");
+        }
+        else
+        {
+            log_error(vm, msg->payload(), "Error updating security groups.");
+
+            vmpool->update(vm);
+        }
+
+        vm->unlock();
+    }
+
+    lcm->trigger(LCMAction::UPDATESG, sgid);
+    return;
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_driver_cancel(unique_ptr<vm_msg_t> msg)
+{
+    log_message(msg.get());
+}
+
+/* -------------------------------------------------------------------------- */
+
+void VirtualMachineManager::_log(unique_ptr<vm_msg_t> msg)
+{
+    NebulaLog::log("VMM", log_type(msg->status()[0]), msg->payload());
+}
+
+/* -------------------------------------------------------------------------- */
diff --git a/src/vn_template/VNTemplate.cc b/src/vn_template/VNTemplate.cc
index 97aa0e5f13..1d31370f4b 100644
--- a/src/vn_template/VNTemplate.cc
+++ b/src/vn_template/VNTemplate.cc
@@ -16,6 +16,7 @@
 
 #include "VNTemplate.h"
 #include "VirtualNetwork.h"
+#include "OneDB.h"
 
 /* ************************************************************************ */
 /* VNTemplate :: Constructor/Destructor                                     */
@@ -28,8 +29,8 @@ VNTemplate::VNTemplate(int id,
                        const string& _gname,
                        int umask,
                        VirtualNetworkTemplate * _template_contents):
-        PoolObjectSQL(id,VNTEMPLATE,"",_uid,_gid,_uname,_gname,table),
-        regtime(time(0))
+    PoolObjectSQL(id,VNTEMPLATE,"",_uid,_gid,_uname,_gname,one_db::vn_template_table),
+    regtime(time(0))
 {
     if (_template_contents != 0)
     {
@@ -47,19 +48,6 @@ VNTemplate::VNTemplate(int id,
 /* VNTemplate :: Database Access Functions                                  */
 /* ************************************************************************ */
 
-const char * VNTemplate::table = "vn_template_pool";
-
-const char * VNTemplate::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * VNTemplate::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS vn_template_pool (oid INTEGER PRIMARY KEY, "
-    "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
-    "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 int VNTemplate::insert(SqlDB *db, string& error_str)
 {
     string vn_mad, phydev, bridge, auto_id_str, vlan_id, auto_outer_str, outer_id;
@@ -151,7 +139,7 @@ int VNTemplate::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if (replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::vn_template_table << " SET "
             << "name = '"    << sql_name   << "', "
             << "body = '"    << sql_xml    << "', "
             << "uid = "      << uid        << ", "
@@ -163,7 +151,8 @@ int VNTemplate::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::vn_template_table
+            << " (" << one_db::vn_template_db_names << ") VALUES ("
             <<            oid        << ","
             << "'"     << sql_name   << "',"
             << "'"     << sql_xml    << "',"
@@ -201,6 +190,16 @@ error_common:
     return -1;
 }
 
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+int VNTemplate::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::vn_template_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
 /* ************************************************************************ */
 /* VNTemplate :: Misc                                                       */
 /* ************************************************************************ */
diff --git a/src/vnm/VirtualNetwork.cc b/src/vnm/VirtualNetwork.cc
index 70bcea6fbf..1258b03213 100644
--- a/src/vnm/VirtualNetwork.cc
+++ b/src/vnm/VirtualNetwork.cc
@@ -44,7 +44,7 @@ VirtualNetwork::VirtualNetwork(int                      _uid,
                                int                      _pvid,
                                const set<int>           &_cluster_ids,
                                VirtualNetworkTemplate * _vn_template):
-            PoolObjectSQL(-1,NET,"",_uid,_gid,_uname,_gname,table),
+            PoolObjectSQL(-1,NET,"",_uid,_gid,_uname,_gname,one_db::vn_table),
             Clusterable(_cluster_ids),
             bridge(""),
             vlan_id_automatic(false),
@@ -78,21 +78,6 @@ void VirtualNetwork::get_permissions(PoolObjectAuth& auths)
     }
 }
 
-/* ************************************************************************** */
-/* Virtual Network :: Database Access Functions                               */
-/* ************************************************************************** */
-
-const char * VirtualNetwork::table    = "network_pool";
-
-const char * VirtualNetwork::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u, pid";
-
-const char * VirtualNetwork::db_bootstrap = "CREATE TABLE IF NOT EXISTS"
-    " network_pool (oid INTEGER PRIMARY KEY, name VARCHAR(128),"
-    " body MEDIUMTEXT, uid INTEGER, gid INTEGER,"
-    " owner_u INTEGER, group_u INTEGER, other_u INTEGER,"
-    " pid INTEGER, UNIQUE(name,uid))";
-
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
@@ -198,8 +183,9 @@ int VirtualNetwork::parse_phydev_vlans(const Template* tmpl, const string& vn_ma
     return 0;
 }
 
-/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
+/* ************************************************************************** */
+/* Virtual Network :: Database Access Functions                               */
+/* ************************************************************************** */
 
 int VirtualNetwork::insert(SqlDB * db, string& error_str)
 {
@@ -499,7 +485,7 @@ int VirtualNetwork::insert_replace(SqlDB *db, bool replace, string& error_str)
     // Construct the SQL statement to Insert or Replace
     if(replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::vn_table << " SET "
             << "name = '"    <<   sql_name    << "', "
             << "body = '"    <<   sql_xml     << "', "
             << "uid = "      <<   uid         << ", "
@@ -512,7 +498,8 @@ int VirtualNetwork::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::vn_table
+            << " (" << one_db::vn_db_names << ") VALUES ("
             <<          oid         << ","
             << "'" <<   sql_name    << "',"
             << "'" <<   sql_xml     << "',"
@@ -552,6 +539,15 @@ error_common:
     return -1;
 }
 
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+int VirtualNetwork::bootstrap(SqlDB * db)
+{
+    ostringstream oss_vnet(one_db::vn_db_bootstrap);
+
+    return db->exec_local_wr(oss_vnet);
+};
+
 /* ************************************************************************** */
 /* Virtual Network :: Misc                                                    */
 /* ************************************************************************** */
diff --git a/src/vnm/VirtualNetworkPool.cc b/src/vnm/VirtualNetworkPool.cc
index e208839ab0..267fc591ce 100644
--- a/src/vnm/VirtualNetworkPool.cc
+++ b/src/vnm/VirtualNetworkPool.cc
@@ -48,7 +48,7 @@ VirtualNetworkPool::VirtualNetworkPool(
     const vector<const SingleAttribute *>& _inherit_attrs,
     const VectorAttribute *             _vlan_conf,
     const VectorAttribute *             _vxlan_conf):
-        PoolSQL(db, VirtualNetwork::table), vlan_conf(_vlan_conf),
+        PoolSQL(db, one_db::vn_table), vlan_conf(_vlan_conf),
         vxlan_conf(_vxlan_conf)
 {
     istringstream iss;
diff --git a/src/vrouter/VirtualRouter.cc b/src/vrouter/VirtualRouter.cc
index 54835c4909..0062a627e4 100644
--- a/src/vrouter/VirtualRouter.cc
+++ b/src/vrouter/VirtualRouter.cc
@@ -76,7 +76,7 @@ VirtualRouter::VirtualRouter(   int             id,
                                 const string&   _gname,
                                 int             _umask,
                                 Template * _template_contents):
-        PoolObjectSQL(id,VROUTER,"",_uid,_gid,_uname,_gname,table),
+        PoolObjectSQL(id,VROUTER,"",_uid,_gid,_uname,_gname,one_db::vr_table),
         vms("VMS")
 {
     if (_template_contents != 0)
@@ -92,22 +92,9 @@ VirtualRouter::VirtualRouter(   int             id,
 }
 
 /* ************************************************************************ */
-/* VirtualRouter :: Database Access Functions                                    */
+/* VirtualRouter :: Database Access Functions                               */
 /* ************************************************************************ */
 
-const char * VirtualRouter::table = "vrouter_pool";
-
-const char * VirtualRouter::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * VirtualRouter::db_bootstrap =
-    "CREATE TABLE IF NOT EXISTS vrouter_pool (oid INTEGER PRIMARY KEY, "
-    "name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, gid INTEGER, "
-    "owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
-
 int VirtualRouter::insert(SqlDB *db, string& error_str)
 {
     int             rc;
@@ -270,7 +257,7 @@ int VirtualRouter::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if (replace)
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::vr_table << " SET "
             << "name = '"    << sql_name   << "', "
             << "body = '"    << sql_xml    << "', "
             << "uid = "      << uid        << ", "
@@ -282,7 +269,8 @@ int VirtualRouter::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::vr_table
+            << " (" << one_db::vr_db_names << ") VALUES ("
             <<            oid        << ","
             << "'"     << sql_name   << "',"
             << "'"     << sql_xml    << "',"
@@ -321,6 +309,16 @@ error_common:
     return -1;
 }
 
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+int VirtualRouter::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::vr_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
 /* ************************************************************************ */
 /* VirtualRouter :: Misc                                                         */
 /* ************************************************************************ */
diff --git a/src/zone/Zone.cc b/src/zone/Zone.cc
index 661bea62d6..19723a5877 100644
--- a/src/zone/Zone.cc
+++ b/src/zone/Zone.cc
@@ -16,19 +16,10 @@
 
 #include "Zone.h"
 #include "ZoneServer.h"
+#include "OneDB.h"
 
 /* ------------------------------------------------------------------------ */
 
-const char * Zone::table = "zone_pool";
-
-const char * Zone::db_names =
-        "oid, name, body, uid, gid, owner_u, group_u, other_u";
-
-const char * Zone::db_bootstrap = "CREATE TABLE IF NOT EXISTS zone_pool ("
-    "oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
-    "gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER, "
-    "UNIQUE(name))";
-
 const char * ZoneServers::SERVER_NAME    = "SERVER";
 
 const char * ZoneServers::SERVER_ID_NAME = "ID";
@@ -37,8 +28,9 @@ const char * ZoneServers::SERVER_ID_NAME = "ID";
 /* -------------------------------------------------------------------------- */
 
 Zone::Zone(int id, Template* zone_template):
-        PoolObjectSQL(id, ZONE, "", -1, -1, "", "", table), servers_template(
-                false, '=', "SERVER_POOL"), servers(0)
+    PoolObjectSQL(id, ZONE, "", -1, -1, "", "", one_db::zone_table),
+    servers_template(false, '=', "SERVER_POOL"),
+    servers(0)
 {
     if (zone_template != 0)
     {
@@ -147,7 +139,7 @@ int Zone::insert_replace(SqlDB *db, bool replace, string& error_str)
 
     if ( replace )
     {
-        oss << "UPDATE " << table << " SET "
+        oss << "UPDATE " << one_db::zone_table << " SET "
             << "name = '"    <<   sql_name  << "', "
             << "body = '"    <<   sql_xml   << "', "
             << "uid = "      <<   uid       << ", "
@@ -159,7 +151,8 @@ int Zone::insert_replace(SqlDB *db, bool replace, string& error_str)
     }
     else
     {
-        oss << "INSERT INTO " << table << " (" << db_names << ") VALUES ("
+        oss << "INSERT INTO " << one_db::zone_table
+            << " (" << one_db::zone_db_names << ") VALUES ("
             <<          oid                 << ","
             << "'" <<   sql_name            << "',"
             << "'" <<   sql_xml             << "',"
@@ -198,6 +191,15 @@ error_common:
     return -1;
 }
 
+/* -------------------------------------------------------------------------- */
+/* -------------------------------------------------------------------------- */
+int Zone::bootstrap(SqlDB * db)
+{
+    ostringstream oss(one_db::zone_db_bootstrap);
+
+    return db->exec_local_wr(oss);
+};
+
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
diff --git a/src/zone/ZonePool.cc b/src/zone/ZonePool.cc
index 4c727d27a8..19cd01b226 100644
--- a/src/zone/ZonePool.cc
+++ b/src/zone/ZonePool.cc
@@ -28,7 +28,8 @@ const int ZonePool::STANDALONE_ZONE_ID = 0;
 
 /* -------------------------------------------------------------------------- */
 
-ZonePool::ZonePool(SqlDB * db, bool is_federation_slave):PoolSQL(db,Zone::table)
+ZonePool::ZonePool(SqlDB * db, bool is_federation_slave)
+    : PoolSQL(db, one_db::zone_table)
 {
     string error_str;