arborist 0.2.0.pre20170519125456 → 0.2.0

data/spec/arborist/mixins_spec.rb

@@ -82,6 +82,7 @@ describe Arborist, "mixins" do
 			expect( extended_class ).to respond_to( :foo? )
 		end
 
+
 		it "can declare a class-level predicate method" do
 			extended_class.singleton_predicate_reader :foo
 			expect( extended_class ).to_not respond_to( :foo )
@@ -89,6 +90,24 @@ describe Arborist, "mixins" do
 			expect( extended_class ).to respond_to( :foo? )
 		end
 
+
+		it "can declare an instance DSLish accessor" do
+			extended_class.dsl_accessor( :foo )
+			instance = extended_class.new
+
+			instance.foo( 13 )
+			expect( instance.foo ).to eq( 13 )
+		end
+
+
+		it "the instance DSLish accessor works with a `false` argument" do
+			extended_class.dsl_accessor( :foo )
+			instance = extended_class.new
+
+			instance.foo( false )
+			expect( instance.foo ).to equal( false )
+		end
+
 	end
 
 

data/spec/arborist/monitor/socket_spec.rb

@@ -102,9 +102,8 @@ describe Arborist::Monitor::Socket do
 			expect( result ).to be_a( Hash )
 			expect( result ).to include( *service_nodes.map(&:identifier) )
 			expect( result.values ).to all( include(
-				tcp_socket_connect: a_hash_including(:time, :duration)
+				tcp_socket_connect: a_hash_including(:duration)
 			) )
-			expect( result.map {|_, res| res[:tcp_socket_connect][:time]} ).to all( be_a(String) )
 		end
 
 

data/spec/arborist/monitor_runner_spec.rb

@@ -3,7 +3,7 @@
 require_relative '../spec_helper'
 
 require 'arborist/monitor_runner'
-
+require 'arborist/node/root'
 
 describe Arborist::MonitorRunner do
 
@@ -35,8 +35,11 @@ describe Arborist::MonitorRunner do
 
 	before( :each ) do
 		allow( CZTop::Reactor ).to receive( :new ).and_return( reactor )
+		allow( Thread ).to receive( :new ).and_yield
 		allow( reactor ).to receive( :register )
 		allow( reactor ).to receive( :unregister )
+		allow( reactor ).to receive( :add_periodic_timer ).
+			with( described_class::THREAD_CLEANUP_INTERVAL )
 	end
 
 
@@ -72,36 +75,39 @@ describe Arborist::MonitorRunner do
 
 		it "can run a monitor using async ZMQ IO" do
 
-			# Queue up the monitor requests and register the socket as wanting to write
+			# Set up the monitor's execution block with fixtured data
 			mon1.exec do |nodes|
 				ping_monitor_data
 			end
 
-			# Fetch
-			request = runner.client.make_fetch_request(
-				mon1.positive_criteria,
-				include_down: false,
-				properties: mon1.node_properties
-			)
-			response = Arborist::TreeAPI.successful_response( node_tree )
+			expect( reactor ).to receive( :event_enabled? ).with( runner.client.tree_api, :write ).
+				at_least( :once ).
+				and_return( true )
+
 
-			expect( runner.client.tree_api ).to receive( :send ).with( request )
-			expect( runner.client.tree_api ).to receive( :recv ).and_return( response )
+			search_request = instance_double( CZTop::Message )
+			search_response = Arborist::TreeAPI.successful_response( node_tree )
+			update_request = instance_double( CZTop::Message )
+			update_response = Arborist::TreeAPI.successful_response( nil )
 
-			runner.reactor.poll_once
+			expect( CZTop::Message ).to receive( :new ).and_return( search_request, update_request )
+			expect( search_request ).to receive( :send_to ).with( runner.client.tree_api )
+			expect( update_request ).to receive( :send_to ).with( runner.client.tree_api )
+			expect( CZTop::Message ).to receive( :receive_from ).with( runner.client.tree_api ).
+				and_return( search_response, update_response )
+			expect( reactor ).to receive( :disable_events ).with( runner.client.tree_api, :write )
 
-			# Update
-			request = runner.client.make_update_request( ping_monitor_data )
-			response = Arborist::TreeAPI.successful_response( nil )
-			expect( runner.client.tree_api ).to receive( :send ).with( request )
-			expect( runner.client.tree_api ).to receive( :recv ).and_return( response )
+			runner.run_monitor( mon1 )
 
