arborist 0.0.1.pre20160128152542 → 0.0.1.pre20160606141735

data/lib/arborist/manager/event_publisher.rb

@@ -41,7 +41,7 @@ class Arborist::Manager::EventPublisher < ZMQ::Handler
 
 	### Publish the specified +event+.
 	def publish( identifier, event )
-		@event_queue << [ identifier, MessagePack.pack(event.to_hash) ]
+		@event_queue << [ identifier, MessagePack.pack(event.to_h) ]
 		self.register
 		return self
 	end

data/lib/arborist/manager/tree_api.rb

@@ -43,7 +43,15 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 		self.log.error "%p: %s" % [ err.class, err.message ]
 		err.backtrace.each {|frame| self.log.debug "  #{frame}" }
 
-		errtype = err.is_a?( Arborist::RequestError ) ? 'client' : 'server'
+		errtype = case err
+			when Arborist::RequestError,
+			     Arborist::ConfigError,
+			     Arborist::NodeError
+				'client'
+			else
+				'server'
+			end
+
 		return self.error_response( errtype, err.message )
 	end
 
@@ -116,8 +124,9 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 		raise Arborist::RequestError, "missing required header 'action'" unless
 			header.key?( 'action' )
 
-		raise Arborist::RequestError, "body must be a Map or Nil" unless
-			body.is_a?( Hash ) || body.nil?
+		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
@@ -125,7 +134,7 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 
 	### Return a response to the `status` action.
 	def handle_status_request( header, body )
-		self.log.info "STATUS: %p" % [ header ]
+		self.log.debug "STATUS: %p" % [ header ]
 		return successful_response(
 			server_version: Arborist::VERSION,
 			state: @manager.running? ? 'running' : 'not running',
@@ -137,7 +146,7 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 
 	### Return a response to the `subscribe` action.
 	def handle_subscribe_request( header, body )
-		self.log.info "SUBSCRIBE: %p" % [ header ]
+		self.log.debug "SUBSCRIBE: %p" % [ header ]
 		event_type      = header[ 'event_type' ]
 		node_identifier = header[ 'identifier' ]
 		subscription    = @manager.create_subscription( node_identifier, event_type, body )
@@ -148,7 +157,7 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 
 	### Return a response to the `unsubscribe` action.
 	def handle_unsubscribe_request( header, body )
-		self.log.info "UNSUBSCRIBE: %p" % [ header ]
+		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
@@ -163,13 +172,20 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 
 	### Return a repsonse to the `list` action.
 	def handle_list_request( header, body )
-		self.log.info "LIST: %p" % [ header ]
-		from = header['from'] || '_'
+		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 = @manager.enumerator_for( start_node )
-		data = iter.map( &:to_hash )
+		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 )
@@ -178,7 +194,7 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 
 	### Return a response to the 'fetch' action.
 	def handle_fetch_request( header, body )
-		self.log.info "FETCH: %p" % [ header ]
+		self.log.debug "FETCH: %p" % [ header ]
 
 		include_down = header['include_down']
 		values = if header.key?( 'return' )
@@ -186,7 +202,11 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 			else
 				nil
 			end
-		states = @manager.fetch_matching_node_states( body, values, include_down )
+
+		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
@@ -194,7 +214,7 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 
 	### Update nodes using the data from the update request's +body+.
 	def handle_update_request( header, body )
-		self.log.info "UPDATE: %p" % [ header ]
+		self.log.debug "UPDATE: %p" % [ header ]
 
 		body.each do |identifier, properties|
 			@manager.update_node( identifier, properties )
@@ -203,5 +223,64 @@ class Arborist::Manager::TreeAPI < ZMQ::Handler
 		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
+
 end # class Arborist::Manager::TreeAPI
 

data/lib/arborist/mixins.rb

@@ -358,6 +358,23 @@ module Arborist
 		end
 
 
+		### Returns true if the specified +hash+ includes the specified +key+, and the value
+		### associated with the +key+ either includes +val+ if it is a Hash, or equals +val+ if it's
+		### anything but a Hash.
+		def hash_matches( hash, key, val )
+			actual = hash[ key ] or return false
+
+			if actual.is_a?( Hash )
+				if val.is_a?( Hash )
+					return val.all? {|subkey, subval| hash_matches(actual, subkey, subval) }
+				else
+					return false
+				end
+			else
+				return actual == val
+			end
+		end
+
 	end # HashUtilities
 
 end # module Arborist

data/lib/arborist/monitor.rb

@@ -35,7 +35,7 @@ class Arborist::Monitor
 	DEFAULT_SPLAY = 0
 
 
