arborist 0.0.1.pre20160606141735 → 0.0.1.pre20160829140603

data/lib/arborist/node/service.rb

@@ -7,11 +7,13 @@ require 'socket'
 
 require 'arborist/node'
 require 'arborist/mixins'
+require 'arborist/exceptions'
 
 
 # A node type for Arborist trees that represent services running on hosts.
 class Arborist::Node::Service < Arborist::Node
-	include Arborist::HashUtilities
+	include Arborist::HashUtilities,
+	        Arborist::NetworkUtilities
 
 
 	# The default transport layer protocol to use for services that don't specify
@@ -29,6 +31,7 @@ class Arborist::Node::Service < Arborist::Node
 		qualified_identifier = "%s-%s" % [ host.identifier, identifier ]
 
 		@host         = host
+		@addresses    = nil
 		@app_protocol = nil
 		@protocol     = nil
 		@port         = nil
@@ -84,9 +87,25 @@ class Arborist::Node::Service < Arborist::Node
 	end
 
 
+	### Set an IP address of the service. This must be one of the addresses of its
+	### containing host.
+	def address( new_address )
+		self.log.debug "Adding address %p to %p" % [ new_address, self ]
+		normalized_addresses = normalize_address( new_address )
+
+		unless normalized_addresses.all? {|addr| @host.addresses.include?(addr) }
+			raise Arborist::ConfigError, "%s is not one of %s's addresses" %
+				[ new_address, @host.identifier ]
+		end
+
+		@addresses ||= []
+		@addresses += normalized_addresses
+	end
+
+
 	### Delegate the service's address to its host.
 	def addresses
-		return @host.addresses
+		return @addresses || @host.addresses
 	end
 
 

data/lib/arborist/observer_runner.rb

@@ -31,7 +31,8 @@ class Arborist::ObserverRunner
 
 		### Create a ZMQ::Handler that acts as the agent that runs the specified
 		### +observer+.
-		def initialize( reactor )
+		def initialize( runner, reactor )
+			@runner = runner
 			@client = Arborist::Client.new
 			@pollitem = ZMQ::Pollitem.new( @client.event_api, ZMQ::POLLIN )
 			@pollitem.handler = self
@@ -45,6 +46,9 @@ class Arborist::ObserverRunner
 		public
 		######
 
+		# The Arborist::ObserverRunner that owns this handler.
+		attr_reader :runner
+
 		# The Arborist::Client that will be used for creating and tearing down subscriptions
 		attr_reader :client
 
@@ -52,6 +56,16 @@ class Arborist::ObserverRunner
 		attr_reader :subscriptions
 
 
+		### Unsubscribe from and clear all current subscriptions.
+		def reset
+			self.log.warn "Resetting the observer handler."
+			self.subscriptions.keys.each do |subid|
+				self.client.event_api.unsubscribe( subid )
+			end
+			self.subscriptions.clear
+		end
+
+
 		### Add the specified +observer+ and subscribe to the events it wishes to receive.
 		def add_observer( observer )
 			self.log.info "Adding observer: %s" % [ observer.description ]
@@ -85,10 +99,13 @@ class Arborist::ObserverRunner
 			subid = self.recv
 			raise "Partial write?!" unless self.pollitem.pollable.rcvmore?
 			raw_event = self.recv
+			event = MessagePack.unpack( raw_event )
 
 			if (( observer = self.subscriptions[subid] ))
-				event = MessagePack.unpack( raw_event )
 				observer.handle_event( subid, event )
+			elsif subid.start_with?( 'sys.' )
+				self.log.debug "System event! %p" % [ event ]
+				self.runner.handle_system_event( subid, event )
 			else
 				self.log.warn "Ignoring event %p for which we have no observer." % [ subid ]
 			end
@@ -105,6 +122,7 @@ class Arborist::ObserverRunner
 		@timers = []
 		@handler = nil
 		@reactor = ZMQ::Loop.new
+		@manager_last_runid = nil
 	end
 
 
