arborist 0.1.0 → 0.2.0.pre20170519125456

checksums.yaml.gz.sig

@@ -1,3 +0,0 @@
-bZ_�Ov�97�~��2�+쳦�;鄀	��#��D5ma��5�PÀ\,�G(�	%A3��&���Z!�g��s�x4
-���ʩ�V�da�oMʡ8��K��:���40�R����t˝&�� 3��/c����"Y�*��w�����N�;Q��#�~xZ��jw��J#�<�_���C\�X������ܘ5)a�$:��gLd)T��&�z)k��T)}�V��Dv��^�&��S�T$(� 	��vE���Vn�M,]ST�x��i�OR�L���]�9qn������
-�=�x=�8@fv~���c�gim))���f�@����ހh!�5^���¼Hp�	�o 3ϸ�*�c���ꎛ]�c"�X��

data/lib/arborist/manager/event_publisher.rb

@@ -1,126 +0,0 @@
-# -*- ruby -*-
-#encoding: utf-8
-
-require 'msgpack'
-require 'loggability'
-require 'rbczmq'
-require 'arborist/manager' unless defined?( Arborist::Manager )
-
-
-class Arborist::Manager::EventPublisher < ZMQ::Handler
-	extend Loggability,
-	       Arborist::MethodUtilities
-
-	# Loggability API -- log to arborist's logger
-	log_to :arborist
-
-
-	### Create a new EventPublish that will publish events emitted by
-	### emitters on the specified +manager+ on the given +pollable+.
-	def initialize( pollitem, manager, reactor )
-		self.log.debug "Setting up a %p for %p (socket %p)" %
-			[ self.class, pollitem, pollitem.pollable ]
-		@pollable    = pollitem.pollable
-		@pollitem    = pollitem
-		@manager     = manager
-		@reactor     = reactor
-		@registered  = true
-		@enabled     = true
-		@event_queue = []
-	end
-
-
-	######
-	public
-	######
-
-	##
-	# True if the publisher is currently registered with the reactor (i.e., waiting
-	# to write published events).
-	attr_predicate :registered
-
-	##
-	# The Queue of pending events to publish
-	attr_reader :event_queue
-
-	##
-	# A on/off toggle for publishing events
-	attr_predicate :enabled
-
-
-	### Publish the specified +event+.
-	def publish( identifier, event )
-		return self unless self.enabled?
-		@event_queue << [ identifier, MessagePack.pack(event.to_h) ]
-		self.register
-		return self
-	end
-
-
-	### ZMQ::Handler API -- write events to the socket as it becomes writable.
-	def on_writable
-		unless @event_queue.empty?
-			tuple = @event_queue.shift
-			identifier, payload = *tuple
-
-			pollsocket = self.pollitem.pollable
-			pollsocket.sendm( identifier )
-			pollsocket.send( payload )
-		end
-		self.unregister if @event_queue.empty?
-		return true
-	end
-
-
-	### Stop accepting events to be published
-	def shutdown
-		@enabled = false
-		return if @event_queue.empty?
-
-		start   = Time.now
-		timeout = start + (@manager.linger.to_f / 2000)
-
-		self.log.warn "Waiting to empty the event queue..."
-		until @event_queue.empty?
-			sleep 0.1
-			break if Time.now > timeout
-		end
-		self.log.warn "  ... waited %0.1f seconds" % [ Time.now - start ]
-	end
-
-
-
-	#########
-	protected
-	#########
-
-	### Register the publisher with the reactor if it's not already.
-	def register
-		count ||= 0
-		@reactor.register( self.pollitem ) unless @registered
-		# self.log.info "Publisher socket is now registered!"
-		@registered = true
-	rescue => err
-		# :TODO:
-		# This is to work around a weird error that happens sometimes when registering:
-		#   Sys error location: loop.c:424
-		# which then raises a RuntimeError with "Socket operation on non-socket". This is
-		# probably due to a race somewhere, but we can't find it. So this works (at least
-		# for the specs) in the meantime.
-		raise unless err.message.include?( "Socket operation on non-socket" )
-		count += 1
-		raise "Gave up trying to register %p with the reactor" % [ self.pollitem ] if count > 5
-		warn "Retrying registration!"
-		retry
-	end
-
-
-	### Unregister the publisher from the reactor if it's registered.
-	def unregister
-		@reactor.remove( self.pollitem ) if @registered
-		@registered = false
-	end
-
-
-end # class Arborist::Manager::EventPublisher
-

