loom-core 0.0.1

data/lib/loom/shell/harness_blob.rb

@@ -0,0 +1,26 @@
+require 'base64'
+require 'digest/sha1'
+
+module Loom::Shell
+
+  # A blob of commands fit for sending to the harness.
+  class HarnessBlob
+
+    def initialize(cmd_blob)
+      @cmd_blob = cmd_blob
+    end
+
+    attr_reader :cmd_blob
+
+    def encoded_script
+      # TODO: Fix this trailing newline hack, it is here to make encoding
+      # consistent with the harness.sh script, which is a bit messy with how it
+      # treats trailing newlines.
+      Base64.encode64(cmd_blob + "\n")
+    end
+
+    def checksum
+      Digest::SHA1.hexdigest encoded_script
+    end
+  end
+end

data/lib/loom/shell/harness_command_builder.rb

@@ -0,0 +1,50 @@
+module Loom
+  module Shell
+
+    HarnessMissingStdin = Class.new Loom::LoomError
+
+    class HarnessCommandBuilder
+
+      # TODO: Resolve a real script path.
+      SCRIPT = "./scripts/harness.sh"
+
+      DEFAULT_RUN_OPTS = {
+        :cmd_shell => "/bin/dash",
+        :record_file => "/opt/loom/commands"
+      }
+
+      def initialize(harness_blob)
+        @harness_blob = harness_blob
+        @run_opts = DEFAULT_RUN_OPTS.dup
+      end
+
+      def run_cmd
+        build_cmd :run, @harness_blob.checksum, *hash_to_opts_array(@run_opts),
+                  {
+                    :stdin => @harness_blob.encoded_script
+                  }
+      end
+
+      def check_cmd
+        build_cmd :check, @harness_blob.checksum, {
+                    :stdin => @harness_blob.encoded_script
+                  }
+      end
+
+      private
+      def hash_to_opts_array(hash)
+        hash.to_a.map do |tuple|
+          "--%s %s" % [tuple.first, tuple.last]
+        end
+      end
+
+      def build_cmd(cmd, *args, stdin: nil)
+        raise HarnessMissingStdin unless stdin
+
+        heredoc = "<<'HARNESS_EOS'\n#{stdin}\nHARNESS_EOS"
+        cmd = "--" + cmd.to_s
+        "%s %s 2>/dev/null - %s %s" % [SCRIPT, cmd, args.join(" "), heredoc]
+      end
+    end
+  end
+end

data/lib/loom/shell/session.rb

@@ -0,0 +1,25 @@
+module Loom::Shell
+  class Session
+    def initialize
+      @command_results = []
+      @success = true
+    end
+
+    attr_reader :command_results
+
+    def success?
+      @success
+    end
+
+    def last
+      @command_results.last
+    end
+
+    def <<(command_result)
+      @command_results << command_result
+      unless command_result.is_test
+        @success &&= command_result.success?
+      end
+    end
+  end
+end

data/lib/loom/trap.rb

@@ -0,0 +1,44 @@
+module Loom
+  class Trap
+
+    class SignalExit < Loom::LoomError
+      attr_reader :signal
+
+      def initialize(signal)
+        @signal = signal
+      end
+    end
+
+    # See `man 7 signal` or #{Signal.list}
+    module Sig
+      HUP = "HUP"
+      INT = "INT"
+      QUIT = "QUIT"
+      TERM = "TERM"
+      USR1 = "USR1"
+      USR2 = "USR2"
+    end
+
+    def self.install(signal, trap_handler)
+      raise "unknown signal => #{signal}" unless Signal.list[signal]
+      Signal.trap signal do
+        trap_handler.handle(signal)
+      end
+    end
+
+    class Handler
+
+      def initialize(&handler)
+        @signal_handle_counts = {}
+        @handler = handler
+      end
+
+      def handle(signal)
+        @signal_handle_counts[signal] ||= 0
+        @signal_handle_counts[signal] += 1
+
+        @handler.call signal, @signal_handle_counts[signal]
+      end
+    end
+  end
+end

data/lib/loom/version.rb

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

data/lib/loomext/all.rb

@@ -0,0 +1,4 @@
+LoomExt = Module.new
+
+require_relative "corefacts"
+require_relative "coremods"

data/lib/loomext/corefacts.rb

@@ -0,0 +1,6 @@
+module LoomExt
+  module CoreFacts
+  end
+end
+
+require_relative "corefacts/all"

