Introduce the public includes for the QMF interfaces.

Rename Agent to AgentEngine to differentiate the API from the underlying engine.

Note that some of these public headers will overlap with the emerging "messaging"
API (notably Connection.h and ConnectionSettings.h).  It is desirable that these
components of the API become common between "messaging" and "qmf".  As such, once
the differences are reconciled, they will most likely be removed from the qmf space
and placed in the messaging space.



git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@805916 13f79535-47bb-0310-9956-ffa450edef68

13 files changed, 786 insertions, 120 deletions

diff --git a/qpid/cpp/bindings/qmf/qmfengine.i b/qpid/cpp/bindings/qmf/qmfengine.i
index 3c67d92031..e1a4c53bec 100644
--- a/qpid/cpp/bindings/qmf/qmfengine.i
+++ b/qpid/cpp/bindings/qmf/qmfengine.i
@@ -19,7 +19,7 @@
 
 %{
 
-#include "Agent.h"
+#include "AgentEngine.h"
 #include <ResilientConnection.h>
 
 %}
@@ -27,7 +27,7 @@
 
 %include <Query.h>
 %include <Message.h>
-%include <Agent.h>
+%include <AgentEngine.h>
 %include <ResilientConnection.h>
 %include <Typecode.h>
 %include <Schema.h>
diff --git a/qpid/cpp/bindings/qmf/ruby/Makefile.am b/qpid/cpp/bindings/qmf/ruby/Makefile.am
index 532fdb6875..1dc08f646a 100644
--- a/qpid/cpp/bindings/qmf/ruby/Makefile.am
+++ b/qpid/cpp/bindings/qmf/ruby/Makefile.am
@@ -36,7 +36,7 @@ rubylibarchdir = $(RUBY_LIB_ARCH)
 rubylibarch_LTLIBRARIES = qmfengine.la
 
 qmfengine_la_LDFLAGS = -avoid-version -module -shrext ".$(RUBY_DLEXT)"
-qmfengine_la_LIBADD = $(RUBY_LIBS) -L$(top_builddir)/src/.libs -lqpidclient $(top_builddir)/src/libqmfcommon.la
+qmfengine_la_LIBADD = $(RUBY_LIBS) -L$(top_builddir)/src/.libs -lqpidclient $(top_builddir)/src/libqmfagent.la
 qmfengine_la_CXXFLAGS = $(INCLUDES) -I$(RUBY_INC) -I$(RUBY_INC_ARCH)
 nodist_qmfengine_la_SOURCES = qmfengine.cpp
 
diff --git a/qpid/cpp/bindings/qmf/ruby/qmf.rb b/qpid/cpp/bindings/qmf/ruby/qmf.rb
index 7ee447c675..35a76c490a 100644
--- a/qpid/cpp/bindings/qmf/ruby/qmf.rb
+++ b/qpid/cpp/bindings/qmf/ruby/qmf.rb
@@ -33,11 +33,11 @@ module Qmf
     class ConnectionSettings < Qmfengine::ConnectionSettings
     end
 
-    class ConnectionEvent
+    class ConnectionHandler
         def conn_event_connected(); end
         def conn_event_disconnected(error); end
-        def conn_event_session_closed(context, error); end
-        def conn_event_recv(context, message); end
+        def sess_event_session_closed(context, error); end
+        def sess_event_recv(context, message); end
     end
 
     class Query
@@ -63,15 +63,10 @@ module Qmf
       end
     end
 
-    class AgentHandler
-      def get_query(context, query, userId); end
-      def method_call(context, name, object_id, args, userId); end
-    end
-
     class Connection
       attr_reader :impl
 
-      def initialize(settings, event_handler = nil, delay_min = 1, delay_max = 128, delay_factor = 2)
+      def initialize(settings, delay_min = 1, delay_max = 128, delay_factor = 2)
         @impl = Qmfengine::ResilientConnection.new(settings, delay_min, delay_max, delay_factor)
         @sockEngine, @sock = Socket::socketpair(Socket::PF_UNIX, Socket::SOCK_STREAM, 0)
         @impl.setNotifyFd(@sockEngine.fileno)
@@ -232,7 +227,12 @@ module Qmf
       end
     end
 
-    class Agent
+    class AgentHandler
+      def get_query(context, query, userId); end
+      def method_call(context, name, object_id, args, userId); end
+    end
+
+    class Agent < ConnectionHandler
       def initialize(handler, label="")
         if label == ""
           @agentLabel = "rb-%s.%d" % [Socket.gethostname, Process::pid]
@@ -241,7 +241,7 @@ module Qmf
         end
         @conn = nil
         @handler = handler
-        @impl = Qmfengine::Agent.new(@agentLabel)
+        @impl = Qmfengine::AgentEngine.new(@agentLabel)
         @event = Qmfengine::AgentEvent.new
         @xmtMessage = Qmfengine::Message.new
       end
