loom-core 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00595d8a3c27f3c3a2567849e6d188c68a3c5914646238f0009767bff5769687'
-  data.tar.gz: 1988e1d88027c87309183db5355a2167f46ef2c48efcde7d5d143daf04011ea3
+  metadata.gz: fca395ca95a28376331f0163c1748fcd3eb083c2f6d677627edb04a795c5b858
+  data.tar.gz: 29fc16366271bfe121eb57b7315daa87a6d8017210d41a061cdecc6665bb26bc
 SHA512:
-  metadata.gz: a48f5d6d82ec87da2c8e0dca0107602a434f8e4d8f42e1eb5d4d5638106aea1733836745d91db52f497b0eb4d2b9812909a42e9aef10a6408a26b23cb227758c
-  data.tar.gz: dc23a63efd9405c7834911e66a709f944793e8b9bca62858e0a86864f999d0d8e942a21f9bda9893bd2672291806205d0b7e752cb9dbe70e0b2854630434bb97
+  metadata.gz: 291da2a4d0b793019dd65c511dfc1caa113a3a12c3a7f2ab12e9b991a8e5ce09b4fba97fb150b15b01edd6c67f0ea0536f16fc00384bf80c6ec54f9b21c9c1c2
+  data.tar.gz: 0b18248b8cf5583a48fb3844c39e15b0db216ad6c6ab62a160b5013d05e6f8931bbf165c35c7e107ce3de28a88e7227662480fd263f11031fb5356da2729c5a6

data/.gitignore

@@ -1 +1,2 @@
 pkg
+loom-core-0.0.1.gem

data/lib/loom/dsl.rb

@@ -31,6 +31,7 @@ module Loom
         sshkit_backend = self
 
         begin
+          # TODO: document the reciever of this yield
           yield sshkit_backend, host_spec
         rescue SocketError => e
           Loom.log.error "error connecting to host => #{host_spec.hostname}"
@@ -53,6 +54,7 @@ module Loom
       end
     end
 
+    # TODO: Why did I make this "shadow" class?
     class SSHKitDSLShadow
       extend SSHKit::DSL
     end

data/lib/loom/host_spec.rb

@@ -11,6 +11,8 @@ module Loom
     attr_accessor :disabled
     attr_reader :sshkit_host
 
+    # TODO: change this to take an sshkit_host and make parse public. Stop calling parse from the
+    # ctor.
     def initialize(host_string)
       @sshkit_host = parse host_string
     end
@@ -26,7 +28,15 @@ module Loom
 
     private
     def parse(host_string)
-      SSHKit::Host.new host_string
+      host = SSHKit::Host.new host_string
+      host.ssh_options = {
+        :auth_methods => ['publickey'],
+        :keys => ["~/.ssh/id_esd25519_2"],
+#        :verbose => :debug,
+      }
+      Loom.log.debug1(self) { "parsing hoststring[#{host_string}] => #{host}" }
+      Loom.log.debug1(self) { "netssh options for host[#{host}] => #{host.netssh_options}" }
+      host
     end
   end
 end

data/lib/loom/mods/action_proxy.rb

@@ -41,11 +41,11 @@ module Loom::Mods
           bound_action_name = tuple[1]
 
           define_method public_action_name do |*args, &block|
-            # TODO: Effectively this is the API for all mods, but it's burried
-            # here in the middle of nowhere. Add documentation - or make it
-            # easier to read.
-            Loom.log.debug2(self) do
-              "proxy to mod #{@mod} => #{public_action_name}: #{args} #{block}"
+            # TODO[P0]: Effectively this is the API for all mods, but it's
+            # burried here in the middle of nowhere. Add documentation - or make
+            # it easier to read.
+            Loom.log.debug(self) do
+              "proxy to mod action: #{public_action_name} => #{bound_action_name}, #{@mod}"
             end
 
             @mod.send bound_action_name, *args, &block
@@ -89,7 +89,7 @@ module Loom::Mods
       def add_action(action_name, bound_method_name, namespace=nil)
         if namespace.nil?
           tuple = [action_name, bound_method_name]
-          @action_tuples << tuple unless namespace 
+          @action_tuples << tuple unless namespace
         else
           # Adds an action name to a nested ActionMap
           add_namespace(namespace).add_action action_name, bound_method_name

