arborist 0.2.0.pre20170519125456 → 0.2.0

data/spec/arborist/client_spec.rb

@@ -9,6 +9,13 @@ describe Arborist::Client do
 
 	let( :client ) { described_class.new }
 
+	it "can return a singleton instance" do
+		one = described_class.instance
+		two = described_class.instance
+		expect( one ).to be_a( described_class )
+		expect( one ).to equal( two )
+	end
+
 	describe "synchronous API", :testing_manager do
 
 		before( :each ) do
@@ -47,26 +54,52 @@ describe Arborist::Client do
 		let( :manager ) { @manager }
 
 
-		describe "high-level methods" do
+		describe "convenience API" do
 
-			it "provides a convenience method for acknowledging" do
-				manager.nodes['sidonie'].update( error: "Clown apocalypse" )
+			it "can fetch a single node" do
+				res = client.fetch_node( 'duir' )
+				expect( res ).to be_a( Hash )
+				expect( res['identifier'] ).to eq( 'duir' )
+			end
 
-				res = client.acknowledge( :sidonie, "I'm on it.", "ged" )
 
-				expect( manager.nodes['sidonie'] ).to be_acked
+			it "has a convenience method for fetching dependencies" do
+				res = client.dependencies_of( 'sidonie' )
+				expect( res ).to be_a( Hash ).and include( 'sidonie-postgresql', 'sidonie-ssh' )
 			end
 
 
-			it "provides a convenience method for clearing acknowledgments" do
-				manager.nodes['sidonie'].update( error: "Clown apocalypse" )
+			it "can pivot dependencies on node attributes" do
+				res = client.dependencies_of( 'sidonie', partition: 'type' )
+				expect( res ).to be_a( Hash )
+				expect( res['service'] ).to include(
+					a_hash_including( { 'identifier' => 'sidonie-ssh' } ),
+					a_hash_including( { 'identifier' => 'sidonie-postgresql' } )
+				)
+			end
 
-				res = client.acknowledge( :sidonie, "I'm on it.", "ged" )
-				res = client.clear_acknowledgement( :sidonie )
 
-				expect( manager.nodes['sidonie'] ).to_not be_acked
+			it "can fetch a subset of node dependency attributes" do
+				res = client.dependencies_of( 'sidonie', properties: %w[ description type ] )
+				expect( res ).to be_a( Hash ).and include(
+					'sandbox01',
+					'sandbox01-canary',
+					'sidonie-couchpotato',
+					'sidonie-demon-http',
+					'sidonie-http',
+					'sidonie-iscsi',
+					'sidonie-pms',
+					'sidonie-postgresql',
+					'sidonie-sabnzbd',
+					'sidonie-sickbeard',
+					'sidonie-smtp',
+					'sidonie-ssh',
+					'vhost01',
+					'yevaud-cozy_frontend'
+				)
+				expect( res.values ).to all( have_attributes(length: a_value_between(1, 2)) )
+				expect( res.values.map(&:keys) ).to all( contain_exactly 'type', 'description' )
 			end
-
 		end
 
 
@@ -78,52 +111,61 @@ describe Arborist::Client do
 			end
 
 
-			it "can list the nodes of the manager it's connected to" do
-				res = client.list
+			it "can fetch the nodes of the manager it's connected to" do
+				res = client.fetch
 				expect( res ).to be_an( Array )
 				expect( res.length ).to eq( manager.nodes.length )
 			end
 
 
-			it "can list a subtree of the nodes of the manager it's connected to" do
-				res = client.list( from: 'duir' )
+			it "can fetch a subtree of the nodes of the manager it's connected to" do
+				res = client.fetch( from: 'duir' )
 				expect( res ).to be_an( Array )
 				expect( res.length ).to be < manager.nodes.length
 			end
 
 
-			it "can list a depth-limited subtree of the node of the managed it's connected to" do
-				res = client.list( depth: 2 )
+			it "can fetch a depth-limited subtree of the node of the managed it's connected to" do
+				res = client.fetch( depth: 2 )
 				expect( res ).to be_an( Array )
-				expect( res.length ).to eq( 8 )
+				expect( res.length ).to eq( 9 )
 			end
 
 
-			it "can list a depth-limited subtree of the nodes of the manager it's connected to" do
-				res = client.list( from: 'duir', depth: 1 )
+			it "can fetch a depth-limited subtree of the nodes of the manager it's connected to" do
+				res = client.fetch( from: 'duir', depth: 1 )
 				expect( res ).to be_an( Array )
-				expect( res.length ).to eq( 5 )
+				expect( res.length ).to eq( 6 )
 			end
 
 
-			it "can fetch all node properties for all 'up' nodes" do
-				res = client.fetch
+			it "can get a Hash of all nodes keyed by identifier" do
+				res = client.search
 				expect( res ).to be_a( Hash )
 				expect( res.length ).to be == manager.nodes.length
 				expect( res.values ).to all( be_a(Hash) )
 			end
 
 
-			it "can fetch identifiers for all 'up' nodes" do
-				res = client.fetch( {}, properties: nil )
+			it "includes downed nodes by default in the results of a search" do
+				manager.nodes['sidonie'].update( error: 'something happened' )
+				res = client.search
+				expect( res ).to be_a( Hash )
+				expect( res.length ).to be == manager.nodes.length
+				expect( res.values ).to all( be_a(Hash) )
+			end
+
+
+			it "can get a Hash of all nodes without user properties" do
+				res = client.search( options: { properties: nil } )
 				expect( res ).to be_a( Hash )
 				expect( res.length ).to be == manager.nodes.length
 				expect( res.values ).to all( be_empty )
 			end
 
 
-			it "can fetch a subset of properties for all 'up' nodes" do
-				res = client.fetch( {}, properties: [:addresses, :status] )
+			it "can get a Hash of all nodes with a subset of properties" do
+				res = client.search( options: { properties: [:addresses, :status] })
 				expect( res ).to be_a( Hash )
 				expect( res.length ).to be == manager.nodes.length
 				expect( res.values ).to all( be_a(Hash) )
@@ -131,16 +173,21 @@ describe Arborist::Client do
 			end
 
 
-			it "can fetch a subset of properties for all 'up' nodes matching specified criteria" do
-				res = client.fetch( {type: 'host'}, properties: [:addresses, :status] )
+			it "can get a Hash of all nodes with a subset of properties that match specified criteria" do
+				res = client.search( criteria: {type: 'host'}, options: {properties: [:addresses, :status]} )
 				expect( res ).to be_a( Hash )
 				expect( res.length ).to be == manager.nodes.values.count {|n| n.type == 'host' }
 				expect( res.values ).to all( include('addresses', 'status') )
 			end
 
 