diff --git a/qpid/cpp/include/qmf/Agent.h b/qpid/cpp/include/qmf/Agent.h
new file mode 100644
index 0000000000..2ba639ca37
--- /dev/null
+++ b/qpid/cpp/include/qmf/Agent.h
@@ -0,0 +1,283 @@
+#ifndef _QmfAgent_
+#define _QmfAgent_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qmf/QmfImportExport.h"
+
+namespace qmf {
+
+    class AgentImpl;
+    class Connection;
+    class ObjectId;
+    class AgentObject;
+    class Value;
+    class Event;
+    class SchemaObjectClass;
+
+    /**
+     * AgentListener is used by agents that select the internalStore=false option (see Agent
+     * constructor) or by agents that wish to provide access control for queries and methods.
+     */
+    class AgentListener {
+        QMF_EXTERN virtual ~AgentListener();
+
+        /**
+         * allowQuery is called before a query operation is executed.  If true is returned
+         * by this function, the query will proceed.  If false is returned, the query will
+         * be forbidden.
+         *
+         * @param q The query being requested.
+         * @param userId The authenticated identity of the user requesting the query.
+         */
+        virtual bool allowQuery(const Query& q, const char* userId);
+
+        /**
+         * allowMethod is called before a method call is executed.  If true is returned
+         * by this function, the method call will proceed.  If false is returned, the method
+         * call will be forbidden.
+         *
+         * @param name The name of the method being called.
+         * @param args A value object (of type "map") that contains both input and output arguments.
+         * @param oid The objectId that identifies the instance of the object being called.
+         * @param cls The Schema describing the object being called.
+         * @param userId The authenticated identity of the requesting user.
+         */
+        virtual bool allowMethod(const char* name, const Value& args, const ObjectId& oid,
+                                 const SchemaObjectClass& cls, const char* userId);
+
+        /**
+         * query is called when the agent receives a query request.  The handler must invoke
+         * Agent::queryResponse zero or more times (using the supplied context) followed by
+         * a single invocation of Agent::queryComplete.  These calls do not need to be made
+         * synchronously in the context of this function.  They may occur before or after this
+         * function returns.
+         *
+         * This function will only be invoked if internalStore=false in the Agent's constructor.
+         *
+         * @param context A context value to use in resulting calls to queryResponse and quertComplete.
+         * @param q The query requested by the console.
+         * @param userId the authenticated identity of the user requesting the query.
+         */
+        virtual void query(uint32_t context, const Query& q, const char* userId);
+
+        /**
+         * syncStart is called when a console requests a standing query.  This function must
+         * behave exactly like AgentListener::query (i.e. send zero or more responses followed
+         * by a queryComplete) except it then remembers the context and the query and makes
+         * subsequent queryResponse calls whenever appropriate according the the query.
+         *
+         * The standing query shall stay in effect until syncStop is called with the same context
+         * value or until a specified period of time elapses without receiving a syncTouch for the
+         * context.
+         *
+         * This function will only be invoked if internalStore=false in the Agent's constructor.
+         *
+         * @param context A context value to use in resulting calls to queryResponse and queryComplete.
+         * @param q The query requested by the console.
+         * @param userId the authenticated identity of the user requesting the query.
+         */
+        virtual void syncStart(uint32_t context, const Query& q, const char* userId);
+
+        /**
+         * syncTouch is called when the console that requested a standing query refreshes its
+         * interest in the query.  The console must periodically "touch" a standing query to keep
+         * it alive.  This prevents standing queries from accumulating when the console disconnects
+         * before it can stop the query.
+         *
+         * This function will only be invoked if internalStore=false in the Agent's constructor.
+         *
+         * @param context The context supplied in a previous call to syncStart.
+         * @param userId The authenticated identity of the requesting user.
+         */
+        virtual void syncTouch(uint32_t context, const char* userId);
+
+        /**
+         * syncStop is called when the console that requested a standing query no longer wishes to
+         * receive data associated with that query.  The application shall stop processing this
+         * query and shall remove its record of the context value.
+         *
+         * This function will only be invoked if internalStore=false in the Agent's constructor.
+         *
+         * @param context The context supplied in a previous call to syncStart.
+         * @param userId The authenticated identity of the requesting user.
+         */
+        virtual void syncStop(uint32_t context, const char* userId);
+
+        /**
+         * methodCall is called when a console invokes a method on a QMF object.  The application
+         * must call Agent::methodResponse once in response to this function.  The response does
+         * not need to be called synchronously in the context of this function.  It may be called
+         * before or after this function returns.
+         *
+         * This function will only be invoked if internalStore=false in the Agent's constructor.
+         *
+         * @param context A context value to use in resulting call to methodResponse.
+         * @param name The name of the method being called.
+         * @param args A value object (of type "map") that contains both input and output arguments.
+         * @param oid The objectId that identifies the instance of the object being called.
+         * @param cls The Schema describing the object being called.
+         * @param userId The authenticated identity of the requesting user.
+         */
+        virtual void methodCall(uint32_t context, const char* name, Value& args,
+                                const ObjectId& oid, const SchemaObjectClass& cls, const char* userId);
+    };
+
+    /**
+     * The Agent class is the QMF Agent portal.  It should be instantiated once and associated with a
+     * Connection (setConnection) to connect an agent to the QMF infrastructure.
+     */
+    class Agent {
+    public:
+        /**
+         * Create an instance of the Agent class.
+         *
+         * @param label An optional string label that can be used to identify the agent.
+         *
+         * @param internalStore If true, objects shall be tracked internally by the agent.
+         *                      If false, the user of the agent must track the objects.
+         *        If the agent is tracking the objects, queries and syncs are handled by
+         *        the agent.  The only involvement the user has is to optionally authorize
+         *        individual operations.  If the user is tracking the objects, the user code
+         *        must implement queries and syncs (standing queries).
+         *
+         * @param listener A pointer to a class that implements the AgentListener interface.
+         *        This must be supplied if any of the following conditions are true:
+         *          - The agent model contains methods
+         *          - The user wishes to individually authorize query and sync operations.
+         *          - internalStore = false
+         */
+        QMF_EXTERN Agent(char* label="qmfa", bool internalStore=true, AgentListener* listener=0);
+
+        /**
+         * Destroy an instance of the Agent class.
+         */
+        QMF_EXTERN ~Agent();
+
+        /**
+         * Set the persistent store file.  This file, if specified, is used to store state information
+         * about the Agent.  For example, if object-ids must be persistent across restarts of the Agent
+         * program, this file path must be supplied.
+         *
+         * @param path Full path to a file that is both writable and readable by the Agent program.
+         */
+        QMF_EXTERN void setStoreDir(const char* path);
+
+        /**
+         * Provide a connection (to a Qpid broker) over which the agent can communicate.
+         *
+         * @param conn Pointer to a Connection object.
+         */
+        QMF_EXTERN void setConnection(Connection* conn);
+
+        /**
+         * Register a class schema (object or event) with the agent.  The agent must have a registered
+         * schema for an object class or an event class before it can handle objects or events of that
+         * class.
+         *
+         * @param cls Pointer to the schema structure describing the class.
+         */
+        QMF_EXTERN void registerClass(SchemaObjectClass* cls);
+        QMF_EXTERN void registerClass(SchemaEventClass* cls);
+
+        /**
+         * Add an object to the agent (for internal storage mode only).
+         *
+         * @param obj Reference to the object to be managed by the agent.
+         *
+         * @param persistent Iff true, the object ID assigned to the object shall indicate persistence
+         *                   (i.e. the object ID shall be the same across restarts of the agent program).
+         *
+         * @param oid 64-bit value for the oid (if zero, the agent will assign the value).
+         *
+         * @param oidLo 32-bit value for the lower 32-bits of the oid.
+         *
+         * @param oidHi 32-bit value for the upper 32-bits of the oid.
+         */
+        QMF_EXTERN const ObjectId* addObject(AgentObject& obj, bool persistent=false, uint64_t oid=0);
+        QMF_EXTERN const ObjectId* addObject(AgentObject& obj, bool persistent, uint32_t oidLo, uint32_t oidHi);
+
+        /**
+         * Allocate an object ID for an object (for external storage mode only).
+         *
+         * @param persistent Iff true, the object ID allocated shall indicate persistence
+         *                   (i.e. the object ID shall be the same across restarts of the agent program).
+         *
+         * @param oid 64-bit value for the oid (if zero, the agent will assign the value).
+         *
+         * @param oidLo 32-bit value for the lower 32-bits of the oid.
+         *
+         * @param oidHi 32-bit value for the upper 32-bits of the oid.
+         */
+        QMF_EXTERN const ObjectId* allocObjectId(bool persistent=false, uint64_t oid=0);
+        QMF_EXTERN const ObjectId* allocObjectId(bool persistent, uint32_t oidLo, uint32_t oidHi);
+
+        /**
+         * Raise a QMF event.
+         *
+         * @param event Reference to an event object to be raised to the QMF infrastructure.
+         */
+        QMF_EXTERN void raiseEvent(Event& event);
+
+        /**
+         * Provide a response to a query (for external storage mode only).
+         *
+         * @param context The context value supplied in the query (via the AgentListener interface).
+         *
+         * @param object A reference to the agent that matched the query criteria.
+         *
+         * @param prop If true, transmit the property attributes of this object.
+         *
+         * @param stat If true, transmit the statistic attributes of this object.
+         */
+        QMF_EXTERN void queryResponse(uint32_t context, AgentObject& object, bool prop = true, bool stat = true);
+
+        /**
+         * Indicate that a query (or the initial dump of a sync) is complete (for external storage mode only).
+         *
+         * @param context The context value supplied in the query/sync (via the AgentListener interface).
+         */
+        QMF_EXTERN void queryComplete(uint32_t context);
+
+        /**
+         * Provide the response to a method call.
+         *
+         * @param context The context value supplied in the method request (via the AgentListener interface).
+         *
+         * @param args The argument list from the method call.  Must include the output arguments (may include
+         *             the input arguments).
+         *
+         * @param status Numerical return status: zero indicates no error, non-zero indicates error.
+         *
+         * @param exception Pointer to an exception value.  If status is non-zero, the exception value is
+         *                  sent to the caller.  It is optional (i.e. leave the pointer as 0), or may be
+         *                  set to any legal value.  A string may be supplied, but an unmanaged object of
+         *                  any schema may also be passed.
+         */
+        QMF_EXTERN void methodResponse(uint32_t context, const Value& args, uint32_t status=0,
+                                       const Value* exception=0);
+
+    private:
+        AgentImpl* impl;
+    };
+
+}
+
+#endif
diff --git a/qpid/cpp/include/qmf/AgentObject.h b/qpid/cpp/include/qmf/AgentObject.h
new file mode 100644
index 0000000000..d6073bca3c
--- /dev/null
+++ b/qpid/cpp/include/qmf/AgentObject.h
@@ -0,0 +1,93 @@
+#ifndef _QmfAgentObject_
+#define _QmfAgentObject_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qmf/QmfImportExport.h"
+
+namespace qmf {
+
+    class AgentObjectImpl;
+    class SchemaObjectClass;
+    class ObjectId;
+    class Value;
+    class Agent;
+
+    /**
+     * AgentObject is an extension of Object with agent-specific methods added.
+     */
+    class AgentObject : public Object {
+    public:
+        /**
+         * Create a new Object of a specific type.
+         *
+         * @param type Pointer to the schema class to use as a type for this object.
+         */
+        QMF_EXTERN AgentObject(const SchemaObjectClass* type);
+
+        /**
+         * Schedule this object for deletion.  Agent objects should never be directly
+         * destroyed, rather this method should be called and all pointers to this
+         * object dropped.  The agent will clean up and properly delete the object at
+         * the appropraite time.
+         */
+        QMF_EXTERN void destroy();
+
+        /**
+         * Set the object ID for this object if it is to be managed by the agent.
+         *
+         * @param oid The new object ID for the managed object.
+         */
+        QMF_EXTERN void setObjectId(ObjectId& oid);
+
+        /**
+         * Handler for invoked method calls.  This will only be called for objects that
+         * are being managed and stored by an agent (see internalStore argument in Agent::Agent).
+         * If this function is not overridden in a child class, the default implementation will
+         * cause AgentListener::methodCall to be invoked in the application program.
+         *
+         * If this function is overridden in a sub-class, the implementation must perform
+         * the actions associated with the method call (i.e. implement the method).  Once the
+         * method execution is complete, it must call Agent::methodResponse with the result
+         * of the method execution.  Agent::methodResponse does not need to be called
+         * synchronously in the context of this function call.  It may be called at a later
+         * time from a different thread.
+         *
+         * @param context Context supplied by the agent and required to be passed in the
+         *                call to Agent::methodResponse
+         *
+         * @param name The name of the method.
+         *
+         * @param args A Value (of type map) that contains the input and output arguments.
+         *
+         * @param userId The authenticated identity of the user who invoked the method.
+         */
+        QMF_EXTERN virtual void methodInvoked(uint32_t context, const char* name, Value& args,
+                                              const char* userId);
+    private:
+        friend class Agent;
+        virtual ~AgentObject();
+        void setAgent(Agent* agent);
+        AgentObjectImpl* impl;
+    };
+
+}
+
+#endif 
diff --git a/qpid/cpp/include/qmf/Connection.h b/qpid/cpp/include/qmf/Connection.h
new file mode 100644
index 0000000000..dbe8e97cfe
--- /dev/null
+++ b/qpid/cpp/include/qmf/Connection.h
@@ -0,0 +1,118 @@
+#ifndef _QmfConnection_
+#define _QmfConnection_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qmf/QmfImportExport.h"
+#include "qmf/ConnectionSettings.h"
+
+namespace qmf {
+
+    enum ConnectionState {
+       CONNECTION_UP   = 1,
+       CONNECTION_DOWN = 2
+    };
+
+    /**
+     * Implement a subclass of ConnectionListener and provide it with the
+     * Connection constructor to receive notification of changes in the
+     * connection state.
+     *
+     * \ingroup qmfapi
+     */
+    class ConnectionListener {
+        QMF_EXTERN virtual ~ConnectionListener();
+
+        /**
+         * Called each time the state of the connection changes.
+         */
+        virtual void newState(ConnectionState state);
+
+        /**
+         * Called if the connection requires input from an interactive client.
+         *
+         * @param prompt Text of the prompt - describes what information is required.
+         * @param answer The interactive user input.
+         * @param answerLen on Input - the maximum number of bytes that can be copied to answer.
+         *                  on Output - the number of bytes copied to answer.
+         */
+        virtual void interactivePrompt(const char* prompt, char* answer, uint32_t answerLen);
+    };
+
+    class ConnectionImpl;
+
+    /**
+     * The Connection class represents a connection to a QPID broker that can
+     * be used by agents and consoles, possibly multiple at the same time.
+     *
+     * \ingroup qmfapi
+     */
+    class Connection {
+    public:
+
+        /**
+         * Creates a connection object and begins the process of attempting to
+         * connect to the QPID broker.
+         *
+         * @param settings The settings that control how the connection is set
+         * up.
+         *
+         * @param listener An optional pointer to a subclass of
+         * ConnectionListener to receive notifications of events related to
+         * this connection.
+         */
+        QMF_EXTERN Connection(const ConnectionSettings& settings,
+                              const ConnectionListener* listener = 0);
+
+        /**
+         * Destroys a connection, causing the connection to be closed.
+         */
+        QMF_EXTERN ~Connection();
+
+        /**
+         * Set the administrative state of the connection (enabled or disabled).
+         *
+         * @param enabled True => enable connection, False => disable connection
+         */
+        QMF_EXTERN void setAdminState(bool enabled);
+
+        /**
+         * Return the current operational state of the connection (up or down).
+         *
+         * @return the current connection state.
+         */
+        QMF_EXTERN ConnectionState getOperState() const;
+
+        /**
+         * Get the error message from the last failure to connect.
+         *
+         * @return Null-terminated string containing the error message.
+         */
+        QMF_EXTERN const char* getLastError() const;
+
+    private:
+        friend class AgentImpl;
+        friend class ConsoleImpl;
+        ConnectionImpl* impl;
+    };
+
+}
+
+#endif
diff --git a/qpid/cpp/include/qmf/ConnectionSettings.h b/qpid/cpp/include/qmf/ConnectionSettings.h
new file mode 100644
index 0000000000..b5f3be7eef
--- /dev/null
+++ b/qpid/cpp/include/qmf/ConnectionSettings.h
@@ -0,0 +1,135 @@
+#ifndef _QmfConnectionSettings_
+#define _QmfConnectionSettings_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "qmf/QmfImportExport.h"
+
+namespace qmf {
+
+    class ConnectionSettingsImpl;
+    class Value;
+
+    /**
+     * Settings for AMQP connections to the broker.
+     */
+    class ConnectionSettings {
+    public:
+
+        /**
+         * Create a set of default connection settings.
+         *
+         * If no further attributes are set, the settings will cause a connection to be made to
+         * the default broker (on localhost or at a host/port supplied by service discovery) and
+         * authentication will be the best-available (GSSAPI/Kerberos, Anonymous, Plain with prompts
+         * for username and password).
+         */
+        QMF_EXTERN ConnectionSettings();
+
+        /**
+         * Create a set of connection settings by URL.
+         *
+         * @param url Universal resource locator describing the broker address and additional attributes.
+         *
+         * The URL is of the form:
+         *    amqp[s]://host[:port][?key=value[&key=value]*]
+         *
+         * For example:
+         *    amqp://localhost
+         *    amqp://broker?transport=rdma&authmech=GSSAPI&authservice=qpidd
+         *    amqps://broker?authmech=PLAIN&authuser=guest&authpass=guest
+         */
+        QMF_EXTERN ConnectionSettings(const char* url);
+
+        /**
+         * Destroy the connection settings object.
+         */
+        QMF_EXTERN ~ConnectionSettings();
+
+        /**
+         * Set an attribute to control connection setup.
+         *
+         * @param key A null-terminated string that is an attribute name.
+         *
+         * @param value Reference to a value to be stored as the attribute.  The type of the value
+         *              is specific to the key.
+         */
+        QMF_EXTERN void setAttr(const char* key, const Value& value);
+
+        /**
+         * Get the value of an attribute.
+         *
+         * @param key A null-terminated attribute name.
+         */
+        QMF_EXTERN const Value& getAttr(const char* key) const;
+
+        /**
+         * Get the attribute string (the portion of the URL following the '?') for the settings.
+         *
+         * @return A pointer to the attribute string.  If the content of this string needs to be
+         *         available beyond the scope of the calling function, it should be copied.  The
+         *         returned pointer may become invalid if the set of attributes is changed.
+         */
+        QMF_EXTERN const char* getAttrString() const;
+
+        /**
+         * Shortcuts for setting the transport for the connection.
+         *
+         * @param port The port value for the connection address.
+         */
+        QMF_EXTERN void transportTcp(uint16_t port = 5672);
+        QMF_EXTERN void transportSsl(uint16_t port = 5671);
+        QMF_EXTERN void transportRdma(uint16_t port = 5672);
+
+        /**
+         * Shortcuts for setting authentication mechanisms.
+         *
+         * @param username Null-terminated authentication user name.
+         *
+         * @param password Null-terminated authentication password.
+         *
+         * @param serviceName Null-terminated GSSAPI service name (Kerberos service principal)
+         *
+         * @param minSsf Minimum security factor for connections. 0 = encryption not required.
+         *
+         * @param maxSsf Maximum security factor for connections. 0 = encryption not permitted.
+         */
+        QMF_EXTERN void authAnonymous(const char* username = 0);
+        QMF_EXTERN void authPlain(const char* username = 0, const char* password = 0);
+        QMF_EXTERN void authGssapi(const char* serviceName, uint32_t minSsf = 0, uint32_t maxSsf = 256);
+
+        /**
+         * Shortcut for setting connection retry attributes.
+         *
+         * @param delayMin Minimum delay (in seconds) between connection attempts.
+         *
+         * @param delaxMax Maximum delay (in seconds) between connection attempts.
+         *
+         * @param delayFactor Factor to multiply the delay by between failed connection attempts.
+         */
+        QMF_EXTERN void setRetry(int delayMin = 1, int delayMax = 128, int delayFactor = 2);
+
+    private:
+        ConnectionSettingsImpl* impl;
+    };
+
+}
+
+#endif
diff --git a/qpid/cpp/include/qmf/QmfImportExport.h b/qpid/cpp/include/qmf/QmfImportExport.h
new file mode 100644
index 0000000000..8353a3cc16
--- /dev/null
+++ b/qpid/cpp/include/qmf/QmfImportExport.h
@@ -0,0 +1,33 @@
+#ifndef QMF_IMPORT_EXPORT_H
+#define QMF_IMPORT_EXPORT_H
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+#if defined(WIN32) && !defined(QPID_DECLARE_STATIC)
+#  if defined(QMF_EXPORT) || defined (qmf_EXPORTS)
+#    define QMF_EXTERN __declspec(dllexport)
+#  else
+#    define QMF_EXTERN __declspec(dllimport)
+#  endif
+#else
+#  define QMF_EXTERN
+#endif
+
+#endif
diff --git a/qpid/cpp/src/qmf.mk b/qpid/cpp/src/qmf.mk
index 62393cdcfb..8ccc1f4a95 100644
--- a/qpid/cpp/src/qmf.mk
+++ b/qpid/cpp/src/qmf.mk
@@ -18,7 +18,7 @@
 #
 
 #
