arborist 0.0.1.pre20160106113421

data/spec/arborist/monitor/socket_spec.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../spec_helper'
+
+require 'arborist'
+require 'arborist/node/host'
+require 'arborist/node/service'
+require 'arborist/monitor/socket'
+
+
+describe Arborist::Monitor::Socket do
+
+	describe 'TCP' do
+
+		let( :described_class ) { Arborist::Monitor::Socket::TCP }
+
+		let( :host_node ) do
+			Arborist::Node.create( 'host', 'test' ) do
+				description "Test host node with a few TCP services"
+				address '192.168.26.1'
+
+				tags :testing
+			end
+		end
+
+		let( :default_timeout ) { described_class::DEFAULT_OPTIONS[:timeout] }
+
+		let( :www_service_node ) { host_node.service('www') }
+		let( :ssh_service_node ) { host_node.service('ssh') }
+		let( :nat_pmp_service_node ) { host_node.service('nat-pmp', port: 5351) }
+
+		let( :service_nodes ) {[ www_service_node, ssh_service_node, nat_pmp_service_node ]}
+		let( :service_nodes_hash ) do
+			service_nodes.each_with_object({}) do |node, accum|
+				accum[ node.identifier ] = node.fetch_values
+			end
+		end
+
+
+		# it_behaves_like "an Arborist Monitor"
+
+
+		def sockaddr_for( node )
+			return Socket.sockaddr_in( node.port, node.addresses.first.to_s )
+		end
+
+
+		def make_successful_mock_socket( node )
+			address = Addrinfo.tcp( node.addresses.first.to_s, node.port )
+			socket = instance_double( Socket, "#{node.identifier} socket", remote_address: address )
+			errors = [ IO::EINPROGRESSWaitWritable, Errno::EISCONN ]
+
+			expect( socket ).to receive( :connect_nonblock ) do |addr|
+				expect( addr ).to eq( sockaddr_for(node) )
+				raise errors.shift
+			end.at_least( :once )
+
+			return socket
+		end
+
+
+		def make_initial_error_mock_socket( node, error_class, message )
+			address = Addrinfo.tcp( node.addresses.first.to_s, node.port )
+			socket = instance_double( Socket, "#{node.identifier} socket", remote_address: address )
+
+			expect( socket ).to receive( :connect_nonblock ).
+				with( sockaddr_for(node) ).
+				and_raise( error_class.new(message) )
+
+			return socket
+		end
+
+
+		def make_wait_error_mock_socket( node, error_class, message )
+			address = Addrinfo.tcp( node.addresses.first.to_s, node.port )
+			socket = instance_double( Socket, "#{node.identifier} socket", remote_address: address )
+			errors = [ IO::EINPROGRESSWaitWritable, error_class.new(message) ]
+
+			expect( socket ).to receive( :connect_nonblock ) do |addr|
+				expect( addr ).to eq( sockaddr_for(node) )
+				raise errors.shift
+			end.at_least( :once )
+
+			return socket
+		end
+
+
+		it "opens TCP connections to the ports of the nodes" do
+			fake_sockets = service_nodes.map do |node|
+				make_successful_mock_socket( node )
+			end
+
+			expect( Socket ).to receive( :new ).and_return( *fake_sockets )
+			expect( IO ).to receive( :select ).
+				with( nil, fake_sockets, nil, kind_of(Numeric) ).
+				and_return( [nil, fake_sockets, nil] )
+
+			expect( fake_sockets ).to all( receive( :close ) )
+
+			result = described_class.run( service_nodes_hash )
+
+			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)
+			) )
+			expect( result.map {|_, res| res[:tcp_socket_connect][:time]} ).to all( be_a(String) )
+		end
+
+
+		it "updates nodes with an error on a SocketError" do
+			socket = make_initial_error_mock_socket( www_service_node, SocketError,
+				"getaddrinfo: nodename nor servname provided, or not known" )
+			allow( Socket ).to receive( :new ).and_return( socket )
+
+			result = described_class.run( 'test-www' => www_service_node.fetch_values )
+
+			expect( result ).to be_a( Hash )
+			expect( result ).to include( 'test-www' )
+			expect(
+				result['test-www']
+			).to include( error: 'getaddrinfo: nodename nor servname provided, or not known' )
+		end
+
+
+		it "updates nodes with an error if the connection times out" do
+			socket = make_successful_mock_socket( www_service_node )
+			allow( Socket ).to receive( :new ).and_return( socket )
+			allow( socket ).to receive( :close )
+			allow( IO ).to receive( :select ) do
+				sleep 0.2
+				[nil, nil, nil]
+			end
+
+			result = described_class.new( timeout: 0.1 ).
+				run( 'test-www' => www_service_node.fetch_values )
+
+			expect( result ).to be_a( Hash )
+			expect( result ).to include( 'test-www' )
+			expect( result['test-www'] ).to include( error: 'Timeout after 0.100s' )
+		end
+
+
+		it "updates nodes with an error on a 'connection refused' error" do
+			socket = make_initial_error_mock_socket( www_service_node, Errno::ECONNREFUSED,
+				"the message" )
+			allow( Socket ).to receive( :new ).and_return( socket )
+
+			result = described_class.run( 'test-www' => www_service_node.fetch_values )
+
+			expect( result ).to be_a( Hash )
+			expect( result ).to include( 'test-www' )
+			expect( result['test-www'] ).to include( error: 'Connection refused - the message' )
+		end
+
+
+		it "updates nodes with an error on a 'host unreachable' error" do
+			socket = make_initial_error_mock_socket( www_service_node, Errno::EHOSTUNREACH,
+				"the message" )
+			allow( Socket ).to receive( :new ).and_return( socket )
+
+			result = described_class.run( 'test-www' => www_service_node.fetch_values )
+
+			expect( result ).to be_a( Hash )
+			expect( result ).to include( 'test-www' )
+			expect( result['test-www'] ).to include( error: 'No route to host - the message' )
+		end
+
+
+		it "updates nodes with an error on a 'getpeername' error" do
+			socket = make_wait_error_mock_socket( www_service_node, Errno::EINVAL, "getpeername(2)" )
+			allow( Socket ).to receive( :new ).and_return( socket )
+			allow( IO ).to receive( :select ).
+				with( nil, [socket], nil, kind_of(Numeric) ).
+				and_return( [nil, [socket], nil] )
+			allow( socket ).to receive( :close )
+
+			result = described_class.run( 'test-www' => www_service_node.fetch_values )
+
+			expect( result ).to be_a( Hash )
+			expect( result ).to include( 'test-www' )
+			expect( result['test-www'] ).to include( error: 'Invalid argument - getpeername(2)' )
+		end
+
+
+		it "can be instantiated to run with a different timeout" do
+			mon = described_class.new.with_timeout( 30 )
+			expect( mon.timeout ).to eq( 30 )
+		end
+
+	end
+
+end
+
+

