arborist 0.2.0.pre20170519125456 → 0.2.0

data/lib/arborist/command/summary.rb

@@ -0,0 +1,173 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'time'
+require 'tty/table'
+
+require 'arborist/cli' unless defined?( Arborist::CLI )
+require 'arborist/client'
+
+
+# Command to fetch down/acked/disabled nodes for quick display.
+module Arborist::CLI::Summary
+	extend Arborist::CLI::Subcommand
+	using Arborist::TimeRefinements
+
+	BANNER = [
+		'          _             _    _',
+		' __ _ _ _| |__  ___ _ _(_)__| |',
+		'/ _` | \'_| \'_ \\/ _ \\ \'_| (_-< _|',
+		'\\__,_|_| |_.__/\\___/_| |_/__/\\__| %s, %s nodes',
+	]
+
+	desc 'Summarize known problems'
+
+	command :summary do |cmd|
+
+		cmd.flag [:s, :sort],
+			type: String,
+			desc: "Sort output by this node key",
+			arg_name: 'sort',
+			default_value: 'status_changed'
+
+		cmd.action do |globals, options, args|
+			client = Arborist::Client.new
+			status = client.status
+			nodes  = client.fetch
+
+			down     = get_status( nodes, 'down' )
+			warning  = get_status( nodes, 'warn' )
+			acked    = get_status( nodes, 'acked' )
+			disabled = get_status( nodes, 'disabled' )
+			quieted  = get_status( nodes, 'quieted' )
+			problems = ! ( down.size + acked.size + disabled.size + warning.size ).zero?
+
+			prompt.say "Connected to: %s" % [ highlight_string(client.tree_api_url) ]
+			prompt.say "Status as of: %s" % [ hl.on_blue.bright_white(Time.now.to_s) ]
+
+			(0..2).each do |i|
+				prompt.say "%s" % [ hl.bold.bright_green( BANNER[i] ) ]
+			end
+			prompt.say hl.bold.bright_green( BANNER.last ) % [
+				highlight_string(status['server_version']),
+				highlight_string(status['nodecount'])
+			]
+
+			puts
+			if problems
+				output_problems( disabled, acked, down, quieted, warning, options[:sort] )
+			else
+				prompt.say success_string( "No problems found!" )
+			end
+		end
+
+	end
+
+
+	###############
+	module_function
+	###############
+
+	### Since we fetch all nodes instead of doing separate
+	### API searches, quickly return nodes of a given +status+.
+	def get_status( nodes, status )
+		return nodes.select{|n| n['status'] == status}
+	end
+
+
+	### Output all problems.
+	###
+	def output_problems( disabled, acked, down, quieted, warning, sort )
+		unless disabled.size.zero?
+			prompt.say hl.headline( "Disabled Nodes" )
+			display_table( *format_acked(disabled, sort) )
+			puts
+		end
+		unless acked.size.zero?
+			prompt.say hl.headline( "Acknowledged Outages" )
+			display_table( *format_acked(acked, sort) )
+			puts
+		end
+		unless warning.size.zero?
+			prompt.say hl.headline( "Warnings" )
+			header = [
+				highlight_string( 'identifier' ),
+				highlight_string( 'type' ),
+				highlight_string( 'when' ),
+				highlight_string( 'warnings' )
+			]
+
+			display_table( header, format_warn(warning, sort) )
+			puts
+		end
+		unless down.size.zero?
+			prompt.say hl.headline( "Current Outages" )
+			header = [
+				highlight_string( 'identifier' ),
+				highlight_string( 'type' ),
+				highlight_string( 'when' ),
+				highlight_string( 'errors' )
+			]
+
+			display_table( header, format_down(down, sort) )
+			prompt.say "%d nodes have been %s as a result of the above problems." % [
+				quieted.size,
+				hl.quieted( 'quieted' )
+			]
+			puts
+		end
+	end
+
+
+	### Prepare an array of acked/disabled nodes.
+	def format_acked( nodes, sort_key )
+		header = [
+			highlight_string( 'identifier' ),
+			highlight_string( 'type' ),
+			highlight_string( 'when' ),
+			highlight_string( 'who' ),
+			highlight_string( 'message' )
+		]
+
+		rows = nodes.sort_by{|n| n[sort_key] }.each_with_object([]) do |node, acc|
+			acc << [
+				hl.disabled( node['identifier'] ),
+				node[ 'type' ],
+				Time.parse( node[ 'status_changed' ] ).as_delta,
+				node[ 'ack' ][ 'sender' ],
+				node[ 'ack' ][ 'message' ]
+			]
+		end
+		return header, rows
+	end
+
+
+	### Prepare an array of down nodes.
+	def format_down( nodes, sort_key )
+		return nodes.sort_by{|n| n[sort_key] }.each_with_object([]) do |node, acc|
+			errors = node[ 'errors' ].map{|err| "%s: %s" % [ err.first, err.last ]}
+			acc << [
+				hl.down( node['identifier'] ),
+				node[ 'type' ],
+				Time.parse( node[ 'status_changed' ] ).as_delta,
+				errors.join( "\n" )
+			]
+		end
+	end
+
+
+	### Prepare an array of nodes in a warning state.
+	def format_warn( nodes, sort_key )
+		return nodes.sort_by{|n| n[sort_key] }.each_with_object([]) do |node, acc|
+			warnings = node[ 'warnings' ].map{|err| "%s: %s" % [ err.first, err.last ]}
+			acc << [
+				hl.warn( node['identifier'] ),
+				node[ 'type' ],
+				Time.parse( node[ 'status_changed' ] ).as_delta,
+				warnings.join( "\n" )
+			]
+		end
+	end
+
+end # module Arborist::CLI::Summary
+

