arborist 0.0.1.pre20160128152542 → 0.0.1.pre20160606141735

data/lib/arborist/client.rb

@@ -58,10 +58,11 @@ class Arborist::Client
 
 
 	### Return the manager's current node tree.
-	def make_list_request( from: nil )
+	def make_list_request( from: nil, depth: nil )
 		header = {}
 		self.log.debug "From is: %p" % [ from ]
 		header[:from] = from if from
+		header[:depth] = depth if depth
 
 		return self.pack_message( :list, header )
 	end
@@ -75,19 +76,54 @@ class Arborist::Client
 
 
 	### Return the manager's current node tree.
-	def make_fetch_request( criteria, include_down: false, properties: :all )
+	def make_fetch_request( criteria, include_down: false, properties: :all, exclude: {} )
 		header = {}
 		header[ :include_down ] = true if include_down
 		header[ :return ] = properties if properties != :all
 
-		return self.pack_message( :fetch, header, criteria )
+		return self.pack_message( :fetch, header, [ criteria, exclude ] )
 	end
 
 
+	### Mark a node as 'acknowledged' if it's down, or 'disabled' if
+	### it's up.  (A pre-emptive acknowledgement.)  Requires the node
+	### +identifier+, an acknowledgement +message+, and +sender+.  You
+	### can optionally include a +via+ (source), and override the default
+	### +time+ of now.
+	def acknowledge( node, message, sender, via=nil, time=Time.now )
+		data = {
+			node => {
+				ack: {
+					message: message,
+					sender:  sender,
+					via:     via,
+					time:    time.to_s
+				}
+			}
+		}
+
+		request = self.make_update_request( data )
+		self.send_tree_api_request( request )
+		return true
+	end
+	alias_method :ack, :acknowledge
+
+
+	### Clear an acknowledged/disabled +node+.
+	def clear_acknowledgement( node )
+		data = { node => { ack: nil } }
+		request = self.make_update_request( data )
+		self.send_tree_api_request( request )
+		return true
+	end
+	alias_method :clear_ack, :clear_acknowledgement
+
+
 	### Update the identified nodes in the manager with the specified data.
 	def update( *args )
 		request = self.make_update_request( *args )
-		return self.send_tree_api_request( request )
+		self.send_tree_api_request( request )
+		return true
 	end
 
 
@@ -133,6 +169,63 @@ class Arborist::Client
 	end
 
 
+	### Remove a node
+	def prune( *args )
+		request = self.make_prune_request( *args )
+		response = self.send_tree_api_request( request )
+		return response
+	end
+
+
+	### Remove the node with the specified +identfier+.
+	def make_prune_request( identifier )
+		self.log.debug "Making prune request for identifier: %s" % [ identifier ]
+
+		return self.pack_message( :prune, identifier: identifier )
+	end
+
+
+	### Add a new node to the tree.
+	def graft( *args )
+		request = self.make_graft_request( *args )
+		response = self.send_tree_api_request( request )
+		return response
+	end
+
+
+	### Add a node with the specified +identifier+ and +arguments+.
+	def make_graft_request( identifier, attributes={} )
+		self.log.debug "Making graft request for identifer: %s" % [ identifier ]
+
+		parent = attributes.delete( :parent )
+		type   = attributes.delete( :type )
+
+		header = {
+			identifier: identifier,
+			parent:     parent,
+			type:       type
+		}
+
+		return self.pack_message( :graft, header, attributes )
+	end
+
+
+	### Modify operational attributes of a node.
+	def modify( *args )
+		request = self.make_modify_request( *args )
+		response = self.send_tree_api_request( request )
+		return true
+	end
+
+
+	### Modify the operations +attributes+ of the node with the specified +identifier+.
+	def make_modify_request( identifier, attributes={} )
+		self.log.debug "Making modify request for identifer: %s" % [ identifier ]
+
+		return self.pack_message( :modify, {identifier: identifier}, attributes )
+	end
+
+
 	### Send the packed +request+ via the Tree API socket, raise an error on
 	### unsuccessful response, and return the response body.
 	def send_tree_api_request( request )

