dopi 0.17.0

data/lib/dopi/cli/command_show.rb

@@ -0,0 +1,109 @@
+
+module Dopi
+  module Cli
+
+    def self.command_show(base)
+      base.class_eval do
+
+        desc 'Show plan details and state'
+        arg_name 'name'
+        command :show do |c|
+          c.desc 'Do not exit and continuously update the display'
+          c.default_value false
+          c.switch [:follow, :f]
+
+          c.desc 'Display all details of the tree'
+          c.default_value false
+          c.switch [:detailed, :d]
+
+          c.action do |global_options,options,args|
+            help_now!('Specify a plan name to show') if args.empty?
+            help_now!('You can only show one plan') if args.length > 1
+            plan_name = args[0]
+            if options[:follow]
+              begin
+                Curses.noecho
+                Curses.curs_set(0)
+                Curses.init_screen
+                Curses.start_color
+                Curses.init_pair(1, Curses::COLOR_BLACK, Curses::COLOR_WHITE)
+                Curses.init_pair(2, Curses::COLOR_WHITE, Curses::COLOR_BLACK)
+                Curses.init_pair(3, Curses::COLOR_BLUE, Curses::COLOR_BLACK)
+                Curses.init_pair(4, Curses::COLOR_GREEN, Curses::COLOR_BLACK)
+                Curses.init_pair(5, Curses::COLOR_YELLOW, Curses::COLOR_BLACK)
+                Curses.init_pair(6, Curses::COLOR_RED, Curses::COLOR_BLACK)
+                draw_screen(plan_name, options[:detailed])
+                Curses.refresh
+                Dopi.on_state_change(plan_name) do
+                  Curses.clear
+                  draw_screen(plan_name, options[:detailed])
+                  Curses.refresh
+                end
+              ensure
+                Curses.close_screen
+              end
+            else
+              print_state(plan_name, options[:detailed])
+            end
+          end
+        end
+
+      end
+    end
+
+    def self.str_state_color(state, string)
+      attr = case state
+      when :ready then Curses.color_pair(3)
+      when :done then Curses.color_pair(4)
+      when :partial then Curses.color_pair(5)
+      when :running, :started then Curses.color_pair(5) | Curses::A_BLINK
+      when :failed then Curses.color_pair(6)
+      else Curses.color_pair(2)
+      end
+      Curses.attrset(attr)
+      Curses.addstr(string)
+      Curses.attrset(Curses.color_pair(2))
+    end
+
+    def self.draw_screen(plan_name, detailed)
+      plan = Dopi.show(plan_name)
+      Curses.setpos(0, 0)
+      Curses.attrset(Curses.color_pair(1))
+      Curses.addstr("DOPi #{Dopi::VERSION} - #{plan.name} [ #{plan.state.to_s} ]".ljust(Curses.cols))
+      Curses.setpos(1, 0)
+      Curses.attrset(Curses.color_pair(2))
+      plan.step_sets.each do |step_set|
+        draw_step_set(step_set, detailed)
+      end
+    end
+
+    def self.draw_step_set(step_set, detailed)
+      str_state_color(step_set.state, ' - [' + step_set.state.to_s + '] ' + step_set.name + "\n")
+      if detailed or step_set.state_running? or step_set.state_children_partial?
+        step_set.steps.each do |step|
+          draw_step(step, detailed)
+        end
+      end
+    end
+
+    def self.draw_step(step, detailed)
+      str_state_color(step.state, '   - [' + step.state.to_s + '] ' + step.name + "\n")
+      if detailed or step.state_running? or step.state_children_partial?
+        step.command_sets.each do |command_set|
+          draw_command_set(command_set, detailed)
+        end
+      end
+    end
+
+    def self.draw_command_set(command_set, detailed)
+      str_state_color(command_set.state, "     - [ #{command_set.state.to_s} ] #{command_set.node.name}\n")
+      if detailed or command_set.state_running? or command_set.state_children_partial?
+        command_set.commands.each do |command|
+          str_state_color(command.state, "       - [ #{command.state.to_s} ] #{command.title}\n")
+        end
+      end
+    end
+
+  end
+end
+

data/lib/dopi/cli/command_update.rb