data/lib/arborist/manager/tree_api.rb

@@ -1,302 +0,0 @@
-# -*- ruby -*-
-#encoding: utf-8
-
-require 'msgpack'
-require 'loggability'
-require 'rbczmq'
-require 'arborist/manager' unless defined?( Arborist::Manager )
-
-
-class Arborist::Manager::TreeAPI < ZMQ::Handler
-	extend Loggability,
-	       Arborist::MethodUtilities
-
-
-	# Loggability API -- log to the arborist logger
-	log_to :arborist
-
-
-	### Create the TreeAPI handler that will read requests from the specified +pollable+
-	### and call into the +manager+ to respond to them.
-	def initialize( pollable, manager )
-		@pollitem = pollable
-		@enabled  = true
-		@manager  = manager
-	end
-
-
-	##
-	# True if the Tree API is accepting commands
-	attr_predicate :enabled
-
-
-	### ZMQ::Handler API -- Read and handle an incoming request.
-	def on_readable
-		request = self.recv
-		response = self.handle_request( request )
-		self.send( response )
-	end
-
-
-	### Handle the specified +raw_request+ and return a response.
-	def handle_request( raw_request )
-		raise "Manager is shutting down" unless self.enabled?
-
-		header, body = self.parse_request( raw_request )
-		return self.dispatch_request( header, body )
-
-	rescue => err
-		self.log.error "%p: %s" % [ err.class, err.message ]
-		err.backtrace.each {|frame| self.log.debug "  #{frame}" }
-
-		errtype = case err
-			when Arborist::RequestError,
-			     Arborist::ConfigError,
-			     Arborist::NodeError
-				'client'
-			else
-				'server'
-			end
-
-		return self.error_response( errtype, err.message )
-	end
-
-
-	### Attempt to dispatch a request given its +header+ and +body+, and return the
-	### serialized response.
-	def dispatch_request( header, body )
-		handler = self.lookup_request_action( header ) or
-			raise Arborist::RequestError, "No such action '%s'" % [ header['action'] ]
-
-		response = handler.call( header, body )
-
-		return response
-	end
-
-
-	### Given a request +header+, return a #call-able object that can handle the response.
-	def lookup_request_action( header )
-		raise Arborist::RequestError, "unsupported version %d" % [ header['version'] ] unless
-			header['version'] == 1
-
-		handler_name = "handle_%s_request" % [ header['action'] ]
-		return nil unless self.respond_to?( handler_name )
-
-		return self.method( handler_name )
-	end
-
-
-	### Build an error response message for the specified +category+ and +reason+.
-	def error_response( category, reason )
-		msg = [
-			{ category: category, reason: reason, success: false, version: 1 }
-		]
-		return MessagePack.pack( msg )
-	end
-
-
-	### Build a successful response with the specified +body+.
-	def successful_response( body )
-		msg = [
-			{ success: true, version: 1 },
-			body
-		]
-		return MessagePack.pack( msg )
-	end
-
-
-	### Validate and return a parsed msgpack +raw_request+.
-	def parse_request( raw_request )
-		tuple = begin
-			MessagePack.unpack( raw_request )
-		rescue => err
-			raise Arborist::RequestError, err.message
-		end
-
-		raise Arborist::RequestError, 'not a tuple' unless tuple.is_a?( Array )
-		raise Arborist::RequestError, 'incorrect length' if tuple.length.zero? || tuple.length > 2
-
-		header, body = *tuple
-		raise Arborist::RequestError, "header is not a Map" unless
-			header.is_a?( Hash )
-		raise Arborist::RequestError, "missing required header 'version'" unless
-			header.key?( 'version' )
-		raise Arborist::RequestError, "missing required header 'action'" unless
-			header.key?( 'action' )
-
-		raise Arborist::RequestError, "body must be Nil, a Map, or an Array of Maps" unless
-			body.is_a?( Hash ) || body.nil? ||
-			( body.is_a?(Array) && body.all? {|obj| obj.is_a?(Hash) } )
-
-		return header, body
-	end
-
-
-	### Return a response to the `status` action.
-	def handle_status_request( header, body )
-		self.log.debug "STATUS: %p" % [ header ]
-		return successful_response(
-			server_version: Arborist::VERSION,
-			state: @manager.running? ? 'running' : 'not running',
-			uptime: @manager.uptime,
-			nodecount: @manager.nodecount
-		)
-	end
-
-
-	### Return a response to the `subscribe` action.
-	def handle_subscribe_request( header, body )
-		self.log.debug "SUBSCRIBE: %p" % [ header ]
-		event_type      = header[ 'event_type' ]
-		node_identifier = header[ 'identifier' ]
-
-		body = [ body ] unless body.is_a?( Array )
-		positive = body.shift
-		negative = body.shift || {}
-
-		subscription = @manager.
-			create_subscription( node_identifier, event_type, positive, negative )
-
-		return successful_response([ subscription.id ])
-	end
-
-
-	### Return a response to the `unsubscribe` action.
-	def handle_unsubscribe_request( header, body )
-		self.log.debug "UNSUBSCRIBE: %p" % [ header ]
-		subscription_id = header[ 'subscription_id' ] or
-			return error_response( 'client', 'No identifier specified for UNSUBSCRIBE.' )
-		subscription = @manager.remove_subscription( subscription_id ) or
-			return successful_response( nil )
-
-		return successful_response(
-			event_type: subscription.event_type,
-			criteria: subscription.criteria
-		)
-	end
-
-
-	### Return a repsonse to the `list` action.
-	def handle_list_request( header, body )
-		self.log.debug "LIST: %p" % [ header ]
-		from  = header['from'] || '_'
-		depth = header['depth']
-
-		start_node = @manager.nodes[ from ]
-		self.log.debug "  Listing nodes under %p" % [ start_node ]
-		iter = if depth
-			self.log.debug "    depth limited to %d" % [ depth ]
-			@manager.depth_limited_enumerator_for( start_node, depth )
-		else
-			self.log.debug "    no depth limit"
-			@manager.enumerator_for( start_node )
-		end
-		data = iter.map( &:to_h )
-		self.log.debug "  got data for %d nodes" % [ data.length ]
-
-		return successful_response( data )
-	end
-
-
-	### Return a response to the 'fetch' action.
-	def handle_fetch_request( header, body )
-		self.log.debug "FETCH: %p" % [ header ]
-
-		include_down = header['include_down']
-		values = if header.key?( 'return' )
-				header['return'] || []
-			else
-				nil
-			end
-
-		body = [ body ] unless body.is_a?( Array )
-		positive = body.shift
-		negative = body.shift || {}
-		states = @manager.fetch_matching_node_states( positive, values, include_down, negative )
-
-		return successful_response( states )
-	end
-
-
-	### Update nodes using the data from the update request's +body+.
-	def handle_update_request( header, body )
-		self.log.debug "UPDATE: %p" % [ header ]
-
-		unless body.respond_to?( :each )
-			return error_response( 'client', 'Malformed update: body does not respond to #each' )
-		end
-
-		body.each do |identifier, properties|
-			@manager.update_node( identifier, properties )
-		end
-
-		return successful_response( nil )
-	end
-
-
-	### Remove a node and its children.
-	def handle_prune_request( header, body )
-		self.log.debug "PRUNE: %p" % [ header ]
-
-		identifier = header[ 'identifier' ] or
-			return error_response( 'client', 'No identifier specified for PRUNE.' )
-		node = @manager.remove_node( identifier )
-
-		return successful_response( node ? true : nil )
-	end
-
-
-	### Add a node
-	def handle_graft_request( header, body )
-		self.log.debug "GRAFT: %p" % [ header ]
-
-		identifier = header[ 'identifier' ] or
-			return error_response( 'client', 'No identifier specified for GRAFT.' )
-		type = header[ 'type' ] or
-			return error_response( 'client', 'No type specified for GRAFT.' )
-		parent = header[ 'parent' ] || '_'
-		parent_node = @manager.nodes[ parent ] or
-			return error_response( 'client', 'No parent node found for %s.' % [parent] )
-
-		self.log.debug "Grafting a new %s node under %p" % [ type, parent_node ]
-
-		# If the parent has a factory method for the node type, use it, otherwise
-		# use the Pluggability factory
-		node = if parent_node.respond_to?( type )
-				parent_node.method( type ).call( identifier, body )
-			else
-				body.merge!( parent: parent )
-				Arborist::Node.create( type, identifier, body )
-			end
-
-		@manager.add_node( node )
-
-		return successful_response( node ? node.identifier : nil )
-	end
-
-
-	### Modify a node's operational attributes
-	def handle_modify_request( header, body )
-		self.log.debug "MODIFY: %p" % [ header ]
-
-		identifier = header[ 'identifier' ] or
-			return error_response( 'client', 'No identifier specified for MODIFY.' )
-		return error_response( 'client', "Unable to MODIFY root node." ) if identifier == '_'
-		node = @manager.nodes[ identifier ] or
-			return error_response( 'client', "No such node %p" % [identifier] )
-
-		self.log.debug "Modifying operational attributes of the %s node: %p" % [ identifier, body ]
-
-		node.modify( body )
-
-		return successful_response( nil )
-	end
-
-
-	### Disable the API, returning errors for any future requests.
-	def shutdown
-		@enabled = false
-	end
-
-end # class Arborist::Manager::TreeAPI
-