-	Arborist.add_dsl_constructor( :Monitor ) do |description, &block|
+	Arborist.add_dsl_constructor( self ) do |description, &block|
 		Arborist::Monitor.new( description, &block )
 	end
 
@@ -250,6 +250,15 @@ class Arborist::Monitor
 		parent_writer.close
 
 		return context.handle_results( pid, parent_reader, parent_err_reader )
+	rescue SystemCallError => err
+		self.log.error "%p while running external monitor command `%s`: %s" % [
+			err.class,
+			Shellwords.join( command ),
+			err.message
+		]
+		self.log.debug "  %s" % [ err.backtrace.join("\n  ") ]
+		return {}
+
 	ensure
 		if pid
 			begin

data/lib/arborist/monitor/socket.rb

@@ -3,6 +3,7 @@
 
 require 'loggability'
 require 'timeout'
+require 'socket'
 
 require 'arborist/monitor' unless defined?( Arborist::Monitor )
 
@@ -12,7 +13,6 @@ using Arborist::TimeRefinements
 # Socket-related Arborist monitor logic
 module Arborist::Monitor::Socket
 
-
 	# Arborist TCP socket monitor logic
 	class TCP
 		extend Loggability
@@ -119,6 +119,8 @@ module Arborist::Monitor::Socket
 			until connections.empty? || timeout_at.past?
 				self.log.debug "Waiting on %d connections for %0.3ds..." %
 					[ connections.values.length, timeout_at - Time.now ]
+
+				# :FIXME: Race condition: errors if timeout_at - Time.now is 0
 				_, ready, _ = IO.select( nil, connections.keys, nil, timeout_at - Time.now )
 
 				self.log.debug "  select returned: %p" % [ ready ]
@@ -154,10 +156,129 @@ module Arborist::Monitor::Socket
 
 			return results
 		end
-
 	end # class TCP
 
 
+	# Arborist UDP socket monitor logic
+	class UDP
+		extend Loggability
+		log_to :arborist
+
+
+		# Defaults for instances of this monitor
+		DEFAULT_OPTIONS = {
+			timeout: 0.001
+		}
+
+
+		### Instantiate a monitor check and run it for the specified +nodes+.
+		def self::run( nodes )
+			return self.new.run( nodes )
+		end
+
+
+		### Create a new UDP monitor with the specified +options+. Valid options are:
+		###
+		### +:timeout+
+		###   Set the number of seconds to wait for a connection for each node.
+		def initialize( options=DEFAULT_OPTIONS )
+			options = DEFAULT_OPTIONS.merge( options || {} )
+
+			options.each do |name, value|
+				self.public_send( "#{name}=", value )
+			end
+		end
+
+
+		######
+		public
+		######
+
+		# The timeout for connecting, in seconds.
+		attr_accessor :timeout
+
+
+		### Run the UDP check for each of the specified Hash of +nodes+ and return a Hash of
+		### updates for them based on trying to connect to them.
+		def run( nodes )
+			self.log.debug "Got nodes to UDP check: %p" % [ nodes ]
+
+			connections = self.make_connections( nodes )
+			return self.wait_for_connections( connections )
+		end
+
+
+		### Open a socket for each of the specified nodes and return a Hash of
+		### the sockets (or the error from the connection attempt) keyed by
+		### node identifier.
+		def make_connections( nodes )
+			return nodes.each_with_object( {} ) do |(identifier, node_data), accum|
+
+				address = node_data['addresses'].first
+				port = node_data['port']
+
+				self.log.debug "Creating UDP connection for %s:%d" % [ address, port ]
+				sock = Socket.new( :INET, :DGRAM )
+
+				conn = begin
+					sockaddr = Socket.sockaddr_in( port, address )
+					sock.connect( sockaddr )
+					sock.send( '', 0 )
+					sock
+				rescue SocketError => err
+					self.log.error "  %p setting up connection: %s" % [ err.class, err.message ]
+					err
+				end
+
+				accum[ conn ] = [ identifier, sock ]
+			end
+		end
+
+
+		### For any elements of +connections+ that are sockets, wait on them to complete or error
+		### and then return a Hash of node updates keyed by identifier based on the results.
+		def wait_for_connections( connections )
+			results = {}
+			start = Time.now
+
+			# First strip out all the ones that failed in the first #connect
+			connections.delete_if do |sock, (identifier, _)|
+				next false if sock.respond_to?( :recvfrom_nonblock ) # Keep sockets
+				self.log.debug "  removing connect error for node %s" % [ identifier ]
+				results[ identifier ] = { error: sock.message }
+			end
+
+			# Test all connections
+			connections.each do |sock, (identifier, _)|
+				begin
+					sock.recvfrom_nonblock( 1 )
+
+				rescue IO::WaitReadable
+					ready, _, _ = IO.select( [sock], [], [], self.timeout )
+					if ready.nil?
+						now = Time.now
+						results[ identifier ] = {
+							udp_socket_connect: { time: now.to_s, duration: now - start }
+						}
+						self.log.debug "  connection successful"
+					else
+						retry
+					end
+
+				rescue SocketError, SystemCallError => err
+					self.log.debug "%p during connection: %s" % [ err.class, err.message ]
+					results[ identifier ] = { error: err.message }
+
+				ensure
+					sock.close
+				end
+			end
+
+			return results
+		end
+	end # class UDP
+
+
 end # module Arborist::Monitor::Socket
 
 

