choria-mcorpc-support 2.22.1 → 2.23.0.pre

data/lib/mcollective/application/playbook.rb

@@ -0,0 +1,207 @@
+module MCollective
+  class Application
+    class Playbook < Application
+      description "Choria Playbook Runner"
+
+      usage <<-USAGE
+  mco playbook [OPTIONS] <ACTION> <PLAYBOOK>
+
+  The ACTION can be one of the following:
+
+    run       - run the playbook as your local user
+
+  The PLAYBOOK Puppet Plan describing the tasks to perform
+
+  Passing --help as well as a PLAYBOOK argument will show
+  flags and help related to the specific playbook.
+
+  Any inputs to the playbook should be given on the CLI.
+      USAGE
+
+      exclude_argument_sections "common", "filter", "rpc"
+
+      def pre_parse_modulepath
+        words = Shellwords.shellwords(ARGV.join(" "))
+        words.each_with_index do |word, idx|
+          if word == "--modulepath"
+            configuration[:__modulepath] = words[idx + 1]
+            break
+          end
+        end
+      end
+
+      # Playbook should be given right after the command, this finds the value after the command
+      #
+      # @return [String,nil]
+      def pre_parse_find_playbook
+        commands = Regexp.union(valid_commands)
+
+        cmd_idx = ARGV.index {|a| a.match(commands)}
+        return nil unless cmd_idx
+
+        pb = ARGV[cmd_idx + 1]
+
+        pb if pb =~ /\A([a-z][a-z0-9_]*)?(::[a-z][a-z0-9_]*)*\Z/
+      end
+
+      # Creates an instance of the plan runner
+      #
+      # @param plan [String] the name of a plan
+      # @return [Util::BoltSupport::PlanRunner]
+      def runner(plan, loglevel=nil)
+        require "mcollective/util/bolt_support"
+        plan_runner = Util::BoltSupport::PlanRunner.new(
+          plan,
+          configuration[:__tmpdir],
+          configuration[:__modulepath],
+          configuration[:__loglevel] || "info"
+        )
+
+        unless plan_runner.exist?
+          warn("Cannot find supplied Playbook %s" % plan)
+          $stderr.puts
+          warn("Module Path:")
+          $stderr.puts
+
+          if configuration[:__modulepath]
+            warn(Util.align_text(configuration[:__modulepath].split(":").join("\n")))
+          else
+            warn(Util.align_text("Puppet Default"))
+          end
+
+          exit(1)
+        end
+
+        plan_runner
+      end
+
+      # Adds the playbook inputs as CLI options before starting the app
+      def run
+        pre_parse_modulepath
+
+        Dir.mktmpdir("choria") do |dir|
+          configuration[:__tmpdir] = dir
+
+          if playbook_name = pre_parse_find_playbook
+            configuration[:__playbook] = playbook_name
+            runner(playbook_name).add_cli_options(self, false)
+          end
+
+          # Hackily done here to force it below the playbook options
+          self.class.option :__json_input,
+                            :arguments => ["--input INPUT"],
+                            :description => "JSON input to pass to the task",
+                            :required => false,
+                            :type => String
+
+          self.class.option :__modulepath,
+                            :arguments => ["--modulepath PATH"],
+                            :description => "Path to find Puppet module when using the Playbook DSL",
+                            :type => String
+
+          self.class.option :__loglevel,
+                            :arguments => ["--loglevel LEVEL"],
+                            :description => "Override the loglevel set in the playbook (emerg alert crit err warning notice info verbose debug)",
+                            :type => String,
+                            :validate => ->(level) { %w[emerg alert crit err warning notice info verbose debug].include?(level) }
+
+          super
+        end
+      end
+
+      def post_option_parser(configuration)
+        if ARGV.length >= 1
+          configuration[:__command] = ARGV.shift
+        else
+          abort("Please specify a command, valid commands are: %s" % valid_commands.join(", "))
+        end
+
+        if input = configuration[:__json_input]
+          result = {}
+
+          if input.start_with?("@")
+            input.sub!("@", "")
+            result = JSON.parse(File.read(input)) if input.end_with?("json")
+            result = YAML.safe_load(File.read(input)) if input.end_with?("yaml")
+          else
+            result = JSON.parse(input)
+          end
+
+          configuration.merge!(result)
+        end
+      end
+
+      # Validates the configuration
+      #
+      # @return [void]
+      def validate_configuration(configuration)
+        abort("Please specify a playbook to run") unless configuration[:__playbook]
+
+        configuration[:__loglevel] = "debug" if options[:verbose] && !configuration.include?(:loglevel)
+      end
+
+      # List of valid commands this application respond to
+      #
+      # @return [Array<String>] like `plan` and `run`
+      def valid_commands
+        methods.grep(/_command$/).map {|c| c.to_s.gsub("_command", "")}
+      end
+
+      def run_command
+        pb_config = configuration.clone
+        pb_config.delete_if {|k, _| k.to_s.start_with?("__")}
+
+        pb = runner(configuration[:__playbook], configuration[:__loglevel])
+
+        run_plan(pb, pb_config)
+      end
+
+      def run_plan(playbook, pb_config)
+        startime = Time.now
+
+        success = true
+
+        result = playbook.run!(pb_config)
+      rescue
+        success = false
+      ensure
+        disconnect
+
+        endtime = Time.now
+
+        color = :green
+        msg = "OK"
+
+        unless success
+          color = :red
+          msg = "FAILED"
+        end
+
+        puts
+        puts "Playbook %s ran in %.2f seconds: %s" % [
+          Util.colorize(:bold, configuration[:__playbook]),
+          endtime - startime,
+          Util.colorize(color, msg)
+        ]
+
+        if result
+          puts
+          puts "Result: "
+          puts
+          if result.instance_of?(String)
+            puts result
+          else
+            puts Util.align_text(JSON.pretty_generate(result), 10000)
+          end
+          puts
+        end
+
+        success ? exit(0) : exit(1)
+      end
+
+      def main
+        send("%s_command" % configuration[:__command])
+      end
+    end
+  end
+end

