arborist 0.0.1.pre20160106113421

data/lib/arborist/observer/summarize.rb

@@ -0,0 +1,105 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'schedulability'
+require 'schedulability/schedule'
+require 'loggability'
+
+require 'arborist/observer' unless defined?( Arborist::Observer )
+
+
+# An summarization action taken by an Observer.
+class Arborist::Observer::Summarize
+	extend Loggability
+
+
+	# Loggability API -- log to the Arborist logger
+	log_to :arborist
+
+
+	### Create a new Summary that will call the specified +block+ +during+ the given schedule,
+	### +every+ specified number of seconds or +count+ events, whichever is sooner.
+	def initialize( every: 0, count: 0, during: nil, &block )
+		raise ArgumentError, "Summarize requires a block" unless block
+		raise ArgumentError, "Summarize requires a value for `every` or `count`." if
+			every.zero? && count.zero?
+
+		@time_threshold  = every
+		@count_threshold = count
+		@schedule        = Schedulability::Schedule.parse( during ) if during
+		@block           = block
+
+		@event_history = {}
+	end
+
+
+	######
+	public
+	######
+
+	##
+	# The object to #call when the action is triggered.
+	attr_reader :block
+
+	##
+	# The number of seconds between calls to the action
+	attr_reader :time_threshold
+
+	##
+	# The number of events that cause the action to be called.
+	attr_reader :count_threshold
+
+	##
+	# The schedule that applies to this action.
+	attr_reader	:schedule
+
+	##
+	# The Hash of recent events, keyed by their arrival time.
+	attr_reader :event_history
+
+
+	### Call the action for the specified +event+.
+	def handle_event( event )
+		self.record_event( event )
+		self.call_block if self.should_run?
+	end
+
+
+	### Handle a timing event by calling the block with any events in the history.
+	def on_timer
+		self.log.debug "Timer event: %d pending event/s" % [ self.event_history.size ]
+		self.call_block unless self.event_history.empty?
+	end
+
+
+	### Execute the action block.
+	def call_block
+		self.block.call( self.event_history.dup )
+	ensure
+		self.event_history.clear
+	end
+
+
+	### Record the specified +event+ in the event history if within the scheduled period(s).
+	def record_event( event )
+		return if self.schedule && !self.schedule.now?
+		self.event_history[ Time.now ] = event
+	end
+
+
+	### Returns +true+ if the count threshold is exceeded and the current time is within the
+	### action's schedule.
+	def should_run?
+		return self.count_threshold_exceeded?
+	end
+
+
+	### Returns +true+ if the number of events in the event history meet or exceed the
+	### #count_threshold.
+	def count_threshold_exceeded?
+		return false if self.count_threshold.zero?
+		self.log.debug "Event history has %d events" % [ self.event_history.size ]
+		return self.event_history.size >= self.count_threshold
+	end
+
+end # class Arborist::Observer::Summarize

data/lib/arborist/observer_runner.rb

