loom-core 0.0.1

data/lib/loom/core_ext.rb

@@ -0,0 +1,37 @@
+module Loom
+  module CoreExt
+    refine String do
+      def underscore
+        uncamelify = self.gsub /[a-z\W][A-Z]/ do |m|
+          m.gsub /(^.)/, '\1_' 
+        end
+        uncamelify.downcase.gsub(/[^a-z0-9]+/, '_')
+      end
+
+      def demodulize
+        self.split('::').last
+      end
+    end
+
+    module ModuleExt
+      ##
+      # A method like :attr_accessor, except the setter and getter
+      # methods are combined into one. It acts as a setter if an
+      # argument is passed, and always returns the currnet value.
+      def loom_accessor(*names)
+        names.each do |name|
+          instance_variable_set "@#{name}", nil
+
+          define_method name do |*args|
+            raise 'expected 0..1 arguments' if args.size > 1
+            instance_variable_set("@#{name}", args.first) if args.size > 0
+            instance_variable_get "@#{name}"
+          end
+        end
+      end
+    end
+
+    ::Module.include ModuleExt
+
+  end
+end

data/lib/loom/dsl.rb

@@ -0,0 +1,60 @@
+require 'socket'
+
+module Loom
+
+  # TODO: Rename this to something like SSHKitWrapper, DSL is a
+  # terribly misinformative name.
+  module DSL
+
+    UnexpectedHostError = Class.new Loom::LoomError
+    SSHConnectionError = Class.new Loom::LoomError
+
+    ##
+    # Runs the given patter_block on each host in
+    # +host_specs+. +host_specs+ should be an array of String
+    # hostname/connection strings or +SSHKitHost+ instances.
+    #
+    # +&block+ should accept an SSHKit::Backend and SSHKit::Host
+    def on_host(host_specs, &run_block)
+      host_specs.each do |spec|
+        raise UnexpectedHostError, "not a HostSpec => #{spec}" unless spec.is_a? HostSpec
+      end
+
+      host_spec_map = host_specs.reduce({}) do |map, spec|
+        map[spec.hostname] = spec
+        map
+      end
+
+      execution_block = lambda do |sshkit_host|
+        host_spec = host_spec_map[sshkit_host.hostname]
+        Loom.log.debug1(self) { "connecting to host => #{host_spec.hostname}" }
+        sshkit_backend = self
+
+        begin
+          yield sshkit_backend, host_spec
+        rescue SocketError => e
+          Loom.log.error "error connecting to host => #{host_spec.hostname}"
+          raise SSHConnectionError, e
+        end
+      end
+
+      local_specs = host_specs.select { |s| s.is_localhost? }
+      unless local_specs.empty?
+        Loom.log.debug1(self) do
+          "local execution for host entry => #{local_specs.first}"
+        end
+        SSHKitDSLShadow.run_locally &execution_block
+      end
+
+      remote_specs = host_specs.select { |s| s.is_remote? }.map(&:sshkit_host)
+      unless remote_specs.empty?
+        Loom.log.debug1(self) { "remoted execution for #{remote_specs.size} hosts" }
+        SSHKitDSLShadow.on remote_specs, &execution_block
+      end
+    end
+
+    class SSHKitDSLShadow
+      extend SSHKit::DSL
+    end
+  end
+end

data/lib/loom/facts.rb

@@ -0,0 +1,13 @@
+require_relative "facts/all"
+
+module Loom
+  module Facts
+    class << self
+
+      def fact_set(host_spec, shell, loom_config)
+        FactSet.create_for_host host_spec, shell, loom_config
+      end
+
+    end
+  end
+end

data/lib/loom/facts/all.rb

@@ -0,0 +1,2 @@
+require_relative "fact_set"
+require_relative "fact_file_provider"

data/lib/loom/facts/fact_file_provider.rb

