arborist 0.0.1.pre20160829140603 → 0.0.1.pre20161005112841

data/spec/arborist/manager_spec.rb

@@ -164,7 +164,7 @@ describe Arborist::Manager do
 
 
 		it "checkpoints the state file periodically if an interval is configured" do
-			described_class.configure( manager: {checkpoint_frequency: 20_000, state_file: 'arb.tree'} )
+			described_class.configure( checkpoint_frequency: 20_000, state_file: 'arb.tree' )
 
 			zloop = instance_double( ZMQ::Loop, register: nil, :verbose= => nil )
 			timer = instance_double( ZMQ::Timer, "checkpoint timer" )
@@ -203,12 +203,12 @@ describe Arborist::Manager do
 
 		it "errors if configured with a heartbeat of 0" do
 			expect {
-				described_class.configure( manager: {heartbeat_frequency: 0} )
+				described_class.configure( heartbeat_frequency: 0 )
 			}.to raise_error( Arborist::ConfigError, /positive non-zero/i )
 		end
 
 
-		it "is sent at the configured "
+		it "is sent at the configured interval"
 
 	end
 

data/spec/arborist/monitor/socket_spec.rb

@@ -48,12 +48,11 @@ describe Arborist::Monitor::Socket do
 		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 )
+			expect( socket ).to receive( :connect_nonblock ).with( sockaddr_for(node) ).
+				and_raise( IO::EINPROGRESSWaitWritable )
+			allow( socket ).to receive( :getpeername ).
+				and_return( address.to_sockaddr )
 
 			return socket
 		end
@@ -74,12 +73,13 @@ describe Arborist::Monitor::Socket do
 		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 )
+			expect( socket ).to receive( :connect_nonblock ).with( sockaddr_for(node) ).
+				and_raise( IO::EINPROGRESSWaitWritable )
+			expect( socket ).to receive( :getpeername ).
+				and_raise( Errno::EINVAL.new("Invalid argument - getpeername(2)") )
+			expect( socket ).to receive( :read ).with( 1 ).
+				and_raise( Errno::ECONNREFUSED.new )
 
 			return socket
 		end
@@ -167,22 +167,6 @@ describe Arborist::Monitor::Socket do
 		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 )

data/spec/arborist/node_spec.rb

@@ -205,6 +205,13 @@ describe Arborist::Node do
 				expect( node ).to be_disabled
 			end
 
+			it "transitions to `disabled` from `unknown` status if it's updated with an `ack` property" do
+				node.status = 'unknown'
+				node.update( ack: {message: "Maintenance", sender: 'mahlon'} )
+
+				expect( node ).to be_disabled
+			end
+
 			it "stays `disabled` if it gets an error" do
 				node.status = 'up'
 				node.update( ack: {message: "Maintenance", sender: 'mahlon'} )
@@ -804,12 +811,24 @@ describe Arborist::Node do
 		end
 
 
-		it "can be declared for unrelated identifiers"
-		it "can be declared for related identifiers"
+		it "can be declared for all of a group of identifiers" do
+			node.depends_on( 'iscsi', 'memcached', 'ldap', on: 'dmz' )
+			expect( node ).to have_dependencies
+			expect( node.dependencies.behavior ).to eq( :all )
+			expect( node.dependencies.identifiers ).to include( 'dmz-iscsi', 'dmz-memcached', 'dmz-ldap' )
+		end
 
 
-		it "can be declared for all of a group of identifiers"
-		it "can be declared for any of a group of identifiers"
+		it "can be declared for any of a group of identifiers" do
+			node.depends_on( node.any_of('memcached', on: %w[blade1 blade2 blade3]) )
+			expect( node ).to have_dependencies
+			expect( node.dependencies.behavior ).to eq( :all )
+			expect( node.dependencies.subdeps.size ).to eq( 1 )
+			subdep = node.dependencies.subdeps.first
+			expect( subdep.behavior ).to eq( :any )
+			expect( subdep.identifiers ).
+				to include( 'blade1-memcached', 'blade2-memcached', 'blade3-memcached' )
+		end
 
 
 		it "cause the node to be quieted when the dependent node goes down" do

data/spec/arborist/observer_spec.rb

@@ -43,6 +43,39 @@ describe Arborist::Observer do
 	end
 
 
+	it "can specify criteria for events" do
+		observer = described_class.new( "testing observer" ) do
+			subscribe to: 'node.up', where: { type: 'host' }
+		end
+
+		expect( observer.subscriptions ).to be_an( Array )
+		expect( observer.subscriptions ).to include( a_hash_including(criteria: {type: 'host'}) )
+		expect( observer.subscriptions.length ).to eq( 1 )
+	end
+
+
+	it "can specify negative criteria for events" do
+		observer = described_class.new( "testing observer" ) do
+			subscribe to: 'node.up', exclude: { type: 'host' }
+		end
+
+		expect( observer.subscriptions ).to be_an( Array )
+		expect( observer.subscriptions ).to include( a_hash_including(exclude: {type: 'host'}) )
+		expect( observer.subscriptions.length ).to eq( 1 )
+	end
+
+
+	it "can specify a subscription node other than the root" do
+		observer = described_class.new( "testing observer" ) do
+			subscribe to: 'node.down', on: 'dmz-gateway'
+		end
+
+		expect( observer.subscriptions ).to be_an( Array )
+		expect( observer.subscriptions ).to include( a_hash_including(identifier: 'dmz-gateway') )
+		expect( observer.subscriptions.length ).to eq( 1 )
+	end
+
+
 	it "can specify an action to run when a subscribed event is received" do
 		observer = described_class.new( "testing observer" ) do
 			action do |event|