data/lib/arborist/command/tree.rb

@@ -0,0 +1,215 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'pp'
+require 'msgpack'
+require 'tty-tree'
+
+require 'arborist/cli' unless defined?( Arborist::CLI )
+require 'arborist/client'
+
+
+# Command to dump the node tree of a running Arborist manager
+module Arborist::CLI::Tree
+	extend Arborist::CLI::Subcommand
+
+	desc 'Dump the node tree of the running manager'
+
+	command :tree do |cmd|
+		cmd.switch :raw,
+			desc: "Dump the node tree data as raw data instead of prettifying it.",
+			negatable: false
+		cmd.switch :path,
+			desc: "Include the parent path back to root, when using --from.",
+			negatable: false
+
+		cmd.flag [:f, :from],
+			type: String,
+			desc: "Start at a node other than the root.",
+			arg_name: 'identifier'
+		cmd.flag [:e, :depth],
+			type: Integer,
+			desc: "Limit the depth of the fetched tree.",
+			arg_name: 'integer'
+
+		cmd.action do |globals, options, args|
+			client = Arborist::Client.instance
+
+			opts = { tree: true }
+			opts[ :from ]  = options[ :from ]  if options[ :from ]
+			opts[ :depth ] = options[ :depth ] if options[ :depth ]
+
+			nodes = client.fetch( opts )
+
+			if options[:raw]
+				pp nodes.first
+
+			else
+				status = client.status
+				prompt.say "Arborist Manager %s {%s} [%s nodes] (uptime: %s secs)\n\n" % [
+					highlight_string( status['server_version'] ),
+					highlight_string( client.tree_api_url ),
+					highlight_string( status['nodecount'] ),
+					highlight_string( "%d" % status['uptime'] )
+				]
+
+				root = nodes.first
+				root_data = {}
+
+				# Recursively fetch each parent node upwards to the
+				# Arborist root.
+				#
+				tree_data = if options[ :path ] && options[ :from ]
+					path_to_root = fetch_parents( root )
+					{ node_description( path_to_root.shift ) => build_path( path_to_root, root ) }
+
+				# Just display starting at the specified root.
+				#
+				else
+					{ node_description(root) => root_data }
+				end
+
+				root[ 'children' ].each_value do |node|
+					root_data[ node_description(node) ] = build_tree( node )
+				end
+
+				tree = TTY::Tree.new( tree_data )
+				prompt.say tree.render( indent: 4 )
+			end
+		end
+
+	end
+
+
+	###############
+	module_function
+	###############
+
+	#### Reorganize the node data to format used by TTY::Tree.
+	def build_tree( node )
+		return [] if node[ 'children' ].empty?
+
+		children = []
+		node[ 'children' ].each_value do |child|
+			children << { node_description(child) => build_tree(child) }
+		end
+		return children
+	end
+
+
+	### Given a sorted array of +nodes+, reorganize it for TTY::Tree.
+	def build_path( nodes, root )
+		children = []
+		parent_node = nodes.shift
+		return children unless parent_node
+
+		if parent_node == root
+			children << { node_description(parent_node) => build_tree(parent_node) }
+		else
+			children << { node_description(parent_node) => build_path(nodes, root) }
+		end
+		return children
+	end
+
+
+	### Given a starting node, walk upwards through the tree until
+	### reaching the Arborist root node.  Returns an array of nodes,
+	### sorted root down.
+	def fetch_parents( start_node )
+		client = Arborist::Client.instance
+		path = [ start_node ]
+		parent = start_node[ 'parent' ]
+		while parent
+			parent_node = client.fetch_node( parent )
+			path << parent_node
+			parent = parent_node[ 'parent' ]
+		end
+		return path.reverse
+	end
+
+
+	### Return a description of the specified +node+.
+	def node_description( node )
+		desc = ""
+
+		case node['type']
+		when 'root'
+			desc << "%s" % [ hl.bold.bright_blue(node['type']) ]
+		else
+			desc << highlight_string( node['identifier'] )
+			desc << " %s" % [ hl.dark.white(node['type']) ]
+		end
+
+		desc << " [%s]" % [ node['description'] ] unless
+			!node['description'] || node['description'].empty?
+		desc << " (%s)" % [ status_description(node) ]
+
+		child_count = node[ 'children' ].length
+		desc << " [%d child node%s" % [
+			child_count, child_count == 1 ? ']' : 's]'
+		] unless child_count.zero?
+
+		case node['status']
+		when 'down'
+			desc << errors_description( node )
+		when 'warn'
+			desc << warnings_description( node )
+		when 'quieted'
+			desc << quieted_reasons_description( node )
+		when 'acked'
+			desc << ack_description( node )
+			desc << "; was: "
+			desc << errors_description( node )
+		end
+
+		return desc
+	end
+
+
+	### Return a more colorful description of the status of the given +node+.
+	def status_description( node )
+		status = node['status'] or return '-'
+		return hl.decorate( status, status.to_sym ) rescue status
+	end
+
+
+	### Return the errors from the specified +node+ in a single line.
+	def errors_description( node )
+		errors = node['errors'] or return ''
+		return '  ' + errors.map do |monid, error|
+			"%s: %s" % [ monid, error ]
+		end.join( '; ' )
+	end
+
+	### Return the warnings from the specified +node+ in a single line.
+	def warnings_description( node )
+		warnings = node['warnings'] or return ''
+		return '  ' + warnings.map do |monid, error|
+			"%s: %s" % [ monid, error ]
+		end.join( '; ' )
+	end
+
+
+	### Return the quieted reasons from the specified +node+ in a single line.
+	def quieted_reasons_description( node )
+		reasons = node['quieted_reasons'] or return ''
+		return '  ' + reasons.map do |depname, reason|
+			"%s: %s" % [ depname, reason ]
+		end.join( '; ' )
+	end
+
+
+	### Return a description of the acknowledgement from the node.
+	def ack_description( node )
+		ack = node['ack'] or return '(no ack)'
+
+		return " Acked by %s at %s%s: %s" % [
+			ack['sender'],
+			ack['time'],
+			ack['via'] ? ' via ' + ack['via'] : '',
+			ack['message']
+		]
+	end
+
+end # module Arborist::CLI::Tree
+

