loom-core 0.0.1

data/lib/loom/pattern/reference.rb

@@ -0,0 +1,71 @@
+module Loom::Pattern
+  class Reference
+
+    attr_reader :slug, :source_file, :desc
+
+    def initialize(slug, unbound_method, source_file, definition_ctx, description)
+      @slug = slug
+      @unbound_method = unbound_method
+      @source_file = source_file
+      @definition_ctx = definition_ctx
+      @desc = description
+    end
+
+    def call(shell_api, host_fact_set)
+      run_context = RunContext.new @unbound_method, @definition_ctx
+
+      fact_set = @definition_ctx.fact_set host_fact_set
+      Loom.log.debug5(self) { "fact set for pattern execution => #{fact_set.facts}" }
+
+      @definition_ctx.define_let_readers run_context, fact_set
+
+      begin
+        run_context.run shell_api, fact_set
+      rescue => e
+        error_msg = "error executing '#{slug}' in #{source_file} => #{e} \n%s"
+        Loom.log.error(error_msg % e.backtrace.join("\n\t"))
+        raise
+      end
+    end
+
+    private
+
+    ##
+    # A small class to bind the unbound_method to and provide context
+    # in the case of errors.
+    class RunContext
+      def initialize(unbound_method, definition_ctx)
+        @bound_method = unbound_method.bind self
+        @definition_ctx = definition_ctx
+      end
+
+      def run(shell_api, fact_set)
+        before_hooks = @definition_ctx.before_hooks
+        after_hooks = @definition_ctx.after_hooks
+
+        begin
+          Loom.log.debug1(self) { "before hooks => #{before_hooks}"}
+          before_hooks.each do |hook|
+            Loom.log.debug2(self) { "executing before hook => #{hook}"}
+            self.instance_exec shell_api, fact_set, &hook.block
+          end
+
+          # This is the entry point into calling patterns.
+          apply_pattern shell_api, fact_set
+        ensure
+          Loom.log.debug1(self) { "after hooks => #{after_hooks}" }
+          after_hooks.each do |hook|
+            Loom.log.debug2(self) { "executing after hook => #{hook}"}
+            self.instance_exec shell_api, fact_set, &hook.block
+          end
+        end
+      end
+
+      private
+      def apply_pattern(*args)
+        @bound_method.call *args
+      end
+    end
+
+  end
+end

data/lib/loom/pattern/reference_set.rb

