Conversion to QMFv2

matahari-qmf-v2.patch

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5749656..877beb1 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -51,6 +51,7 @@ set(SCHEMA_SOURCES
         ${CMAKE_CURRENT_BINARY_DIR}/qmf/org/matahariproject/EventHeartbeat.cpp
         ${CMAKE_CURRENT_BINARY_DIR}/qmf/org/matahariproject/EventService_op.cpp
         ${CMAKE_CURRENT_BINARY_DIR}/qmf/org/matahariproject/EventResource_op.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/qmf/org/matahariproject/QmfPackage.cpp
         ${CMAKE_CURRENT_BINARY_DIR}/qmf/org/matahariproject/Package.cpp)
 
 ## Libraries and Common code
@@ -177,13 +178,15 @@ if (regen_schema)
     execute_process(COMMAND rm -f ${SCHEMA_SOURCES})
     execute_process(COMMAND ${QMFGEN} -o ./qmf ${SCHEMAS}
                     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    execute_process(COMMAND ${QMFGEN} -2 -o ./qmf ${SCHEMAS}
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 else (regen_schema)
     message(STATUS "No need to generate QMF schema")
 endif (regen_schema)
 
 # Add QF libraries
 foreach(daemon ${DAEMONS}) 
-    target_link_libraries(${daemon} ${QPIDCOMMON_LIBRARY} ${QPIDCLIENT_LIBRARY} ${QMF_LIBRARY})
+    target_link_libraries(${daemon} ${QPIDCOMMON_LIBRARY} ${QPIDCLIENT_LIBRARY} ${QPIDMESSAGING_LIBRARY} ${QMF2_LIBRARY})
     IF(QPIDTYPES_FOUND)
         target_link_libraries(${daemon} ${QPIDTYPES_LIBRARY})
     ENDIF(QPIDTYPES_FOUND)
diff --git a/src/cmake/modules/FindQPID.cmake b/src/cmake/modules/FindQPID.cmake
index 6aa71cb..1fc98b5 100644
--- a/src/cmake/modules/FindQPID.cmake
+++ b/src/cmake/modules/FindQPID.cmake
@@ -14,15 +14,21 @@ if(MSVC)
 
 else(MSVC)
    find_library(QMF_LIBRARY qmf)
+   find_library(QMF2_LIBRARY qmf2)
    find_library(QPIDCLIENT_LIBRARY qpidclient)
-   find_library(QPIDCOMMON_LIBRARY qpidcommon)	
-   find_library(QPIDTYPES_LIBRARY qpidtypes)	
+   find_library(QPIDCOMMON_LIBRARY qpidcommon)
+   find_library(QPIDTYPES_LIBRARY qpidtypes)
+   find_library(QPIDMESSAGING_LIBRARY qpidmessaging)
 
    # Check if we found all libraries
    if(QMF_LIBRARY)
        set(QMF_FOUND true)
    endif(QMF_LIBRARY)
 
+   if(QMF2_LIBRARY)
+       set(QMF2_FOUND true)
+   endif(QMF2_LIBRARY)
+
    if(QPIDCLIENT_LIBRARY)
        set(QPIDCLIENT_FOUND true)
    endif(QPIDCLIENT_LIBRARY)
@@ -35,6 +41,10 @@ else(MSVC)
        set(QPIDTYPES_FOUND true)
    endif(QPIDTYPES_LIBRARY)
 
+   if(QPIDMESSAGING_LIBRARY)
+       set(QPIDMESSAGING_FOUND true)
+   endif(QPIDMESSAGING_LIBRARY)
+
    # Handle found/not found libraries
    if(QMF_FOUND)
        if(NOT QPID_FIND_QUIETLY)
@@ -46,6 +56,16 @@ else(MSVC)
        endif(QPID_FIND_REQUIRED)
    endif(QMF_FOUND)
 
+   if(QMF2_FOUND)
+       if(NOT QPID_FIND_QUIETLY)
+           message(STATUS "Found QMF2: ${QMF2_LIBRARY}")
+       endif(NOT QPID_FIND_QUIETLY)
+   else(QMF2_FOUND)
+       if(QPID_FIND_REQUIRED)
+           message(FATAL_ERROR "Could not find QMF2")
+       endif(QPID_FIND_REQUIRED)
+   endif(QMF2_FOUND)
+
    if(QPIDCLIENT_FOUND)
        if(NOT QPID_FIND_QUIETLY)
            message(STATUS "Found QPIDCLIENT: ${QPIDCLIENT_LIBRARY}")
@@ -78,6 +98,18 @@ else(MSVC)
        endif(QPID_FIND_REQUIRED)
    endif(QPIDTYPES_FOUND)
 
+   if(QPIDMESSAGING_FOUND)
+       if(NOT QPID_FIND_QUIETLY)
+           message(STATUS "Found QPIDMESSAGING: ${QPIDMESSAGING_LIBRARY}")
+       endif(NOT QPID_FIND_QUIETLY)
+   else(QPIDMESSAGING_FOUND)
+       if(QPID_FIND_REQUIRED)
+           # we don't want to fail now even we don't have QPIDMESSAGING!
+           # TODO: fix once QPIDMESSAGING available
+           message(STATUS "Could not find QPIDMESSAGING")
+       endif(QPID_FIND_REQUIRED)
+   endif(QPIDMESSAGING_FOUND)
+
    # Figure out the qpid version
    if(WIN32)
       find_file(QPIDD qpidd.exe)
diff --git a/src/host/matahari-host.cpp b/src/host/matahari-host.cpp
index c8c28cf..e04664f 100644
--- a/src/host/matahari-host.cpp
+++ b/src/host/matahari-host.cpp
@@ -23,26 +23,22 @@
 
 #include <set>
 #include "matahari/mh_agent.h"
+#include <qmf/Data.h>
 #include "qmf/org/matahariproject/Host.h"
 #include "qmf/org/matahariproject/EventHeartbeat.h"
-#include <sigar.h>
 
 extern "C" {
 #include <string.h>
+#include <sigar.h>
 #include "matahari/host.h"
 }
 
 class HostAgent : public MatahariAgent
 {
-    private:
-	ManagementAgent* _agent;
-	_qmf::Host* _management_object;
-	
     public:
 	int heartbeat();
-	int setup(ManagementAgent* agent);
-	ManagementObject* GetManagementObject() const { return _management_object; }
-	status_t ManagementMethod(uint32_t method, Args& arguments, string& text);
+	int setup(qmf::AgentSession session);
+	gboolean invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data);
 };
 
 static gboolean heartbeat_timer(gpointer data)
@@ -65,44 +61,47 @@ main(int argc, char **argv)
     return rc;
 }
 