-			it "can fetch all node properties for 'up' nodes that don't match specified criteria" do
-				res = client.fetch( {}, properties: [:addresses, :status], exclude: {tag: 'testing'} )
+			it "can get a Hash of all nodes with a subset of properties that don't match specified criteria" do
+				res = client.search(
+					options: {
+						properties: [:addresses, :status],
+						exclude: {tag: 'testing'}
+					}
+				)
 
 				testing_nodes = manager.nodes.values.select {|n| n.tags.include?('testing') }
 
@@ -151,15 +198,14 @@ describe Arborist::Client do
 			end
 
 
-			it "can fetch all properties for all nodes regardless of their status" do
+			it "can get a Hash of nodes that exclude nodes that are down" do
 				# Down a node
 				manager.nodes['duir'].update( error: 'something happened' )
 
-				res = client.fetch( {type: 'host'}, include_down: true )
+				res = client.search( criteria: {type: 'host'}, options: {exclude_down: true} )
 
 				expect( res ).to be_a( Hash )
-				expect( res ).to include( 'duir' )
-				expect( res['duir']['status'] ).to eq( 'down' )
+				expect( res ).to_not include( 'duir' )
 			end
 
 
@@ -173,6 +219,17 @@ describe Arborist::Client do
 			end
 
 
+			it "can fetch a list of all nodes which have a dependency on a target node" do
+				res = client.deps( identifier: 'sidonie-postgresql' )
+
+				expected_ids = manager.nodes['sidonie-postgresql'].node_subscribers.to_a
+
+				expect( res ).to be_a( Hash ).and( include('deps') )
+				expect( res['deps'] ).to be_an( Array )
+				expect( res['deps'] ).to contain_exactly( *expected_ids )
+			end
+
+
 			it "can subscribe to all events" do
 				sub_id = client.subscribe
 				expect( sub_id ).to be_a( String )
@@ -261,7 +318,7 @@ describe Arborist::Client do
 
 
 			it "can prune nodes from the tree" do
-				res = client.prune( 'sidonie-ssh' )
+				res = client.prune( identifier: 'sidonie-ssh' )
 
 				expect( res ).to be_a( Hash )
 				expect( res ).to include( 'identifier' => 'sidonie-ssh' )
@@ -270,13 +327,13 @@ describe Arborist::Client do
 
 
 			it "returns nil without error when pruning a node that doesn't exist" do
-				res = client.prune( 'carrigor' )
+				res = client.prune( identifier: 'carrigor' )
 				expect( res ).to be_nil
 			end
 
 
 			it "can graft new nodes onto the tree" do
-				res = client.graft( 'breakfast-burrito', type: 'host' )
+				res = client.graft( identifier: 'breakfast-burrito', type: 'host' )
 				expect( res ).to eq({ 'identifier' => 'breakfast-burrito' })
 				expect( manager.nodes ).to include( 'breakfast-burrito' )
 				expect( manager.nodes['breakfast-burrito'] ).to be_a( Arborist::Node::Host )
@@ -285,11 +342,14 @@ describe Arborist::Client do
 
 
 			it "can graft nodes with attributes onto the tree" do
