dopi 0.17.0

data/lib/dopi/command/winrm/wait_for_login.rb

@@ -0,0 +1,49 @@
+#
+# DOPi Plugin: Wait For Login
+#
+
+module Dopi
+  class Command
+    class Winrm
+      class WaitForLogin < Dopi::Command
+        include Dopi::Connector::Winrm
+        include Dopi::CommandParser::ExitCode
+
+        DEFAULT_INTERVAL = 10
+
+        def validate
+          validate_winrm
+          validate_exit_code
+          log_validation_method(:interval_valid?, CommandParsingError)
+        end
+
+        def run
+          connected = false
+          until connected
+            begin connected = check_exit_code(winrm_command('exit')[2])
+            rescue Dopi::NodeConnectionError, Dopi::CommandConnectionError
+            end
+            unless connected
+              sleep interval
+              raise GracefulExit if signals[:stop]
+              log(:info, "Retrying connect to node")
+            end
+          end
+          true
+        end
+
+        def interval
+          @interval ||= interval_valid? ?
+            hash[:interval] : DEFAULT_INTERVAL
+        end
+
+        def interval_valid?
+          return false if hash[:interval].nil? # is optional
+          hash[:interval].class == Fixnum or
+            raise CommandParsingError, "Plugin #{name}: the value of 'interval' has to be a number"
+        end
+
+      end
+    end
+  end
+end

data/lib/dopi/command.rb

