mcollective-client 2.0.0 → 2.2.0

data/lib/mcollective/rpc/helpers.rb

@@ -2,15 +2,6 @@ module MCollective
   module RPC
     # Various utilities for the RPC system
     class Helpers
-      # Checks in PATH returns true if the command is found
-      def self.command_in_path?(command)
-        found = ENV["PATH"].split(File::PATH_SEPARATOR).map do |p|
-          File.exist?(File.join(p, command))
-        end
-
-        found.include?(true)
-      end
-
       # Parse JSON output as produced by printrpc and extract
       # the "sender" of each rpc response
       #
@@ -42,54 +33,6 @@ module MCollective
         end
       end
 
-      # Figures out the columns and liens of the current tty
-      #
-      # Returns [0, 0] if it can't figure it out or if you're
-      # not running on a tty
-      def self.terminal_dimensions
-        return [0, 0] unless STDOUT.tty?
-
-        return [80, 40] if Util.windows?
-
-        if ENV["COLUMNS"] && ENV["LINES"]
-          return [ENV["COLUMNS"].to_i, ENV["LINES"].to_i]
-
-        elsif ENV["TERM"] && command_in_path?("tput")
-          return [`tput cols`.to_i, `tput lines`.to_i]
-
-        elsif command_in_path?('stty')
-          return `stty size`.scan(/\d+/).map {|s| s.to_i }
-        else
-          return [0, 0]
-        end
-      rescue
-        [0, 0]
-      end
-
-      # Return color codes, if the config color= option is false
-      # just return a empty string
-      def self.color(code)
-        colorize = Config.instance.color
-
-        colors = {:red => "",
-          :green => "",
-          :yellow => "",
-          :cyan => "",
-          :bold => "",
-          :reset => ""}
-
-        if colorize
-          return colors[code] || ""
-        else
-          return ""
-        end
-      end
-
-      # Helper to return a string in specific color
-      def self.colorize(code, msg)
-        "#{self.color(code)}#{msg}#{self.color(:reset)}"
-      end
-
       # Returns a blob of text representing the results in a standard way
       #
       # It tries hard to do sane things so you often
@@ -109,7 +52,7 @@ module MCollective
       # hostnames, it will just print the result as if it's one huge result,
       # handy for things like showing a combined mailq.
       def self.rpcresults(result, flags = {})
-        flags = {:verbose => false, :flatten => false, :format => :console}.merge(flags)
+        flags = {:verbose => false, :flatten => false, :format => :console, :force_display_mode => false}.merge(flags)
 
         result_text = ""
         ddl = nil
@@ -133,26 +76,31 @@ module MCollective
                 sender = r[:sender]
                 status = r[:statuscode]
                 message = r[:statusmsg]
-                display = ddl[:display]
                 result = r[:data]
 
+                if flags[:force_display_mode]
+                  display = flags[:force_display_mode]
+                else
+                  display = ddl[:display]
+                end
+
                 # appand the results only according to what the DDL says
                 case display
-                when :ok
-                  if status == 0
-                    result_text << text_for_result(sender, status, message, result, ddl)
-                  end
+                  when :ok
+                    if status == 0
+                      result_text << text_for_result(sender, status, message, result, ddl)
+                    end
 
-                when :failed
-                  if status > 0
-                    result_text << text_for_result(sender, status, message, result, ddl)
-                  end
+                  when :failed
+                    if status > 0
+                      result_text << text_for_result(sender, status, message, result, ddl)
+                    end
 
-                when :always
-                  result_text << text_for_result(sender, status, message, result, ddl)
+                  when :always
+                    result_text << text_for_result(sender, status, message, result, ddl)
 
-                when :flatten
-                  result_text << text_for_flattened_result(status, result)
+                  when :flatten
+                    result_text << text_for_flattened_result(status, result)
 
                 end
               rescue Exception => e
@@ -170,14 +118,14 @@ module MCollective
       # Return text representing a result
       def self.text_for_result(sender, status, msg, result, ddl)
         statusses = ["",
-                     colorize(:red, "Request Aborted"),
-                     colorize(:yellow, "Unknown Action"),
-                     colorize(:yellow, "Missing Request Data"),
-                     colorize(:yellow, "Invalid Request Data"),
-                     colorize(:red, "Unknown Request Status")]
+                     Util.colorize(:red, "Request Aborted"),
+                     Util.colorize(:yellow, "Unknown Action"),
+                     Util.colorize(:yellow, "Missing Request Data"),
+                     Util.colorize(:yellow, "Invalid Request Data"),
+                     Util.colorize(:red, "Unknown Request Status")]
 
         result_text = "%-40s %s\n" % [sender, statusses[status]]
