arborist 0.0.1.pre20160128152542 → 0.0.1.pre20160606141735

data/lib/arborist/node/ack.rb

@@ -0,0 +1,72 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'arborist/node' unless defined?( Arborist::Node )
+require 'arborist/mixins'
+
+
+# The inner class for the 'ack' operational property
+class Arborist::Node::Ack
+	extend Arborist::HashUtilities
+
+	### Construct an instance from the values in the specified +hash+.
+	def self::from_hash( hash )
+		hash = symbolify_keys( hash )
+
+		message = hash.delete( :message ) or raise ArgumentError, "Missing required ACK message"
+		sender  = hash.delete( :sender )  or raise ArgumentError, "Missing required ACK sender"
+
+		if hash[:time]
+			hash[:time] = Time.at( hash[:time] ) if hash[:time].is_a?( Numeric )
+			hash[:time] = Time.parse( hash[:time] ) unless hash[:time].is_a?( Time )
+		end
+
+		return new( message, sender, **hash )
+	end
+
+
+	### Create a new acknowledgement
+	def initialize( message, sender, via: nil, time: nil )
+		time ||= Time.now
+
+		@message = message
+		@sender  = sender
+		@via     = via
+		@time    = time.to_time
+	end
+
+	##
+	# The object's message, :sender, :via, :time
+	attr_reader :message, :sender, :via, :time
+
+
+	### Return a string description of the acknowledgement for logging and inspection.
+	def description
+		return "by %s%s -- %s" % [
+			self.sender,
+			self.via ? " via #{self.via}" : '',
+			self.message
+		]
+	end
+
+
+	### Return the Ack as a Hash.
+	def to_h
+		return {
+			message: self.message,
+			sender: self.sender,
+			via: self.via,
+			time: self.time.iso8601,
+		}
+	end
+
+
+	### Returns true if the +other+ object is an Ack with the same values.
+	def ==( other )
+		return other.is_a?( self.class ) &&
+			self.to_h == other.to_h
+	end
+
+end # class Arborist::Node::Ack
+
+

data/lib/arborist/node/host.rb

@@ -19,7 +19,7 @@ class Arborist::Node::Host < Arborist::Node
 
 
 	### Create a new Host node.
-	def initialize( identifier, &block )
+	def initialize( identifier, attributes={}, &block )
 		@addresses = []
 		super
 	end
@@ -34,6 +34,22 @@ class Arborist::Node::Host < Arborist::Node
 	attr_reader :addresses
 
 
+	### Set one or more node +attributes+. Supported attributes (in addition to
+	### those supported by Node) are: +addresses+.
+	def modify( attributes )
+		attributes = stringify_keys( attributes )
+
+		super
+
+		if attributes['addresses']
+			self.addresses.clear
+			Array( attributes['addresses'] ).each do |addr|
+				self.address( addr )
+			end
+		end
+	end
+
+
 	### Return the host's operational attributes.
 	def operational_values
 		properties = super
@@ -42,7 +58,7 @@ class Arborist::Node::Host < Arborist::Node
 
 
 	### Set an IP address of the host.
-	def address( new_address, options={} )
+	def address( new_address )
 		self.log.debug "Adding address %p to %p" % [ new_address, self ]
 		case new_address
 		when IPAddr
@@ -72,16 +88,35 @@ class Arborist::Node::Host < Arborist::Node
 	end
 
 
-	### Add a service to the host
-	def service( name, options={}, &block )
-		return Arborist::Node.create( :service, name, self, options, &block )
-	end
-
-
 	### Return host-node-specific information for #inspect.
 	def node_description
 		return "{no addresses}" if self.addresses.empty?
 		return "{addresses: %s}" % [ self.addresses.map(&:to_s).join(', ') ]
 	end
 
+
+	#
+	# Serialization
+	#
+
+	### Return a Hash of the host node's state.
+	def to_h
+		return super.merge( addresses: self.addresses.map(&:to_s) )
+	end
+
+
+	### Marshal API -- set up the object's state using the +hash+ from a previously-marshalled
+	### node. Overridden to turn the addresses back into IPAddr objects.
+	def marshal_load( hash )
+		super
+		@addresses = hash[:addresses].map {|addr| IPAddr.new(addr) }
+	end
+
+
+	### Equality operator -- returns +true+ if +other_node+ is equal to the
+	### receiver. Overridden to also compare addresses.
+	def ==( other_host )
+		return super && other_host.addresses == self.addresses
+	end
+
 end # class Arborist::Node::Host

data/lib/arborist/node/resource.rb