data/lib/loomext/corefacts/all.rb

@@ -0,0 +1,8 @@
+module LoomExt
+  module CoreFacts
+  end
+end
+
+require "loom"
+
+require_relative "facter_provider"

data/lib/loomext/corefacts/facter_provider.rb

@@ -0,0 +1,24 @@
+module LoomExt::CoreFacts
+  class FacterProvider < Loom::Facts::Provider
+
+    Loom::Facts::Provider.register_factory(self) do |host_spec, shell, loom_config|
+      FacterProvider.new host_spec, shell
+    end
+
+    def initialize(host_spec, shell)
+      @has_facter = shell.test :which, "facter"
+      disable(host_spec) unless @has_facter
+      @shell = shell
+    end
+
+    def collect_facts
+      unless @has_facter
+        Loom.log.error "facter not installed"
+        return {}
+      end
+
+      yaml_facts = @shell.capture :facter, "--yaml"
+      yaml_facts.nil? ? {} : YAML.load(yaml_facts)
+    end
+  end
+end

data/lib/loomext/coremods.rb

@@ -0,0 +1,5 @@
+module LoomExt
+  module CoreMods
+  end
+end
+require_relative "coremods/all"

data/lib/loomext/coremods/all.rb

@@ -0,0 +1,13 @@
+module LoomExt
+  module CoreMods
+  end
+end
+
+require "loom"
+
+require_relative "exec"
+require_relative "files"
+require_relative "net"
+require_relative "user"
+require_relative "package/package"
+require_relative "vm/all"

data/lib/loomext/coremods/exec.rb

@@ -0,0 +1,50 @@
+module LoomExt::CoreMods
+
+  FailError = Class.new Loom::ExecutionError
+
+  ##
+  # Executes shell commands from patterns. e.g.
+  #
+  # loom << :echo, "hello there"
+  class Exec < Loom::Mods::Module
+    register_mod :exec, :alias => [:x, :<<] do |*cmd, **opts|
+      shell.execute *cmd, **opts
+    end
+  end
+
+  class ChangeDirectory < Loom::Mods::Module
+    register_mod :change_directory, :alias => :cd do |path, &block|
+      shell.cd path, &block
+    end
+  end
+
+  class Timeout < Loom::Mods::Module
+    register_mod :timeout do |timeout: 60, &block|
+      shell.wrap(:timeout, timeout, :should_quote => false, &block)
+    end
+  end
+
+  class Time < Loom::Mods::Module
+    register_mod :time do |&block|
+      shell.wrap(:time, :should_quote => false, &block)
+    end
+  end
+
+  class Sudo < Loom::Mods::Module
+    register_mod :sudo do |user: nil, cmd: nil, &block|
+      shell.sudo user, cmd, &block
+    end
+  end
+
+  class Test < Loom::Mods::Module
+    register_mod :test do |*cmd|
+      shell.test *cmd
+    end
+  end
+
+  class Fail < Loom::Mods::Module
+    register_mod :fail do |message=nil|
+      raise FailError, message
+    end
+  end
+end

data/lib/loomext/coremods/files.rb

@@ -0,0 +1,104 @@
+module LoomExt::CoreMods
+  class Files < Loom::Mods::Module
+
+    register_mod :files
+
+    def init_action(paths)
+      @paths = [paths].flatten.compact
+    end
+
+    private
+    ##
+    # Executes #{action} for each path in #{paths} or #{@paths}. If
+    # action is not given, a block is expected to which each path will
+    # be passed.
+    def each_path(action: nil, flags: nil, &block)
+      raise 'use either action or block in each_path' if action && block_given?
+      raise 'use either action or block in each_path' unless action || block_given?
+
+      @paths.each do |p|
+        next unless p
+
+        raise "prefix relative paths with '.': #{p}" unless p.match /^[.]?\//
+        if block
+          yield p
+        else
+          shell.execute action, flags, p
+        end
+      end
+
+      # Return self for chaining in pattern files
+      self
+    end
+
+    module Actions
+
+      def cat
+        each_path do |p|
+          shell.capture :cat, p
+        end
+      end
+
+      def rm
+        each_path do |p|
+          shell.capture :rm, "-f", p
+        end
+      end
+
+      def match?(pattern: /./)
+        all = true
+        each_path do |p|
+          file = shell.capture :cat, p
+          all &&= file.match(pattern)
+        end
+        all
+      end
+
+      def gsub(pattern: nil, replace: nil, &block)
+        each_path do |p|
+          contents = shell.capture :cat, p
+          if contents
+            contents.gsub!(pattern, replace, &block) unless pattern.nil?
+            write contents
+          end
+        end
+      end
+
+      def chown(user: nil, group: nil)
+        group_arg = group && ":" + group.to_s
+
+        each_path do |p|
+          shell.execute :chown, [user, group_arg].compact.map(&:to_s).join, p
+        end
+      end
+
+      def touch
+        each_path :action => :touch
+      end
+
+      def mkdir(flags: nil, **opts)
+        each_path :action => :mkdir, :flags => flags
+      end
+
+      def append(text="")
+        each_path do |p|
+          loom.test "[ -f #{p} ]"
+
+          redirect = Loom::Shell::CmdRedirect.append_stdout p
+          cmd = Loom::Shell::CmdWrapper.new(
+            :"/bin/echo", "-e", text, redirect: redirect)
+          shell.execute cmd
+        end
+      end
+
+      def write(text="")
+        each_path do |p|
+          loom.x :"/bin/echo", "-e", text, :piped_cmds => [[:tee, p]]
+        end
+      end
+
+    end
+  end
+
+  Files.import_actions Files::Actions
+end