data/lib/arborist/command/watch.rb

@@ -1,6 +1,7 @@
 # -*- ruby -*-
 #encoding: utf-8
 
+require 'tty/spinner'
 require 'msgpack'
 
 require 'arborist/cli' unless defined?( Arborist::CLI )
@@ -27,6 +28,9 @@ module Arborist::CLI::Watch
 			prompt.say "Subscribing to manager heartbeat events."
 			sock.subscribe( 'sys.heartbeat' )
 
+			spinner = TTY::Spinner.new( "[           :spinner           ] waiting for events...\r",
+				frames: HEARTBEAT_CHARACTERS, hide_cursor: true )
+
 			begin
 				last_runid = nil
 				prompt.say "Watching for events on manager at %s" % [ client.event_api_url ]
@@ -47,22 +51,22 @@ module Arborist::CLI::Watch
 							self.log.debug "Manager is alive (runid: %s)" % [ this_runid ]
 						end
 
-						$stderr.print( heartbeat() )
+						spinner.spin
 						last_runid = this_runid
 					when 'sys.node_added'
 						prompt.say "[%s] «Node added» %s\n" % [
-							hl(Time.now.strftime('%Y-%m-%d %H:%M:%S %Z')).color(:dark, :white),
-							hl(event['node']).color( :bold, :cyan )
+							hl.dark.white( Time.now.strftime('%Y-%m-%d %H:%M:%S %Z') ),
+							hl.bold.cyan( event['node'] )
 						]
 					when 'sys.node_removed'
 						prompt.say "[%s] »Node removed« %s\n" % [
-							hl(Time.now.strftime('%Y-%m-%d %H:%M:%S %Z')).color(:dark, :white),
-							hl(event['node']).color( :dark, :cyan )
+							hl.dark.white( Time.now.strftime('%Y-%m-%d %H:%M:%S %Z') ),
+							hl.dark.cyan( event['node'] )
 						]
 					else
 						prompt.say "[%s] %s\n" % [
-							hl(Time.now.strftime('%Y-%m-%d %H:%M:%S %Z')).color(:dark, :white),
-							hl(dump_event( event )).color( :dark, :white )
+							hl.dark.white( Time.now.strftime('%Y-%m-%d %H:%M:%S %Z') ),
+							hl.dark.white( dump_event( event ) )
 						]
 					end
 				end