-int
-HostAgent::setup(ManagementAgent* agent)
+gboolean 
+HostAgent::invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data)
 {
-  this->_agent = agent;
-
-  _management_object = new _qmf::Host(agent, this);
-
-  _management_object->set_update_interval(5);
-  _management_object->set_uuid(host_get_uuid());
-  _management_object->set_hostname(host_get_hostname());
-  _management_object->set_os(host_get_operating_system());
-  _management_object->set_wordsize(host_get_cpu_wordsize());
-  _management_object->set_arch(host_get_architecture());
-  _management_object->set_memory(host_get_memory());
-  _management_object->set_swap(host_get_swap());
-  _management_object->set_cpu_count(host_get_cpu_count());
-  _management_object->set_cpu_cores(host_get_cpu_number_of_cores());
-  _management_object->set_cpu_model(host_get_cpu_model());
-  _management_object->set_cpu_flags(host_get_cpu_flags());
-
-  agent->addObject(_management_object);
-  return 1;
+    if(event.getType() == qmf::AGENT_METHOD) {
+	const std::string& methodName(event.getMethodName());
+	if (methodName == "shutdown") {
+	    host_shutdown();
+	} else if (methodName == "reboot") {
+	    host_reboot();
+	} else {
+	    session.raiseException(event, MH_NOT_IMPLEMENTED);
+	    goto bail;
+	}
+    }
+    
+    session.methodSuccess(event);
+  bail:
+    return TRUE;
 }
 
-Manageable::status_t
-HostAgent::ManagementMethod(uint32_t method, Args& arguments, string& text)
+int
+HostAgent::setup(qmf::AgentSession session)
 {
-  switch(method)
-    {
-    case _qmf::Host::METHOD_SHUTDOWN:
-      host_shutdown();
-      return Manageable::STATUS_OK;
-    case _qmf::Host::METHOD_REBOOT:
-      host_reboot();
-      return Manageable::STATUS_OK;
-    }
-
-  return Manageable::STATUS_NOT_IMPLEMENTED;
+    _instance = qmf::Data(_package.data_Host);
+    
+    _instance.setProperty("update_interval", 5);
+    _instance.setProperty("uuid", host_get_uuid());
+    _instance.setProperty("hostname", host_get_hostname());
+    _instance.setProperty("os", host_get_operating_system());
+    _instance.setProperty("wordsize", host_get_cpu_wordsize());
+    _instance.setProperty("arch", host_get_architecture());
+    _instance.setProperty("memory", host_get_memory());
+    _instance.setProperty("swap", host_get_swap());
+    _instance.setProperty("cpu_count", host_get_cpu_count());
+    _instance.setProperty("cpu_cores", host_get_cpu_number_of_cores());
+    _instance.setProperty("cpu_model", host_get_cpu_model());
+    _instance.setProperty("cpu_flags", host_get_cpu_flags());
+
+    _agent_session.addData(_instance);    
+    
+    return 0;
 }
 
 int
@@ -113,7 +112,7 @@ HostAgent::heartbeat()
     sigar_proc_stat_t procs;
     static uint32_t _heartbeat_sequence = 1;
 
-    if(_management_object->get_update_interval() == 0) {
+    if(_instance.getProperty("update_interval").asInt32() == 0) {
 	/* Updates disabled, just sleep */
 	qpid::sys::sleep(60);
     }
@@ -123,13 +122,12 @@ HostAgent::heartbeat()
 #endif
 
     now = timestamp * 1000000000;
-    this->_agent->raiseEvent(_qmf::EventHeartbeat(timestamp, _heartbeat_sequence++));
 
-    _management_object->set_last_updated(now);
-    _management_object->set_sequence(_heartbeat_sequence);
+    _instance.setProperty("last_updated", now);
+    _instance.setProperty("sequence", _heartbeat_sequence);
 
-    _management_object->set_free_swap(host_get_swap_free());
-    _management_object->set_free_mem(host_get_mem_free());
+    _instance.setProperty("free_swap", host_get_swap_free());
+    _instance.setProperty("free_mem", host_get_mem_free());
 
     ::qpid::types::Variant::Map load;
     memset(&avg, 0, sizeof(sigar_loadavg_t));
@@ -137,7 +135,7 @@ HostAgent::heartbeat()
     load["1"]  = ::qpid::types::Variant((double)avg.loadavg[0]);
     load["5"]  = ::qpid::types::Variant((double)avg.loadavg[1]);
     load["15"] = ::qpid::types::Variant((double)avg.loadavg[2]);
-    _management_object->set_load(load);
+    _instance.setProperty("load", load);
 
     ::qpid::types::Variant::Map proc;
     host_get_processes(&procs);
@@ -147,7 +145,8 @@ HostAgent::heartbeat()
     proc["running"]  = ::qpid::types::Variant((int)procs.running);
     proc["stopped"]  = ::qpid::types::Variant((int)procs.stopped);
     proc["sleeping"] = ::qpid::types::Variant((int)procs.sleeping);
-    _management_object->set_process_statistics(proc);
+    _instance.setProperty("process_statistics", proc);
 
-    return _management_object->get_update_interval() * 1000;
+    // _agent_session.raiseEvent(_instance);
+    return _instance.getProperty("update_interval").asInt32() * 1000;
 }