data/lib/loom/mods/module.rb

@@ -40,6 +40,9 @@ module Loom::Mods
       else
         Loom.log.debug3(self) { "initing action => #{args}" }
         init_action *args, &pattern_block
+
+        # TODO: ooohhh... the action_proxy code path is fucking
+        # crazy. ActionProxy needs some documentation.
         action_proxy
       end
     end
@@ -50,6 +53,8 @@ module Loom::Mods
         Loom.log.debug2(self) { "registered mod => #{name}" }
 
         if block_given?
+          # TODO: i forget what mod_blocks are. read through, remember, and
+          # document them.
           Loom.log.debug2(self) { "acting as mod_block => #{name}:#{block}" }
           define_method :mod_block, &block
         end
@@ -83,6 +88,11 @@ module Loom::Mods
       def bind_action(action_name, unbound_method, namespace=nil)
         bound_method_name = [namespace, action_name].compact.join '_'
 
+        # TODO: document why the `define_method` calls in class only operate on
+        # the single mod instance, rather than adding each "bound_method_name"
+        # (e.g.) to each instance of Module. (actually I think it's because this
+        # is executing from the subclass (via import_actions), so it's only that
+        # class). in any case, add more docs and code pointers.
         define_method bound_method_name do |*args, &block|
           Loom.log.debug1(self) { "exec mod action #{self.class}##{bound_method_name}" }
 

data/lib/loom/pattern/result_reporter.rb

@@ -44,6 +44,14 @@ module Loom::Pattern
       report << "Completed in: %01.3fs" % @delta_t
 
       cmds.find_all { |cmd| !cmd.is_test }.each do |cmd|
+        # TODO: this is a bit confusing for the user... when you cat a file from
+        # a loom pattern, the output of a command isn't visible unless -V is
+        # specified... not sure what to do here. I don't want to see the output
+        # of every command, and I don't really want to pipe more info through
+        # the `@shell_session.command_results` (e.g. should_report_result:)?
+        #
+        # Although.. maybe that's the better API? then the logic here can be
+        # moved and strategized per command/result/shell.
         if !cmd.success? || @loom_config.run_verbose
           report.concat generate_cmd_report(cmd)
         end

data/lib/loom/runner.rb

@@ -165,8 +165,8 @@ module Loom
       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
+      # TODO: This is a crappy mechanism for tracking errors (hency my crappy error reporting :( ),
+      # 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
@@ -175,7 +175,8 @@ module Loom
         Loom.log.debug e.backtrace.join "\n\t"
         run_failure << e
       ensure
-        # TODO: this prints out [Result: OK] even if an exception is raised
+        # TODO[P0]: this prints out [Result: OK] even if an exception is raised... this is really
+        # annoying.
         result_reporter.write_report
 
         # TODO: this is not the correct error condition.

data/lib/loom/shell/core.rb

@@ -24,6 +24,10 @@ module Loom::Shell
 
     attr_reader :session, :shell_api, :mod_loader, :dry_run
 
+    def is_sudo?
+      !@sudo_users.empty?
+    end
+
     def local
       @local ||= LocalShell.new @mod_loader, @session, @dry_run
     end
@@ -96,6 +100,35 @@ module Loom::Shell
       end
     end
 
+    # def sudo(user=nil, *sudo_cmd, &block)
+    #   # I'm trying to work around crappy double escaping issues caused by
+    #   # sudo_legacy... but I'm failing
+    #   if block_given?
+    #     # TODO: this shit is broken with these errors:
+    #     #   $ ... 'You cannot switch to user '' using sudo, please check the sudoers file'
+    #     #
+    #     # Loom.log.debug3(self) { "sudo with SSHKit::Backend+as+" }
+    #     # @sshkit_backend.as user, &block
+
+    #     # Aside from probably being unsafe... this implementation leads to a
+    #     # hung terminal after switching to root.... sigh....
+    #     #
+    #     # Loom.log.warn(self) { "fix sudo... this doesn't seem safe" }
+    #     # execute "sudo", "su", user
+    #     # begin
+    #     #   yield
+    #     # ensure
+    #     #   execute "exit"
+    #     # end
+
+    #     Loom.log.debug3(self) { "sudo legacy... the other way" }
+    #     sudo_stack_and_wrap(user, *sudo_cmd, &block)
+    #   else
+    #     Loom.log.debug3(self) { "sudo legacy" }
+    #     sudo_stack_and_wrap(user, *sudo_cmd)
+    #   end
+    # end
+
     def cd(path, &block)
       Loom.log.debug1(self) { "cd => #{path} #{block}" }
 
