arborist 0.2.0.pre20170519125456 → 0.2.0

data/lib/arborist/client.rb

@@ -18,13 +18,17 @@ class Arborist::Client
 	log_to :arborist
 
 
+	### Create and return a singleton instance with configured
+	### endpoints.
+	def self::instance
+		return @instance ||= new
+	end
+
+
 	### Create a new Client with the given API socket URIs.
 	def initialize( tree_api_url: nil, event_api_url: nil )
 		@tree_api_url  = tree_api_url  || Arborist.tree_api_url
 		@event_api_url = event_api_url || Arborist.event_api_url
-
-		@request_queue = nil
-		@event_subscriptions = nil
 	end
 
 
@@ -40,40 +44,35 @@ class Arborist::Client
 
 
 	#
-	# High-level methods
+	# Convenience methods
 	#
 
-	### 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
-				}
-			}
-		}
 
-		return self.update( data )
+	### Return dependencies of the given +identifier+ as an array.
+	def dependencies_of( identifier, partition: nil, properties: :all )
+		dependencies = self.deps( identifier: identifier )[ 'deps' ]
+		dependencies = self.search(
+			criteria: { identifier: dependencies },
+			options:  { properties: properties }
+		)
+
+		if partition
+			partition = partition.to_s
+			dependencies.keys.each{|id| dependencies[id]['identifier'] = id }
+			dependencies = dependencies.values.group_by do |node|
+				node[ partition ]
+			end
+		end
+
+		return dependencies
 	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
+	### Retreive a single node.
+	def fetch_node( identifier )
+		request = self.make_fetch_request( from: identifier, depth: 0 )
+		return self.send_tree_api_request( request ).first
 	end
-	alias_method :clear_ack, :clear_acknowledgement
-
 
 
 	#
@@ -87,44 +86,63 @@ class Arborist::Client
 	end
 
 
-	### Return the manager's current status as a hash.
+	### Return a `status` request as a ZMQ message (a CZTop::Message).
 	def make_status_request
 		return Arborist::TreeAPI.request( :status )
 	end
 
 
-	### Return the manager's current node tree.
-	def list( **args )
-		request = self.make_list_request( **args )
+	### Fetch the manager's current node tree.
+	def fetch( **args )
+		request = self.make_fetch_request( **args )
 		return self.send_tree_api_request( request )
 	end
 
 
-	### Return the manager's current node tree.
-	def make_list_request( from: nil, depth: nil )
+	### Return a `fetch` request as a ZMQ message (a CZTop::Message) with the given
+	### attributes.
+	def make_fetch_request( from: nil, depth: nil, tree: false )
 		header = {}
 		self.log.debug "From is: %p" % [ from ]
 		header[:from] = from if from
 		header[:depth] = depth if depth
+		header[:tree] = 'true' if tree
 
-		return Arborist::TreeAPI.request( :list, header )
+		return Arborist::TreeAPI.request( :fetch, header, nil )
 	end
 
 
 	### Return the manager's current node tree.
-	def fetch( criteria={}, options={} )
-		request = self.make_fetch_request( criteria, **options )
+	def search( criteria:{}, options:{}, **args )
+		criteria = args if criteria.empty?
+		request = self.make_search_request( criteria, **options )
 		return self.send_tree_api_request( request )
 	end
 
 
-	### Return the manager's current node tree.
-	def make_fetch_request( criteria, include_down: false, properties: :all, exclude: {} )
+	### Return a `search` request as a ZMQ message (a CZTop::Message) with the given
+	### attributes.
+	def make_search_request( criteria, exclude_down: false, properties: :all, exclude: {} )
 		header = {}
-		header[ :include_down ] = true if include_down
+		header[ :exclude_down ] = true if exclude_down
 		header[ :return ] = properties if properties != :all
 
-		return Arborist::TreeAPI.request( :fetch, header, [ criteria, exclude ] )
+		return Arborist::TreeAPI.request( :search, header, [ criteria, exclude ] )
+	end
+
+
+	### Return the identifiers that have a dependency on the node with the
+	### specified +identifier+.
+	def deps( identifier: )
+		request = self.make_deps_request( identifier )
+		return self.send_tree_api_request( request )
+	end
+
+
+	### Return a `deps` request as a ZMQ message (a CZTop::Message) with the given
+	### +identifier+.
+	def make_deps_request( identifier )
+		return Arborist::TreeAPI.request( :deps, { from: identifier }, nil )
 	end
 
 
@@ -136,9 +154,10 @@ class Arborist::Client
 	end
 
 
-	### Update the identified nodes in the manager with the specified data.
-	def make_update_request( data )
-		return Arborist::TreeAPI.request( :update, nil, data )
+	### Return an `update` request as a zmq message (a CZTop::Message) with the given
+	### +data+.
+	def make_update_request( data, header={} )
+		return Arborist::TreeAPI.request( :update, header, data )
 	end
 
 