data/spec/arborist/manager/event_publisher_spec.rb

@@ -1,65 +0,0 @@
-#!/usr/bin/env rspec -cfd
-
-require_relative '../../spec_helper'
-
-require 'arborist/manager/event_publisher'
-
-
-describe Arborist::Manager::EventPublisher do
-
-	let( :socket ) { instance_double( ZMQ::Socket::Pub ) }
-	let( :pollitem ) { instance_double( ZMQ::Pollitem, pollable: socket ) }
-	let( :zloop ) { instance_double( ZMQ::Loop ) }
-
-	let( :manager ) { Arborist::Manager.new }
-	let( :event ) { Arborist::Event.create(TestEvent, 'stuff') }
-
-	let( :publisher ) { described_class.new(pollitem, manager, zloop) }
-
-
-	it "starts out registered for writing" do
-		expect( publisher ).to be_registered
-	end
-
-
-	it "unregisters itself if told to write with an empty event queue" do
-		expect( zloop ).to receive( :remove ).with( pollitem )
-		expect {
-			publisher.on_writable
-		}.to change { publisher.registered? }.to( false )
-	end
-
-
-	it "registers itself if it's not already when an event is appended" do
-		# Cause the socket to become unregistered
-		allow( zloop ).to receive( :remove )
-		publisher.on_writable
-
-		expect( zloop ).to receive( :register ).with( pollitem )
-
-		expect {
-			publisher.publish( 'identifier-00aa', event )
-		}.to change { publisher.registered? }.to( true )
-	end
-
-
-	it "publishes events with their identifier" do
-		identifier = '65b2430b-6855-4961-ab46-d742cf4456a1'
-
-		expect( socket ).to receive( :sendm ).with( identifier )
-		expect( socket ).to receive( :send ) do |raw_data|
-			ev = MessagePack.unpack( raw_data )
-			expect( ev ).to include( 'type', 'data' )
-
-			expect( ev['type'] ).to eq( 'test.event' )
-			expect( ev['data'] ).to eq( 'stuff' )
-		end
-		expect( zloop ).to receive( :remove ).with( pollitem )
-
-		publisher.publish( identifier, event )
-		publisher.on_writable
-	end
-
-end
-
-