diff --git a/src/include/matahari/mh_agent.h b/src/include/matahari/mh_agent.h
index 3662429..62c5aef 100644
--- a/src/include/matahari/mh_agent.h
+++ b/src/include/matahari/mh_agent.h
@@ -24,27 +24,57 @@
 #include <qpid/sys/Time.h>
 #include <qpid/agent/ManagementAgent.h>
 #include <qpid/management/Manageable.h>
+#include <qpid/messaging/Connection.h>
+#include <qmf/AgentEvent.h>
 
 extern "C" {
 #include "matahari/mainloop.h"
 }
 
+#define MH_NOT_IMPLEMENTED "Not implemented"
+
 using namespace qpid::management;
 using namespace std;
 
-#include "qmf/org/matahariproject/Package.h"
+#include "qmf/org/matahariproject/QmfPackage.h" // v2 schema
 namespace _qmf = qmf::org::matahariproject;
+namespace _qtype = ::qpid::types;
 
-class MatahariAgent : public Manageable
+typedef struct mainloop_qmf_s 
 {
+	GSource source;
+	qmf::AgentSession session;
+	qmf::AgentEvent event;
+	guint id;
+	void *user_data;
+	GDestroyNotify dnotify;
+	gboolean (*dispatch)(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data);
+
+} mainloop_qmf_t;
+
+extern mainloop_qmf_t *mainloop_add_qmf(int priority, qmf::AgentSession session,
+				  gboolean (*dispatch)(qmf::AgentSession session, qmf::AgentEvent event, gpointer userdata),
+				  GDestroyNotify notify, gpointer userdata);
+
+extern gboolean mainloop_destroy_qmf(mainloop_qmf_t* source);
+
+class MatahariAgent
+{
+ protected:
     GMainLoop *mainloop;
-    mainloop_fd_t *qpid_source;
+    mainloop_qmf_t *qpid_source;
+
+    qmf::Data _instance;
+    qmf::AgentSession _agent_session;
+    qpid::messaging::Connection _amqp_connection;
+    qmf::org::matahariproject::PackageDefinition _package;
     
   public:
     MatahariAgent() {};
     ~MatahariAgent() {};
     
-    virtual int setup(ManagementAgent *agent) { return 0; };
+    virtual int setup(qmf::AgentSession session) { return 0; };
+    virtual gboolean invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data) { return FALSE; };
     int init(int argc, char **argv, const char* proc_name);
     void run();
 };
diff --git a/src/lib/mh_agent.cpp b/src/lib/mh_agent.cpp
index 9a4a605..169f222 100644
--- a/src/lib/mh_agent.cpp
+++ b/src/lib/mh_agent.cpp
@@ -27,6 +27,7 @@ int use_stderr = 0;
 #include <iostream>
 #include <fstream>
 #include <string.h>
+#include <sstream>
 #include <errno.h>
 #include <vector>
 #include <exception>
@@ -37,8 +38,6 @@ int use_stderr = 0;
 #include <qpid/sys/Time.h>
 #include <qpid/agent/ManagementAgent.h>
 #include <qpid/client/ConnectionSettings.h>