data/lib/arborist/monitor_runner.rb

@@ -62,12 +62,12 @@ class Arborist::MonitorRunner
 
 		### Run the specified +monitor+ and update nodes with the results.
 		def run_monitor( monitor )
-			criteria     = monitor.positive_criteria
+			positive     = monitor.positive_criteria
+			negative     = monitor.negative_criteria
 			include_down = monitor.include_down?
 			props        = monitor.node_properties
 
-			self.fetch( criteria, include_down, props ) do |nodes|
-				# :FIXME: Doesn't apply negative criteria
+			self.fetch( positive, include_down, props, negative ) do |nodes|
 				results = monitor.run( nodes )
 				self.update( results ) do
 					self.log.debug "Updated %d via the '%s' monitor" %
@@ -79,10 +79,11 @@ class Arborist::MonitorRunner
 
 		### Create a fetch request using the runner's client, then queue the request up
 		### with the specified +block+ as the callback.
-		def fetch( criteria, include_down, properties, &block )
+		def fetch( criteria, include_down, properties, negative={}, &block )
 			fetch = self.client.make_fetch_request( criteria,
 				include_down: include_down,
-				properties: properties
+				properties: properties,
+				exclude: negative
 			)
 			self.queue_request( fetch, &block )
 		end

data/lib/arborist/node.rb

@@ -11,6 +11,8 @@ require 'loggability'
 require 'pluggability'
 require 'arborist' unless defined?( Arborist )
 require 'arborist/mixins'
+require 'arborist/exceptions'
+require 'arborist/dependency'
 
 using Arborist::TimeRefinements
 
@@ -24,37 +26,76 @@ class Arborist::Node
 	       Arborist::MethodUtilities
 
 
-	##
 	# The key for the thread local that is used to track instances as they're
 	# loaded.
 	LOADED_INSTANCE_KEY = :loaded_node_instances
 
+	# Regex to match a valid identifier
+	VALID_IDENTIFIER = /^\w[\w\-]*$/
 
-	##
-	# The struct for the 'ack' operational property
-	ACK = Struct.new( 'ArboristNodeACK', :message, :via, :sender, :time )
 
-	##
-	# The keys required to be set for an ACK
-	ACK_REQUIRED_PROPERTIES = %w[ message sender ]
+	autoload :Root, 'arborist/node/root'
+	autoload :Ack, 'arborist/node/ack'
 
 
-	##
 	# Log via the Arborist logger
 	log_to :arborist
 
-	##
 	# Search for plugins in lib/arborist/node directories in loaded gems
 	plugin_prefixes 'arborist/node'
 
 
+	##
+	# :method: unknown?
+	# Returns +true+ if the node is in an 'unknown' state.
+
+	##
+	# :method: up?
+	# Returns +true+ if the node is in an 'up' state.
+
+	##
+	# :method: down?
+	# Returns +true+ if the node is in an 'down' state.
+
+	##
+	# :method: acked?
+	# Returns +true+ if the node is in an 'acked' state.
+
+	##
+	# :method: disabled?
+	# Returns +true+ if the node is in an 'disabled' state.
+
+	##
+	# :method: human_status_name
+	# Return the node's status as a human-readable String.
+
+	##
+	# :method: status
+	# Return the +status+ of the node. This will be one of: +unknown+, +up+, +down+, +acked+, or
+	# +disabled+.
+
+	##
+	# :method: status=
+	# :call-seq:
+	#   status=( new_status )
+	#
+	# Set the status of the node to +new_status+.
+
+	##
+	# :method: status?
+	# :call-seq:
+	#   status?( status_name )
+	#
+	# Returns +true+ if the node's status is +status_name+.
+
 	state_machine( :status, initial: :unknown ) do
 
 		state :unknown,
 			:up,
 			:down,
 			:acked,