-				res = client.graft( 'breakfast-burrito',
+				res = client.graft(
+					identifier: 'breakfast-burrito',
 					type: 'service',
 					parent: 'duir',
-					port: 9999,
-					tags: ['yusss']
+					attributes: {
+						port: 9999,
+						tags: ['yusss']
+					}
 				)
 				expect( res ).to eq({ 'identifier' => 'duir-breakfast-burrito' })
 				expect( manager.nodes ).to include( 'duir-breakfast-burrito' )
@@ -301,11 +361,36 @@ describe Arborist::Client do
 
 
 			it "can modify operational attributes of a node" do
-				res = client.modify( "duir", tags: 'girlrobot' )
+				res = client.modify( identifier: "duir", attributes: { tags: 'girlrobot' })
 				expect( res ).to be_truthy
 				expect( manager.nodes['duir'].tags ).to eq( ['girlrobot'] )
 			end
 
+
+			it "can acknowledge a node" do
+				manager.nodes['sidonie'].update( error: "Clown apocalypse" )
+
+				res = client.acknowledge( identifier: 'sidonie', message: "I'm on it.", sender: "ged" )
+
+				expect( manager.nodes['sidonie'] ).to be_acked
+			end
+
+
+			it "can clear a node's acknowledgment" do
+				manager.nodes['sidonie'].update( error: "Clown apocalypse" )
+
+				res = client.acknowledge( identifier: 'sidonie', message: "I'm on it.", sender: "ged" )
+				res = client.clear_acknowledgement( identifier: 'sidonie' )
+
+				expect( manager.nodes['sidonie'] ).to_not be_acked
+			end
+
+
+			it "acking raises an appropriate error when it's missing arguments" do
+				expect {
+					client.acknowledge( identifier: 'sidonie', message: "I'm on it." )
+				}.to raise_error( ArgumentError, /missing keyword: sender/ )
+			end
 		end
 
 	end
@@ -326,8 +411,8 @@ describe Arborist::Client do
 		end
 
 
-		it "can make a raw list request" do
-			req = client.make_list_request
+		it "can make a raw fetch request" do
+			req = client.make_fetch_request
 			expect( req ).to be_a( CZTop::Message )
 
 			header, body = Arborist::TreeAPI.decode( req )
@@ -336,12 +421,12 @@ describe Arborist::Client do
 			expect( header ).to include( 'version', 'action' )
 			expect( header ).to_not include( 'from' )
 			expect( header['version'] ).to eq( Arborist::Client::API_VERSION )
-			expect( header['action'] ).to eq( 'list' )
+			expect( header['action'] ).to eq( 'fetch' )
 		end
 
 
-		it "can make a raw fetch request" do
-			req = client.make_fetch_request( {} )
+		it "can make a raw search request" do
+			req = client.make_search_request( {} )
 			expect( req ).to be_a( CZTop::Message )
 
 			header, body = Arborist::TreeAPI.decode( req )
@@ -349,14 +434,14 @@ describe Arborist::Client do
 			expect( header ).to be_a( Hash )
 			expect( header ).to include( 'version', 'action' )
 			expect( header['version'] ).to eq( Arborist::Client::API_VERSION )
-			expect( header['action'] ).to eq( 'fetch' )
+			expect( header['action'] ).to eq( 'search' )
 
 			expect( body ).to eq([ {}, {} ])
 		end
 
 
-		it "can make a raw fetch request with criteria" do
-			req = client.make_fetch_request( {type: 'host'} )
+		it "can make a raw search request with criteria" do
+			req = client.make_search_request( {type: 'host'} )
 			expect( req ).to be_a( CZTop::Message )
 
 			header, body = Arborist::TreeAPI.decode( req )
@@ -364,7 +449,7 @@ describe Arborist::Client do
 			expect( header ).to be_a( Hash )
 			expect( header ).to include( 'version', 'action' )
 			expect( header['version'] ).to eq( Arborist::Client::API_VERSION )
-			expect( header['action'] ).to eq( 'fetch' )
+			expect( header['action'] ).to eq( 'search' )
 
 			body = body
 			expect( body.first ).to be_a( Hash )
@@ -389,6 +474,27 @@ describe Arborist::Client do
 			expect( body['duir'] ).to eq( 'error' => 'Something happened.' )
 		end
 
+
+		it "can make a raw update request with headers" do
+			req = client.make_update_request(
+				{duir: {error: "Something happened."}},
+				{monitor_key: 'foom'}
+			)
+			expect( req ).to be_a( CZTop::Message )
+
+			header, body = Arborist::TreeAPI.decode( req )
+
+			expect( header ).to be_a( Hash )
+			expect( header ).to include( 'version', 'action', 'monitor_key' )
+			expect( header['version'] ).to eq( Arborist::Client::API_VERSION )
+			expect( header['action'] ).to eq( 'update' )
+			expect( header['monitor_key'] ).to eq( 'foom' )
+
+			expect( body ).to be_a( Hash )
+			expect( body ).to include( 'duir' )
+			expect( body['duir'] ).to eq( 'error' => 'Something happened.' )
+		end
+
 	end
 
 

data/spec/arborist/dependency_spec.rb

@@ -332,6 +332,27 @@ describe Arborist::Dependency do
 			expect( dep.down_reason ).to match( /node(1|2) \(and 1 other\) are unavailable as of/i )
 		end
 
+
+		it "can describe the reason if nodes in subdepedencies are down" do
+			dep.subdeps << described_class.on( :any, 'node4', 'node5' )
+
+			dep.mark_down( 'node1' )
+			dep.mark_down( 'node4' )
+			dep.mark_down( 'node5' )
+
+			expect( dep.down_reason ).to match( /node1.*node4.*node5/i )
+		end
+
+
+		it "can describe the reason if only nodes in subdepedencies are down" do
+			dep.subdeps << described_class.on( :any, 'node4', 'node5' )
+
+			dep.mark_down( 'node4' )
+			dep.mark_down( 'node5' )
+
+			expect( dep.down_reason ).to match( /node4.*node5/i )
+		end
+
 	end
 
 

data/spec/arborist/event/node_spec.rb

@@ -26,6 +26,11 @@ describe Arborist::Event::Node do
 	let( :event ) { described_class.new(node) }
 
 
+	it "serializes with useful metadata attached" do
+		expect( event.to_h ).to include( :identifier, :parent, :nodetype )
+		expect( event.to_h[:nodetype] ).to eq( 'testnode' )
+	end
+
 
 	it "matches match-anything subscriptions" do
 		sub = Arborist::Subscription.new {}

data/spec/arborist/event_spec.rb

@@ -51,10 +51,10 @@ describe Arborist::Event do
 
 			result = ev.to_h
 
-			expect( result ).to include( 'type', 'data' )
+			expect( result ).to include( :type, :data )
 
-			expect( result['type'] ).to eq( 'test.event' )
-			expect( result['data'] ).to eq( payload )
+			expect( result[:type] ).to eq( 'test.event' )
+			expect( result[:data] ).to eq( payload )
 		end
 
 

data/spec/arborist/manager_spec.rb

@@ -5,7 +5,12 @@ require_relative '../spec_helper'
 require 'tmpdir'
 require 'timecop'
 require 'arborist/manager'
+require 'arborist/mixins'
 require 'arborist/node/host'
+require 'arborist/event/node_update'
+
+using Arborist::TimeRefinements
+
 
 describe Arborist::Manager do
 
@@ -21,7 +26,7 @@ describe Arborist::Manager do
 
 
 	let( :manager ) { described_class.new }
-
+	let( :tmpfile_pathname ) { Pathname(Dir::Tmpname.create(['arb', 'tree']) {}) }
 
 
 	#
@@ -164,7 +169,7 @@ describe Arborist::Manager do
 
 
 		it "checkpoints the state file periodically if an interval is configured" do
-			statefile = Pathname( Dir.tmpdir ) + Dir::Tmpname.make_tmpname( 'arb', 'tree' )
+			statefile = tmpfile_pathname()
 			described_class.configure( checkpoint_frequency: 20_000, state_file: statefile )
 
 			manager = described_class.new
@@ -212,7 +217,38 @@ describe Arborist::Manager do
 		end
 
 
-		it "is sent at the configured interval"
+		it "is sent at the configured interval" do
+			described_class.configure( heartbeat_frequency: 11 )
+			expect( manager.reactor ).to receive( :add_periodic_timer ).with( 11 )
+
+			manager.register_heartbeat_timer
+		end
+
+
+		it "doesn't try to publish the heartbeat if it's not been started" do
+			manager.start_time = nil
+
+			manager.publish_heartbeat_event
+			expect( manager.event_queue ).to be_empty
+		end
+
+
+		it "contains runtime information about the manager" do
+			time = Time.now
+			manager.start_time = time
+
+			manager.publish_heartbeat_event
+			event = manager.event_queue.shift
+
+			expect( event ).to be_a( CZTop::Message )
+			decoded = Arborist::EventAPI.decode( event )
+
+			expect( decoded ).to include(
+				'run_id' => manager.run_id,
+				'start_time' => time.iso8601,
+				'version' => Arborist::VERSION
+			)
+		end
 
 	end
 
@@ -257,17 +293,13 @@ describe Arborist::Manager do
 		end
 
 
-		it "can replace an existing node" do
+		it "complains if adding a node that already exists" do
 			manager.add_node( node )
 			another_node = testing_node( 'italian_lessons' )
-			manager.add_node( another_node )
-
-			expect( manager.nodes ).to include( 'italian_lessons' )
-			expect( manager.nodes['italian_lessons'] ).to_not be( node )
-			expect( manager.nodes['italian_lessons'] ).to be( another_node )
 
-			expect( manager.nodecount ).to eq( 2 )
-			expect( manager.nodelist ).to include( '_', 'italian_lessons' )
+			expect {
+				manager.add_node( another_node )
+			}.to raise_error( Arborist::NodeError, /already present/ )
 		end
 
 
@@ -343,17 +375,6 @@ describe Arborist::Manager do
 		end
 
 
-		it "replaces a node in the tree when a node with an existing identifier is added" do
-			updated_node = testing_node( 'leaf' ) do
-				parent 'trunk'
-			end
-
-			manager.add_node( updated_node )
-			expect( manager.nodes['branch'].children ).to_not include( 'leaf' => leaf_node )
-			expect( manager.nodes['trunk'].children ).to include( 'leaf' => updated_node )
-		end
-
-
 		it "rebuilds the tree when a node is removed from it" do
 			manager.remove_node( 'branch' )
 
@@ -365,7 +386,7 @@ describe Arborist::Manager do
 	end
 
 
-	xdescribe "tree API", :testing_manager do
+	describe "tree API", :testing_manager do
 
 		before( :each ) do
 			@manager = nil
@@ -401,14 +422,23 @@ describe Arborist::Manager do
 		end
 
 
-		describe "status" do
+		let( :manager ) { @manager }
+
+		let( :sock ) do
+			sock = CZTop::Socket::REQ.new
+			sock.options.linger = 0
+			sock.connect( TESTING_API_SOCK )
+			sock
+		end
 
 
+		describe "status" do
+
 			it "returns a Map describing the manager and its state" do
-				msg = Arborist::TreeAPI.encode( :status )
+				msg = Arborist::TreeAPI.request( :status )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -419,13 +449,13 @@ describe Arborist::Manager do
 		end
 
 
-		describe "fetch" do
+		describe "search" do
 
 			it "returns an array of full state maps for nodes matching specified criteria" do
-				msg = Arborist::TreeAPI.encode( :fetch, type: 'service', port: 22 )
+				msg = Arborist::TreeAPI.request( :search, type: 'service', port: 22 )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -439,10 +469,10 @@ describe Arborist::Manager do
 
 
 			it "returns an array of full state maps for nodes not matching specified negative criteria" do
-				msg = Arborist::TreeAPI.encode( :fetch, [ {}, {type: 'service', port: 22} ] )
+				msg = Arborist::TreeAPI.request( :search, [ {}, {type: 'service', port: 22} ] )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -456,28 +486,28 @@ describe Arborist::Manager do
 
 
 			it "returns an array of full state maps for nodes combining positive and negative criteria" do
-				msg = Arborist::TreeAPI.encode( :fetch, [ {type: 'service'}, {port: 22} ] )
+				msg = Arborist::TreeAPI.request( :search, [ {type: 'service'}, {port: 22} ] )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
 
 				expect( body ).to be_a( Hash )
-				expect( body.length ).to eq( 16 )
+				expect( body.length ).to eq( 18 )
 
 				expect( body.values ).to all( be_a(Hash) )
 				expect( body.values ).to all( include('status', 'type') )
 			end
 
 
-			it "doesn't return nodes beneath downed nodes by default" do
+			it "omits nodes beneath downed nodes if asked to" do
 				manager.nodes['sidonie'].update( error: 'sunspots' )
-				msg = Arborist::TreeAPI.encode( :fetch, type: 'service', port: 22 )
+				msg = Arborist::TreeAPI.request( :search, {exclude_down: true}, type: 'service', port: 22 )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -487,12 +517,12 @@ describe Arborist::Manager do
 			end
 
 
-			it "does return nodes beneath downed nodes if asked to" do
+			it "include nodes beneath downed nodes by default" do
 				manager.nodes['sidonie'].update( error: 'plague of locusts' )
-				msg = Arborist::TreeAPI.encode( :fetch, {include_down: true}, type: 'service', port: 22 )
+				msg = Arborist::TreeAPI.request( :search, type: 'service', port: 22 )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -503,10 +533,10 @@ describe Arborist::Manager do
 
 
 			it "returns only identifiers if the `return` header is set to `nil`" do
-				msg = Arborist::TreeAPI.encode( :fetch, {return: nil}, type: 'service', port: 22 )
+				msg = Arborist::TreeAPI.request( :search, {return: nil}, type: 'service', port: 22 )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -518,11 +548,11 @@ describe Arborist::Manager do
 
 
 			it "returns only specified state if the `return` header is set to an Array of keys" do
-				msg = Arborist::TreeAPI.encode( :fetch, {return: %w[status tags addresses]},
+				msg = Arborist::TreeAPI.request( :search, {return: %w[status tags addresses]},
 					type: 'service', port: 22 )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -535,12 +565,12 @@ describe Arborist::Manager do
 		end
 
 
-		describe "list" do
+		describe "fetch" do
 
 			it "returns an array of node state" do
-				msg = Arborist::TreeAPI.encode( :list )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :fetch )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -554,10 +584,44 @@ describe Arborist::Manager do
 				expect( body ).to include( hash_including('identifier' => 'yevaud') )
 			end
 
+
+			it "can start at a node other than the root" do
+				msg = Arborist::TreeAPI.request( :fetch, {from: 'sidonie'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => true )
+				expect( body.length ).to eq( manager.nodes.keys.count {|id| id.include?('sidonie')} )
+				expect( body ).to all( be_a(Hash) )
+				expect( body ).to_not include( hash_including('identifier' => '_') )
+				expect( body ).to_not include( hash_including('identifier' => 'duir') )
+				expect( body ).to include( hash_including('identifier' => 'sidonie') )
+				expect( body ).to include( hash_including('identifier' => 'sidonie-ssh') )
+				expect( body ).to include( hash_including('identifier' => 'sidonie-demon-http') )
+				expect( body ).to_not include( hash_including('identifier' => 'yevaud') )
+			end
+
+
+			it "can be fetched as a tree" do
+				msg = Arborist::TreeAPI.request( :fetch, {tree: true}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => true )
+				expect( body.length ).to eq( 1 )
+				expect( body.first ).to be_a( Hash )
+				expect( body.first ).to include( 'children' )
+				expect( body.first['identifier'] ).to eq( '_' )
+				expect( body.first['children'].keys ).to include( 'duir', 'localhost' )
+			end
+
+
 			it "can be limited by depth" do
-				msg = Arborist::TreeAPI.encode( :list, {depth: 1}, nil )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :fetch, {depth: 1}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -567,6 +631,18 @@ describe Arborist::Manager do
 				expect( body ).to include( hash_including('identifier' => 'duir') )
 				expect( body ).to_not include( hash_including('identifier' => 'duir-ssh') )
 			end
+
+
+			it "errors when fetching from a nonexistent node" do
+				msg = Arborist::TreeAPI.request( :fetch, {from: "nope-nope-nope"}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+				expect( hdr ).to include( "reason" => "No such node nope-nope-nope." )
+				expect( body ).to be_nil
+			end
 		end
 
 
@@ -590,9 +666,9 @@ describe Arborist::Manager do
 						}
 					}
 				}
