mcollective-client 2.7.0 → 2.8.0

data/lib/mcollective/application/plugin.rb

@@ -0,0 +1,369 @@
+module MCollective
+  class Application::Plugin<Application
+
+    exclude_argument_sections "common", "filter", "rpc"
+
+    description "MCollective Plugin Application"
+    usage <<-END_OF_USAGE
+mco plugin package [options] <directory>
+       mco plugin info <directory>
+       mco plugin doc <plugin>
+       mco plugin doc <type/plugin>
+       mco plugin generate agent <pluginname> [actions=val,val]
+       mco plugin generate data <pluginname> [outputs=val,val]
+
+          info : Display plugin information including package details.
+       package : Create all available plugin packages.
+           doc : Display documentation for a specific plugin.
+    END_OF_USAGE
+
+    option :pluginname,
+           :description => 'Plugin name',
+           :arguments   => ['-n', '--name NAME'],
+           :type        => String
+
+    option :postinstall,
+           :description => 'Post install script',
+           :arguments   => ['--postinstall POSTINSTALL'],
+           :type        => String
+
+    option :preinstall,
+           :description => 'Pre install script',
+           :arguments   => ['--preinstall PREINSTALL'],
+           :type        => String
+
+    option :revision,
+           :description => 'Revision number',
+           :arguments   => ['--revision REVISION'],
+           :type        => String
+
+    option :iteration,
+           :description => 'DEPRECATED - Use --revision instead',
+           :arguments   => ['--iteration ITERATION'],
+           :type        => String
+
+    option :vendor,
+           :description => 'Vendor name',
+           :arguments   => ['--vendor VENDOR'],
+           :type        => String
+
+    option :pluginpath,
+           :description => 'MCollective plugin path',
+           :arguments   => ['--pluginpath PATH'],
+           :type        => String
+
+    option :mcname,
+           :description => 'MCollective type (mcollective, pe-mcollective) that the packages depend on',
+           :arguments   => ['--mcname NAME'],
+           :type        => String
+
+    option :mcversion,
+           :description => 'Version of MCollective that the packages depend on',
+           :arguments   => ['--mcversion MCVERSION'],
+           :type        => String
+
+    option :dependency,
+           :description => 'Adds a dependency to the plugin',
+           :arguments   => ['--dependency DEPENDENCIES'],
+           :type        => :array
+
+    option :format,
+           :description => 'Package output format. Defaults to rpmpackage or debpackage',
+           :arguments   => ['--format OUTPUTFORMAT'],
+           :type        => String
+
+    option :sign,
+           :description => 'Embed a signature in the package',
+           :arguments   => ['--sign'],
+           :type        => :boolean
+
+    option :rpctemplate,
+           :description => 'Template to use.',
+           :arguments   => ['--template HELPTEMPLATE'],
+           :type        => String
+
+    option :description,
+           :description => 'Plugin description',
+           :arguments   => ['--description DESCRIPTION'],
+           :type        => String
+
+    option :author,
+           :description => 'The author of the plugin',
+           :arguments   => ['--author AUTHOR'],
+           :type        => String
+
+    option :license,
+           :description => 'The license under which the plugin is distributed',
+           :arguments   => ['--license LICENSE'],
+           :type        => String
+
+    option :version,
+           :description => 'The version of the plugin',
+           :arguments   => ['--pluginversion VERSION'],
+           :type        => String
+
+    option :url,
+           :description => 'Url at which information about the plugin can be found',
+           :arguments   => ['--url URL'],
+           :type        => String
+
+    option :timeout,
+           :description => "The plugin's timeout",
+           :arguments   => ['--timeout TIMEOUT'],
+           :type        => Integer
+
+    option :actions,
+           :description => 'Actions to be generated for an Agent Plugin',
+           :arguments   => ['--actions [ACTIONS]'],
+           :type        => Array
+
+    option :outputs,
+           :description => 'Outputs to be generated for an Data Plugin',
+           :arguments   => ['--outputs [OUTPUTS]'],
+           :type        => Array
+
+    option :keep_artifacts,
+           :description => "Don't remove artifacts after building packages",
+           :arguments   => ['--keep-artifacts'],
+           :type        => :boolean
+
+    option :module_template,
+           :description => "Path to the template used by the modulepackager",
+           :arguments   => ['--module-template PATH'],
+           :type        => String
+
+    # Handle alternative format that optparser can't parse.
+    def post_option_parser(configuration)
+      if ARGV.length >= 1
+        configuration[:action] = ARGV.delete_at(0)
+
+        configuration[:target] = ARGV.delete_at(0) || "."
+
+        if configuration[:action] == "generate"
+          unless ARGV[0] && ARGV[0].match(/(actions|outputs)=(.+)/i)
+            unless configuration[:pluginname]
+              configuration[:pluginname] = ARGV.delete_at(0)
+            else
+              ARGV.delete_at(0)
+            end
+          end
+
+          ARGV.each do |argument|
+            if argument.match(/(actions|outputs)=(.+)/i)
+              configuration[$1.downcase.to_sym]= $2.split(",")
+            else
+              raise "Could not parse --arg '#{argument}'"
+            end
+          end
+        end
+      end
+    end
+
+    # Display info about plugin
+    def info_command
+      plugin = prepare_plugin
+      packager = PluginPackager["#{configuration[:format].capitalize}Packager"]
+      packager.new(plugin).package_information
+    end
+
+    # Generate a plugin skeleton
+    def generate_command
+      raise "undefined plugin type. cannot generate plugin. valid types are 'agent' and 'data'" if configuration["target"] == '.'
+
+      unless configuration[:pluginname]
+        puts "No plugin name specified. Using 'new_plugin'"
+        configuration[:pluginname] = "new_plugin"
+      end
+
+      load_plugin_config_values
+
+      case configuration[:target].downcase
+      when 'agent'
+        Generators::AgentGenerator.new(configuration[:pluginname], configuration[:actions], configuration[:pluginname],
+                                       configuration[:description], configuration[:author], configuration[:license],
+                                       configuration[:version], configuration[:url], configuration[:timeout])
+      when 'data'
+        raise "data plugin must have at least one output" unless configuration[:outputs]
+        Generators::DataGenerator.new(configuration[:pluginname], configuration[:outputs], configuration[:pluginname],
+                                       configuration[:description], configuration[:author], configuration[:license],
+                                       configuration[:version], configuration[:url], configuration[:timeout])
+      else
+        raise "invalid plugin type. cannot generate plugin '#{configuration[:target]}'"
+      end
+    end
+
+    # Package plugin
+    def package_command
+      if configuration[:sign] && Config.instance.pluginconf.include?("debian_packager.keyname")
+        configuration[:sign] = Config.instance.pluginconf["debian_packager.keyname"]
+        configuration[:sign] = "\"#{configuration[:sign]}\"" unless configuration[:sign].match(/\".*\"/)
+      end
+
+      plugin = prepare_plugin
+      (configuration[:pluginpath] = configuration[:pluginpath] + "/") if (configuration[:pluginpath] && !configuration[:pluginpath].match(/^.*\/$/))
+      packager = PluginPackager["#{configuration[:format].capitalize}Packager"]
+      packager.new(plugin, configuration[:pluginpath], configuration[:sign],
+                   options[:verbose], configuration[:keep_artifacts],
+                   configuration[:module_template]).create_packages
+    end
+
+    # Agents are just called 'agent' but newer plugin types are
+    # called plugin_plugintype for example facter_facts etc so
+    # this will first try the old way then the new way.
+    def load_plugin_ddl(plugin, type)
+      [plugin, "#{plugin}_#{type}"].each do |p|
+        ddl = DDL.new(p, type, false)
+        if ddl.findddlfile(p, type)
+          ddl.loadddlfile
+          return ddl
+        end
+      end
+
+      return nil
+    end
+
+    # Show application list and plugin help
+    def doc_command
+      known_plugin_types = [["Agents", :agent], ["Aggregate", :aggregate],
+                            ["Connectors", :connector], ["Data Queries", :data],
+                            ["Discovery Methods", :discovery], ["Validator Plugins", :validator]]
+
+      if configuration.include?(:target) && configuration[:target] != "."
+        if configuration[:target] =~ /^(.+?)\/(.+)$/
+          ddl = load_plugin_ddl($2.to_sym, $1)
+        else
+          found_plugin_type = nil
+
+          known_plugin_types.each do |plugin_type|
+            PluginManager.find(plugin_type[1], "ddl").each do |ddl|
+              pluginname = ddl.gsub(/_#{plugin_type[1]}$/, "")
+              if pluginname == configuration[:target]
+                abort "Duplicate plugin name found, please specify a full path like agent/rpcutil" if found_plugin_type
+                found_plugin_type = plugin_type[1]
+              end
+            end
+          end
+
+          abort "Could not find a plugin named '%s' in any supported plugin type" % configuration[:target] unless found_plugin_type
+          ddl = load_plugin_ddl(configuration[:target], found_plugin_type)
+        end
+
+        if ddl
+          puts ddl.help(configuration[:rpctemplate])
+        else
+          abort "Could not find a '%s' plugin named '%s'" % configuration[:target].split('/')
+        end
+
+      else
+        puts "Please specify a plugin. Available plugins are:"
+        puts
+
+        load_errors = []
+
+        known_plugin_types.each do |plugin_type|
+          puts "%s:" % plugin_type[0]
+
+          PluginManager.find(plugin_type[1], "ddl").each do |ddl|
+            begin
+              help = DDL.new(ddl, plugin_type[1])
+              pluginname = ddl.gsub(/_#{plugin_type[1]}$/, "")
+              puts "  %-25s %s" % [pluginname, help.meta[:description]]
+            rescue => e
+              load_errors << [plugin_type[1], ddl, e]
+            end
+          end
+
+          puts
+        end
+
+        unless load_errors.empty?
+          puts "Plugin Load Errors:"
+
+          load_errors.each do |e|
+            puts "  %-25s %s" % ["#{e[0]}/#{e[1]}", Util.colorize(:yellow, e[2])]
+          end
+        end
+      end
+    end
+
+    # Creates the correct package plugin object.
+    def prepare_plugin
+      plugintype = set_plugin_type unless configuration[:plugintype]
+      configuration[:format] = "ospackage" unless configuration[:format]
+      PluginPackager.load_packagers
+      plugin_class = PluginPackager[configuration[:plugintype]]
+
+      if configuration[:dependency] && configuration[:dependency].size == 1
+        configuration[:dependency] = configuration[:dependency][0].split(" ")
+      elsif configuration[:dependency]
+        configuration[:dependency].map!{|dep| {:name => dep, :version => nil}}
+      end
+
+      mcdependency = {:mcname => configuration[:mcname], :mcversion => configuration[:mcversion]}
+
+      # Deprecation warning for --iteration
+      if configuration[:iteration]
+        puts 'Warning. The --iteration flag has been deprecated. Please use --revision instead.'
+        configuration[:revision] = configuration[:iteration] unless configuration[:revision]
+      end
+
+      plugin_class.new(configuration, mcdependency, plugintype)
+    end
+
+    def plugin_directory_exists?(plugin_type)
+      File.directory?(File.join(PluginPackager.get_plugin_path(configuration[:target]), plugin_type))
+    end
+
+    # Identify plugin type if not provided.
+    def set_plugin_type
+      if plugin_directory_exists?("agent") || plugin_directory_exists?("application")
+        configuration[:plugintype] = "AgentDefinition"
+        return "Agent"
+      elsif plugin_directory_exists?(plugintype = identify_plugin)
+        configuration[:plugintype] = "StandardDefinition"
+        return plugintype
+      else
+        raise RuntimeError, "target directory is not a valid mcollective plugin"
+      end
+    end
+
+    # If plugintype is StandardDefinition, identify which of the special
+    # plugin types we are dealing with based on directory structure.
+    # To keep it simple we limit it to one type per target directory.
+    # Return the name of the type of plugin as a string
+    def identify_plugin
+      plugintype = Dir.glob(File.join(configuration[:target], "*")).select do |file|
+        File.directory?(file) && file.match(/(connector|facts|registration|security|audit|pluginpackager|data|discovery|validator)/)
+      end
+
+      raise RuntimeError, "more than one plugin type detected in directory" if plugintype.size > 1
+      raise RuntimeError, "no plugins detected in directory" if plugintype.size < 1
+
+      File.basename(plugintype[0])
+    end
+
+    # Load preset metadata values from config if they are present
+    # This makes it possible to override metadata values in a local
+    # client config file.
+    #
+    # Example : plugin.metadata.license = Apache 2
+    def load_plugin_config_values
+      config = Config.instance
+      [:pluginname, :description, :author, :license, :version, :url, :timeout].each do |confoption|
+        configuration[confoption] = config.pluginconf["metadata.#{confoption}"] unless configuration[confoption]
+      end
+    end
+
+    def main
+        abort "No action specified, please run 'mco help plugin' for help" unless configuration.include?(:action)
+
+        cmd = "#{configuration[:action]}_command"
+
+        if respond_to? cmd
+          send cmd
+        else
+          abort "Invalid action #{configuration[:action]}, please run 'mco help plugin' for help."
+        end
+    end
+  end
+end

data/lib/mcollective/application/rpc.rb

@@ -0,0 +1,121 @@
+class MCollective::Application::Rpc<MCollective::Application
+  description "Generic RPC agent client application"
+
+  usage "mco rpc [options] [filters] --agent <agent> --action <action> [--argument <key=val> --argument ...]"
+  usage "mco rpc [options] [filters] <agent> <action> [<key=val> <key=val> ...]"
+
+  option :show_results,
+         :description    => "Do not process results, just send request",
+         :arguments      => ["--no-results", "--nr"],
+         :default        => true,
+         :type           => :bool
+
+  option :agent,
+         :description    => "Agent to call",
+         :arguments      => ["-a", "--agent AGENT"]
+
+  option :action,
+         :description    => "Action to call",
+         :arguments      => ["--action ACTION"]
+
+  option :arguments,
+         :description    => "Arguments to pass to agent",
+         :arguments      => ["--arg", "--argument ARGUMENT"],
+         :type           => :array,
+         :default        => [],
+         :validate       => Proc.new {|val| val.match(/^(.+?)=(.+)$/) ? true : "Could not parse --arg #{val} should be of the form key=val" }
+
+  def post_option_parser(configuration)
+    # handle the alternative format that optparse cant parse
+    unless (configuration.include?(:agent) && configuration.include?(:action))
+      if ARGV.length >= 2
+        configuration[:agent] = ARGV[0]
+        ARGV.delete_at(0)
+
+        configuration[:action] = ARGV[0]
+        ARGV.delete_at(0)
+
+        ARGV.each do |v|
+          if v =~ /^(.+?)=(.+)$/
+            configuration[:arguments] = [] unless configuration.include?(:arguments)
+            configuration[:arguments] << v
+          else
+            STDERR.puts("Could not parse --arg #{v}")
+            exit(1)
+          end
+        end
+      else
+        STDERR.puts("No agent, action and arguments specified")
+        exit(1)
+      end
+    end
+
+    # convert arguments to symbols for keys to comply with simplerpc conventions
+    args = configuration[:arguments].clone
+    configuration[:arguments] = {}
+
+    args.each do |v|
+      if v =~ /^(.+?)=(.+)$/
+        configuration[:arguments][$1.to_sym] = $2
+      end
+    end
+  end
+
+  def string_to_ddl_type(arguments, ddl)
+    return if ddl.empty?
+
+    arguments.keys.each do |key|
+      if ddl[:input].keys.include?(key)
+        case ddl[:input][key][:type]
+          when :boolean
+            arguments[key] = MCollective::DDL.string_to_boolean(arguments[key])
+
+          when :number, :integer, :float
+            arguments[key] = MCollective::DDL.string_to_number(arguments[key])
+        end
+      end
+    end
+  end
+
+  def main
+    mc = rpcclient(configuration[:agent])
+
+    mc.agent_filter(configuration[:agent])
+
+    string_to_ddl_type(configuration[:arguments], mc.ddl.action_interface(configuration[:action])) if mc.ddl
+
+    mc.validate_request(configuration[:action], configuration[:arguments])
+
+    if mc.reply_to
+      configuration[:arguments][:process_results] = true
+
+      puts "Request sent with id: " + mc.send(configuration[:action], configuration[:arguments]) + " replies to #{mc.reply_to}"
+    elsif !configuration[:show_results]
+      configuration[:arguments][:process_results] = false
+
+      puts "Request sent with id: " + mc.send(configuration[:action], configuration[:arguments])
+    else
+      discover_args = {:verbose => true}
+      # IF the discovery method hasn't been explicitly overridden
+      #  and we're not being run interactively,
+      #  and someone has piped us some data
+      # Then we assume it's a discovery list - this can be either:
+      #  - list of hosts in plaintext
+      #  - JSON that came from another rpc or printrpc
+      if mc.default_discovery_method && !STDIN.tty? && !STDIN.eof?
+          # Then we override discovery to try to grok the data on STDIN
+          mc.discovery_method = 'stdin'
+          mc.discovery_options = 'auto'
+          discover_args = {:verbose => false}
+      end
+
+      mc.discover discover_args
+
+      printrpc mc.send(configuration[:action], configuration[:arguments])
+
+      printrpcstats :summarize => true, :caption => "#{configuration[:agent]}##{configuration[:action]} call stats" if mc.discover.size > 0
+
+      halt mc.stats
+    end
+  end
+end

data/lib/mcollective/application.rb

@@ -1,3 +1,5 @@
+require 'mcollective/rpc'
+
 module MCollective
   class Application
     include RPC

data/lib/mcollective/audit/logfile.rb

@@ -0,0 +1,26 @@
+module MCollective
+  module RPC
+    # An audit plugin that just logs to a file
+    #
+    # You can configure which file it logs to with the setting
+    #
+    #   plugin.rpcaudit.logfile
+
+    class Logfile<Audit
+      require 'pp'
+
+      def audit_request(request, connection)
+        logfile = Config.instance.pluginconf["rpcaudit.logfile"] || "/var/log/mcollective-audit.log"
+
+        now = Time.now
+        # Already told timezone to be in UTC so we don't look it up again
+        # This avoids platform specific timezone representation issues
+        now_iso8601 = now.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+
+        File.open(logfile, "a") do |f|
+          f.puts("[#{now_iso8601}] reqid=#{request.uniqid}: reqtime=#{request.time} caller=#{request.caller}@#{request.sender} agent=#{request.agent} action=#{request.action} data=#{request.data.pretty_print_inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/config.rb

@@ -5,7 +5,7 @@ module MCollective
 
     attr_accessor :mode
 
-    attr_reader :daemonize, :pluginconf, :libdir, :configured
+    attr_reader :daemonize, :pluginconf, :configured
     attr_reader :logfile, :keeplogs, :max_log_size, :loglevel, :logfacility
     attr_reader :identity, :daemonize, :connector, :securityprovider, :factsource
     attr_reader :registration, :registerinterval, :classesfile
@@ -27,6 +27,7 @@ module MCollective
       set_config_defaults(configfile)
 
       if File.exists?(configfile)
+        libdirs = []
         File.readlines(configfile).each do |line|
 
           # strip blank spaces, tabs etc off the end of all lines
@@ -66,10 +67,7 @@ module MCollective
                   paths.each do |path|
                     raise("libdir paths should be absolute paths but '%s' is relative" % path) unless Util.absolute_path?(path)
 
-                    @libdir << path
-                    unless $LOAD_PATH.include?(path)
-                      $LOAD_PATH << path
-                    end
+                    libdirs << path
                   end
                 when "identity"
                   @identity = val
@@ -139,15 +137,21 @@ module MCollective
           end
         end
 
-        raise('The %s config file does not specify a libdir setting, cannot continue' % configfile) if @libdir.empty?
-
         read_plugin_config_dir("#{@configdir}/plugin.d")
 
         raise 'Identities can only match /\w\.\-/' unless @identity.match(/^[\w\.\-]+$/)
 
         @configured = true
 
-        @libdir.each {|dir| Log.warn("Cannot find libdir: #{dir}") unless File.directory?(dir)}
+        libdirs.each do |dir|
+          unless File.directory?(dir)
+            Log.warn("Cannot find libdir: #{dir}")
+          end
+
+          # remove the old one if it exists, we're moving it to the front
+          $LOAD_PATH.reject! { |elem| elem == dir }
+          $LOAD_PATH.unshift dir
+        end
 
         if @logger_type == "syslog"
           raise "The sylog logger is not usable on the Windows platform" if Util.windows?
@@ -190,7 +194,6 @@ module MCollective
       @keeplogs = 5
       @max_log_size = 2097152
       @rpclimitmethod = :first
-      @libdir = Array.new
       @fact_cache_time = 300
       @loglevel = "info"
       @logfacility = "user"
@@ -211,6 +214,10 @@ module MCollective
       @connection_timeout = nil
     end
 
+    def libdir
+      $LOAD_PATH
+    end
+
     def read_plugin_config_dir(dir)
       return unless File.directory?(dir)
 

data/lib/mcollective/connector/activemq.ddl

@@ -0,0 +1,9 @@
+metadata    :name        => "ActiveMQ Connector",
+            :description => "Connector plugin for ActiveMQ middleware",
+            :author      => "Puppet Labs",
+            :license     => "ASL 2.0",
+            :version     => "1.0.0",
+            :url         => "http://projects.puppetlabs.com/projects/mcollective-plugins/wiki",
+            :timeout     => 60
+
+requires :mcollective => "2.6.0"