mcollective-client 2.7.0 → 2.8.0

data/lib/mcollective/agent/discovery.rb

@@ -0,0 +1,37 @@
+module MCollective
+  module Agent
+    # Discovery agent for The Marionette Collective
+    #
+    # Released under the Apache License, Version 2
+    class Discovery
+      attr_reader :timeout, :meta
+
+      def initialize
+        config = Config.instance.pluginconf
+
+        @timeout = 5
+        @meta = {:license => "Apache License, Version 2",
+                 :author => "R.I.Pienaar <rip@devco.net>",
+                 :timeout => @timeout,
+                 :name => "Discovery Agent",
+                 :version => MCollective.version,
+                 :url => "http://www.marionette-collective.org",
+                 :description => "MCollective Discovery Agent"}
+      end
+
+      def handlemsg(msg, stomp)
+        reply = "unknown request"
+
+        case msg[:body]
+          when "ping"
+            reply = "pong"
+
+          else
+            reply = "Unknown Request: #{msg[:body]}"
+        end
+
+        reply
+      end
+    end
+  end
+end

data/lib/mcollective/agent/rpcutil.ddl

@@ -0,0 +1,220 @@
+metadata    :name        => "rpcutil",
+            :description => "General helpful actions that expose stats and internals to SimpleRPC clients",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "Apache License, Version 2.0",
+            :version     => "1.0",
+            :url         => "http://marionette-collective.org/",
+            :timeout     => 10
+
+action "collective_info", :description => "Info about the main and sub collectives" do
+    display :always
+
+    output :main_collective,
+           :description => "The main Collective",
+           :display_as => "Main Collective"
+
+    output :collectives,
+           :description => "All Collectives",
+           :display_as => "All Collectives"
+
+    summarize do
+        aggregate summary(:collectives)
+    end
+end
+
+action "inventory", :description => "System Inventory" do
+    display :always
+
+    output :agents,
+           :description => "List of agent names",
+           :display_as => "Agents"
+
+    output :facts,
+           :description => "List of facts and values",
+           :display_as => "Facts"
+
+    output :classes,
+           :description => "List of classes on the system",
+           :display_as => "Classes"
+
+    output :version,
+           :description => "MCollective Version",
+           :display_as => "Version"
+
+    output :main_collective,
+           :description => "The main Collective",
+           :display_as => "Main Collective"
+
+    output :collectives,
+           :description => "All Collectives",
+           :display_as => "All Collectives"
+
+    output :data_plugins,
+           :description => "List of data plugin names",
+           :display_as => "Data Plugins"
+end
+
+action "get_fact", :description => "Retrieve a single fact from the fact store" do
+     display :always
+
+     input :fact,
+           :prompt      => "The name of the fact",
+           :description => "The fact to retrieve",
+           :type        => :string,
+           :validation  => '^[\w\-\.]+$',
+           :optional    => false,
+           :maxlength   => 40
+
+     output :fact,
+            :description => "The name of the fact being returned",
+            :display_as => "Fact"
+
+     output :value,
+            :description => "The value of the fact",
+            :display_as => "Value"
+
+    summarize do
+        aggregate summary(:value)
+    end
+end
+
+action "get_facts", :description => "Retrieve multiple facts from the fact store" do
+     display :always
+
+     input :facts,
+           :prompt      => "Comma-separated list of facts",
+           :description => "Facts to retrieve",
+           :type        => :string,
+           :validation  => '^\s*[\w\.\-]+(\s*,\s*[\w\.\-]+)*$',
+           :optional    => false,
+           :maxlength   => 200
+
+     output :values,
+            :description => "List of values of the facts",
+            :display_as => "Values"
+end
+
+action "daemon_stats", :description => "Get statistics from the running daemon" do
+    display :always
+
+    output :threads,
+           :description => "List of threads active in the daemon",
+           :display_as => "Threads"
+
+    output :agents,
+           :description => "List of agents loaded",
+           :display_as => "Agents"
+
+    output :pid,
+           :description => "Process ID of the daemon",
+           :display_as => "PID"
+
+    output :times,
+           :description => "Processor time consumed by the daemon",
+           :display_as => "Times"
+
+    output :validated,
+           :description => "Messages that passed security validation",
+           :display_as => "Security Validated"
+
+    output :unvalidated,
+           :description => "Messages that failed security validation",
+           :display_as => "Failed Security"
+
+    output :passed,
+           :description => "Passed filter checks",
+           :display_as => "Passed Filter"
+
+    output :filtered,
+           :description => "Didn't pass filter checks",
+           :display_as => "Failed Filter"
+
+    output :starttime,
+           :description => "Time the server started",
+           :display_as => "Start Time"
+
+    output :total,
+           :description => "Total messages received",
+           :display_as => "Total Messages"
+
+    output :replies,
+           :description => "Replies sent back to clients",
+           :display_as => "Replies"
+
+    output :configfile,
+           :description => "Config file used to start the daemon",
+           :display_as => "Config File"
+
+    output :version,
+           :description => "MCollective Version",
+           :display_as => "Version"
+
+    output :ttlexpired,
+           :description => "Messages that did pass TTL checks",
+           :display_as => "TTL Expired"
+
+    summarize do
+        aggregate summary(:version)
+        aggregate summary(:agents)
+    end
+end
+
+action "agent_inventory", :description => "Inventory of all agents on the server" do
+    display :always
+
+    output :agents,
+           :description => "List of agents on the server",
+           :display_as => "Agents"
+end
+
+action "get_config_item", :description => "Get the active value of a specific config property" do
+    display :always
+
+    input :item,
+          :prompt      => "Configuration Item",
+          :description => "The item to retrieve from the server",
+          :type        => :string,
+          :validation  => '^.+$',
+          :optional    => false,
+          :maxlength    => 50
+
+    output :item,
+           :description => "The config property being retrieved",
+           :display_as => "Property"
+
+    output :value,
+           :description => "The value that is in use",
+           :display_as => "Value"
+
+    summarize do
+        aggregate summary(:value)
+    end
+end
+
+action "get_data", :description => "Get data from a data plugin" do
+    display :always
+
+    input :source,
+          :prompt      => "Data Source",
+          :description => "The data plugin to retrieve information from",
+          :type        => :string,
+          :validation  => '^\w+$',
+          :optional    => false,
+          :maxlength   => 50
+
+    input :query,
+          :prompt      => "Query",
+          :description => "The query argument to supply to the data plugin",
+          :type        => :string,
+          :validation  => '^.+$',
+          :optional    => true,
+          :maxlength   => 200
+end
+
+action "ping", :description => "Responds to requests for PING with PONG" do
+    display :always
+
+    output :pong,
+           :description => "The local timestamp",
+           :display_as => "Timestamp"
+end