@@ -133,12 +151,11 @@ class Arborist::ObserverRunner
 
 	### Run the specified +observers+
 	def run
-		self.handler = Arborist::ObserverRunner::Handler.new( self.reactor )
+		self.handler = Arborist::ObserverRunner::Handler.new( self, self.reactor )
 
-		self.observers.each do |observer|
-			self.handler.add_observer( observer )
-			self.add_timers_for( observer )
-		end
+		self.register_observers
+		self.register_observer_timers
+		self.subscribe_to_system_events
 
 		self.reactor.start
 	rescue Interrupt
@@ -158,6 +175,28 @@ class Arborist::ObserverRunner
 	end
 
 
+	### Register each of the runner's Observers with its handler.
+	def register_observers
+		self.observers.each do |observer|
+			self.handler.add_observer( observer )
+		end
+	end
+
+
+	### Register timers for each Observer.
+	def register_observer_timers
+		self.observers.each do |observer|
+			self.add_timers_for( observer )
+		end
+	end
+
+
+	### Subscribe the runner to system events published by the Manager.
+	def subscribe_to_system_events
+		self.handler.client.event_api.subscribe( 'sys.' )
+	end
+
+
 	### Register a timer for the specified +observer+.
 	def add_timers_for( observer )
 		observer.timers.each do |interval, callback|
@@ -177,5 +216,27 @@ class Arborist::ObserverRunner
 		end
 	end
 
+
+	### Handle a `sys.` event from the Manager being observed.
+	def handle_system_event( event_type, event )
+		self.log.debug "Got a %s event from the Manager: %p" % [ event_type, event ]
+
+		case event_type
+		when 'sys.heartbeat'
+			this_runid = event['run_id']
+			if @manager_last_runid && this_runid != @manager_last_runid
+				self.log.warn "Manager run ID changed: re-subscribing"
+				self.handler.reset
+				self.register_observers
+			end
+
+			@manager_last_runid = this_runid
+		when 'sys.node_added', 'sys.node_removed'
+			# no-op
+		else
+			# no-op
+		end
+	end
+
 end # class Arborist::ObserverRunner
 

data/spec/arborist/client_spec.rb

@@ -12,15 +12,15 @@ describe Arborist::Client do
 	describe "synchronous API", :testing_manager do
 
 		before( :each ) do
-			@manager = make_testing_manager()
 			@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.running? || count > 30
+			until (@manager && @manager.running?) || count > 30
 				sleep 0.1
 				count += 1
 			end
@@ -28,7 +28,7 @@ describe Arborist::Client do
 		end
 
 		after( :each ) do
-			@manager.stop
+			@manager.simulate_signal( :TERM )
 			@manager_thread.join
 
 			count = 0

data/spec/arborist/manager/event_publisher_spec.rb

@@ -60,7 +60,6 @@ describe Arborist::Manager::EventPublisher do
 		publisher.on_writable
 	end
 
-
 end
 
 

data/spec/arborist/manager/tree_api_spec.rb

@@ -6,23 +6,24 @@ require_relative '../../spec_helper'
 describe Arborist::Manager::TreeAPI, :testing_manager do
 
 	before( :each ) do
-		@manager = make_testing_manager()
+		@manager = nil
 		@manager_thread = Thread.new do
+			@manager = make_testing_manager()
 			Thread.current.abort_on_exception = true
-			manager.run
+			@manager.run
 			Loggability[ Arborist ].info "Stopped the test manager"
 		end
 
 		count = 0
-		until manager.running? || count > 30
+		until (@manager && @manager.running?) || count > 30
 			sleep 0.1
 			count += 1
 		end
-		raise "Manager didn't start up" unless manager.running?
+		raise "Manager didn't start up" unless @manager.running?
 	end
 
 	after( :each ) do
-		@manager.stop
+		@manager.simulate_signal( :TERM )
 		unless @manager_thread.join( 5 )
 			$stderr.puts "Manager thread didn't exit on its own; killing it."
 			@manager_thread.kill