-			# Unregister
-			expect( zmq_loop ).to receive( :remove ).with( runner.pollitem )
-			expect {
-				runner.on_writable
-			}.to change { runner.registered? }.from( true ).to( false )
+			# trigger the search request
+			search_event = instance_double( CZTop::Reactor::Event,
+				writable?: true, socket: runner.client.tree_api )
+			runner.handle_io_event( search_event )
 
+			# trigger the update request
+			update_event = instance_double( CZTop::Reactor::Event,
+				writable?: true, socket: runner.client.tree_api )
+			runner.handle_io_event( update_event )
 		end
 
 
@@ -117,25 +123,71 @@ describe Arborist::MonitorRunner do
 			nodes = { 'test1' => {}, 'test2' => {} }
 			monitor_results = { 'test1' => {ping: {rtt: 1}}, 'test2' => {ping: {rtt: 8}} }
 
-			expect( runner ).to receive( :fetch ).
+			expect( runner ).to receive( :search ).
 				with( {type: 'host'}, false, [:addresses], {} ).
 				and_yield( nodes )
 
 			expect( monitor ).to receive( :run ).with( nodes ).
 				and_return( monitor_results )
 
-			expect( runner ).to receive( :update ).
-				with({
-					"test1"=>{:ping=>{:rtt=>1}, "_monitor_key"=>:test},
-					"test2"=>{:ping=>{:rtt=>8}, "_monitor_key"=>:test}
-				})
+			expect( runner ).to receive( :update ).with(
+				{
+					"test1"=>{:ping=>{:rtt=>1}},
+					"test2"=>{:ping=>{:rtt=>8}}
+				},
+				:test
+			)
 
 			runner.run_monitor( monitor )
 		end
 
-	end
 
+		it "sets an error condition if the monitor raises an exception" do
+			monitor = Arborist::Monitor.new do
+				description 'test monitor'
+				key :test
+				every 20
+				match type: 'host'
+				use :addresses
+				exec do |nodes|
+					raise "boom!"
+				end
+			end
+			nodes = { 'test' => {} }
+
+			expect( runner ).to receive( :search ).
+				with( {type: 'host'}, false, [:addresses], {} ).
+				and_yield( nodes )
 
+			expect( runner ).to receive( :update ).with(
+				{"test" => {error: 'Exception while running "test monitor" monitor: RuntimeError: boom!'}},
+				:test
+			)
+
+			runner.run_monitor( monitor )
+		end
 
+
+		it "skips the monitor execution if no nodes were returned in the search" do
+			monitor = Arborist::Monitor.new do
+				description 'test monitor'
+				key :test
+				every 20
+				match type: 'host'
+				use :addresses
+				exec 'fping', '-e', '-t', '150'
+			end
+			nodes = {}
+
+			expect( runner ).to receive( :search ).
+				with( {type: 'host'}, false, [:addresses], {} ).
+				and_yield( nodes )
+
+			expect( runner ).to_not receive( :update )
+			runner.run_monitor( monitor )
+		end
+
+
+	end
 end
 

data/spec/arborist/monitor_spec.rb

@@ -20,6 +20,7 @@ describe Arborist::Monitor do
 	end
 	let( :leaf_node ) do
 		testing_node( 'leaf', 'branch' ) do
+			tags :one, :two
 			properties['pork'] = 'twice'
 		end
 	end
@@ -37,7 +38,7 @@ describe Arborist::Monitor do
 		expect( mon ).to be_a( described_class )
 		expect( mon.description ).to eq( "the description" )
 		expect( mon.key ).to eq( :key )
-		expect( mon.include_down? ).to be_falsey
+		expect( mon.exclude_down? ).to be_falsey
 		expect( mon.interval ).to eq( Arborist::Monitor::DEFAULT_INTERVAL )
 		expect( mon.splay ).to eq( 0 )
 		expect( mon.positive_criteria ).to be_empty
@@ -55,7 +56,7 @@ describe Arborist::Monitor do
 		expect( mon ).to be_a( described_class )
 		expect( mon.description ).to eq( "the description" )
 		expect( mon.key ).to eq( :key )
-		expect( mon.include_down? ).to be_falsey
+		expect( mon.exclude_down? ).to be_falsey
 		expect( mon.interval ).to eq( Arborist::Monitor::DEFAULT_INTERVAL )
 		expect( mon.splay ).to eq( 0 )
 		expect( mon.positive_criteria ).to be_empty