@@ -0,0 +1,169 @@
+module Loom::Pattern
+
+  DuplicatePatternRef = Class.new Loom::LoomError
+  UnknownPatternMethod = Class.new Loom::LoomError
+  InvalidPatternNamespace = Class.new Loom::LoomError
+
+  ##
+  # A collection of Pattern::Reference objects
+  class ReferenceSet
+
+    class << self
+      def load_from_file(path)
+        Loom.log.debug1(self) { "loading patterns from file => #{path}" }
+        Builder.create File.read(path), path
+      end
+    end
+
+    def initialize
+      @slug_to_ref_map = {}
+    end
+
+    def slugs
+      @slug_to_ref_map.keys
+    end
+
+    def pattern_refs
+      @slug_to_ref_map.values
+    end
+
+    def get_pattern_ref(slug)
+      ref = @slug_to_ref_map[slug]
+      raise UnknownPatternMethod, slug unless ref
+      ref
+    end
+    alias_method :[], :get_pattern_ref
+
+    def merge!(ref_set)
+      self.add_pattern_refs(ref_set.pattern_refs)
+    end
+
+    def add_pattern_refs(refs)
+      map = @slug_to_ref_map
+      refs.each do |ref|
+        Loom.log.debug2(self) { "adding ref to set => #{ref.slug}" }
+        raise DuplicatePatternRef, ref.slug if map[ref.slug]
+        map[ref.slug] = ref
+      end
+    end
+
+    class Builder
+      using Loom::CoreExt # using demodulize for namespace creation
+
+      class << self
+        def create(ruby_code, source)
+          shell_module = Module.new
+          shell_module.include Loom::Pattern
+          shell_module.module_eval ruby_code, source, 1
+          shell_module.namespace ""
+
+          self.new(shell_module, source).build
+        end
+      end
+
+      def initialize(shell_module, source)
+        @shell_module = shell_module
+        @pattern_mod_specs = pattern_mod_specs
+        @source = source
+      end
+
+      def build
+        ref_set = ReferenceSet.new
+        ref_set.add_pattern_refs pattern_refs
+        ref_set
+      end
+
+      private
+      def pattern_refs
+        @pattern_mod_specs.map { |mod_spec| refs_for_mod_spec mod_spec }.flatten
+      end
+
+      def refs_for_mod_spec(mod_spec)
+        mod = mod_spec[:module]
+        context = context_for_mod_spec mod_spec
+        source = @source
+
+        mod_spec[:pattern_methods].map do |m|
+          method = mod.pattern_method m
+          desc = mod.pattern_description m
+          slug = compute_slug mod_spec[:namespace_list], m
+
+          Loom.log.warn "no descripiton for pattern => #{slug}" unless desc
+          Reference.new slug, method, source, context, desc
+        end
+      end
+
+      def context_for_mod_spec(mod_spec)
+        parents = mod_spec[:parent_modules].find_all do |mod|
+          is_pattern_module mod
+        end
+        parent_context = parents.reduce(nil) do |parent_ctx, parent_mod|
+          DefinitionContext.new parent_mod, parent_ctx
+        end
+
+        mod = mod_spec[:module]
+        DefinitionContext.new mod, parent_context
+      end
+
+      def compute_slug(namespace_list, pattern_method_name)
+        namespace_list.dup.push(pattern_method_name).join ":"
+      end
+
+      def mod_namespace_list(pattern, parent_modules)
+        mods = parent_modules.dup << pattern
+        mods.reduce([]) do |memo, mod|
+          mod_name = if mod.respond_to?(:namespace) && mod.namespace
+                       mod.namespace
+                     else
+                       mod.name.demodulize rescue ''
+                     end
+          if memo.size > 0 && mod_name.empty?
+            raise InvalidPatternNamespace, "only the root can have an empty namespace"
+          end
+          memo << mod_name.downcase unless mod_name.empty?
+          memo
+        end
+      end
+
+      def pattern_mod_specs
+        pattern_mods = []
+        traverse_pattern_modules @shell_module do |pattern_mod, parent_modules|
+          Loom.log.debug2(self) { "found pattern module => #{pattern_mod}" }
+          pattern_methods = pattern_mod.pattern_methods
+
+          next if pattern_methods.empty?
+          pattern_mods << {
+            :namespace_list => mod_namespace_list(pattern_mod, parent_modules),
+            :pattern_methods => pattern_methods,
+            :module => pattern_mod,
+            :parent_modules => parent_modules.dup
+          }
+        end
+        pattern_mods
+      end
+
+      def is_pattern_module(mod)
+        mod.included_modules.include? Loom::Pattern
+      end
+
+      def traverse_pattern_modules(mod, pattern_parents=[], visited={}, &block)
+        return if visited[mod.name] # prevent cycles
+        visited[mod.name] = true
+
+        yield mod, pattern_parents.dup if is_pattern_module(mod)
+
+        # Traverse all sub modules, even ones that aren't
+        # Loom::Pattern[s], since they might contain more sub modules
+        # themselves.
+        sub_modules = mod.constants
+                        .map { |c| mod.const_get(c) }
+                        .find_all { |m| m.is_a? Module }
+
+        pattern_parents << mod
+        sub_modules.each do |sub_mod|
+          traverse_pattern_modules sub_mod, pattern_parents.dup, visited, &block
+        end
+      end
+    end
+  end
+end

data/lib/loom/pattern/result_reporter.rb