data/spec/arborist/manager_spec.rb

@@ -164,30 +164,32 @@ describe Arborist::Manager do
 
 
 		it "checkpoints the state file periodically if an interval is configured" do
-			described_class.configure( manager: {checkpoint_frequency: 20, state_file: 'arb.tree'} )
+			described_class.configure( manager: {checkpoint_frequency: 20_000, state_file: 'arb.tree'} )
 
+			zloop = instance_double( ZMQ::Loop, register: nil, :verbose= => nil )
 			timer = instance_double( ZMQ::Timer, "checkpoint timer" )
-			expect( ZMQ::Timer ).to receive( :new ).with( 20, 0 ).and_return( timer )
+			expect( ZMQ::Loop ).to receive( :new ).and_return( zloop )
+			allow( ZMQ::Timer ).to receive( :new ).and_call_original
+			expect( ZMQ::Timer ).to receive( :new ).with( 20.0, 0 ).and_return( timer )
 
-			expect( manager.start_state_checkpointing ).to eq( timer )
+			manager = described_class.new
+			expect( manager.checkpoint_timer ).to eq( timer )
 		end
 
 
 		it "doesn't checkpoint if no interval is configured" do
 			described_class.configure( manager: {checkpoint_frequency: nil, state_file: 'arb.tree'} )
 
-			expect( ZMQ::Timer ).to_not receive( :new )
-
-			expect( manager.start_state_checkpointing ).to be_nil
+			manager = described_class.new
+			expect( manager.checkpoint_timer ).to be_nil
 		end
 
 
 		it "doesn't checkpoint if no state file is configured" do
 			described_class.configure( manager: {checkpoint_frequency: 20, state_file: nil} )
 
-			expect( ZMQ::Timer ).to_not receive( :new )
-
-			expect( manager.start_state_checkpointing ).to be_nil
+			manager = described_class.new
+			expect( manager.checkpoint_timer ).to be_nil
 		end
 
 
@@ -197,6 +199,20 @@ describe Arborist::Manager do
 	end
 
 
+	context "heartbeat event" do
+
+		it "errors if configured with a heartbeat of 0" do
+			expect {
+				described_class.configure( manager: {heartbeat_frequency: 0} )
+			}.to raise_error( Arborist::ConfigError, /positive non-zero/i )
+		end
+
+
+		it "is sent at the configured "
+
+	end
+
+
 	context "a new empty manager" do
 
 		let( :node ) do
@@ -583,12 +599,14 @@ describe Arborist::Manager do
 		let( :event_pollitem ) { instance_double(ZMQ::Pollitem, "event API pollitem") }
 		let( :signal_timer ) { instance_double(ZMQ::Timer, "signal timer") }
 
+
 		before( :each ) do
 			allow( ZMQ::Loop ).to receive( :new ).and_return( zmq_loop )
 
 			allow( zmq_context ).to receive( :socket ).with( :REP ).and_return( tree_sock )
 			allow( zmq_context ).to receive( :socket ).with( :PUB ).and_return( event_sock )
 
+			allow( zmq_loop ).to receive( :verbose= )
 			allow( zmq_loop ).to receive( :remove ).with( tree_pollitem )
 			allow( zmq_loop ).to receive( :remove ).with( event_pollitem )
 
@@ -596,41 +614,52 @@ describe Arborist::Manager do
 			allow( tree_sock ).to receive( :close )
 			allow( event_pollitem ).to receive( :pollable ).and_return( event_sock )
 			allow( event_sock ).to receive( :close )
-		end
-
 
-		it "sets up its sockets with handlers and starts the ZMQ loop when started" do
-			expect( tree_sock ).to receive( :bind ).with( Arborist.tree_api_url )
-			expect( tree_sock ).to receive( :linger= ).with( 0 )
+			allow( tree_sock ).to receive( :bind ).with( Arborist.tree_api_url )
+			allow( tree_sock ).to receive( :linger= )
 
