mcollective-client 1.3.3

data/lib/mcollective/rpc/progress.rb

@@ -0,0 +1,63 @@
+module MCollective
+  module RPC
+    # Class that shows a progress bar, currently only supports a twirling
+    # progress bar.
+    #
+    # You can specify a size for the progress bar if you want if you dont
+    # it will use the helper functions to figure out terminal dimensions
+    # and draw an appropriately sized bar
+    #
+    # p = Progress.new
+    # 100.times {|i| print p.twirl(i+1, 100) + "\r"};puts
+    #
+    #  * [ ==================================================> ] 100 / 100
+    class Progress
+      def initialize(size=nil)
+        @twirl = ['|', '/', '-', "\\", '|', '/', '-', "\\"]
+        @twirldex = 0
+
+        if size
+          @size = size
+        else
+          cols = Helpers.terminal_dimensions[0] - 22
+
+          # Defaults back to old behavior if it
+          # couldn't figure out the size or if
+          # its more than 60 wide
+          if cols <= 0
+            @size = 0
+          elsif cols > 60
+            @size = 60
+          else
+            @size = cols
+          end
+        end
+      end
+
+      def twirl(current, total)
+        # if the size is negative there is just not enough
+        # space on the terminal, return a simpler version
+        return "\r#{current} / #{total}" if @size == 0
+
+        if current == total
+          txt = "\r " + Helpers.colorize(:green, "*") + " [ "
+        else
+          txt = "\r #{@twirl[@twirldex]} [ "
+        end
+
+        dashes = ((current.to_f / total) * @size).round
+
+        dashes.times { txt << "=" }
+        txt << ">"
+
+        (@size - dashes).times { txt << " " }
+
+        txt << " ] #{current} / #{total}"
+
+        @twirldex == 7 ? @twirldex = 0 : @twirldex += 1
+
+        return txt
+      end
+    end
+  end
+end

data/lib/mcollective/rpc/reply.rb

@@ -0,0 +1,61 @@
+module MCollective
+  module RPC
+    # Simple class to manage compliant replies to MCollective::RPC
+    class Reply
+      attr_accessor :statuscode, :statusmsg, :data
+
+      def initialize
+        @data = {}
+        @statuscode = 0
+        @statusmsg = "OK"
+      end
+
+      # Helper to fill in statusmsg and code on failure
+      def fail(msg, code=1)
+        @statusmsg = msg
+        @statuscode = code
+      end
+
+      # Helper that fills in statusmsg and code but also raises an appropriate error
+      def fail!(msg, code=1)
+        @statusmsg = msg
+        @statuscode = code
+
+        case code
+        when 1
+          raise RPCAborted, msg
+
+        when 2
+          raise UnknownRPCAction, msg
+
+        when 3
+          raise MissingRPCData, msg
+
+        when 4
+          raise InvalidRPCData, msg
+
+        else
+          raise UnknownRPCError, msg
+        end
+      end
+
+      # Write to the data hash
+      def []=(key, val)
+        @data[key] = val
+      end
+
+      # Read from the data hash
+      def [](key)
+        @data[key]
+      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}
+      end
+    end
+  end
+end

data/lib/mcollective/rpc/request.rb

@@ -0,0 +1,51 @@
+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
+
+      def initialize(msg)
+        @time = msg[:msgtime]
+        @action = msg[:body][:action]
+        @data = msg[:body][:data]
+        @sender = msg[:senderid]
+        @agent = msg[:body][:agent]
+        @uniqid = msg[:requestid]
+        @caller = msg[:callerid] || "unknown"
+      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)
+        return @data.include?(key)
+      end
+
+      # If no :process_results is specified always respond else respond
+      # based on the supplied property
+      def should_respond?
+        return @data[:process_results] if @data.include?(:process_results)
+
+        return 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[key]
+      end
+
+      def to_hash
+        return {:agent => @agent,
+          :action => @action,
+          :data => @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,41 @@
+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
+      end
+
+      def [](idx)
+        @results[idx]
+      end
+
+      def []=(idx, item)
+        @results[idx] = item
+      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)
+      end
+    end
+  end
+end

data/lib/mcollective/rpc/stats.rb