-# qmf agent library makefile fragment, to be included in Makefile.am
+# qmf library makefile fragment, to be included in Makefile.am
 # 
 lib_LTLIBRARIES +=				\
   libqmfcommon.la				\
@@ -27,13 +27,15 @@ lib_LTLIBRARIES +=				\
 # Public header files
 nobase_include_HEADERS +=			\
   ../include/qpid/agent/ManagementAgent.h	\
-  ../include/qpid/agent/QmfAgentImportExport.h
-
+  ../include/qpid/agent/QmfAgentImportExport.h	\
+  ../include/qmf/Agent.h			\
+  ../include/qmf/Connection.h			\
+  ../include/qmf/QmfImportExport.h		\
+  ../include/qmf/ConnectionSettings.h		\
+  ../include/qmf/AgentObject.h
 
 libqmfcommon_la_SOURCES =			\
-  qmf/Agent.cpp					\
-  qmf/Agent.h					\
-  qmf/Console.h					\
+  qmf/ConsoleEngine.h				\
   qmf/Event.h					\
   qmf/Message.h					\
   qmf/MessageImpl.cpp				\
@@ -58,9 +60,9 @@ libqmfcommon_la_SOURCES =			\
   qmf/ValueImpl.h
 
 libqmfagent_la_SOURCES =			\