-			:disabled
+			:disabled,
+			:quieted
 
 		event :update do
 			transition [:down, :unknown, :acked] => :up, if: :last_contact_successful?
@@ -64,14 +105,24 @@ class Arborist::Node
 			transition :disabled => :unknown, unless: :ack_set?
 		end
 
+		event :handle_event do
+			transition :unknown => :acked, if: :ack_and_error_set?
+			transition any - [:disabled, :quieted, :acked] => :quieted, if: :has_quieted_reason?
+			transition :quieted => :unknown, unless: :has_quieted_reason?
+		end
+
 		after_transition any => :acked, do: :on_ack
 		after_transition :acked => :up, do: :on_ack_cleared
 		after_transition :down => :up, do: :on_node_up
 		after_transition [:unknown, :up] => :down, do: :on_node_down
 		after_transition [:unknown, :up] => :disabled, do: :on_node_disabled
+		after_transition any => :quieted, do: :on_node_quieted
 		after_transition :disabled => :unknown, do: :on_node_enabled
+		after_transition :quieted => :unknown, do: :on_node_unquieted
 
 		after_transition any => any, do: :log_transition
+		after_transition any => any, do: :make_transition_event
+		after_transition any => any, do: :update_status_changed
 
 		after_transition do: :add_status_to_update_delta
 	end
@@ -79,7 +130,11 @@ class Arborist::Node
 
 	### Return a curried Proc for the ::create method for the specified +type+.
 	def self::curried_create( type )
-		return self.method( :create ).to_proc.curry( 2 )[ type ]
+		if type.subnode_type?
+			return self.method( :create ).to_proc.curry( 3 )[ type ]
+		else
+			return self.method( :create ).to_proc.curry( 2 )[ type ]
+		end
 	end
 
 
@@ -113,14 +168,46 @@ class Arborist::Node
 	def self::inherited( subclass )
 		super
 
-		if name = subclass.name
-			name.sub!( /.*::/, '' )
-			body = self.curried_create( subclass )
-			Arborist.add_dsl_constructor( name, &body )
-		else
-			self.log.info "Skipping DSL constructor for anonymous class."
+		body = self.curried_create( subclass )
+		Arborist.add_dsl_constructor( subclass, &body )
+	end
+
+
+	### Get/set the node type instances of the class live under. If no parent_type is set, it
+	### is a top-level node type.
+	def self::parent_types( *types )
+		@parent_types ||= []
+
+		types.each do |new_type|
+			subclass = Arborist::Node.get_subclass( new_type )
+			@parent_types << subclass
+			subclass.add_subnode_factory_method( self )
 		end
 
+		return @parent_types
+	end
+	singleton_method_alias :parent_type, :parent_types
+
+
+	### Returns +true+ if the receiver must be created under a specific node type.
+	def self::subnode_type?
+		return ! self.parent_types.empty?
+	end
+
+
+	### Add a factory method that can be used to create subnodes of the specified +subnode_type+
+	### on instances of the receiving class.
+	def self::add_subnode_factory_method( subnode_type )
+		if subnode_type.name
+			name = subnode_type.plugin_name
+			body = lambda do |identifier, attributes={}, &block|
+				return Arborist::Node.create( name, identifier, self, attributes, &block )
+			end
+
+			define_method( name, &body )
+		else
+			self.log.info "Skipping factory constructor for anonymous subnode class."
+		end
 	end
 
 
@@ -150,31 +237,42 @@ class Arborist::Node
 
 	### Create a new Node with the specified +identifier+, which must be unique to the
 	### loaded tree.
-	def initialize( identifier, &block )
-		raise "Invalid identifier %p" % [identifier] unless
-			identifier =~ /^\w[\w\-]*$/
+	def initialize( identifier, *args, &block )
+		attributes  = args.last.is_a?( Hash ) ? args.pop : {}
+		parent_node = args.pop
 