@@ -0,0 +1,181 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'rbczmq'
+require 'loggability'
+
+require 'arborist' unless defined?( Arborist )
+require 'arborist/client'
+require 'arborist/observer'
+
+
+# Undo the useless scoping
+class ZMQ::Loop
+	public_class_method :instance
+end
+
+
+# An event-driven runner for Arborist::Observers.
+class Arborist::ObserverRunner
+	extend Loggability
+
+	log_to :arborist
+
+
+	# A ZMQ::Handler object for managing IO for all running observers.
+	class Handler < ZMQ::Handler
+		extend Loggability,
+		       Arborist::MethodUtilities
+
+		log_to :arborist
+
+		### Create a ZMQ::Handler that acts as the agent that runs the specified
+		### +observer+.
+		def initialize( reactor )
+			@client = Arborist::Client.new
+			@pollitem = ZMQ::Pollitem.new( @client.event_api, ZMQ::POLLIN )
+			@pollitem.handler = self
+			@subscriptions = {}
+
+			reactor.register( @pollitem )
+		end
+
+
+		######
+		public
+		######
+
+		# The Arborist::Client that will be used for creating and tearing down subscriptions
+		attr_reader :client
+
+		# The map of subscription IDs to the Observer which it was created for.
+		attr_reader :subscriptions
+
+
+		### 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 ]
+			observer.subscriptions.each do |sub|
+				subid = self.client.subscribe( sub )
+				self.subscriptions[ subid ] = observer
+				self.client.event_api.subscribe( subid )
+				self.log.debug "  subscribed to %p with subscription %s" % [ sub, subid ]
+			end
+		end
+
+
+		### Remove the specified +observer+ after unsubscribing from its events.
+		def remove_observer( observer )
+			self.log.info "Removing observer: %s" % [ observer.description ]
+
+			self.subscriptions.keys.each do |subid|
+				next unless self.subscriptions[ subid ] == observer
+
+				self.client.unsubscribe( subid )
+				self.subscriptions.delete( subid )
+				self.client.event_api.unsubscribe( subid )
+				self.log.debug "  unsubscribed from %p" % [ subid ]
+			end
+		end
+
+
+		### Read events from the event socket when it becomes readable, and dispatch them to
+		### the correct observer.
+		def on_readable
+			subid = self.recv
+			raise "Partial write?!" unless self.pollitem.pollable.rcvmore?
+			raw_event = self.recv
+
+			if (( observer = self.subscriptions[subid] ))
+				event = MessagePack.unpack( raw_event )
+				observer.handle_event( subid, event )
+			else
+				self.log.warn "Ignoring event %p for which we have no observer." % [ subid ]
+			end
+
+			return true
+		end
+
+	end # class Handler
+
+
+	### Create a new Arborist::ObserverRunner
+	def initialize
+		@observers = []
+		@timers = []
+		@handler = nil
+		@reactor = ZMQ::Loop.new
+	end
+
+
+	######
+	public
+	######
+
+	# The Array of loaded Arborist::Observers the runner should run.
+	attr_reader :observers
+
+	# The Array of registered ZMQ::Timers
+	attr_reader :timers
+
+	# The ZMQ::Handler subclass that handles all async IO
+	attr_accessor :handler
+
+	# The reactor (a ZMQ::Loop) the runner uses to drive everything
+	attr_accessor :reactor
+
+
+	### Load observers from the specified +enumerator+.
+	def load_observers( enumerator )
+		@observers += enumerator.to_a
+	end
+
+
+	### Run the specified +observers+
+	def run
+		self.handler = Arborist::ObserverRunner::Handler.new( self.reactor )
+
+		self.observers.each do |observer|
+			self.handler.add_observer( observer )
+			self.add_timers_for( observer )
+		end
+
+		self.reactor.start
+	rescue Interrupt
+		$stderr.puts "Interrupted!"
+		self.stop
+	end
+
+
+	### Stop the observer
+	def stop
+		self.observers.each do |observer|
+			self.remove_timers
+			self.handler.remove_observer( observer )
+		end
+
+		self.reactor.stop
+	end
+
+
+	### Register a timer for the specified +observer+.
+	def add_timers_for( observer )
+		observer.timers.each do |interval, callback|
+			self.log.info "Creating timer for %s observer to run %p every %ds" %
+				[ observer.description, callback, interval ]
+			timer = ZMQ::Timer.new( interval, 0, &callback )
+			self.reactor.register_timer( timer )
+			self.timers << timer
+		end
+	end
+
+
+	### Remove any registered timers.
+	def remove_timers
+		self.timers.each do |timer|
+			self.reactor.cancel_timer( timer )
+		end
+	end
+
+end # class Arborist::ObserverRunner
+

data/lib/arborist/subscription.rb