@@ -0,0 +1,37 @@
+module Dopi
+  module Cli
+
+    def self.command_update(base)
+      base.class_eval do
+
+        desc 'Update the plan and/or the plan state for a given plan yaml or plan name.'
+        arg_name 'plan'
+        command :update do |c|
+          c.desc 'Remove the existing DOPi state and start with a clean state'
+          c.default_value false
+          c.switch [:clear, :c]
+
+          c.desc 'Ignore the update and keep the state as it is, only update the internal version string'
+          c.default_value false
+          c.switch [:ignore, :i]
+
+          c.action do |global_options,options,args|
+            help_now!('Specify a plan name or  to update') if args.empty?
+            help_now!('You can only update one plan') if args.length > 1
+            plan = args[0]
+            if Dopi.list.include?(plan)
+              Dopi.update_state(plan, options)
+            elsif File.exists?(plan)
+              Dopi.update_plan(plan, options)
+            else
+              help_now!("the provided plan '#{plan}' is not an existing file or plan name")
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+end
+

data/lib/dopi/cli/command_validate.rb

@@ -0,0 +1,27 @@
+module Dopi
+  module Cli
+
+    def self.command_validate(base)
+      base.class_eval do
+
+        desc 'Validate a plan file'
+        arg_name 'plan_file'
+        command :validate do |c|
+          c.action do |global_options,options,args|
+            help_now!('Specify a plan file to add') if args.empty?
+            help_now!('You can only add one plan') if args.length > 1
+            plan_file = args[0]
+            if Dopi.valid?(plan_file)
+              puts "Plan is valid"
+            else
+              exit_now!("Plan is NOT valid")
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+end
+

data/lib/dopi/cli/global_options.rb

@@ -0,0 +1,55 @@
+#
+# DOPi CLI gloable options
+#
+
+module Dopi
+  module Cli
+
+    def self.global_options(base)
+      base.class_eval do
+        desc 'Use Hiera to get the role for the nodes'
+        default_value DopCommon.config.use_hiera
+        switch [:use_hiera, :h]
+
+        desc 'Specify the hiera configuration file'
+        default_value DopCommon.config.hiera_yaml
+        arg_name 'YAML'
+        flag [:hiera_yaml]
+
+        desc 'Try to load the scope for the nodes from existing facts'
+        default_value DopCommon.config.load_facts
+        switch [:load_facts]
+
+        desc 'Specify the directory where dopi can find facts'
+        default_value DopCommon.config.facts_dir
+        arg_name 'DIR'
+        flag [:facts_dir]
+
+        desc 'Set the name of the variable DOPi should use as the roles variable'
+        default_value DopCommon.config.role_variable
+        arg_name 'VARIABLE_NAME'
+        flag [:role_variable]
+
+        desc 'Set the default value for the node role'
+        default_value DopCommon.config.role_default
+        arg_name 'ROLE'
+        flag [:role_default]
+
+        desc 'Set the MCollective client configuration.'
+        default_value DopCommon.config.mco_config
+        arg_name 'FILE'
+        flag [:mco_config]
+
+        desc 'Use the DOPi logger to capture MCollective logs (this is enabled by default)'
+        default_value DopCommon.config.mco_dopi_logger
+        switch [:mco_dopi_logger]
+
+        desc 'Time until a connection check is marked as failure'
+        default_value DopCommon.config.connection_check_timeout
+        arg_name 'SECONDS'
+        flag [:connection_check_timeout]
+      end
+    end
+
+  end
+end

data/lib/dopi/cli/log.rb

@@ -0,0 +1,33 @@
+#
+# Initializes the logger for the CLI
+#
+
+module Dopi
+  module Cli
+
+    def self.state(plan_name, detailed = false)
+      plan = Dopi.show(plan_name)
+      result = "[#{plan.state.to_s}] #{plan.name}\n"
+      plan.step_sets.each do |step_set|
+        result << "  [#{step_set.state.to_s}] #{step_set.name}\n"
+        step_set.steps.each do |step|
+          result << "    [#{step.state.to_s}] #{step.name}\n"
+          if detailed or step.state_running? or step.state_children_partial?
+            step.command_sets.each do |command_set|
+              result << "      [#{command_set.state.to_s}] #{command_set.name}\n"
+              command_set.commands.each do |command|
+                result << "        [#{command.state.to_s}] #{command.title}\n"
+              end
+            end
+          end
+        end
+      end
+      return result
+    end
+
+    def self.print_state(plan_name, detailed = false)
+      puts state(plan_name, detailed)
+    end
+
+  end
+end