data/lib/arborist/command/client.rb

@@ -17,7 +17,8 @@ module Arborist::CLI::Client
 		cmd.action do |globals, options, args|
 			begin
 				require 'pry'
-			rescue LoadError
+			rescue LoadError => err
+				self.log.debug( err )
 				exit_now! "This command requires the 'pry' gem."
 			end
 

data/lib/arborist/command/start.rb

@@ -22,11 +22,15 @@ module Arborist::CLI::Start
 		cmd.flag :loader, desc: "Specify a loader type to use.",
 			default_value: 'file'
 
+		cmd.desc "Run under the profiler in the given MODE (one of wall, cpu, or object; defaults to wall)."
+		cmd.arg_name :MODE
+		cmd.flag [:p, 'profiler'], must_match: ['wall', 'cpu', 'object']
+
 		cmd.action do |globals, options, args|
 			appname = args.shift
 			source  = args.shift
 
-			loader = Arborist::Loader.create( options.loader, source )
+			loader = Arborist::Loader.create( options[:loader], source )
 			runner = case appname
 				when 'manager'
 					Arborist.manager_for( loader )
@@ -39,7 +43,7 @@ module Arborist::CLI::Start
 				end
 
 			unless_dryrun( "starting #{appname}" ) do
-				start( runner )
+				start( runner, options[:p] )
 			end
 		end
 	end
@@ -51,10 +55,52 @@ module Arborist::CLI::Start
 
 	### Start the specified +runner+ instance after setting up the environment for
 	### it.
-	def start( runner )
-		$0 = runner.class.name
-		runner.run
+	def start( runner, profile_mode=nil )
+		Process.setproctitle( runner.class.name )
+
+		if profile_mode
+			self.with_profiling_enabled( profile_mode, runner ) do
+				runner.run
+			end
+		else
+			runner.run
+		end
+	end
+
+
+	### Wrap the profiler around the specified +callable+.
+	def self::with_profiling_enabled( profile_arg, runner, &block )
+		require 'stackprof'
+		mode, outfile = self.parse_profile_args( profile_arg, runner )
+
+		self.log.info "Profiling in %s mode, outputting to %s" % [ mode, outfile ]
+		StackProf.run( mode: mode.to_sym, out: outfile, &block )
+	rescue LoadError => err
+		self.log.debug "%p while loading the StackProf profiler: %s"
+		exit_now!( "Couldn't load the profiler; you probably need to `gem install stackprof`", 254 )
 	end
 
+
+	### Set up the StackProf profiler to run in the given +mode+.
+	def self::parse_profile_args( arg, runner )
+		profile_mode, profile_filename = arg.split( ':', 2 )
+		profile_filename ||= self.default_profile_filename( profile_mode, runner )
+
+		return profile_mode, profile_filename
+	end
+
+
+	### Return a filename for a StackProf profile run over the given +runner+.
+	def self::default_profile_filename( mode, runner )
+		basename = runner.class.name.gsub( /.*::/, '' )
+		return "%s-%s-%s.%d.dump" % [
+			basename,
+			mode,
+			Time.now.strftime('%Y%m%d%H%M%S'),
+			Process.pid,
+		]
+	end
+
+
 end # module Arborist::CLI::Start
 

data/lib/arborist/dependency.rb

