loom-core 0.0.1

data/lib/loom/shell.rb

@@ -0,0 +1,12 @@
+module Loom
+  module Shell
+
+    VerifyError = Class.new Loom::LoomError
+
+    def self.create(*args)
+      Loom::Shell::Core.new *args
+    end
+  end
+end
+
+require_relative "shell/all"

data/lib/loom/shell/all.rb

@@ -0,0 +1,10 @@
+require_relative "harness_blob"
+require_relative "harness_command_builder"
+
+require_relative "cmd_result"
+require_relative "cmd_wrapper"
+
+require_relative "session"
+require_relative "api"
+
+require_relative "core"

data/lib/loom/shell/api.rb

@@ -0,0 +1,48 @@
+module Loom::Shell
+
+  ##
+  # A facade for the shell API exposed to Loom files. This is the +loom+ object
+  # passed to patterns.
+  class Api
+
+    def initialize(shell)
+      @shell = shell
+      @mod_loader = shell.mod_loader
+      @dry_run = shell.dry_run
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    def local
+      @shell.local.shell_api
+    end
+
+    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
+      # Shell::Api should have a shell and not care about the mod_loader,
+      # currently it seems to violate Demeter. The shell should dispatch to the
+      # mod_loader only as an implementation detail. Otherwise this is harder to
+      # test.
+      @mod_loader.send name, @shell, *args, &block
+    end
+  end
+
+  class FakeApi < Api
+
+    # Fake Override
+    def initialize
+      @cmd_executions = []
+      @cmd_execution_args = []
+    end
+    attr_reader :cmd_executions, :cmd_execution_args
+
+    def method_missing(name, *args, &block)
+      @cmd_executions.push name
+      @cmd_execution_args.push args
+    end
+  end
+
+end

data/lib/loom/shell/cmd_result.rb

@@ -0,0 +1,33 @@
+module Loom::Shell
+  class CmdResult
+    def initialize(command, stdout, stderr, exit_status, is_test, shell)
+      @command = command
+      @stdout = stdout
+      @stderr = stderr
+      @exit_status = exit_status
+      @is_test = is_test
+      @time = Time.now
+      @shell = shell
+    end
+
+    attr_reader :command, :stdout, :stderr, :exit_status, :time, :is_test
+
+    def success?
+      @exit_status == 0
+    end
+
+    def pipe(*cmd, fd: :stdout)
+      puts "stdout >>> " + @stdout.inspect
+      @shell.pipe [:"/bin/echo", "-e", @stdout], [*cmd]
+    end
+
+    def self.create_from_sshkit_command(cmd, is_test, shell)
+      CmdResult.new cmd.command,
+                        cmd.full_stdout,
+                        cmd.full_stderr,
+                        cmd.exit_status,
+                        is_test,
+                        shell
+    end
+  end
+end

data/lib/loom/shell/cmd_wrapper.rb

