loom-core 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dd2b1e4959e4556b67f1369c3e8de87bdca21c0082ec446d629319cc58ee748
-  data.tar.gz: edb2d6b2f14a01549b6b75820cf3d456d401fb396f7c13469b812922ae700e2b
+  metadata.gz: 11bd9487c4e4752e294000493fe1fe04537f97bfcea9385b1cf16e90c2c79a71
+  data.tar.gz: 926227cb27d65b64103dd0f541acb1f523afdfac2df832180450f1aaaff4397f
 SHA512:
-  metadata.gz: 8459bc0b442c21f59217a8d4646418c17a82a77fa0321f56f1877e8892bc84be56ee16043f9fc362acd437b713296c66f3a8542df0fe9be64c9a08070453bf55
-  data.tar.gz: 3fb25060598c49d64efcc60e23a44e1ca927304ae861ddf45baa3ded0481da9da8d0f40f358b7c2e8df4c6ec2a1bf9cb2f017285cb0cf63a8ade311d7b149282
+  metadata.gz: 687255010d7a4c709cb95b2022151a95175ae88decb368cfac503dd3bfdb24c677abdbd2ef055f16a80a783bad2d24762ab856bf20c085ec08d1f51734c78c01
+  data.tar.gz: b789683f5aefd5a1997536e3f930f143bb7c12fc24be4e40d10fb0147e0c997c5af84798fad9e2da79d3cdbb7f5fe4a854d3f981f6deabe43ff08ab0092e3c68

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    loom-core (0.0.5)
+    loom-core (0.0.6)
       bcrypt_pbkdf (>= 1.0, < 2.0)
       commander (~> 4.4)
       ed25519 (>= 1.0, < 2.0)

data/bin/loom

@@ -65,9 +65,13 @@ EOS
         Loom.configure { |c| c.inventory_all_hosts = flag }
       end
 
+      global_option "-L", "Adds localhost to the active inventory" do |flag|
+        Loom.configure { |c| c.inventory_hosts << "localhost" }
+      end
+
       global_option "-H", "--hosts host1,h2,h3", Array,
                     "Adds HOSTS to the active inventory" do |hosts|
-        Loom.configure { |c| c.inventory_hosts = hosts }
+        Loom.configure { |c| c.inventory_hosts.concat hosts }
       end
 
       global_option "-G", "--groups group1,g2,g3", Array,

data/lib/loom/config.rb