@@ -0,0 +1,73 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'arborist/node'
+require 'arborist/mixins'
+
+
+# A node type for Arborist trees that represent arbitrary resources of a host.
+class Arborist::Node::Resource < Arborist::Node
+
+	# Services live under Host nodes
+	parent_type :host
+
+
+	### Create a new Resource node.
+	def initialize( identifier, host, attributes={}, &block )
+		raise Arborist::NodeError, "no host given" unless host.is_a?( Arborist::Node::Host )
+		qualified_identifier = "%s-%s" % [ host.identifier, identifier ]
+
+		@host = host
+
+		super( qualified_identifier, host, attributes, &block )
+	end
+
+
+	### Returns +true+ if the node matches the specified +key+ and +val+ criteria.
+	def match_criteria?( key, val )
+		self.log.debug "Matching %p: %p against %p" % [ key, val, self ]
+		return case key
+			when 'address'
+				search_addr = IPAddr.new( val )
+				self.addresses.any? {|a| search_addr.include?(a) }
+			else
+				super
+			end
+	end
+
+
+	### Return a Hash of the operational values that are included with the node's
+	### monitor state.
+	def operational_values
+		return super.merge(
+			addresses: self.addresses.map( &:to_s )
+		)
+	end
+
+
+	### Delegate the resources's address to its host.
+	def addresses
+		return @host.addresses
+	end
+
+
+	### Overridden to disallow modification of a Resource parent, as it needs a
+	### reference to the Host node for delegation.
+	def parent( new_parent=nil )
+		return super unless new_parent
+		raise "Can't reparent a resource; replace the node instead"
+	end
+
+
+	#
+	# Serialization
+	#
+
+	### Return a Hash of the host node's state.
+	def to_h
+		return super.merge(
+			addresses: self.addresses.map( &:to_s )
+		)
+	end
+
+end # class Arborist::Node::Resource

data/lib/arborist/node/root.rb

@@ -45,6 +45,12 @@ class Arborist::Node::Root < Arborist::Node
 	end
 
 
+	### Ignore restores of serialized root nodes.
+	def restore( other_node )
+		self.log.info "Ignoring restored root node."
+	end
+
+
 	### Ignore updates to the root node.
 	def update( properties )
 		self.log.warn "Update to the root node ignored."

data/lib/arborist/node/service.rb

@@ -6,31 +6,44 @@ require 'ipaddr'
 require 'socket'
 
 require 'arborist/node'
+require 'arborist/mixins'
 
 
 # A node type for Arborist trees that represent services running on hosts.
 class Arborist::Node::Service < Arborist::Node
+	include Arborist::HashUtilities
+
 
 	# The default transport layer protocol to use for services that don't specify
 	# one
 	DEFAULT_PROTOCOL = 'tcp'
 
 
-	### Create a new Service node.
-	def initialize( identifier, host, options={}, &block )
-		my_identifier = "%s-%s" % [ host.identifier, identifier ]
-		super( my_identifier )
-
-		@host = host
-		@parent = host.identifier
-		@app_protocol = options[:app_protocol] || identifier
-		@protocol = options[:protocol] || DEFAULT_PROTOCOL
+	# Services live under Host nodes
+	parent_type :host
 
-		service_port = options[:port] || default_port_for( @app_protocol, @protocol ) or
-			raise ArgumentError, "can't determine the port for %s/%s" % [ @app_protocol, @protocol ]
-		@port = Integer( service_port )
 
-		self.instance_eval( &block ) if block
+	### Create a new Service node.
+	def initialize( identifier, host, attributes={}, &block )
+		raise Arborist::NodeError, "no host given" unless host.is_a?( Arborist::Node::Host )
+		qualified_identifier = "%s-%s" % [ host.identifier, identifier ]
+
+		@host         = host
+		@app_protocol = nil
+		@protocol     = nil
+		@port         = nil
+
+		attributes[ :app_protocol ] ||= identifier
+		attributes[ :protocol ] ||= DEFAULT_PROTOCOL
+
+		super( qualified_identifier, host, attributes, &block )
+
+		unless @port
+			service_port = default_port_for( @app_protocol, @protocol ) or
+				raise ArgumentError, "can't determine the port for %s/%s" %
+					[ @app_protocol, @protocol ]
+			@port = Integer( service_port )
+		end
 	end
 
 
@@ -38,17 +51,37 @@ class Arborist::Node::Service < Arborist::Node
 	public
 	######
 