@@ -72,7 +73,7 @@ describe Arborist::Monitor do
 		expect( mon ).to be_a( described_class )
 		expect( mon.description ).to eq( "the description" )
 		expect( mon.key ).to eq( :key )
-		expect( mon.include_down? ).to be_falsey
+		expect( mon.exclude_down? ).to be_falsey
 		expect( mon.interval ).to eq( Arborist::Monitor::DEFAULT_INTERVAL )
 		expect( mon.splay ).to eq( 0 )
 		expect( mon.positive_criteria ).to be_empty
@@ -87,7 +88,7 @@ describe Arborist::Monitor do
 		expect( mon ).to be_a( described_class )
 		expect( mon.description ).to eq( "the description" )
 		expect( mon.key ).to eq( :the_key )
-		expect( mon.include_down? ).to be_falsey
+		expect( mon.exclude_down? ).to be_falsey
 		expect( mon.interval ).to eq( Arborist::Monitor::DEFAULT_INTERVAL )
 		expect( mon.splay ).to eq( 0 )
 		expect( mon.positive_criteria ).to be_empty
@@ -96,12 +97,12 @@ describe Arborist::Monitor do
 	end
 
 
-	it "raises a ConfigError if constructed without a description" do
-		expect {
-			described_class.new do
-				key :key
-			end
-		}.to raise_error( Arborist::ConfigError, /no description/i )
+	it "uses a default description if constructed without one" do
+		mon = described_class.new do
+			key :key
+		end
+
+		expect( mon.description ).to_not be_empty
 	end
 
 
@@ -163,16 +164,16 @@ describe Arborist::Monitor do
 			match status: 'down'
 		end
 
-		expect( mon.include_down? ).to be_truthy
+		expect( mon.exclude_down? ).to be_falsey
 	end
 
 
-	it "can specify that it will include hosts marked as 'down'" do
+	it "can specify that it will exclude hosts marked as 'down'" do
 		mon = described_class.new( "testing monitor", :testing ) do
-			include_down true
+			exclude_down true
 		end
 
-		expect( mon.include_down? ).to be_truthy
+		expect( mon.exclude_down? ).to be_truthy
 	end
 
 
@@ -230,6 +231,27 @@ describe Arborist::Monitor do
 	end
 
 
+	it "uses node properties specified by the runnable object if it provides them" do
+		mod = Module.new do
+			class << self; attr_accessor :was_run ; end
+			@was_run = false
+
+			def self::run( nodes )
+				self.was_run = true
+			end
+
+			def self::node_properties
+				%i[ uri http_method body mimetype ]
+			end
+		end
+
+		mon = described_class.new( "the description", :testing )
+		mon.exec( mod )
+
+		expect( mon.node_properties ).to include( :uri, :http_method, :body, :mimetype )
+	end
+
+
 	it "can provide a function for building arguments for its command" do
 		mon = described_class.new( "the description", :testing ) do
 
@@ -257,6 +279,30 @@ describe Arborist::Monitor do
 	end
 
 
+	it "stringifies any Array properties with the default exec_input context" do
+		mon = described_class.new( "the description", :testing ) do
+			exec 'the_command'
+			handle_results {|*| }
+		end
+
+		child_stdin, parent_writer      = IO.pipe
+		parent_reader, child_stdout     = IO.pipe
+		parent_err_reader, child_stderr = IO.pipe
+
+		expect( IO ).to receive( :pipe ).and_return(
+			[ child_stdin, parent_writer ],
+			[ parent_reader, child_stdout ],
+			[ parent_err_reader, child_stderr ]
+		)
+
+		expect( parent_writer ).to receive( :puts ).with match( 'tags=one,two' )
+		expect( Process ).to receive( :spawn ).
+			with( 'the_command', out: child_stdout, in: child_stdin, err: child_stderr )
+
+		mon.run({ leaf: leaf_node.to_h })
+	end
+
+
 	it "handles system call errors while running the monitor command" do
 		mon = described_class.new( "the description", :testing ) do
 
@@ -350,5 +396,34 @@ describe Arborist::Monitor do
 		expect( results['leaf'] ).to eq({ echoed: 'yep' })
 	end
 