@@ -0,0 +1,86 @@
+require "yaml"
+
+module Loom::Facts
+
+  class FactFileProvider < Provider
+
+    InvalidFactFileConversion = Class.new Loom::LoomError
+
+    YAML_FILE_GLOBS = [
+      "facts.yml",
+      "facts/**/*.yml",
+      "facts/**/*.yaml"
+    ]
+
+    TXT_FILE_GLOBS = [
+      "facts.txt",
+      "facts/**/*.txt"
+    ]
+
+    ALL_FILE_GLOBS = [
+      "facts/**/*"
+    ]
+
+    Provider.register_factory(self) do |host_spec, shell, loom_config|
+      providers = []
+
+      yaml_paths = loom_config.files.find YAML_FILE_GLOBS
+      providers << YAMLFactFileProvider.new(yaml_paths)
+
+      txt_paths = loom_config.files.find TXT_FILE_GLOBS
+      providers << TxtFileProvider.new(txt_paths)
+      providers
+    end
+
+    def initialize(paths)
+      @fact_map = convert_file_paths paths
+    end
+
+    def collect_facts
+      @fact_map.dup
+    end
+
+    protected
+    def convert_path_to_map
+      raise 'not implemented'
+    end
+
+    private
+    def convert_file_paths(paths)
+      paths.reduce({}) do |memo, path|
+        Loom.log.debug { "loading fact file provider for => #{path}" }
+        tmp_map = convert_path_to_map path
+        raise InvalidFactFileConversion, path unless tmp_map.is_a? Hash
+        memo.merge! tmp_map
+      end
+    end
+
+    def load_config(config)
+      file_paths = config.files.find @file_globs
+    end
+  end
+
+  class YAMLFactFileProvider < FactFileProvider
+
+    def convert_path_to_map(path)
+      YAML.load_file path
+    end
+
+  end
+
+  class TxtFileProvider < FactFileProvider
+
+    def convert_path_to_map(path)
+      map = {}
+      File.open(path, 'r') do |io|
+        io.each_line do |line|
+          next if line.match /^\s*#/
+          k,v = line.split "="
+          map[k] = v.strip
+        end
+        map
+      end
+    end
+
+  end
+end

data/lib/loom/facts/fact_set.rb

@@ -0,0 +1,138 @@
+module Loom::Facts
+
+  class Provider
+    attr_reader :fact_map
+
+    class << self
+      def disable_for_host(host_spec, klass)
+        Loom.log.warn "disabling fact provider => #{klass} on #{host_spec.hostname}"
+        @disabled_providers ||= {}
+        @disabled_providers[host_spec.hostname] ||= []
+        @disabled_providers[host_spec.hostname] << klass
+      end
+
+      def disabled_for_host?(host_spec, klass)
+        @disabled_providers ||= {}
+        @disabled_providers[host_spec.hostname] ||= []
+        @disabled_providers[host_spec.hostname].include? klass
+      end
+
+      def register_factory(klass, &block)
+        @provider_factories ||= []
+        @provider_factories << block
+        Loom.log.debug1(self) { "registered fact provider => #{klass}" }
+      end
+
+      def create_fact_providers(host_spec, shell, loom_config)
+        @provider_factories.map do |block|
+          block.call(host_spec, shell, loom_config)
+        end.flatten
+      end
+    end
+
+    def disable(host_spec)
+      Provider.disable_for_host host_spec, self.class
+    end
+
+    # Should return a Hash
+    def collect_facts
+      raise 'not implemented'
+    end
+  end
+
+  class FactSet
+
+    InvalidFactName = Class.new Loom::LoomError
+    InvalidFactValue = Class.new Loom::LoomError
+    UnmarshalableError = Class.new Loom::LoomError
+
+    class << self
+      def create_for_host(host_spec, shell, loom_config)
+        fact_map = {}
+        fact_providers = Provider.create_fact_providers(host_spec, shell, loom_config)
+        fact_providers.each do |provider|
+          next if Provider.disabled_for_host?(host_spec, provider.class)
+
+          Loom.log.debug { "loading facts from provider => #{provider}" }
+
+          begin
+            provider.collect_facts.each do |k, v|
+              k = k.to_sym
+              if fact_map[k]
+                Loom.log.warn "overriding fact => #{k}"
+              end
+              Loom.log.debug5(self) { "adding fact => #{k}=#{v.to_s}" }
+              fact_map[k] = v
+            end
+          rescue => e
+            Loom.log.error "error executing fact provider #{provider.class} => #{e.message}"
+            provider.disable(host_spec)
+          end
+        end
+
+        FactSet.new host_spec, fact_map
+      end
+    end
+
+    def initialize(host_spec, fact_map)
+      raise unless fact_map.is_a? Hash
+      validate_facts fact_map
+
+      @fact_map = YAML.load(fact_map.to_yaml).reduce({}) do |memo, tuple|
+        memo[tuple.first.to_sym] = tuple.last
+        memo
+      end
+      @host_spec = host_spec
+    end
+
+    attr_reader :host_spec
+
+    def merge(facts)
+      facts = case facts
+              when FactSet
+                facts.facts
+              when Hash
+                facts
+              else
+                raise "unable to merge facts => #{facts.class}:#{facts}"
+              end
+      merged_facts = @fact_map.merge facts
+      FactSet.new @host_spec, merged_facts
+    end
+
+    def hostname
+      host_spec.hostname
+    end
+
+    def get(fact_name)
+      result = @fact_map[fact_name.to_sym]
+      result.dup rescue result
+    end
+    alias_method :[], :get
+
+    def facts
+      @fact_map.dup
+    end
+
+    def to_s
+      @fact_map.to_a.map { |tuple| tuple.join "=" }.join "\n"
+    end
+
+    private
+    def validate_facts(fact_map)
+      fact_map.each do |k, v|
+        validate_fact_name k.to_sym
+        validate_fact_value v
+      end
+      raise UnmarshalableError unless fact_map.eql? YAML.load(fact_map.to_yaml)
+    end
+
+    def validate_fact_name(name)
+      raise InvalidFactName, name unless name.eql? YAML.load(name.to_yaml)
+    end
+
+    def validate_fact_value(value)
+      raise InvalidFactValue, value unless value.eql? YAML.load(value.to_yaml)
+    end
+  end
+end