@@ -0,0 +1,82 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'loggability'
+require 'securerandom'
+
+require 'arborist' unless defined?( Arborist )
+require 'arborist/mixins'
+
+
+# An observer subscription to node events.
+class Arborist::Subscription
+	extend Loggability
+	include Arborist::HashUtilities
+
+
+	# Loggability API -- log to the Arborist logger
+	log_to :arborist
+
+
+	### Instantiate a new Subscription object given an +event+ pattern
+	### and event +criteria+.
+	def initialize( publisher, event_type=nil, criteria={} )
+		@publisher  = publisher
+		@event_type = event_type
+		@criteria   = stringify_keys( criteria )
+		@id         = self.generate_id
+	end
+
+
+	######
+	public
+	######
+
+	# The Arborist::Manager::EventPublisher the subscription will use to publish matching events.
+	attr_reader :publisher
+
+	# A unique identifier for this subscription request.
+	attr_reader :id
+
+	# The Arborist event pattern that this subscription handles.
+	attr_reader :event_type
+
+	# Node selection attributes to match
+	attr_reader :criteria
+
+
+	### Create an identifier for this subscription object.
+	def generate_id
+		return SecureRandom.uuid
+	end
+
+
+	### Publish any of the specified +events+ which match the subscription.
+	def on_events( *events )
+		events.flatten.each do |event|
+			self.publisher.publish( self.id, event ) if self.interested_in?( event )
+		end
+	end
+
+
+	### Returns +true+ if the receiver is interested in publishing the specified +event+.
+	def interested_in?( event )
+		self.log.debug "Testing %p against type = %p and criteria = %p" %
+			[ event, self.event_type, self.criteria ]
+		return event.match( self )
+	end
+	alias_method :is_interested_in?, :interested_in?
+
+
+	### Return a String representation of the object suitable for debugging.
+	def inspect
+		return "#<%p:%#x [%s] for %s events matching: %p>" % [
+			self.class,
+			self.object_id * 2,
+			self.id,
+			self.event_type,
+			self.criteria,
+		]
+	end
+
+end # class Arborist::Subscription

data/spec/arborist/client_spec.rb