@@ -124,6 +157,10 @@ module Loom::Shell
       execute cmd
     end
 
+    def upload(local_path, remote_path)
+      @sshkit_backend.upload! local_path, remote_path
+    end
+
     def execute(*cmd_parts, is_test: false, **cmd_opts)
       cmd_parts.compact!
       raise "empty command passed to execute" if cmd_parts.empty?
@@ -159,9 +196,10 @@ module Loom::Shell
       "[%s]:$ %s" % [prompt_label, output]
     end
 
-    def execute_internal(*cmd_parts, piped_cmds: [])
+    def execute_internal(*cmd_parts, pipe_to: [])
       primary_cmd = create_command *cmd_parts
-      piped_cmds = piped_cmds.map { |cmd_parts| CmdWrapper.new *cmd_parts }
+      # TODO: where is piped_cmds used?
+      piped_cmds = pipe_to.map { |cmd_parts| CmdWrapper.new *cmd_parts }
 
       cmd = CmdPipeline.new([primary_cmd].concat(piped_cmds)).to_s
       # Tests if the command looks like "echo\ hi", the trailing slash after
@@ -187,9 +225,13 @@ module Loom::Shell
     # @return [String|Loom::Shell::CmdWrapper]
     def create_command(*cmd_parts)
       cmd_wrapper = if cmd_parts.is_a? CmdWrapper
+                      Loom.log.debug3(self) { "existing cmd from args => #{cmd_parts}" }
                       cmd_parts
+                    elsif cmd_parts[0].is_a? CmdWrapper
+                      Loom.log.debug3(self) { "existing cmd from args[0] => #{cmd_parts[0]}" }
+                      cmd_parts[0]
                     else
-                      Loom.log.debug3(self) { "new cmd from parts => #{cmd_parts}" }
+                      Loom.log.debug3(self) { "new cmd from args => #{cmd_parts}" }
                       CmdWrapper.new *cmd_parts
                     end
 

data/lib/loom/shell/harness/session.rb