data/spec/arborist/subscription_spec.rb

@@ -18,10 +18,6 @@ describe Arborist::Subscription do
 	let( :service_node ) do
 		host_node.service( 'ssh' )
 	end
-	let( :published_events ) {[]}
-	let( :subscription ) do
-		described_class.new( 'node.delta', type: 'host', &published_events.method(:push) )
-	end
 
 
 	it "raises an error if created without a callback block" do
@@ -32,34 +28,47 @@ describe Arborist::Subscription do
 
 
 	it "generates a unique ID when it's created" do
+		subscription = described_class.new( 'node.delta', type: 'host' ) do |*|
+			# no-op
+		end
 		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'] )
+		published_events = []
+		subscription = described_class.new( 'node.delta', type: 'host' ) do |_, event|
+			published_events << event
+		end
+		event = Arborist::Event.create( 'node_delta', host_node, 'status' => ['up', 'down'] )
 
 		subscription.on_events( event )
 
-		expect( published_events ).to eq([ subscription.id, event ])
+		expect( published_events ).to eq([ event ])
 	end
 
 
 	it "publishes events which are of any type if the specified type is `nil`" do
-		subscription = described_class.new( &published_events.method(:push) )
+		published_events = []
+		subscription = described_class.new( nil, type: 'host' ) do |_, event|
+			published_events << event
+		end
+
 		event1 = Arborist::Event.create( 'node_delta', host_node, status: ['up', 'down'] )
 		event2 = Arborist::Event.create( 'node_update', host_node )
 
 		subscription.on_events( event1, event2 )
 
-		expect( published_events ).to eq([
-			subscription.id, event1,
-			subscription.id, event2
-		])
+		expect( published_events ).to eq([ event1, event2 ])
 	end
 
 
 	it "doesn't publish events which are of the desired type but don't have matching criteria" do
+		published_events = []
+		subscription = described_class.new( 'node.delta', type: 'host' ) do |_, event|
+			published_events << event
+		end
+
 		event = Arborist::Event.create( 'node_delta', service_node, status: ['up', 'down'] )
 
 		subscription.on_events( event )
@@ -69,6 +78,11 @@ describe Arborist::Subscription do
 
 
 	it "doesn't publish events which have matching criteria but aren't of the desired type" do
+		published_events = []
+		subscription = described_class.new( 'node.delta', type: 'host' ) do |_, event|
+			published_events << event
+		end
+
 		event = Arborist::Event.create( 'node_update', host_node )
 
 		subscription.on_events( event )
@@ -76,5 +90,43 @@ describe Arborist::Subscription do
 		expect( published_events ).to be_empty
 	end
 
+
+	it "doesn't publish events which have matching negative criteria" do
+		published_events = []
+		subscription = described_class.new( 'node.update', type: 'host' ) do |_, event|
+			Loggability[ Arborist ].warn "Published event: %p" % [ event ]
+			published_events << event
+		end
+		subscription.exclude( 'status' => 'down' )
+
+		events = host_node.update( error: "Angry bees." )
+		subscription.on_events( events )
+
+		events = host_node.update( error: nil )
+		subscription.on_events( events )
+
+		expect( published_events ).to all( be_a Arborist::Event::NodeUpdate )
+		expect( published_events.length ).to eq( 1 )
+	end
+
+
+	it "doesn't publish delta events which have matching negative criteria" do
+		published_events = []
+		subscription = described_class.new( 'node.delta', type: 'host' ) do |_, event|
+			published_events << event
+		end
+		subscription.exclude( 'delta' => {'status' => ['unknown', 'down']} )
+
+		events = host_node.update( error: "Angry badgers." )
+		subscription.on_events( events )
+
+		events = host_node.update( error: nil )
+		subscription.on_events( events )
+
+		expect( published_events.length ).to eq( 1 )
+		expect( published_events.first ).to be_a( Arborist::Event::NodeDelta )
+		expect( published_events.first.payload['status'] ).to eq( ['down', 'up'] )
+	end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arborist
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre20160829140603
+  version: 0.0.1.pre20161005112841
 platform: ruby
 authors:
 - Michael Granger
@@ -36,7 +36,7 @@ cert_chain:
   w8aNA5re5+Rt/Vvjxj5AcEnZnZiz5x959NaddQocX32Z1unHw44pzRNUur1GInfW
   p4vpx2kUSFSAGjtCbDGTNV2AH8w9OU4xEmNz8c5lyoA=
   -----END CERTIFICATE-----
-date: 2016-08-29 00:00:00.000000000 Z
+date: 2016-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: schedulability
@@ -413,7 +413,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Arborist is a monitoring toolkit that follows the UNIX philosophy of small