data/lib/mcollective/agent/rpcutil.rb

@@ -0,0 +1,108 @@
+module MCollective
+  module Agent
+    class Rpcutil<RPC::Agent
+      # Basic system inventory, same as the basic discovery agent
+      action "inventory" do
+        reply[:agents] = Agents.agentlist
+        reply[:facts] = PluginManager["facts_plugin"].get_facts
+        reply[:version] = MCollective.version
+        reply[:classes] = []
+        reply[:main_collective] = config.main_collective
+        reply[:collectives] = config.collectives
+        reply[:data_plugins] = PluginManager.grep(/_data$/)
+
+        cfile = Config.instance.classesfile
+        if File.exist?(cfile)
+          reply[:classes] = File.readlines(cfile).map {|i| i.chomp}
+        end
+      end
+
+      # Retrieve a single fact from the node
+      action "get_fact" do
+        reply[:fact] = request[:fact]
+        reply[:value] = Facts[request[:fact]]
+      end 
+
+      action "get_facts" do
+        response = {}
+        request[:facts].split(',').map { |x| x.strip }.each do |fact|
+          value = Facts[fact]
+          response[fact] = value
+        end
+        reply[:values] = response
+      end
+
+      # Get the global stats for this mcollectied
+      action "daemon_stats" do
+        stats = PluginManager["global_stats"].to_hash
+
+        reply[:threads] = stats[:threads]
+        reply[:agents] = stats[:agents]
+        reply[:pid] = stats[:pid]
+        reply[:times] = stats[:times]
+        reply[:configfile] = Config.instance.configfile
+        reply[:version] = MCollective.version
+
+        reply.data.merge!(stats[:stats])
+      end
+
+      # Builds an inventory of all agents on teh machine
+      # including license, version and timeout information
+      action "agent_inventory" do
+        reply[:agents] = []
+
+        Agents.agentlist.sort.each do |target_agent|
+          agent = PluginManager["#{target_agent}_agent"]
+          actions = agent.methods.grep(/_agent/)
+
+          agent_data = {:agent => target_agent,
+                        :license => "unknown",
+                        :timeout => agent.timeout,
+                        :description => "unknown",
+                        :name => target_agent,
+                        :url => "unknown",
+                        :version => "unknown",
+                        :author => "unknown"}
+
+          agent_data.merge!(agent.meta)
+
+          reply[:agents] << agent_data
+        end
+      end
+
+      # Retrieves a single config property that is in effect
+      action "get_config_item" do
+        reply.fail! "Unknown config property #{request[:item]}" unless config.respond_to?(request[:item])
+
+        reply[:item] = request[:item]
+        reply[:value] = config.send(request[:item])
+      end
+
+      # Responds to PING requests with the local timestamp
+      action "ping" do
+        reply[:pong] = Time.now.to_i
+      end
+
+      # Returns all configured collectives
+      action "collective_info" do
+        config = Config.instance
+        reply[:main_collective] = config.main_collective
+        reply[:collectives] = config.collectives
+      end
+
+      action "get_data" do
+        if request[:query]
+          query = Data.ddl_transform_input(Data.ddl(request[:source]), request[:query].to_s)
+        else
+          query = nil
+        end
+
+        data = Data[ request[:source] ].lookup(query)
+
+        data.keys.each do |key|
+          reply[key] = data[key]
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/aggregate/average.ddl

