minestrone 0.0.1

data/lib/minestrone/configuration/servers.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'minestrone/server_definition'
+require 'minestrone/errors'
+
+module Minestrone
+  class Configuration
+    module Servers
+      def initialize_servers #:nodoc:
+        @server = nil
+      end
+
+      # Define the server. The host may include user and port information, or
+      # those may be supplied as options:
+      #
+      #   server "www@example.com"
+      #   server "app.example.com", :user => "deploy"
+
+      def server(host, options = {})
+        raise ArgumentError, "server accepts one host and an optional options hash" unless options.is_a?(Hash)
+        raise ArgumentError, "you may only define one server" if @server
+
+        @server = server_definition_from(host, options)
+      end
+
+      # Returns the configured server. If the SERVER environment variable
+      # is set, it replaces the configured host name while preserving configured
+      # connection options such as user, port, and SSH options.
+
+      def resolved_server
+        if env_key = server_override_env
+          host = ENV[env_key].strip
+          raise ArgumentError, "#{env_key} must name a single server" if host.empty? || host.include?(',')
+
+          options = @server ? connection_options_for(@server) : {}
+          server_definition_from(host, options)
+        else
+          @server or raise Minestrone::NoMatchingServersError, "no server configured"
+        end
+      end
+
+
+      protected
+
+      def server_override_env
+        if ENV.key?('SERVER')
+          'SERVER'
+        elsif ENV.key?('HOSTS')
+          'HOSTS'
+        end
+      end
+
+      def server_definition_from(host, options = {})
+        raise ArgumentError, "server must be defined as a string" unless host.is_a?(String)
+
+        host = host.strip
+        raise ArgumentError, "server value must be a single hostname" if host.empty? || host.include?(',')
+
+        ServerDefinition.new(host, options)
+      end
+
+      def connection_options_for(server)
+        options = server.options.dup
+        options[:user] = server.user if server.user
+        options[:port] = server.port if server.port
+        options
+      end
+    end
+  end
+end