-				msg = Arborist::TreeAPI.encode( :update, update_data )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :update, update_data )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -605,18 +681,18 @@ describe Arborist::Manager do
 
 
 			it "ignores unknown identifiers" do
-				msg = Arborist::TreeAPI.encode( :update, charlie_humperton: {ping: { rtt: 8 }} )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :update, charlie_humperton: {ping: { rtt: 8 }} )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
 			end
 
 			it "fails with a client error if the body is invalid" do
-				msg = Arborist::TreeAPI.encode( :update, nil )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :update, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => false )
@@ -628,12 +704,12 @@ describe Arborist::Manager do
 		describe "subscribe" do
 
 			it "adds a subscription for all event types to the root node by default" do
-				msg = Arborist::TreeAPI.encode( :subscribe, [{}, {}] )
+				msg = Arborist::TreeAPI.request( :subscribe, [{}, {}] )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to change { manager.subscriptions.length }.by( 1 ).and(
 					change { manager.root.subscriptions.length }.by( 1 )
 				)
@@ -642,42 +718,44 @@ describe Arborist::Manager do
 				sub_id = manager.subscriptions.keys.first
 
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq([ sub_id ])
+				expect( body ).to be_a( Hash )
+				expect( body ).to include( 'id' )
+				expect( manager.subscriptions.keys ).to include( body['id'] )
 			end
 
 
 			it "adds a subscription to the specified node if an identifier is specified" do