@@ -150,7 +169,8 @@ class Arborist::Client
 	end
 
 
-	### Make a subscription request for the specified +criteria+, +identifier+, and +event_type+.
+	### Return a `subscribe` request as a zmq message (a CZTop::Message) with the
+	### specified attributes.
 	def make_subscribe_request( criteria: {}, identifier: nil, event_type: nil, exclude: {} )
 		self.log.debug "Making subscription request for identifier: %p, event_type: %p, criteria: %p" %
 			[ identifier, event_type, criteria ]
@@ -170,11 +190,12 @@ class Arborist::Client
 	end
 
 
-	### Remove the subscription with the specified +subid+.
+	### Return an `unsubscribe` request as a zmq message (a CZTop::Message) with the
+	### specified +subid+.
 	def make_unsubscribe_request( subid )
 		self.log.debug "Making unsubscribe request for subid: %s" % [ subid ]
 
-		return Arborist::TreeAPI.request( :unsubscribe, subscription_id: subid )
+		return Arborist::TreeAPI.request( :unsubscribe, {subscription_id: subid}, nil )
 	end
 
 
@@ -186,11 +207,12 @@ class Arborist::Client
 	end
 
 
-	### Remove the node with the specified +identfier+.
-	def make_prune_request( identifier )
+	### Return a `prune` request as a zmq message (a CZTop::Message) with the
+	### specified +identifier+.
+	def make_prune_request( identifier: )
 		self.log.debug "Making prune request for identifier: %s" % [ identifier ]
 
-		return Arborist::TreeAPI.request( :prune, identifier: identifier )
+		return Arborist::TreeAPI.request( :prune, {identifier: identifier}, nil )
 	end
 
 
@@ -202,13 +224,11 @@ class Arborist::Client
 	end
 
 
-	### Add a node with the specified +identifier+ and +arguments+.
-	def make_graft_request( identifier, attributes={} )
+	### Return a `graft` request as a zmq message (a CZTop::Message) with the
+	### specified attributes.
+	def make_graft_request( identifier:, type:, parent: nil, attributes:{} )
 		self.log.debug "Making graft request for identifer: %s" % [ identifier ]
 