@@ -0,0 +1,239 @@
+#
+# This class loades the dopi command plugins
+#
+require 'dop_common'
+require 'forwardable'
+require 'timeout'
+
+
+module Dopi
+  class Command
+    extend Forwardable
+    include Dopi::State
+    include DopCommon::Validator
+
+    def self.inherited(klass)
+      PluginManager << klass
+    end
+
+    def self.create_plugin_instance(command_parser, step, node, is_verify_command = false)
+      plugin_type = PluginManager.get_plugin_name(self) + '/'
+      plugin_full_name = plugin_type + command_parser.plugin
+      Dopi.log.debug("Creating instance of plugin #{plugin_full_name}")
+      PluginManager.create_instance(plugin_full_name, command_parser, step, node, is_verify_command)
+    end
+
+    def self.set_plugin_defaults(node_name, hash)
+      @plugin_defaults ||= {}
+      @plugin_defaults[node_name] ||= {}
+      @plugin_defaults[node_name].merge!(DopCommon::HashParser.symbolize_keys(hash))
+    end
+
+    def self.plugin_defaults(node_name)
+      @plugin_defaults ||= {}
+      @plugin_defaults[node_name] ||= {}
+    end
+
+    # wipe all the defaults for this plugin
+    def self.wipe_plugin_defaults
+      @plugin_defaults = {}
+    end
+
+    # delete all the defaults on this plugin for the node
+    def self.delete_plugin_defaults(node_name)
+      @plugin_defaults ||= {}
+      @plugin_defaults[node_name] = {}
+    end
+
+    # delete a specific default for the node
+    def self.delete_plugin_default(node_name, key)
+      @plugin_defaults ||= {}
+      @plugin_defaults[node_name] ||= {}
+      @plugin_defaults[node_name].delete(key)
+    end
+
+    attr_reader :node, :hash, :is_verify_command
+
+    def initialize(command_parser, step, node, is_verify_command)
+      @command_parser    = command_parser
+      @step              = step
+      @node              = node
+      @is_verify_command = is_verify_command
+      @hash              = merged_hash
+      log(:debug, "Plugin created with merged command hash: #{hash.inspect}")
+      # make sure verify commands are initialized as well
+      verify_commands
+    end
+
+    def merged_hash
+      if @command_parser.hash.kind_of?(Hash)
+        self.class.plugin_defaults(@node.name).merge(@command_parser.hash)
+      else
+        self.class.plugin_defaults(@node.name)
+      end
+    end
+
+    def_delegator :@command_parser, :plugin, :name
+    def_delegator :@command_parser, :title, :title
+
+    def meta_run(noop = false)
+      return if skip_run?(noop)
+      state_run unless noop
+      # Nest timeout in itself to fix working in combination with popen3() used
+      # by command connectors
+      Timeout::timeout(plugin_timeout) do
+        Timeout::timeout(plugin_timeout) do
+          log(:info, "Running command #{name}") unless @is_verify_command
+          if noop
+            run_noop
+          else
+            if run
+              if verify_after_run
+                verify_commands_ok? or
+                  raise CommandExecutionError, "Verify commands failed to confirm a successful run"
+              end
+              state_finish
+              log(:info, "#{name} [OK]") if state_done?
+            else
+              state_fail
+              log(:info, "#{name} [FAILED]")
+            end
+          end
+        end
+      end
+    rescue GracefulExit
+      log(:info, "Command excited gracefuly, resetting to ready")
+      state_reset(true) unless noop
+    rescue Timeout::Error
+      log(:error, "Command timed out (plugin_timeout is set to #{plugin_timeout})", false)
+      state_fail unless noop
+      send_signal(:abort)
+    rescue CommandExecutionError => e
+      log(:error, "Command failed: #{e.message}", false)
+      Dopi.log.error(e) if DopCommon.config.trace
+      state_fail unless noop
+    rescue => e
+      log(:error, "Unexpected error!!! This is a Bug", false)
+      Dopi.log.error(e.message)
+      Dopi.log.error(e.backtrace)
+      state_fail unless noop
+      raise e
+    end
+
+    def meta_valid?
+      validity = valid?
+      validity = false unless verify_commands.all? do |verify_command|
+        begin
+          verify_command.meta_valid?
+        rescue PluginLoaderError => e
+          Dopi.log.error("Step '#{@step.name}': Can't load plugin #{verify_command.plugin}: #{e.message}")
+        end
+      end
+      validity
+    end
+
+    def_delegator  :@command_parser, :verify_commands, :parsed_verify_commands
+    def_delegators :@command_parser, :plugin_timeout, :verify_after_run
+
+    def load_state(state_hash)
+      command_state = state_hash[:command_state] || :ready
+      unless command_state == :ready
+        @state = command_state
+        state_changed
+      end
+    end
+
+    def state_hash
+      {:command_state => @state}
+    end
+
+  private
+
+    def run
+      raise Dopi::CommandExecutionError, "No run method implemented in plugin #{name}"
+    end
+
+    def run_noop
+      Dopi.log.error("The plugin #{name} does not support noop runs and will not show the command")
+    end
+
+    def validate
+      Dopi.log.warn("No 'validate' method implemented in plugin #{name}. Validation not possible")
+      true
+    end
+
+    def skip_run?(noop = false)
+      if state_done?
+        log(:info, "Is already in state 'done'. Skipping")
+        true
+      elsif verify_commands.any? && verify_commands_ok?
+        if noop
+          log(:info, "All verify commands ok. Skipping")
+        else
+          log(:info, "All verify commands ok. Skipping and marked as 'done'")
+          state_run
+          state_finish
+        end
+        true
+      else
+        false
+      end
+    end
+
+    def verify_commands
+      @verify_commands ||= parsed_verify_commands.map do |command|
+        Dopi::Command.create_plugin_instance(command, @step, @node, true)
+      end
+    end
+
+    def verify_commands_ok?
+      verify_commands.all? do |command|
+        command.state_reset(true)
+        command.meta_run
+        command.state_done?
+      end
+    end
+
+    def log_prefix
+      if @is_verify_command
+        "  [Verify] #{@node.name} : "
+      else
+        "  [Command] #{@node.name} : "
+      end
+    end
+
+    def log(severity, message, overwrite = true)
+      # Ignore verify command errors, because they are expected
+      if @is_verify_command && overwrite
+        severity = :debug if severity == :error || severity == :warn
+      end
+      # TODO: implement Node specific logging
+      # for now we simply forward to the global DOPi logger
+      Dopi.log.log(Logger.const_get(severity.upcase), log_prefix + message)
+    end
+
+  end
+end
+
+
+# load standard command plugins
+require 'dopi/command/dummy'
+require 'dopi/command/custom'
+require 'dopi/command/ssh/custom'
+require 'dopi/command/ssh/puppet_agent_run'
+require 'dopi/command/ssh/wait_for_login'
+require 'dopi/command/ssh/file_contains'
+require 'dopi/command/ssh/file_exists'
+require 'dopi/command/ssh/file_replace'
+require 'dopi/command/ssh/file_deploy'
+require 'dopi/command/ssh/reboot'
+require 'dopi/command/mco/rpc'
+require 'dopi/command/winrm/cmd'
+require 'dopi/command/winrm/powershell'
+require 'dopi/command/winrm/puppet_agent_run'
+require 'dopi/command/winrm/wait_for_login'
+require 'dopi/command/winrm/file_contains'
+require 'dopi/command/winrm/file_exists'
+require 'dopi/command/winrm/reboot'
+
+# TODO: load plugins from the plugin paths