@@ -0,0 +1,77 @@
+module Loom::Pattern
+  class ResultReporter
+    def initialize(loom_config, pattern_slug, hostname, shell_session)
+      @loom_config = loom_config
+      @start = Time.now
+      @delta_t = nil
+      @hostname = hostname
+      @pattern_slug = pattern_slug
+      @shell_session = shell_session
+    end
+
+    attr_reader :hostname
+
+    def failure_summary
+      return "scenario did not fail" if success?
+      scenario_string
+    end
+
+    def write_report
+      @delta_t = Time.now - @start
+
+      report = generate_report.join "\n\t"
+      if success?
+        Loom.log.info report
+      else
+        Loom.log.warn report
+      end
+    end
+
+    private
+    def success?
+      @shell_session.success?
+    end
+
+    def scenario_string
+      status = success? ? "OK" : "FAILED"
+      "#{hostname} => #{@pattern_slug} [Result: #{status}] "
+    end
+
+    def generate_report
+      cmds = @shell_session.command_results
+
+      report = ["--- #{scenario_string}"]
+      report << "Completed in: %01.3fs" % @delta_t
+
+      cmds.find_all { |cmd| !cmd.is_test }.each do |cmd|
+        if !cmd.success? || @loom_config.run_verbose
+          report.concat generate_cmd_report(cmd)
+        end
+      end
+
+      report
+    end
+
+    def generate_cmd_report(cmd)
+      status = cmd.success? ? "Success" : "Failed"
+
+      report = []
+      report << ""
+      report << "--- #{status} Command ---"
+      report << "$ #{cmd.command}"
+
+      unless cmd.stdout.empty?
+        report << cmd.stdout
+      end
+
+      unless cmd.stderr.empty?
+        report << "[STDERR]:"
+        report << cmd.stderr
+      end
+
+      report << "[EXIT STATUS]: #{cmd.exit_status}"
+
+      report
+    end
+  end
+end

data/lib/loom/runner.rb