-		parent = attributes.delete( :parent )
-		type   = attributes.delete( :type )
-
 		header = {
 			identifier: identifier,
 			parent:     parent,
@@ -227,14 +247,60 @@ class Arborist::Client
 	end
 
 
-	### Modify the operations +attributes+ of the node with the specified +identifier+.
-	def make_modify_request( identifier, attributes={} )
+	### Return a `modify` request as a zmq message (a CZTop::Message) with the
+	### specified attributes.
+	def make_modify_request( identifier:, attributes: )
 		self.log.debug "Making modify request for identifer: %s" % [ identifier ]
 
 		return Arborist::TreeAPI.request( :modify, {identifier: identifier}, attributes )
 	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( *args )
+		request = self.make_acknowledge_request( *args )
+		response = self.send_tree_api_request( request )
+		return true
+	end
+	alias_method :ack, :acknowledge
+
+
+	### Return an `ack` request as a zmq message (a CZTop::Message) with the specified
+	### attributes.
+	def make_acknowledge_request( identifier:, message:, sender:, via: nil, time: Time.now )
+		ack = {
+			message: message,
+			sender:  sender,
+			via:     via,
+			time:    time.to_s
+		}
+
+		return Arborist::TreeAPI.request( :ack, {identifier: identifier}, ack )
+	end
+
+
+	### Clear the acknowledgement for a node.
+	def clear_acknowledgement( *args )
+		request = self.make_unack_request( *args )
+		response = self.send_tree_api_request( request )
+		return true
+	end
+	alias_method :unack, :clear_acknowledgement
+	alias_method :clear_ack, :clear_acknowledgement
+	alias_method :unacknowledge, :clear_acknowledgement
+
+
+	### Return an `unack` request as a zmq message (a CZTop::Message) with the specified
+	### attribute.
+	def make_unack_request( identifier: )
+		return Arborist::TreeAPI.request( :unack, {identifier: identifier}, nil )
+	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/ack.rb

@@ -0,0 +1,86 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'etc'
+
+require 'arborist/cli' unless defined?( Arborist::CLI )
+require 'arborist/client'
+
+# Command to ack a node
+module Arborist::CLI::Ack
+	extend Arborist::CLI::Subcommand
+
+	desc 'Ack/disable one or more nodes in the Arborist tree'
+
+	arg :IDENTIFIER, optional: true, multiple: true
+
+	command :ack do |cmd|
+
+		cmd.switch :clear, default: false,
+			desc: "Clear the ack instead of setting it.",
+			negatable: false
+
+		cmd.flag [ :u, :user ],
+			desc: "The user to mark the nodes with."
+		cmd.flag [ :m, :message ],
+			desc: "The acknowledgement message."
+
+		cmd.action do |globals, options, args|
+			identifiers = get_identifiers( args )
+			help_now!( "No node identifiers supplied." ) if identifiers.empty?
+
+			client = Arborist::Client.new
+			res = {}
+
+			if options[ :clear ]
+				identifiers.each do |id|
+					res[ id ] = client.clear_ack( identifier: id )
+				end
+
+			else
+				message = options[ :message ] || prompt.ask( "Ack/disable message:" )
+				help_now!( "A acknowlegement/disable message is required." ) unless message
+
+				userid = options[ :user ] || prompt.ask( "Your name?", default: Etc.getpwuid.name )
+				help_now!( "Unable to determine ack user." ) unless userid
+
+				identifiers.each do |id|
+					res[ id ] = unless_dryrun( "Acking #{id}...", true ) do
+						client.ack(
+							identifier: id,
+							message:    message,
+							sender:     userid,
+							via:        "command line"
+						)
+					end
+				end
+			end
+
+			res.each_pair do |identifier, result|
+				prompt.say "%s: %s" % [
+					hl.bold.bright_blue( identifier ),
+					result == true ? "Okay." : hl.red( res.to_s )
+				]
+			end
+		end
+	end
+
+
+	###############
+	module_function
+	###############
+
+	### Parse a list of identifiers from the command line or from
+	### a multiline prompt.
+	def get_identifiers( args )
+		identifiers = args
+		if args.empty?
+			identifiers = prompt.multiline( "Enter node identifiers, separated with newlines or commas:" )
+			identifiers = identifiers.map( &:chomp ).map{|id| id.split(/,\s*/) }.flatten
+		end
+
+		return identifiers.uniq
+	end
+
+end # module Arborist::CLI::Ack
+

data/lib/arborist/command/reset.rb

@@ -0,0 +1,48 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'arborist/cli' unless defined?( Arborist::CLI )
+require 'arborist/node'
+require 'arborist/manager'
+
+
+# Command to reset node states while retaining acknowledgement state.
+module Arborist::CLI::Reset
+	extend Arborist::CLI::Subcommand
+
+	desc 'Reset all state except for acknowledged/disabled'
+	long_desc <<-EOF
+		If you've rearranged the dependencies in the tree, existing states may no
+		longer be valid.  This command forcefully resets all states to "unknown" so
+		they can be re-checked, but retains existing acknowledgements and intentionally
+		disabled nodes.  (If you don't care about those you should instead simply delete
+		the state file.)
+
+		It's pointless to use this command while the Manager is running.
+	EOF
+
+	arg :SOURCE
+
+	command :reset do |cmd|
+
+		cmd.flag :loader, desc: "Specify a loader type to use.",
+			default_value: 'file'
+
+		cmd.action do |globals, options, args|
+			source  = args.shift
+			loader  = Arborist::Loader.create( options[:loader], source )
+			manager = Arborist.manager_for( loader )
+
+			manager.nodes.each_pair do |identifier, node|
+				next if node.ack || node.operational?
+				node.status = 'unknown'
+			end
+
+			unless_dryrun( "Resetting node states." ) do
+				manager.save_node_states
+			end
+		end
+	end
+
+end # module Arborist::CLI::Reset
+

data/lib/arborist/command/start.rb

@@ -8,6 +8,12 @@ require 'arborist/cli' unless defined?( Arborist::CLI )
 module Arborist::CLI::Start
 	extend Arborist::CLI::Subcommand
 
+	VALID_DAEMONS = %w[
+		manager
+		monitors
+		observers
+	]
+
 	desc 'Start an Arborist daemon'
 	long_desc <<-EOF
 	Start the Arborist manager, observers, or monitors. The SOURCE is
@@ -30,6 +36,10 @@ module Arborist::CLI::Start
 			appname = args.shift
 			source  = args.shift
 
+			unless VALID_DAEMONS.include?( appname )
+				raise "Unknown daemon component.  Should be one of: %s" % [ VALID_DAEMONS.join(', ') ]
+			end
+
 			loader = Arborist::Loader.create( options[:loader], source )
 			runner = case appname
 				when 'manager'
@@ -42,7 +52,7 @@ module Arborist::CLI::Start
 					raise "Don't know how to start %p" % [ appname ]
 				end
 
-			unless_dryrun( "starting #{appname}" ) do
+			unless_dryrun( "starting #{appname} using #{runner.inspect}" ) do
 				start( runner, options[:p] )
 			end
 		end