@@ -0,0 +1,286 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'set'
+require 'time'
+require 'loggability'
+
+require 'arborist' unless defined?( Arborist )
+
+
+
+# A inter-node dependency that is outside of the implicit ones expressed by the
+# tree.
+class Arborist::Dependency
+	extend Loggability
+
+
+	# Loggability API -- log to the Arborist logger
+	log_to :arborist
+
+
+	### Construct a new Dependency for the specified +behavior+ on the given +identifiers+
+	### with +prefixes+.
+	def self::on( behavior, *identifiers, prefixes: nil )
+		deps, identifiers = identifiers.flatten.uniq.partition {|obj| obj.is_a?(self.class) }
+		prefixes = Array( prefixes ).uniq
+		identifiers = prefixes.product( identifiers ).map {|pair| pair.join('-') } unless
+			prefixes.empty?
+
+		return self.new( behavior, identifiers + deps )
+	end
+
+
+	### Construct a new instance using the specified +hash+, which should be in the same form
+	### as that generated by #to_h:
+	###
+	###   {
+	###     behavior: <string>,
+	###     identifiers: [<identifier_1>, <identifier_n>],
+	###     subdeps: [<dephash_1>, <dephash_n>],
+	###   }
+	###
+	def self::from_hash( hash )
+		self.log.debug "Creating a new %p from a hash: %p" % [ self, hash ]
+
+		hash[:subdeps] ||= []
+		subdeps = hash[:subdeps].map {|subhash| self.from_hash(subhash) }
+
+		return self.new( hash[:behavior], hash[:identifiers] + subdeps )
+	end
+
+
+	### Create a new Dependency on the specified +nodes_or_subdeps+ with the given +behavior+
+	### (one of :any or :all)
+	def initialize( behavior, *nodes_or_subdeps )
+		@behavior = behavior
+		@subdeps, identifiers = nodes_or_subdeps.flatten.
+			partition {|obj| obj.is_a?(self.class) }
+		@identifier_states = identifiers.product([ nil ]).to_h
+	end
+
+
+	### Dup constructor -- dup internal datastructures without ephemeral state on #dup.
+	def initialize_dup( original ) # :nodoc:
+		@subdeps = @subdeps.map( &:dup )
+		@identifier_states = @identifier_states.keys.product([ nil ]).to_h
+	end
+
+
+	### Clone constructor -- clone internal datastructures without ephemeral state on #clone.
+	def initialize_clone( original ) # :nodoc:
+		@subdeps = @subdeps.map( &:clone )
+		@identifier_states = @identifier_states.keys.product([ nil ]).to_h
+	end
+
+
+	######
+	public
+	######
+
+	##
+	# The behavior that determines if the dependency is met by any or all of the
+	# nodes.
+	attr_reader :behavior
+
+	##
+	# The Hash of identifier states
+	attr_reader :identifier_states
+
+	##
+	# The Array of sub-dependencies (instances of Dependency).
+	attr_reader :subdeps
+
+
+	### Return a Set of identifiers belonging to this dependency.
+	def identifiers
+		return Set.new( self.identifier_states.keys )
+	end
+
+
+	### Return a Set of identifiers which have been marked down in this dependency.
+	def down_identifiers
+		return Set.new( self.identifier_states.select {|_, mark| mark }.map(&:first) )
+	end
+
+
+	### Return a Set of identifiers which have not been marked down in this dependency.
+	def up_identifiers
+		return Set.new( self.identifier_states.reject {|_, mark| mark }.map(&:first) )
+	end
+
+
+	### Return a Set of identifiers for all of this Dependency's sub-dependencies.
+	def subdep_identifiers
+		return self.subdeps.map( &:all_identifiers ).reduce( :+ ) || Set.new
+	end
+
+
+	### Return the Set of this Dependency's identifiers as well as those of all of its
+	### sub-dependencies.
+	def all_identifiers
+		return self.identifiers + self.subdep_identifiers
+	end
+
+
+	### Return any of this dependency's sub-dependencies that are down.
+	def down_subdeps
+		return self.subdeps.select( &:down? )
+	end
+
+
+	### Return any of this dependency's sub-dependencies that are up.
+	def up_subdeps
+		return self.subdeps.select( &:up? )
+	end
+
+
+	### Yield each unique identifier and Time of downed nodes from both direct and
+	### sub-dependencies.
+	def each_downed
+		return enum_for( __method__ ) unless block_given?
+
+		yielded = Set.new
+		self.identifier_states.each do |ident, time|
+			if time
+				yield( ident, time ) unless yielded.include?( ident )
+				yielded.add( ident )
+			end
+		end
+		self.subdeps.each do |subdep|
+			subdep.each_downed do |ident, time|
+				if time
+					yield( ident, time ) unless yielded.include?( ident )
+					yielded.add( ident )
+				end
+			end
+		end
+	end
+
+
+	### Returns +true+ if the receiver includes all of the given +identifiers+.
+	def include?( *identifiers )
+		return self.all_identifiers.include?( *identifiers )
+	end
+
+
+	### Returns +true+ if this dependency doesn't contain any identifiers or
+	### sub-dependencies.
+	def empty?
+		return self.all_identifiers.empty?
+	end
+
+
+	### Mark the specified +identifier+ as being down and propagate it to any subdependencies.
+	def mark_down( identifier, time=Time.now )
+		self.identifier_states[ identifier ] = time if self.identifier_states.key?( identifier )
+		self.subdeps.each do |dep|
+			dep.mark_down( identifier, time )
+		end
+	end
+
+
+	### Mark the specified +identifier+ as being up and propagate it to any subdependencies.
+	def mark_up( identifier )
+		self.subdeps.each do |dep|
+			dep.mark_up( identifier )
+		end
+		self.identifier_states[ identifier ] = nil if self.identifier_states.key?( identifier )
+	end
+
+
+	### Returns +true+ if this dependency cannot be met.
+	def down?
+		case self.behavior
+		when :all
+			self.identifier_states.values.any? || self.subdeps.any?( &:down? )
+		when :any
+			self.identifier_states.values.all? && self.subdeps.all?( &:down? )
+		end
+	end
+
+
+	### Returns +true+ if this dependency is met.
+	def up?
+		return !self.down?
+	end
+
+
+	### Returns the earliest Time a node was marked down.
+	def earliest_down_time
+		return self.identifier_states.values.compact.min
+	end
+
+
+	### Returns the latest Time a node was marked down.
+	def latest_down_time
+		return self.identifier_states.values.compact.max
+	end
+
+
+	### Return an English description of why this dependency is not met. If it is
+	### met, returns +nil+.
+	def down_reason
+		ids = self.down_identifiers
+		subdeps = self.down_subdeps
+
+		return nil if ids.empty? && subdeps.empty?
+
+		msg = nil
+		case self.behavior
+		when :all
+			msg = ids.first.dup
+			if ids.size == 1
+				msg << " is down"
+			else
+				msg << " (and %d other%s) are down" % [ ids.size - 1, ids.size == 2 ? '' : 's' ]
+			end
+
+			msg << " as of %s" % [ self.earliest_down_time ]
+
+		when :any
+			msg = "%s are all down" % [ ids.to_a.join(', ') ]
+			msg << " as of %s" % [ self.latest_down_time ]
+
+		else
+			raise "Don't know how to build a description of down behavior for %p" % [ self.behavior ]
+		end
+
+		return msg
+	end
+
+
+	### Return the entire dependency tree as a nested Hash.
+	def to_h
+		return {
+			behavior: self.behavior,
+			identifiers: self.identifier_states.keys,
+			subdeps: self.subdeps.map( &:to_h )
+		}
+	end
+
+
+	### Returns true if +other+ is the same object or if they both have the same
+	### identifiers, sub-dependencies, and identifier states.
+	def eql?( other )
+		self.log.debug "Comparing %p to %p (with states)" % [ self, other ]
+		return true if other.equal?( self )
+		return self == other &&
+			self.identifier_states.eql?( other.identifier_states ) &&
+			self.subdeps.eql?( other.subdeps )
+	end
+
+
+	### Equality comparison operator -- return true if the +other+ dependency has the same
+	### behavior, identifiers, and sub-dependencies. Does not consider identifier states.
+	def ==( other )
+		return true if other.equal?( self )
+		return false unless other.is_a?( self.class )
+
+		return self.behavior == other.behavior &&
+			self.identifiers == other.identifiers &&
+			self.subdeps == other.subdeps
+	end
+
+end # class Arborist::Dependency
+