data/lib/minestrone/configuration/variables.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Minestrone
+  class Configuration
+    module Variables
+      def self.included(base) #:nodoc:
+        %w(respond_to? method_missing).each do |m|
+          base_name = m[/^\w+/]
+          punct     = m[/\W+$/]
+          base.send :alias_method, "#{base_name}_without_variables#{punct}", m
+          base.send :alias_method, m, "#{base_name}_with_variables#{punct}"
+        end
+      end
+
+      # The hash of variables that have been defined in this configuration instance.
+      attr_reader :variables
+
+      # Set a variable to the given value.
+      def set(variable, *args, &block)
+        if variable.to_s !~ /^[_a-z]/
+          raise ArgumentError, "invalid variable `#{variable}' (variables must begin with an underscore, or a lower-case letter)"
+        end
+
+        if !block_given? && args.empty? || block_given? && !args.empty?
+          raise ArgumentError, "you must specify exactly one of either a value or a block"
+        end
+
+        if args.length > 1
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+
+        value = args.empty? ? block : args.first
+        sym = variable.to_sym
+        @variables[sym] = value
+      end
+
+      alias :[]= :set
+
+      # Removes any trace of the given variable.
+      def unset(variable)
+        sym = variable.to_sym
+        @original_procs.delete(sym)
+        @variables.delete(sym)
+      end
+
+      # Returns true if the variable has been defined, and false otherwise.
+      def exists?(variable)
+        @variables.key?(variable.to_sym)
+      end
+
+      # If the variable was originally a proc value, it will be reset to it's
+      # original proc value. Otherwise, this method does nothing. It returns
+      # true if the variable was actually reset.
+      def reset!(variable)
+        sym = variable.to_sym
+
+        if @original_procs.key?(sym)
+          @variables[sym] = @original_procs.delete(sym)
+          true
+        else
+          false
+        end
+      end
+
+      # Access a named variable. If the value of the variable responds_to? :call,
+      # #call will be invoked (without parameters) and the return value cached
+      # and returned.
+
+      def fetch(variable, *args)
+        if !args.empty? && block_given?
+          raise ArgumentError, "you must specify either a default value or a block, but not both"
+        end
+
+        sym = variable.to_sym
+
+        if !@variables.key?(sym)
+          return args.first unless args.empty?
+          return yield(variable) if block_given?
+          raise IndexError, "`#{variable}' not found"
+        end
+
+        if @variables[sym].respond_to?(:call)
+          @original_procs[sym] = @variables[sym]
+          @variables[sym] = @variables[sym].call
+        end
+
+        @variables[sym]
+      end
+
+      def [](variable)
+        fetch(variable, nil)
+      end
+
+      def initialize_variables #:nodoc:
+        @variables = {}
+        @original_procs = {}
+
+        set :ssh_options, {}
+        set :logger, logger
+      end
+
+      def respond_to_with_variables?(sym, include_priv = false) #:nodoc:
+        @variables.has_key?(sym.to_sym) || respond_to_without_variables?(sym, include_priv)
+      end
+
+      def method_missing_with_variables(sym, *args, &block) #:nodoc:
+        if args.length == 0 && block.nil? && @variables.has_key?(sym)
+          self[sym]
+        else
+          method_missing_without_variables(sym, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/minestrone/configuration.rb

@@ -0,0 +1,69 @@
+require 'minestrone/logger'
+
+require 'minestrone/configuration/alias_task'
+require 'minestrone/configuration/callbacks'
+require 'minestrone/configuration/connections'
+require 'minestrone/configuration/execution'
+require 'minestrone/configuration/loading'
+require 'minestrone/configuration/log_formatters'
+require 'minestrone/configuration/namespaces'
+require 'minestrone/configuration/servers'
+require 'minestrone/configuration/variables'
+
+require 'minestrone/configuration/actions/file_transfer'
+require 'minestrone/configuration/actions/inspect'
+require 'minestrone/configuration/actions/invocation'
+
+module Minestrone
+
+  #
+  # Represents a specific Minestrone configuration. A Configuration instance
+  # may be used to load multiple recipe files, define and describe tasks,
+  # define a server, and set configuration variables.
+  #
+
+  class Configuration
+
+    # The logger instance defined for this configuration.
+    attr_accessor :debug, :logger, :dry_run
+
+    def initialize(options = {}) #:nodoc:
+      @debug = false
+      @dry_run = false
+      @logger = Logger.new(options)
+
+      initialize_connections
+      initialize_execution
+      initialize_loading
+      initialize_namespaces
+      initialize_servers
+      initialize_variables
+      initialize_invocation
+      initialize_callbacks
+    end
+
+    # make the DSL easier to read when using lazy evaluation via lambdas
+    alias defer lambda
+
+    # The includes must come at the bottom, since they may redefine methods
+    # defined in the base class.
+    include AliasTask, Connections, Execution, Loading, LogFormatters, Namespaces, Servers, Variables
+
+    # Mix in the actions
+    include Actions::FileTransfer, Actions::Inspect, Actions::Invocation
+
+    # Must mix last, because it hooks into previously defined methods
+    include Callbacks
+
+    (self.instance_methods & Kernel.methods).select do |name|
+      # Select the instance methods owned by the Configuration class.
+      self.instance_method(name).owner.to_s.start_with?("Minestrone::Configuration")
+    end.select do |name|
+      # Of those, select methods that are being shadowed by the Kernel module in the Namespace class.
+      Namespaces::Namespace.method_defined?(name) && Namespaces::Namespace.instance_method(name).owner == Kernel
+    end.each do |name|
+      # Undefine the shadowed methods, since we want Namespace objects to defer handling to the Configuration object.
+      Namespaces::Namespace.send(:undef_method, name)
+    end
+  end
+end

data/lib/minestrone/errors.rb

@@ -0,0 +1,17 @@
+module Minestrone
+  Error = Class.new(RuntimeError)
+
+  CaptureError            = Class.new(Minestrone::Error)
+  NoSuchTaskError         = Class.new(Minestrone::Error)
+  NoMatchingServersError  = Class.new(Minestrone::Error)
+
+  class RemoteError < Error
+    attr_accessor :host
+  end
+
+  ConnectionError     = Class.new(Minestrone::RemoteError)
+  TransferError       = Class.new(Minestrone::RemoteError)
+  CommandError        = Class.new(Minestrone::RemoteError)
+
+  LocalArgumentError  = Class.new(Minestrone::Error)
+end

data/lib/minestrone/ext/string.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class String
+  def compact
+    self.gsub(/\s+/, ' ')
+  end
+end

data/lib/minestrone/extensions.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Minestrone
+  class ExtensionProxy #:nodoc:
+    def initialize(config, mod)
+      @config = config
+      extend(mod)
+    end
+
+    def method_missing(sym, *args, &block)
+      @config.send(sym, *args, &block)
+    end
+  end
+
+  # Holds the set of registered plugins, keyed by name (where the name is a symbol).
+  EXTENSIONS = {}
+
+  # Register the given module as a plugin with the given name. It will henceforth
+  # be available via a proxy object on Configuration instances, accessible by
+  # a method with the given name.
+
+  def self.plugin(name, mod)
+    name = name.to_sym
+    return false if EXTENSIONS.has_key?(name)
+
+    methods = Minestrone::Configuration.public_instance_methods +
+      Minestrone::Configuration.protected_instance_methods +
+      Minestrone::Configuration.private_instance_methods
+
+    if methods.any? { |m| m.to_sym == name }
+      raise Minestrone::Error, "registering a plugin named `#{name}' would shadow a method on Minestrone::Configuration with the same name"
+    end
+
+    Minestrone::Configuration.class_eval <<-STR, __FILE__, __LINE__+1
+      def #{name}
+        @__#{name}_proxy ||= Minestrone::ExtensionProxy.new(self, Minestrone::EXTENSIONS[#{name.inspect}])
+      end
+    STR
+
+    EXTENSIONS[name] = mod
+    return true
+  end
+
+  # Unregister the plugin with the given name.
+
+  def self.remove_plugin(name)
+    name = name.to_sym
+
+    if EXTENSIONS.delete(name)
+      Minestrone::Configuration.send(:remove_method, name)
+      return true
+    end
+
+    return false
+  end
+end

data/lib/minestrone/logger.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Minestrone
+  class Logger #:nodoc:
+    attr_accessor :level, :device, :disable_formatters
+
+    IMPORTANT = 0
+    INFO      = 1
+    DEBUG     = 2
+    TRACE     = 3
+
+    MAX_LEVEL = 3
+
+    COLORS = {
+      :none     => "0",
+      :black    => "30",
+      :red      => "31",
+      :green    => "32",
+      :yellow   => "33",
+      :blue     => "34",
+      :magenta  => "35",
+      :cyan     => "36",
+      :white    => "37"
+    }
+
+    STYLES = {
+      :bright     => 1,
+      :dim        => 2,
+      :underscore => 4,
+      :blink      => 5,
+      :reverse    => 7,
+      :hidden     => 8
+    }
+
+    @default_formatters = [
+      # TRACE
+      { :match => /command finished/,          :color => :white,   :style => :dim, :level => 3, :priority => -10 },
+      { :match => /executing locally/,         :color => :yellow,  :level => 3, :priority => -20 },
+
+      # DEBUG
+      { :match => /executing `.*/,             :color => :green,   :level => 2, :priority => -10, :timestamp => true },
+      { :match => /.*/,                        :color => :yellow,  :level => 2, :priority => -30 },
+
+      # INFO
+      { :match => /.*out\] (fatal:|ERROR:).*/, :color => :red,     :level => 1, :priority => -10 },
+      { :match => /Permission denied/,         :color => :red,     :level => 1, :priority => -20 },
+      { :match => /sh: .+: command not found/, :color => :magenta, :level => 1, :priority => -30 },
+
+      # IMPORTANT
+      { :match => /^err ::/,                   :color => :red,     :level => 0, :priority => -10 },
+      { :match => /.*/,                        :color => :blue,    :level => 0, :priority => -20 }
+    ]
+
+    @formatters = @default_formatters
+
+    class << self
+      def default_formatters
+        @default_formatters
+      end
+
+      def default_formatters=(defaults = nil)
+        @default_formatters = [defaults].flatten
+
+        # reset the formatters
+        @formatters = @default_formatters
+        @sorted_formatters = nil
+      end
+
+      def add_formatter(options) #:nodoc:
+        @formatters.push(options)
+        @sorted_formatters = nil
+      end
+
+      def sorted_formatters
+        # Sort matchers in reverse order so we can break if we found a match.
+        @sorted_formatters ||= @formatters.sort_by { |i| -(i[:priority] || i[:prio] || 0) }
+      end
+    end
+
+    def initialize(options = {})
+      output = options[:output] || $stderr
+
+      if output.respond_to?(:puts)
+        @device = output
+      else
+        @device = File.open(output.to_str, "a")
+        @needs_close = true
+      end
+
+      @options = options
+      @level = options[:level] || 0
+      @disable_formatters = options[:disable_formatters]
+    end
+
+    def close
+      device.close if @needs_close
+    end
+
+    def log(level, message, line_prefix = nil)
+      if level <= self.level
+
+        # Only format output if device is a TTY and formatters are not disabled
+        if device.tty? && !@disable_formatters
+          color = :none
+          style = nil
+
+          Logger.sorted_formatters.each do |formatter|
+            if (formatter[:level] == level || formatter[:level].nil?)
+              if message =~ formatter[:match] || formatter[:match] =~ line_prefix.to_s
+                color = formatter[:color] if formatter[:color]
+                style = formatter[:style] || formatter[:attribute] # (support original cap colors)
+                message.gsub!(formatter[:match], formatter[:replace]) if formatter[:replace]
+                message = formatter[:prepend] + message unless formatter[:prepend].nil?
+                message = message + formatter[:append] unless formatter[:append].nil?
+                message = Time.now.strftime('%Y-%m-%d %T') + ' ' + message if formatter[:timestamp]
+                break unless formatter[:replace]
+              end
+            end
+          end
+
+          if color == :hide
+            # Don't do anything if color is set to :hide
+            return false
+          end
+
+          term_color = COLORS[color]
+          term_style = STYLES[style]
+
+          # Don't format message if no color or style
+          unless color == :none and style.nil?
+            unless line_prefix.nil?
+              line_prefix = format(line_prefix, term_color, term_style, nil)
+            end
+            message = format(message, term_color, term_style)
+          end
+        end
+
+        indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
+
+        message.lines.each do |line|
+          if line_prefix
+            device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
+          else
+            device.puts "#{indent} #{line.strip}\n"
+          end
+        end
+      end
+    end
+
+    def important(message, line_prefix = nil)
+      log(IMPORTANT, message, line_prefix)
+    end
+
+    def info(message, line_prefix = nil)
+      log(INFO, message, line_prefix)
+    end
+
+    def debug(message, line_prefix = nil)
+      log(DEBUG, message, line_prefix)
+    end
+
+    def trace(message, line_prefix = nil)
+      log(TRACE, message, line_prefix)
+    end
+
+    def format(message, color, style, nl = "\n")
+      style = "#{style};" if style
+      "\e[#{style}#{color}m" + message.to_s.strip + "\e[0m#{nl}"
+    end
+  end
+end

data/lib/minestrone/processable.rb

@@ -0,0 +1,50 @@
+module Minestrone
+  module Processable
+    module SessionAssociation
+      def self.on(exception, session)
+        unless exception.respond_to?(:session)
+          exception.extend(self)
+          exception.session = session
+        end
+
+        return exception
+      end
+
+      attr_accessor :session
+    end
+
+    def process_iteration(wait = nil, &block)
+      ensure_session { |session| session.preprocess }
+
+      return false if block && !block.call(self)
+
+      readers = session.listeners.keys.reject { |io| io.closed? }
+      writers = readers.select { |io| io.respond_to?(:pending_write?) && io.pending_write? }
+
+      if readers.any? || writers.any?
+        readers, writers, = IO.select(readers, writers, nil, wait)
+      else
+        return false
+      end
+
+      if readers
+        ensure_session do |session|
+          ios = session.listeners.keys
+          session.postprocess(ios & readers, ios & writers)
+        end
+      end
+
+      true
+    end
+
+    def ensure_session
+      begin
+        yield session
+      rescue Exception => error
+        raise SessionAssociation.on(error, session)
+      end
+
+      session
+    end
+  end
+end