arborist 0.0.1.pre20160106113421

data/spec/arborist/observer_spec.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+describe Arborist::Observer do
+
+
+	it "can be created with just a description" do
+		observer = described_class.new( "the description" )
+		expect( observer ).to be_a( described_class )
+		expect( observer.description ).to eq( "the description" )
+	end
+
+
+	it "yields itself to the provided block for the DSL" do
+		block_self = nil
+		observer = described_class.new( "testing observer" ) do
+			block_self = self
+		end
+
+		expect( block_self ).to be( observer )
+	end
+
+
+	it "can specify a subscription for an event it's interested in" do
+		observer = described_class.new( "testing observer" ) do
+			subscribe to: 'node.delta'
+		end
+
+		expect( observer.subscriptions ).to be_an( Array )
+		expect( observer.subscriptions.length ).to eq( 1 )
+	end
+
+
+	it "can specify a subscription for more than one event it's interested in" do
+		observer = described_class.new( "testing observer" ) do
+			subscribe to: 'node.delta'
+			subscribe to: 'sys.reload'
+		end
+
+		expect( observer.subscriptions ).to be_an( Array )
+		expect( observer.subscriptions.length ).to eq( 2 )
+	end
+
+
+	it "can specify an action to run when a subscribed event is received" do
+		observer = described_class.new( "testing observer" ) do
+			action do |uuid, event|
+				puts( uuid )
+			end
+		end
+
+		expect( observer.actions ).to be_an( Array )
+		expect( observer.actions.length ).to eq( 1 )
+	end
+
+
+	it "can specify more than one action to run when a subscribed event is received" do
+		observer = described_class.new( "testing observer" ) do
+			action do |uuid, event|
+				puts( uuid )
+			end
+			action do |uuid, event|
+				$stderr.puts( uuid )
+			end
+		end
+
+		expect( observer.actions ).to be_an( Array )
+		expect( observer.actions.length ).to eq( 2 )
+		expect( observer.actions ).to all( be_a(Arborist::Observer::Action) )
+	end
+
+
+	it "can specify a summary action" do
+		observer = described_class.new( "testing observer" ) do
+			summarize( every: 5 ) do |events|
+				puts( events.size )
+			end
+		end
+
+		expect( observer.actions ).to be_an( Array )
+		expect( observer.actions.length ).to eq( 1 )
+		expect( observer.actions.first ).to be_a( Arborist::Observer::Summarize )
+	end
+
+
+	it "can specify a mix of regular and summary actions" do
+		observer = described_class.new( "testing observer" ) do
+			summarize( every: 5 ) do |events|
+				puts( events.size )
+			end
+			action do |uuid, event|
+				$stderr.puts( uuid )
+			end
+		end
+
+		expect( observer.actions ).to be_an( Array )
+		expect( observer.actions.length ).to eq( 2 )
+		expect( observer.actions.first ).to be_a( Arborist::Observer::Summarize )
+		expect( observer.actions.last ).to be_a( Arborist::Observer::Action )
+	end
+
+
+	it "passes events it is given to handle to its actions" do
+		observer = described_class.new( "testing observer" ) do
+			summarize( every: 5 ) do |events|
+				puts( events.size )
+			end
+			action do |uuid, event|
+				$stderr.puts( uuid )
+			end
+		end
+
+		event = {}
+		expect( observer.actions.first ).to receive( :handle_event ).with( event )
+		expect( observer.actions.last ).to receive( :handle_event ).with( event )
+
+		observer.handle_event( "eventid", event )
+	end
+
+
+	it "can build a list of timer callbacks for its actions" do
+		summarize_called = false
+
+		observer = described_class.new( "testing observer" ) do
+			summarize( every: 5 ) do |events|
+				summarize_called = true
+			end
+			action do |uuid, event|
+				$stderr.puts( uuid )
+			end
+		end
+
+		results = observer.timers
+
+		expect( results ).to be_an( Array )
+		expect( results.size ).to eq( 1 )
+		expect( results ).to all( be_an(Array) )
+		expect( results.last[0] ).to eq( 5 )
+
+		observer.handle_event( "eventid", {} )
+		expect { results.last[1].call }.to change { summarize_called }.to( true )
+	end
+
+end
+