-		@identifier     = identifier
-		@parent         = '_'
-		@description    = nil
-		@tags           = Set.new
-		@source         = nil
-		@children       = {}
-
-		@status         = 'unknown'
-		@status_changed = Time.at( 0 )
-
-		@error          = nil
-		@ack            = nil
-		@properties     = {}
-		@last_contacted = Time.at( 0 )
-
-		@update_delta   = Hash.new do |h,k|
+		raise "Invalid identifier %p" % [identifier] unless
+			identifier =~ VALID_IDENTIFIER
+
+		# Attributes of the target
+		@identifier      = identifier
+		@parent          = parent_node ? parent_node.identifier : '_'
+		@description     = nil
+		@tags            = Set.new
+		@properties      = {}
+		@source          = nil
+		@children        = {}
+		@dependencies    = Arborist::Dependency.new( :all )
+
+		# Primary state
+		@status          = 'unknown'
+		@status_changed  = Time.at( 0 )
+
+		# Attributes that govern state
+		@error           = nil
+		@ack             = nil
+		@last_contacted  = Time.at( 0 )
+		@quieted_reasons = {}
+
+		# Event-handling
+		@update_delta    = Hash.new do |h,k|
 			h[ k ] = Hash.new( &h.default_proc )
 		end
 		@pending_update_events = []
 		@subscriptions  = {}
 
+		self.log.debug "Setting node attributes to: %p" % [ attributes ]
+		self.modify( attributes )
 		self.instance_eval( &block ) if block
 	end
 
@@ -228,6 +326,16 @@ class Arborist::Node
 	# subscription ID.
 	attr_reader :subscriptions
 
+	##
+	# The node's secondary dependencies, expressed as an Arborist::Node::Sexp
+	attr_accessor :dependencies
+
+
+	##
+	# The reasons this node was quieted. This is a Hash of text descriptions keyed by the
+	# type of dependency it came from (either :primary or :secondary).
+	attr_reader :quieted_reasons
+
 
 	### Set the source of the node to +source+, which should be a valid URI.
 	def source=( source )
@@ -235,6 +343,23 @@ class Arborist::Node
 	end
 
 
+	### Set one or more node +attributes+. This should be overridden by subclasses which
+	### wish to allow their operational attributes to be set/updated via the Tree API
+	### (+modify+ and +graft+). Supported attributes are: +parent+, +description+, and
+	### +tags+.
+	def modify( attributes )
+		attributes = stringify_keys( attributes )
+
+		self.parent( attributes['parent'] )
+		self.description( attributes['description'] )
+
+		if attributes['tags']
+			@tags.clear
+			self.tags( attributes['tags'] )
+		end
+	end
+
+
 	#
 	# :section: DSLish declaration methods
 	# These methods are both getter and setter for a node's attributes, used
@@ -263,11 +388,40 @@ class Arborist::Node
 
 	### Declare one or more +tags+ for this node.
 	def tags( *tags )
+		tags.flatten!
 		@tags.merge( tags.map(&:to_s) ) unless tags.empty?
 		return @tags.to_a
 	end
 
 
+	### Group +identifiers+ together in an 'any of' dependency.
+	def any_of( *identifiers, on: nil )
+		return Arborist::Dependency.on( :any, *identifiers, prefixes: on )
+	end
+
+
+	### Group +identifiers+ together in an 'all of' dependency.
+	def all_of( *identifiers, on: nil )
+		return Arborist::Dependency.on( :all, *identifiers, prefixes: on )
+	end
+
+
+	### Add secondary dependencies to the receiving node.
+	def depends_on( *dependencies, on: nil )
+		dependencies = self.all_of( *dependencies, on: on )
+
+		self.log.debug "Setting secondary dependencies to: %p" % [ dependencies ]
+		self.dependencies = check_dependencies( dependencies )
+	end
+
+
+	### Returns +true+ if the node has one or more secondary dependencies.
+	def has_dependencies?
+		return !self.dependencies.empty?
+	end
+
+
+
 	#
 	# :section: Manager API
 	# Methods used by the manager to manage its nodes.
@@ -299,14 +453,6 @@ class Arborist::Node
 	end
 
 
-	### Publish the specified +events+ to any subscriptions the node has which match them.
-	def publish_events( *events )
-		self.subscriptions.each_value do |sub|
-			sub.on_events( *events )
-		end
-	end
-
-
 	### Update specified +properties+ for the node.
 	def update( new_properties )
 		new_properties = stringify_keys( new_properties )
@@ -329,6 +475,7 @@ class Arborist::Node
 		events << self.make_update_event
 		events << self.make_delta_event unless self.update_delta.empty?
 
+		self.broadcast_events( *events )
 		return events
 	ensure
 		self.update_delta.clear
@@ -397,6 +544,8 @@ class Arborist::Node
 	### Returns +true+ if the node matches the specified +key+ and +val+ criteria.
 	def match_criteria?( key, val )
 		return case key
+			when 'delta'
+				true
 			when 'status'
 				self.status == val
 			when 'type'