data/lib/mcollective/application/plugin.rb

@@ -1,6 +1,5 @@
 module MCollective
-  class Application::Plugin<Application
-
+  class Application::Plugin < Application # rubocop:disable Style/ClassAndModuleChildren
     exclude_argument_sections "common", "filter", "rpc"
 
     description "MCollective Plugin Application"
@@ -18,119 +17,119 @@ mco plugin package [options] <directory>
     END_OF_USAGE
 
     option :pluginname,
-           :description => 'Plugin name',
-           :arguments   => ['-n', '--name NAME'],
-           :type        => String
+           :description => "Plugin name",
+           :arguments => ["-n", "--name NAME"],
+           :type => String
 
     option :postinstall,
-           :description => 'Post install script',
-           :arguments   => ['--postinstall POSTINSTALL'],
-           :type        => String
+           :description => "Post install script",
+           :arguments => ["--postinstall POSTINSTALL"],
+           :type => String
 
     option :preinstall,
-           :description => 'Pre install script',
-           :arguments   => ['--preinstall PREINSTALL'],
-           :type        => String
+           :description => "Pre install script",
+           :arguments => ["--preinstall PREINSTALL"],
+           :type => String
 
     option :revision,
-           :description => 'Revision number',
-           :arguments   => ['--revision REVISION'],
-           :type        => String
+           :description => "Revision number",
+           :arguments => ["--revision REVISION"],
+           :type => String
 
     option :iteration,
-           :description => 'DEPRECATED - Use --revision instead',
-           :arguments   => ['--iteration ITERATION'],
-           :type        => String
+           :description => "DEPRECATED - Use --revision instead",
+           :arguments => ["--iteration ITERATION"],
+           :type => String
 
     option :vendor,
-           :description => 'Vendor name',
-           :arguments   => ['--vendor VENDOR'],
-           :type        => String
+           :description => "Vendor name",
+           :arguments => ["--vendor VENDOR"],
+           :type => String
 
     option :pluginpath,