-        result_text << "   %s\n" % [colorize(:yellow, msg)] unless msg == "OK"
+        result_text << "   %s\n" % [Util.colorize(:yellow, msg)] unless msg == "OK"
 
         # only print good data, ignore data that results from failure
         if [0, 1].include?(status)
@@ -192,7 +140,7 @@ module MCollective
               end
             end
 
-            result.keys.each do |k|
+            result.keys.sort_by{|k| k}.each do |k|
               # get all the output fields nicely lined up with a
               # 3 space front padding
               begin
@@ -289,7 +237,7 @@ module MCollective
               end
             else
               unless r[:statuscode] == 0
-                result_text << "%-40s %s\n" % [r[:sender], colorize(:red, r[:statusmsg])]
+                result_text << "%-40s %s\n" % [r[:sender], Util.colorize(:red, r[:statusmsg])]
               end
             end
           end
@@ -319,7 +267,11 @@ module MCollective
           options[:batch_sleep_time] = v
         end
 
-        parser.on('--limit-nodes COUNT', '--ln', 'Send request to only a subset of nodes, can be a percentage') do |v|
+        parser.on('--limit-seed NUMBER', Integer, 'Seed value for deterministic random batching') do |v|
+          options[:limit_seed] = v
+        end
+
+        parser.on('--limit-nodes COUNT', '--ln', '--limit', 'Send request to only a subset of nodes, can be a percentage') do |v|
           raise "Invalid limit specified: #{v} valid limits are /^\d+%*$/" unless v =~ /^\d+%*$/
 
           if v =~ /^\d+$/
@@ -333,6 +285,16 @@ module MCollective
           options[:progress_bar] = false
           options[:output_format] = :json
         end
+
+        parser.on('--display MODE', 'Influence how results are displayed. One of ok, all or failed') do |v|
+          if v == "all"
+            options[:force_display_mode] = :always
+          else
+            options[:force_display_mode] = v.intern
+          end
+
+          raise "--display has to be one of 'ok', 'all' or 'failed'" unless [:ok, :failed, :always].include?(options[:force_display_mode])
+        end
       end
     end
   end

data/lib/mcollective/rpc/progress.rb

@@ -19,7 +19,7 @@ module MCollective
         if size
           @size = size
         else
-          cols = Helpers.terminal_dimensions[0] - 22
+          cols = Util.terminal_dimensions[0] - 22
 
           # Defaults back to old behavior if it
           # couldn't figure out the size or if
@@ -40,9 +40,9 @@ module MCollective
         return "\r#{current} / #{total}" if @size == 0
 
         if current == total
-          txt = "\r " + Helpers.colorize(:green, "*") + " [ "
+          txt = "\r %s [ " % Util.colorize(:green, "*")
         else
-          txt = "\r #{@twirl[@twirldex]} [ "
+          txt = "\r %s [ " % Util.colorize(:red, @twirl[@twirldex])
         end
 
         dashes = ((current.to_f / total) * @size).round

data/lib/mcollective/rpc/reply.rb

@@ -4,10 +4,30 @@ module MCollective
     class Reply
       attr_accessor :statuscode, :statusmsg, :data
 
-      def initialize
+      def initialize(action, ddl)
         @data = {}
         @statuscode = 0
         @statusmsg = "OK"
+        @ddl = ddl
+        @action = action
+
+        begin
+          initialize_data
+        rescue Exception => e
+          Log.warn("Could not pre-populate reply data from the DDL: %s: %s" % [e.class, e.to_s ])
+        end
+      end
+
+      def initialize_data
+        unless @ddl.actions.include?(@action)
+          raise "No action '%s' defined for agent '%s' in the DDL" % [@action, @ddl.pluginname]
+        end
+
+        interface = @ddl.action_interface(@action)
+
+        interface[:output].keys.each do |output|
+          @data[output] = interface[:output][output][:default]
+        end
       end
 
       # Helper to fill in statusmsg and code on failure
@@ -22,20 +42,20 @@ module MCollective
         @statuscode = code
 
         case code
-        when 1
-          raise RPCAborted, msg
+          when 1
+            raise RPCAborted, msg
 
-        when 2
-          raise UnknownRPCAction, msg
+          when 2
+            raise UnknownRPCAction, msg
 
-        when 3
-          raise MissingRPCData, msg
+          when 3
+            raise MissingRPCData, msg
 
-        when 4
-          raise InvalidRPCData, msg
+          when 4
+            raise InvalidRPCData, msg
 