@@ -440,6 +589,129 @@ class Arborist::Node
 	end
 
 
+	### Register subscriptions for secondary dependencies on the receiving node with the
+	### given +manager+.
+	def register_secondary_dependencies( manager )
+		self.dependencies.all_identifiers.each do |identifier|
+			# Check to be sure the identifier isn't a descendant or ancestor
+			if manager.ancestors_for( self ).any? {|node| node.identifier == identifier}
+				raise Arborist::ConfigError, "Can't depend on ancestor node %p." % [ identifier ]
+			elsif manager.descendants_for( self ).any? {|node| node.identifier == identifier }
+				raise Arborist::ConfigError, "Can't depend on descendant node %p." % [ identifier ]
+			end
+
+			sub = Arborist::Subscription.new do |_, event|
+				self.handle_event( event )
+			end
+			manager.subscribe( identifier, sub )
+		end
+	end
+
+
+	### Publish the specified +events+ to any subscriptions the node has which match them.
+	def publish_events( *events )
+		self.log.debug "Got published events: %p" % [ events ]
+		self.subscriptions.each_value do |sub|
+			sub.on_events( *events )
+		end
+	end
+
+
+	### Send an event to this node's immediate children.
+	def broadcast_events( *events )
+		events.flatten!
+		self.children.each do |identifier, child|
+			self.log.debug "Broadcasting %d events to %p" % [ events.length, identifier ]
+			events.each do |event|
+				child.handle_event( event )
+			end
+		end
+	end
+
+
+	### Handle the specified +event+, delivered either via broadcast or secondary
+	### dependency subscription.
+	def handle_event( event )
+		self.log.debug "Handling %p" % [ event ]
+		handler_name = "handle_%s_event" % [ event.type.gsub('.', '_') ]
+		if self.respond_to?( handler_name )
+			self.log.debug "Handling a %s event." % [ event.type ]
+			self.method( handler_name ).call( event )
+		end
+		super
+	end
+
+
+	### Returns +true+ if this node's dependencies are not met.
+	def dependencies_down?
+		return self.dependencies.down?
+	end
+	alias_method :has_downed_dependencies?, :dependencies_down?
+
+
+	### Returns +true+ if this node's dependencies are met.
+	def dependencies_up?
+		return !self.dependencies_down?
+	end
+
+
+	### Returns +true+ if any reasons have been set as to why the node has been
+	### quieted. Guard condition for transition to and from `quieted` state.
+	def has_quieted_reason?
+		return !self.quieted_reasons.empty?
+	end
+
+
+	### Handle a 'node.down' event received via broadcast.
+	def handle_node_down_event( event )
+		self.log.debug "Got a node.down event: %p" % [ event ]
+		self.dependencies.mark_down( event.node.identifier )
+
+		if self.dependencies_down?
+			self.quieted_reasons[ :secondary ] = "Secondary dependencies not met: %s" %
+				[ self.dependencies.down_reason ]
+		end
+
+		if event.node.identifier == self.parent
+			self.quieted_reasons[ :primary ] = "Parent down: %s" % [ self.parent ] # :TODO: backtrace?
+		end
+	end
+
+
+	### Handle a 'node.quieted' event received via broadcast.
+	def handle_node_quieted_event( event )
+		self.log.debug "Got a node.quieted event: %p" % [ event ]
+		self.dependencies.mark_down( event.node.identifier )
+
+		if self.dependencies_down?
+			self.quieted_reasons[ :secondary ] = "Secondary dependencies not met: %s" %
+				[ self.dependencies.down_reason ]
+		end
+
+		if event.node.identifier == self.parent
+			self.quieted_reasons[ :primary ] = "Parent quieted: %s" % [ self.parent ] # :TODO: backtrace?
+		end
+	end
+
+
+	### Handle a 'node.up' event received via broadcast.
+	def handle_node_up_event( event )
+		self.log.debug "Got a node.up event: %p" % [ event ]
+
+		self.dependencies.mark_up( event.node.identifier )
+		self.quieted_reasons.delete( :secondary ) if self.dependencies_up?
+
+		if event.node.identifier == self.parent
+			self.log.info "Parent of %s (%s) came back up." % [
+				self.identifier,
+				self.parent
+			]
+			self.quieted_reasons.delete( :primary )
+		end
+	end
+
+
+
 	#
 	# :section: Hierarchy API
 	#
@@ -490,15 +762,26 @@ class Arborist::Node
 	# :section: Utility methods
 	#
 
