minestrone 0.0.1

data/lib/minestrone/configuration/connections.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'minestrone/ssh'
+require 'minestrone/errors'
+
+module Minestrone
+  class Configuration
+    module Connections
+      attr_accessor :session
+
+      def initialize_connections #:nodoc:
+        @session = nil
+        @failed = false
+      end
+
+      # Used to force a connection to be made to the current task's server.
+      # Connections are normally made lazily in Minestrone--you can use this
+      # to force them open before performing some operation that might be
+      # time-sensitive.
+
+      def connect!
+        establish_connection_to_server
+      end
+
+      # Ensures that there is an active session for the server.
+
+      def establish_connection_to_server
+        return if @session
+
+        server = resolved_server
+        @session = SSH.connect(server, self)
+      rescue Exception => err
+        raise err unless server
+
+        error = ConnectionError.new("connection failed for: #{server} (#{err.class}: #{err.message})")
+        error.host = server
+        raise error
+      end
+
+      # Determines the configured server, establishes a connection to it, and
+      # yields to the command and transfer layers.
+
+      def execute_on_server
+        raise ArgumentError, "expected a block" unless block_given?
+
+        task = current_task
+        return if task && task.continue_on_error? && @failed
+
+        begin
+          establish_connection_to_server
+        rescue ConnectionError => error
+          raise error unless task && task.continue_on_error?
+          @failed = true
+          return
+        end
+
+        begin
+          yield
+        rescue RemoteError => error
+          raise error unless task && task.continue_on_error?
+          @failed = true
+        end
+      end
+    end
+  end
+end

data/lib/minestrone/configuration/execution.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'minestrone/errors'
+
+module Minestrone
+  class Configuration
+    module Execution
+      # A struct for representing a single instance of an invoked task.
+      TaskCallFrame = Struct.new(:task, :rollback)
+
+      def initialize_execution #:nodoc:
+        @task_call_frames = []
+        @rollback_requests = nil
+      end
+
+      # Returns true if there is a transaction currently active.
+      def transaction?
+        !rollback_requests.nil?
+      end
+
+      # The call stack of the tasks. The currently executing task may inspect
+      # this to see who its caller was. The current task is always the last
+      # element of this stack.
+      def task_call_frames
+        @task_call_frames
+      end
+
+      # The stack of tasks that have registered rollback handlers within the
+      # current transaction. If this is nil, then there is no transaction
+      # that is currently active.
+      attr_accessor :rollback_requests
+
+      # Invoke a set of tasks in a transaction. If any task fails (raises an
+      # exception), all tasks executed within the transaction are inspected to
+      # see if they have an associated on_rollback hook, and if so, that hook
+      # is called.
+
+      def transaction
+        raise ArgumentError, "expected a block" unless block_given?
+        raise ScriptError, "transaction must be called from within a task" if task_call_frames.empty?
+
+        return yield if transaction?
+
+        logger.info "transaction: start"
+
+        begin
+          self.rollback_requests = []
+          yield
+          logger.info "transaction: commit"
+        rescue Object
+          rollback!
+          raise
+        ensure
+          self.rollback_requests = nil
+        end
+      end
+
+      # Specifies an on_rollback hook for the currently executing task. If this
+      # or any subsequent task then fails, and a transaction is active, this
+      # hook will be executed.
+
+      def on_rollback(&block)
+        if transaction?
+          # don't note a new rollback request if one has already been set
+          rollback_requests << task_call_frames.last unless task_call_frames.last.rollback
+          task_call_frames.last.rollback = block
+        end
+      end
+
+      # Returns the TaskDefinition object for the currently executing task.
+      # It returns nil if there is no task being executed.
+
+      def current_task
+        return nil if task_call_frames.empty?
+        task_call_frames.last.task
+      end
+
+      # Executes the task with the given name, without invoking any associated callbacks.
+
+      def execute_task(task)
+        logger.debug "executing `#{task.fully_qualified_name}'"
+        push_task_call_frame(task)
+        invoke_task_directly(task)
+      ensure
+        pop_task_call_frame
+      end
+
+      # Attempts to locate the task at the given fully-qualified path, and
+      # execute it. If no such task exists, a Minestrone::NoSuchTaskError will
+      # be raised.
+
+      def find_and_execute_task(path, hooks = {})
+        task = find_task(path) or raise NoSuchTaskError, "the task `#{path}' does not exist"
+
+        trigger(hooks[:before], task) if hooks[:before]
+        result = execute_task(task)
+        trigger(hooks[:after], task) if hooks[:after]
+
+        result
+      end
+
+
+      protected
+
+      def rollback!
+        return if rollback_requests.nil?
+
+        # throw the task back on the stack so that roles are properly
+        # interpreted in the scope of the task in question.
+
+        rollback_requests.reverse.each do |frame|
+          begin
+            push_task_call_frame(frame.task)
+            logger.important "rolling back", frame.task.fully_qualified_name
+            frame.rollback.call
+          rescue Object => e
+            logger.info "exception while rolling back: #{e.class}, #{e.message}", frame.task.fully_qualified_name
+          ensure
+            pop_task_call_frame
+          end
+        end
+      end
+
+      def push_task_call_frame(task)
+        frame = TaskCallFrame.new(task)
+        task_call_frames.push frame
+      end
+
+      def pop_task_call_frame
+        task_call_frames.pop
+      end
+
+      # Invokes the task's body directly, without setting up the call frame.
+      def invoke_task_directly(task)
+        task.namespace.instance_eval(&task.body)
+      end
+    end
+  end
+end