@@ -0,0 +1,168 @@
+# 10/21/2018: I resurrected this from an auto save file from a LOONNGGGG time
+# ago., not really sure exactly what the original purpose is, but it has the
+# code for uploading the harness script. I believe this was working at one
+# point, but that was long ago
+
+module Loom
+
+  # Ensures loom is setup to run on the remote.
+  # - creates the boostrap loom directory
+  # - uploads the harness
+  # - creates a directoy for loom execution logging
+  class HostSession
+
+    HISTORY_FILE = "command.log"
+
+    # @param [Loom::HostSpec] host_spec
+    # @param [Loom::Config] loom_config
+    # @param [SSHKit::Backend::Abstract] sshkit_backend
+    def initialize(host_spec, loom_config, sshkit_backend)
+      @host_spec = host_spec
+      @sshkit_backend = sshkit_backend
+      @loom_config = loom_config
+
+      @remote_loom_root = loom_config.bootstrap_loom_root
+      @loom_user = loom_config.loom_user
+
+      @session_name = "session.%d" % Time.now.to_i
+      @disabled = false
+    end
+
+    attr_reader :session_name
+
+    def bootstrap
+      ensure_loom_remote_dirs
+      ensure_harness_uploaded
+      log_to_command_history "begin loom execution"
+      log_to_command_history "start: " + Time.now.to_i.to_s
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    # @param [Loom::Pattern::Reference] pattern_ref
+    # @return [Loom::Pattern::ExecResult]
+    def execute_pattern(pattern_ref)
+      shell = create_shell
+
+      shell_session = shell.session
+      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
+        fact_set = collect_facts_for_host
+        pattern_ref.call(shell.shell_api, fact_set)
+      rescue => e
+        handle_host_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 result_reporter.failure_summary
+        end
+        @result_reports << result_reporter
+        @run_failures << run_failure unless run_failure.empty?
+      end
+    end
+
+    def handle_host_failure(error_or_message=nil)
+      Loom.log.debug { "handling host failure => #{hostname}" }
+      if error_or_message.respond_to? :backtrace
+        Loom.log.debug { e.backtrace.join "\n\t" }
+      end
+
+      message = if error_or_message.respond_to? :message
+                  error_or_message.message
+                else
+                  error_or_message
+                end
+
+      failure_strategy = @loom_config.run_failure_strategy.to_sym
+      case failure_strategy
+      when :exclude_host
+        Loom.log.warn "disabling host due to failure => #{message}"
+        @disabled = true
+      when :fail_fast
+        Loom.log.error "fail fast host failure => #{message}"
+        raise FailFastExecutionError, message
+      when :cowboy
+        # This is mostly for testing, don't use in prod.
+        Loom.log.warn "cowboy failure, wooohooo => #{message}"
+      else
+        raise ConfigError, "unknown failure_strategy: #{failure_stratgy}"
+      end
+    end
+
+    private
+
+    # @return [String]
+    def script_path
+      File.join @remote_loom_root, "scripts"
+    end
+
+    # @return [String]
+    def session_path
+      File.join @remote_loom_root, "run", @session_name
+    end
+
+    # @return [String]
+    def history_file
+      File.join session_name, HISTORY_FILE
+    end
+
+    def ensure_loom_remote_dirs
+      @sshkit_backend.as user: :root do
+        @sshkit_backend.execute :mkdir, '-p', @remote_loom_root
+        @sshkit_backend.execute :mkdir, '-p', script_path
+        @sshkit_backend.execute :mkdir, '-p', session_path
+
+        chown_opts = "-R %s:%s %s" % [@loom_user, @loom_user, @remote_loom_root]
+        @sshkit_backend.execute :chown, chown_opts
+      end
+    end
+
+    def ensure_harness_uploaded
+      @sshkit_backend.upload! Loom::Resource::HARNESS, script_path
+    end
+
+    def create_command_history
+      @sshkit_backend :touch, history_file
+    end
+
+    def write_to_command_history(text)
+      @sshkit_backend :cat, "<<EOS\n#{text}\nEOS", ">>", history_file
+    end
+
+    def log_to_command_history(text)
+      write_to_command_history(
+        "[%s] %s: #{text}" % [Time.now.utc.to_s, hostname])
+    end
+
+    # The naming inconsistency w/ the missing underscore in hostname (vs
+    # host_spec, host_session, etc...) is confusing, but that's *nix's fault.
+    def hostname
+      @host_spec.hostname
+    end
+
+    def collect_facts_for_host
+      Loom.log.info "collecting facts for host => #{hostname}"
+      Loom::Facts.fact_set(@host_spec, create_shell, @loom_config)
+    end
+
+    def create_shell
+      Loom::Shell.create create_mod_loader, @sshkit_backend
+    end
+
+    def create_mod_loader
+      Loom::Mods::ModLoader.new loom_config
+    end
+  end
+end

data/lib/loom/version.rb

@@ -1,3 +1,3 @@
 module Loom
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/loomext/coremods/all.rb

@@ -10,4 +10,5 @@ require_relative "files"
 require_relative "net"
 require_relative "user"
 require_relative "package/package"
+require_relative "system"
 require_relative "vm/all"

data/lib/loomext/coremods/exec.rb

@@ -31,11 +31,17 @@ module LoomExt::CoreMods
   end
 
   class Sudo < Loom::Mods::Module
-    register_mod :sudo do |user: nil, cmd: nil, &block|
+    register_mod :sudo do |user: :root, cmd: nil, &block|
       shell.sudo user, cmd, &block
     end
   end
 
+  class SudoCheck < Loom::Mods::Module
+    register_mod :is_sudo? do
+      shell.is_sudo?
+    end
+  end
+
   class Test < Loom::Mods::Module
     register_mod :test do |*cmd|
       shell.test *cmd
@@ -47,4 +53,10 @@ module LoomExt::CoreMods
       raise FailError, message
     end
   end
+
+  class Upload < Loom::Mods::Module
+    register_mod :upload do |local_path, remote_path|
+      shell.upload local_path, remote_path
+    end
+  end
 end

data/lib/loomext/coremods/files.rb

@@ -3,6 +3,8 @@ module LoomExt::CoreMods
 
     register_mod :files
 