data/spec/arborist/monitor_runner_spec.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'arborist/monitor_runner'
+
+
+describe Arborist::MonitorRunner do
+
+	let( :zmq_loop ) { instance_double(ZMQ::Loop) }
+	let( :req_socket ) { instance_double(ZMQ::Socket::Req) }
+	let( :pollitem ) { instance_double(ZMQ::Pollitem) }
+
+	let( :runner ) do
+		obj = described_class.new
+		obj.reactor = zmq_loop
+		obj
+	end
+
+	let( :monitor_class ) { Class.new(Arborist::Monitor) }
+
+	let( :mon1 ) { monitor_class.new("testing monitor1") }
+	let( :mon2 ) { monitor_class.new("testing monitor2") { splay 10 } }
+	let( :mon3 ) { monitor_class.new("testing monitor3") }
+	let( :monitors ) {[ mon1, mon2, mon3 ]}
+
+
+	it "can load monitors from an enumerator that yields Arborist::Monitors" do
+		runner.load_monitors([ mon1, mon2, mon3 ])
+		expect( runner.monitors ).to include( mon1, mon2, mon3 )
+	end
+
+
+	describe "a runner with loaded monitors" do
+
+		before( :each ) do
+			allow( zmq_loop ).to receive( :register ).with( an_instance_of(ZMQ::Pollitem) )
+		end
+
+
+		it "registers its monitors to run on an interval and starts the ZMQ loop when run" do
+			runner.monitors.replace([ mon1 ])
+
+			interval_timer = instance_double( ZMQ::Timer )
+			expect( ZMQ::Timer ).to receive( :new ) do |i_delay, i_repeat, &i_block|
+				expect( i_delay ).to eq( mon1.interval )
+				expect( i_repeat ).to eq( 0 )
+
+				expect( runner.handler ).to receive( :run_monitor ).with( mon1 )
+
+				i_block.call
+				interval_timer
+			end
+
+			expect( zmq_loop ).to receive( :register_timer ).with( interval_timer )
+			expect( zmq_loop ).to receive( :start )
+
+			runner.run
+		end
+
+
+		it "delays registration of its interval timer if a monitor has a splay" do
+			runner.monitors.replace([ mon2 ])
+
+			interval_timer = instance_double( ZMQ::Timer )
+			expect( ZMQ::Timer ).to receive( :new ).with( mon2.interval, 0 ).
+				and_return( interval_timer )
+
+			timer = instance_double( ZMQ::Timer )
+			expect( ZMQ::Timer ).to receive( :new ) do |delay, repeat, &block|
+				expect( delay ).to be >= 0
+				expect( delay ).to be <= mon2.splay
+				expect( repeat ).to eq( 1 )
+
+				block.call
+				timer
+			end
+
+			expect( zmq_loop ).to receive( :register_timer ).with( interval_timer )
+			expect( zmq_loop ).to receive( :register_timer ).with( timer )
+			expect( zmq_loop ).to receive( :start )
+
+			runner.run
+		end
+
+	end
+
+
+	describe Arborist::MonitorRunner::Handler do
+
+		let( :tree_api_handler ) { Arborist::Manager::TreeAPI.new(:pollable, :manager) }
+
+		let( :handler ) { described_class.new( zmq_loop ) }
+
+		let( :node_tree ) {{
+			'router' => {
+				'addresses' => ['10.2.1.2', '1.2.3.4']
+			},
+			'server' => {
+				'addresses' => ['10.2.1.118']
+			}
+		}}
+		let( :ping_monitor_data ) {{
+			'router' => {'ping' => { 'rtt' => 22 }},
+			'server' => {'ping' => { 'rtt' => 8 }},
+		}}
+
+
+		it "can run a monitor using async ZMQ IO" do
+			expect( zmq_loop ).to receive( :register ).with( handler.pollitem )
+
+			# Queue up the monitor requests and register the socket as wanting to write
+			mon1.exec do |nodes|
+				ping_monitor_data
+			end
+			expect {
+				handler.run_monitor( mon1 )
+			}.to change { handler.registered? }.from( false ).to( true )
+
+			# Fetch
+			request = handler.client.make_fetch_request(
+				mon1.positive_criteria,
+				include_down: false,
+				properties: mon1.node_properties
+			)
+			response = tree_api_handler.successful_response( node_tree )
+
+			expect( handler.client.tree_api ).to receive( :send ).with( request )
+			expect( handler.client.tree_api ).to receive( :recv ).and_return( response )
+
+			expect {
+				handler.on_writable
+			}.to_not change { handler.registered? }
+
+			# Update
+			request = handler.client.make_update_request( ping_monitor_data )
+			response = tree_api_handler.successful_response( nil )
+			expect( handler.client.tree_api ).to receive( :send ).with( request )
+			expect( handler.client.tree_api ).to receive( :recv ).and_return( response )
+
+			# Unregister
+			expect( zmq_loop ).to receive( :remove ).with( handler.pollitem )
+			expect {
+				handler.on_writable
+			}.to change { handler.registered? }.from( true ).to( false )
+
+		end
+
+	end
+
+end
+