@@ -12,6 +12,12 @@ module Loom
     CONFIG_VARS = {
       :loom_search_paths => ['/etc/loom', File.join(ENV['HOME'], '.loom'), './.loom'],
       :loom_files => ['site.loom'],
+      :loom_file_patterns => ['*.loom'],
+
+      :loomfile_autoloads => [
+        'loomext/corefacts',
+        'loomext/coremods',
+      ],
 
       :inventory_all_hosts => false,
       :inventory_hosts => [],
@@ -49,6 +55,8 @@ module Loom
     end
     alias_method :dump, :to_yaml # aliased to dump for debugging purposes
 
+    # TODO: disallow CONFIG_VAR properties named after Config methods.... like
+    # files. this is shitty, but I don't want to do a larger change.
     def files
       @file_manager
     end
@@ -68,11 +76,10 @@ module Loom
     private
     class FileManager
 
-      LOOM_FILE_PATTERNS = ["*.loom"]
-
       def initialize(config)
         @loom_search_paths = config.loom_search_paths
         @loom_files = config.loom_files
+        @loom_file_patterns = config.loom_file_patterns
       end
 
       def find(glob_patterns)
@@ -80,7 +87,7 @@ module Loom
       end
 
       def loom_files
-        [@loom_files + search_loom_paths(LOOM_FILE_PATTERNS)].flatten.uniq
+        [@loom_files + search_loom_paths(@loom_file_patterns)].flatten.uniq
       end
 
       private

data/lib/loom/facts/fact_set.rb

@@ -1,5 +1,11 @@
 module Loom::Facts
 
+  class << self
+    def is_empty?(fact_set)
+      EMPTY.equal? fact_set
+    end
+  end
+
   EMPTY = {}
   class << EMPTY
     def [](*args)
@@ -104,7 +110,7 @@ NB
       v = @fact_map[fact_name.to_sym]
       dup = v.dup rescue v
       if dup.nil?
-        EMPTY
+        Loom::Facts::EMPTY
       else
         dup
       end

data/lib/loom/mods/module.rb

@@ -19,10 +19,9 @@ module Loom::Mods
       @mods = shell.mod_loader
       @loom_config = loom_config
 
-      # The action proxy is a facade for the mod provided to patterns by the
-      # ShellApi (the 'loom' object). The ShellApi calls back to the mod_loader
-      # on method missing which instantiates a new Module object and returns the
-      # action_proxy.
+      # The action proxy is a facade (or is it a proxy? i don't know) for the mod provided to
+      # patterns by the ShellApi (the 'loom' object). The ShellApi calls back to the mod_loader on
+      # method missing which instantiates a new Module object and returns the action_proxy.
       @action_proxy = self.class.action_proxy self, shell.shell_api
       @action_args = nil
       @action_block = nil

data/lib/loom/pattern/definition_context.rb

@@ -45,7 +45,7 @@ module Loom::Pattern
         Loom.log.debug1(self) { "let[:#{let_key}] => #{value}" }
 
         if value.nil? || value.equal?(Loom::Facts::EMPTY)
-          Loom.log.e "value of let expression[:#{let_key}] is nil"
+          Loom.log.error "value of let expression[:#{let_key}] is nil"
           raise NilLetValueError, let_key
         end
         scope_object.define_singleton_method(let_key) { value }

data/lib/loom/pattern/dsl.rb

@@ -1,36 +1,63 @@
-=begin
-
 # TODO: DSL extensions:
-- Pattern+non_idempotent+ marks a pattern as explicitly not idempotent, this
-  let's additional warnings and checks to be added
-- A history module, store a log of each executed command, a hash of the .loom
-  file, and the requisite facts (the let declarations) for each executed pattern
-  on the host it executes. /var/log/loom/history? Create this log on startup.
-  -- add a new set of history commands through the CLI and a history
-     FactProvider exposing host/loom/pattern_slug execution stats.
-- Provide automatic command reversion support with a =Module= DSL that ties in
-  with local revision history.
-  -- allow Module actions/mods to define an "undo" command of itself given the
-     original inputs to the action
-  -- using the history to pull previous params (let defns) into a revert command.
-  -- usages of the raw shell, such as `loom.x` and `loom.capture` would be
-     unsupported. so would accesses to the fact_set in any before/after/pattern
-     blocks.
-  -- however patterns that only used let blocks, and used all "revertable"
-     module methods, could have automatic state reversion and integrity checking
-     managed.
-  -- best practices (encouraged through warnings) to be to heavily discourage
-     uses of loom.execute and loom.capture in .loom files and encourage all
-     accesses to fact_set be done in let expressions (enforce this maybe?)
-  -- Later... before/after hooks can ensure the entire loom execution sequence
-     was "revertable"
+# - a way to test and verify pattern execution.... I still don't trust this
+#   enough. this starts with fixing error reporting.
+# - Pattern+non_idempotent+ marks a pattern as explicitly not idempotent, this
+#   let's additional warnings and checks to be added
+# - A history module, store a log of each executed command, a hash of the .loom
+#   file, and the requisite facts (the let declarations) for each executed pattern
+#   on the host it executes. /var/log/loom/history? Create this log on startup.
+#   -- add a new set of history commands through the CLI and a history
+#      FactProvider exposing host/loom/pattern_slug execution stats.
+# - Provide automatic command reversion support with a =Module= DSL that ties in
+#   with local revision history.
+#   -- allow Module actions/mods to define an "undo" command of itself given the
+#      original inputs to the action
+#   -- using the history to pull previous params (let defns) into a revert command.
+#   -- usages of the raw shell, such as `loom.x` and `loom.capture` would be
+#      unsupported. so would accesses to the fact_set in any before/after/pattern
+#      blocks.
+#   -- however patterns that only used let blocks, and used all "revertable"
+#      module methods, could have automatic state reversion and integrity checking
+#      managed.
+#   -- best practices (encouraged through warnings) to be to heavily discourage
+#      uses of loom.execute and loom.capture in .loom files and encourage all
+#      accesses to fact_set be done in let expressions (enforce this maybe?)
+#   -- Later... before/after hooks can ensure the entire loom execution sequence
+#      was "revertable"
+# - A mechanism to allow mods to register CLI flags and actions. Using an action predicate
+#   mechanisms can add flags at the global or action levels. All CLI flags set config values.
+#   -- Mods can also register for action namespaces similar to git. This is consistent with mod
+#      namespaces on the loom object.
+#   -- Best way is to migrate loom/mods/module and loom/mods/action_proxy into base classes of
+#      themselves. The isolate the shell specific behavior into a subclass of each to preserve the
+#      current behavior. A new "cli" module and "cli" action proxy would enable the implementation.
+# - Add a phase to the pattern execution sequence to collect calls to factset and loom
+#   objects. Results collected from this ""pre-execute"" can be analyzed for errors, optimization,
+#   success assertions, verification, etc. The loom file then executes in 2 passes, analyze &
+#   execute.
+#   -- pre-fact collection - inject the facts (or loom) object as a recorder (like a mock in record mode)
+#      instead of the factual fact set. no need to change any loom files.
+#   -- only run fact providers which are accessed in the pattern set
+#   -- only load modules accessed in the pattern set
+# - Replace Pattern "mods" and "mod specs" in Loom::Pattern::ReferenceSet with usages of a builder
+#   instead. Currently the internal data model in ReferenceSet is confusing, but luckily it's the
+#   only client of pattern modules, that have used Loom::Pattern::DSL. Change calls to
+#   DSL#pattern/report/weave (anythin else that creates a pattern) to add a new PatternBuilder to
+#   the module. Use the builder to implement the TODO above ("Add a phase..."). Implement analysis
+#   on the builder.
+
+=begin
 
 ## .loom File DSL
 
-See specs/test.loom for a valid .loom file.
+See:
+* spec/test.loom for a valid .loom file.
+* spec/loom/pattern/dsl_spec.rb for other examples
 
-I've tried to take inspriation from the RSpec DSL for .loom, so hopefully it
-feels comfortable.
+
+I've tried to take inspriation from several ruby DSLs, including (but not
+limited to) RSpec, Thor, Commander, Sinatra... so hopefully it feels
+comfortable.
 
 Loom::Pattern::DSL is the mixin that defines the declarative API for all .loom
 file defined modules. It is included into Loom::Pattern by default. The outer