data/lib/dopi/command_parser/arguments.rb

@@ -0,0 +1,38 @@
+#
+# Simple command parser class to parse arguments
+#
+module Dopi
+  module CommandParser
+    module Arguments
+
+      def validate_arguments
+        log_validation_method('arguments_valid?', CommandParsingError)
+      end
+
+      def arguments
+        arguments_valid? ? parse_arguments : ""
+      end
+
+    private
+
+      def arguments_valid?
+        return false unless hash.kind_of?(Hash) # plugin may not have parameters
+        return false if hash[:arguments].nil? # arguments are optional
+        hash[:arguments].kind_of?(Hash) or
+          hash[:arguments].kind_of?(Array) or
+          hash[:arguments].kind_of?(String) or
+          raise CommandParsingError, "The value for 'arguments' hast to be an Array, Hash or String"
+      end
+
+      def parse_arguments
+        case hash[:arguments]
+        when Hash   then hash[:arguments].to_a.flatten.join(' ')
+        when Array  then hash[:arguments].flatten.join(' ')
+        when String then hash[:arguments]
+        else ""
+        end
+      end
+
+    end
+  end
+end

data/lib/dopi/command_parser/credentials.rb

@@ -0,0 +1,59 @@
+#
+# Dopi Credentials helper module
+#
+# This module will provide a credentials method which contains all the credential
+# objects for the plugin.
+#
+# Make sure you call "validate_credentials" method from your validation method.
+#
+# Implement a method "supported_credential_types" in your plugin if you want to limit
+# the types which are supported and trow an error during validation if some other type
+# is assigned
+#
+module Dopi
+  module CommandParser
+    module Credentials
+      include DopCommon::Validator
+      include DopCommon::HashParser
+
+    public
+
+      def validate_credentials
+        log_validation_method('credentials_valid?', CommandParsingError)
+      end
+
+      def credentials
+        @credentials ||= credentials_valid? ? parse_credentials : []
+      end
+
+    private
+
+      def credentials_valid?
+        return false unless hash.kind_of?(Hash) # plugin may not have parameters
+        key_aliases(hash, :credentials, ['credentials', :credential, 'credential'])
+        return false if hash[:credentials].nil? # credentials is optional
+        hash[:credentials].kind_of?(String) or hash[:credentials].kind_of?(Array) or
+          raise CommandParsingError, "the value for 'credentials' has to be a string or an array of strings"
+        [hash[:credentials]].flatten.each do |c|
+          c.kind_of?(String) or
+            raise CommandParsingError, "All values in the 'credentials' array have to be strings"
+          @step.plan.credentials.has_key?(c) or
+            raise CommandParsingError, "Credentials #{c} are not configured"
+          if self.methods.include?(:supported_credential_types)
+            cred_type = @step.plan.credentials[c].type
+            supported_credential_types.include?(cred_type) or
+              raise CommandParsingError, "Credential #{c} is of type #{cred_type}, which is not supported by the plugin"
+          end
+        end
+        true
+      end
+
+      def parse_credentials
+        [hash[:credentials]].flatten.map{|c| @step.plan.credentials[c]}
+      end
+
+    end
+  end
+end
+
+

data/lib/dopi/command_parser/env.rb