data/lib/dopi/cli.rb

@@ -0,0 +1,57 @@
+#
+# The DOPi CLI main module
+#
+require 'gli'
+require 'dopi'
+require 'dop_common/cli/node_selection'
+require 'dop_common/cli/log'
+require 'dop_common/cli/global_options'
+require 'dopi/cli/log'
+require 'dopi/cli/global_options'
+require 'dopi/cli/command_run'
+require 'dopi/cli/command_validate'
+require 'dopi/cli/command_add'
+require 'dopi/cli/command_update'
+require 'dopi/cli/command_list'
+require 'dopi/cli/command_remove'
+require 'dopi/cli/command_show'
+require 'dopi/cli/command_reset'
+require 'logger/colors'
+require 'curses'
+require 'yaml'
+require 'fileutils'
+
+module Dopi
+  module Cli
+    include GLI::App
+    extend self
+
+    program_desc 'DOPi Command line Client'
+    version Dopi::VERSION
+
+    subcommand_option_handling :normal
+    arguments :strict
+
+    config_file DopCommon.config.config_file
+
+    DopCommon::Cli.global_options(self)
+    global_options(self)
+
+    pre do |global,command,options,args|
+      DopCommon.configure = global
+      ENV['GLI_DEBUG'] = 'true' if global[:trace] == true
+      DopCommon::Cli.initialize_logger('dopi.log', global[:log_level], global[:verbosity], global[:trace])
+      true
+    end
+
+    command_run(self)
+    command_validate(self)
+    command_add(self)
+    command_update(self)
+    command_list(self)
+    command_remove(self)
+    command_show(self)
+    command_reset(self)
+
+  end
+end

data/lib/dopi/command/custom.rb

@@ -0,0 +1,52 @@
+#
+# DOPi Plugin: Custom Command
+#
+
+module Dopi
+  class Command
+    class Custom < Dopi::Command
+      include Dopi::Connector::Local
+      include Dopi::CommandParser::Exec
+      include Dopi::CommandParser::Env
+      include Dopi::CommandParser::Arguments
+      include Dopi::CommandParser::ExitCode
+      include Dopi::CommandParser::Output
+
+    public
+      def validate
+        #validate_exec
+        # remove after the refactoring is complete
+        unless Dopi::Command::Custom > self.class && self.method(:exec).owner == self.class
+          log_validation_method('exec_valid?', CommandParsingError)
+        end
+        validate_env
+        validate_arguments
+        validate_exit_code
+        validate_output
+      end
+
+      def run
+        result = []
+        cmd_stdout, cmd_stderr, cmd_exit_code = local_command(env, command_string)
+        # Output Parser
+        result << check_output(cmd_stdout)
+        result << check_output(cmd_stderr)
+        # Exit Code Parser
+        result << check_exit_code(cmd_exit_code)
+        result.all?
+      end
+
+      def run_noop
+        log(:info, "(NOOP) Executing '#{command_string}' for command #{name}")
+        log(:info, "(NOOP) Environment: #{env.to_s}")
+      end
+
+    private
+
+      def command_string
+        exec + ' ' + arguments
+      end
+
+    end
+  end
+end

data/lib/dopi/command/dummy.rb

@@ -0,0 +1,27 @@
+#
+# DOPi dummy command.
+#
+# this simply prints the command hash if there was one given
+#
+
+module Dopi
+  class Command
+    class Dummy < Dopi::Command
+
+      def validate
+        true
+      end
+
+      def run
+        log(:info, "Running dummy command")
+        if @command_hash.class == Hash
+          log(:info, "Command hash was: #{hash.inspect}")
+        end
+        true
+      end
+
+    end
+  end
+end
+
+

data/lib/dopi/command/mco/rpc.rb