-  ../include/qpid/agent/ManagementAgent.h	\
+  qmf/AgentEngine.cpp				\
+  qmf/AgentEngine.h				\
   qpid/agent/ManagementAgentImpl.cpp		\
-  qpid/agent/ManagementAgentImpl.h		\
-  qmf/Agent.cpp
+  qpid/agent/ManagementAgentImpl.h
 
-libqmfagent_la_LIBADD = libqpidclient.la
+libqmfagent_la_LIBADD = libqpidclient.la libqmfcommon.la
diff --git a/qpid/cpp/src/qmf/Agent.cpp b/qpid/cpp/src/qmf/AgentEngine.cpp
index 6d59ae2750..bef8b3d102 100644
--- a/qpid/cpp/src/qmf/Agent.cpp
+++ b/qpid/cpp/src/qmf/AgentEngine.cpp
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-#include "qmf/Agent.h"
+#include "qmf/AgentEngine.h"
 #include "qmf/MessageImpl.h"
 #include "qmf/SchemaImpl.h"
 #include "qmf/Typecode.h"
@@ -77,13 +77,13 @@ namespace qmf {
         AgentQueryContext() : schemaMethod(0) {}
     };
 
-    class AgentImpl {
+    class AgentEngineImpl {
     public:
-        AgentImpl(char* label, bool internalStore);
-        ~AgentImpl();
+        AgentEngineImpl(char* label, bool internalStore);
+        ~AgentEngineImpl();
 
-        void setStoreDir(char* path);
-        void setTransferDir(char* path);
+        void setStoreDir(const char* path);
+        void setTransferDir(const char* path);
         void handleRcvMessage(Message& message);
         bool getXmtMessage(Message& item);
         void popXmt();
@@ -200,9 +200,9 @@ namespace qmf {
     };
 }
 
-const char* AgentImpl::QMF_EXCHANGE = "qpid.management";
-const char* AgentImpl::DIR_EXCHANGE = "amq.direct";
-const char* AgentImpl::BROKER_KEY   = "broker";
+const char* AgentEngineImpl::QMF_EXCHANGE = "qpid.management";
+const char* AgentEngineImpl::DIR_EXCHANGE = "amq.direct";
+const char* AgentEngineImpl::BROKER_KEY   = "broker";
 
 #define STRING_REF(s) {if (!s.empty()) item.s = const_cast<char*>(s.c_str());}
 
@@ -228,7 +228,7 @@ AgentEvent AgentEventImpl::copy()
     return item;
 }
 