@@ -0,0 +1,33 @@
+metadata  :name        => "average",
+          :description => "Displays the average of a set of numeric values",
+          :author      => "Pieter Loubser <pieter.loubser@puppetlabs.com>",
+          :license     => "ASL 2.0",
+          :version     => "1.0",
+          :url         => "http://projects.puppetlabs.com/projects/mcollective-plugins/wiki",
+          :timeout     => 5
+
+usage <<-USAGE
+
+  This aggregate plugin will determine te average of a set of numeric values.
+
+  DDL Example:
+
+    summarize do
+      aggregate average(:value)
+    end
+
+  Sample Output:
+
+    host1.example.com
+      Value: 10
+
+    host2.example.com
+      Value: 20
+
+
+   Summary of Value:
+
+      Average of Value: 15.000000
+
+USAGE
+

data/lib/mcollective/aggregate/average.rb

@@ -0,0 +1,29 @@
+module MCollective
+  class Aggregate
+    class Average<Base
+      # Before function is run processing
+      def startup_hook
+        @result[:value] = 0
+        @result[:type] = :numeric
+
+        @count = 0
+
+        # Set default aggregate_function if it is undefined
+        @aggregate_format = "Average of #{@result[:output]}: %f" unless @aggregate_format
+      end
+
+      # Determines the average of a set of numerical values
+      def process_result(value, reply)
+        @result[:value] += value
+        @count += 1
+      end
+
+      # Stops execution of the function and returns a ResultObject
+      def summarize
+        @result[:value] /= @count
+
+        result_class(:numeric).new(@result, @aggregate_format, @action)
+      end
+    end
+  end
+end