@@ -0,0 +1,209 @@
+module Loom
+  class Runner
+
+    PatternExecutionError = Class.new Loom::LoomError
+    FailFastExecutionError = Class.new PatternExecutionError
+
+    include Loom::DSL
+
+    def initialize(loom_config, pattern_slugs=[], other_facts={})
+      @pattern_slugs = pattern_slugs
+      @loom_config = loom_config
+      @other_facts = other_facts
+
+      @run_failures = []
+      @result_reports = []
+
+      # these are initialized in +load+
+      @inventory_list = nil
+      @active_hosts = nil
+      @pattern_refs = nil
+      @mod_loader = nil
+
+      Loom.log.debug1(self) do
+        "initialized runner with config => #{loom_config.dump}"
+      end
+
+      @caught_sig_int = false
+    end
+
+    def run(dry_run)
+      install_signal_traps
+
+      begin
+        load
+
+        if @pattern_refs.empty?
+          Loom.log.warn "no patterns given, there's no work to do"
+          return
+        end
+        if @active_hosts.empty?
+          Loom.log.warn "no hosts in the active inventory"
+          return
+        end
+
+        hostnames = @active_hosts.map(&:hostname)
+        Loom.log.info do
+          "executing patterns #{@pattern_slugs} across hosts #{hostnames}"
+        end
+
+        run_internal dry_run
+
+        unless @run_failures.empty?
+          raise PatternExecutionError, @run_failures
+        end
+      rescue Loom::Trap::SignalExit => e
+        Loom.log.error "exiting on signal  => #{e.signal}"
+        # Exit with the signal code or 40 for unknown Signal
+        code = Signal.list[e.signal] || 40
+        exit code
+      rescue PatternExecutionError => e
+        num_patterns_failed = @run_failures.size
+        Loom.log.error "error executing #{num_patterns_failed} patterns => #{e}"
+        Loom.log.debug e.backtrace.join "\n"
+        exit 100 + num_patterns_failed
+      rescue Loom::LoomError => e
+        Loom.log.error "loom error => #{e.inspect}"
+        exit 98
+      rescue => e
+        Loom.log.fatal "fatal error => #{e.inspect}"
+        Loom.log.fatal e.backtrace.join "\n\t"
+        exit 99
+      end
+    end
+
+    private
+
+    def install_signal_traps
+      signal_handler = Loom::Trap::Handler.new do |sig, count|
+        case sig
+        when Loom::Trap::Sig::INT
+          @caught_sig_int = true
+          if count == 1
+            puts "Caught #{sig}, exiting after current pattern completion"
+            puts "Ctrl-C again to exit immediately"
+          else
+            puts "Caught #{sig}"
+            raise Loom::Trap::SignalExit.new sig
+          end
+        else
+          puts "Caught unhandled signal #{sig}"
+          raise Loom::Trap::SignalExit.new sig
+        end
+      end
+      Loom::Trap.install(Loom::Trap::Sig::INT, signal_handler)
+    end
+
+    def load
+      @inventory_list =
+        Loom::Inventory::InventoryList.active_inventory @loom_config
+      @active_hosts = @inventory_list.hosts
+
+      pattern_loader = Loom::Pattern::Loader.load @loom_config
+      @pattern_refs = pattern_loader.patterns @pattern_slugs
+
+      @mod_loader = Loom::Mods::ModLoader.new @loom_config
+    end
+
+    def run_internal(dry_run)
+      # TODO: fix the bindings in the block below so we don't need
+      # this alias
+      inventory_list = @inventory_list
+
+      on_host @active_hosts do |sshkit_backend, host_spec|
+        hostname = host_spec.hostname
+
+        begin
+          @pattern_refs.each do |pattern_ref|
+            slug = pattern_ref.slug
+            pattern_description = "[#{hostname} => #{slug}]"
+
+            if @caught_sig_int
+              Loom.log.warn "caught SIGINT, skipping #{pattern_description}"
+              next
+            elsif inventory_list.disabled? hostname
+              Loom.log.warn "host disabled due to previous failure, " +
+                            "skipping: #{pattern_description}"
+              next
+            end
+
+            Loom.log.debug "collecting facts for => #{pattern_description}"
+            # Collect facts for each pattern run on each host, this way if one
+            # pattern run updates would be facts, the next pattern will see the
+            # new fact.
+            fact_shell = Loom::Shell.create @mod_loader, sshkit_backend, dry_run
+            fact_set = Loom::Facts.fact_set(host_spec, fact_shell, @loom_config)
+                         .merge @other_facts
+
+            Loom.log.info "running pattern => #{pattern_description}"
+            # Each pattern execution needs its own shell and mod loader to make
+            # sure context is reported correctly (this is probably a hack, there
+            # should just be a way to clear/ignore state from certain commands -
+            # like the fact_finding ones above).
+            pattern_shell = Loom::Shell.create @mod_loader, sshkit_backend, dry_run
+
+            Loom.log.warn "dry run only => #{pattern_description}" if dry_run
+            execute_pattern pattern_ref, pattern_shell, fact_set
+          end
+        rescue IOError => e
+          # TODO: Try to patch SSHKit for a more specific error for unexpected SSH
+          # disconnections
+          Loom.log.error "unexpected SSH disconnect => #{hostname}"
+          Loom.log.debug e
+          handle_host_failure_strategy hostname, e.message
+        rescue Errno::ECONNREFUSED => e
+          Loom.log.error "unable to connect to host => #{hostname}"
+          Loom.log.debug e
+          handle_host_failure_strategy hostname, e.message
+        end
+      end
+    end
+
+    def execute_pattern(pattern_ref, shell, fact_set)
+      shell_session = shell.session
+      hostname = fact_set.hostname
+      result_reporter = Loom::Pattern::ResultReporter.new(
+        @loom_config, pattern_ref.slug, hostname, shell_session)
+
+      # TODO: This is a crappy mechanism for tracking errors, there should be an
+      # exception thrown inside of Shell when a command fails and pattern
+      # execution should stop. All errors should come from exceptions.
+      run_failure = []
+      begin
+        pattern_ref.call(shell.shell_api, fact_set)
+      rescue Loom::ExecutionError => e
+        Loom.log.debug e.backtrace.join "\n\t"
+        run_failure << e
+      ensure
+        # TODO: this prints out [Result: OK] even if an exception is raised
+        result_reporter.write_report
+
+        # TODO: this is not the correct error condition.
+        unless shell_session.success?
+          run_failure << result_reporter.failure_summary
+          handle_host_failure_strategy hostname, result_reporter.failure_summary
+        end
+        @result_reports << result_reporter
+        @run_failures << run_failure unless run_failure.empty?
+      end
+    end
+
+    private
+    def handle_host_failure_strategy(hostname, failure_summary=nil)
+      failure_strategy = @loom_config.run_failure_strategy.to_sym
+
+      case failure_strategy
+      when :exclude_host
+        Loom.log.warn "disabling host per :run_failure_strategy => #{failure_strategy}"
+        @inventory_list.disable hostname
+      when :fail_fast
+        Loom.log.error "erroring out of failed scenario per :run_failure_strategy"
+        raise FailFastExecutionError, failure_summary
+      when :cowboy
+        Loom.log.warn "continuing on past failed scenario per :run_failure_strategy"
+      else
+        raise ConfigError, "unknown failure_strategy: #{failure_stratgy}"
+      end
+    end
+  end
+end