+
+	### Return a description of the ack if it's set, or a generic string otherwise.
+	def acked_description
+		return self.ack.description if self.ack
+		return "(unset)"
+	end
+
+
 	### Return a string describing the node's status.
 	def status_description
 		case self.status
 		when 'up', 'down'
 			return "%s as of %s" % [ self.status.upcase, self.last_contacted ]
 		when 'acked'
-			return "ACKed by %s %s" % [ self.ack.sender, self.ack.time.as_delta ]
+			return "ACKed %s" % [ self.acked_description ]
 		when 'disabled'
-			return "disabled by %s %s" % [ self.ack.sender, self.ack.time.as_delta ]
+			return "disabled %s" % [ self.acked_description ]
+		when 'quieted'
+			reasons = self.quieted_reasons.values.join( ',' )
+			return "quieted: %s" % [ reasons ]
 		else
 			return "in an unknown state"
 		end
@@ -514,7 +797,7 @@ class Arborist::Node
 
 	### Return a String representation of the object suitable for debugging.
 	def inspect
-		return "#<%p:%#x [%s] -> %s %p %s%s, %d children, %s>" % [
+		return "#<%p:%#x [%s] -> %s %p %s %s, %d children, %s>" % [
 			self.class,
 			self.object_id * 2,
 			self.identifier,
@@ -532,52 +815,78 @@ class Arborist::Node
 	# :section: Serialization API
 	#
 
+	### Restore any saved state from the +old_node+ loaded from the state file.
+	def restore( old_node )
+		@status          = old_node.status
+		@properties      = old_node.properties.dup
+		@ack             = old_node.ack.dup if old_node.ack
+		@last_contacted  = old_node.last_contacted
+		@status_changed  = old_node.status_changed
+		@error           = old_node.error
+		@quieted_reasons = old_node.quieted_reasons
+
+		# Only merge in downed dependencies.
+		old_node.dependencies.each_downed do |identifier, time|
+			@dependencies.mark_down( identifier, time )
+		end
+	end
+
+
 	### Return a Hash of the node's state.
-	def to_hash
+	def to_h
 		return {
 			identifier: self.identifier,
 			type: self.class.name.to_s.sub( /.+::/, '' ).downcase,
 			parent: self.parent,
 			description: self.description,
 			tags: self.tags,
-			properties: self.properties.dup,
 			status: self.status,
+			properties: self.properties.dup,
 			ack: self.ack ? self.ack.to_h : nil,
 			last_contacted: self.last_contacted ? self.last_contacted.iso8601 : nil,
 			status_changed: self.status_changed ? self.status_changed.iso8601 : nil,
 			error: self.error,
+			dependencies: self.dependencies.to_h,
+			quieted_reasons: self.quieted_reasons,
 		}
 	end
 
 
 	### Marshal API -- return the node as an object suitable for marshalling.
 	def marshal_dump
-		return self.to_hash
+		return self.to_h.merge( dependencies: self.dependencies )
 	end
 
 
 	### Marshal API -- set up the object's state using the +hash+ from a
 	### previously-marshalled node.
 	def marshal_load( hash )
-		@identifier = hash[:identifier]
-		@properties = hash[:properties]
+		@identifier      = hash[:identifier]
+		@properties      = hash[:properties]
 
-		@parent         = hash[:parent]
-		@description    = hash[:description]
-		@tags           = Set.new( hash[:tags] )
-		@children       = {}
+		@parent          = hash[:parent]
+		@description     = hash[:description]
+		@tags            = Set.new( hash[:tags] )
+		@children        = {}
 
-		@status         = hash[:status]
-		@status_changed = Time.parse( hash[:status_changed] )
+		@status          = 'unknown'
+		@status_changed  = Time.parse( hash[:status_changed] )
 
-		@error          = hash[:error]
-		@properties     = hash[:properties]
-		@last_contacted = Time.parse( hash[:last_contacted] )
+		@error           = hash[:error]
+		@properties      = hash[:properties] || {}
+		@last_contacted  = Time.parse( hash[:last_contacted] )
+		@quieted_reasons = hash[:quieted_reasons] || {}
+		self.log.debug "Deps are: %p" % [ hash[:dependencies] ]
+		@dependencies    = hash[:dependencies]
 
-		if hash[:ack]
-			ack_values = hash[:ack].values_at( *Arborist::Node::ACK.members )
-			@ack = Arborist::Node::ACK.new( *ack_values )
+		@update_delta    = Hash.new do |h,k|
+			h[ k ] = Hash.new( &h.default_proc )
 		end
+
+		@pending_update_events = []
+		@subscriptions         = {}
+
+		self.ack = hash[:ack]
 	end
 
 
@@ -588,11 +897,7 @@ class Arborist::Node
 			other_node.identifier == self.identifier &&
 			other_node.parent == self.parent &&
 			other_node.description == self.description &&
-			other_node.tags == self.tags &&
-			other_node.properties == self.properties &&
-			other_node.status == self.status &&
-			other_node.ack == self.ack &&
-			other_node.error == self.error
+			other_node.tags == self.tags
 	end
 
 
@@ -604,15 +909,7 @@ class Arborist::Node
 	def ack=( ack_data )
 		if ack_data
 			self.log.info "Node %s ACKed with data: %p" % [ self.identifier, ack_data ]
-			ack_data['time'] ||= Time.now
-			ack_values = ack_data.values_at( *Arborist::Node::ACK.members.map(&:to_s) )
-			new_ack = Arborist::Node::ACK.new( *ack_values )
-
-			if missing = ACK_REQUIRED_PROPERTIES.find {|prop| new_ack[prop].nil? }
-				raise "Missing required ACK attribute %s" % [ missing ]
-			end
-
-			@ack = new_ack
+			@ack = Arborist::Node::Ack.from_hash( ack_data )
 		else
 			self.log.info "Node %s ACK cleared explicitly" % [ self.identifier ]
 			@ack = nil
@@ -637,6 +934,12 @@ class Arborist::Node
 	end
 
 
+	### Returns +true+ if the node has been acked and also has an error set.
+	def ack_and_error_set?
+		return self.error && self.ack_set?
+	end
+
+
 	#
 	# :section: State Callbacks
 	#
@@ -648,18 +951,30 @@ class Arborist::Node
 	end
 
 
+	### Update the last status change time.
+	def update_status_changed( transition )
+		self.status_changed = Time.now
+	end
+
+
+	### Queue up a transition event whenever one happens
+	def make_transition_event( transition )
+		node_type = "node_%s" % [ transition.to ]
+		self.log.debug "Making a %s event for %p" % [ node_type, transition ]
+		self.pending_update_events << Arborist::Event.create( node_type, self )
+	end
+
+
 	### Callback for when an acknowledgement is set.
 	def on_ack( transition )
 		self.log.warn "ACKed: %s" % [ self.status_description ]
-		self.pending_update_events <<
-			Arborist::Event.create( 'node_acked', self.fetch_values, self.ack.to_h )
 	end
 
 
 	### Callback for when an acknowledgement is cleared.
 	def on_ack_cleared( transition )
-		self.error = nil
 		self.log.warn "ACK cleared for %s" % [ self.identifier ]
+		self.ack = nil
 	end
 
 
@@ -683,6 +998,18 @@ class Arborist::Node
 	end
 
 
+	### Callback for when a node goes from any state to quieted
+	def on_node_quieted( transition )
+		self.log.warn "%s is %s" % [ self.identifier, self.status_description ]
+	end
+
+
+	### Callback for when a node transitions from quieted to unknown
+	def on_node_unquieted( transition )
+		self.log.warn "%s is %s" % [ self.identifier, self.status_description ]
+	end
+
+
 	### Callback for when a node goes from disabled to unknown
 	def on_node_enabled( transition )
 		self.log.warn "%s is %s" % [ self.identifier, self.status_description ]
@@ -700,21 +1027,20 @@ class Arborist::Node
 	private
 	#######
 
-	### Returns true if the specified +hash+ includes the specified +key+, and the value
-	### associated with the +key+ either includes +val+ if it is a Hash, or equals +val+ if it's
-	### anything but a Hash.
-	def hash_matches( hash, key, val )
-		actual = hash[ key ] or return false
+	### Check the specified +dependencies+ (an Arborist::Dependency) for illegal dependencies
+	### and raise an error if any are found.
+	def check_dependencies( dependencies )
+		identifiers = dependencies.all_identifiers
 
-		if actual.is_a?( Hash )
-			if val.is_a?( Hash )
-				return val.all? {|subkey, subval| hash_matches(actual, subkey, subval) }
-			else
-				return false
-			end
-		else
-			return actual == val
+		self.log.debug "Checking dependency identifiers: %p" % [ identifiers ]
+		if identifiers.include?( '_' )
+			raise Arborist::ConfigError, "a node can't depend on the root node"
+		elsif identifiers.include?( self.identifier )
+			raise Arborist::ConfigError, "a node can't depend on itself"
 		end
+
+		return dependencies
 	end
 
+
 end # class Arborist::Node