-AgentImpl::AgentImpl(char* _label, bool i) :
+AgentEngineImpl::AgentEngineImpl(char* _label, bool i) :
     label(_label), queueName("qmfa-"), internalStore(i), nextTransientId(1),
     requestedBrokerBank(0), requestedAgentBank(0),
     assignedBrokerBank(0), assignedAgentBank(0),
@@ -237,11 +237,11 @@ AgentImpl::AgentImpl(char* _label, bool i) :
     queueName += label;
 }
 
-AgentImpl::~AgentImpl()
+AgentEngineImpl::~AgentEngineImpl()
 {
 }
 
-void AgentImpl::setStoreDir(char* path)
+void AgentEngineImpl::setStoreDir(const char* path)
 {
     Mutex::ScopedLock _lock(lock);
     if (path)
@@ -250,7 +250,7 @@ void AgentImpl::setStoreDir(char* path)
         storeDir.clear();
 }
 
-void AgentImpl::setTransferDir(char* path)
+void AgentEngineImpl::setTransferDir(const char* path)
 {
     Mutex::ScopedLock _lock(lock);
     if (path)
@@ -259,7 +259,7 @@ void AgentImpl::setTransferDir(char* path)
         transferDir.clear();
 }
 
-void AgentImpl::handleRcvMessage(Message& message)
+void AgentEngineImpl::handleRcvMessage(Message& message)
 {
     Buffer   inBuffer(message.body, message.length);
     uint8_t  opcode;
@@ -277,7 +277,7 @@ void AgentImpl::handleRcvMessage(Message& message)
     }
 }
 
-bool AgentImpl::getXmtMessage(Message& item)
+bool AgentEngineImpl::getXmtMessage(Message& item)
 {
     Mutex::ScopedLock _lock(lock);
     if (xmtQueue.empty())
@@ -286,14 +286,14 @@ bool AgentImpl::getXmtMessage(Message& item)
     return true;
 }
 
-void AgentImpl::popXmt()
+void AgentEngineImpl::popXmt()
 {
     Mutex::ScopedLock _lock(lock);
     if (!xmtQueue.empty())
         xmtQueue.pop_front();
 }
 
-bool AgentImpl::getEvent(AgentEvent& event)
+bool AgentEngineImpl::getEvent(AgentEvent& event)
 {
     Mutex::ScopedLock _lock(lock);
     if (eventQueue.empty())
@@ -302,14 +302,14 @@ bool AgentImpl::getEvent(AgentEvent& event)
     return true;
 }
 
-void AgentImpl::popEvent()
+void AgentEngineImpl::popEvent()
 {
     Mutex::ScopedLock _lock(lock);
     if (!eventQueue.empty())
         eventQueue.pop_front();
 }
 
-void AgentImpl::newSession()
+void AgentEngineImpl::newSession()
 {
     Mutex::ScopedLock _lock(lock);
     eventQueue.clear();
@@ -319,7 +319,7 @@ void AgentImpl::newSession()
     eventQueue.push_back(eventSetupComplete());
 }
 
-void AgentImpl::startProtocol()
+void AgentEngineImpl::startProtocol()
 {
     Mutex::ScopedLock _lock(lock);
     char    rawbuffer[512];
@@ -335,7 +335,7 @@ void AgentImpl::startProtocol()
              " reqAgent=" << requestedAgentBank);
 }
 
-void AgentImpl::heartbeat()
+void AgentEngineImpl::heartbeat()
 {
     Mutex::ScopedLock _lock(lock);
     Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
@@ -348,7 +348,7 @@ void AgentImpl::heartbeat()
     QPID_LOG(trace, "SENT HeartbeatIndication");
 }
 