@@ -0,0 +1,37 @@
+#
+# Simple command parser module for environment variable hashes
+#
+# To set plugin specific defaults for the environment create
+# a 'env_defaults' method which returns a hash with:
+# { var => val, var2 => val2, ... }
+# This hash will be merged with the user specified hash.
+#
+module Dopi
+  module CommandParser
+    module Env
+
+      def validate_env
+        log_validation_method(:env_valid?, CommandParsingError)
+      end
+
+      def env
+        env_valid? ? create_env.merge(hash[:env]) : create_env
+      end
+
+    private
+
+      def env_valid?
+        return false unless hash.kind_of?(Hash) # plugin may not have parameters
+        return false if hash[:env].nil? # env is optional
+        hash[:env].kind_of?(Hash) or
+          raise CommandParsingError, "The value for 'env' has to be a hash"
+      end
+
+      def create_env
+        defaults = respond_to?(:env_defaults) ? env_defaults : {}
+        { 'DOP_NODE_FQDN' => @node.name }.merge(defaults)
+      end
+
+    end
+  end
+end

data/lib/dopi/command_parser/exec.rb

@@ -0,0 +1,27 @@
+#
+# Simple command parser module for exec
+#
+module Dopi
+  module CommandParser
+    module Exec
+
+      def validate_exec
+        log_validation_method('exec_valid?', CommandParsingError)
+      end
+
+      def exec
+        exec_valid? ? hash[:exec] : nil
+      end
+
+    private
+
+      def exec_valid?
+        hash[:exec] or
+          raise CommandParsingError, "#Step #{@step.name} | Plugin #{name} | No command to execute in 'exec' defined"
+        hash[:exec].kind_of?(String) or
+          raise CommandParsingError, "#Step #{@step.name} | Plugin #{name} | The value for 'exec' has to be a String"
+      end
+
+    end
+  end
+end

data/lib/dopi/command_parser/exit_code.rb

@@ -0,0 +1,73 @@
+#
+# This is a mixin for command plugins that need to parse an exit Code of some sort
+#
+# To set plugin specific defaults you can implement the 'expect_exit_codes_defaults'
+# method which returns an array of expected exit codes
+#
+module Dopi
+  module CommandParser
+    module ExitCode
+
+    public
+
+      def validate_exit_code
+        log_validation_method('expect_exit_codes_valid?', CommandParsingError)
+      end
+
+      def expect_exit_codes
+        @expect_exit_codes ||= expect_exit_codes_valid? ?
+          hash[:expect_exit_codes] : create_exit_codes
+      end
+
+      # Returns true if the exit code is one we expected, otherwise false
+      def check_exit_code(cmd_exit_code)
+        log(:debug, "Checking exit code '#{cmd_exit_code}'")
+        exit_code_ok = case expect_exit_codes
+        when 'all', 'ALL', 'All', :all then true
+        when Array then expect_exit_codes.include?(cmd_exit_code)
+        when Fixnum then expect_exit_codes == cmd_exit_code
+        else false
+        end
+
+        unless exit_code_ok
+          log(:error, "Wrong exit code in command #{name}")
+          if expect_exit_codes.kind_of?(Array)
+            log(:error, "Exit code was #{cmd_exit_code.to_s} should be one of #{expect_exit_codes.join(', ')}")
+          elsif expect_exit_codes.kind_of?(Fixnum)
+            log(:error, "Exit code was #{cmd_exit_code.to_s} should be #{expect_exit_codes.to_s}")
+          else
+            log(:error, "Exit code was #{cmd_exit_code.to_s} #{expect_exit_codes}")
+          end
+        end
+
+        exit_code_ok
+      end
+
+    private
+
+      def expect_exit_codes_valid?
+        return false unless hash.kind_of?(Hash) # plugin may not have parameters
+        return false if hash[:expect_exit_codes].nil? # expect_exit_codes is optional
+        hash[:expect_exit_codes].kind_of?(Fixnum) or
+          hash[:expect_exit_codes].kind_of?(String) or
+          hash[:expect_exit_codes].kind_of?(Symbol) or
+          hash[:expect_exit_codes].kind_of?(Array) or
+          raise CommandParsingError, "The value for 'expect_exit_codes' hast to be a number or an array of numbers or :all"
+        if hash[:expect_exit_codes].kind_of?(String) || hash[:expect_exit_codes].kind_of?(Symbol)
+          ['all', 'All', 'ALL', :all].include? hash[:expect_exit_codes] or
+            raise CommandParsingError, "Unknown keyword for expect_exit_codes. This has to be a number, an array or :all"
+        end
+        if hash[:expect_exit_codes].kind_of?(Array)
+          hash[:expect_exit_codes].all?{|exit_code| exit_code.kind_of?(Fixnum)} or
+            raise CommandParsingError, "The array in 'expect_exit_codes' can only contain numbers"
+        end
+        true
+      end
+
+      def create_exit_codes
+        respond_to?(:expect_exit_codes_defaults) ? expect_exit_codes_defaults : 0
+      end
+
+    end
+  end
+end