@@ -0,0 +1,164 @@
+require "shellwords"
+
+module Loom::Shell
+
+  class CmdWrapper
+
+    class << self
+      # Escapes a shell command.
+      # @param cmd [CmdWrapper|String]
+      # @return [String]
+      def escape(cmd)
+        if cmd.is_a? CmdWrapper
+          cmd.escape_cmd
+        else
+          Shellwords.escape(cmd)
+        end
+      end
+
+      # Wraps a command in another command. See `CmdWrapper.new'
+      # @param cmd_parts [CmdWrapper|String|Symbol]
+      # @param should_quote [Boolean]
+      def wrap_cmd(*cmd_parts, should_quote: false)
+        cmd_parts = cmd_parts.map do |parts|
+          if parts.respond_to? :cmd_parts
+            parts.cmd_parts
+          else
+            parts
+          end
+        end
+        CmdWrapper.new *cmd_parts.flatten, {
+          :should_quote => should_quote,
+          :is_wrapped => true
+        }
+      end
+    end
+
+    # @param cmd [Array<[#to_s]>] Command parts that will be shell escaped.
+    # @param :should_quote [Boolean] Whether wrapped commands should be quoted.
+    # @param :redirc [Array<CmdRedirect>] STDIO redirection for the command
+    # in quotes.
+    def initialize(*cmd, should_quote: false, is_wrapped: false, redirect: [])
+      @cmd_parts = cmd.flatten
+      @should_quote = should_quote
+      @is_wrapped = is_wrapped
+      @redirects = [redirect].flatten.compact
+      Loom.log.debug2(self) { "CmdWrapper.new {#{cmd}} => #{self.escape_cmd}" }
+    end
+
+    attr_reader :cmd_parts
+
+    # Shell escapes each part of `@cmd_parts` and joins them with spaces.
+    # @return [String]
+    def escape_cmd
+      escaped_cmd = escape_inner
+
+      cmd_with_redirects = [escaped_cmd].concat @redirects.map(&:to_s)
+      cmd_with_redirects.join " "
+    end
+    alias_method :to_s, :escape_cmd
+
+    # @param wrapped_cmd [String]
+    # @return [Array<#to_s>] The `wrapped_cmd` wrapped by `#escape_cmd`
+    def wrap(*wrapped_cmd)
+      wrapped_cmd =
+        CmdWrapper.wrap_cmd(*wrapped_cmd, should_quote: @should_quote)
+      CmdWrapper.new(self, wrapped_cmd)
+    end
+
+    private
+    def escape_inner
+      escaped_parts = escape_parts(@cmd_parts)
+
+      # Don't fuck with this unless you really want to fix it.
+      if @should_quote && @is_wrapped
+        double_escaped = escape_parts(escaped_parts).join " "
+
+        # Shellwords escapes spaces, but I'm wrapping this string in another set
+        # of quotes here, so it's unnecessary.
+        double_escaped.gsub!(/\\(\s)/, "\\1") while double_escaped.match(/\\\s/)
+
+        "\"#{double_escaped}\""
+      else
+        escaped_parts.join " "
+      end
+    end
+
+    # Maps each entry of #{cmd_parts} to the escaped form of itself, except if
+    # the part is frozen (like a Symbol)
+    # @param cmd_parts [Array<String|Symbol|CmdWrapper>]
+    # @return [Array<String|Symbol>]
+    def escape_parts(cmd_parts)
+      cmd_parts.map do |part|
+        part.cmd_parts rescue part
+      end.flatten
+
+      cmd_parts.map do |part|
+        unless part.frozen?
+          CmdWrapper.escape part
+        else
+          part
+        end
+      end
+    end
+  end
+
+  class CmdRedirect
+
+    class << self
+      def append_stdout(word)
+        CmdRedirect.new(word, mode: Mode::APPEND)
+      end
+    end
+
+    # See `man bash` under REDIRECTION
+    module Mode
+      INPUT = :input
+      OUTPUT = :output
+      APPEND = :append
+      OUTPUT_12 = :output_1_and_2
+      APPEND_12 = :append_1_and_2
+    end
+
+    def initialize(word, fd: nil, mode: Mode::OUTPUT)
+      @fd = fd
+      @word = word
+      @mode = mode
+    end
+
+    def to_s
+      case @mode
+      when Mode::INPUT
+        "%s<%s" % [@fd, @word]
+      when Mode::OUTPUT
+        "%s>%s" % [@fd, @word]
+      when Mode::APPEND
+        "%s>>%s" % [@fd, @word]
+      when Mode::OUTPUT_12
+        "&>%s" % [@word]
+      when Mode::APPEND_12
+        "&>>%s" % [@word]
+      else
+        raise "invalid shell redirection mode: #{@mode}"
+      end
+    end
+
+  end
+
+  class CmdPipeline
+    def initialize(piped_cmds)
+      @piped_cmds = piped_cmds
+    end
+
+    def to_s
+      @piped_cmds.map do |cmd|
+        if cmd.respond_to? :escape_cmd
+          cmd.escape_cmd
+        else
+          cmd
+        end
+      end.join " | "
+    end
+  end
+
+end