-
-#include "qmf/org/matahariproject/Package.h"
 #include "matahari/mh_agent.h"
 
 extern "C" {
@@ -50,9 +49,6 @@ using namespace qpid::client;
 using namespace std;
 namespace _qmf = qmf::org::matahariproject;
 
-// Global Variables
-ManagementAgent::Singleton* singleton;
-
 void
 shutdown(int /*signal*/)
 {
@@ -114,12 +110,11 @@ print_usage(const char *proc_name)
 #endif
 
 static gboolean 
-mh_qpid_callback(int fd, gpointer user_data)
+mh_qpid_callback(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data)
 {
-    ManagementAgent *agent = (ManagementAgent *)user_data;
+    MatahariAgent *agent = (MatahariAgent*) user_data;
     mh_trace("Qpid message recieved");
-    agent->pollCallbacks();
-    return TRUE;
+    return agent->invoke(session, event, user_data);
 }
 
 static void
@@ -141,14 +136,12 @@ MatahariAgent::init(int argc, char **argv, const char* proc_name)
 
     bool gssapi = false;
     char *servername = strdup(MATAHARI_BROKER);
-    char *username = NULL;
-    char *password = NULL;
-    char *service = NULL;
-    int serverport = MATAHARI_PORT;
-    int debuglevel = 0;
+    char *username  = NULL;
+    char *password  = NULL;
+    char *service   = NULL;
+    int serverport  = MATAHARI_PORT;
 
     qpid::management::ConnectionSettings settings;
-    ManagementAgent *agent;
 
     /* Set up basic logging */
     mh_log_init(proc_name, LOG_INFO, FALSE);    
@@ -280,11 +273,6 @@ MatahariAgent::init(int argc, char **argv, const char* proc_name)
     /* Re-initialize logging now that we've completed option processing */
     mh_log_init(proc_name, mh_log_level, mh_log_level > LOG_INFO);
 
-    // Get our management agent
-    singleton = new ManagementAgent::Singleton();
-    agent = singleton->getInstance();
-    _qmf::Package packageInit(agent);
-
     // Set up the cleanup handler for sigint
     signal(SIGINT, shutdown);
 
@@ -292,35 +280,47 @@ MatahariAgent::init(int argc, char **argv, const char* proc_name)
     settings.host = servername;
     settings.port = serverport;
 
-    if (username != NULL) {
-	settings.username = username;
+    mh_info("Connecting to Qpid broker at %s on port %d", servername, serverport);
+
+    // Create a v2 API options map.
+    qpid::types::Variant::Map options;
+    options["reconnect"] = bool(true);
+    if (username) {
+	options["username"] = username;
     }
-    if (password != NULL) {
-        settings.password = password;
+    if (password) {
+	options["password"] = password;
     }
-    if (service != NULL) {
-	settings.service = service;
+    if (service) {
+	options["sasl-service"] = service;
     }
-    if (gssapi == true) {
-	settings.mechanism = "GSSAPI";
+    if (gssapi) {
+	options["sasl-mechanism"] = "GSSAPI";
     }
 
-    mh_info("Connecting to Qpid broker at %s on port %d", servername, serverport);
-    agent->setName("matahariproject.org", proc_name);
-    std::string dataFile(".matahari-data-");
-    agent->init(settings, 5, true, dataFile + proc_name);
+    std::stringstream url;
+    url << servername << ":" << serverport ;
+
+    _amqp_connection = qpid::messaging::Connection(url.str(), options);
+    _amqp_connection.open();
+
+    _agent_session = qmf::AgentSession(_amqp_connection);
+    _agent_session.setVendor("matahariproject.org");
+    _agent_session.setProduct(proc_name);
+
+    _package.configure(_agent_session);
+    _agent_session.open();
 
     /* Do any setup required by our agent */
-    if(this->setup(agent) < 0) {
+    if(this->setup(_agent_session) < 0) {
 	mh_err("Failed to set up broker connection to %s on %d for %s\n", 
 	       servername, serverport, proc_name);
 	return -1;
-    } 
-    
+    }
 
     this->mainloop = g_main_new(FALSE);
-    this->qpid_source = mainloop_add_fd(
-	G_PRIORITY_HIGH, agent->getSignalFd(), mh_qpid_callback, mh_qpid_disconnect, agent);
+    this->qpid_source = mainloop_add_qmf(
+	G_PRIORITY_HIGH, _agent_session, mh_qpid_callback, mh_qpid_disconnect, this);
 
     return 0;
 }
@@ -331,3 +331,96 @@ MatahariAgent::run()
     mh_trace("Starting agent mainloop");
     g_main_run(this->mainloop);
 }
+
+static gboolean
+mainloop_qmf_prepare(GSource* source, gint *timeout)
+{
+    return FALSE;
+}
+
+static gboolean
+mainloop_qmf_check(GSource* source)
+{
+    mainloop_qmf_t *qmf = (mainloop_qmf_t*)source;
+    if (qmf->event || qmf->session.nextEvent(qmf->event, qpid::messaging::Duration::IMMEDIATE)) {
+	return TRUE;
+    }
+    return FALSE;
+}
+
+static gboolean
+mainloop_qmf_dispatch(GSource *source, GSourceFunc callback, gpointer userdata)
+{
+    mainloop_qmf_t *qmf = (mainloop_qmf_t*)source;
+    mh_trace("%p", source);
+    if (qmf->dispatch != NULL) {
+	qmf::AgentEvent event = qmf->event;
+	qmf->event = NULL;
+	
+	if(qmf->dispatch(qmf->session, event, qmf->user_data) == FALSE) {
+	    g_source_unref(source); /* Really? */
+	    return FALSE;
+	}
+    }
+    
+    return TRUE;
+}
+
+static void
+mainloop_qmf_destroy(GSource* source)
+{
+    mainloop_qmf_t *qmf = (mainloop_qmf_t*)source;
+    mh_trace("%p", source);
+
+    if (qmf->dnotify) {
+	qmf->dnotify(qmf->user_data);
+    }
+}
+
+static GSourceFuncs mainloop_qmf_funcs = {
+    mainloop_qmf_prepare,
+    mainloop_qmf_check,
+    mainloop_qmf_dispatch,
+    mainloop_qmf_destroy,
+};
+
+mainloop_qmf_t*
+mainloop_add_qmf(int priority, qmf::AgentSession session,
+		gboolean (*dispatch)(qmf::AgentSession session, qmf::AgentEvent event, gpointer userdata),
+		GDestroyNotify notify, gpointer userdata)
+{
+    GSource *source = NULL;
+    mainloop_qmf_t *qmf_source = NULL;
+    MH_ASSERT(sizeof(mainloop_qmf_t) > sizeof(GSource));
+    source = g_source_new(&mainloop_qmf_funcs, sizeof(mainloop_qmf_t));
+    MH_ASSERT(source != NULL);
+
+    qmf_source = (mainloop_qmf_t*)source;
+    qmf_source->id = 0;
+    qmf_source->event = NULL;
+    qmf_source->session = session;
+
+    /*
+     * Normally we'd use g_source_set_callback() to specify the dispatch function,
+     * But we want to supply the qmf session too, so we store it in qmf_source->dispatch instead
+     */
+    qmf_source->dnotify = notify;
+    qmf_source->dispatch = dispatch;
+    qmf_source->user_data = userdata;
+
+    g_source_set_priority(source, priority);
+    g_source_set_can_recurse(source, FALSE);
+    
+    qmf_source->id = g_source_attach(source, NULL);
+    return qmf_source;
+}
+
+gboolean
+mainloop_destroy_qmf(mainloop_qmf_t* source)
+{
+    g_source_remove(source->id);
+    source->id = 0;
+    g_source_unref((GSource*)source);
+    
+    return TRUE;
+}
diff --git a/src/net/matahari-net.cpp b/src/net/matahari-net.cpp
index d7f03d0..36882b2 100644
--- a/src/net/matahari-net.cpp
+++ b/src/net/matahari-net.cpp
@@ -46,14 +46,9 @@ extern "C" {
 
 class NetAgent : public MatahariAgent
 {
-    private:
-	ManagementAgent* _agent;
-	_qmf::Network* _management_object;
-	
     public:
-	int setup(ManagementAgent* agent);
-	ManagementObject* GetManagementObject() const { return _management_object; }
-	status_t ManagementMethod(uint32_t method, Args& arguments, string& text);
+	int setup(qmf::AgentSession session);
+	gboolean invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data);
 };
 
 int
@@ -71,95 +66,80 @@ static int interface_status(const char *iface)
 {
     uint64_t flags = 0;
     if(iface == NULL)
-	return 3;
-	
+       return 3;
+       
     network_status(iface, &flags);
 
     if(flags & SIGAR_IFF_UP) {
-	return 0;
+       return 0;
     }
     return 1; /* Inactive */
 }
 
 int
-NetAgent::setup(ManagementAgent* agent)
+NetAgent::setup(qmf::AgentSession session)
 {
-    this->_agent = agent;
-    this->_management_object = new _qmf::Network(agent, this);
-    this->_management_object->set_hostname(matahari_hostname());
-    this->_management_object->set_uuid(matahari_uuid());
+    _instance = qmf::Data(_package.data_Network);
+    
+    _instance.setProperty("hostname", matahari_hostname());
+    _instance.setProperty("uuid", matahari_uuid());
 
-    agent->addObject(this->_management_object);
+    _agent_session.addData(_instance);    
     return 0;
 }
 
-Manageable::status_t
-NetAgent::ManagementMethod(uint32_t method, Args& arguments, string& text)
+gboolean
+NetAgent::invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data)
 {
-    switch(method)
-	{
-	case _qmf::Network::METHOD_LIST:
-	    {
-                GList *interface_list = NULL;
-                GList *plist = NULL;
-                sigar_net_interface_config_t *ifconfig = NULL;
-		
-		_qmf::ArgsNetworkList& ioArgs = (_qmf::ArgsNetworkList&) arguments;
-                interface_list = network_get_interfaces();
-                for(plist = g_list_first(interface_list); plist; plist = g_list_next(plist)) {
-                    ifconfig = (sigar_net_interface_config_t *)plist->data;
-                    ioArgs.o_iface_map.push_back(ifconfig->name);
-		}
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Network::METHOD_START:
-	    {
-		_qmf::ArgsNetworkStart& ioArgs = (_qmf::ArgsNetworkStart&) arguments;
-                ioArgs.o_status = interface_status(ioArgs.i_iface.c_str());
-		if((ioArgs.o_status) == 1) {
-		    network_start(ioArgs.i_iface.c_str());
-		    ioArgs.o_status = interface_status(ioArgs.i_iface.c_str());
-		}
-	    }
-	    return Manageable::STATUS_OK;
+    if(event.getType() == qmf::AGENT_METHOD) {
+	const std::string& methodName(event.getMethodName());
+	if (methodName == "list") {
+	    GList *plist = NULL;
+	    GList *interface_list = NULL;
+
+	    _qtype::Variant::List s_list;
+	    sigar_net_interface_config_t *ifconfig = NULL;
 	    
-	case _qmf::Network::METHOD_STOP:
-	    {
-		_qmf::ArgsNetworkStop& ioArgs = (_qmf::ArgsNetworkStop&) arguments;
-                ioArgs.o_status = interface_status(ioArgs.i_iface.c_str());
-		if(ioArgs.o_status == 0) {
-		    network_stop(ioArgs.i_iface.c_str());
-		    ioArgs.o_status = interface_status(ioArgs.i_iface.c_str());
-		}
+	    interface_list = network_get_interfaces();
+	    for(plist = g_list_first(interface_list); plist; plist = g_list_next(plist)) {
+		ifconfig = (sigar_net_interface_config_t *)plist->data;
+		s_list.push_back(ifconfig->name);
 	    }
-	    return Manageable::STATUS_OK;
+	    event.addReturnArgument("iface_map", s_list);
 
-	case _qmf::Network::METHOD_STATUS:
-	    {
-		_qmf::ArgsNetworkStatus& ioArgs = (_qmf::ArgsNetworkStatus&) arguments;
-		ioArgs.o_status = interface_status(ioArgs.i_iface.c_str());
+	} else if (methodName == "start") {
+	    int rc = interface_status(event.getArguments()["iface"].asString().c_str());
 
+	    if(rc == 1) {
+		network_start(event.getArguments()["iface"].asString().c_str());
+		rc = interface_status(event.getArguments()["iface"].asString().c_str());
 	    }
-	    return Manageable::STATUS_OK;
+	    event.addReturnArgument("status", rc);
 
-	case _qmf::Network::METHOD_GET_IP_ADDRESS:
-	    {
-		_qmf::ArgsNetworkGet_ip_address& ioArgs = (_qmf::ArgsNetworkGet_ip_address&) arguments;
-
-                ioArgs.o_ip = g_strdup((network_get_ip_address(ioArgs.i_iface.c_str())));
+	} else if (methodName == "stop") {
+	    int rc = interface_status(event.getArguments()["iface"].asString().c_str());
+	    if(rc == 0) {
+		network_stop(event.getArguments()["iface"].asString().c_str());
+		rc = interface_status(event.getArguments()["iface"].asString().c_str());
 	    }
-	    return Manageable::STATUS_OK;
+	    event.addReturnArgument("status", rc);
+
+	} else if (methodName == "status") {
+	    event.addReturnArgument("status", interface_status(event.getArguments()["iface"].asString().c_str()));
+	    
+	} else if (methodName == "get_ip_address") {
+	    event.addReturnArgument("ip", network_get_ip_address(event.getArguments()["iface"].asString().c_str()));
 
-	case _qmf::Network::METHOD_GET_MAC_ADDRESS:
-	    {
-                const char *mac_str;
-		_qmf::ArgsNetworkGet_mac_address& ioArgs = (_qmf::ArgsNetworkGet_mac_address&) arguments;
+	} else if (methodName == "get_mac_address") {
+	    event.addReturnArgument("mac", network_get_mac_address(event.getArguments()["iface"].asString().c_str()));
 
-                mac_str = network_get_mac_address(ioArgs.i_iface.c_str());
-                ioArgs.o_mac = g_strdup(mac_str);
-	    }
-	    return Manageable::STATUS_OK;
+	} else {
+	    session.raiseException(event, MH_NOT_IMPLEMENTED);
+	    goto bail;
 	}
-    return Manageable::STATUS_NOT_IMPLEMENTED;
+    }
+
+    session.methodSuccess(event);
+  bail:
+    return TRUE;
 }
diff --git a/src/service/matahari-srv.cpp b/src/service/matahari-srv.cpp
index d484626..f0c50ab 100644
--- a/src/service/matahari-srv.cpp
+++ b/src/service/matahari-srv.cpp
@@ -26,28 +26,9 @@
 #include "matahari/mh_agent.h"
 
 #include "qmf/org/matahariproject/Services.h"
-#include "qmf/org/matahariproject/ArgsServicesList.h"
-#include "qmf/org/matahariproject/ArgsServicesDescribe.h"
-#include "qmf/org/matahariproject/ArgsServicesStop.h"
-#include "qmf/org/matahariproject/ArgsServicesStart.h"
-#include "qmf/org/matahariproject/ArgsServicesStatus.h"
-#include "qmf/org/matahariproject/ArgsServicesEnable.h"
-#include "qmf/org/matahariproject/ArgsServicesDisable.h"
-#include "qmf/org/matahariproject/ArgsServicesCancel.h"
-#include "qmf/org/matahariproject/ArgsServicesFail.h"
 #include "qmf/org/matahariproject/EventService_op.h"
 
 #include "qmf/org/matahariproject/Resources.h"
-#include "qmf/org/matahariproject/ArgsResourcesList.h"
-#include "qmf/org/matahariproject/ArgsResourcesList_classes.h"
-#include "qmf/org/matahariproject/ArgsResourcesList_ocf_providers.h"
-#include "qmf/org/matahariproject/ArgsResourcesDescribe.h"
-#include "qmf/org/matahariproject/ArgsResourcesStop.h"
-#include "qmf/org/matahariproject/ArgsResourcesStart.h"
-#include "qmf/org/matahariproject/ArgsResourcesMonitor.h"
-#include "qmf/org/matahariproject/ArgsResourcesInvoke.h"
-#include "qmf/org/matahariproject/ArgsResourcesCancel.h"
-#include "qmf/org/matahariproject/ArgsResourcesFail.h"
 #include "qmf/org/matahariproject/EventResource_op.h"
 
 extern "C" { 
@@ -67,7 +48,7 @@ class SrvManageable : public Manageable
 	    agent->addObject(this->_management_object);
 	};
 	ManagementObject* GetManagementObject() const { return _management_object; }
-	status_t ManagementMethod(uint32_t method, Args& arguments, string& text);
+	gboolean invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data);
 };
 
 class RscManageable : public Manageable
@@ -83,7 +64,7 @@ class RscManageable : public Manageable
 	    agent->addObject(this->_management_object);
 	};
 	ManagementObject* GetManagementObject() const { return _management_object; }
-	status_t ManagementMethod(uint32_t method, Args& arguments, string& text);
+	gboolean invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data);
 };
 
 class SrvAgent : public MatahariAgent
@@ -175,211 +156,184 @@ SrvAgent::setup(ManagementAgent* agent)
     return 0;
 }
 
-Manageable::status_t
-SrvManageable::ManagementMethod(uint32_t method, Args& arguments, string& text)
+gboolean 
+SrvManageable::invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data)
 {
     int default_timeout_ms = 60000;
-    switch(method)
-	{
-	case _qmf::Services::METHOD_LIST:
-	    {
-		GList *gIter = NULL;
-		GList *services = services_list();
-		_qmf::ArgsServicesList& ioArgs = (_qmf::ArgsServicesList&) arguments;
+    const std::string& methodName(event.getMethodName());
+    if(event.getType() != qmf::AGENT_METHOD) {
+	return TRUE;
+    }
+    
+    if (methodName == "list") {
+	_qtype::Variant::List s_list;
+	GList *gIter = NULL;
+	GList *services = services_list();
 		
-		for(gIter = services; gIter != NULL; gIter = gIter->next) {
-		    ioArgs.o_services.push_back((const char *)gIter->data);
-		}
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Services::METHOD_ENABLE:
-	    {
-		_qmf::ArgsServicesEnable& ioArgs = (_qmf::ArgsServicesEnable&) arguments;
-		svc_action_t * op = services_action_create(ioArgs.i_name.c_str(), "enable", 0, default_timeout_ms);
-		services_action_sync(op);
-		services_action_free(op);
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Services::METHOD_DISABLE:
-	    {
-		_qmf::ArgsServicesDisable& ioArgs = (_qmf::ArgsServicesDisable&) arguments;
-		svc_action_t * op = services_action_create(ioArgs.i_name.c_str(), "disable", 0, default_timeout_ms);
-		services_action_sync(op);
-		services_action_free(op);
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Services::METHOD_START:
-	    {
-		_qmf::ArgsServicesStart& ioArgs = (_qmf::ArgsServicesStart&) arguments;
-		svc_action_t *op = services_action_create(ioArgs.io_name.c_str(), "start", 0, ioArgs.i_timeout);
-		services_action_sync(op);
-		ioArgs.o_rc = op->rc;
-		services_action_free(op);
-	    }
-	    return Manageable::STATUS_OK;
+	for(gIter = services; gIter != NULL; gIter = gIter->next) {
+	    s_list.push_back((const char *)gIter->data);
+	}
+
+	event.addReturnArgument("services", s_list);
+
+    } else if (methodName == "enable") {
+	svc_action_t * op = services_action_create(
+	    event.getArguments()["name"].asString().c_str(), "enable", 0, default_timeout_ms);
+	services_action_sync(op);
+	services_action_free(op);
+
+    } else if (methodName == "disable") {
+	svc_action_t * op = services_action_create(
+	    event.getArguments()["name"].asString().c_str(), "disable", 0, default_timeout_ms);
+	services_action_sync(op);
+	services_action_free(op);
+
+    } else if (methodName == "start") {
+	svc_action_t *op = services_action_create(
+	    event.getArguments()["name"].asString().c_str(), "start", 0, event.getArguments()["timeout"]);
+	services_action_sync(op);
+	event.addReturnArgument("rc", op->rc);
+	services_action_free(op);
 	    
-	case _qmf::Services::METHOD_STOP:
-	    {
-		_qmf::ArgsServicesStop& ioArgs = (_qmf::ArgsServicesStop&) arguments;
-		svc_action_t * op = services_action_create(ioArgs.io_name.c_str(), "stop", 0, ioArgs.i_timeout);
-		services_action_sync(op);
-		ioArgs.o_rc = op->rc;
-		services_action_free(op);
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Services::METHOD_STATUS:
-	    {
-		_qmf::ArgsServicesStatus& ioArgs = (_qmf::ArgsServicesStatus&) arguments;
-		svc_action_t *op = services_action_create(ioArgs.io_name.c_str(), "status", ioArgs.io_interval, ioArgs.i_timeout);
-
-		if(ioArgs.io_interval) {
-		    return Manageable::STATUS_NOT_IMPLEMENTED;
-
-		    services_action_async(op, mh_service_callback);
-		    ioArgs.o_rc = OCF_PENDING;
-
-		} else {
-		    services_action_sync(op);
-		    ioArgs.o_rc = op->rc;
-		    services_action_free(op);
-		}
-	    }	    
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Services::METHOD_CANCEL:
-	    {
-		_qmf::ArgsServicesCancel& ioArgs = (_qmf::ArgsServicesCancel&) arguments;
-		services_action_cancel(ioArgs.i_name.c_str(), ioArgs.i_action.c_str(), ioArgs.i_interval);
-	    }
+    } else if (methodName == "stop") {
+	svc_action_t * op = services_action_create(
+	    event.getArguments()["name"].asString().c_str(), "stop", 0, event.getArguments()["timeout"]);
+	services_action_sync(op);
+	event.addReturnArgument("rc", op->rc);
+	services_action_free(op);
+
+    } else if (methodName == "status") {
+	svc_action_t *op = services_action_create(
+	    event.getArguments()["name"].asString().c_str(), "status", 
+	    event.getArguments()["interval"], event.getArguments()["timeout"]);
 	    
-	    return Manageable::STATUS_OK;
-
-	// case _qmf::Services::METHOD_DESCRIBE:
+	if(event.getArguments()["interval"]) {
+	    session.raiseException(event, MH_NOT_IMPLEMENTED);
+	    return TRUE;
+		
+	    services_action_async(op, mh_service_callback);
+	    event.addReturnArgument("rc", OCF_PENDING);
+		
+	} else {
+	    services_action_sync(op);
+	    event.addReturnArgument("rc", op->rc);
+	    services_action_free(op);
 	}
-    return Manageable::STATUS_NOT_IMPLEMENTED;
+
+    } else if (methodName == "cancel") {
+	services_action_cancel(
+	    event.getArguments()["name"].asString().c_str(), event.getArguments()["action"].asString().c_str(), 
+	    event.getArguments()["interval"]);
+
+    } else {
+	session.raiseException(event, MH_NOT_IMPLEMENTED);
+	return TRUE;
+    }
+    
+    session.methodSuccess(event);
+    return TRUE;
 }
 
-Manageable::status_t
-RscManageable::ManagementMethod(uint32_t method, Args& arguments, string& text)
+gboolean
+RscManageable::invoke(qmf::AgentSession session, qmf::AgentEvent event, gpointer user_data)
 {
-    switch(method)
-	{
-	case _qmf::Resources::METHOD_LIST_CLASSES:
-	    {
-		_qmf::ArgsResourcesList_classes& ioArgs = (_qmf::ArgsResourcesList_classes&) arguments;
-		ioArgs.o_classes.push_back("ocf");
-		ioArgs.o_classes.push_back("lsb");
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Resources::METHOD_LIST_OCF_PROVIDERS:
-	    {
-		GList *gIter = NULL;
-		GList *providers = resources_list_ocf_providers();
-		_qmf::ArgsResourcesList_ocf_providers& ioArgs = (_qmf::ArgsResourcesList_ocf_providers&) arguments;
-		
-		for(gIter = providers; gIter != NULL; gIter = gIter->next) {
-		    ioArgs.o_providers.push_back((const char *)gIter->data);
-		}
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Resources::METHOD_LIST:
-	    {
-		GList *gIter = NULL;
-		_qmf::ArgsResourcesList& ioArgs = (_qmf::ArgsResourcesList&) arguments;
-		GList *agents = resources_list_ocf_agents(ioArgs.i_provider.c_str());
+    const std::string& methodName(event.getMethodName());
+    if(event.getType() != qmf::AGENT_METHOD) {
+	return TRUE;
+    }
+    
+    if (methodName == "list_classes") {
+	_qtype::Variant::List c_list;
+	c_list.push_back("ocf");
+	c_list.push_back("lsb");
+	event.addReturnArgument("classes", c_list);
+
+    } else if (methodName == "list_ocf_providers") {
+	GList *gIter = NULL;
+	GList *providers = resources_list_ocf_providers();
+	_qtype::Variant::List p_list;
 		
-		for(gIter = agents; gIter != NULL; gIter = gIter->next) {
-		    ioArgs.o_types.push_back((const char *)gIter->data);
-		}
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Resources::METHOD_START:
-	    {
-		_qmf::ArgsResourcesStart& ioArgs = (_qmf::ArgsResourcesStart&) arguments;
-		GHashTable *params = qmf_map_to_hash(ioArgs.i_parameters);
-		svc_action_t *op = resources_action_create(
-		    ioArgs.io_name.c_str(), ioArgs.io_provider.c_str(), ioArgs.io_type.c_str(),
-		    "start", 0, ioArgs.i_timeout, params);
-		services_action_sync(op);
-		ioArgs.o_rc = op->rc;
-		services_action_free(op);
-	    }
-	    return Manageable::STATUS_OK;
-	    
-	case _qmf::Resources::METHOD_STOP:
-	    {
-		_qmf::ArgsResourcesStop& ioArgs = (_qmf::ArgsResourcesStop&) arguments;
-		GHashTable *params = qmf_map_to_hash(ioArgs.i_parameters);
-		svc_action_t *op = resources_action_create(
-		    ioArgs.io_name.c_str(), ioArgs.io_provider.c_str(), ioArgs.io_type.c_str(),
-		    "stop", 0, ioArgs.i_timeout, params);
-		services_action_sync(op);
-		ioArgs.o_rc = op->rc;
-		services_action_free(op);
-	    }
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Resources::METHOD_MONITOR:
-	    {
-		_qmf::ArgsResourcesMonitor& ioArgs = (_qmf::ArgsResourcesMonitor&) arguments;
-		GHashTable *params = qmf_map_to_hash(ioArgs.i_parameters);
-		svc_action_t *op = resources_action_create(
-		    ioArgs.io_name.c_str(), ioArgs.io_provider.c_str(), ioArgs.io_type.c_str(),
-		    "monitor", ioArgs.io_interval, ioArgs.i_timeout, params);
-
-		if(op->interval) {
-		    return Manageable::STATUS_NOT_IMPLEMENTED;
-
-		    services_action_async(op, mh_resource_callback);
-		    ioArgs.o_rc = OCF_PENDING;
-
-		} else {
-		    services_action_sync(op);
-		    ioArgs.o_rc = op->rc;
-		    services_action_free(op);
-		}
-	    }	    
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Resources::METHOD_INVOKE:
-	    {
-		_qmf::ArgsResourcesInvoke& ioArgs = (_qmf::ArgsResourcesInvoke&) arguments;
-		GHashTable *params = qmf_map_to_hash(ioArgs.i_parameters);
-		svc_action_t *op = resources_action_create(
-		    ioArgs.io_name.c_str(), ioArgs.io_provider.c_str(), ioArgs.io_type.c_str(),
-		    ioArgs.io_action.c_str(), ioArgs.io_interval, ioArgs.i_timeout, params);
+	for(gIter = providers; gIter != NULL; gIter = gIter->next) {
+	    p_list.push_back((const char *)gIter->data);
+	}
+	event.addReturnArgument("providers", p_list);
 
+    } else if (methodName == "list") {
+	GList *gIter = NULL;
+	GList *agents = resources_list_ocf_agents(event.getArguments()["provider"].asString().c_str());
+	_qtype::Variant::List t_list;
 		
-		if(op->interval) {
-		    return Manageable::STATUS_NOT_IMPLEMENTED;
-
-		    services_action_async(op, mh_resource_callback);
-		    ioArgs.o_rc = OCF_PENDING;
-
-		} else {
-		    services_action_sync(op);
-		    ioArgs.o_rc = op->rc;
-		    services_action_free(op);
-		}
-	    }	    
-	    return Manageable::STATUS_OK;
-
-	case _qmf::Resources::METHOD_CANCEL:
-	    {
-		_qmf::ArgsResourcesCancel& ioArgs = (_qmf::ArgsResourcesCancel&) arguments;
-		services_action_cancel(ioArgs.io_name.c_str(), ioArgs.io_action.c_str(), ioArgs.io_interval);
-	    }
-	    
-	    return Manageable::STATUS_OK;
+	for(gIter = agents; gIter != NULL; gIter = gIter->next) {
+	    t_list.push_back((const char *)gIter->data);
+	}
+	event.addReturnArgument("types", t_list);
+
+    } else if (methodName == "start") {
+	GHashTable *params = qmf_map_to_hash(event.getArguments()["parameters"].asMap());
+	svc_action_t *op = resources_action_create(
+	    event.getArguments()["name"].asString().c_str(), event.getArguments()["provider"].asString().c_str(),
+	    event.getArguments()["type"].asString().c_str(), "start", 0, event.getArguments()["timeout"], params);
+	services_action_sync(op);
+	event.addReturnArgument("rc", op->rc);
+	services_action_free(op);
+
+    } else if (methodName == "stop") {
+	GHashTable *params = qmf_map_to_hash(event.getArguments()["parameters"].asMap());
+	svc_action_t *op = resources_action_create(
+	    event.getArguments()["name"].asString().c_str(), event.getArguments()["provider"].asString().c_str(),
+	    event.getArguments()["type"].asString().c_str(), "stop", 0, event.getArguments()["timeout"], params);
+	services_action_sync(op);
+	event.addReturnArgument("rc", op->rc);
+	services_action_free(op);
+
+    } else if (methodName == "monitor") {
+	GHashTable *params = qmf_map_to_hash(event.getArguments()["parameters"].asMap());
+	svc_action_t *op = resources_action_create(
+	    event.getArguments()["name"].asString().c_str(), event.getArguments()["provider"].asString().c_str(),
+	    event.getArguments()["type"].asString().c_str(), "monitor", event.getArguments()["interval"], 
+	    event.getArguments()["timeout"], params);
+
+	if(op->interval) {
+	    session.raiseException(event, MH_NOT_IMPLEMENTED);
+	    return TRUE;
+
+	    services_action_async(op, mh_resource_callback);
+	    event.addReturnArgument("rc", OCF_PENDING);
+
+	} else {
+	    services_action_sync(op);
+	    event.addReturnArgument("rc", op->rc);
+	    services_action_free(op);
+	}
+    } else if (methodName == "invoke") {
+	GHashTable *params = qmf_map_to_hash(event.getArguments()["parameters"].asMap());
+	svc_action_t *op = resources_action_create(
+	    event.getArguments()["name"].asString().c_str(), event.getArguments()["provider"].asString().c_str(), 
+	    event.getArguments()["type"].asString().c_str(), event.getArguments()["action"].asString().c_str(),
+	    event.getArguments()["interval"], event.getArguments()["timeout"], params);
+		
+	if(op->interval) {
+	    session.raiseException(event, MH_NOT_IMPLEMENTED);
+	    return TRUE;
+
+	    services_action_async(op, mh_resource_callback);
+	    event.addReturnArgument("rc", OCF_PENDING);
 
-	// case _qmf::Resources::METHOD_DESCRIBE:
+	} else {
+	    services_action_sync(op);
+	    event.addReturnArgument("rc", op->rc);
+	    services_action_free(op);
 	}
-    return Manageable::STATUS_NOT_IMPLEMENTED;
+    } else if (methodName == "cancel") {
+	services_action_cancel(
+	    event.getArguments()["name"].asString().c_str(), event.getArguments()["action"].asString().c_str(),
+	    event.getArguments()["interval"]);
+
+    } else {
+	session.raiseException(event, MH_NOT_IMPLEMENTED);
+	return TRUE;
+    }
+	    
+    session.methodSuccess(event);
+    return TRUE;
 }