mcollective-client 1.3.3

data/bin/mc-call-agent

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'mcollective'
+require 'pp'
+
+oparser = MCollective::Optionparser.new({:verbose => true}, "filter")
+
+options = oparser.parse{|parser, options|
+    parser.define_head "Call an agent parsing an argument to it"
+    parser.banner = "Usage: mc-call-agent [options] --agent agent --argument arg"
+
+    parser.on('-a', '--agent AGENT', 'Agent to call') do |v|
+        options[:agent] = v
+    end
+
+    parser.on('--arg', '--argument ARGUMENT', 'Argument to pass to agent') do |v|
+        options[:argument] = v
+    end
+}
+
+if options[:agent] == nil || options[:argument] == nil
+    puts("Please use either --agent or --argument")
+    exit 1
+end
+
+begin
+    options[:filter]["agent"] << options[:agent]
+
+    client = MCollective::Client.new(options[:config])
+    client.options = options
+
+    c = 0
+
+    stats = client.discovered_req(options[:argument], options[:agent]) do |resp|
+        next if resp == nil
+
+        c += 1
+
+        if options[:verbose]
+            puts("#{resp[:senderid]}>")
+            pp resp[:body]
+        else
+            puts if c % 4 == 1
+            printf("%-30s", resp[:senderid])
+        end
+    end
+
+    client.disconnect
+rescue Exception => e
+    STDERR.puts "Could not call remote agent: #{e}"
+    exit 1
+end
+
+client.display_stats(stats)

data/bin/mco

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'mcollective'
+
+Version = MCollective.version
+known_applications = MCollective::Applications.list
+
+# links from mc-ping to mc will result in ping being run
+if $0 =~ /mc\-([a-zA-Z\-_\.]+)$/
+    app_name = $1
+else
+    app_name = ARGV.first
+    ARGV.delete_at(0)
+end
+
+if known_applications.include?(app_name)
+    # make sure the various options classes shows the right help etc
+    $0 = app_name
+
+    MCollective::Applications.run(app_name)
+else
+    puts "The Marionette Collective version #{MCollective.version}"
+    puts
+    puts "#{$0}: command (options)"
+    puts
+    puts "Known commands: #{known_applications.join " "}"
+end

data/lib/mcollective.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'stomp'
+require 'timeout'
+require 'digest/md5'
+require 'optparse'
+require 'singleton'
+require 'socket'
+require 'erb'
+require 'shellwords'
+require 'mcollective/monkey_patches'
+require 'tempfile'
+require 'rbconfig'
+require 'tmpdir'
+
+# == The Marionette Collective
+#
+# Framework to build and run Systems Administration agents running on a
+# publish/subscribe middleware system.  The system allows you to treat your
+# network as the only true source of the state of your platform via discovery agents
+# and allow you to run agents matching discovery criteria.
+#
+# For an overview of the idea behind this and what it enables please see:
+#   http://www.devco.net/archives/2009/10/18/middleware_for_systems_administration.php
+module MCollective
+  # Exceptions for the RPC system
+  class RPCError<StandardError;end
+  class RPCAborted<RPCError;end
+  class UnknownRPCAction<RPCError;end
+  class MissingRPCData<RPCError;end
+  class InvalidRPCData<RPCError;end
+  class UnknownRPCError<RPCError;end
+  class NotTargettedAtUs<RuntimeError;end
+  class SecurityValidationFailed<RuntimeError;end
+  class DDLValidationError<RuntimeError;end
+  class MsgTTLExpired<RuntimeError;end
+  class MsgDoesNotMatchRequestID < RuntimeError; end
+
+
+  autoload :Config, "mcollective/config"
+  autoload :Log, "mcollective/log"
+  autoload :Logger, "mcollective/logger"
+  autoload :Runner, "mcollective/runner"
+  autoload :RunnerStats, "mcollective/runnerstats"
+  autoload :Agents, "mcollective/agents"
+  autoload :Client, "mcollective/client"
+  autoload :Util, "mcollective/util"
+  autoload :Optionparser, "mcollective/optionparser"
+  autoload :Connector, "mcollective/connector"
+  autoload :Security, "mcollective/security"
+  autoload :Facts, "mcollective/facts"
+  autoload :Registration, "mcollective/registration"
+  autoload :PluginManager, "mcollective/pluginmanager"
+  autoload :RPC, "mcollective/rpc"
+  autoload :Matcher, "mcollective/matcher"
+  autoload :Message, "mcollective/message"
+  autoload :SSL, "mcollective/ssl"
+  autoload :Application, "mcollective/application"
+  autoload :Applications, "mcollective/applications"
+  autoload :Vendor, "mcollective/vendor"
+  autoload :Shell, "mcollective/shell"
+  autoload :PluginPackager, "mcollective/pluginpackager"
+
+  MCollective::Vendor.load_vendored
+
+  VERSION="@DEVELOPMENT_VERSION@"
+
+  def self.version
+    VERSION
+  end
+end