@@ -40,7 +67,7 @@ default. Submodules must explicitly include Loom::Pattern, and will receive DSL.
 For example, given the following .loom file:
 
 ``` ~ruby
-def top_level; end
+pattern :cmd do |loom, facts| puts loom.xe :uptime end
 
 module Outer
 
@@ -76,6 +103,11 @@ file. A ReferenseSet being a collection of references with uniquely named
 slugs. The slug of a reference is computed from the module namespace and
 instance method name.
 
+### `report`
+
+Use `report` to create a pattern that outputs a fact, other value, or result of
+a block to yaml, json, or any other format.
+
 ### `let`, `before`, and `after`
 
 Module::Inner, from above, inherits all +let+ declarations from its outer
@@ -172,7 +204,7 @@ invoked via Loom::Runner+load+. Expansion happens on read via
 Loom::Pattern::Loader+patterns+, thus the list of patterns is constant
 throughout all phases of pattern execution.
 
-#### Pattern Execution Phases
+#### Pattern Execution Sequence
 
 Once hosts and patterns are identified in earlier Loom::Runner phases,
 Loom::Runner+run_internal+, per host, initiates an SSH session and command
@@ -210,8 +242,14 @@ TODO
 ##
 
 =end
+
+require "yaml"
+require "json"
+
 module Loom::Pattern
 
+  PatternDefinitionError = Class.new Loom::LoomError
+
   # TODO: clarify this DSL to only export:
   # - description
   # - pattern
@@ -246,6 +284,39 @@ module Loom::Pattern
       define_pattern_internal(name, &block)
     end
 
+    ##
+    # @param format[:yaml|:json|:raw] default is :yaml
+    def report(name, format: :yaml, &block)
+      Loom.log.debug1(self) { "defining reporting pattern => #{name}" }
+      define_pattern_internal(name) do |loom, facts|
+        # TODO: I don't like all of this logic in the dsl.
+        result = if block_given?
+                   Loom.log.debug(self) { "report[#{name}] from block" }
+                   self.instance_exec(loom, facts, &block)
+                 elsif !Loom::Facts.is_empty?(facts[name])
+                   Loom.log.debug(self) { "report[#{name}] from facts[#{name}]" }
+                   facts[name]
+                 elsif self.respond_to?(name) && !self.send(name).nil?
+                   Loom.log.debug(self) { "report[#{name}] from let{#{name}}" }
+                   self.send name
+                 else
+                   err_msg = "no facts to report for fact[#{name}:#{name.class}]"
+                   raise PatternDefinitionError, err_msg
+                 end
+        result = result.stdout if result.is_a? Loom::Shell::CmdResult
+
+        puts case format
+             when :yaml then result.to_yaml
+             when :json then result.to_json
+             when :raw then result
+             else
+               err_msg = "invalid report format: #{format.inspect}"
+               err_msg << "valid options: yaml,json,raw"
+               raise PatternDefinitionError, err_msg
+             end
+      end
+    end
+
     def weave(name, pattern_slugs)
       Loom.log.debug1(self) { "defining weave => #{name}" }
       @weave_slugs ||= {}
@@ -300,7 +371,7 @@ module Loom::Pattern
     end
 
     private
-    def define_pattern_internal(name, &block)
+    def define_pattern_internal(name, &loom_file_block)
       @pattern_methods ||= []
       @pattern_method_map ||= {}
       @pattern_descriptions ||= {}
@@ -312,7 +383,17 @@ module Loom::Pattern
       @pattern_descriptions[method_name] = @next_description
       @next_description = nil
 
-      define_method method_name, &block
+      ##
+      # ```ruby
+      # pattern :xyz do |loom, facts|
+      #   loom.x :dostuff
+      # end
+      # ```
+      # Patterns declared in the .loom file are defined here:
+      define_method method_name do |loom, facts|
+        Loom.log.debug2(self) { "calling .loom file pattern: #{name}" }
+        self.instance_exec(loom, facts, &loom_file_block)
+      end
     end
 
     def hook(scope, &block)