data/lib/loom/shell/core.rb

@@ -0,0 +1,226 @@
+require "forwardable"
+require "shellwords"
+require "sshkit"
+
+module Loom::Shell
+
+  class Core
+
+    def initialize(mod_loader, sshkit_backend, dry_run=false)
+      @dry_run = dry_run
+      @mod_loader = mod_loader
+      @sshkit_backend = sshkit_backend
+
+      @session = Session.new
+      @shell_api = Api.new self
+
+      @cmd_wrappers = []
+      @sudo_users = []
+
+      # TODO: @sudo_dirs is a smelly workaround for not having a better
+      # understanding of sudo security policies and inheriting environments.
+      @sudo_dirs = []
+    end
+
+    attr_reader :session, :shell_api, :mod_loader, :dry_run
+
+    def local
+      @local ||= LocalShell.new @mod_loader, @session, @dry_run
+    end
+
+    def test(*cmd, check: :exit_status, **cmd_opts)
+      # TODO: is_test smells like a hack. I can't rely on Command#is_success?
+      # here (returned from execute) because I'm overriding it with :is_test =>
+      # true. Fix Command#is_success? to not be a lie.. that is a lazy hack for
+      # result reporting (I think the fix & feature) is to define Command
+      # objects and declare style of reporting & error code handling it
+      # has. Commands can be defined to ignore errors and just return their
+      # results.
+      execute *cmd, :is_test => true, **cmd_opts
+
+      case check
+      when :exit_status
+        @session.last.exit_status == 0
+      when :stderr
+        @session.last.stderr.empty?
+      else
+        raise "unknown test check => #{check}"
+      end
+    end
+
+    def verify(*check)
+      raise VerifyError, check unless test *check
+    end
+
+    def verify_which(command)
+      verify :which, command
+    end
+
+    def wrap(*wrapper, first: false, should_quote: true, &block)
+      raise "missing block for +wrap+" unless block_given?
+
+      cmd_wrapper = CmdWrapper.new(*wrapper, should_quote: should_quote)
+
+      if first
+        @cmd_wrappers.unshift(cmd_wrapper)
+      else
+        @cmd_wrappers.push(cmd_wrapper)
+      end
+
+      begin
+        yield
+      ensure
+        first ? @cmd_wrappers.shift : @cmd_wrappers.pop
+      end
+    end
+
+    def sudo(user=nil, *sudo_cmd, &block)
+      user ||= :root
+      Loom.log.debug1(self) { "sudo => #{user} #{sudo_cmd} #{block}" }
+
+      is_new_sudoer = @sudo_users.last.to_sym != user.to_sym rescue true
+
+      @sudo_dirs.push(capture :pwd)
+      @sudo_users.push << user if is_new_sudoer
+
+      sudo_wrapper = [:sudo, "-u", user, "--", "/bin/sh", "-c"]
+      sudo_cmd.compact!
+      begin
+        wrap *sudo_wrapper, :should_quote => true do
+          execute *sudo_cmd unless sudo_cmd.empty?
+          yield if block_given?
+        end
+      ensure
+        @sudo_users.pop if is_new_sudoer
+        @sudo_dirs.pop
+      end
+    end
+
+    def cd(path, &block)
+      Loom.log.debug1(self) { "cd => #{path} #{block}" }
+
+      # TODO: this might creates problems with relative paths, e.g.
+      # loom.cd foo => cd ./foo
+      # loom.sudo user => cd ./foo; sudo user
+      @sudo_dirs.push path
+      begin
+        @sshkit_backend.within path, &block
+      ensure
+        @sudo_dirs.pop
+      end
+    end
+
+    def capture(*cmd_parts)
+      if @dry_run
+        # TODO: I'm not sure what to do about this.
+        Loom.log.warn "`capture` during dry run won't do what you want"
+      end
+      execute *cmd_parts
+      @session.last.stdout.strip
+    end
+
+    def pipe(*cmds)
+      cmd = CmdWrapper.pipe *cmds.map { |*cmd| CmdWrapper.new *cmd }
+      execute cmd
+    end
+
+    def execute(*cmd_parts, is_test: false, **cmd_opts)
+      cmd_parts.compact!
+      raise "empty command passed to execute" if cmd_parts.empty?
+
+      result = if @dry_run
+                 wrap :printf, :first => true do
+                   cmd_result = execute_internal *cmd_parts, **cmd_opts
+                   Loom.log.info do
+                     "\t%s" % prompt_fmt(cmd_result.full_stdout.strip)
+                   end
+                   cmd_result
+                 end
+               else
+                 execute_internal *cmd_parts, **cmd_opts
+               end
+      @session << CmdResult.create_from_sshkit_command(result, is_test, self)
+
+      Loom.log.debug @session.last.stdout unless @session.last.stdout.empty?
+      Loom.log.debug @session.last.stderr unless @session.last.stderr.empty?
+      @session.last
+    end
+    alias_method :exec, :execute
+
+    protected
+    def prompt_label
+      # TODO: get the real hostname.
+      "remote"
+    end
+
+    private
+    def prompt_fmt(*cmd_parts)
+      output = Shellwords.join(cmd_parts).gsub /\\/, ''
+      "[%s]:$ %s" % [prompt_label, output]
+    end
+
+    def execute_internal(*cmd_parts, piped_cmds: [])
+      primary_cmd = create_command *cmd_parts
+      piped_cmds = piped_cmds.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
+      # echo indicates that just 1 big string was passed in and we can't really
+      # isolate the execuatable part of the command. This might be fine, but
+      # it's better to be strict now and relax this later if it's OK.
+      if cmd.match /^[\w\-\[]+\\/i
+        raise "use array parts for command escaping => #{cmd}"
+      end
+
+      Loom.log.debug1(self) { "executing => #{cmd}" }
+
+      # This is a big hack to get access to the SSHKit command
+      # object and avoid the automatic errors thrown on non-zero
+      # error codes
+      @sshkit_backend.send(
+        :create_command_and_execute,
+        cmd,
+        :raise_on_non_zero_exit => false)
+    end
+
+    # Here be dragons.
+    # @return [String|Loom::Shell::CmdWrapper]
+    def create_command(*cmd_parts)
+      cmd_wrapper = if cmd_parts.is_a? CmdWrapper
+                      cmd_parts
+                    else
+                      Loom.log.debug3(self) { "new cmd from parts => #{cmd_parts}" }
+                      CmdWrapper.new *cmd_parts
+                    end
+
+      # Useful for sudo, dry runs, timing a set of commands, or
+      # timeout... anytime you want to prefix a group of commands.  Reverses the
+      # array to wrap from inner most call to `#{wrap}` to outer most.
+      cmd = @cmd_wrappers.reverse.reduce(cmd_wrapper) do |cmd_or_wrapper, wrapper|
+        Loom.log.debug3(self) { "wrapping cmds => #{wrapper} => #{cmd_or_wrapper}"}
+        wrapper.wrap cmd_or_wrapper
+      end
+
+      unless @sudo_dirs.empty? || @dry_run
+        cmd = "cd #{@sudo_dirs.last}; " << cmd.to_s
+      end
+      cmd
+    end
+
+    # A shell object restricted to localhost.
+    class LocalShell < Core
+      def initialize(mod_loader, session, dry_run)
+        super mod_loader, SSHKit::Backend::Local.new, dry_run
+        @session = session
+      end
+
+      def local
+        raise 'already in a local shell'
+      end
+
+      def prompt_label
+        "local"
+      end
+    end
+  end
+end