data/lib/mcollective/aggregate/result.rb

@@ -1,9 +1,9 @@
 module MCollective
   class Aggregate
     module Result
-      autoload :Base, 'mcollective/aggregate/result/base'
-      autoload :NumericResult, 'mcollective/aggregate/result/numeric_result'
-      autoload :CollectionResult, 'mcollective/aggregate/result/collection_result'
+      require 'mcollective/aggregate/result/base'
+      require 'mcollective/aggregate/result/numeric_result'
+      require 'mcollective/aggregate/result/collection_result'
     end
   end
 end

data/lib/mcollective/aggregate/sum.ddl

@@ -0,0 +1,33 @@
+metadata  :name        => "Sum",
+          :description => "Determine the total added value of a set of values",
+          :author      => "Pieter Loubser <pieter.loubser@puppetlabs.com>",
+          :license     => "ASL 2.0",
+          :version     => "1.0",
+          :url         => "http://projects.puppetlabs.com/projects/mcollective-plugins/wiki",
+          :timeout     => 5
+
+usage <<-USAGE
+
+  This aggregate plugin will determine the total added value of a set of values.
+
+  DDL Example:
+
+    summarize do
+      aggregate sum(:value)
+    end
+
+  Sample Output:
+
+    host1.example.com
+      Value: 10
+
+    host2.example.com
+      Value: 20
+
+
+   Summary of Value:
+
+      Sum of Value: 30
+
+USAGE
+

data/lib/mcollective/aggregate/sum.rb

@@ -0,0 +1,18 @@
+module MCollective
+  class Aggregate
+    class Sum<Base
+      def startup_hook
+        @result[:value] = 0
+        @result[:type] = :numeric
+
+        # Set default aggregate_function if it is undefined
+        @aggregate_format = "Sum of #{@result[:output]}: %f" unless @aggregate_format
+      end
+
+      # Determines the average of a set of numerical values
+      def process_result(value, reply)
+        @result[:value] += value
+      end
+    end
+  end
+end

data/lib/mcollective/aggregate/summary.ddl

@@ -0,0 +1,33 @@
+metadata  :name        => "summary",
+          :description => "Displays the summary of a set of results",
+          :author      => "Pieter Loubser <pieter.loubser@puppetlabs.com>",
+          :license     => "ASL 2.0",
+          :version     => "1.0",
+          :url         => "http://projects.puppetlabs.com/projects/mcollective-plugins/wiki",
+          :timeout     => 5
+
+usage <<-USAGE
+
+  This aggregate plugin will display the summary of a set of results.
+
+  DDL Example:
+
+    summarize do
+      aggregate summary(:value)
+    end
+
+  Sample Output:
+
+    host1.example.com
+      Property: collectives
+          Value: ["mcollective", "uk_collective"]
+
+    Summary of Value:
+
+        mcollective = 25
+      uk_collective = 15
+      fr_collective = 9
+      us_collective = 1
+
+USAGE
+

data/lib/mcollective/aggregate/summary.rb

@@ -0,0 +1,53 @@
+module MCollective
+  class Aggregate
+    class Summary<Base
+      # Before function is run processing
+      def startup_hook
+        @result[:value] = {}
+        @result[:type] = :collection
+
+        # set default aggregate_format if it is undefined
+        @aggregate_format = :calculate unless @aggregate_format
+      end
+
+      # Increments the value field if value has been seen before
+      # Else create a new value field
+      def process_result(value, reply)
+        unless value.nil?
+          if value.is_a? Array
+            value.map{|val| add_value(val)}
+          else
+            add_value(value)
+          end
+        end
+      end
+
+      def add_value(value)
+        if @result[:value].keys.include?(value)
+          @result[:value][value] += 1
+        else
+          @result[:value][value] = 1
+        end
+      end
+
+      def summarize
+        if @aggregate_format == :calculate
+          max_key_length = @result[:value].keys.map do |k|
+
+            # Response values retain their types. Here we check
+            # if the response is a string and turn it into a string
+            # if it isn't one.
+            if k.respond_to?(:length)
+              k.length
+            elsif k.respond_to?(:to_s)
+              k.to_s.length
+            end
+          end.max
+          @aggregate_format = "%#{max_key_length}s = %s"
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/mcollective/aggregate.rb