@@ -0,0 +1,158 @@
+#
+# DOPi Plugin: MCO RPC
+#
+require 'mcollective'
+
+module Dopi
+  class Command
+    module Mco
+      class Rpc < Dopi::Command
+        include MCollective::RPC
+        include Dopi::CommandParser::ExitCode
+
+        def validate
+          log_validation_method('options_valid?', CommandParsingError)
+          log_validation_method('arguments_valid?', CommandParsingError)
+          # Skip validation in subclasses that overwrite the non optional methods
+          unless Dopi::Command::Mco::Rpc > self.class && self.method(:agent).owner == self.class
+            log_validation_method('agent_valid?', CommandParsingError)
+          end
+          unless Dopi::Command::Mco::Rpc > self.class && self.method(:action).owner == self.class
+            log_validation_method('action_valid?', CommandParsingError)
+          end
+          validate_exit_code
+        end
+
+        def run
+          result_ok = true
+          flags = {
+            :configfile      => DopCommon.config.mco_config,
+            :options         => options,
+            :exit_on_failure => false
+          }
+          mc = rpcclient(agent, flags)
+          results = mc.custom_request(action, arguments, [@node.name], {'identity' => @node.name})
+          if results.empty?
+            log(:error, "No answer from node recieved")
+            result_ok = false
+          else
+            result_ok = false unless parse_mco_result(results.first)
+          end
+          mc.disconnect
+          result_ok
+        end
+
+        def run_noop
+          log(:info, "(NOOP) command #{name}: agent: #{agent}")
+          log(:info, "(NOOP) command #{name}: options: #{options}")
+          log(:info, "(NOOP) command #{name}: arguments: #{arguments}")
+        end
+
+        def agent
+          @agent ||= agent_valid? ?
+            hash[:agent] : nil
+        end
+
+        def options
+          @options ||= options_valid? ?
+            options_defaults.merge(hash[:options]) :
+            options_defaults
+        end
+
+        def action
+          @action ||= action_valid? ?
+            hash[:action] : nil
+        end
+
+        def arguments
+          @arguments ||= arguments_valid? ?
+            hash[:arguments] : {}
+        end
+
+      private
+
+        def expect_exit_codes_defaults
+          0
+        end
+
+        def options_defaults
+          MCollective::Util.default_options.merge({
+            :config => DopCommon.config.mco_config
+          })
+        end
+
+        def parse_mco_result(result)
+          result_ok = true
+          unless check_exit_code(result[:statuscode])
+            log(:error, result[:statusmsg])
+            result_ok = false
+          end
+          result_ok = false unless parse_mco_result_data(result[:data])
+          result_ok
+        end
+
+        def parse_mco_result_data(data)
+          warning  = "You are using the RPC plugin to run the #{agent} MCollective agent."
+          warning += " DOPi will not know what to expect in the resulting data as this is plugin specific."
+          warning += " Not all errors may be detected."
+          log(:warn, warning)
+          log(:debug, 'Receieved data: ' + data.inspect)
+          return true
+        end
+
+        def agent_valid?
+          hash[:agent] or
+            raise CommandParsingError, "No agent defined"
+          hash[:agent].kind_of?(String) or
+            raise CommandParsingError, "The value for 'agent' has to be a String"
+          begin
+            MCollective::DDL.new(hash[:agent])
+          rescue => e
+            raise CommandParsingError, "Unable to load the MCollective agent #{hash[:agent]}on this system: #{e.message}"
+          end
+          true
+        end
+
+        def options_valid?
+          return false if hash[:options].nil? # is optional
+          hash[:options].kind_of?(Hash) or
+            raise CommandParsingError, "The value for 'options' has to be a Hash"
+        end
+
+        def action_valid?
+          hash[:action] or
+           raise CommandParsingError, "No action defined"
+          hash[:action].kind_of?(String) or
+            raise CommandParsingError, "The value for 'action' has to be a String"
+          agent_ddl = nil
+          begin
+            agent_ddl = MCollective::DDL.new(agent)
+          rescue CommandParsingError
+            raise CommandParsingError, "Agent not valid, unable to verify the action #{hash[:action]}"
+          else
+            agent_ddl.actions.include?(hash[:action]) or
+              raise CommandParsingError, "The action #{hash[:action]} for agent #{agent} does not exist"
+          end
+          true
+        end
+
+        def arguments_valid?
+          hash.nil? or hash[:arguments].nil? or hash[:arguments].kind_of?(Hash) or
+            raise CommandParsingError, "The value for 'arguments' has to be a Hash"
+          begin
+            args = hash ? ( hash[:arguments] or {} ) : {}
+            agent_ddl = MCollective::DDL.new(agent)
+            agent_ddl.validate_rpc_request(action, args)
+          rescue CommandParsingError
+            raise CommandParsingError, "Agent and/or Action not valid, unable to verify the action #{hash[:action]}"
+          rescue MCollective::DDLValidationError => e
+            raise CommandParsingError, "Error while parsing arguments for agent #{agent} and action #{action}: #{e.message}"
+          end
+          return false if hash[:arguments].nil? # is completely optional if no exception was raised so far
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/dopi/command/ssh/custom.rb