@@ -97,42 +101,38 @@ module Arborist::CLI::Watch
 		when 'node.update'
 			type, status, errors = event['data'].values_at( *%w'type status errors' )
 			return "%s updated: %s is %s%s" % [
-				hl( id ).color( :cyan ),
+				hl.cyan( id ),
 				type,
-				hl( status ).color( status.to_sym ),
+				hl.decorate( status, status.to_sym ),
 				errors ? " (#{errors})" : ''
 			]
 		when 'node.delta'
 			pairs = diff_pairs( event['data'] )
-			return "%s delta, changes: %s" % [ hl( id ).color( :cyan ), pairs ]
+			return "%s delta, changes: %s" % [ hl.cyan( id ), pairs ]
 		else
-			return "%s event: %p" % [ hl(event_type).color(:dark, :white), event ]
+			return "%s event: %p" % [ hl.dark.white( event_type ), event ]
 		end
 	end
 
 
 	### Return a string showing the differences in a delta event's change +data+.
 	def diff_pairs( data )
-		return data.collect do |key, pairs|
+		diff = data.collect do |key, pairs|
 			if pairs.is_a?( Hash )
 				diff_pairs( pairs )
 			else
 				val1, val2 = *pairs
 				"%s: %s -> %s" % [
-					hl( key ).color( :dark, :white ),
-					hl( val1 ).color( :yellow ),
-					hl( val2 ).color( :bold, :yellow )
+					hl.dark.white( key ),
+					hl.yellow( val1 ),
+					hl.bold.yellow( val2 )
 				]
 			end
-		end.join( hl(", ").color(:dark, :white) )
-	end
-
+		end
 
-	### Return a heartbeat string for the current time.
-	def heartbeat
-		idx = (Time.now.to_i % HEARTBEAT_CHARACTERS.length) - 1
-		return " " + HEARTBEAT_CHARACTERS[ idx ] + "\x08\x08"
+		return hl.dark.white( diff.join(', ') )
 	end
 
+
 end # module Arborist::CLI::Watch