-	##
-	# The network port the service uses
-	attr_reader :port
+	### Set service +attributes+.
+	def modify( attributes )
+		attributes = stringify_keys( attributes )
+
+		super
+
+		self.port( attributes['port'] )
+		self.app_protocol( attributes['app_protocol'] )
+		self.protocol( attributes['protocol'] )
+	end
+
+
+	### Get/set the port the service is bound to.
+	def port( new_port=nil )
+		return @port unless new_port
+		@port = new_port
+	end
 
-	##
-	# The transport layer protocol the service uses
-	attr_reader :protocol
 
-	##
-	# The (layer 7) protocol used by the service
-	attr_reader :app_protocol
+	### Get/set the (layer 7) protocol used by the service
+	def app_protocol( new_proto=nil )
+		return @app_protocol unless new_proto
+		@app_protocol = new_proto
+	end
+
+
+	### Get/set the transport layer protocol the service uses
+	def protocol( new_proto=nil )
+		return @protocol unless new_proto
+		@protocol = new_proto
+	end
 
 
 	### Delegate the service's address to its host.
@@ -96,6 +129,40 @@ class Arborist::Node::Service < Arborist::Node
 	end
 
 
+	### Overridden to disallow modification of a Service's parent, as it needs a reference to
+	### the Host node for delegation.
+	def parent( new_parent=nil )
+		return super unless new_parent
+		raise "Can't reparent a service; replace the node instead"
+	end
+
+
+	#
+	# Serialization
+	#
+
+	### Return a Hash of the host node's state.
+	def to_h
+		return super.merge(
+			addresses: self.addresses.map(&:to_s),
+			protocol: self.protocol,
+			app_protocol: self.app_protocol,
+			port: self.port
+		)
+	end
+
+
+	### Equality operator -- returns +true+ if +other_node+ is equal to the
+	### receiver. Overridden to also compare addresses.
+	def ==( other_host )
+		return super &&
+			other_host.addresses == self.addresses &&
+			other_host.protocol == self.protocol &&
+			other_host.app_protocol == self.app_protocol &&
+			other_host.port == self.port
+	end
+
+
 	#######
 	private
 	#######

data/lib/arborist/observer.rb

@@ -28,7 +28,7 @@ class Arborist::Observer
 	OBSERVER_FILE_PATTERN = '**/*.rb'
 
 
-	Arborist.add_dsl_constructor( :Observer ) do |description, &block|
+	Arborist.add_dsl_constructor( self ) do |description, &block|
 		Arborist::Observer.new( description, &block )
 	end
 

data/lib/arborist/subscription.rb

@@ -20,8 +20,9 @@ class Arborist::Subscription
 
 	### Instantiate a new Subscription object given an +event+ pattern
 	### and event +criteria+.
-	def initialize( publisher, event_type=nil, criteria={} )
-		@publisher  = publisher
+	def initialize( event_type=nil, criteria={}, &callback )
+		raise LocalJumpError, "requires a callback block" unless callback
+		@callback   = callback
 		@event_type = event_type
 		@criteria   = stringify_keys( criteria )
 		@id         = self.generate_id
@@ -32,8 +33,8 @@ class Arborist::Subscription
 	public
 	######
 
-	# The Arborist::Manager::EventPublisher the subscription will use to publish matching events.
-	attr_reader :publisher
+	# The callable that should be called when the subscription receives a matching event
+	attr_reader :callback
 
 	# A unique identifier for this subscription request.
 	attr_reader :id
@@ -54,7 +55,10 @@ class Arborist::Subscription
 	### 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 )
+			if self.interested_in?( event )
+				self.log.debug "Calling %p for a %s event" % [ self.callback, event.type ]
+				self.callback.call( self.id, event )
+			end
 		end
 	end
 
@@ -70,12 +74,13 @@ class Arborist::Subscription
 
 	### Return a String representation of the object suitable for debugging.
 	def inspect