data/lib/loom/pattern/reference_set.rb

@@ -56,22 +56,22 @@ module Loom::Pattern
       using Loom::CoreExt # using demodulize for namespace creation
 
       class << self
-        def create(ruby_code, source)
+        def create(ruby_code, source_file)
           shell_module = Module.new
           shell_module.include Loom::Pattern
           # TODO: I think this is my black magic for capturing stacktrace
           # info... I forget the details. Add documentation.
-          shell_module.module_eval ruby_code, source, 1
+          shell_module.module_eval ruby_code, source_file, 1
           shell_module.namespace ""
 
-          self.new(shell_module, source).build
+          self.new(shell_module, source_file).build
         end
       end
 
-      def initialize(shell_module, source)
+      def initialize(shell_module, source_file)
         @shell_module = shell_module
         @pattern_mod_specs = pattern_mod_specs
-        @source = source
+        @source_file = source_file
       end
 
       def build
@@ -106,7 +106,7 @@ module Loom::Pattern
         desc = mod.pattern_description weave_name
         Loom.log.warn "no descripiton for weave => #{slug}" unless desc
 
-        ExpandingReference.new slug, mod.weave_slugs[weave_name], @source, desc
+        ExpandingReference.new slug, mod.weave_slugs[weave_name], @source_file, desc
       end
 
       def build_pattern_reference(pattern_name, slug, context, mod)