@@ -0,0 +1,48 @@
+#
+# DOPi Plugin: Custom Command
+#
+
+module Dopi
+  class Command
+    class Ssh
+      class Custom < Dopi::Command
+        include Dopi::Connector::Ssh
+        include Dopi::CommandParser::Exec
+        include Dopi::CommandParser::Env
+        include Dopi::CommandParser::Arguments
+        include Dopi::CommandParser::ExitCode
+        include Dopi::CommandParser::Output
+
+      public
+
+        def validate
+          validate_ssh
+          validate_exec
+          validate_env
+          validate_arguments
+          validate_exit_code
+          validate_output
+        end
+
+        def run
+          cmd_stdout, cmd_stderr, cmd_exit_code = ssh_command(env, command_string)
+          check_output(cmd_stdout) &&
+            check_output(cmd_stderr) &&
+            check_exit_code(cmd_exit_code)
+        end
+
+        def run_noop
+          log(:info, "(NOOP) Executing '#{command_string}' for command #{name}")
+          log(:info, "(NOOP) Environment: #{env.to_s}")
+        end
+
+      private
+
+        def command_string
+          exec + ' ' + arguments
+        end
+
+      end
+    end
+  end
+end

data/lib/dopi/command/ssh/file_contains.rb

@@ -0,0 +1,70 @@
+#
+# DOPi Plugin: File Contains
+#
+require 'pathname'
+
+module Dopi
+  class Command
+    class Ssh
+      class FileContains < Dopi::Command
+        include Dopi::Connector::Ssh
+        include Dopi::CommandParser::ExitCode
+
+      public
+
+        def validate
+          validate_ssh
+          validate_exit_code
+          log_validation_method(:file_valid?, CommandParsingError)
+          log_validation_method(:pattern_valid?, CommandParsingError)
+        end
+
+        def run
+          cmd_stdout, cmd_stderr, cmd_exit_code = ssh_command({}, command_string)
+          check_exit_code(cmd_exit_code)
+        end
+
+        def run_noop
+          log(:info, "(NOOP) Executing '#{command_string}' for command #{name}")
+        end
+
+        def file
+          @file ||= file_valid? ? hash[:file] : nil
+        end
+
+        def pattern
+          @pattern ||= pattern_valid? ?
+            hash[:pattern] : nil
+        end
+
+      private
+
+        def command_string
+          "grep -e \"#{pattern}\" #{file}"
+        end
+
+        def file_valid?
+          hash[:file] or
+            raise CommandParsingError, "Plugin #{name}: The key 'file' needs to be specified"
+          begin
+            Pathname.new(hash[:file]).absolute? or
+              raise CommandParsingError, "Plugin #{name}: The path for 'file' has to be absolute"
+          rescue ArgumentError => e
+            raise CommandParsingError, "Plugin #{name}: The value in 'file' is not a valid file path: #{e.message}"
+          end
+        end
+
+        def pattern_valid?
+          hash[:pattern] or
+            raise CommandParsingError, "Plugin #{name}: The key 'pattern' needs to be specified"
+          begin
+            Regexp.new(hash[:pattern])
+          rescue
+            raise CommandParsingError, "Plugin #{name}: The value in 'pattern' is not a valid regexp: #{e.message}"
+          end
+        end
+
+      end
+    end
+  end
+end