-void AgentImpl::methodResponse(uint32_t sequence, uint32_t status, char* text,
+void AgentEngineImpl::methodResponse(uint32_t sequence, uint32_t status, char* text,
                                const Value& argMap)
 {
     Mutex::ScopedLock _lock(lock);
@@ -381,7 +381,7 @@ void AgentImpl::methodResponse(uint32_t sequence, uint32_t status, char* text,
     QPID_LOG(trace, "SENT MethodResponse");
 }
 
-void AgentImpl::queryResponse(uint32_t sequence, Object& object, bool prop, bool stat)
+void AgentEngineImpl::queryResponse(uint32_t sequence, Object& object, bool prop, bool stat)
 {
     Mutex::ScopedLock _lock(lock);
     map<uint32_t, AgentQueryContext::Ptr>::iterator iter = contextMap.find(sequence);
@@ -403,7 +403,7 @@ void AgentImpl::queryResponse(uint32_t sequence, Object& object, bool prop, bool
     QPID_LOG(trace, "SENT ContentIndication");
 }
 
-void AgentImpl::queryComplete(uint32_t sequence)
+void AgentEngineImpl::queryComplete(uint32_t sequence)
 {
     Mutex::ScopedLock _lock(lock);
     map<uint32_t, AgentQueryContext::Ptr>::iterator iter = contextMap.find(sequence);
@@ -415,7 +415,7 @@ void AgentImpl::queryComplete(uint32_t sequence)
     sendCommandCompleteLH(context->exchange, context->key, context->sequence, 0, "OK");
 }
 
-void AgentImpl::registerClass(SchemaObjectClass* cls)
+void AgentEngineImpl::registerClass(SchemaObjectClass* cls)
 {
     Mutex::ScopedLock _lock(lock);
     SchemaObjectClassImpl* impl = cls->impl;
@@ -433,7 +433,7 @@ void AgentImpl::registerClass(SchemaObjectClass* cls)
     // TODO: Indicate this schema if connected.
 }
 
-void AgentImpl::registerClass(SchemaEventClass* cls)
+void AgentEngineImpl::registerClass(SchemaEventClass* cls)
 {
     Mutex::ScopedLock _lock(lock);
     SchemaEventClassImpl* impl = cls->impl;
@@ -451,13 +451,13 @@ void AgentImpl::registerClass(SchemaEventClass* cls)
     // TODO: Indicate this schema if connected.
 }
 
-const ObjectId* AgentImpl::addObject(Object&, uint64_t)
+const ObjectId* AgentEngineImpl::addObject(Object&, uint64_t)
 {
     Mutex::ScopedLock _lock(lock);
     return 0;
 }
 
-const ObjectId* AgentImpl::allocObjectId(uint64_t persistId)
+const ObjectId* AgentEngineImpl::allocObjectId(uint64_t persistId)
 {
     Mutex::ScopedLock _lock(lock);
     uint16_t sequence  = persistId ? 0 : bootSequence;
@@ -467,17 +467,17 @@ const ObjectId* AgentImpl::allocObjectId(uint64_t persistId)
     return oid->envelope;
 }
 
-const ObjectId* AgentImpl::allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi)
+const ObjectId* AgentEngineImpl::allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi)
 {
     return allocObjectId(((uint64_t) persistIdHi) << 32 | (uint64_t) persistIdLo);
 }
 
-void AgentImpl::raiseEvent(Event&)
+void AgentEngineImpl::raiseEvent(Event&)
 {
     Mutex::ScopedLock _lock(lock);
 }
 
-void AgentImpl::encodeHeader(Buffer& buf, uint8_t opcode, uint32_t seq)
+void AgentEngineImpl::encodeHeader(Buffer& buf, uint8_t opcode, uint32_t seq)
 {
     buf.putOctet('A');
     buf.putOctet('M');
@@ -486,7 +486,7 @@ void AgentImpl::encodeHeader(Buffer& buf, uint8_t opcode, uint32_t seq)
     buf.putLong (seq);
 }
 
-bool AgentImpl::checkHeader(Buffer& buf, uint8_t *opcode, uint32_t *seq)
+bool AgentEngineImpl::checkHeader(Buffer& buf, uint8_t *opcode, uint32_t *seq)
 {
     if (buf.getSize() < 8)
         return false;
@@ -501,7 +501,7 @@ bool AgentImpl::checkHeader(Buffer& buf, uint8_t *opcode, uint32_t *seq)
     return h1 == 'A' && h2 == 'M' && h3 == '3';
 }
 
-AgentEventImpl::Ptr AgentImpl::eventDeclareQueue(const string& name)
+AgentEventImpl::Ptr AgentEngineImpl::eventDeclareQueue(const string& name)
 {
     AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::DECLARE_QUEUE));
     event->name = name;
@@ -509,8 +509,8 @@ AgentEventImpl::Ptr AgentImpl::eventDeclareQueue(const string& name)
     return event;
 }
 
-AgentEventImpl::Ptr AgentImpl::eventBind(const string& exchange, const string& queue,
-                                         const string& key)
+AgentEventImpl::Ptr AgentEngineImpl::eventBind(const string& exchange, const string& queue,
+                                               const string& key)
 {
     AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::BIND));
     event->name       = queue;
@@ -520,14 +520,14 @@ AgentEventImpl::Ptr AgentImpl::eventBind(const string& exchange, const string& q
     return event;
 }
 
-AgentEventImpl::Ptr AgentImpl::eventSetupComplete()
+AgentEventImpl::Ptr AgentEngineImpl::eventSetupComplete()
 {
     AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::SETUP_COMPLETE));
     return event;
 }
 
-AgentEventImpl::Ptr AgentImpl::eventQuery(uint32_t num, const string& userId, const string& package,
-                                          const string& cls, boost::shared_ptr<ObjectId> oid)
+AgentEventImpl::Ptr AgentEngineImpl::eventQuery(uint32_t num, const string& userId, const string& package,
+                                                const string& cls, boost::shared_ptr<ObjectId> oid)
 {
     AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::GET_QUERY));
     event->sequence = num;
@@ -538,9 +538,9 @@ AgentEventImpl::Ptr AgentImpl::eventQuery(uint32_t num, const string& userId, co
     return event;
 }
 