data/spec/arborist/subscription_spec.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'arborist/subscription'
+
+
+describe Arborist::Subscription do
+
+	let( :host_node ) do
+		Arborist::Node.create( 'host', 'testnode' ) do
+			description "Test host"
+			address '192.168.1.1'
+		end
+	end
+	let( :service_node ) do
+		host_node.service( 'ssh' )
+	end
+	let( :publisher ) do
+		instance_double( Arborist::Manager::EventPublisher )
+	end
+	let( :subscription ) do
+		described_class.new( publisher, 'node.delta', type: 'host' )
+	end
+
+
+	it "generates a unique ID when it's created" do
+		expect( subscription.id ).to match( /^\S{16,}$/ )
+	end
+
+
+	it "publishes events which are of the desired type and have matching criteria" do
+		event = Arborist::Event.create( 'node_delta', host_node, status: ['up', 'down'] )
+
+		expect( publisher ).to receive( :publish ).with( subscription.id, event )
+
+		subscription.on_events( event )
+	end
+
+
+	it "publishes events which are of any type if the specified type is `nil`" do
+		subscription = described_class.new( publisher )
+		event1 = Arborist::Event.create( 'node_delta', host_node, status: ['up', 'down'] )
+		event2 = Arborist::Event.create( 'sys_reloaded' )
+
+		expect( publisher ).to receive( :publish ).with( subscription.id, event1 )
+		expect( publisher ).to receive( :publish ).with( subscription.id, event2 )
+
+		subscription.on_events( event1, event2 )
+	end
+
+
+	it "doesn't publish events which are of the desired type but don't have matching criteria" do
+		event = Arborist::Event.create( 'node_delta', service_node, status: ['up', 'down'] )
+
+		expect( publisher ).to_not receive( :publish )
+
+		subscription.on_events( event )
+	end
+
+
+	it "doesn't publish events which have matching criteria but aren't of the desired type" do
+		event = Arborist::Event.create( 'node_update', host_node )
+
+		expect( publisher ).to_not receive( :publish )
+
+		subscription.on_events( event )
+	end
+
+end
+

data/spec/arborist_spec.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative 'spec_helper'
+
+require 'pathname'
+require 'arborist'
+
+
+describe Arborist do
+
+	before( :all ) do
+		@original_config_env = ENV[Arborist::CONFIG_ENV]
+		@data_dir = Pathname( __FILE__ ).dirname + 'data'
+		@nodes_dir = @data_dir + 'nodes'
+	end
+
+	before( :each ) do
+		ENV.delete(Arborist::CONFIG_ENV)
+	end
+
+	after( :all ) do
+		ENV[Arborist::CONFIG_ENV] = @original_config_env
+	end
+
+
+	it "has a semantic version" do
+		expect( described_class::VERSION ).to match( /^\d+\.\d+\.\d+/ )
+	end
+
+
+	describe "configurability" do
+
+		before( :each ) do
+			Configurability.configure_objects( Configurability.default_config )
+		end
+
+		after( :all ) do
+			Configurability.reset
+		end
+
+
+		it "can return the loaded configuration" do
+			expect( described_class.config ).to be( Configurability.loaded_config )
+		end
+
+
+		it "knows whether or not the config has been loaded" do
+			expect( described_class ).to be_config_loaded
+			Configurability.reset
+			expect( described_class ).to_not be_config_loaded
+		end
+
+
+		it "will load a local config file if it exists and none is specified" do
+			config_object = double( "Configurability::Config object" )
+			allow( config_object ).to receive( :[] ).with( :arborist ).and_return( {} )
+
+			expect( Configurability ).to receive( :gather_defaults ).
+				and_return( {} )
+			expect( Arborist::LOCAL_CONFIG_FILE ).to receive( :exist? ).
+				and_return( true )
+			expect( Configurability::Config ).to receive( :load ).
+				with( Arborist::LOCAL_CONFIG_FILE, {} ).
+				and_return( config_object )
+			expect( config_object ).to receive( :install )
+
+			Arborist.load_config
+		end
+
+
+		it "will load a default config file if none is specified and there's no local config" do
+			config_object = double( "Configurability::Config object" )
+			allow( config_object ).to receive( :[] ).with( :arborist ).and_return( {} )
+
+			expect( Configurability ).to receive( :gather_defaults ).
+				and_return( {} )
+			expect( Arborist::LOCAL_CONFIG_FILE ).to receive( :exist? ).
+				and_return( false )
+			expect( Configurability::Config ).to receive( :load ).
+				with( Arborist::DEFAULT_CONFIG_FILE, {} ).
+				and_return( config_object )
+			expect( config_object ).to receive( :install )
+
+			Arborist.load_config
+		end
+
+
+		it "will load a config file given in an environment variable" do
+			ENV['ARBORIST_CONFIG'] = '/usr/local/etc/config.yml'
+
+			config_object = double( "Configurability::Config object" )
+			allow( config_object ).to receive( :[] ).with( :arborist ).and_return( {} )
+
+			expect( Configurability ).to receive( :gather_defaults ).
+				and_return( {} )
+			expect( Configurability::Config ).to receive( :load ).
+				with( '/usr/local/etc/config.yml', {} ).
+				and_return( config_object )
+			expect( config_object ).to receive( :install )
+
+			Arborist.load_config
+		end
+
+
+		it "will load a config file and install it if one is given" do
+			config_object = double( "Configurability::Config object" )
+			allow( config_object ).to receive( :[] ).with( :arborist ).and_return( {} )
+
+			expect( Configurability ).to receive( :gather_defaults ).
+				and_return( {} )
+			expect( Configurability::Config ).to receive( :load ).
+				with( 'a/configfile.yml', {} ).
+				and_return( config_object )
+			expect( config_object ).to receive( :install )
+
+			Arborist.load_config( 'a/configfile.yml' )
+		end
+
+
+		it "will override default values when loading the config if they're given" do
+			config_object = double( "Configurability::Config object" )
+			allow( config_object ).to receive( :[] ).with( :arborist ).and_return( {} )
+
+			expect( Configurability ).to_not receive( :gather_defaults )
+			expect( Configurability::Config ).to receive( :load ).
+				with( 'a/different/configfile.yml', {database: {dbname: 'test'}} ).
+				and_return( config_object )
+			expect( config_object ).to receive( :install )
+
+			Arborist.load_config( 'a/different/configfile.yml', database: {dbname: 'test'} )
+		end
+
+	end
+
+
+	it "can load all nodes in a directory and return a manager for them" do
+		expect( described_class.manager_for(@nodes_dir) ).to be_a( Arborist::Manager )
+	end
+
+
+	it "has a ZMQ context" do
+		expect( described_class.zmq_context ).to be_a( ZMQ::Context )
+	end
+
+end
+