@@ -1,7 +1,7 @@
 module MCollective
   class Aggregate
-    autoload :Result, 'mcollective/aggregate/result'
-    autoload :Base, 'mcollective/aggregate/base'
+    require 'mcollective/aggregate/result'
+    require 'mcollective/aggregate/base'
 
     attr_accessor :ddl, :functions, :action, :failed
 

data/lib/mcollective/application/completion.rb

@@ -0,0 +1,104 @@
+module MCollective
+  class Application::Completion<MCollective::Application
+    description "Helper for shell completion systems"
+
+    exclude_argument_sections "common", "filter", "rpc"
+
+    option :list_agents,
+           :description => "List all known agents",
+           :arguments => "--list-agents",
+           :required => false,
+           :type => :boolean
+
+    option :list_actions,
+           :description => "List all actions for an agent",
+           :arguments => "--list-actions",
+           :required => false,
+           :type => :boolean
+
+    option :list_inputs,
+           :description => "List all inputs for an action",
+           :arguments => "--list-inputs",
+           :required => false,
+           :type => :boolean
+
+    option :list_applications,
+           :description => "List all known applications",
+           :arguments => "--list-applications",
+           :required => false,
+           :type => :boolean
+
+    option :agent,
+           :description => "The agent to operate on",
+           :arguments => "--agent AGENT",
+           :required => false
+
+    option :action,
+           :description => "The action to operate on",
+           :arguments => "--action ACTION",
+           :required => false
+
+    def list_agents
+      if options[:verbose]
+        PluginManager.find(:agent, "ddl").each do |agent|
+          begin
+            ddl = DDL.new(agent)
+            puts "%s:%s" % [ agent, ddl.meta[:description] ]
+          rescue
+          end
+        end
+      else
+        PluginManager.find(:agent, "ddl").each {|p| puts p}
+      end
+    end
+
+    def list_actions
+      abort "Please specify an agent to list actions for" unless configuration[:agent]
+
+      if options[:verbose]
+        ddl = DDL.new(configuration[:agent], :agent)
+
+        ddl.actions.sort.each do |action|
+          puts "%s:%s" % [action, ddl.action_interface(action)[:description]]
+        end
+      else
+        DDL.new(configuration[:agent], :agent).actions.sort.each {|a| puts a}
+      end
+    rescue
+    end
+
+    def list_inputs
+      abort "Please specify an action and agent to list inputs for" unless configuration[:agent] && configuration[:action]
+
+      if options[:verbose]
+        ddl = DDL.new(configuration[:agent], :agent)
+        action = ddl.action_interface(configuration[:action])
+        action[:input].keys.sort.each do |input|
+          puts "%s:%s" % [input, action[:input][input][:description]]
+        end
+      else
+        DDL.new(configuration[:agent], :agent).action_interface(configuration[:action])[:input].keys.sort.each {|i| puts i}
+      end
+    rescue
+    end
+
+    def list_applications
+      if options[:verbose]
+        Applications.list.each do |app|
+          puts "%s:%s" % [app, Applications[app].application_description]
+        end
+      else
+        Applications.list.each {|a| puts a}
+      end
+    end
+
+    def main
+      actions = configuration.keys.map{|k| k.to_s}.grep(/^list_/)
+
+      abort "Please choose either --list-[agents|actions|inputs|applications]" if actions.empty?
+      abort "Please choose only one of --list-[agents|actions|inputs|applications]" if actions.size > 1
+
+      send actions.first
+    end
+  end
+end