data/lib/loomext/coremods/net.rb

@@ -0,0 +1,33 @@
+module LoomExt::CoreMods
+  class Net < Loom::Mods::Module
+
+    NoNetworkError = Class.new Loom::ExecutionError
+
+    register_mod :net
+
+    def init_action(timeout: 10, check_host: "8.8.8.8")
+      @net_timeout = timeout
+      @check_host = check_host
+    end
+
+    module Actions
+
+      def has_net?
+        loom.timeout :timeout => @net_timeout do
+          loom.test :sh, "-c", "while ! ping -c1 #{@check_host}; do true; done"
+        end
+      end
+
+      def check_net
+        raise NoNetworkError, "no network available" unless has_net?
+      end
+
+      def with_net(&block)
+        check_net
+        yield if block_given?
+      end
+    end
+
+    import_actions Net::Actions
+  end
+end

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

@@ -0,0 +1,100 @@
+module LoomExt::CoreMods
+  class Package < Loom::Mods::Module
+
+    class PkgAdapter
+
+      attr_reader :loom
+
+      def initialize(loom)
+        @loom = loom
+      end
+
+      def ensure_installed(pkg_name)
+        install(pkg_name) unless installed?(pkg_name)
+      end
+
+      def installed?(pkg_name)
+        raise 'not implemnted'
+      end
+
+      def install(pkg_name)
+        raise 'not implemented'
+      end
+
+      def uninstall(pkg_name)
+        raise 'not implemented'
+      end
+
+      def update_cache
+        raise 'not implemented'
+      end
+
+      def upgrade(pkg_name)
+        raise 'not implemented'
+      end
+    end
+
+    class GemAdapter < PkgAdapter
+      def installed?(pkg_name)
+        loom.test "ruby -r#{pkg_name} -e exit"
+      end
+
+      def install(pkg_name)
+        loom << "gem install #{pkg_name}"
+      end
+    end
+
+    class DpkgAdapter < PkgAdapter
+
+      def installed?(pkg_name)
+        loom.test "dpkg -s #{pkg_name}"
+      end
+    end
+
+    class AptAdapter < DpkgAdapter
+
+      def install(pkg_name)
+        loom.net.with_net { loom << "echo apt-get install #{pkg_name}" }
+      end
+
+      def uninstall(pkg_name)
+        loom << "echo apt uninstall"
+      end
+
+      def update_cache
+        loom.net.with_net { loom << "apt update" }
+      end
+
+      def upgrade(pkg_name)
+        loom.net.with_net { loom << "apt upgrade" }
+      end
+    end
+
+    class RpmAdapter < PkgAdapter
+
+      def installed?(pkg_name)
+        loom.test :rpm, "-q #{pkg_name}"
+      end
+
+    end
+
+    class DnfAdapter < RpmAdapter
+
+      def install(pkg_name)
+        loom.net.with_net { loom << "dnf install #{pkg_name}" }
+      end
+
+      def uninstall(pkg_name)
+        loom << "echo dnf uninstall"
+      end
+
+      def update_cache
+        loom.net.with_net { loom << "dnf updateinfo" }
+      end
+
+      def upgrade(pkg_name)
+        raise 'not implemented'
+      end
+    end
+  end
+end