-			expect( event_sock ).to receive( :bind ).with( Arborist.event_api_url )
-			expect( event_sock ).to receive( :linger= ).with( 0 )
+			allow( event_sock ).to receive( :bind ).with( Arborist.event_api_url )
+			allow( event_sock ).to receive( :linger= )
 
-			expect( ZMQ::Pollitem ).to receive( :new ).with( tree_sock, ZMQ::POLLIN|ZMQ::POLLOUT ).
+			allow( ZMQ::Pollitem ).to receive( :new ).with( tree_sock, ZMQ::POLLIN|ZMQ::POLLOUT ).
 				and_return( tree_pollitem )
-			expect( ZMQ::Pollitem ).to receive( :new ).with( event_sock, ZMQ::POLLOUT ).
+			allow( ZMQ::Pollitem ).to receive( :new ).with( event_sock, ZMQ::POLLOUT ).
 				and_return( event_pollitem )
 
-			expect( tree_pollitem ).to receive( :handler= ).
+			allow( tree_pollitem ).to receive( :handler= ).
 				with( an_instance_of(Arborist::Manager::TreeAPI) )
-			expect( zmq_loop ).to receive( :register ).with( tree_pollitem )
-			expect( event_pollitem ).to receive( :handler= ).
+			allow( zmq_loop ).to receive( :register ).with( tree_pollitem )
+			allow( event_pollitem ).to receive( :handler= ).
 				with( an_instance_of(Arborist::Manager::EventPublisher) )
-			expect( zmq_loop ).to receive( :register ).with( event_pollitem )
+			allow( zmq_loop ).to receive( :register ).with( event_pollitem )
+		end
+
 
+		it "starts handling signals and events when started" do
 			expect( ZMQ::Timer ).to receive( :new ).
 				with( described_class::SIGNAL_INTERVAL, 0, manager.method(:process_signal_queue) ).
 				and_return( signal_timer )
 			expect( zmq_loop ).to receive( :register_timer ).with( signal_timer )
+			expect( zmq_loop ).to receive( :register_timer ).with( manager.heartbeat_timer )
 			expect( zmq_loop ).to receive( :start )
 
 			expect( zmq_loop ).to receive( :remove ).with( tree_pollitem )
 			expect( zmq_loop ).to receive( :remove ).with( event_pollitem )
 
 			manager.run
-		end
-	end
 
+			expect( manager.event_publisher.event_queue.length ).to eq( 1 )
+
+			event = manager.event_publisher.event_queue.first
+			expect( event.first ).to eq( 'sys.startup' )
+
+			payload = unpack_message( event.last )
+			expect( payload ).to include(
+				'start_time' => an_instance_of(String),
+				'version' => an_instance_of(String)
+			)
+		end
 
+	end
 end
 

data/spec/arborist/node/resource_spec.rb

@@ -19,6 +19,10 @@ describe Arborist::Node::Resource do
 		expect( result.identifier ).to eq( "testhost-disk" )
 	end
 