data/lib/minestrone/configuration/loading.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module Minestrone
+  class Configuration
+    module Loading
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        # Used by third-party task bundles to identify the minestrone
+        # configuration that is loading them. Its return value is not reliable
+        # in other contexts. If +require_config+ is not false, an exception
+        # will be raised if the current configuration is not set.
+
+        def instance(require_config = false)
+          config = @instance
+
+          if require_config && config.nil?
+            raise LoadError, "Please require this file from within a Minestrone recipe"
+          end
+
+          config
+        end
+
+        # Used internally by Minestrone to specify the current configuration
+        # before loading a third-party task bundle.
+
+        def instance=(config)
+          @instance = config
+        end
+
+        # Used internally by Minestrone to track which recipes have been loaded
+        # via require, so that they may be successfully reloaded when require
+        # is called again.
+
+        def recipes_per_feature
+          @recipes_per_feature ||= {}
+        end
+
+        # Used internally to specify the current file being required, so that
+        # any recipes loaded by that file can be remembered. This allows
+        # recipes loaded via require to be correctly reloaded in different
+        # Configuration instances in the same Ruby instance.
+
+        attr_accessor :current_feature
+      end
+
+      # The load paths used for locating recipe files.
+      attr_reader :load_paths
+
+      def initialize_loading #:nodoc:
+        @load_paths = ['.', File.expand_path("../recipes", __dir__)]
+        @loaded_features = []
+      end
+
+      # Load a configuration file or string into this configuration.
+      #
+      # Usage:
+      #
+      #   load("recipe"):
+      #     Look for and load the contents of 'recipe.rb' into this
+      #     configuration.
+      #
+      #   load(:file => "recipe"):
+      #     same as above
+      #
+      #   load(:string => "set :scm, :git"):
+      #     Load the given string as a configuration specification.
+      #
+      #   load { ... }
+      #     Load the block in the context of the configuration.
+
+      def load(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+
+        if block
+          raise ArgumentError, "loading a block requires 0 arguments" unless options.empty? && args.empty?
+          load(:proc => block)
+
+        elsif args.any?
+          args.each { |arg| load options.merge(:file => arg) }
+
+        elsif options[:file]
+          load_from_file(options[:file], options[:name])
+
+        elsif options[:string]
+          remember_load(options) unless options[:reloading]
+          instance_eval(options[:string], options[:name] || "<eval>")
+
+        elsif options[:proc]
+          remember_load(options) unless options[:reloading]
+          instance_eval(&options[:proc])
+
+        else
+          raise ArgumentError, "don't know how to load #{options.inspect}"
+        end
+      end
+
+      # Require another file. This is identical to the standard require method,
+      # with the exception that it sets the receiver as the "current" configuration
+      # so that third-party task bundles can include themselves relative to
+      # that configuration.
+      #
+      # This is a bit more complicated than an initial review would seem to
+      # necessitate, but the use case that complicates things is this: An
+      # advanced user wants to embed minestrone, and needs to instantiate
+      # more than one minestrone configuration at a time. They also want each
+      # configuration to require a third-party minestrone extension. Using a
+      # naive require implementation, this would allow the first configuration
+      # to successfully load the third-party extension, but the require would
+      # fail for the second configuration because the extension has already
+      # been loaded.
+      #
+      # To work around this, we do a few things:
+      #
+      # 1. Each time a 'require' is invoked inside of a minestrone recipe,
+      #    we remember the arguments (see "current_feature").
+      # 2. Each time a 'load' is invoked inside of a minestrone recipe, and
+      #    "current_feature" is not nil (meaning we are inside of a pending
+      #    require) we remember the options (see "remember_load" and
+      #    "recipes_per_feature").
+      # 3. Each time a 'require' is invoked inside of a minestrone recipe,
+      #    we check to see if this particular configuration has ever seen these
+      #    arguments to require (see @loaded_features), and if not, we proceed
+      #    as if the file had never been required. If the superclass' require
+      #    returns false (meaning, potentially, that the file has already been
+      #    required), then we look in the recipes_per_feature collection and
+      #    load any remembered recipes from there.
+      #
+      # It's kind of a bear, but it works, and works transparently. Note that
+      # a simpler implementation would just muck with $", allowing files to be
+      # required multiple times, but that will cause warnings (and possibly
+      # errors) if the file to be required contains constant definitions and
+      # such, alongside (or instead of) minestrone recipe definitions.
+
+      def require(*args)
+        # look to see if this specific configuration instance has ever seen
+        # these arguments to require before
+        if @loaded_features.include?(args)
+          return false
+        end
+
+        @loaded_features << args
+
+        begin
+          original_instance, self.class.instance = self.class.instance, self
+          original_feature, self.class.current_feature = self.class.current_feature, args
+
+          result = super
+
+          if !result # file has been required previously, load up the remembered recipes
+            list = self.class.recipes_per_feature[args] || []
+            list.each { |options| load(options.merge(:reloading => true)) }
+          end
+
+          return result
+        ensure
+          # restore the original, so that require's can be nested
+          self.class.instance = original_instance
+          self.class.current_feature = original_feature
+        end
+      end
+
+      def file_in_load_path?(file)
+        begin
+          !!find_file_in_load_path(file)
+        rescue LoadError
+          false
+        end
+      end
+
+      private
+
+      # Load a recipe from the named file. If +name+ is given, the file will
+      # be reported using that name.
+
+      def load_from_file(file, name = nil)
+        file = find_file_in_load_path(file) unless File.file?(file)
+        load :string => File.read(file), :name => name || file
+      end
+
+      def find_file_in_load_path(file)
+        load_paths.each do |path|
+          ['', '.rb'].each do |ext|
+            name = File.join(path, "#{file}#{ext}")
+            return name if File.file?(name)
+          end
+        end
+
+        raise LoadError, "no such file to load -- #{file}"
+      end
+
+      # If a file is being required, the options associated with loading a
+      # recipe are remembered in the recipes_per_feature archive under the
+      # name of the file currently being required.
+
+      def remember_load(options)
+        if self.class.current_feature
+          list = (self.class.recipes_per_feature[self.class.current_feature] ||= [])
+          list << options
+        end
+      end
+    end
+  end
+end

data/lib/minestrone/configuration/log_formatters.rb

@@ -0,0 +1,75 @@
+# Add custom log formatters
+#
+# Passing a hash or a array of hashes with custom log formatters.
+#
+# Add the following to your deploy.rb or in your ~/.caprc
+#
+# == Example:
+#
+#   minestrone_log_formatters = [
+#     { :match => /command finished/,       :color => :hide,      :priority => 10, :prepend => "$$$" },
+#     { :match => /executing command/,      :color => :blue,      :priority => 10, :style => :underscore, :timestamp => true },
+#     { :match => /^transaction: commit$/,  :color => :magenta,   :priority => 10, :style => :blink },
+#     { :match => /git/,                    :color => :white,     :priority => 20, :style => :reverse }
+#   ]
+#
+#   log_formatter minestrone_log_formatters
+#
+# You can call log_formatter multiple times, with either a hash or an array of hashes.
+#
+# == Colors:
+#
+# :color can have the following values:
+#
+# * :hide  (hides the row completely)
+# * :none
+# * :black
+# * :red
+# * :green
+# * :yellow
+# * :blue
+# * :magenta
+# * :cyan
+# * :white
+#
+# == Styles:
+#
+# :style can have the following values:
+#
+# * :bright
+# * :dim
+# * :underscore
+# * :blink
+# * :reverse
+# * :hidden
+#
+#
+#  == Text alterations
+#
+# :prepend gives static text to be prepended to the output
+# :replace replaces the matched text in the output
+# :timestamp adds the current time before the output
+
+module Minestrone
+  class Configuration
+    module LogFormatters
+      def log_formatter(options)
+        if options.class == Array
+          options.each do |option|
+            Minestrone::Logger.add_formatter(option)
+          end
+        else
+          Minestrone::Logger.add_formatter(options)
+        end
+      end
+
+      def default_log_formatters(formatters)
+        default_formatters = [*formatters]
+      end
+
+      def disable_log_formatters
+        @logger.disable_formatters = true
+      end
+    end
+  end
+end

data/lib/minestrone/configuration/namespaces.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'minestrone/configuration/alias_task'
+require 'minestrone/task_definition'
+
+module Minestrone
+  class Configuration
+    module Namespaces
+      DEFAULT_TASK = :default
+
+      # The name of this namespace. Defaults to +nil+ for the top-level
+      # namespace.
+      attr_reader :name
+
+      # The parent namespace of this namespace. Returns +nil+ for the top-level
+      # namespace.
+      attr_reader :parent
+
+      # The hash of tasks defined for this namespace.
+      attr_reader :tasks
+
+      # The hash of namespaces defined for this namespace.
+      attr_reader :namespaces
+
+      def initialize_namespaces(name = nil, parent = nil) #:nodoc:
+        @name = name
+        @parent = parent
+        @tasks = {}
+        @namespaces = {}
+      end
+
+      # Returns the top-level namespace (the one with no parent).
+      def top
+        parent ? parent.top : self
+      end
+
+      # Returns the fully-qualified name of this namespace, or nil if the
+      # namespace is at the top-level.
+      def fully_qualified_name
+        if name
+          [parent.fully_qualified_name, name].compact.join(':')
+        else
+          nil
+        end
+      end
+
+      # Describe the next task to be defined. The given text will be attached to
+      # the next task that is defined and used as its description.
+      def desc(text)
+        @next_description = text
+      end
+
+      # Returns the value set by the last, pending "desc" call. If +reset+ is
+      # not false, the value will be reset immediately afterwards.
+      def next_description(reset = false)
+        @next_description
+      ensure
+        @next_description = nil if reset
+      end
+
+      # Open a namespace in which to define new tasks. If the namespace was
+      # defined previously, it will be reopened, otherwise a new namespace
+      # will be created for the given name.
+      def namespace(name, &block)
+        name = name.to_sym
+        raise ArgumentError, "expected a block" unless block_given?
+
+        namespace_already_defined = namespaces.key?(name)
+
+        if all_methods.any? { |m| m.to_sym == name } && !namespace_already_defined
+          thing = tasks.key?(name) ? "task" : "method"
+          raise ArgumentError, "defining a namespace named `#{name}' would shadow an existing #{thing} with that name"
+        end
+
+        namespaces[name] ||= Namespace.new(name, self)
+        namespaces[name].instance_eval(&block)
+
+        # make sure any open description gets terminated
+        namespaces[name].desc(nil)
+
+        if !namespace_already_defined
+          metaclass = class << self; self; end
+          metaclass.send(:define_method, name) { namespaces[name] }
+        end
+      end
+
+      # Describe a new task. If a description is active (see #desc), it is added
+      # to the options under the <tt>:desc</tt> key. The new task is added to
+      # the namespace.
+      def task(name, options = {}, &block)
+        name = name.to_sym
+        raise ArgumentError, "expected a block" unless block_given?
+
+        task_already_defined = tasks.key?(name)
+
+        if all_methods.any? { |m| m.to_sym == name } && !task_already_defined
+          thing = namespaces.key?(name) ? "namespace" : "method"
+          raise ArgumentError, "defining a task named `#{name}' would shadow an existing #{thing} with that name"
+        end
+
+        task = TaskDefinition.new(name, self, { :desc => next_description(:reset) }.merge(options), &block)
+
+        define_task(task)
+      end
+
+      def define_task(task)
+        tasks[task.name] = task
+
+        metaclass = class << self; self; end
+        metaclass.send(:define_method, task.name) { execute_task(tasks[task.name]) }
+      end
+
+      # Find the task with the given name, where name is the fully-qualified
+      # name of the task. This will search into the namespaces and return
+      # the referenced task, or nil if no such task can be found. If the name
+      # refers to a namespace, the task in that namespace named "default"
+      # will be returned instead, if one exists.
+
+      def find_task(name)
+        parts = name.to_s.split(/:/)
+        tail = parts.pop.to_sym
+
+        ns = self
+
+        until parts.empty?
+          next_part = parts.shift
+          ns = next_part.empty? ? nil : ns.namespaces[next_part.to_sym]
+          return nil if ns.nil?
+        end
+
+        if ns.namespaces.key?(tail)
+          ns = ns.namespaces[tail]
+          tail = DEFAULT_TASK
+        end
+
+        ns.tasks[tail]
+      end
+
+      # Given a task name, this will search the current namespace, and all
+      # parent namespaces, looking for a task that matches the name, exactly.
+      # It returns the task, if found, or nil, if not.
+
+      def search_task(name)
+        name = name.to_sym
+        ns = self
+
+        until ns.nil?
+          return ns.tasks[name] if ns.tasks.key?(name)
+          ns = ns.parent
+        end
+
+        return nil
+      end
+
+      # Returns the default task for this namespace. This will be +nil+ if
+      # the namespace is at the top-level, and will otherwise return the
+      # task named "default". If no such task exists, +nil+ will be returned.
+
+      def default_task
+        parent ? tasks[DEFAULT_TASK] : nil
+      end
+
+      # Returns the tasks in this namespace as an array of TaskDefinition
+      # objects. If a non-false parameter is given, all tasks in all
+      # namespaces under this namespace will be returned as well.
+
+      def task_list(all = false)
+        list = tasks.values
+        namespaces.each { |name,space| list.concat(space.task_list(:all)) } if all
+        list
+      end
+
+
+      private
+
+      def all_methods
+        public_methods.concat(protected_methods).concat(private_methods)
+      end
+
+      class Namespace
+        def initialize(name, parent)
+          initialize_namespaces(name, parent)
+        end
+
+        def respond_to?(sym, include_priv = false)
+          super || parent.respond_to?(sym, include_priv)
+        end
+
+        def method_missing(sym, *args, &block)
+          if parent.respond_to?(sym)
+            parent.send(sym, *args, &block)
+          else
+            super
+          end
+        end
+
+        include Minestrone::Configuration::AliasTask
+        include Minestrone::Configuration::Namespaces
+
+        undef :desc, :next_description
+      end
+    end
+  end
+end
+
+module Kernel
+  class << self
+    alias_method :method_added_without_minestrone, :method_added
+
+    # Detect method additions to Kernel and remove them in the Namespace class
+
+    def method_added(name)
+      result = method_added_without_minestrone(name)
+      return result if self != Kernel
+
+      namespace = Minestrone::Configuration::Namespaces::Namespace
+
+      if namespace.method_defined?(name) && namespace.instance_method(name).owner == Kernel
+        namespace.send :undef_method, name
+      end
+
+      result
+    end
+  end
+end