+    # TODO: document loom file statements like:
+    #     `loom.files("some", "different/paths").cat`
     def init_action(paths)
       @paths = [paths].flatten.compact
     end
@@ -45,6 +47,12 @@ module LoomExt::CoreMods
         end
       end
 
+      def mv(new_path)
+        each_path do |p|
+          shell.capture :mv, p, new_path
+        end
+      end
+
       def match?(pattern: /./)
         all = true
         each_path do |p|
@@ -80,20 +88,70 @@ module LoomExt::CoreMods
         each_path :action => :mkdir, :flags => flags
       end
 
+      def ensure_line(line, sudo: false)
+        if loom.is_sudo?
+          Loom.log.warn "do not use files.ensure_line in sudo  due to poor command escaping" +
+            ": use files.ensure_line and pass sudo: true"
+        end
+
+        each_path do |p|
+          file = shell.capture :cat, p
+
+          unless file.match(line)
+            if sudo
+              sudo_append(line)
+            else
+              append(line)
+            end
+          end
+        end
+      end
+
+      # this is a hack to accomodate append being f'd inside sudo blocks
+      def sudo_append(text="")
+        if text.index "\n"
+          Loom.log.warn "append lines individually until cmd escaping is fixed.... "
+        end
+
+        each_path do |p|
+          text.each_line do |line|
+            loom.x "/bin/echo", "-e", line, :pipe_to => [[:sudo, :tee, "-a", p]]
+          end
+        end
+      end
+
       def append(text="")
+        if text.index "\n"
+          Loom.log.warn "append lines individually until cmd escaping is fixed.... "
+        end
+
+        if loom.is_sudo?
+          Loom.log.warn "do not use files.append in sudo" +
+            ": use files.sudo_append due to poor command escaping"
+        end
+
         each_path do |p|
-          loom.test "[ -f #{p} ]"
+          # TODO: this shit is broken when escaped in a sudo command. This is
+          # why I began work on the harness.
+          # 	$ cd /home/pi; sudo -u root -- /bin/sh -c "/bin/echo -e 192.168.1.190 rp0\''; '\'" | tee -a /etc/hosts
+          #
+          text.each_line do |line|
+            loom.x :"/bin/echo", "-e", line, :pipe_to => [[:tee, "-a", p]]
+          end
 
-          redirect = Loom::Shell::CmdRedirect.append_stdout p
-          cmd = Loom::Shell::CmdWrapper.new(
-            :"/bin/echo", "-e", text, redirect: redirect)
-          shell.execute cmd
+          # TODO: fix this broken shit w/ the harness, CmdRedirect and
+          # CmdWrapper are dogshit. This was an escaping attempt before harness
+          # script.
+          #
+          # redirect = Loom::Shell::CmdRedirect.append_stdout p
+          # cmd = Loom::Shell::CmdWrapper.new(
+          #   :"/bin/echo", "-e", text, redirect: redirect)
         end
       end
 
       def write(text="")
         each_path do |p|
-          loom.x :"/bin/echo", "-e", text, :piped_cmds => [[:tee, p]]
+          loom.x :"/bin/echo", "-e", text, :pipe_to => [[:tee, p]]
         end
       end
 

data/lib/loomext/coremods/package/adapter.rb

@@ -54,7 +54,8 @@ module LoomExt::CoreMods
     class AptAdapter < DpkgAdapter
 
       def install(pkg_name)
-        loom.net.with_net { loom << "echo apt-get install #{pkg_name}" }
+        loom.x "apt-get", "-y", "install", pkg_name
+#        loom.net.with_net { loom << "echo apt-get install #{pkg_name}" }
       end
 
       def uninstall(pkg_name)
@@ -62,11 +63,14 @@ module LoomExt::CoreMods
       end
 
       def update_cache
-        loom.net.with_net { loom << "apt update" }
+#        loom.net.with_net { loom << "apt update" }
+        loom.x "apt", "-y", "update"
       end
 
-      def upgrade(pkg_name)
-        loom.net.with_net { loom << "apt upgrade" }
+      def upgrade(pkg_name = nil)
+#        loom.net.with_net { loom << "apt upgrade" }
+        args = ["apt-get", "-y", "upgrade", pkg_name].compact
+        loom.x(*args)
       end
     end
 

data/lib/loomext/coremods/system.rb