-           :description => 'MCollective plugin path',
-           :arguments   => ['--pluginpath PATH'],
-           :type        => String
+           :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
+           :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
+           :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
+           :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
+           :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
+           :description => "Embed a signature in the package",
+           :arguments => ["--sign"],
+           :type => :boolean
 
     option :rpctemplate,
-           :description => 'Template to use.',
-           :arguments   => ['--template HELPTEMPLATE'],
-           :type        => String
+           :description => "Template to use.",
+           :arguments => ["--template HELPTEMPLATE"],
+           :type => String
 
     option :description,
-           :description => 'Plugin description',
-           :arguments   => ['--description DESCRIPTION'],
-           :type        => String
+           :description => "Plugin description",
+           :arguments => ["--description DESCRIPTION"],
+           :type => String
 
     option :author,
-           :description => 'The author of the plugin',
-           :arguments   => ['--author AUTHOR'],
-           :type        => String
+           :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
+           :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
+           :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
+           :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
+           :arguments => ["--timeout TIMEOUT"],
+           :type => Integer
 
     option :actions,
-           :description => 'Actions to be generated for an Agent Plugin',
-           :arguments   => ['--actions [ACTIONS]'],
-           :type        => Array
+           :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
+           :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
+           :arguments => ["--keep-artifacts"],
+           :type => :boolean
 
     option :module_template,
            :description => "Path to the template used by the modulepackager",
-           :arguments   => ['--module-template PATH'],
-           :type        => String
+           :arguments => ["--module-template PATH"],
+           :type => String
 
     # Handle alternative format that optparser can't parse.
     def post_option_parser(configuration)
@@ -141,16 +140,16 @@ mco plugin package [options] <directory>
 
         if configuration[:action] == "generate"
           unless ARGV[0] && ARGV[0].match(/(actions|outputs)=(.+)/i)
-            unless configuration[:pluginname]
-              configuration[:pluginname] = ARGV.delete_at(0)
-            else
+            if configuration[:pluginname] # rubocop:disable Metrics/BlockNesting
               ARGV.delete_at(0)
+            else
+              configuration[:pluginname] = ARGV.delete_at(0)
             end
           end
 
           ARGV.each do |argument|
             if argument.match(/(actions|outputs)=(.+)/i)
-              configuration[$1.downcase.to_sym]= $2.split(",")
+              configuration[$1.downcase.to_sym] = $2.split(",")
             else
               raise "Could not parse --arg '#{argument}'"
             end
@@ -168,7 +167,7 @@ mco plugin package [options] <directory>
 
     # Generate a plugin skeleton
     def generate_command
-      raise "undefined plugin type. cannot generate plugin. valid types are 'agent' and 'data'" if configuration["target"] == '.'
+      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'"
@@ -178,15 +177,16 @@ mco plugin package [options] <directory>
       load_plugin_config_values
 
       case configuration[:target].downcase
-      when 'agent'
+      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'
+      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])
+                                      configuration[:description], configuration[:author], configuration[:license],
+                                      configuration[:version], configuration[:url], configuration[:timeout])
       else
         raise "invalid plugin type. cannot generate plugin '#{configuration[:target]}'"
       end