@@ -0,0 +1,282 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'arborist/client'
+
+
+describe Arborist::Client do
+
+	let( :client ) { described_class.new }
+
+	describe "synchronous API", :testing_manager do
+
+		before( :each ) do
+			@manager = make_testing_manager()
+			@manager_thread = Thread.new do
+				Thread.current.abort_on_exception = true
+				@manager.run
+				Loggability[ Arborist ].info "Stopped the test manager"
+			end
+
+			count = 0
+			until @manager.running? || count > 30
+				sleep 0.1
+				count += 1
+			end
+			raise "Manager didn't start up" unless @manager.running?
+		end
+
+		after( :each ) do
+			@manager.stop
+			@manager_thread.join
+
+			count = 0
+			while @manager.zmq_loop.running? || count > 30
+				sleep 0.1
+				Loggability[ Arborist ].info "ZMQ loop still running"
+				count += 1
+			end
+			raise "ZMQ Loop didn't stop" if @manager.zmq_loop.running?
+		end
+
+
+		let( :manager ) { @manager }
+
+
+		it "can fetch the status of the manager it's connected to" do
+			res = client.status
+			expect( res ).to include( 'server_version', 'state', 'uptime', 'nodecount' )
+		end
+
+
+		it "can list the nodes of the manager it's connected to" do
+			res = client.list
+			expect( res ).to be_an( Array )
+			expect( res.length ).to eq( manager.nodes.length )
+		end
+
+
+		it "can list a subtree of the nodes of the manager it's connected to" do
+			res = client.list( from: 'duir' )
+			expect( res ).to be_an( Array )
+			expect( res.length ).to be < manager.nodes.length
+		end
+
+
+		it "can fetch all node properties for all 'up' nodes" do
+			res = client.fetch
+			expect( res ).to be_a( Hash )
+			expect( res.length ).to be == manager.nodes.length
+			expect( res.values ).to all( be_a(Hash) )
+		end
+
+
+		it "can fetch identifiers for all 'up' nodes" do
+			res = client.fetch( {}, properties: nil )
+			expect( res ).to be_a( Hash )
+			expect( res.length ).to be == manager.nodes.length
+			expect( res.values ).to all( be_empty )
+		end
+
+
+		it "can fetch a subset of properties for all 'up' nodes" do
+			res = client.fetch( {}, properties: [:addresses, :status] )
+			expect( res ).to be_a( Hash )
+			expect( res.length ).to be == manager.nodes.length
+			expect( res.values ).to all( be_a(Hash) )
+			expect( res.values.map(&:length) ).to all( be <= 2 )
+		end
+
+
+		it "can fetch a subset of properties for all 'up' nodes matching specified criteria" do
+			res = client.fetch( {type: 'host'}, properties: [:addresses, :status] )
+			expect( res ).to be_a( Hash )
+			expect( res.length ).to be == manager.nodes.values.count {|n| n.type == 'host' }
+			expect( res.values ).to all( include('addresses', 'status') )
+		end
+
+
+		it "can fetch all properties for all nodes regardless of their status" do
+			# Down a node
+			manager.nodes['duir'].update( error: 'something happened' )
+
+			res = client.fetch( {type: 'host'}, include_down: true )
+
+			expect( res ).to be_a( Hash )
+			expect( res ).to include( 'duir' )
+			expect( res['duir']['status'] ).to eq( 'down' )
+		end
+
+
+		it "can update the properties of managed nodes" do
+			client.update( duir: { ping: {rtt: 24} } )
+
+			expect( manager.nodes['duir'].properties ).to include( 'ping' )
+			expect( manager.nodes['duir'].properties['ping'] ).to include( 'rtt' )
+			expect( manager.nodes['duir'].properties['ping']['rtt'] ).to eq( 24 )
+		end
+
+
+		it "can subscribe to all events" do
+			sub_id = client.subscribe
+			expect( sub_id ).to be_a( String )
+			expect( sub_id ).to match( /^[\w\-]{16,}/ )
+
+			node = manager.subscriptions[ sub_id ]
+			sub = manager.root.subscriptions[ sub_id ]
+
+			expect( sub ).to be_a( Arborist::Subscription )
+			expect( sub.criteria ).to be_empty
+			expect( sub.event_type ).to be_nil
+		end
+
+
+		it "can subscribe to a particular kind of event" do
+			sub_id = client.subscribe( event_type: 'node.ack' )
+			expect( sub_id ).to be_a( String )
+			expect( sub_id ).to match( /^[\w\-]{16,}/ )
+
+			node = manager.subscriptions[ sub_id ]
+			sub = manager.root.subscriptions[ sub_id ]
+
+			expect( sub ).to be_a( Arborist::Subscription )
+			expect( sub.criteria ).to be_empty
+			expect( sub.event_type ).to eq( 'node.ack' )
+		end
+
+
+		it "can subscribe to events for descendants of a particular node in the tree" do
+			sub_id = client.subscribe( identifier: 'sidonie' )
+			expect( sub_id ).to be_a( String )
+			expect( sub_id ).to match( /^[\w\-]{16,}/ )
+
+			node = manager.subscriptions[ sub_id ]
+			sub = node.subscriptions[ sub_id ]
+
+			expect( node.identifier ).to eq( 'sidonie' )
+			expect( sub ).to be_a( Arborist::Subscription )
+			expect( sub.criteria ).to be_empty
+			expect( sub.event_type ).to be_nil
+		end
+
+
+		it "can subscribe to events of a particular type for descendants of a particular node" do
+			sub_id = client.subscribe( identifier: 'sidonie', event_type: 'node.delta' )
+			expect( sub_id ).to be_a( String )
+			expect( sub_id ).to match( /^[\w\-]{16,}/ )
+
+			node = manager.subscriptions[ sub_id ]
+			sub = node.subscriptions[ sub_id ]
+
+			expect( node.identifier ).to eq( 'sidonie' )
+			expect( sub ).to be_a( Arborist::Subscription )
+			expect( sub.criteria ).to be_empty
+			expect( sub.event_type ).to eq( 'node.delta' )
+		end
+
+
+		it "can subscribe to events matching one or more criteria" do
+			sub_id = client.subscribe( criteria: {type: 'service'} )
+			expect( sub_id ).to be_a( String )
+			expect( sub_id ).to match( /^[\w\-]{16,}/ )
+
+			node = manager.subscriptions[ sub_id ]
+			sub = node.subscriptions[ sub_id ]
+
+			expect( node.identifier ).to eq( '_' )
+			expect( sub ).to be_a( Arborist::Subscription )
+			expect( sub.criteria ).to eq( 'type' => 'service' )
+			expect( sub.event_type ).to eq( nil )
+		end
+
+	end
+
+
+	describe "asynchronous API" do
+
+		it "can make a raw status request" do
+			req = client.make_status_request
+			expect( req ).to be_a( String )
+			expect( req.encoding ).to eq( Encoding::ASCII_8BIT )
+
+			msg = unpack_message( req )
+			expect( msg ).to be_an( Array )
+			expect( msg.first ).to be_a( Hash )
+			expect( msg.first ).to include( 'version', 'action' )
+			expect( msg.first['version'] ).to eq( Arborist::Client::API_VERSION )
+			expect( msg.first['action'] ).to eq( 'status' )
+		end
+
+
+		it "can make a raw list request" do
+			req = client.make_list_request
+			expect( req ).to be_a( String )
+			expect( req.encoding ).to eq( Encoding::ASCII_8BIT )
+
+			msg = unpack_message( req )
+			expect( msg ).to be_an( Array )
+			expect( msg.first ).to be_a( Hash )
+			expect( msg.first ).to include( 'version', 'action' )
+			expect( msg.first ).to_not include( 'from' )
+			expect( msg.first['version'] ).to eq( Arborist::Client::API_VERSION )
+			expect( msg.first['action'] ).to eq( 'list' )
+		end
+
+
+		it "can make a raw fetch request" do
+			req = client.make_fetch_request( {} )
+			expect( req ).to be_a( String )
+			expect( req.encoding ).to eq( Encoding::ASCII_8BIT )
+
+			msg = unpack_message( req )
+			expect( msg ).to be_an( Array )
+			expect( msg.first ).to be_a( Hash )
+			expect( msg.first ).to include( 'version', 'action' )
+			expect( msg.first['version'] ).to eq( Arborist::Client::API_VERSION )
+			expect( msg.first['action'] ).to eq( 'fetch' )
+
+			expect( msg.last ).to eq( {} )
+		end
+
+
+		it "can make a raw fetch request with criteria" do
+			req = client.make_fetch_request( {type: 'host'} )
+			expect( req ).to be_a( String )
+			expect( req.encoding ).to eq( Encoding::ASCII_8BIT )
+
+			msg = unpack_message( req )
+			expect( msg ).to be_an( Array )
+			expect( msg.first ).to be_a( Hash )
+			expect( msg.first ).to include( 'version', 'action' )
+			expect( msg.first['version'] ).to eq( Arborist::Client::API_VERSION )
+			expect( msg.first['action'] ).to eq( 'fetch' )
+
+			expect( msg.last ).to be_a( Hash )
+			expect( msg.last ).to include( 'type' )
+			expect( msg.last['type'] ).to eq( 'host' )
+		end
+
+
+		it "can make a raw update request" do
+			req = client.make_update_request( duir: {error: "Something happened."} )
+			expect( req ).to be_a( String )
+			expect( req.encoding ).to eq( Encoding::ASCII_8BIT )
+
+			msg = unpack_message( req )
+			expect( msg ).to be_an( Array )
+			expect( msg.first ).to be_a( Hash )
+			expect( msg.first ).to include( 'version', 'action' )
+			expect( msg.first['version'] ).to eq( Arborist::Client::API_VERSION )
+			expect( msg.first['action'] ).to eq( 'update' )
+
+			expect( msg.last ).to be_a( Hash )
+			expect( msg.last ).to include( 'duir' )
+			expect( msg.last['duir'] ).to eq( 'error' => 'Something happened.' )
+		end
+
+	end
+
+
+end
+