Preliminary connecting via HTTP in Gtk client.

Better handling of overflowed client event receive buffer.
Store fixes, complain only once about orphans, don't request an orphan parent over and over.


git-svn-id: http://svn.drobilla.net/lad/ingen@1447 a436a847-0d15-0410-975c-d299462d15a1

18 files changed, 729 insertions, 73 deletions

diff --git a/src/libs/client/ClientStore.cpp b/src/libs/client/ClientStore.cpp
index 0597aa21..18582046 100644
--- a/src/libs/client/ClientStore.cpp
+++ b/src/libs/client/ClientStore.cpp
@@ -72,17 +72,15 @@ ClientStore::add_plugin_orphan(SharedPtr<NodeModel> node)
 {
 	if (!_handle_orphans)
 		return;
-	cerr << "WARNING: Node " << node->path() << " received, but plugin "
-		<< node->plugin_uri() << " unknown." << endl;
 
 	Raul::Table<string, list<SharedPtr<NodeModel> > >::iterator spawn
 		= _plugin_orphans.find(node->plugin_uri());
 
-	_engine->request_plugin(node->plugin_uri());
-
 	if (spawn != _plugin_orphans.end()) {
 		spawn->second.push_back(node);
 	} else {
+		cerr << "WARNING: Orphans of plugin " << node->plugin_uri() << " received" << endl;
+		_engine->request_plugin(node->plugin_uri());
 		list<SharedPtr<NodeModel> > l;
 		l.push_back(node);
 		_plugin_orphans[node->plugin_uri()] = l;
@@ -108,7 +106,7 @@ ClientStore::resolve_plugin_orphans(SharedPtr<PluginModel> plugin)
 		for (list<SharedPtr<NodeModel> >::iterator i = spawn.begin();
 				i != spawn.end(); ++i) {
 			(*i)->_plugin = plugin;
-			add_object(*i);
+			//add_object(*i);
 		}
 	}
 }