@@ -196,11 +196,11 @@ mco plugin package [options] <directory>
     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(/\".*\"/)
+        configuration[:sign] = "\"#{configuration[:sign]}\"" unless configuration[:sign].match(/".*"/)
       end
 
       plugin = prepare_plugin
-      (configuration[:pluginpath] = configuration[:pluginpath] + "/") if (configuration[:pluginpath] && !configuration[:pluginpath].match(/^.*\/$/))
+      (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],
@@ -219,11 +219,11 @@ mco plugin package [options] <directory>
         end
       end
 
-      return nil
+      nil
     end
 
     # Show application list and plugin help
-    def doc_command
+    def doc_command # rubocop:disable Metrics/MethodLength
       known_plugin_types = [
         ["Agents", :agent],
         ["Aggregate", :aggregate],
@@ -240,12 +240,12 @@ mco plugin package [options] <directory>
           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
+            PluginManager.find(plugin_type[1], "ddl").each do |ddlf|
+              pluginname = ddlf.gsub(/_#{plugin_type[1]}$/, "")
+
+              abort "Duplicate plugin name found, please specify a full path like agent/rpcutil" if pluginname == configuration[:target] && found_plugin_type
+
+              found_plugin_type = plugin_type[1] if pluginname == configuration[:target]
             end
           end
 
@@ -256,7 +256,7 @@ mco plugin package [options] <directory>
         if ddl
           puts ddl.help(configuration[:rpctemplate])
         else
-          abort "Could not find a '%s' plugin named '%s'" % configuration[:target].split('/')
+          abort "Could not find a '%s' plugin named '%s'" % configuration[:target].split("/")
         end
 
       else
@@ -268,17 +268,17 @@ mco plugin package [options] <directory>
         known_plugin_types.each do |plugin_type|
           puts "%s:" % plugin_type[0]
 
-          PluginManager.find(plugin_type[1], "ddl").each do |ddl|
+          PluginManager.find(plugin_type[1], "ddl").each do |ddlf|
             begin
-              help = DDL.new(ddl, plugin_type[1], false)
+              help = DDL.new(ddlf, plugin_type[1], false)
 
               next unless help.client_activated?
 
               help.loadddlfile
-              pluginname = ddl.gsub(/_#{plugin_type[1]}$/, "")
+              pluginname = ddlf.gsub(/_#{plugin_type[1]}$/, "")
               puts "  %-25s %s" % [pluginname, help.meta[:description]]
             rescue => e
-              load_errors << [plugin_type[1], ddl, e]
+              load_errors << [plugin_type[1], ddlf, e]
             end
           end
 
@@ -305,7 +305,7 @@ mco plugin package [options] <directory>
       if configuration[:dependency] && configuration[:dependency].size == 1
         configuration[:dependency] = configuration[:dependency][0].split(" ")
       elsif configuration[:dependency]
-        configuration[:dependency].map!{|dep| {:name => dep, :version => nil}}
+        configuration[:dependency].map! {|dep| {:name => dep, :version => nil}}
       end
 
       mcdependency = {
@@ -315,7 +315,7 @@ mco plugin package [options] <directory>
 
       # Deprecation warning for --iteration
       if configuration[:iteration]
-        puts 'Warning. The --iteration flag has been deprecated. Please use --revision instead.'
+        puts "Warning. The --iteration flag has been deprecated. Please use --revision instead."
         configuration[:revision] = configuration[:iteration] unless configuration[:revision]
       end
 
@@ -330,12 +330,12 @@ mco plugin package [options] <directory>
     def set_plugin_type
       if plugin_directory_exists?("agent") || plugin_directory_exists?("application")
         configuration[:plugintype] = "AgentDefinition"
-        return "Agent"
+        "Agent"
       elsif plugin_directory_exists?(plugintype = identify_plugin)
         configuration[:plugintype] = "StandardDefinition"
-        return plugintype
+        plugintype
       else
-        raise RuntimeError, "target directory is not a valid mcollective plugin"
+        raise "target directory is not a valid mcollective plugin"
       end
     end
 
@@ -348,8 +348,8 @@ mco plugin package [options] <directory>
         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
+      raise "more than one plugin type detected in directory" if plugintype.size > 1
+      raise "no plugins detected in directory" if plugintype.empty?
 
       File.basename(plugintype[0])
     end
@@ -367,15 +367,15 @@ mco plugin package [options] <directory>
     end
 
     def main
-        abort "No action specified, please run 'mco help plugin' for help" unless configuration.include?(:action)
+      abort "No action specified, please run 'mco help plugin' for help" unless configuration.include?(:action)
 
-        cmd = "#{configuration[:action]}_command"
+      cmd = "#{configuration[:action]}_command"
 
-        if respond_to? cmd
-          send cmd
-        else
-          abort "Invalid action #{configuration[:action]}, please run 'mco help plugin' for help."
-        end
+      if respond_to? cmd
+        send cmd
+      else
+        abort "Invalid action #{configuration[:action]}, please run 'mco help plugin' for help."
+      end
     end
   end
 end