data/lib/loom/host_spec.rb

@@ -0,0 +1,32 @@
+require "forwardable"
+require "sshkit"
+
+module Loom
+
+  UnparseableHostStringError = Class.new Loom::LoomError
+
+  class HostSpec
+    extend Forwardable
+
+    attr_accessor :disabled
+    attr_reader :sshkit_host
+
+    def initialize(host_string)
+      @sshkit_host = parse host_string
+    end
+    def_delegators :@sshkit_host, :hostname, :user, :port
+
+    def is_remote?
+      !is_localhost?
+    end
+
+    def is_localhost?
+      hostname == "localhost" && port.nil? && user.nil?
+    end
+
+    private
+    def parse(host_string)
+      SSHKit::Host.new host_string
+    end
+  end
+end

data/lib/loom/inventory.rb

@@ -0,0 +1,124 @@
+require 'yaml'
+
+module Loom
+  module Inventory
+
+    InvalidHostEntry = Class.new Loom::LoomError
+    InventoryFileEntryError = Class.new Loom::LoomError
+
+    INVENTORY_FILE_NAMES = [
+      "inventory.yml",
+      "inventory.yaml"
+    ]
+
+    class InventoryList
+
+      class << self
+        def total_inventory(loom_config)
+          fileset = InventoryFileSet.new inventory_files(loom_config)
+          config_hostlist = loom_config.inventory_hosts
+          hostlist = fileset.hostlist + config_hostlist
+          InventoryList.new hostlist, fileset.hostgroup_map
+        end
+
+        ##
+        # The list of hosts to apply patterns to
+        def active_inventory(loom_config)
+          return total_inventory loom_config if loom_config.inventory_all_hosts
+
+          fileset = InventoryFileSet.new inventory_files(loom_config)
+          groups = loom_config.inventory_groups.map(&:to_sym).reduce({}) do |map, group|
+            Loom.log.debug2(self) { "looking for group => #{group}" }
+            key = group.to_sym
+            map[key] = fileset.hostgroup_map[key] if fileset.hostgroup_map.key? key
+            map
+          end
+          Loom.log.debug1(self) { "groups map => #{groups}" }
+
+          InventoryList.new loom_config.inventory_hosts, groups
+        end
+
+        private
+        def inventory_files(loom_config)
+          loom_config.files.find INVENTORY_FILE_NAMES
+        end
+      end
+
+      attr_reader :hosts
+
+      def initialize(hostlist, hostgroup_map={})
+        @hostgroup_map = hostgroup_map
+
+        all_hosts = hostgroup_map.values.flatten + hostlist
+        @hosts = parse_hosts(all_hosts).uniq { |h| h.hostname }
+        @disabled_hosts = {}
+      end
+
+      def disable(hostname)
+        @disabled_hosts[hostname] = true
+      end
+
+      def disabled?(hostname)
+        !!@disabled_hosts[hostname]
+      end
+
+      def hostnames
+        @hosts.map { |h| h.hostname }
+      end
+
+      def group_names
+        @hostgroup_map.keys
+      end
+
+      private
+      def parse_hosts(list)
+        list.map do |hoststring|
+          raise InvalidHostEntry, hoststring.class.name unless hoststring.is_a? String
+          HostSpec.new hoststring
+        end
+      end
+    end
+
+    private
+    class InventoryFileSet
+      def initialize(inventory_files)
+        @hostgroup_map = nil
+        @hostlist = nil
+
+        @raw_inventories = inventory_files.map do |path|
+          Loom.log.debug "loading inventory file #{path}"
+          YAML.load_file path
+        end
+      end
+
+      def hostgroup_map
+        @hostgroup_map ||= @raw_inventories.reduce({}) do |map, i|
+          i.each do |entry|
+            if entry.is_a? Hash
+              Loom.log.debug "merging groups in #{entry}"
+              entry.each do |k,v|
+                map[k.to_sym] = v
+              end
+            end
+          end
+          map
+        end
+      end
+
+      def hostlist
+        @hostlist ||= @raw_inventories.map do |i|
+          i.map do |entry|
+            case entry
+            when String
+              entry
+            when Hash
+              entry.values
+            else
+              raise InventoryFileEntryError, "unexpected entry #{entry}"
+            end
+          end
+        end.flatten
+      end
+    end
+  end
+end