@@ -0,0 +1,52 @@
+module LoomExt::CoreMods
+
+  class Systemd < Loom::Mods::Module
+
+    register_mod :systemd
+
+    def do_systemctl(action, *args)
+      shell.execute "systemctl", action, *args
+    end
+
+    module Actions
+
+      def is_loaded?(unit)
+        status(unit).match? /^\s+Loaded:\sloaded\s/
+      end
+
+      def is_active?(unit)
+        status(unit).match? /^\s+Active:\sactive\s/
+      end
+
+      def status(unit)
+        do_systemctl "status", unit
+      end
+
+      def enable(unit)
+        do_systemctl "enable", unit
+      end
+
+      def start(unit)
+        do_systemctl "start", unit
+      end
+
+      def disable(unit)
+        do_systemctl "disable", unit
+      end
+
+      def restart(unit)
+        do_systemctl "restart", unit
+      end
+
+      def stop(unit)
+        do_systemctl "stop", unit
+      end
+
+      def link(path)
+        do_systemctl "link", path
+      end
+    end
+  end
+
+  Systemd.import_actions Systemd::Actions
+end

data/lib/loomext/coremods/vm/vbox.rb

@@ -13,7 +13,7 @@ module LoomExt::CoreMods::VM
       end
 
       def check_running(vm)
-        loom.test "vboxmanage list runningvms".split, :piped_cmds => [
+        loom.test "vboxmanage list runningvms".split, :pipe_to => [
           "grep \"#{vm}\"".split
         ]
       end

data/loom.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'sshkit', '~> 1.11'
   s.add_dependency 'commander', '~> 4.4'
 
+  # *** Obsolete, see new issue below ***
   # Need net-ssh beta and its explicit requirements until for ed25519
   # elliptic curve key support
   # https://github.com/net-ssh/net-ssh/issues/214
@@ -26,9 +27,13 @@ Gem::Specification.new do |s|
   # release due to net-scp gem dependencies.
   # I can manually `gem install net-ssh --version 4.0.0.beta3` for now.
   # s.add_dependency 'net-ssh', '>= 4.0.0.beta3'
-  s.add_dependency 'net-ssh', '>= 3'
+  s.add_dependency 'net-ssh', '>= 5'
   s.add_dependency 'rbnacl-libsodium', '1.0.10'
-  s.add_dependency 'bcrypt_pbkdf', '1.0.0.alpha1'
+  s.add_dependency 'bcrypt_pbkdf', ">= 1.0", "< 2.0"
+
+  # New net-ssh requiremetns for ed25519
+  # https://github.com/net-ssh/net-ssh/issues/565
+  s.add_dependency 'ed25519', '>=1.0', '<2.0'
 
   s.add_development_dependency 'bundler', '~> 1.13'
   s.add_development_dependency 'rake', '~> 11.3'

data/scripts/harness.sh

@@ -28,7 +28,8 @@
 #  EOS
 #
 # There are 2 different shells that the harness deals with. The
-# harness shell, and the command shell.
+# harness shell, and the command shell. The point being, to isolate
+# each environment and be independent of the other.
 #
 # The harness shell is the shell used to run the harness script (this
 # file). Only POSIX features are supported in the harness

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loom-core
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Erick Johnson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-27 00:00:00.000000000 Z
+date: 2018-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sshkit
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rbnacl-libsodium
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +70,42 @@ dependencies:
   name: bcrypt_pbkdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.0.0.alpha1
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.0.0.alpha1
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -213,6 +239,7 @@ files:
 - lib/loom/shell/cmd_result.rb
 - lib/loom/shell/cmd_wrapper.rb
 - lib/loom/shell/core.rb
+- lib/loom/shell/harness/session.rb
 - lib/loom/shell/harness_blob.rb
 - lib/loom/shell/harness_command_builder.rb
 - lib/loom/shell/session.rb
@@ -229,6 +256,7 @@ files:
 - lib/loomext/coremods/net.rb
 - lib/loomext/coremods/package/adapter.rb
 - lib/loomext/coremods/package/package.rb
+- lib/loomext/coremods/system.rb
 - lib/loomext/coremods/user.rb
 - lib/loomext/coremods/vm.rb
 - lib/loomext/coremods/vm/all.rb
@@ -268,7 +296,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Repeatable management of remote hosts over SSH