choria-mcorpc-support 0.0.1

data/lib/mcollective/rpc/request.rb

@@ -0,0 +1,86 @@
+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, :ddl
+
+      def initialize(msg, ddl)
+        @time = msg[:msgtime]
+        @action = msg[:body][:action] || msg[:body]["action"]
+        @data = msg[:body][:data] || msg[:body]["data"]
+        @sender = msg[:senderid]
+        @agent = msg[:body][:agent] || msg[:body]["agent"]
+        @uniqid = msg[:requestid]
+        @caller = msg[:callerid] || "unknown"
+        @ddl = ddl
+      end
+
+      # In a scenario where a request came from a JSON pure medium like a REST
+      # service or other language client DDL::AgentDDL#validate_rpc_request will
+      # check "package" against the intput :package should the input "package" not
+      # also be known
+      #
+      # Thus once the request is built it will also have "package" and not :package
+      # data, so we need to fetch the correct key out of the hash.
+      def compatible_key(key)
+        return key if data.include?(key)
+
+        if ddl
+          input = ddl.action_interface(action)[:input]
+
+          # if :package is requested and the DDL also declares "package" we cant tell it to fetch
+          # "package", hence the check against the input here
+          return key.to_s if key.is_a?(Symbol) && !input.include?(key.to_s) && data.include?(key.to_s)
+        end
+
+        key
+      end
+
+      # If data is a hash, quick helper to get access to it's include? method
+      # else returns false
+      def include?(key)
+        return false unless @data.is_a?(Hash)
+
+        @data.include?(compatible_key(key))
+      end
+
+      # If no :process_results is specified always respond else respond
+      # based on the supplied property
+      def should_respond?
+        return false unless @data.is_a?(Hash)
+        return @data[:process_results] if @data.include?(:process_results)
+        return @data["process_results"] if @data.include?("process_results")
+
+        true
+      end
+
+      # If data is a hash, gives easy access to its members, else returns nil
+      def [](key)
+        return nil unless @data.is_a?(Hash)
+        return @data[compatible_key(key)]
+      end
+
+      def fetch(key, default)
+        return nil unless @data.is_a?(Hash)
+        return @data.fetch(compatible_key(key), default)
+      end
+
+      def to_hash
+        {:agent => @agent,
+         :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
+      end
+    end
+  end
+end

data/lib/mcollective/rpc/result.rb

@@ -0,0 +1,90 @@
+module MCollective
+  module RPC
+    # Simple class to manage compliant results from MCollective::RPC agents
+    #
+    # Currently it just fakes Hash behaviour to the result to remain backward
+    # compatible but it also knows which agent and action produced it so you
+    # can associate results to a DDL
+    class Result
+      attr_reader :agent, :action, :results
+
+      include Enumerable
+
+      def initialize(agent, action, result={})
+        @agent = agent
+        @action = action
+        @results = result
+
+        convert_data_based_on_ddl if ddl
+      end
+
+      def ddl
+        @_ddl ||= DDL.new(agent)
+      rescue
+        nil
+      end
+
+      def data
+        @results[:data] = @results.delete("data") if @results.include?("data")
+
+        self[:data]
+      end
+
+      # Converts keys on the supplied data to those listed as outputs
+      # in the DDL.  This is to facilitate JSON based transports
+      # without forcing everyone to rewrite DDLs and clients to
+      # convert symbols to strings, the data will be on symbol keys
+      # if the DDL has a symbol and not a string output defined
+      def convert_data_based_on_ddl
+        interface = ddl.action_interface(action)
+
+        return if interface.fetch(:output, {}).empty?
+
+        interface[:output].each do |output, properties|
+          next if data.include?(output)
+
+          if output.is_a?(Symbol) && data.include?(output.to_s)
+            data[output] = data.delete(output.to_s)
+          end
+        end
+      end
+
+      def compatible_key(key)
+        if key.is_a?(Symbol) && @results.include?(key.to_s)
+          key.to_s
+        else
+          key
+        end
+      end
+
+      def [](key)
+        @results[compatible_key(key)]
+      end
+
+      def []=(key, item)
+        @results[key] = item
+      end
+
+      def fetch(key, default)
+        @results.fetch(compatible_key(key), default)
+      end
+
+      def each
+        @results.each_pair {|k,v| yield(k,v) }
+      end
+
+      def to_json(*a)
+        {:agent => @agent,
+         :action => @action,
+         :sender => self[:sender],
+         :statuscode => self[:statuscode],
+         :statusmsg => self[:statusmsg],
+         :data => data}.to_json(*a)
+      end
+
+      def <=>(other)
+        self[:sender] <=> other[:sender]
+      end
+    end
+  end
+end

data/lib/mcollective/rpc/stats.rb

@@ -0,0 +1,294 @@
+module MCollective
+  module RPC
+    # Class to wrap all the stats and to keep track of some timings
+    class Stats
+      attr_accessor :noresponsefrom, :unexpectedresponsefrom, :starttime, :discoverytime, :blocktime, :responses
+      attr_accessor :totaltime, :discovered, :discovered_nodes, :okcount, :failcount, :noresponsefrom
+      attr_accessor :responsesfrom, :requestid, :aggregate_summary, :ddl, :aggregate_failures
+
+      def initialize
+        reset
+      end
+
+      # Resets stats, if discovery time is set we keep it as it was
+      def reset
+        @noresponsefrom = []
+        @unexpectedresponsefrom = []
+        @responsesfrom = []
+        @responses = 0
+        @starttime = Time.now.to_f
+        @discoverytime = 0 unless @discoverytime
+        @blocktime = 0
+        @totaltime = 0
+        @discovered = 0
+        @discovered_nodes = []
+        @okcount = 0
+        @failcount = 0
+        @requestid = nil
+        @aggregate_summary = []
+        @aggregate_failures = []
+      end
+
+      # returns a hash of our stats
+      def to_hash
+        {:noresponsefrom    => @noresponsefrom,
+         :unexpectedresponsefrom => @unexpectedresponsefrom,
+         :starttime         => @starttime,
+         :discoverytime     => @discoverytime,
+         :blocktime         => @blocktime,
+         :responses         => @responses,
+         :totaltime         => @totaltime,
+         :discovered        => @discovered,
+         :discovered_nodes  => @discovered_nodes,
+         :okcount           => @okcount,
+         :requestid         => @requestid,
+         :failcount         => @failcount,
+         :aggregate_summary => @aggregate_summary,
+         :aggregate_failures => @aggregate_failures}
+      end
+
+      # Fake hash access to keep things backward compatible
+      def [](key)
+        to_hash[key]
+      rescue
+        nil
+      end
+
+      # increment the count of ok hosts
+      def ok
+        @okcount += 1
+      rescue
+        @okcount = 1
+      end
+
+      # increment the count of failed hosts
+      def fail
+        @failcount += 1
+      rescue
+        @failcount = 1
+      end
+
+      # Re-initializes the object with stats from the basic client
+      def client_stats=(stats)
+        @noresponsefrom = stats[:noresponsefrom]
+        @unexpectedresponsefrom = stats[:unexpectedresponsefrom]
+        @responses = stats[:responses]
+        @starttime = stats[:starttime]
+        @blocktime = stats[:blocktime]
+        @totaltime = stats[:totaltime]
+        @requestid = stats[:requestid]
+        @discoverytime = stats[:discoverytime] if @discoverytime == 0
+      end
+
+      # Utility to time discovery from :start to :end
+      def time_discovery(action)
+        if action == :start
+          @discovery_start = Time.now.to_f
+        elsif action == :end
+          @discoverytime = Time.now.to_f - @discovery_start
+        else
+          raise("Uknown discovery action #{action}")
+        end
+      rescue
+        @discoverytime = 0
+      end
+
+      # helper to time block execution time
+      def time_block_execution(action)
+        if action == :start
+          @block_start = Time.now.to_f
+        elsif action == :end
+          @blocktime += Time.now.to_f - @block_start
+        else
+          raise("Uknown block action #{action}")
+        end
+      rescue
+        @blocktime = 0
+      end
+
+      # Update discovered and discovered_nodes based on
+      # discovery results
+      def discovered_agents(agents)
+        @discovered_nodes = agents
+        @discovered = agents.size
+      end
+
+      # Helper to calculate total time etc
+      def finish_request
+        @totaltime = @blocktime + @discoverytime
+
+        # figure out who responded unexpectedly
+        @unexpectedresponsefrom = @responsesfrom - @discovered_nodes
+
+        # figure out who we had no responses from
+        @noresponsefrom = @discovered_nodes - @responsesfrom
+      rescue
+        @totaltime = 0
+        @noresponsefrom = []
+        @unexpectedresponsefrom = []
+      end
+
+      # Helper to keep track of who we received responses from
+      def node_responded(node)
+        @responsesfrom << node
+      rescue
+        @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
+
+          if aggregate.is_a?(Aggregate::Result::Base)
+            aggregate_report = aggregate.to_s
+          else
+            next
+          end
+
+          result.puts Util.colorize(:bold, "Summary of %s:" % display_as)
+          result.puts
+          unless aggregate_report == ""
+            result.puts aggregate.to_s.split("\n").map{|x| "   " + x}.join("\n")
+          else
+            result.puts Util.colorize(:yellow, "     No aggregate summary could be computed")
+          end
+          result.puts
+        end
+
+        @aggregate_failures.each do |failed|
+          case(failed[:type])
+          when :startup
+            message = "exception raised while processing startup hook"
+          when :create
+            message = "unspecified output '#{failed[:name]}' for the action"
+          when :process_result
+            message = "exception raised while processing result data"
+          when :summarize
+            message = "exception raised while summarizing"
+          end
+
+          result.puts Util.colorize(:bold, "Summary of %s:" % failed[:name])
+          result.puts
+          result.puts Util.colorize(:yellow, "     Could not compute summary - %s" % message)
+          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", summarize = true, verbose = false)
+        result_text = []
+
+        if verbose
+            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" % [ 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" % [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]
+          result_text << "      Total Time: %.2fms"  % [@totaltime * 1000]
+        else
+          if @discovered
+            @responses < @discovered ? color = :red : color = :green
+
+            if @aggregate_summary.size + @aggregate_failures.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" % [Util.colorize(:bold, @responses), @blocktime * 1000]
+          end
+        end
+
+        no_response_r = no_response_report
+        unexpected_response_r = unexpected_response_report
+        if no_response_r || unexpected_response_r
+          result_text << ""
+        end
+
+        if no_response_r != ""
+          result_text << "" << no_response_r
+        end
+
+        if unexpected_response_r != ""
+          result_text << "" << unexpected_response_r
+        end
+
+        if no_response_r || unexpected_response_r
+          result_text << ""
+        end
+
+        result_text.join("\n")
+      end
+
+      # Returns a blob of text indicating what nodes did not respond
+      def no_response_report
+        result_text = StringIO.new
+
+        if @noresponsefrom.size > 0
+          result_text.puts Util.colorize(:red, "No response from:")
+          result_text.puts
+
+          field_size = Util.field_size(@noresponsefrom, 30)
+          fields_num = Util.field_number(field_size)
+          format = "   " + ( " %-#{field_size}s" * fields_num )
+
+          @noresponsefrom.sort.in_groups_of(fields_num) do |c|
+            result_text.puts format % c
+          end
+        end
+
+        result_text.string
+      end
+
+      # Returns a blob of text indicating what nodes responded but weren't discovered
+      def unexpected_response_report
+        result_text = StringIO.new
+
+        if @unexpectedresponsefrom.size > 0
+          result_text.puts Util.colorize(:red, "Unexpected response from:")
+          result_text.puts
+
+          field_size = Util.field_size(@unexpectedresponsefrom, 30)
+          fields_num = Util.field_number(field_size)
+          format = "   " + ( " %-#{field_size}s" * fields_num )
+
+          @unexpectedresponsefrom.sort.in_groups_of(fields_num) do |c|
+            result_text.puts format % c
+          end
+        end
+
+        result_text.string
+      end
+    end
+  end
+end