@@ -0,0 +1,185 @@
+module MCollective
+  module RPC
+    # Class to wrap all the stats and to keep track of some timings
+    class Stats
+      attr_accessor :noresponsefrom, :starttime, :discoverytime, :blocktime, :responses, :totaltime
+      attr_accessor :discovered, :discovered_nodes, :okcount, :failcount, :noresponsefrom, :responsesfrom
+
+      def initialize
+        reset
+      end
+
+      # Resets stats, if discovery time is set we keep it as it was
+      def reset
+        @noresponsefrom = []
+        @responsesfrom = []
+        @responses = 0
+        @starttime = Time.now.to_f
+        @discoverytime = 0 unless @discoverytime
+        @blocktime = 0
+        @totaltime = 0
+        @discovered = 0
+        @discovered_nodes = []
+        @okcount = 0
+        @failcount = 0
+        @noresponsefrom = []
+      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}
+      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]
+        @responses = stats[:responses]
+        @starttime = stats[:starttime]
+        @blocktime = stats[:blocktime]
+        @totaltime = stats[:totaltime]
+        @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
+
+        # figures out who we had no responses from
+        dhosts = @discovered_nodes.clone
+        @responsesfrom.each {|r| dhosts.delete(r)}
+        @noresponsefrom = dhosts
+      rescue
+        @totaltime = 0
+        @noresponsefrom = []
+      end
+
+      # Helper to keep track of who we received responses from
+      def node_responded(node)
+        @responsesfrom << node
+      rescue
+        @responsesfrom = [node]
+      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)
+        result_text = []
+
+        if verbose
+          result_text << Helpers.colorize(:yellow, "---- #{caption} ----")
+
+          if @discovered
+            @responses < @discovered ? color = :red : color = :reset
+            result_text << "           Nodes: %s / %s" % [ Helpers.colorize(color, @discovered), Helpers.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 << "      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
+
+            result_text << "Finished processing %s / %s hosts in %.2f ms" % [Helpers.colorize(color, @responses), Helpers.colorize(color, @discovered), @blocktime * 1000]
+          else
+            result_text << "Finished processing %s hosts in %.2f ms" % [Helpers.colorize(:bold, @responses), @blocktime * 1000]
+          end
+        end
+
+        if no_response_report != ""
+          result_text << "" << no_response_report
+        end
+
+        result_text.join("\n")
+      end
+
+      # Returns a blob of text indicating what nodes did not respond
+      def no_response_report
+        result_text = []
+
+        if @noresponsefrom.size > 0
+          result_text << Helpers.colorize(:red, "\nNo response from:\n")
+
+          @noresponsefrom.each_with_index do |c,i|
+            result_text << "" if i % 4 == 0
+            result_text << "%30s" % [c]
+          end
+
+          result_text << ""
+        end
+
+        result_text.join("\n")
+      end
+    end
+  end
+end

data/lib/mcollective/runnerstats.rb

@@ -0,0 +1,90 @@
+module MCollective
+  # Class to store stats about the mcollectived, it should live in the PluginManager
+  # so that agents etc can get hold of it and return the stats to callers
+  class RunnerStats
+    def initialize
+      @starttime = Time.now.to_i
+      @validated = 0
+      @unvalidated = 0
+      @filtered = 0
+      @passed = 0
+      @total = 0
+      @replies = 0
+      @ttlexpired = 0
+
+      @mutex = Mutex.new
+    end
+
+    # Records a message that failed TTL checks
+    def ttlexpired
+      Log.debug("Incrementing ttl expired stat")
+      @ttlexpired += 1
+    end
+
+    # Records a message that passed the filters
+    def passed
+      Log.debug("Incrementing passed stat")
+      @passed += 1
+    end
+
+    # Records a message that didnt pass the filters
+    def filtered
+      Log.debug("Incrementing filtered stat")
+      @filtered += 1
+    end
+
+    # Records a message that validated ok
+    def validated
+      Log.debug("Incrementing validated stat")
+      @validated += 1
+    end
+
+    def unvalidated
+      Log.debug("Incrementing unvalidated stat")
+      @unvalidated += 1
+    end
+
+    # Records receipt of a message
+    def received
+      Log.debug("Incrementing total stat")
+      @total += 1
+    end
+
+    # Records sending a message
+    def sent
+      @mutex.synchronize do
+        Log.debug("Incrementing replies stat")
+        @replies += 1
+      end
+    end
+
+    # Returns a hash with all stats
+    def to_hash
+      stats = {:validated => @validated,
+        :unvalidated => @unvalidated,
+        :passed => @passed,
+        :filtered => @filtered,
+        :starttime => @starttime,
+        :total => @total,
+        :ttlexpired => @ttlexpired,
+        :replies => @replies}
+
+      reply = {:stats => stats,
+        :threads => [],
+        :pid => Process.pid,
+        :times => {} }
+
+      ::Process.times.each_pair{|k,v|
+        k = k.to_sym
+        reply[:times][k] = v
+      }
+
+      Thread.list.each do |t|
+        reply[:threads] << "#{t.inspect}"
+      end
+
+      reply[:agents] = Agents.agentlist
+      reply
+    end
+  end
+end