-        else
-          raise UnknownRPCError, msg
+          else
+            raise UnknownRPCError, msg
         end
       end
 
@@ -49,12 +69,16 @@ module MCollective
         @data[key]
       end
 
+      def fetch(key, default)
+        @data.fetch(key, default)
+      end
+
       # Returns a compliant Hash of the reply that should be sent
       # over the middleware
       def to_hash
         return {:statuscode => @statuscode,
-          :statusmsg => @statusmsg,
-          :data => @data}
+                :statusmsg => @statusmsg,
+                :data => @data}
       end
     end
   end

data/lib/mcollective/rpc/request.rb

@@ -2,9 +2,9 @@ module MCollective
   module RPC
     # Simple class to manage compliant requests for MCollective::RPC agents
     class Request
-      attr_accessor :time, :action, :data, :sender, :agent, :uniqid, :caller
+      attr_accessor :time, :action, :data, :sender, :agent, :uniqid, :caller, :ddl
 
-      def initialize(msg)
+      def initialize(msg, ddl)
         @time = msg[:msgtime]
         @action = msg[:body][:action]
         @data = msg[:body][:data]
@@ -12,6 +12,7 @@ module MCollective
         @agent = msg[:body][:agent]
         @uniqid = msg[:requestid]
         @caller = msg[:callerid] || "unknown"
+        @ddl = ddl
       end
 
       # If data is a hash, quick helper to get access to it's include? method
@@ -35,16 +36,26 @@ module MCollective
         return @data[key]
       end
 
+      def fetch(key, default)
+        return nil unless @data.is_a?(Hash)
+        return @data.fetch(key, default)
+      end
+
       def to_hash
         return {:agent => @agent,
-          :action => @action,
-          :data => @data}
+                :action => @action,
+                :data => @data}
+      end
+
+      # Validate the request against the DDL
+      def validate!
+        @ddl.validate_rpc_request(@action, @data)
       end
 
       def to_json
         to_hash.merge!({:sender   => @sender,
-                         :callerid => @callerid,
-                         :uniqid   => @uniqid}).to_json
+                        :callerid => @callerid,
+                        :uniqid   => @uniqid}).to_json
       end
     end
   end

data/lib/mcollective/rpc/result.rb

@@ -24,17 +24,21 @@ module MCollective
         @results[idx] = item
       end
 
+      def fetch(key, default)
+        @results.fetch(key, default)
+      end
+
       def each
         @results.each_pair {|k,v| yield(k,v) }
       end
 
       def to_json(*a)
         {:agent => @agent,
-          :action => @action,
-          :sender => @results[:sender],
-          :statuscode => @results[:statuscode],
-          :statusmsg => @results[:statusmsg],
-          :data => @results[:data]}.to_json(*a)
+         :action => @action,
+         :sender => @results[:sender],
+         :statuscode => @results[:statuscode],
+         :statusmsg => @results[:statusmsg],
+         :data => @results[:data]}.to_json(*a)
       end
     end
   end

data/lib/mcollective/rpc/stats.rb

@@ -4,6 +4,7 @@ module MCollective
     class Stats
       attr_accessor :noresponsefrom, :starttime, :discoverytime, :blocktime, :responses, :totaltime
       attr_accessor :discovered, :discovered_nodes, :okcount, :failcount, :noresponsefrom, :responsesfrom
+      attr_accessor :requestid, :aggregate_summary, :ddl
 
       def initialize
         reset
@@ -23,21 +24,25 @@ module MCollective
         @okcount = 0
         @failcount = 0
         @noresponsefrom = []
+        @requestid = nil
+        @aggregate_summary = []
       end
 
       # returns a hash of our stats
       def to_hash
-        {:noresponsefrom   => @noresponsefrom,
-         :starttime        => @starttime,
-         :discoverytime    => @discoverytime,
-         :blocktime        => @blocktime,
-         :responses        => @responses,
-         :totaltime        => @totaltime,
-         :discovered       => @discovered,
-         :discovered_nodes => @discovered_nodes,
-         :noresponsefrom   => @noresponsefrom,
-         :okcount          => @okcount,
-         :failcount        => @failcount}
+        {:noresponsefrom    => @noresponsefrom,
+         :starttime         => @starttime,
+         :discoverytime     => @discoverytime,
+         :blocktime         => @blocktime,
+         :responses         => @responses,
+         :totaltime         => @totaltime,
+         :discovered        => @discovered,
+         :discovered_nodes  => @discovered_nodes,
+         :noresponsefrom    => @noresponsefrom,
+         :okcount           => @okcount,
+         :requestid         => @requestid,
+         :failcount         => @failcount,
+         :aggregate_summary => @aggregate_summary}
       end
 
       # Fake hash access to keep things backward compatible