-				msg = Arborist::TreeAPI.encode( :subscribe, {identifier: 'sidonie'}, [{}, {}] )
+				msg = Arborist::TreeAPI.request( :subscribe, {identifier: 'sidonie'}, [{}, {}] )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to change { manager.subscriptions.length }.by( 1 ).and(
 					change { manager.nodes['sidonie'].subscriptions.length }.by( 1 )
 				)
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 
-				sub_id = manager.subscriptions.keys.first
-
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq([ sub_id ])
+				expect( body ).to be_a( Hash )
+				expect( body ).to include( 'id' )
+				expect( manager.subscriptions.keys ).to include( body['id'] )
 			end
 
 
 			it "adds a subscription for particular event types if one is specified" do
-				msg = Arborist::TreeAPI.encode( :subscribe, {event_type: 'node.acked'}, [{}, {}] )
+				msg = Arborist::TreeAPI.request( :subscribe, {event_type: 'node.acked'}, [{}, {}] )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to change { manager.subscriptions.length }.by( 1 ).and(
 					change { manager.root.subscriptions.length }.by( 1 )
 				)
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
-				node = manager.subscriptions[ body.first ]
-				sub = node.subscriptions[ body.first ]
+				node = manager.subscriptions[ body['id'] ]
+				sub = node.subscriptions[ body['id'] ]
 
 				expect( sub.event_type ).to eq( 'node.acked' )
 			end
@@ -686,18 +764,19 @@ describe Arborist::Manager do
 			it "adds a subscription for events which match a pattern if one is specified" do
 				criteria = { type: 'host' }
 
-				msg = Arborist::TreeAPI.encode( :subscribe, [criteria, {}] )
+				msg = Arborist::TreeAPI.request( :subscribe, [criteria, {}] )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to change { manager.subscriptions.length }.by( 1 ).and(
 					change { manager.root.subscriptions.length }.by( 1 )
 				)
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
-				node = manager.subscriptions[ body.first ]
-				sub = node.subscriptions[ body.first ]
+				expect( body ).to be_a( Hash ).and( include('id') )
+				node = manager.subscriptions[ body['id'] ]
+				sub = node.subscriptions[ body['id'] ]
 
 				expect( sub.event_type ).to be_nil
 				expect( sub.criteria ).to eq({ 'type' => 'host' })
@@ -707,18 +786,19 @@ describe Arborist::Manager do
 			it "adds a subscription for events which don't match a pattern if an exclusion pattern is given" do
 				criteria = { type: 'host' }
 
-				msg = Arborist::TreeAPI.encode( :subscribe, [{}, criteria] )
+				msg = Arborist::TreeAPI.request( :subscribe, [{}, criteria] )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to change { manager.subscriptions.length }.by( 1 ).and(
 					change { manager.root.subscriptions.length }.by( 1 )
 				)
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
-				node = manager.subscriptions[ body.first ]
-				sub = node.subscriptions[ body.first ]
+				expect( body ).to be_a( Hash ).and( include('id') )
+				node = manager.subscriptions[ body['id'] ]
+				sub = node.subscriptions[ body['id'] ]
 
 				expect( sub.event_type ).to be_nil
 				expect( sub.negative_criteria ).to eq({ 'type' => 'host' })
@@ -735,12 +815,12 @@ describe Arborist::Manager do
 
 
 			it "removes the subscription with the specified ID" do
-				msg = Arborist::TreeAPI.encode( :unsubscribe, {subscription_id: subscription.id}, nil )
+				msg = Arborist::TreeAPI.request( :unsubscribe, {subscription_id: subscription.id}, nil )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to change { manager.subscriptions.length }.by( -1 ).and(
 					change { manager.root.subscriptions.length }.by( -1 )
 				)
@@ -751,12 +831,12 @@ describe Arborist::Manager do
 
 
 			it "ignores unsubscription of a non-existant ID" do
-				msg = Arborist::TreeAPI.encode( :unsubscribe, {subscription_id: 'the bears!'}, nil )
+				msg = Arborist::TreeAPI.request( :unsubscribe, {subscription_id: 'the bears!'}, nil )
 
 				resmsg = nil
 				expect {
-					sock.send( msg )
-					resmsg = sock.recv
+					msg.send_to( sock )
+					resmsg = sock.receive
 				}.to_not change { manager.subscriptions.length }
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 
@@ -769,21 +849,22 @@ describe Arborist::Manager do
 		describe "prune" do
 
 			it "removes a single node" do