data/spec/arborist/monitor_spec.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'arborist/monitor'
+
+
+describe Arborist::Monitor do
+
+
+	let( :trunk_node ) do
+		testing_node( 'trunk' ) do
+			properties['pork'] = 'nope'
+		end
+	end
+	let( :branch_node ) do
+		testing_node( 'branch', 'trunk' ) do
+			properties['pork'] = 'yes'
+		end
+	end
+	let( :leaf_node ) do
+		testing_node( 'leaf', 'branch' ) do
+			properties['pork'] = 'twice'
+		end
+	end
+
+
+	let( :testing_nodes ) {[ trunk_node, branch_node, leaf_node ]}
+
+
+	it "can be created with just a description" do
+		mon = described_class.new( "the description" )
+		expect( mon ).to be_a( described_class )
+		expect( mon.description ).to eq( "the description" )
+		expect( mon.include_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
+		expect( mon.negative_criteria ).to be_empty
+		expect( mon.node_properties ).to be_empty
+	end
+
+
+	it "yields itself to the provided block for the DSL" do
+		block_self = nil
+		mon = described_class.new( "testing monitor" ) do
+			block_self = self
+		end
+
+		expect( block_self ).to be( mon )
+	end
+
+
+	it "can specify an interval" do
+		mon = described_class.new( "testing monitor" ) do
+			every 30
+		end
+
+		expect( mon.interval ).to eq( 30 )
+	end
+
+
+	it "can specify a splay" do
+		mon = described_class.new( "testing monitor" ) do
+			splay 15
+		end
+
+		expect( mon.splay ).to eq( 15 )
+	end
+
+
+	it "can specify criteria for matching nodes to monitor" do
+		mon = described_class.new( "testing monitor" ) do
+			match type: 'host'
+		end
+
+		expect( mon.positive_criteria ).to include( type: 'host' )
+	end
+
+
+	it "can specify criteria for matching nodes not to monitor" do
+		mon = described_class.new( "testing monitor" ) do
+			exclude tag: 'laptop'
+		end
+
+		expect( mon.negative_criteria ).to include( tag: 'laptop' )
+	end
+
+
+	it "can specify that it will include hosts marked as 'down'" do
+		mon = described_class.new( "testing monitor" ) do
+			include_down true
+		end
+
+		expect( mon.include_down? ).to be_truthy
+	end
+
+
+	it "can specify one or more properties to include in the input to the monitor" do
+		mon = described_class.new( "testing monitor" ) do
+			use :address, :tags
+		end
+
+		expect( mon.node_properties ).to include( :address, :tags )
+	end
+
+
+	it "can specify a command to exec to do the monitor's work" do
+		mon = described_class.new( "the description" ) do
+			exec 'cat'
+		end
+
+		output = mon.run( testing_nodes )
+		expect( output ).to be_a( Hash )
+		expect( output ).to include( *(testing_nodes.map(&:identifier)) )
+	end
+
+
+	it "can specify a block to call to do the monitor's work" do
+		block_was_run = false
+
+		mon = described_class.new( "the description" )
+		mon.exec do |nodes|
+			block_was_run = true
+		end
+
+		mon.run( testing_nodes )
+
+		expect( block_was_run ).to be_truthy
+	end
+
+
+	it "can specify a runnable object to do the monitor's work" do
+		mod = Module.new do
+			class << self; attr_accessor :was_run ; end
+			@was_run = false
+
+			def self::run( nodes )
+				self.was_run = true
+			end
+		end
+
+
+		mon = described_class.new( "the description" )
+		mon.exec( mod )
+
+		mon.run( testing_nodes )
+
+		expect( mod.was_run ).to be_truthy
+	end
+
+
+	it "can provide a function for building arguments for its command" do
+		mon = described_class.new( "the description" ) do
+
+			exec 'the_command'
+
+			handle_results {|*| }
+			exec_input {|*| }
+			exec_arguments do |nodes|
+				Loggability[ Arborist ].debug "In the argument-builder."
+				nodes.map {|n| n.identifier }
+			end
+		end
+
+		expect( Process ).to receive( :spawn ) do |*args|
+			options = args.pop
+
+			expect( args ).to eq([ 'the_command', 'trunk', 'branch', 'leaf' ])
+			expect( options ).to be_a( Hash )
+			expect( options ).to include( :in, :out, :err )
+
+			nil
+		end
+
+		mon.run( testing_nodes )
+	end
+
+
+	it "can provide a function for providing input to its command" do
+		mon = described_class.new( "the description" ) do
+
+			exec 'cat'
+
+			exec_input do |nodes, writer|
+				writer.puts( nodes.map(&:identifier) )
+			end
+			handle_results do |pid, out, err|
+				return out.readlines.map( &:chomp )
+			end
+		end
+
+		results = mon.run( testing_nodes )
+
+		expect( results ).to eq( testing_nodes.map(&:identifier) )
+	end
+
+
+	it "can provide a function for parsing its command's output" do
+		mon = described_class.new( "the description" ) do
+
+			exec 'cat'
+
+			exec_arguments {|*| }
+			exec_input do |nodes, writer|
+				writer.puts( nodes.map(&:identifier) )
+			end
+			handle_results do |pid, out, err|
+				out.readlines.map( &:chomp ).map( &:upcase )
+			end
+		end
+
+		results = mon.run( testing_nodes )
+
+		expect( results ).to eq( testing_nodes.map(&:identifier).map(&:upcase) )
+	end
+
+
+	it "can provide a Module that implements its exec callbacks" do
+		the_module = Module.new do
+
+			def exec_input( nodes, writer )
+				writer.puts( nodes.map {|n| n.identifier } )
+			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" ) do
+			exec 'cat'
+			exec_callbacks( the_module )
+		end
+
+		results = mon.run( testing_nodes )
+
+		expect( results ).to be_a( Hash )
+		expect( results.size ).to eq( 3 )
+		expect( results ).to include( *testing_nodes.map(&:identifier) )
+		expect( results['trunk'] ).to eq({ echoed: 'yep' })
+		expect( results['branch'] ).to eq({ echoed: 'yep' })
+		expect( results['leaf'] ).to eq({ echoed: 'yep' })
+	end
+
+end
+