data/lib/mcollective/agents.rb

@@ -0,0 +1,160 @@
+module MCollective
+  # A collection of agents, loads them, reloads them and dispatches messages to them.
+  # It uses the PluginManager to store, load and manage instances of plugins.
+  class Agents
+    def initialize(agents = {})
+      @config = Config.instance
+      raise ("Configuration has not been loaded, can't load agents") unless @config.configured
+
+      @@agents = agents
+
+      loadagents
+    end
+
+    # Deletes all agents
+    def clear!
+      @@agents.each_key do |agent|
+        PluginManager.delete "#{agent}_agent"
+        Util.unsubscribe(Util.make_subscriptions(agent, :broadcast))
+      end
+
+      @@agents = {}
+    end
+
+    # Loads all agents from disk
+    def loadagents
+      Log.debug("Reloading all agents from disk")
+
+      clear!
+
+      @config.libdir.each do |libdir|
+        agentdir = "#{libdir}/mcollective/agent"
+        next unless File.directory?(agentdir)
+
+        Dir.new(agentdir).grep(/\.rb$/).each do |agent|
+          agentname = File.basename(agent, ".rb")
+          loadagent(agentname) unless PluginManager.include?("#{agentname}_agent")
+        end
+      end
+    end
+
+    # Loads a specified agent from disk if available
+    def loadagent(agentname)
+      agentfile = findagentfile(agentname)
+      return false unless agentfile
+      classname = class_for_agent(agentname)
+
+      PluginManager.delete("#{agentname}_agent")
+
+      begin
+        single_instance = ["registration", "discovery"].include?(agentname)
+
+        PluginManager.loadclass(classname)
+
+        if activate_agent?(agentname)
+          PluginManager << {:type => "#{agentname}_agent", :class => classname, :single_instance => single_instance}
+
+          Util.subscribe(Util.make_subscriptions(agentname, :broadcast)) unless @@agents.include?(agentname)
+
+          @@agents[agentname] = {:file => agentfile}
+          return true
+        else
+          Log.debug("Not activating agent #{agentname} due to agent policy in activate? method")
+          return false
+        end
+      rescue Exception => e
+        Log.error("Loading agent #{agentname} failed: #{e}")
+        PluginManager.delete("#{agentname}_agent")
+        return false
+      end
+    end
+
+    # Builds a class name string given a Agent name
+    def class_for_agent(agent)
+      "MCollective::Agent::#{agent.capitalize}"
+    end
+
+    # Checks if a plugin should be activated by
+    # calling #activate? on it if it responds to
+    # that method else always activate it
+    def activate_agent?(agent)
+      klass = Kernel.const_get("MCollective").const_get("Agent").const_get(agent.capitalize)
+
+      if klass.respond_to?("activate?")
+        return klass.activate?
+      else
+        Log.debug("#{klass} does not have an activate? method, activating as default")
+        return true
+      end
+    rescue Exception => e
+      Log.warn("Agent activation check for #{agent} failed: #{e.class}: #{e}")
+      return false
+    end
+
+    # searches the libdirs for agents
+    def findagentfile(agentname)
+      @config.libdir.each do |libdir|
+        agentfile = File.join([libdir, "mcollective", "agent", "#{agentname}.rb"])
+        if File.exist?(agentfile)
+          Log.debug("Found #{agentname} at #{agentfile}")
+          return agentfile
+        end
+      end
+      return false
+    end
+
+    # Determines if we have an agent with a certain name
+    def include?(agentname)
+      PluginManager.include?("#{agentname}_agent")
+    end
+
+    # Returns the help for an agent after first trying to get
+    # rid of some indentation infront
+    def help(agentname)
+      raise("No such agent") unless include?(agentname)
+
+      body = PluginManager["#{agentname}_agent"].help.split("\n")
+
+      if body.first =~ /^(\s+)\S/
+        indent = $1
+
+        body = body.map {|b| b.gsub(/^#{indent}/, "")}
+      end
+
+      body.join("\n")
+    end
+
+    # Dispatches a message to an agent, accepts a block that will get run if there are
+    # any replies to process from the agent
+    def dispatch(request, connection)
+      Log.debug("Dispatching a message to agent #{request.agent}")
+
+      Thread.new do
+        begin
+          agent = PluginManager["#{request.agent}_agent"]
+
+          Timeout::timeout(agent.timeout) do
+            replies = agent.handlemsg(request.payload, connection)
+
+            # Agents can decide if they wish to reply or not,
+            # returning nil will mean nothing goes back to the
+            # requestor
+            unless replies == nil
+              yield(replies)
+            end
+          end
+        rescue Timeout::Error => e
+          Log.warn("Timeout while handling message for #{request.agent}")
+        rescue Exception => e
+          Log.error("Execution of #{request.agent} failed: #{e}")
+          Log.error(e.backtrace.join("\n\t\t"))
+        end
+      end
+    end
+
+    # Get a list of agents that we have
+    def self.agentlist
+      @@agents.keys
+    end
+  end
+end

data/lib/mcollective/application.rb

@@ -0,0 +1,354 @@
+module MCollective
+  class Application
+    include RPC
+
+    class << self
+      # Intialize a blank set of options if its the first time used
+      # else returns active options
+      def application_options
+        intialize_application_options unless @application_options
+        @application_options
+      end
+
+      # set an option in the options hash
+      def []=(option, value)
+        intialize_application_options unless @application_options
+        @application_options[option] = value
+      end
+
+      # retrieves a specific option
+      def [](option)
+        intialize_application_options unless @application_options
+        @application_options[option]
+      end
+
+      # Sets the application description, there can be only one
+      # description per application so multiple calls will just
+      # change the description
+      def description(descr)
+        self[:description] = descr
+      end
+
+      # Supplies usage information, calling multiple times will
+      # create multiple usage lines in --help output
+      def usage(usage)
+        self[:usage] << usage
+      end
+
+      def exclude_argument_sections(*sections)
+        sections = [sections].flatten
+
+        sections.each do |s|
+          raise "Unknown CLI argument section #{s}" unless ["rpc", "common", "filter"].include?(s)
+        end
+
+        intialize_application_options unless @application_options
+        self[:exclude_arg_sections] = sections
+      end
+
+      # Wrapper to create command line options
+      #
+      #  - name: varaible name that will be used to access the option value
+      #  - description: textual info shown in --help
+      #  - arguments: a list of possible arguments that can be used
+      #    to activate this option
+      #  - type: a data type that ObjectParser understand of :bool or :array
+      #  - required: true or false if this option has to be supplied
+      #  - validate: a proc that will be called with the value used to validate
+      #    the supplied value
+      #
+      #   option :foo,
+      #          :description => "The foo option"
+      #          :arguments   => ["--foo ARG"]
+      #
+      # after this the value supplied will be in configuration[:foo]
+      def option(name, arguments)
+        opt = {:name => name,
+               :description => nil,
+               :arguments => [],
+               :type => String,
+               :required => false,
+               :validate => Proc.new { true }}
+
+        arguments.each_pair{|k,v| opt[k] = v}
+
+        self[:cli_arguments] << opt
+      end
+
+      # Creates an empty set of options
+      def intialize_application_options
+        @application_options = {:description          => nil,
+                                :usage                => [],
+                                :cli_arguments        => [],
+                                :exclude_arg_sections => []}
+      end
+    end
+
+    # The application configuration built from CLI arguments
+    def configuration
+      @application_configuration ||= {}
+      @application_configuration
+    end
+
+    # The active options hash used for MC::Client and other configuration
+    def options
+      @options
+    end
+
+    # Calls the supplied block in an option for validation, an error raised
+    # will log to STDERR and exit the application
+    def validate_option(blk, name, value)
+      validation_result = blk.call(value)
+
+      unless validation_result == true
+        STDERR.puts "Validation of #{name} failed: #{validation_result}"
+        exit 1
+      end
+    end
+
+    # Creates a standard options hash, pass in a block to add extra headings etc
+    # see Optionparser
+    def clioptions(help)
+      oparser = Optionparser.new({:verbose => false, :progress_bar => true}, "filter", application_options[:exclude_arg_sections])
+
+      options = oparser.parse do |parser, options|
+        if block_given?
+          yield(parser, options)
+        end
+
+        RPC::Helpers.add_simplerpc_options(parser, options) unless application_options[:exclude_arg_sections].include?("rpc")
+      end
+
+      return oparser.parser.help if help
+
+      validate_cli_options
+
+      post_option_parser(configuration) if respond_to?(:post_option_parser)
+
+      return options
+    rescue Exception => e
+      application_failure(e)
+    end
+
+    # Builds an ObjectParser config, parse the CLI options and validates based
+    # on the option config
+    def application_parse_options(help=false)
+      @options ||= {:verbose => false}
+
+      @options = clioptions(help) do |parser, options|
+        parser.define_head application_description if application_description
+        parser.banner = ""
+
+        if application_usage
+          parser.separator ""
+
+          application_usage.each do |u|
+            parser.separator "Usage: #{u}"
+          end
+
+          parser.separator ""
+        end
+
+        parser.define_tail ""
+        parser.define_tail "The Marionette Collective #{MCollective.version}"
+
+
+        application_cli_arguments.each do |carg|
+          opts_array = []
+
+          opts_array << :on
+
+          # if a default is set from the application set it up front
+          if carg.include?(:default)
+            configuration[carg[:name]] = carg[:default]
+          end
+
+          # :arguments are multiple possible ones
+          if carg[:arguments].is_a?(Array)
+            carg[:arguments].each {|a| opts_array << a}
+          else
+            opts_array << carg[:arguments]
+          end
+
+          # type was given and its not one of our special types, just pass it onto optparse
+          opts_array << carg[:type] if carg[:type] and ! [:bool, :array].include?(carg[:type])
+
+          opts_array << carg[:description]
+
+          # Handle our special types else just rely on the optparser to handle the types
+          if carg[:type] == :bool
+            parser.send(*opts_array) do |v|
+              validate_option(carg[:validate], carg[:name], v)
+
+              configuration[carg[:name]] = true
+            end
+
+          elsif carg[:type] == :array
+            parser.send(*opts_array) do |v|
+              validate_option(carg[:validate], carg[:name], v)
+
+              configuration[carg[:name]] = [] unless configuration.include?(carg[:name])
+              configuration[carg[:name]] << v
+            end
+
+          else
+            parser.send(*opts_array) do |v|
+              validate_option(carg[:validate], carg[:name], v)
+
+              configuration[carg[:name]] = v
+            end
+          end
+        end
+      end
+    end
+
+    def validate_cli_options
+      # Check all required parameters were set
+      validation_passed = true
+      application_cli_arguments.each do |carg|
+        # Check for required arguments
+        if carg[:required]
+          unless configuration[ carg[:name] ]
+            validation_passed = false
+            STDERR.puts "The #{carg[:name]} option is mandatory"
+          end
+        end
+      end
+
+      unless validation_passed
+        STDERR.puts "\nPlease run with --help for detailed help"
+        exit 1
+      end
+
+
+    end
+
+    # Retrieves the full hash of application options
+    def application_options
+      self.class.application_options
+    end
+
+    # Retrieve the current application description
+    def application_description
+      application_options[:description]
+    end
+
+    # Return the current usage text false if nothing is set
+    def application_usage
+      usage = application_options[:usage]
+
+      usage.empty? ? false : usage
+    end
+
+    # Returns an array of all the arguments built using
+    # calls to optin
+    def application_cli_arguments
+      application_options[:cli_arguments]
+    end
+
+    # Handles failure, if we're far enough in the initialization
+    # phase it will log backtraces if its in verbose mode only
+    def application_failure(e, err_dest=STDERR)
+      # peole can use exit() anywhere and not get nasty backtraces as a result
+      if e.is_a?(SystemExit)
+        disconnect
+        raise(e)
+      end
+
+      err_dest.puts "#{$0} failed to run: #{e} (#{e.class})"
+
+      if options.nil? || options[:verbose]
+        e.backtrace.each{|l| err_dest.puts "\tfrom #{l}"}
+      end
+
+      disconnect
+
+      exit 1
+    end
+
+    def help
+      application_parse_options(true)
+    end
+
+    # The main logic loop, builds up the options, validate configuration and calls
+    # the main as supplied by the user.  Disconnects when done and pass any exception
+    # onto the application_failure helper
+    def run
+      application_parse_options
+
+      validate_configuration(configuration) if respond_to?(:validate_configuration)
+
+      Util.setup_windows_sleeper if Util.windows?
+
+      main
+
+      disconnect
+
+    rescue Exception => e
+      application_failure(e)
+    end
+
+    def disconnect
+      MCollective::PluginManager["connector_plugin"].disconnect
+    rescue
+    end
+
+    # Fake abstract class that logs if the user tries to use an application without
+    # supplying a main override method.
+    def main
+      STDERR.puts "Applications need to supply a 'main' method"
+      exit 1
+    end
+
+    # A helper that creates a consistent exit code for applications by looking at an
+    # instance of MCollective::RPC::Stats
+    #
+    # Exit with 0 if nodes were discovered and all passed
+    # Exit with 0 if no discovery were done and > 0 responses were received
+    # Exit with 1 if no nodes were discovered
+    # Exit with 2 if nodes were discovered but some RPC requests failed
+    # Exit with 3 if nodes were discovered, but not responses receivedif
+    # Exit with 4 if no discovery were done and no responses were received
+    def halt(stats)
+      request_stats = {:discoverytime => 0,
+                       :discovered => 0,
+                       :failcount => 0}.merge(stats.to_hash)
+
+      # was discovery done?
+      if request_stats[:discoverytime] != 0
+        # was any nodes discovered
+        if request_stats[:discovered] == 0
+          exit 1
+
+        # nodes were discovered, did we get responses
+        elsif request_stats[:responses] == 0
+          exit 3
+
+        else
+          # we got responses and discovery was done, no failures
+          if request_stats[:failcount] == 0
+            exit 0
+          else
+            exit 2
+          end
+        end
+      else
+        # discovery wasnt done and we got no responses
+        if request_stats[:responses] == 0
+          exit 4
+        else
+          exit 0
+        end
+      end
+    end
+
+    # Wrapper around MC::RPC#rpcclient that forcably supplies our options hash
+    # if someone forgets to pass in options in an application the filters and other
+    # cli options wouldnt take effect which could have a disasterous outcome
+    def rpcclient(agent, flags = {})
+      flags[:options] = options unless flags.include?(:options)
+
+      super
+    end
+  end
+end