-				msg = Arborist::TreeAPI.encode( :prune, {identifier: 'duir-ssh'}, nil )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :prune, {identifier: 'duir-ssh'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq( true )
+				expect( body ).to be_a( Hash )
+				expect( body ).to include( 'identifier' => 'duir-ssh' )
 				expect( manager.nodes ).to_not include( 'duir-ssh' )
 			end
 
 
 			it "returns Nil without error if the node to prune didn't exist" do
-				msg = Arborist::TreeAPI.encode( :prune, {identifier: 'shemp-ssh'}, nil )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :prune, {identifier: 'shemp-ssh'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -792,22 +873,23 @@ describe Arborist::Manager do
 
 
 			it "removes children nodes along with the parent" do
-				msg = Arborist::TreeAPI.encode( :prune, {identifier: 'duir'}, nil )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :prune, {identifier: 'duir'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq( true )
+				expect( body ).to be_a( Hash )
+				expect( body ).to include( 'identifier' => 'duir' )
 				expect( manager.nodes ).to_not include( 'duir' )
 				expect( manager.nodes ).to_not include( 'duir-ssh' )
 			end
 
 
 			it "returns an error to the client when missing required attributes" do
-				msg = Arborist::TreeAPI.encode( :prune )
-				sock.send( msg )
-				resmsg = sock.recv
+				msg = Arborist::TreeAPI.request( :prune )
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => false )
@@ -828,14 +910,14 @@ describe Arborist::Manager do
 					addresses: ['10.2.66.8'],
 					tags: ['internal', 'football']
 				}
-				msg = Arborist::TreeAPI.encode( :graft, header, attributes )
+				msg = Arborist::TreeAPI.request( :graft, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq( 'guenter' )
+				expect( body ).to include( 'identifier' => 'guenter' )
 
 				new_node = manager.nodes[ 'guenter' ]
 				expect( new_node ).to be_a( Arborist::Node::Host )
@@ -857,14 +939,14 @@ describe Arborist::Manager do
 					addresses: ['192.168.22.8'],
 					tags: ['evil', 'space', 'entity']
 				}
-				msg = Arborist::TreeAPI.encode( :graft, header, attributes )
+				msg = Arborist::TreeAPI.request( :graft, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq( 'orgalorg' )
+				expect( body ).to include( 'identifier' => 'orgalorg' )
 
 				new_node = manager.nodes[ 'orgalorg' ]
 				expect( new_node ).to be_a( Arborist::Node::Host )
@@ -885,14 +967,14 @@ describe Arborist::Manager do
 				attributes = {
 					description: 'Mmmmm AppleTalk.'
 				}
-				msg = Arborist::TreeAPI.encode( :graft, header, attributes )
+				msg = Arborist::TreeAPI.request( :graft, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
-				expect( body ).to eq( 'duir-echo' )
+				expect( body ).to eq( 'identifier' => 'duir-echo' )
 
 				new_node = manager.nodes[ 'duir-echo' ]
 				expect( new_node ).to be_a( Arborist::Node::Service )
@@ -913,16 +995,31 @@ describe Arborist::Manager do
 				attributes = {
 					description: 'Mmmmm AppleTalk.'
 				}
-				msg = Arborist::TreeAPI.encode( :graft, header, attributes )
+				msg = Arborist::TreeAPI.request( :graft, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => false )
 				expect( hdr['reason'] ).to match( /no host given/i )
 			end
 
+
+			it "errors if adding a node that already exists" do
+				header = {
+					identifier: 'duir',
+			        type: 'host',
+				}
+				msg = Arborist::TreeAPI.request( :graft, header, {} )
+
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+				expect( hdr['reason'] ).to match( /exists/i )
+			end
 		end
 
 
@@ -936,10 +1033,10 @@ describe Arborist::Manager do
 					parent: '_',
 					addresses: ['192.168.32.32', '10.2.2.28']
 				}
-				msg = Arborist::TreeAPI.encode( :modify, header, attributes )
+				msg = Arborist::TreeAPI.request( :modify, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -959,10 +1056,10 @@ describe Arborist::Manager do
 				attributes = {
 					identifier: 'somethingelse'
 				}
-				msg = Arborist::TreeAPI.encode( :modify, header, attributes )
+				msg = Arborist::TreeAPI.request( :modify, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => true )
@@ -979,10 +1076,10 @@ describe Arborist::Manager do
 				attributes = {
 					identifier: 'somethingelse'
 				}
-				msg = Arborist::TreeAPI.encode( :modify, header, attributes )
+				msg = Arborist::TreeAPI.request( :modify, header, attributes )
 
-				sock.send( msg )
-				resmsg = sock.recv
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => false )
@@ -997,16 +1094,396 @@ describe Arborist::Manager do
 				attributes = {
 					identifier: 'somethingelse'
 				}
-				msg = Arborist::TreeAPI.encode( :modify, header, attributes )
+				msg = Arborist::TreeAPI.request( :modify, header, attributes )
+
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+			end
+
+
+			it "reparents a node whose parent is altered" do
+				header = {
+					identifier: 'sidonie'
+				}
+				attributes = {
+					parent: 'yevaud'
+				}
+
+				msg = Arborist::TreeAPI.request( :modify, header, attributes )
+
+				node = manager.nodes[ 'sidonie' ]
+				old_parent = manager.nodes[ 'duir' ]
+				expect( node.parent ).to eq( 'duir' )
+
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => true )
+
+				new_parent = manager.nodes[ 'yevaud' ]
+				expect( node.parent ).to eq( 'yevaud' )
+				expect( old_parent.children ).to_not include( 'sidonie' )
+				expect( new_parent.children ).to include( 'sidonie' )
+			end
+
+		end
+
 
-				sock.send( msg )
-				resmsg = sock.recv
+		describe "deps" do
+
+			it "returns a list of the identifiers of nodes that depend on it" do
+				msg = Arborist::TreeAPI.request( :deps, {from: 'sidonie'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => true )
+				expect( body ).to be_a( Hash )
+				expect( body ).to include( 'deps' )
+				expect( body['deps'] ).to_not include( 'sidonie' )
+				expect( body['deps'] ).to be_an( Array ).
+					and( include('sidonie-ssh', 'yevaud-cozy_frontend', 'sandbox01-canary') )
+			end
+
+		end
+
+
+		describe "ack" do
+
+			it "acknowledges a single node" do
+				msg = Arborist::TreeAPI.request( :ack,
+					{identifier: 'sidonie'},
+					{message: "Planned maintenance", sender: 'xerces'}
+				)
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => true )
+				expect( body ).to be_nil
+
+				expect( manager.nodes['sidonie'] ).to be_disabled
+			end
+
+
+			it "returns an error if the node to ack doesn't exist" do
+				msg = Arborist::TreeAPI.request( :ack,
+					{identifier: 'shemp-ssh'},
+					{message: "Planned maintenance", sender: 'xerces'}
+				)
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+				expect( hdr['reason'] ).to match( /no such node/i )
+			end
+
+
+			it "returns an error if the node to ack isn't specified" do
+				msg = Arborist::TreeAPI.request( :ack, {}, {message: "", sender: ''} )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+				expect( hdr['reason'] ).to match( /no identifier/i )
+			end
+
+
+			it "returns an error if one of the required arguments isn't provided" do
+				msg = Arborist::TreeAPI.request( :ack,
+					{identifier: 'sidonie'},
+					{message: "Planned maintenance"}
+				)
+				msg.send_to( sock )
+				resmsg = sock.receive
 
 				hdr, body = Arborist::TreeAPI.decode( resmsg )
 				expect( hdr ).to include( 'success' => false )
+				expect( hdr['reason'] ).to match( /missing required ack sender/i )
+			end
+
+
+			it "propagates events from an acknowledgement up the node tree" do
+				expect( manager.root ).to receive( :publish_events ).
+					at_least( :once ).
+					and_call_original
+				expect( manager.nodes['duir'] ).to receive( :publish_events ).
+					at_least( :once ).
+					and_call_original
+
+				manager.handle_ack_request( { 'identifier' => 'sidonie' }, {
+					'message' => 'There will also be corn served.',
+					'sender'  =>  'Smoove-B'
+				})
 			end
 		end
 
+
+		describe "unack" do
+
+			it "removes an acknowledgement from a single node" do
+				msg = Arborist::TreeAPI.request( :unack, {identifier: 'sidonie'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => true )
+				expect( body ).to be_nil
+
+				expect( manager.nodes['sidonie'] ).to be_unknown
+			end
+
+
+			it "returns an error if the node to unack doesn't exist" do
+				msg = Arborist::TreeAPI.request( :unack, {identifier: 'shemp-ssh'}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+				expect( hdr['reason'] ).to match( /no such/i )
+			end
+
+
+			it "returns an error if the node to unack isn't specified" do
+				msg = Arborist::TreeAPI.request( :unack, {}, nil )
+				msg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include( 'success' => false )
+				expect( hdr['reason'] ).to match( /no identifier/i )
+			end
+
+
+			it "propagates events from an unack up the node tree" do
+				expect( manager.root ).to receive( :publish_events ).
+					at_least( :once ).
+					and_call_original
+				expect( manager.nodes['duir'] ).to receive( :publish_events ).
+					at_least( :once ).
+					and_call_original
+				manager.handle_unack_request( { 'identifier' => 'sidonie' }, nil )
+			end
+		end
+
+
+
+		describe "malformed requests" do
+
+			it "send an error response if the request can't be deserialized" do
+				sock << "whatevs, dude!"
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if the request isn't a tuple" do
+				sock << MessagePack.pack({ version: 1, action: 'fetch' })
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*not an array/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if the request is empty" do
+				sock << MessagePack.pack([])
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*expected 1-2 parts, got 0/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if the request is an incorrect length" do
+				sock << MessagePack.pack( [{}, {}, {}] )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /expected 1-2 parts, got 3/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if the request's header is not a Map" do
+				sock << MessagePack.pack( [nil, {}] )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /no header/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if the request's body is not Nil, a Map, or an Array of Maps" do
+				sock << MessagePack.pack( [{version: 1, action: 'fetch'}, 18] )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*body must be nil, a map, or an array of maps/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if missing a version" do
+				sock << MessagePack.pack( [{action: 'fetch'}] )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*missing required header 'version'/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response if missing an action" do
+				sock << MessagePack.pack( [{version: 1}] )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*missing required header 'action'/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response for unknown actions" do
+				badmsg = Arborist::TreeAPI.request( :slap )
+				badmsg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*no such action 'slap'/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+
+			it "send an error response for the `tree` action" do
+				badmsg = Arborist::TreeAPI.request( :tree )
+				badmsg.send_to( sock )
+				resmsg = sock.receive
+
+				hdr, body = Arborist::TreeAPI.decode( resmsg )
+				expect( hdr ).to include(
+					'success'  => false,
+					'reason'   => /invalid message.*no such action 'tree'/i,
+					'category' => 'client'
+				)
+				expect( body ).to be_nil
+			end
+
+		end
+
+	end
+
+
+	describe "event API" do
+
+		before( :each ) do
+			@manager = nil
+			@manager_thread = Thread.new do
+				@manager = make_testing_manager()
+				Thread.current.abort_on_exception = true
+				@manager.run
+				Loggability[ Arborist ].info "Stopped the test manager"
+			end
+
+			count = 0
+			until (@manager && @manager.running?) || count > 30
+				sleep 0.1
+				count += 1
+			end
+			raise "Manager didn't start up" unless @manager.running?
+		end
+
+		after( :each ) do
+			@manager.simulate_signal( :TERM )
+			unless @manager_thread.join( 5 )
+				$stderr.puts "Manager thread didn't exit on its own; killing it."
+				@manager_thread.kill
+			end
+
+			count = 0
+			while @manager.running? || count > 30
+				sleep 0.1
+				Loggability[ Arborist ].info "Manager still running"
+				count += 1
+			end
+			raise "Manager didn't stop" if @manager.running?
+		end
+
+
+		let( :manager ) { @manager }
+
+		let!( :sock ) do
+			sock = CZTop::Socket::SUB.new
+			sock.options.linger = 0
+			sock.subscribe( '' )
+			event_uri = manager.event_socket.last_endpoint
+			sock.connect( event_uri )
+			Loggability[ Arborist ].info "Connected subscribed socket to %p" % [ event_uri ]
+			sock
+		end
+
+
+		it "publishes messages via the event socket" do
+			node = Arborist::Node.create( :root )
+			event = Arborist::Event.create( :node_update, node )
+			manager.publish( 'identifier-00aa', event )
+
+			msg = nil
+			wait( 1.second ).for { msg = sock.receive }.to be_a( CZTop::Message )
+
+			expect( msg.frames.first.to_s ).to eq( 'identifier-00aa' )
+			expect( msg.frames.last.to_s ).to be_a_messagepacked( Hash )
+		end
+
 	end
 
 
@@ -1096,7 +1573,7 @@ describe Arborist::Manager do
 	end
 
 
-	describe "node updates and events" do
+	describe "node updates" do
 
 		let( :tree ) do
 			#                        router
@@ -1125,8 +1602,8 @@ describe Arborist::Manager do
 		end
 
 
-		it "can fetch a Hash of node states" do
-			states = manager.fetch_matching_node_states( {}, [] )
+		it "can search a Hash of node states" do
+			states = manager.find_matching_node_states( {}, [] )
 			expect( states.size ).to eq( manager.nodes.size )
 			expect( states ).to include( 'host-b-nfs', 'host-c', 'router' )
 			expect( states['host-b-nfs'] ).to be_a( Hash )
@@ -1135,26 +1612,26 @@ describe Arborist::Manager do
 		end
 
 
-		it "can fetch a Hash of node states for nodes which match specified criteria" do
-			states = manager.fetch_matching_node_states( {'identifier' => 'host-c'}, [] )
+		it "can search a Hash of node states for nodes which match specified criteria" do
+			states = manager.find_matching_node_states( {'identifier' => 'host-c'}, [] )
 			expect( states.size ).to eq( 1 )
 			expect( states.keys.first ).to eq( 'host-c' )
 			expect( states['host-c'] ).to be_a( Hash )
 		end
 
 
-		it "can fetch a Hash of node states for nodes which don't match specified negative criteria" do
-			states = manager.fetch_matching_node_states( {}, [], false, {'identifier' => 'host-c'} )
+		it "can search a Hash of node states for nodes which don't match specified negative criteria" do
+			states = manager.find_matching_node_states( {}, [], false, {'identifier' => 'host-c'} )
 			expect( states.size ).to eq( manager.nodes.size - 1 )
 			expect( states ).to_not include( 'host-c' )
 		end
 
 
-		it "can fetch a Hash of node states for nodes combining positive and negative criteria" do
+		it "can search a Hash of node states for nodes combining positive and negative criteria" do
 			positive = {'tag' => 'home'}
 			negative = {'identifier' => 'host-a-www'}
 
-			states = manager.fetch_matching_node_states( positive, [], false, negative )
+			states = manager.find_matching_node_states( positive, [], false, negative )
 
 			expect( states.size ).to eq( 2 )
 			expect( states ).to_not include( 'host-a-www' )
@@ -1241,201 +1718,3 @@ describe Arborist::Manager do
 end
 
 
-__END__
-
-	let( :socket ) { instance_double( ZMQ::Socket::Pub ) }
-	let( :pollitem ) { instance_double( ZMQ::Pollitem, pollable: socket ) }
-	let( :zloop ) { instance_double( ZMQ::Loop ) }
-
-	let( :manager ) { Arborist::Manager.new }
-	let( :event ) { Arborist::Event.create(TestEvent, 'stuff') }
-
-	let( :publisher ) { described_class.new(pollitem, manager, zloop) }
-
-
-	it "starts out registered for writing" do
-		expect( publisher ).to be_registered
-	end
-
-
-	it "unregisters itself if told to write with an empty event queue" do
-		expect( zloop ).to receive( :remove ).with( pollitem )
-		expect {
-			publisher.on_writable
-		}.to change { publisher.registered? }.to( false )
-	end
-
-
-	it "registers itself if it's not already when an event is appended" do
-		# Cause the socket to become unregistered
-		allow( zloop ).to receive( :remove )
-		publisher.on_writable
-
-		expect( zloop ).to receive( :register ).with( pollitem )
-
-		expect {
-			publisher.publish( 'identifier-00aa', event )
-		}.to change { publisher.registered? }.to( true )
-	end
-
-
-	it "publishes events with their identifier" do
-		identifier = '65b2430b-6855-4961-ab46-d742cf4456a1'
-
-		expect( socket ).to receive( :sendm ).with( identifier )
-		expect( socket ).to receive( :send ) do |raw_data|
-			ev = MessagePack.unpack( raw_data )
-			expect( ev ).to include( 'type', 'data' )
-
-			expect( ev['type'] ).to eq( 'test.event' )
-			expect( ev['data'] ).to eq( 'stuff' )
-		end
-		expect( zloop ).to receive( :remove ).with( pollitem )
-
-		publisher.publish( identifier, event )
-		publisher.on_writable
-	end
-
-
-
-	let( :manager ) { @manager }
-
-	let!( :sock ) do
-		sock = Arborist.zmq_context.socket( :REQ )
-		sock.linger = 0
-		sock.connect( TESTING_API_SOCK )
-		sock
-	end
-
-	let( :api_handler ) { described_class.new( rep_sock, manager ) }
-
-
-	describe "malformed requests" do
-
-		it "send an error response if the request can't be deserialized" do
-			sock.send( "whatevs, dude!" )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if the request isn't a tuple" do
-			sock.send( MessagePack.pack({ version: 1, action: 'list' }) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*not a tuple/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if the request is empty" do
-			sock.send( MessagePack.pack([]) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*incorrect length/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if the request is an incorrect length" do
-			sock.send( MessagePack.pack([{}, {}, {}]) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*incorrect length/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if the request's header is not a Map" do
-			sock.send( MessagePack.pack([nil, {}]) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*header is not a map/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if the request's body is not Nil, a Map, or an Array of Maps" do
-			sock.send( MessagePack.pack([{version: 1, action: 'list'}, 18]) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*body must be nil, a map, or an array of maps/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if missing a version" do
-			sock.send( MessagePack.pack([{action: 'list'}]) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*missing required header 'version'/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response if missing an action" do
-			sock.send( MessagePack.pack([{version: 1}]) )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*missing required header 'action'/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-
-
-		it "send an error response for unknown actions" do
-			badmsg = Arborist::TreeAPI.encode( :slap )
-			sock.send( badmsg )
-			resmsg = sock.recv
-
-			hdr, body = Arborist::TreeAPI.decode( resmsg )
-			expect( hdr ).to include(
-				'success'  => false,
-				'reason'   => /invalid request.*no such action 'slap'/i,
-				'category' => 'client'
-			)
-			expect( body ).to be_nil
-		end
-	end
-