data/spec/data/monitors/pings.rb

@@ -0,0 +1,80 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'loggability'
+require 'arborist/monitor'
+require 'arborist/mixins'
+
+using Arborist::TimeRefinements
+
+module FPingWrapper
+	extend Loggability
+	log_to :arborist
+
+	attr_accessor :identifiers
+
+	def exec_arguments( nodes )
+		self.identifiers = nodes.each_with_object({}) do |(identifier, props), hash|
+			next unless props.key?( 'addresses' )
+			address = props[ 'addresses' ].first
+			hash[ address ] = identifier
+		end
+
+		return {} if self.identifiers.empty?
+
+		return self.identifiers.keys
+	end
+
+	def handle_results( pid, stdout, stderr )
+		# 8.8.8.8 is alive (32.1 ms)
+		# 8.8.4.4 is alive (14.9 ms)
+		# 8.8.0.1 is unreachable
+
+		return stdout.each_line.with_object({}) do |line, hash|
+			address, remainder = line.split( ' ', 2 )
+			identifier = self.identifiers[ address ] or next
+
+			self.log.debug "  parsing result for %s(%s): %p" % [ identifier, address, remainder ]
+
+			if remainder =~ /is alive \((\d+\.\d+) ms\)/
+				hash[ identifier ] = { rtt: Float( $1 ) }
+			else
+				hash[ identifier ] = { error: remainder.chomp }
+			end
+		end
+	end
+
+end
+
+
+Arborist::Monitor 'ping check' do
+	every 20.seconds
+	splay 5.seconds
+	match type: 'host'
+	exclude tag: :laptop
+	use :addresses
+
+	exec 'fping', '-e', '-t', '150'
+	exec_callbacks( FPingWrapper )
+end
+
+Arborist::Monitor 'ping check downed hosts' do
+	every 40.seconds
+	splay 15.seconds
+	match type: 'host', status: 'down'
+	include_down true
+	use :addresses
+
+	exec 'fping', '-e', '-t', '150'
+	exec_callbacks( FPingWrapper )
+end
+
+Arborist::Monitor 'transient host pings' do
+	every 5.minutes
+	match type: 'host', tag: 'laptop'
+	use :addresses
+
+	exec 'fping', '-e', '-t', '500'
+	exec_callbacks( FPingWrapper )
+end
+

data/spec/data/monitors/port_checks.rb

@@ -0,0 +1,27 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'arborist/monitor'
+require 'arborist/monitor/socket'
+
+using Arborist::TimeRefinements
+
+Arborist::Monitor 'port checks on all tcp services' do
+	every 5.seconds
+	match type: 'service', protocol: 'tcp'
+	use :addresses, :port
+	exec( Arborist::Monitor::Socket::TCP )
+end
+
+Arborist::Monitor 'port checks on downed tcp services' do
+	every 10.seconds
+	match type: 'service', protocol: 'tcp', status: 'down'
+	include_down true
+	use :addresses, :port
+	exec( Arborist::Monitor::Socket::TCP )
+end
+
+# :MAHLON: A possible equivalent way to provide the above as a default for some monitors:
+# Arborist::Monitor::Socket::TCP.default_monitor
+
+