+
+	it "uses node properties specified by the exec_callbacks module if it provides them" do
+		the_module = Module.new do
+
+			def self::node_properties
+				%i[ uri http_method body mimetype ]
+			end
+
+			def exec_input( nodes, writer )
+				writer.puts( nodes.keys )
+			end
+
+			def handle_results( pid, out, err )
+				err.flush
+				return out.each_line.with_object({}) do |line, accum|
+					accum[ line.chomp ] = { echoed: 'yep' }
+				end
+			end
+
+		end
+
+		mon = described_class.new( "the description", :testing ) do
+			exec 'cat'
+			exec_callbacks( the_module )
+		end
+
+		expect( mon.node_properties ).to include( :uri, :http_method, :body, :mimetype )
+	end
+
 end
 

data/spec/arborist/node/host_spec.rb

@@ -81,6 +81,35 @@ describe Arborist::Node::Host do
 	end
 
 
+	it "can be created with a hostname attribute" do
+		result = described_class.new( 'testhost', hostname: 'example.com' )
+		expect( result.hostname ).to eq( 'example.com')
+	end
+
+
+	it "sets a hostname if unset, and the address was discovered via DNS" do
+		expect( TCPSocket ).to receive( :gethostbyname ).with( 'example.com' ).
+			and_return(['example.com', [], Socket::AF_INET, '1.1.1.1'])
+		result = described_class.new( 'testhost' ) do
+			address 'example.com'
+		end
+		expect( result.addresses ).to include( IPAddr.new('1.1.1.1') )
+		expect( result.hostname ).to eq( 'example.com')
+	end
+
+
+	it "leaves the hostname untouched if already set" do
+		expect( TCPSocket ).to receive( :gethostbyname ).with( 'example.com' ).
+			and_return(['example.com', [], Socket::AF_INET, '1.1.1.1'])
+		result = described_class.new( 'testhost' ) do
+			hostname 'www.example.com'
+			address 'example.com'
+		end
+		expect( result.addresses ).to include( IPAddr.new('1.1.1.1') )
+		expect( result.hostname ).to_not eq( 'example.com')
+	end
+
+
 	it "appends block address arguments to addresses in attributes" do
 		result = described_class.new( 'testhost', addresses: '192.168.118.3' ) do
 			address '127.0.0.1'
@@ -116,6 +145,16 @@ describe Arborist::Node::Host do
 	end
 
 
+	it "includes its hostname when turned into a Hash" do
+		node = described_class.new( 'testhost' ) do
+			hostname 'example.com'
+		end
+
+		expect( node.to_h ).to include( :hostname )
+		expect( node.to_h[:hostname] ).to eq( 'example.com' )
+	end
+
+
 	it "keeps its addresses when marshalled" do
 		node = described_class.new( 'testhost' ) do
 			address '192.168.118.3'
@@ -127,6 +166,16 @@ describe Arborist::Node::Host do
 	end
 
 
+	it "keeps its hostname when marshalled" do
+		node = described_class.new( 'testhost' ) do
+			hostname 'example.com'
+		end
+		clone = Marshal.load( Marshal.dump(node) )
+
+		expect( clone.hostname ).to eq( node.hostname )
+	end
+
+
 	it "is equal to another host node with the same metadata and addresses" do
 		node1 = described_class.new( 'testhost' ) do
 			address '192.168.118.3'
@@ -154,12 +203,26 @@ describe Arborist::Node::Host do
 	end
 
 
+	it "is not equal to another host node with differing hostnames" do
+		node1 = described_class.new( 'testhost' ) do
+			hostname 'example.com'
+		end
+		node2 = described_class.new( 'testhost' ) do
+			hostname 'pets.com'
+		end
+
+		expect( node1 ).to_not eq( node2 )
+	end
+
+
+
 	describe "matching" do
 
 		let( :node ) do
 			described_class.new( 'testhost' ) do
 				address '192.168.66.12'
 				address '10.2.12.68'
+				hostname 'example.com'
 			end
 		end
 
@@ -170,6 +233,11 @@ describe Arborist::Node::Host do
 		end
 
 
+		it "can be matched on its hostname" do
+			expect( node ).to match_criteria( hostname: 'example.com' )
+		end
+
+
 		it "can be matched with a netblock that includes one of its addresses" do
 			expect( node ).to match_criteria( address: '192.168.66.0/24' )
 			expect( node ).to match_criteria( address: '10.0.0.0/8' )