-AgentEventImpl::Ptr AgentImpl::eventMethod(uint32_t num, const string& userId, const string& method,
-                                           boost::shared_ptr<ObjectId> oid, boost::shared_ptr<Value> argMap,
-                                           SchemaObjectClass* objectClass)
+AgentEventImpl::Ptr AgentEngineImpl::eventMethod(uint32_t num, const string& userId, const string& method,
+                                                 boost::shared_ptr<ObjectId> oid, boost::shared_ptr<Value> argMap,
+                                                 SchemaObjectClass* objectClass)
 {
     AgentEventImpl::Ptr event(new AgentEventImpl(AgentEvent::METHOD_CALL));
     event->sequence = num;
@@ -552,7 +552,7 @@ AgentEventImpl::Ptr AgentImpl::eventMethod(uint32_t num, const string& userId, c
     return event;
 }
 
-void AgentImpl::sendBufferLH(Buffer& buf, const string& destination, const string& routingKey)
+void AgentEngineImpl::sendBufferLH(Buffer& buf, const string& destination, const string& routingKey)
 {
     uint32_t length = buf.getPosition();
     MessageImpl::Ptr message(new MessageImpl);
@@ -567,7 +567,7 @@ void AgentImpl::sendBufferLH(Buffer& buf, const string& destination, const strin
     xmtQueue.push_back(message);
 }
 
-void AgentImpl::sendPackageIndicationLH(const string& packageName)
+void AgentEngineImpl::sendPackageIndicationLH(const string& packageName)
 {
     Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
     encodeHeader(buffer, 'p');
@@ -576,7 +576,7 @@ void AgentImpl::sendPackageIndicationLH(const string& packageName)
     QPID_LOG(trace, "SENT PackageIndication:  package_name=" << packageName);
 }
 
-void AgentImpl::sendClassIndicationLH(ClassKind kind, const string& packageName, const SchemaClassKey& key)
+void AgentEngineImpl::sendClassIndicationLH(ClassKind kind, const string& packageName, const SchemaClassKey& key)
 {
     Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
     encodeHeader(buffer, 'q');
@@ -588,8 +588,8 @@ void AgentImpl::sendClassIndicationLH(ClassKind kind, const string& packageName,
     QPID_LOG(trace, "SENT ClassIndication:  package_name=" << packageName << " class_name=" << key.name);
 }
 
-void AgentImpl::sendCommandCompleteLH(const string& exchange, const string& replyToKey,
-                                      uint32_t sequence, uint32_t code, const string& text)
+void AgentEngineImpl::sendCommandCompleteLH(const string& exchange, const string& replyToKey,
+                                            uint32_t sequence, uint32_t code, const string& text)
 {
     Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
     encodeHeader(buffer, 'z', sequence);
@@ -599,7 +599,7 @@ void AgentImpl::sendCommandCompleteLH(const string& exchange, const string& repl
     QPID_LOG(trace, "SENT CommandComplete: seq=" << sequence << " code=" << code << " text=" << text);
 }
 
-void AgentImpl::sendMethodErrorLH(uint32_t sequence, const string& key, uint32_t code, const string& text)
+void AgentEngineImpl::sendMethodErrorLH(uint32_t sequence, const string& key, uint32_t code, const string& text)
 {
     Buffer buffer(outputBuffer, MA_BUFFER_SIZE);
     encodeHeader(buffer, 'm', sequence);
@@ -625,7 +625,7 @@ void AgentImpl::sendMethodErrorLH(uint32_t sequence, const string& key, uint32_t
     QPID_LOG(trace, "SENT MethodResponse: errorCode=" << code << " text=" << fulltext);
 }
 
-void AgentImpl::handleAttachResponse(Buffer& inBuffer)
+void AgentEngineImpl::handleAttachResponse(Buffer& inBuffer)
 {
     Mutex::ScopedLock _lock(lock);
 
@@ -672,18 +672,18 @@ void AgentImpl::handleAttachResponse(Buffer& inBuffer)
     }
 }
 
-void AgentImpl::handlePackageRequest(Buffer&)
+void AgentEngineImpl::handlePackageRequest(Buffer&)
 {
     Mutex::ScopedLock _lock(lock);
 }
 
-void AgentImpl::handleClassQuery(Buffer&)
+void AgentEngineImpl::handleClassQuery(Buffer&)
 {
     Mutex::ScopedLock _lock(lock);
 }
 
-void AgentImpl::handleSchemaRequest(Buffer& inBuffer, uint32_t sequence,
-                                    const string& replyExchange, const string& replyKey)
+void AgentEngineImpl::handleSchemaRequest(Buffer& inBuffer, uint32_t sequence,
+                                          const string& replyExchange, const string& replyKey)
 {
     Mutex::ScopedLock _lock(lock);
     string rExchange(replyExchange);
@@ -731,7 +731,7 @@ void AgentImpl::handleSchemaRequest(Buffer& inBuffer, uint32_t sequence,
     sendCommandCompleteLH(rExchange, rKey, sequence, 1, "class not found");
 }
 
-void AgentImpl::handleGetQuery(Buffer& inBuffer, uint32_t sequence, const string& replyTo, const string& userId)
+void AgentEngineImpl::handleGetQuery(Buffer& inBuffer, uint32_t sequence, const string& replyTo, const string& userId)
 {
     Mutex::ScopedLock _lock(lock);
     FieldTable ft;
@@ -783,7 +783,7 @@ void AgentImpl::handleGetQuery(Buffer& inBuffer, uint32_t sequence, const string
     eventQueue.push_back(eventQuery(contextNum, userId, pname, cname, oid));
 }
 
-void AgentImpl::handleMethodRequest(Buffer& buffer, uint32_t sequence, const string& replyTo, const string& userId)
+void AgentEngineImpl::handleMethodRequest(Buffer& buffer, uint32_t sequence, const string& replyTo, const string& userId)
 {
     Mutex::ScopedLock _lock(lock);
     string pname;
@@ -842,7 +842,7 @@ void AgentImpl::handleMethodRequest(Buffer& buffer, uint32_t sequence, const str
     eventQueue.push_back(eventMethod(contextNum, userId, method, oid, argMap, schema->envelope));
 }
 
-void AgentImpl::handleConsoleAddedIndication()
+void AgentEngineImpl::handleConsoleAddedIndication()
 {
     Mutex::ScopedLock _lock(lock);
 }
@@ -851,107 +851,107 @@ void AgentImpl::handleConsoleAddedIndication()
 // Wrappers
 //==================================================================
 
-Agent::Agent(char* label, bool internalStore)
+AgentEngine::AgentEngine(char* label, bool internalStore)
 {
-    impl = new AgentImpl(label, internalStore);
+    impl = new AgentEngineImpl(label, internalStore);
 }
 
-Agent::~Agent()
+AgentEngine::~AgentEngine()
 {
     delete impl;
 }
 
-void Agent::setStoreDir(char* path)
+void AgentEngine::setStoreDir(const char* path)
 {
     impl->setStoreDir(path);
 }
 
-void Agent::setTransferDir(char* path)
+void AgentEngine::setTransferDir(const char* path)
 {
     impl->setTransferDir(path);
 }
 
-void Agent::handleRcvMessage(Message& message)
+void AgentEngine::handleRcvMessage(Message& message)
 {
     impl->handleRcvMessage(message);
 }
 
-bool Agent::getXmtMessage(Message& item)
+bool AgentEngine::getXmtMessage(Message& item)
 {
     return impl->getXmtMessage(item);
 }
 
-void Agent::popXmt()
+void AgentEngine::popXmt()
 {
     impl->popXmt();
 }
 
-bool Agent::getEvent(AgentEvent& event)
+bool AgentEngine::getEvent(AgentEvent& event)
 {
     return impl->getEvent(event);
 }
 
-void Agent::popEvent()
+void AgentEngine::popEvent()
 {
     impl->popEvent();
 }
 
-void Agent::newSession()
+void AgentEngine::newSession()
 {
     impl->newSession();
 }
 
-void Agent::startProtocol()
+void AgentEngine::startProtocol()
 {
     impl->startProtocol();
 }
 
-void Agent::heartbeat()
+void AgentEngine::heartbeat()
 {
     impl->heartbeat();
 }
 
-void Agent::methodResponse(uint32_t sequence, uint32_t status, char* text, const Value& arguments)
+void AgentEngine::methodResponse(uint32_t sequence, uint32_t status, char* text, const Value& arguments)
 {
     impl->methodResponse(sequence, status, text, arguments);
 }
 
-void Agent::queryResponse(uint32_t sequence, Object& object, bool prop, bool stat)
+void AgentEngine::queryResponse(uint32_t sequence, Object& object, bool prop, bool stat)
 {
     impl->queryResponse(sequence, object, prop, stat);
 }
 
-void Agent::queryComplete(uint32_t sequence)
+void AgentEngine::queryComplete(uint32_t sequence)
 {
     impl->queryComplete(sequence);
 }
 
-void Agent::registerClass(SchemaObjectClass* cls)
+void AgentEngine::registerClass(SchemaObjectClass* cls)
 {
     impl->registerClass(cls);
 }
 
-void Agent::registerClass(SchemaEventClass* cls)
+void AgentEngine::registerClass(SchemaEventClass* cls)
 {
     impl->registerClass(cls);
 }
 
-const ObjectId* Agent::addObject(Object& obj, uint64_t persistId)
+const ObjectId* AgentEngine::addObject(Object& obj, uint64_t persistId)
 {
     return impl->addObject(obj, persistId);
 }
 
-const ObjectId* Agent::allocObjectId(uint64_t persistId)
+const ObjectId* AgentEngine::allocObjectId(uint64_t persistId)
 {
     return impl->allocObjectId(persistId);
 }
 
-const ObjectId* Agent::allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi)
+const ObjectId* AgentEngine::allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi)
 {
     return impl->allocObjectId(persistIdLo, persistIdHi);
 }
 
-void Agent::raiseEvent(Event& event)
+void AgentEngine::raiseEvent(Event& event)
 {
     impl->raiseEvent(event);
 }
diff --git a/qpid/cpp/src/qmf/Agent.h b/qpid/cpp/src/qmf/AgentEngine.h
index d8f784e9d8..d18a104e96 100644
--- a/qpid/cpp/src/qmf/Agent.h
+++ b/qpid/cpp/src/qmf/AgentEngine.h
@@ -1,5 +1,5 @@
-#ifndef _QmfAgent_
-#define _QmfAgent_
+#ifndef _QmfAgentEngine_
+#define _QmfAgentEngine_
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
@@ -64,15 +64,15 @@ namespace qmf {
         SchemaObjectClass* objectClass; // (METHOD_CALL)
     };
 
-    class AgentImpl;
+    class AgentEngineImpl;
 
     /**
-     * Agent - Protocol engine for the QMF agent
+     * AgentEngine - Protocol engine for the QMF agent
      */
-    class Agent {
+    class AgentEngine {
     public:
-        Agent(char* label, bool internalStore=true);
-        ~Agent();
+        AgentEngine(char* label, bool internalStore=true);
+        ~AgentEngine();
 
         /**
          * Configure the directory path for storing persistent data.
@@ -80,7 +80,7 @@ namespace qmf {
          *            created, written, and read.  If NULL, no persistent storage will be
          *            attempted.
          */
-        void setStoreDir(char* path);
+        void setStoreDir(const char* path);
 
         /**
          * Configure the directory path for files transferred over QMF.
@@ -88,7 +88,7 @@ namespace qmf {
          *            created, deleted, written, and read.  If NULL, file transfers shall not
          *            be permitted.
          */
-        void setTransferDir(char* path);
+        void setTransferDir(const char* path);
 
         /**
          * Pass messages received from the AMQP session to the Agent engine.
@@ -182,11 +182,12 @@ namespace qmf {
          *@return The objectId of the managed object.
          */
         const ObjectId* addObject(Object& obj, uint64_t persistId);
+        const ObjectId* addObject(Object& obj, uint32_t persistIdLo, uint32_t persistIdHi);
 
         /**
-         * Allocate an objecc-id for an object that will be managed by the application.
+         * Allocate an object-id for an object that will be managed by the application.
          *@param persistId A unique non-zero value if the object-id is to be persistent.
-         @return The objectId structure for the allocated ID.
+         *@return The objectId structure for the allocated ID.
          */
         const ObjectId* allocObjectId(uint64_t persistId);
         const ObjectId* allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi);
@@ -198,7 +199,7 @@ namespace qmf {
         void raiseEvent(Event& event);
 
     private:
-        AgentImpl* impl;
+        AgentEngineImpl* impl;
     };
 }
 
diff --git a/qpid/cpp/src/qmf/Console.h b/qpid/cpp/src/qmf/ConsoleEngine.h
index de7949e1de..823e281b14 100644
--- a/qpid/cpp/src/qmf/Console.h
+++ b/qpid/cpp/src/qmf/ConsoleEngine.h
@@ -1,5 +1,5 @@
-#ifndef _QmfConsole_
-#define _QmfConsole_
+#ifndef _QmfConsoleEngine_
+#define _QmfConsoleEngine_
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
@@ -21,7 +21,6 @@
  */
 
 #include <qmf/ManagedConnection.h>
-#include <qmf/Agent.h>
 #include <qmf/Broker.h>
 #include <qmf/Package.h>
 #include <qmf/SchemaClassTable.h>
@@ -50,10 +49,10 @@ namespace qmf {
             getTimeout(20) {}
     };
 
-    class Console {
+    class ConsoleEngine {
     public:
-        Console(ConsoleHandler* handler = 0, ConsoleSettings settings = ConsoleSettings());
-        ~Console();
+        ConsoleEngine(ConsoleHandler* handler = 0, ConsoleSettings settings = ConsoleSettings());
+        ~ConsoleEngine();
 
         Broker* addConnection(ManagedConnection& connection);
         void delConnection(Broker* broker);
@@ -66,6 +65,7 @@ namespace qmf {
         void bindClass(const SchemaClass& otype);
         void bindClass(const std::string& packageName, const std::string& className);
 
+        /*
         void getAgents(std::set<Agent>& agents, Broker* = 0);
         void getObjects(std::vector<Object>& objects, const std::string& typeName,
                         const std::string& packageName = "",
@@ -75,6 +75,7 @@ namespace qmf {
                         const std::map<std::string, std::string>& query,
                         Broker* broker = 0,
                         Agent* agent = 0);
+        */
     };
 }
 
diff --git a/qpid/cpp/src/qmf/Object.h b/qpid/cpp/src/qmf/Object.h
index 8caab8d6dc..eb92cbbe45 100644
--- a/qpid/cpp/src/qmf/Object.h
+++ b/qpid/cpp/src/qmf/Object.h
@@ -31,7 +31,7 @@ namespace qmf {
     public:
         Object(const SchemaObjectClass* type);
         Object(ObjectImpl* impl);
-        ~Object();
+        virtual ~Object();
 
         void destroy();
         const ObjectId* getObjectId() const;