@@ -248,7 +246,6 @@ ClientStore::add_object(SharedPtr<ObjectModel> object)
 	// one (with precedence to the new values).
 	iterator existing = find(object->path());
 	if (existing != end()) {
-		cout << "WARNING: Object " << object->path() << " already exists in store" << endl;
 		PtrCast<ObjectModel>(existing->second)->set(object);
 	} else {
 
@@ -444,6 +441,7 @@ ClientStore::new_node(const string& path, const string& plugin_uri)
 	if (!plug) {
 		SharedPtr<NodeModel> n(new NodeModel(plugin_uri, path));
 		add_plugin_orphan(n);
+		add_object(n);
 	} else {
 		SharedPtr<NodeModel> n(new NodeModel(plug, path));
 		add_object(n);
diff --git a/src/libs/client/HTTPClientReceiver.cpp b/src/libs/client/HTTPClientReceiver.cpp
new file mode 100644
index 00000000..ece55ab2
--- /dev/null
+++ b/src/libs/client/HTTPClientReceiver.cpp
@@ -0,0 +1,97 @@
+/* This file is part of Ingen.
+ * Copyright (C) 2008 Dave Robillard <http://drobilla.net>
+ * 
+ * Ingen is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ * 
+ * Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <list>
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <raul/AtomLiblo.hpp>
+#include "module/Module.hpp"
+#include "HTTPClientReceiver.hpp"
+
+using namespace std;
+using namespace Raul;
+
+namespace Ingen {
+namespace Client {
+
+
+HTTPClientReceiver::HTTPClientReceiver(
+		Shared::World*                     world,
+		const std::string&                 url,
+		SharedPtr<Shared::ClientInterface> target)
+	: _target(target)
+	, _world(world)
+	, _url(url)
+	, _session(NULL)
+{
+	start(false);
+}
+
+
+HTTPClientReceiver::~HTTPClientReceiver()
+{
+	stop();
+}
+
+
+void
+HTTPClientReceiver::message_callback(SoupSession* session, SoupMessage* msg, void* ptr)
+{
+	HTTPClientReceiver* me = (HTTPClientReceiver*)ptr;
+	cout << "RECEIVED ASYNC MESSAGE: " << msg->response_body->data << endl;
+	me->_target->response_ok(0);
+	me->_target->enable();
+	me->_parser->parse_string(me->_world, me->_target.get(), Glib::ustring(msg->response_body->data),
+			Glib::ustring("/"), Glib::ustring(""));
+}
+
+
+void
+HTTPClientReceiver::start(bool dump)
+{
+	Glib::Mutex::Lock lock(_world->rdf_world->mutex());
+	if (!_parser) {
+		if (!_world->serialisation_module)
+			_world->serialisation_module = Ingen::Shared::load_module("ingen_serialisation");
+
+		if (_world->serialisation_module) {
+			Parser* (*new_parser)() = NULL;
+			if (_world->serialisation_module->get_symbol("new_parser", (void*&)new_parser))
+				_parser = SharedPtr<Parser>(new_parser());
+		}
+	}
+	_session = soup_session_async_new();
+	SoupMessage* msg = soup_message_new("GET", _url.c_str());
+	soup_session_queue_message (_session, msg, message_callback, this);
+}
+
+
+void
+HTTPClientReceiver::stop()
+{
+	if (_session != NULL) {
+		//unregister_client();
+		soup_session_abort(_session);
+		_session = NULL;
+	}
+}
+
+
+} // namespace Client
+} // namespace Ingen
diff --git a/src/libs/client/HTTPClientReceiver.hpp b/src/libs/client/HTTPClientReceiver.hpp
new file mode 100644
index 00000000..bab55578
--- /dev/null
+++ b/src/libs/client/HTTPClientReceiver.hpp
@@ -0,0 +1,62 @@
+/* This file is part of Ingen.
+ * Copyright (C) 2008 Dave Robillard <http://drobilla.net>
+ * 
+ * Ingen is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ * 
+ * Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef HTTPCLIENTRECEIVER_H
+#define HTTPCLIENTRECEIVER_H
+
+#include <cstdlib>
+#include <boost/utility.hpp>
+#include <libsoup/soup.h>
+#include "interface/ClientInterface.hpp"
+#include "serialisation/Parser.hpp"
+#include "redlandmm/World.hpp"
+#include "raul/Deletable.hpp"
+
+namespace Ingen {
+namespace Client {
+
+
+class HTTPClientReceiver : public boost::noncopyable, public Raul::Deletable
+{
+public:
+	HTTPClientReceiver(Shared::World*                     world,
+	                   const std::string&                 url,
+	                   SharedPtr<Shared::ClientInterface> target);
+
+	~HTTPClientReceiver();
+
+	std::string uri() const { return _url; }
+
+	void start(bool dump);
+	void stop();
+	
+private:
+	static void message_callback(SoupSession* session, SoupMessage* msg, void* ptr);
+	
+	SharedPtr<Shared::ClientInterface> _target;
+
+	Shared::World*    _world;
+	const std::string _url;
+	SoupSession*      _session;
+	SharedPtr<Parser> _parser;
+};
+
+
+} // namespace Client
+} // namespace Ingen
+
+#endif // HTTPCLIENTRECEIVER_H
diff --git a/src/libs/client/HTTPEngineSender.cpp b/src/libs/client/HTTPEngineSender.cpp
new file mode 100644
index 00000000..882a4bc4
--- /dev/null
+++ b/src/libs/client/HTTPEngineSender.cpp
@@ -0,0 +1,300 @@
+/* This file is part of Ingen.
+ * Copyright (C) 2008 Dave Robillard <http://drobilla.net>
+ * 
+ * Ingen is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ * 
+ * Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <iostream>
+#include <libsoup/soup.h>
+#include "HTTPEngineSender.hpp"
+
+using namespace std;
+
+namespace Ingen {
+namespace Client {
+
+
+HTTPEngineSender::HTTPEngineSender(const string& engine_url)
+	: _engine_url(engine_url)
+	, _id(0)
+	, _enabled(true)
+{
+	_session = soup_session_sync_new();
+}
+
+
+HTTPEngineSender::~HTTPEngineSender()
+{
+	soup_session_abort(_session);
+}
+
+
+void
+HTTPEngineSender::attach(int32_t ping_id, bool block)
+{
+	/*SoupMessage *msg;
+	msg = soup_message_new ("GET", _engine_url.c_str());
+	int status = soup_session_send_message (_session, msg);
+	cout << "STATUS: " << status << endl;
+	cout << "RESPONSE: " << msg->response_body->data << endl;*/
+}
+
+
+/* *** EngineInterface implementation below here *** */
+
+
+/** Register with the engine via HTTP.
+ *
+ * Note that this does not actually use 'key', since the engine creates
+ * it's own key for HTTP clients (namely the incoming URL), for NAT
+ * traversal.  It is a parameter to remain compatible with EngineInterface.
+ */
+void
+HTTPEngineSender::register_client(ClientInterface* client)
+{
+
+}
+
+
+void
+HTTPEngineSender::unregister_client(const string& uri)
+{
+
+}
+
+
+// Engine commands
+void
+HTTPEngineSender::load_plugins()
+{
+
+}
+
+
+void
+HTTPEngineSender::activate()    
+{
+
+}
+
+
+void
+HTTPEngineSender::deactivate()  
+{
+
+}
+
+
+void
+HTTPEngineSender::quit()        
+{
+
+}
+
+
+
+// Object commands
+
+void
+HTTPEngineSender::new_patch(const string& path,
+                           uint32_t      poly)
+{
+}
+
+
+void
+HTTPEngineSender::new_port(const string& path,
+                          uint32_t      index,
+                          const string& data_type,
+                          bool          is_output)
+{
+}
+
+
+void
+HTTPEngineSender::new_node(const string& path,
+                          const string& plugin_uri)
+{
+}
+
+
+/** Create a node using library name and plugin label (DEPRECATED).
+ *
+ * DO NOT USE THIS.
+ */
+void
+HTTPEngineSender::new_node_deprecated(const string& path,
+                                     const string& plugin_type,
+                                     const string& library_name,
+                                     const string& plugin_label)
+{
+}
+
+
+void
+HTTPEngineSender::rename(const string& old_path,
+                        const string& new_name)
+{
+}
+
+
+void
+HTTPEngineSender::destroy(const string& path)
+{
+}
+
+
+void
+HTTPEngineSender::clear_patch(const string& patch_path)
+{
+}
+
+
+void
+HTTPEngineSender::connect(const string& src_port_path,
+                         const string& dst_port_path)
+{
+}
+
+
+void
+HTTPEngineSender::disconnect(const string& src_port_path,
+                            const string& dst_port_path)
+{
+}
+
+
+void
+HTTPEngineSender::disconnect_all(const string& parent_patch_path,
+                                const string& node_path)
+{
+}
+
+
+void
+HTTPEngineSender::set_port_value(const string&     port_path,
+                                const Raul::Atom& value)
+{
+}
+
+
+void
+HTTPEngineSender::set_voice_value(const string&     port_path,
+                                 uint32_t          voice,
+                                 const Raul::Atom& value)
+{
+}
+
+
+void
+HTTPEngineSender::set_port_value_immediate(const string&     port_path,
+                                          const Raul::Atom& value)
+{
+}
+
+
+void
+HTTPEngineSender::set_voice_value_immediate(const string&     port_path,
+                                           uint32_t          voice,
+                                           const Raul::Atom& value)
+{
+}
+
+
+void
+HTTPEngineSender::set_program(const string& node_path,
+                             uint32_t      bank,
+                             uint32_t      program)
+{
+}
+
+
+void
+HTTPEngineSender::midi_learn(const string& node_path)
+{
+}
+
+
+void
+HTTPEngineSender::set_variable(const string&     obj_path,
+                              const string&     predicate,
+                              const Raul::Atom& value)
+{
+}
+
+
+void
+HTTPEngineSender::set_property(const string&    obj_path,
+                               const string&     predicate,
+                               const Raul::Atom& value)
+{
+}
+
+
+
+// Requests //
+
+void
+HTTPEngineSender::ping()
+{
+}
+
+
+void
+HTTPEngineSender::request_plugin(const string& uri)
+{
+}
+
+
+void
+HTTPEngineSender::request_object(const string& path)
+{
+}
+
+
+void
+HTTPEngineSender::request_port_value(const string& port_path)
+{
+}
+
+
+void
+HTTPEngineSender::request_variable(const string& object_path, const string& key)
+{
+}
+
+
+void
+HTTPEngineSender::request_property(const string& object_path, const string& key)
+{
+}
+
+
+void
+HTTPEngineSender::request_plugins()
+{
+}
+
+
+void
+HTTPEngineSender::request_all_objects()
+{
+}
+
+
+
+} // namespace Client
+} // namespace Ingen
+
+
diff --git a/src/libs/client/HTTPEngineSender.hpp b/src/libs/client/HTTPEngineSender.hpp
new file mode 100644
index 00000000..f753eea3
--- /dev/null
+++ b/src/libs/client/HTTPEngineSender.hpp
@@ -0,0 +1,162 @@
+/* This file is part of Ingen.
+ * Copyright (C) 2008 Dave Robillard <http://drobilla.net>
+ * 
+ * Ingen is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ * 
+ * Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef HTTPENGINESENDER_H
+#define HTTPENGINESENDER_H
+
+#include <inttypes.h>
+#include <string>
+#include <libsoup/soup.h>
+#include "interface/EngineInterface.hpp"
+using std::string;
+using Ingen::Shared::EngineInterface;
+using Ingen::Shared::ClientInterface;
+
+namespace Ingen {
+namespace Client {
+
+
+/* HTTP (via libsoup) interface to the engine.
+ *
+ * Clients can use this opaquely as an EngineInterface to control the engine
+ * over HTTP (whether over a network or not).
+ *
+ * \ingroup IngenClient
+ */
+class HTTPEngineSender : public EngineInterface {
+public:
+	HTTPEngineSender(const string& engine_url);
+	~HTTPEngineSender();
+	
+	string uri() const { return _engine_url; }
+	
+	inline int32_t next_id()
+	{ int32_t ret = (_id == -1) ? -1 : _id++; return ret; }
+
+	void set_next_response_id(int32_t id) { _id = id; }
+	void disable_responses() { _id = -1; }
+
+	void attach(int32_t ping_id, bool block);
+
+
+	/* *** EngineInterface implementation below here *** */
+	
+	void enable()  { _enabled = true; }
+	void disable() { _enabled = false; }
+	
+	void bundle_begin()   { transfer_begin(); }
+	void bundle_end()     { transfer_end(); }
+	
+	void transfer_begin();
+	void transfer_end();
+
+	// Client registration
+	void register_client(ClientInterface* client);
+	void unregister_client(const string& uri);
+
+	// Engine commands
+	void load_plugins();
+	void activate();
+	void deactivate();
+	void quit();
+	
+	// Object commands
+	
+	void new_patch(const string& path,
+	               uint32_t      poly);
+
+	void new_port(const string& path,
+	              uint32_t      index,
+	              const string& data_type,
+	              bool          is_output);
+
+	void new_node(const string& path,
+	              const string& plugin_uri);
+	
+	void new_node_deprecated(const string& path,
+	                         const string& plugin_type,
+	                         const string& library_name,
+	                         const string& plugin_label);
+
+	void rename(const string& old_path,
+	            const string& new_name);
+
+	void destroy(const string& path);
+
+	void clear_patch(const string& patch_path);
+	
+	void connect(const string& src_port_path,
+	             const string& dst_port_path);
+
+	void disconnect(const string& src_port_path,
+	                const string& dst_port_path);
+
+	void disconnect_all(const string& parent_patch_path,
+	                    const string& node_path);
+
+	void set_port_value(const string&     port_path,
+	                    const Raul::Atom& value);
+
+	void set_voice_value(const string&     port_path,
+	                     uint32_t          voice,
+	                     const Raul::Atom& value);
+	
+	void set_port_value_immediate(const string&     port_path,
+	                              const Raul::Atom& value);
+	
+	void set_voice_value_immediate(const string&     port_path,
+	                               uint32_t          voice,
+	                               const Raul::Atom& value);
+	
+	void set_program(const string& node_path,
+	                 uint32_t      bank,
+	                 uint32_t      program);
+
+	void midi_learn(const string& node_path);
+
+	void set_variable(const string&     obj_path,
+	                  const string&     predicate,
+	                  const Raul::Atom& value);
+	
+	void set_property(const string&     obj_path,
+	                  const string&     predicate,
+	                  const Raul::Atom& value);
+	
+	// Requests //
+	void ping();
+	void request_plugin(const string& uri);
+	void request_object(const string& path);
+	void request_port_value(const string& port_path);
+	void request_variable(const string& path, const string& key);
+	void request_property(const string& path, const string& key);
+	void request_plugins();
+	void request_all_objects();
+
+protected:
+	SoupSession* _session;
+	const string _engine_url;
+	int          _client_port;
+	int32_t      _id;
+	bool         _enabled;
+};
+
+
+} // namespace Client
+} // namespace Ingen
+
+#endif // HTTPENGINESENDER_H
+
diff --git a/src/libs/client/Makefile.am b/src/libs/client/Makefile.am
index 88e2b393..76835de6 100644
--- a/src/libs/client/Makefile.am
+++ b/src/libs/client/Makefile.am
@@ -15,7 +15,8 @@ libingen_client_la_CXXFLAGS = \
 	@LXML2_CFLAGS@ \
 	@RAUL_CFLAGS@ \
 	@REDLANDMM_CFLAGS@ \