+	it "defaults the category to the identifier" do
+		result = described_class.new( 'load', host )
+		expect( result.category ).to eq( 'load' )
+	end
 
 	it "raises a sensible error when created without a host" do
 		expect {
@@ -51,6 +55,11 @@ describe Arborist::Node::Resource do
 			expect( node ).to_not match_criteria( address: '192.168.66.64/27' )
 			expect( node ).to_not match_criteria( address: '127.0.0.0/8' )
 		end
+
+		it "can be matched with a category" do
+			expect( node ).to match_criteria( category: 'disk' )
+			expect( node ).to_not match_criteria( category: 'processes' )
+		end
 	end
 end
 

data/spec/arborist/node/service_spec.rb

@@ -122,12 +122,27 @@ describe Arborist::Node::Service do
 		end
 
 
-		it "can be matched with one of its host's addresses" do
+		it "inherits its host's addresses" do
 			expect( node ).to match_criteria( address: '192.168.66.12' )
 			expect( node ).to_not match_criteria( address: '127.0.0.1' )
 		end
 
 
+		it "can be limited to a subset of its host's addresses" do
+			node.address( host.addresses.first )
+			expect( node ).to match_criteria( address: '192.168.66.12' )
+			expect( node ).to_not match_criteria( address: '10.1.33.8' )
+			expect( node ).to_not match_criteria( address: '127.0.0.1' )
+		end
+
+
+		it "errors if it specifies an address other than one of its host's addresses" do
+			expect {
+				node.address( '127.0.0.1' )
+			}.to raise_error( Arborist::ConfigError, /127.0.0.1 is not one of testhost's addresses/i )
+		end
+
+
 		it "can be matched with a netblock that includes one of its host's addresses" do
 			expect( node ).to match_criteria( address: '192.168.66.0/24' )
 			expect( node ).to match_criteria( address: '10.0.0.0/8' )

data/spec/arborist/node_spec.rb

@@ -356,6 +356,8 @@ describe Arborist::Node do
 						any_of('webproxy', on: ['fe-host1','fe-host2','fe-host3'])
 					)
 
+					config os: 'freebsd-10'
+
 					update( 'song' => 'Around the World', 'artist' => 'Daft Punk', 'length' => '7:09' )
 				end
 			end
@@ -400,6 +402,7 @@ describe Arborist::Node do
 
 				old_node.instance_variable_set( :@parent, 'foo' )
 				old_node.instance_variable_set( :@description, 'Some older description' )
+				old_node.instance_variable_set( :@config, {'os' => 'freebsd-8'} )
 				old_node.tags( :bunker, :lucky, :tickle, :trucker )
 				old_node.source = '/somewhere/else'
 
@@ -410,6 +413,7 @@ describe Arborist::Node do
 				expect( node.tags ).to eq( node_copy.tags )
 				expect( node.source ).to eq( node_copy.source )
 				expect( node.dependencies ).to eq( node_copy.dependencies )
+				expect( node.config ).to eq( node_copy.config )
 			end
 
 
@@ -465,26 +469,25 @@ describe Arborist::Node do
 			end
 
 
-			it "an ACKed node goes back to ACKed when re-added to the tree" do
+			it "can be marshalled" do
+				data = Marshal.dump( node )
+				cloned_node = Marshal.load( data )
+
+				expect( cloned_node ).to eq( node )
+			end
+
 
+			it "an ACKed node stays ACKed when serialized and restored" do
 				node.update( error: "there's a fire" )
 				node.update( ack: {
 					message: 'We know about the fire. It rages on.',
 					sender: '1986 Labyrinth David Bowie'
 				})
-				cloned_node = concrete_class.from_hash( node.to_h )
-				node_added_event = Arborist::Event.create( :sys_node_added, cloned_node )
-				cloned_node.handle_event( node_added_event )
-
-				expect( cloned_node ).to be_acked
-			end
-
+				expect( node ).to be_acked
 
-			it "can be marshalled" do
-				data = Marshal.dump( node )
-				cloned_node = Marshal.load( data )
+				restored_node = Marshal.load( Marshal.dump(node) )
 
-				expect( cloned_node ).to eq( node )
+				expect( restored_node ).to be_acked
 			end
 
 
@@ -639,6 +642,7 @@ describe Arborist::Node do
 				parent 'bar'
 				description "The prototypical node"
 				tags :chunker, :hunky, :flippin, :hippo
+				config os: 'freebsd-10'
 
 				update(
 					'song' => 'Around the World',
@@ -692,6 +696,12 @@ describe Arborist::Node do
 		end
 
 
+		it "can be matched with config values" do
+			expect( node ).to match_criteria( config: {os: 'freebsd-10'} )
+			expect( node ).to_not match_criteria( config: {os: 'macosx-10.11.3'} )
+		end
+
+
 		it "can be matched with its user properties" do
 			expect( node ).to match_criteria( song: 'Around the World' )
 			expect( node ).to match_criteria( artist: 'Daft Punk' )