@@ -114,7 +114,7 @@ module Loom::Pattern
         desc = mod.pattern_description pattern_name
         Loom.log.warn "no descripiton for pattern => #{slug}" unless desc
 
-        Reference.new slug, method, @source, context, desc
+        Reference.new slug, method, @source_file, context, desc
       end
 
       def context_for_mod_spec(mod_spec)

data/lib/loom/runner.rb

@@ -78,6 +78,10 @@ module Loom
       rescue => e
         Loom.log.fatal "fatal error => #{e.inspect}"
         Loom.log.fatal e.backtrace.join "\n\t"
+
+        loom_files = @loom_config.files.loom_files
+        loom_errors = e.backtrace.select { |line| line =~ /(#{loom_files.join("|")})/ }
+        Loom.log.error "Loom file errors: \n\t" + loom_errors.join("\n\t")
         exit 99
       end
     end
@@ -114,6 +118,10 @@ module Loom
       pattern_loader = Loom::Pattern::Loader.load @loom_config
       @pattern_refs = pattern_loader.patterns @pattern_slugs
 
+      @loom_config[:loomfile_autoloads].each do |path|
+        Loom.log.debug { "autoloading: #{path}" }
+        require path
+      end
       @mod_loader = Loom::Mods::ModLoader.new @loom_config
     end
 

data/lib/loom/shell/api.rb

@@ -19,6 +19,7 @@ module Loom::Shell
       @shell.local.shell_api
     end
 
+    # This is the entry point for `loom.foo` calls from .loom files.
     def method_missing(name, *args, &block)
       Loom.log.debug3(self) { "shell api => #{name} #{args} #{block}" }
       # TODO: The relationship between shell and mod_loader seems leaky here, a
@@ -42,6 +43,7 @@ module Loom::Shell
     def method_missing(name, *args, &block)
       @cmd_executions.push name
       @cmd_execution_args.push args
+      self
     end
   end
 

data/lib/loom/version.rb

@@ -1,3 +1,3 @@
 module Loom
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/loomext/corefacts/system_info_provider.rb

@@ -83,8 +83,9 @@ module LoomExt::CoreFacts
       facts = {}
       os_release.each_line do |l|
         l = l.strip
+        next if l.empty?
         key, value = l.split("=")
-        unquoted_value = value.gsub(/^"(.+)"$/) { |m| $1 }
+        unquoted_value = value.gsub(/^"(.+)"$/) { |m| $1 } rescue ""
         facts[key.to_sym] = unquoted_value
       end
       facts

data/lib/loomext/coremods/all.rb

@@ -7,8 +7,9 @@ require "loom"
 
 require_relative "exec"
 require_relative "files"
+require_relative "git"
 require_relative "net"
 require_relative "user"
 require_relative "package/package"
-require_relative "system"
+require_relative "systemd"
 require_relative "vm/all"

data/lib/loomext/coremods/exec.rb

@@ -1,3 +1,4 @@
+# TODO: rename this file -> oneliners.rb
 module LoomExt::CoreMods
 
   FailError = Class.new Loom::ExecutionError
@@ -14,8 +15,16 @@ module LoomExt::CoreMods
     end
   end
 
+  class ExecEcho < Loom::Mods::Module
+    register_mod :exec_echo, :alias => [:xe, :"<<e"] do |*cmd, **opts|
+      shell.capture *cmd, **opts
+    end
+  end
+
   class ChangeDirectory < Loom::Mods::Module
     register_mod :change_directory, :alias => :cd do |path, &block|
+      # TODO: I think this block binding is to the Module instead of the RunContext. Find out and
+      # fix it.
       shell.cd path, &block
     end
   end
@@ -34,6 +43,7 @@ module LoomExt::CoreMods
 
   class Sudo < Loom::Mods::Module
     register_mod :sudo do |user: :root, cmd: nil, &block|
+      # TODO: ditto re: binding to Module instead of RunContext.
       shell.sudo user, cmd, &block
     end
   end