@@ -68,6 +73,7 @@ module MCollective
         @starttime = stats[:starttime]
         @blocktime = stats[:blocktime]
         @totaltime = stats[:totaltime]
+        @requestid = stats[:requestid]
         @discoverytime = stats[:discoverytime] if @discoverytime == 0
       end
 
@@ -124,24 +130,58 @@ module MCollective
         @responsesfrom = [node]
       end
 
+      def text_for_aggregates
+        result = StringIO.new
+
+        @aggregate_summary.each do |aggregate|
+          output_item = aggregate.result[:output]
+
+          begin
+            action_interface = @ddl.action_interface(aggregate.action)
+            display_as = action_interface[:output][output_item][:display_as]
+          rescue
+            display_as = output_item
+          end
+
+          aggregate_report = aggregate.to_s
+
+          result.puts Util.colorize(:bold, "Summary of %s:" % display_as)
+          result.puts
+          unless aggregate_report == ""
+            result.puts aggregate.to_s
+          else
+            result.puts Util.colorize(:yellow, "     No aggregate summary could be computed")
+          end
+          result.puts
+        end
+
+        result.string
+      end
+
       # Returns a blob of text representing the request status based on the
       # stats contained in this class
-      def report(caption = "rpc stats", verbose = false)
+      def report(caption = "rpc stats", summarize = true, verbose = false)
         result_text = []
 
         if verbose
-          result_text << Helpers.colorize(:yellow, "---- #{caption} ----")
+            if @aggregate_summary.size > 0 && summarize
+              result_text << text_for_aggregates
+            else
+              result_text << ""
+            end
+
+          result_text << Util.colorize(:yellow, "---- #{caption} ----")
 
           if @discovered
             @responses < @discovered ? color = :red : color = :reset
-            result_text << "           Nodes: %s / %s" % [ Helpers.colorize(color, @discovered), Helpers.colorize(color, @responses) ]
+            result_text << "           Nodes: %s / %s" % [ Util.colorize(color, @discovered), Util.colorize(color, @responses) ]
           else
             result_text << "           Nodes: #{@responses}"
           end
 
           @failcount < 0 ? color = :red : color = :reset
 
-          result_text << "     Pass / Fail: %s / %s" % [Helpers.colorize(color, @okcount), Helpers.colorize(color, @failcount) ]
+          result_text << "     Pass / Fail: %s / %s" % [Util.colorize(color, @okcount), Util.colorize(color, @failcount) ]
           result_text << "      Start Time: %s"      % [Time.at(@starttime)]
           result_text << "  Discovery Time: %.2fms"  % [@discoverytime * 1000]
           result_text << "      Agent Time: %.2fms"  % [@blocktime * 1000]
@@ -150,9 +190,15 @@ module MCollective
           if @discovered
             @responses < @discovered ? color = :red : color = :green
 
-            result_text << "Finished processing %s / %s hosts in %.2f ms" % [Helpers.colorize(color, @responses), Helpers.colorize(color, @discovered), @blocktime * 1000]
+            if @aggregate_summary.size > 0 && summarize
+              result_text << text_for_aggregates
+            else
+              result_text << ""
+            end
+
+            result_text << "Finished processing %s / %s hosts in %.2f ms" % [Util.colorize(color, @responses), Util.colorize(color, @discovered), @blocktime * 1000]
           else
-            result_text << "Finished processing %s hosts in %.2f ms" % [Helpers.colorize(:bold, @responses), @blocktime * 1000]
+            result_text << "Finished processing %s hosts in %.2f ms" % [Util.colorize(:bold, @responses), @blocktime * 1000]
           end
         end
 
@@ -165,20 +211,21 @@ module MCollective
 
       # Returns a blob of text indicating what nodes did not respond
       def no_response_report
-        result_text = []
+        result_text = StringIO.new
 
         if @noresponsefrom.size > 0
-          result_text << Helpers.colorize(:red, "\nNo response from:\n")
+          result_text.puts
+          result_text.puts Util.colorize(:red, "No response from:")
+          result_text.puts
 
-          @noresponsefrom.each_with_index do |c,i|
-            result_text << "" if i % 4 == 0
-            result_text << "%30s" % [c]
+          @noresponsefrom.sort.in_groups_of(3) do |c|
+            result_text.puts "   %-30s%-30s%-30s" % c
           end
 
-          result_text << ""
+          result_text.puts
         end
 
-        result_text.join("\n")
+        result_text.string
       end
     end
   end