data/lib/dopi/command_parser/output.rb

@@ -0,0 +1,126 @@
+#
+# This is a mixin for command plugins that need to parse an output of some sort
+#
+# Make sure to call the validation method from the class you use the module
+#
+# To set plugin specific output parser patterns, implement the method
+# 'parse_output_defaults' which should return a hash with the patterns.
+#
+module Dopi
+  module CommandParser
+    module Output
+      include DopCommon::Validator
+
+    public
+
+      def validate_output
+        log_validation_method('parse_output_valid?', CommandParsingError)
+        unless parse_output.empty?
+          log_validation_method('error_patterns_valid?', CommandParsingError)
+          log_validation_method('warning_patterns_valid?', CommandParsingError)
+        end
+        log_validation_method('fail_on_warning_valid?', CommandParsingError)
+      end
+
+      def check_output(raw_output)
+        if error_patterns.empty? && warning_patterns.empty?
+          log(:debug, "No patterns defined to parse the output")
+          return true
+        end
+
+        output_ok = true
+
+        error_patterns.each do |pattern|
+          lines_with_matches(raw_output, pattern).each do |line_with_error|
+            log(:error, line_with_error)
+            output_ok = false
+          end
+        end
+
+        warning_patterns.each do |pattern|
+          lines_with_matches(raw_output, pattern).each do |line_with_warning|
+            if fail_on_warning
+              log(:error, line_with_warning)
+              output_ok = false
+            else
+              log(:warn, line_with_warning)
+            end
+          end
+        end
+
+        output_ok
+      end
+
+      def parse_output
+        if parse_output_valid?
+          Hash[hash[:parse_output].map{|k,v| [k.to_sym, v]}]
+        else
+          respond_to?(:parse_output_defaults) ? parse_output_defaults : {}
+        end
+      end
+
+      def error_patterns
+        @error_patterns ||= parser_patterns_valid?(parse_output[:error]) ?
+          [ parse_output[:error] ].flatten : []
+      end
+
+      def warning_patterns
+        @warning_patterns ||= parser_patterns_valid?(parse_output[:warning]) ?
+          [ parse_output[:warning] ].flatten : []
+      end
+
+      def fail_on_warning
+        @fail_on_warning ||= fail_on_warning_valid? ?
+          hash[:fail_on_warning] : false
+      end
+
+      def lines_with_matches(raw_output, pattern)
+        regexp = Regexp.new(pattern)
+        raw_output.lines.find_all{ |line| line.scan(regexp).any? }
+      end
+
+    private
+
+      def parse_output_valid?
+        return false unless hash.kind_of?(Hash)
+        return false if hash[:parse_output].nil? # optional
+        hash[:parse_output].kind_of?(Hash) or
+          raise CommandParsingError, "The value for 'parse_output' has to be a Hash"
+        true
+      end
+
+      def error_patterns_valid?
+        parser_patterns_valid?(parse_output[:error])
+      end
+
+      def warning_patterns_valid?
+        parser_patterns_valid?(parse_output[:warning])
+      end
+
+      def parser_patterns_valid?(pattern)
+        return false if pattern.nil? # optional
+        pattern.kind_of?(Array) or
+          raise CommandParsingError, "The value of 'error' and 'warning' in 'parse_output' has to be an Array"
+        pattern.each do |entry|
+          begin
+            Regexp.new(entry)
+          rescue
+            raise CommandParsingError, "The pattern #{entry} in 'parse_output' is not a valid regular expression"
+          end
+        end
+        true
+      end
+
+      def fail_on_warning_valid?
+        return false unless hash.kind_of?(Hash)
+        return false if hash[:fail_on_warning].nil? # is optional
+        hash[:fail_on_warning].kind_of?(TrueClass) or hash[:fail_on_warning].kind_of?(FalseClass) or
+          raise CommandParsingError, "The value for 'fail_on_warning' must be boolean"
+        true
+      end
+
+    end
+  end
+end
+
+