-		return "#<%p:%#x [%s] for %s events matching: %p>" % [
+		return "#<%p:%#x [%s] for %s events matching: %p -> %p>" % [
 			self.class,
 			self.object_id * 2,
 			self.id,
 			self.event_type,
 			self.criteria,
+			self.callback,
 		]
 	end
 

data/spec/arborist/client_spec.rb

@@ -64,6 +64,20 @@ describe Arborist::Client do
 		end
 
 
+		it "can list a depth-limited subtree of the node of the managed it's connected to" do
+			res = client.list( depth: 2 )
+			expect( res ).to be_an( Array )
+			expect( res.length ).to eq( 8 )
+		end
+
+
+		it "can list a depth-limited subtree of the nodes of the manager it's connected to" do
+			res = client.list( from: 'duir', depth: 1 )
+			expect( res ).to be_an( Array )
+			expect( res.length ).to eq( 5 )
+		end
+
+
 		it "can fetch all node properties for all 'up' nodes" do
 			res = client.fetch
 			expect( res ).to be_a( Hash )
@@ -97,6 +111,18 @@ describe Arborist::Client do
 		end
 
 
+		it "can fetch all node properties for 'up' nodes that don't match specified criteria" do
+			res = client.fetch( {}, properties: [:addresses, :status], exclude: {tag: 'testing'} )
+
+			testing_nodes = manager.nodes.values.select {|n| n.tags.include?('testing') }
+
+			expect( res ).to be_a( Hash )
+			expect( res ).to_not be_empty()
+			expect( res.length ).to eq( manager.nodes.length - testing_nodes.length )
+			expect( res.values ).to all( be_a(Hash) )
+		end
+
+
 		it "can fetch all properties for all nodes regardless of their status" do
 			# Down a node
 			manager.nodes['duir'].update( error: 'something happened' )
@@ -110,8 +136,9 @@ describe Arborist::Client do
 
 
 		it "can update the properties of managed nodes", :no_ci do
-			client.update( duir: { ping: {rtt: 24} } )
+			res = client.update( duir: { ping: {rtt: 24} } )
 
+			expect( res ).to be_truthy
 			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 )
@@ -190,6 +217,66 @@ describe Arborist::Client do
 			expect( sub.event_type ).to eq( nil )
 		end
 
+
+		it "can unsubscribe from events using a subscription ID" do
+			sub_id = client.subscribe
+			res = client.unsubscribe( sub_id )
+			expect( res ).to be_truthy
+			expect( manager.subscriptions ).to_not include( sub_id )
+		end
+
+
+		it "returns nil without error when unsubscribing to a non-existant subscription" do
+			res = client.unsubscribe( 'a_subid' )
+			expect( res ).to be_nil
+		end
+
+
+		it "can prune nodes from the tree" do
+			res = client.prune( 'sidonie-ssh' )
+
+			expect( res ).to eq( true )
+			expect( manager.nodes ).to_not include( 'sidonie-ssh' )
+		end
+
+
+		it "returns nil without error when pruning a node that doesn't exist" do
+			res = client.prune( 'carrigor' )
+			expect( res ).to be_nil
+		end
+
+
+		it "can graft new nodes onto the tree" do
+			res = client.graft( 'breakfast-burrito', type: 'host' )
+			expect( res ).to eq( 'breakfast-burrito' )
+			expect( manager.nodes ).to include( 'breakfast-burrito' )
+			expect( manager.nodes['breakfast-burrito'] ).to be_a( Arborist::Node::Host )
+			expect( manager.nodes['breakfast-burrito'].parent ).to eq( '_' )
+		end
+
+
+		it "can graft nodes with attributes onto the tree" do
+			res = client.graft( 'breakfast-burrito',
+				type: 'service',
+				parent: 'duir',
+				port: 9999,
+				tags: ['yusss']
+			)
+			expect( res ).to eq( 'duir-breakfast-burrito' )
+			expect( manager.nodes ).to include( 'duir-breakfast-burrito' )
+			expect( manager.nodes['duir-breakfast-burrito'] ).to be_a( Arborist::Node::Service )
+			expect( manager.nodes['duir-breakfast-burrito'].parent ).to eq( 'duir' )
+			expect( manager.nodes['duir-breakfast-burrito'].port ).to eq( 9999 )
+			expect( manager.nodes['duir-breakfast-burrito'].tags ).to include( 'yusss' )
+		end
+
+
+		it "can modify operational attributes of a node" do
+			res = client.modify( "duir", tags: 'girlrobot' )
+			expect( res ).to be_truthy
+			expect( manager.nodes['duir'].tags ).to eq( ['girlrobot'] )
+		end
+
 	end
 
 
@@ -236,7 +323,7 @@ describe Arborist::Client do
 			expect( msg.first['version'] ).to eq( Arborist::Client::API_VERSION )
 			expect( msg.first['action'] ).to eq( 'fetch' )
 
-			expect( msg.last ).to eq( {} )
+			expect( msg.last ).to eq([ {}, {} ])
 		end
 
 
@@ -252,9 +339,10 @@ describe Arborist::Client do
 			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' )
+			body = msg.last
+			expect( body.first ).to be_a( Hash )
+			expect( body.first ).to include( 'type' )
+			expect( body.first['type'] ).to eq( 'host' )
 		end