-	@SLV2_CFLAGS@
+	@SLV2_CFLAGS@ \
+	@SOUP_CFLAGS@
 
 libingen_client_la_LIBADD = \
 	../shared/libingen_shared.la \
@@ -25,14 +26,21 @@ libingen_client_la_LIBADD = \
 	@LXML2_LIBS@ \
 	@RAUL_LIBS@ \
 	@REDLANDMM_LIBS@ \
-	@SLV2_LIBS@
+	@SLV2_LIBS@ \
+	@SOUP_LIBS@
 
 libingen_client_la_SOURCES = \
 	$(top_srcdir)/ingen/src/common/interface/ClientInterface.hpp \
 	$(top_srcdir)/ingen/src/common/interface/EngineInterface.hpp \
+	ClientStore.cpp \
+	ClientStore.hpp \
 	ConnectionModel.hpp \
 	DeprecatedLoader.cpp \
 	DeprecatedLoader.hpp \
+	HTTPClientReceiver.cpp \
+	HTTPClientReceiver.hpp \
+	HTTPEngineSender.cpp \
+	HTTPEngineSender.hpp \
 	NodeModel.cpp \
 	NodeModel.hpp \
 	OSCClientReceiver.cpp \
@@ -45,13 +53,11 @@ libingen_client_la_SOURCES = \
 	PatchModel.hpp \
 	PluginModel.cpp \
 	PluginModel.hpp \
-	PluginUI.hpp \
 	PluginUI.cpp \
+	PluginUI.hpp \
 	PortModel.cpp \
 	PortModel.hpp \
 	SigClientInterface.hpp \
-	ClientStore.cpp \
-	ClientStore.hpp \
 	ThreadedSigClientInterface.cpp \
 	ThreadedSigClientInterface.hpp \
 	client.cpp \
diff --git a/src/libs/client/NodeModel.cpp b/src/libs/client/NodeModel.cpp
index 02a0a678..ac0c8e68 100644
--- a/src/libs/client/NodeModel.cpp
+++ b/src/libs/client/NodeModel.cpp
@@ -69,7 +69,7 @@ void
 NodeModel::remove_port(SharedPtr<PortModel> port)
 {
 	// FIXME: slow
-	for (PortModelList::iterator i = _ports.begin(); i != _ports.end(); ++i) {
+	for (Ports::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 		if ((*i) == port) {
 			_ports.erase(i);
 			break;
@@ -83,7 +83,7 @@ void
 NodeModel::remove_port(const Path& port_path)
 {
 	// FIXME: slow
-	for (PortModelList::iterator i = _ports.begin(); i != _ports.end(); ++i) {
+	for (Ports::iterator i = _ports.begin(); i != _ports.end(); ++i) {
 		if ((*i)->path() == port_path) {
 			_ports.erase(i);
 			break;
@@ -141,7 +141,7 @@ NodeModel::add_port(SharedPtr<PortModel> pm)
 	assert(pm->path().is_child_of(_path));
 	assert(pm->parent().get() == this);
 
-	PortModelList::iterator existing = find(_ports.begin(), _ports.end(), pm);
+	Ports::iterator existing = find(_ports.begin(), _ports.end(), pm);
 	
 	// Store should have handled this by merging the two
 	assert(existing == _ports.end());
@@ -155,7 +155,7 @@ SharedPtr<PortModel>
 NodeModel::get_port(const string& port_name) const
 {
 	assert(port_name.find("/") == string::npos);
-	for (PortModelList::const_iterator i = _ports.begin(); i != _ports.end(); ++i)
+	for (Ports::const_iterator i = _ports.begin(); i != _ports.end(); ++i)
 		if ((*i)->path().name() == port_name)
 			return (*i);
 	return SharedPtr<PortModel>();
@@ -211,8 +211,10 @@ void
 NodeModel::set(SharedPtr<ObjectModel> model)
 {
 	SharedPtr<NodeModel> node = PtrCast<NodeModel>(model);
-	if (node)
+	if (node) {
+		_plugin_uri = node->_plugin_uri;
 		_plugin = node->_plugin;
+	}
 
 	ObjectModel::set(model);
 }
diff --git a/src/libs/client/NodeModel.hpp b/src/libs/client/NodeModel.hpp
index a4bcf4d8..03afc17c 100644
--- a/src/libs/client/NodeModel.hpp
+++ b/src/libs/client/NodeModel.hpp
@@ -50,6 +50,8 @@ class NodeModel : public ObjectModel, virtual public Ingen::Shared::Node
 public:
 	NodeModel(const NodeModel& copy);
 	virtual ~NodeModel();
+	
+	typedef vector<SharedPtr<PortModel> > Ports;
 
 	SharedPtr<PortModel> get_port(const string& port_name) const;
 	
@@ -58,7 +60,7 @@ public:
 	const string&         plugin_uri() const { return _plugin_uri; }
 	const Shared::Plugin* plugin()     const { return _plugin.get(); }
 	uint32_t              num_ports()  const { return _ports.size(); }
-	const PortModelList&  ports()      const { return _ports; }
+	const Ports&          ports()      const { return _ports; }
 	
 	void port_value_range(SharedPtr<PortModel> port, float& min, float& max);
 	
@@ -84,7 +86,7 @@ protected:
 
 	virtual void clear();
 	
-	PortModelList          _ports;      ///< List of ports (not a Table to preserve order)
+	Ports                  _ports;      ///< Vector of ports (not a Table to preserve order)
 	string                 _plugin_uri; ///< Plugin URI (if PluginModel is unknown)
 	SharedPtr<PluginModel> _plugin;     ///< The plugin this node is an instance of
 	uint32_t               _num_values; ///< Size of _min_values and _max_values
@@ -93,9 +95,6 @@ protected:
 };
 
 
-typedef Table<string, SharedPtr<NodeModel> > NodeModelMap;
-
-
 } // namespace Client
 } // namespace Ingen
 
diff --git a/src/libs/client/OSCClientReceiver.hpp b/src/libs/client/OSCClientReceiver.hpp
index f1d71dbb..ea5871b3 100644
--- a/src/libs/client/OSCClientReceiver.hpp
+++ b/src/libs/client/OSCClientReceiver.hpp
@@ -25,18 +25,13 @@
 #include "raul/Deletable.hpp"
 
 namespace Ingen {
-
-/** Client library */
 namespace Client {
 
-//class NodeModel;
-
-/* Some boilerplate killing macros... */
+/** Arguments to a liblo handler */
 #define LO_HANDLER_ARGS const char* path, const char* types, lo_arg** argv, int argc, lo_message msg
 
-/* Defines a static handler to be passed to lo_add_method, which is a trivial
- * wrapper around a non-static method that does the real work.  Makes a whoole
- * lot of ugly boiler plate go away */
+/** Define a static handler to be passed to lo_add_method, which is a trivial
+ * wrapper around a non-static method that does the real work. */
 #define LO_HANDLER(name) \
 int _##name##_cb (LO_HANDLER_ARGS);\
 inline static int name##_cb(LO_HANDLER_ARGS, void* osc_listener)\
@@ -62,6 +57,8 @@ public:
 	OSCClientReceiver(int listen_port, SharedPtr<Shared::ClientInterface> target);
 	~OSCClientReceiver();
 
+	std::string uri() const { return lo_server_thread_get_url(_st); }
+
 	void start(bool dump_osc);
 	void stop();
 	
@@ -105,7 +102,6 @@ private:
 
 
 } // namespace Client
-
 } // namespace Ingen
 
 #endif // OSCCLIENTRECEIVER_H
diff --git a/src/libs/client/OSCEngineSender.hpp b/src/libs/client/OSCEngineSender.hpp
index dbb7e8f5..4c92afdb 100644
--- a/src/libs/client/OSCEngineSender.hpp
+++ b/src/libs/client/OSCEngineSender.hpp
@@ -44,7 +44,7 @@ public:
 
 	~OSCEngineSender();
 	
-	string engine_url() { return _engine_url; }
+	std::string uri() const { return _engine_url; }
 	
 	inline int32_t next_id()
 	{ int32_t ret = (_id == -1) ? -1 : _id++; return ret; }
@@ -148,9 +148,9 @@ public:
 	void request_all_objects();
 
 protected:
-	string     _engine_url;
-	int        _client_port;
-	int32_t    _id;
+	const string _engine_url;
+	int          _client_port;
+	int32_t      _id;
 };
 
 
diff --git a/src/libs/client/ObjectModel.cpp b/src/libs/client/ObjectModel.cpp
index e9a491a6..ede5f822 100644
--- a/src/libs/client/ObjectModel.cpp
+++ b/src/libs/client/ObjectModel.cpp
@@ -119,21 +119,26 @@ ObjectModel::polyphonic() const
  * @a model as correct.  The paths of the two models MUST be equal.
  */
 void
-ObjectModel::set(SharedPtr<ObjectModel> model)
+ObjectModel::set(SharedPtr<ObjectModel> o)
 {
-	assert(_path == model->path());
-
-	for (Variables::const_iterator other = model->variables().begin();
-			other != model->variables().end(); ++other) {
-		
-		Variables::const_iterator mine = _variables.find(other->first);
-		
-		if (mine != _variables.end()) {
-			cerr << "WARNING:  " << _path << "Client/Server data mismatch: " << other->first << endl;
-		}
-
-		_variables[other->first] = other->second;
-		signal_variable.emit(other->first, other->second);
+	assert(_path == o->path());
+	if (o->_parent)
+		_parent = o->_parent;
+
+	for (Variables::const_iterator v = o->variables().begin(); v != o->variables().end(); ++v) {
+		Variables::const_iterator mine = _variables.find(v->first);
+		if (mine != _variables.end())
+			cerr << "WARNING:  " << _path << "Client/Server variable mismatch: " << v->first << endl;
+		_variables[v->first] = v->second;
+		signal_variable.emit(v->first, v->second);
+	}
+	
+	for (Properties::const_iterator v = o->properties().begin(); v != o->properties().end(); ++v) {
+		Properties::const_iterator mine = _properties.find(v->first);
+		if (mine != _properties.end())
+			cerr << "WARNING:  " << _path << "Client/Server property mismatch: " << v->first << endl;
+		_properties[v->first] = v->second;
+		signal_variable.emit(v->first, v->second);
 	}
 }
 
diff --git a/src/libs/client/PortModel.cpp b/src/libs/client/PortModel.cpp
index fa3cb345..c18378db 100644
--- a/src/libs/client/PortModel.cpp
+++ b/src/libs/client/PortModel.cpp
@@ -51,7 +51,11 @@ PortModel::set(SharedPtr<ObjectModel> model)
 {
 	SharedPtr<PortModel> port = PtrCast<PortModel>(model);
 	if (port) {
+		_index = port->_index;
+		_type = port->_type;
+		_direction = port->_direction;
 		_current_val = port->_current_val;
+		_connections = port->_connections;
 		signal_value_changed.emit(_current_val);
 	}
 
diff --git a/src/libs/client/PortModel.hpp b/src/libs/client/PortModel.hpp
index a86c9188..a7f52679 100644
--- a/src/libs/client/PortModel.hpp
+++ b/src/libs/client/PortModel.hpp
@@ -105,8 +105,6 @@ private:
 	size_t    _connections;
 };
 
-typedef vector<SharedPtr<PortModel> > PortModelList;
-
 
 } // namespace Client
 } // namespace Ingen
diff --git a/src/libs/client/SigClientInterface.hpp b/src/libs/client/SigClientInterface.hpp
index 32a0a43b..7ab32c12 100644
--- a/src/libs/client/SigClientInterface.hpp
+++ b/src/libs/client/SigClientInterface.hpp
@@ -41,6 +41,8 @@ class SigClientInterface : public Ingen::Shared::ClientInterface, public sigc::t
 {
 public:
 	SigClientInterface() : _enabled(true) {}
+	
+	bool enabled() const { return _enabled; }
 
 	std::string uri() const { return "(internal)"; }
 
diff --git a/src/libs/client/ThreadedSigClientInterface.cpp b/src/libs/client/ThreadedSigClientInterface.cpp
index 3b7af80c..ef95133b 100644
--- a/src/libs/client/ThreadedSigClientInterface.cpp
+++ b/src/libs/client/ThreadedSigClientInterface.cpp
@@ -17,7 +17,8 @@
 
 #include "ThreadedSigClientInterface.hpp"
 #include <iostream>
-using std::cerr; using std::endl;
+
+using namespace std;
 
 namespace Ingen {
 namespace Client {
@@ -28,23 +29,19 @@ namespace Client {
 void
 ThreadedSigClientInterface::push_sig(Closure ev)
 {
+	_attached = true;
 	if (!_enabled)
 		return;
 
 	bool success = false;
-	bool first   = true;
-	
-	// (Very) slow busy-wait if the queue is full
-	// FIXME: Make this wait on a signal from process_sigs iff this happens
 	while (!success) {
-		//printf("push %zu\n", _sigs.fill());
 		success = _sigs.push(ev);
 		if (!success) {
-			if (first) {
-				cerr << "[ThreadedSigClientInterface] WARNING:  (Client) event queue full.  Waiting to try again..." << endl;
-				first = false;
-			}
-			usleep(200000); // 100 milliseconds (2* rate process_sigs is called)
+			cerr << "WARNING: Client event queue full.  Waiting..." << endl;
+			_mutex.lock();
+			_cond.wait(_mutex);
+			_mutex.unlock();
+			cerr << "Queue drained, continuing" << endl;
 		}
 	}
 }
@@ -58,18 +55,21 @@ ThreadedSigClientInterface::push_sig(Closure ev)
 bool
 ThreadedSigClientInterface::emit_signals()
 {
-	// Process a maximum of queue-size events, to prevent locking the GTK
+	// Process a limited number of events, to prevent locking the GTK
 	// thread indefinitely while processing continually arriving events
-	const size_t limit = _sigs.capacity();
+
 	size_t num_processed = 0;
-	while (!_sigs.empty() && num_processed++ < limit) {
-		//printf("emit %zu\n", _sigs.fill());
+	while (!_sigs.empty() && num_processed++ < (_sigs.capacity() * 3 / 4)) {
 		Closure& ev = _sigs.front();
-		_sigs.pop();
 		ev();
 		ev.disconnect();
+		_sigs.pop();
 	}
 
+	_mutex.lock();
+	_cond.broadcast();
+	_mutex.unlock();
+
 	return true;
 }
 
diff --git a/src/libs/client/ThreadedSigClientInterface.hpp b/src/libs/client/ThreadedSigClientInterface.hpp
index b3a1b72c..3014c139 100644
--- a/src/libs/client/ThreadedSigClientInterface.hpp
+++ b/src/libs/client/ThreadedSigClientInterface.hpp
@@ -21,10 +21,12 @@
 #include <inttypes.h>
 #include <string>
 #include <sigc++/sigc++.h>
+#include <glibmm/thread.h>
 #include "interface/ClientInterface.hpp"
 #include "SigClientInterface.hpp"
-#include <raul/SRSWQueue.hpp>
 #include <raul/Atom.hpp>
+#include <raul/SRSWQueue.hpp>
+
 using std::string;
 
 /** Returns nothing and takes no parameters (because they have all been bound) */
@@ -65,12 +67,15 @@ public:
 	, port_activity_slot(signal_port_activity.make_slot())
 	, program_add_slot(signal_program_add.make_slot())
 	, program_remove_slot(signal_program_remove.make_slot())
-	{}
+	{
+	}
 
 	virtual std::string uri() const { return "(internal)"; }
 
     virtual void subscribe(Shared::EngineInterface* engine) { throw; }
 
+	bool enabled() const { return _attached; }
+
 	void bundle_begin()
 		{ push_sig(bundle_begin_slot); }
 
@@ -143,7 +148,11 @@ public:
 private:
 	void push_sig(Closure ev);
 	
+	Glib::Mutex _mutex;
+	Glib::Cond  _cond;
+
 	Raul::SRSWQueue<Closure> _sigs;
+	bool                     _attached;
 
 	sigc::slot<void>                                     bundle_begin_slot; 
 	sigc::slot<void>                                     bundle_end_slot; 
diff --git a/src/libs/client/client.cpp b/src/libs/client/client.cpp
index 8b86e958..32380378 100644
--- a/src/libs/client/client.cpp
+++ b/src/libs/client/client.cpp
@@ -15,21 +15,37 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <iostream>
 #include "client.hpp"
 #include "OSCEngineSender.hpp"
+#include "HTTPEngineSender.hpp"
+
+using namespace std;
 
 namespace Ingen {
 namespace Client {
 	
 
 SharedPtr<Ingen::Shared::EngineInterface>
-new_osc_interface(const std::string& url)
+new_remote_interface(const std::string& url)
 {
-	OSCEngineSender* oes = new OSCEngineSender(url);
-	oes->attach(rand(), true);
-	return SharedPtr<Shared::EngineInterface>(oes);
+	const string scheme = url.substr(0, url.find(":"));
+	cout << "SCHEME: " << scheme << endl;
+	if (scheme == "osc.udp" || scheme == "osc.tcp") {
+		OSCEngineSender* oes = new OSCEngineSender(url);
+		oes->attach(rand(), true);
+		return SharedPtr<Shared::EngineInterface>(oes);
+	} else if (scheme == "http") {
+		HTTPEngineSender* hes = new HTTPEngineSender(url);
+		hes->attach(rand(), true);
+		return SharedPtr<Shared::EngineInterface>(hes);
+	} else {
+		cerr << "WARNING: Unknown URI scheme '" << scheme << "'" << endl;
+		return SharedPtr<Shared::EngineInterface>();
+	}
 }
 
+
 } // namespace Client
 } // namespace Ingen
 
diff --git a/src/libs/client/client.hpp b/src/libs/client/client.hpp
index 931e4c45..82166da5 100644
--- a/src/libs/client/client.hpp
+++ b/src/libs/client/client.hpp
@@ -30,7 +30,7 @@ namespace Client {
 
 extern "C" {
 
-	SharedPtr<Shared::EngineInterface> new_osc_interface(const std::string& url);
+	SharedPtr<Shared::EngineInterface> new_remote_interface(const std::string& url);
 	SharedPtr<Shared::EngineInterface> new_queued_interface(SharedPtr<Ingen::Engine> engine);
 
 }