minestrone 0.0.1

data/test/configuration/alias_task_test.rb

@@ -0,0 +1,110 @@
+require 'utils'
+require 'minestrone/configuration/alias_task'
+require 'minestrone/configuration/execution'
+require 'minestrone/configuration/namespaces'
+require 'minestrone/task_definition'
+
+class AliasTaskTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :options
+    attr_accessor :logger
+
+    def initialize(options = {})
+      @options = {}
+      @logger = options.delete(:logger)
+      initialize_execution
+      initialize_namespaces
+    end
+
+    include Minestrone::Configuration::AliasTask
+    include Minestrone::Configuration::Execution
+    include Minestrone::Configuration::Namespaces
+  end
+
+  def setup
+    @config = MockConfig.new( :logger => stub(:debug => nil, :info => nil, :important => nil) )
+  end
+
+  def test_makes_a_copy_of_the_task
+    @config.task(:foo) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    assert @config.tasks.key?(:new_foo)
+  end
+
+  def test_original_task_remain_with_same_name
+    @config.task(:foo) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    assert_equal :foo, @config.tasks[:foo].name
+    assert_equal :new_foo, @config.tasks[:new_foo].name
+  end
+
+  def test_aliased_task_do_the_same
+    @config.task(:foo) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    assert_equal 42, @config.find_and_execute_task('new_foo')
+  end
+
+  def test_aliased_task_should_preserve_description
+    @config.task(:foo, :desc => "the Ultimate Question of Life, the Universe, and Everything" ) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    task = @config.find_task('foo')
+    new_task = @config.find_task('new_foo')
+
+    assert_equal task.description, new_task.description
+  end
+
+  def test_aliased_task_should_preserve_on_error
+    @config.task(:foo, :on_error => :continue) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    task = @config.find_task('foo')
+    new_task = @config.find_task('new_foo')
+
+    assert_equal task.on_error, new_task.on_error
+  end
+
+  def test_raise_exception_when_task_doesnt_exist
+    assert_raises(Minestrone::NoSuchTaskError) { @config.alias_task 'non_existant_task', 'fail_miserably' }
+  end
+
+  def test_convert_task_names_using_to_str
+    @config.task(:foo) { 42 }
+
+    @config.alias_task 'one', 'foo'
+    @config.alias_task :two, 'foo'
+    @config.alias_task 'three', :foo
+    @config.alias_task :four, :foo
+
+    assert @config.tasks.key?(:one)
+    assert @config.tasks.key?(:two)
+    assert @config.tasks.key?(:three)
+    assert @config.tasks.key?(:four)
+  end
+
+  def test_raise_an_exception_when_task_names_can_not_be_converted
+    @config.task(:foo) { 42 }
+
+    assert_raises(ArgumentError) { @config.alias_task mock('x'), :foo }
+  end
+
+  def test_should_include_namespace
+    @config.namespace(:outer) do
+      task(:foo) { 42 }
+      alias_task 'new_foo', 'foo'
+
+      namespace(:inner) do
+        task(:foo) { 43 }
+        alias_task 'new_foo', 'foo'
+      end
+    end
+
+    assert_equal 42, @config.find_and_execute_task('outer:new_foo')
+    assert_equal 42, @config.find_and_execute_task('outer:foo')
+    assert_equal 43, @config.find_and_execute_task('outer:inner:new_foo')
+    assert_equal 43, @config.find_and_execute_task('outer:inner:foo')
+  end
+end

data/test/configuration/callbacks_test.rb

@@ -0,0 +1,201 @@
+require "utils"
+require 'minestrone/configuration/callbacks'
+
+class ConfigurationCallbacksTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :original_initialize_called
+    attr_reader :called
+
+    def initialize
+      @original_initialize_called = true
+      @called = []
+      initialize_callbacks
+    end
+
+    def execute_task(task)
+      invoke_task_directly(task)
+    end
+
+    protected
+
+    def invoke_task_directly(task)
+      @called << task
+    end
+
+    include Minestrone::Configuration::Callbacks
+  end
+
+  def setup
+    @config = MockConfig.new
+    @config.stubs(:logger).returns(stub_everything("logger"))
+  end
+
+  def test_initialize_should_initialize_callbacks_collection
+    assert @config.original_initialize_called
+    assert @config.callbacks.empty?
+  end
+
+  def test_before_should_delegate_to_on
+    @config.expects(:on).with(:before, :foo, "bing:blang", {:only => :bar, :zip => :zing})
+    @config.before :bar, :foo, "bing:blang", :zip => :zing
+  end
+
+  def test_before_should_keep_task_names_as_given
+    @config.before "deploy:create_symlink", "bing:blang", "deploy:create_symlink"
+    assert_equal "bing:blang", @config.callbacks[:before][0].source
+    assert_equal "deploy:create_symlink", @config.callbacks[:before][1].source
+    assert_equal ["deploy:create_symlink"], @config.callbacks[:before][1].only
+  end
+
+  def test_before_should_keep_task_name_arrays_as_given
+    @config.before ["deploy:create_symlink", "bingo:blast"], "bing:blang"
+    assert_equal ["deploy:create_symlink", "bingo:blast"], @config.callbacks[:before].last.only
+  end
+
+  def test_after_should_delegate_to_on
+    @config.expects(:on).with(:after, :foo, "bing:blang", {:only => :bar, :zip => :zing})
+    @config.after :bar, :foo, "bing:blang", :zip => :zing
+  end
+
+  def test_after_should_keep_task_names_as_given
+    @config.after "deploy:create_symlink", "bing:blang", "deploy:create_symlink"
+    assert_equal "bing:blang", @config.callbacks[:after][0].source
+    assert_equal "deploy:create_symlink", @config.callbacks[:after][1].source
+    assert_equal ["deploy:create_symlink"], @config.callbacks[:after][1].only
+  end
+
+  def test_after_should_keep_task_name_arrays_as_given
+    @config.after ["deploy:create_symlink", "bingo:blast"], "bing:blang"
+    assert_equal ["deploy:create_symlink", "bingo:blast"], @config.callbacks[:after].last.only
+  end
+
+  def test_on_with_single_reference_should_add_task_callback
+    @config.on :before, :a_test
+    assert_equal 1, @config.callbacks[:before].length
+    assert_equal :a_test, @config.callbacks[:before][0].source
+    @config.expects(:find_and_execute_task).with(:a_test)
+    @config.callbacks[:before][0].call
+  end
+
+  def test_on_with_multi_reference_should_add_all_as_task_callback
+    @config.on :before, :first, :second, :third
+    assert_equal 3, @config.callbacks[:before].length
+    assert_equal %w(first second third), @config.callbacks[:before].map { |c| c.source.to_s }
+  end
+
+  def test_on_with_block_should_add_block_as_proc_callback
+    called = false
+    @config.on(:before) { called = true }
+    assert_equal 1, @config.callbacks[:before].length
+    assert_instance_of Proc, @config.callbacks[:before][0].source
+    @config.callbacks[:before][0].call
+    assert called
+  end
+
+  def test_on_with_single_only_should_set_only_as_string_array_on_all_references
+    @config.on :before, :first, "second:third", :only => :primary
+    assert_equal 2, @config.callbacks[:before].length
+    assert @config.callbacks[:before].all? { |c| c.only == %w(primary) }
+  end
+
+  def test_on_with_multi_only_should_set_only_as_string_array_on_all_references
+    @config.on :before, :first, "second:third", :only => [:primary, "other:one"]
+    assert_equal 2, @config.callbacks[:before].length
+    assert @config.callbacks[:before].all? { |c| c.only == %w(primary other:one) }
+  end
+
+  def test_on_with_single_except_should_set_except_as_string_array_on_all_references
+    @config.on :before, :first, "second:third", :except => :primary
+    assert_equal 2, @config.callbacks[:before].length
+    assert @config.callbacks[:before].all? { |c| c.except == %w(primary) }
+  end
+
+  def test_on_with_multi_except_should_set_except_as_string_array_on_all_references
+    @config.on :before, :first, "second:third", :except => [:primary, "other:one"]
+    assert_equal 2, @config.callbacks[:before].length
+    assert @config.callbacks[:before].all? { |c| c.except == %w(primary other:one) }
+  end
+
+  def test_on_with_only_and_block_should_set_only_as_string_array
+    @config.on(:before, :only => :primary) { blah }
+    assert_equal 1, @config.callbacks[:before].length
+    assert_equal %w(primary), @config.callbacks[:before].first.only
+  end
+
+  def test_on_with_except_and_block_should_set_except_as_string_array
+    @config.on(:before, :except => :primary) { blah }
+    assert_equal 1, @config.callbacks[:before].length
+    assert_equal %w(primary), @config.callbacks[:before].first.except
+  end
+
+  def test_on_without_tasks_or_block_should_raise_error
+    assert_raises(ArgumentError) { @config.on(:before) }
+  end
+
+  def test_on_with_both_tasks_and_block_should_raise_error
+    assert_raises(ArgumentError) { @config.on(:before, :first) { blah } }
+  end
+
+  def test_trigger_without_constraints_should_invoke_all_callbacks
+    task = stub(:fully_qualified_name => "any:old:thing")
+    @config.on(:before, :first, "second:third")
+    @config.on(:after, :another, "and:another")
+    @config.expects(:find_and_execute_task).with(:first)
+    @config.expects(:find_and_execute_task).with("second:third")
+    @config.expects(:find_and_execute_task).with(:another).never
+    @config.expects(:find_and_execute_task).with("and:another").never
+    @config.trigger(:before, task)
+  end
+
+  def test_trigger_with_only_constraint_should_invoke_only_matching_callbacks
+    task = stub(:fully_qualified_name => "any:old:thing")
+    @config.on(:before, :first)
+    @config.on(:before, "second:third", :only => "any:old:thing")
+    @config.on(:before, "this:too", :only => "any:other:thing")
+    @config.on(:after, :another, "and:another")
+    @config.expects(:find_and_execute_task).with(:first)
+    @config.expects(:find_and_execute_task).with("second:third")
+    @config.expects(:find_and_execute_task).with("this:too").never
+    @config.expects(:find_and_execute_task).with(:another).never
+    @config.expects(:find_and_execute_task).with("and:another").never
+    @config.trigger(:before, task)
+  end
+
+  def test_trigger_with_except_constraint_should_invoke_anything_but_matching_callbacks
+    task = stub(:fully_qualified_name => "any:old:thing")
+    @config.on(:before, :first)
+    @config.on(:before, "second:third", :except => "any:old:thing")
+    @config.on(:before, "this:too", :except => "any:other:thing")
+    @config.on(:after, :another, "and:another")
+    @config.expects(:find_and_execute_task).with(:first)
+    @config.expects(:find_and_execute_task).with("second:third").never
+    @config.expects(:find_and_execute_task).with("this:too")
+    @config.expects(:find_and_execute_task).with(:another).never
+    @config.expects(:find_and_execute_task).with("and:another").never
+    @config.trigger(:before, task)
+  end
+
+  def test_trigger_without_task_should_invoke_all_callbacks_for_that_event
+    @config.on(:before, :first)
+    @config.on(:before, "second:third", :except => "any:old:thing")
+    @config.on(:before, "this:too", :except => "any:other:thing")
+    @config.on(:after, :another, "and:another")
+    @config.expects(:find_and_execute_task).with(:first)
+    @config.expects(:find_and_execute_task).with("second:third")
+    @config.expects(:find_and_execute_task).with("this:too")
+    @config.expects(:find_and_execute_task).with(:another).never
+    @config.expects(:find_and_execute_task).with("and:another").never
+    @config.trigger(:before)
+  end
+
+  def test_execute_task_without_named_hooks_should_just_call_task
+    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
+    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
+
+    ns.stubs(:search_task).returns(nil)
+
+    @config.execute_task(task)
+    assert_equal [task], @config.called
+  end
+
+end

data/test/configuration/connections_test.rb

@@ -0,0 +1,192 @@
+require "utils"
+require 'minestrone/configuration/connections'
+
+class ConfigurationConnectionsTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :original_initialize_called
+    attr_reader :values
+    attr_reader :dry_run
+    attr_accessor :current_task
+    attr_accessor :server
+
+    def initialize
+      @original_initialize_called = true
+      @values = {}
+      initialize_connections
+    end
+
+    def fetch(*args)
+      @values.fetch(*args)
+    end
+
+    def [](key)
+      @values[key]
+    end
+
+    def exists?(key)
+      @values.key?(key)
+    end
+
+    def resolved_server
+      @server
+    end
+
+    include Minestrone::Configuration::Connections
+  end
+
+  def setup
+    @config = MockConfig.new
+    @config.stubs(:logger).returns(stub_everything)
+    Net::SSH.stubs(:configuration_for).returns({})
+  end
+
+  def test_initialize_should_initialize_session_and_call_original_initialize
+    assert @config.original_initialize_called
+    assert_nil @config.session
+    assert_false @config.instance_variable_get('@failed')
+  end
+
+  def test_establish_connection_to_server_should_use_the_resolved_server
+    Minestrone::SSH.expects(:connect).with { |s,c| s.host == "minestrone" && c == @config }.returns(:success)
+    assert_nil @config.session
+    @config.server = server("minestrone")
+    @config.establish_connection_to_server
+    assert_equal :success, @config.session
+  end
+
+  def test_establish_connection_to_server_should_not_attempt_to_reestablish_existing_connection
+    Minestrone::SSH.expects(:connect).never
+    @config.expects(:resolved_server).never
+    @config.session = :ok
+    @config.server = server("cap1")
+    @config.establish_connection_to_server
+    assert_equal :ok, @config.session
+  end
+
+  def test_establish_connection_to_server_should_raise_connection_error_on_failure
+    Minestrone::SSH.expects(:connect).raises(Exception)
+    @config.server = server("cap1")
+    assert_raises(Minestrone::ConnectionError) {
+      @config.establish_connection_to_server
+    }
+  end
+
+  def test_connection_error_should_include_failed_host
+    Minestrone::SSH.expects(:connect).raises(Exception)
+    @config.server = server("cap1")
+    begin
+      @config.establish_connection_to_server
+      flunk "expected an exception to be raised"
+    rescue Minestrone::ConnectionError => e
+      assert e.respond_to?(:host)
+      assert_equal "cap1", e.host.to_s
+    end
+  end
+
+  def test_execute_on_server_should_require_a_block
+    assert_raises(ArgumentError) { @config.execute_on_server }
+  end
+
+  def test_execute_on_server_without_current_task_should_use_configured_server
+    host = server("first")
+    @config.server = host
+    @config.expects(:establish_connection_to_server).returns(:done)
+    block_called = false
+    @config.execute_on_server do
+      block_called = true
+    end
+    assert block_called
+  end
+
+  def test_execute_on_server_should_determine_server_from_configured_server
+    assert_nil @config.session
+    @config.server = server("cap1")
+    @config.current_task = mock_task
+    Minestrone::SSH.expects(:connect).returns(:success)
+    @config.execute_on_server {}
+    assert_equal :success, @config.session
+  end
+
+  def test_execute_on_server_should_yield_to_block
+    assert_nil @config.session
+    host = server("cap1")
+    @config.server = host
+    @config.current_task = mock_task
+    Minestrone::SSH.expects(:connect).returns(:success)
+    block_called = false
+    @config.execute_on_server do
+      block_called = true
+      assert @config.session
+    end
+    assert block_called
+  end
+
+  def test_execute_servers_should_raise_connection_error_on_failure_by_default
+    @config.current_task = mock_task
+    @config.server = server("cap1")
+    Minestrone::SSH.expects(:connect).raises(Exception)
+    assert_raises(Minestrone::ConnectionError) do
+      @config.execute_on_server do
+        flunk "expected an exception to be raised"
+      end
+    end
+  end
+
+  def test_execute_servers_should_not_raise_connection_error_on_failure_with_on_errors_continue
+    host = server("cap1")
+    @config.current_task = mock_task(:on_error => :continue)
+    @config.server = host
+    Minestrone::SSH.expects(:connect).raises(Exception)
+    assert_nothing_raised {
+      @config.execute_on_server do
+        flunk "should not yield after connection failure"
+      end
+    }
+    assert @config.instance_variable_get('@failed')
+  end
+
+  def test_execute_on_server_should_skip_failed_host_with_on_errors_continue
+    @config.current_task = mock_task(:on_error => :continue)
+    @config.server = server("cap1")
+    @config.instance_variable_set('@failed', true)
+
+    Minestrone::SSH.expects(:connect).never
+
+    @config.execute_on_server do
+      flunk "should not yield for failed host"
+    end
+  end
+
+  def test_execute_on_server_should_record_command_errors_with_on_errors_continue
+    host = server("cap1")
+    @config.current_task = mock_task(:on_error => :continue)
+    @config.server = host
+    Minestrone::SSH.expects(:connect).returns(:success)
+    @config.execute_on_server do
+      error = Minestrone::CommandError.new
+      error.host = host
+      raise error
+    end
+    assert @config.instance_variable_get('@failed')
+  end
+
+  def test_connect_should_establish_connection_to_server_in_scope
+    assert_nil @config.session
+    @config.current_task = mock_task
+    @config.server = server("cap1")
+    Minestrone::SSH.expects(:connect).returns(:success)
+    @config.connect!
+    assert_equal :success, @config.session
+  end
+
+  private
+
+  def mock_task(options = {})
+    continue_on_error = options[:on_error] == :continue
+    stub("task",
+      :fully_qualified_name => "name",
+      :options => options,
+      :continue_on_error? => continue_on_error
+    )
+  end
+end

data/test/configuration/execution_test.rb

@@ -0,0 +1,176 @@
+require "utils"
+require 'minestrone/configuration/execution'
+require 'minestrone/task_definition'
+
+class ConfigurationExecutionTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :tasks, :namespaces, :fully_qualified_name, :parent
+    attr_reader :state, :original_initialize_called
+    attr_accessor :logger, :default_task
+
+    def initialize(options = {})
+      @original_initialize_called = true
+      @tasks = {}
+      @namespaces = {}
+      @state = {}
+      @fully_qualified_name = options[:fqn]
+      @parent = options[:parent]
+      @logger = options.delete(:logger)
+      initialize_execution
+    end
+
+    include Minestrone::Configuration::Execution
+  end
+
+  def setup
+    @config = MockConfig.new(:logger => stub(:debug => nil, :info => nil, :important => nil))
+    @config.stubs(:search_task).returns(nil)
+  end
+
+  def test_initialize_should_initialize_collections
+    assert_nil @config.rollback_requests
+    assert @config.original_initialize_called
+    assert @config.task_call_frames.empty?
+  end
+
+  def test_execute_task_should_populate_call_stack
+    task = new_task @config, :testing
+    assert_nothing_raised { @config.execute_task(task) }
+    assert_equal %w(testing), @config.state[:testing][:stack]
+    assert_nil @config.state[:testing][:history]
+    assert @config.task_call_frames.empty?
+  end
+
+  def test_nested_execute_task_should_add_to_call_stack
+    testing = new_task @config, :testing
+    outer = new_task(@config, :outer) { execute_task(testing) }
+
+    assert_nothing_raised { @config.execute_task(outer) }
+    assert_equal %w(outer testing), @config.state[:testing][:stack]
+    assert_nil @config.state[:testing][:history]
+    assert @config.task_call_frames.empty?
+  end
+
+  def test_execute_task_should_execute_in_scope_of_tasks_parent
+    ns = stub("namespace", :tasks => {}, :default_task => nil, :fully_qualified_name => "ns")
+    ns.expects(:instance_eval)
+    testing = new_task ns, :testing
+    @config.execute_task(testing)
+  end
+
+  def test_transaction_outside_of_task_should_raise_exception
+    assert_raises(ScriptError) { @config.transaction {} }
+  end
+
+  def test_transaction_without_block_should_raise_argument_error
+    testing = new_task(@config, :testing) { transaction }
+    assert_raises(ArgumentError) { @config.execute_task(testing) }
+  end
+
+  def test_transaction_should_initialize_transaction_history
+    @config.state[:inspector] = stack_inspector
+    testing = new_task(@config, :testing) { transaction { instance_eval(&state[:inspector]) } }
+    @config.execute_task(testing)
+    assert_equal [], @config.state[:testing][:history]
+  end
+
+  def test_transaction_from_within_transaction_should_not_start_new_transaction
+    third = new_task(@config, :third, &stack_inspector)
+    second = new_task(@config, :second) { transaction { execute_task(third) } }
+    first = new_task(@config, :first) { transaction { execute_task(second) } }
+    # kind of fragile...not sure how else to check that transaction was only
+    # really run twice...but if the transaction was REALLY run, logger.info
+    # will be called once when it starts, and once when it finishes.
+    @config.logger = mock()
+    @config.logger.stubs(:debug)
+    @config.logger.expects(:info).times(2)
+    @config.execute_task(first)
+  end
+
+  def test_on_rollback_should_have_no_effect_outside_of_transaction
+    aaa = new_task(@config, :aaa) { on_rollback { state[:rollback] = true }; raise "boom" }
+    assert_raises(RuntimeError) { @config.execute_task(aaa) }
+    assert_nil @config.state[:rollback]
+  end
+
+  def test_exception_raised_in_transaction_should_call_all_registered_rollback_handlers_in_reverse_order
+    aaa = new_task(@config, :aaa) { on_rollback { (state[:rollback] ||= []) << :aaa } }
+    bbb = new_task(@config, :bbb) { on_rollback { (state[:rollback] ||= []) << :bbb } }
+    ccc = new_task(@config, :ccc) {}
+    ddd = new_task(@config, :ddd) { on_rollback { (state[:rollback] ||= []) << :ddd }; execute_task(bbb); execute_task(ccc) }
+    eee = new_task(@config, :eee) { transaction { execute_task(ddd); execute_task(aaa); raise "boom" } }
+    assert_raises(RuntimeError) do
+      @config.execute_task(eee)
+    end
+    assert_equal [:aaa, :bbb, :ddd], @config.state[:rollback]
+    assert_nil @config.rollback_requests
+    assert @config.task_call_frames.empty?
+  end
+
+  def test_exception_during_rollback_should_simply_be_logged_and_ignored
+    aaa = new_task(@config, :aaa) { on_rollback { state[:aaa] = true; raise LoadError, "ouch" }; execute_task(bbb) }
+    bbb = new_task(@config, :bbb) { raise MadError, "boom" }
+    ccc = new_task(@config, :ccc) { transaction { execute_task(aaa) } }
+    assert_raises(NameError) do
+      @config.execute_task(ccc)
+    end
+    assert @config.state[:aaa]
+  end
+
+  def test_on_rollback_called_twice_should_result_in_last_rollback_block_being_effective
+    aaa = new_task(@config, :aaa) do
+      transaction do
+        on_rollback { (state[:rollback] ||= []) << :first }
+        on_rollback { (state[:rollback] ||= []) << :second }
+        raise "boom"
+      end
+    end
+
+    assert_raises(RuntimeError) do
+      @config.execute_task(aaa)
+    end
+
+    assert_equal [:second], @config.state[:rollback]
+  end
+
+  def test_find_and_execute_task_should_raise_error_when_task_cannot_be_found
+    @config.expects(:find_task).with("path:to:task").returns(nil)
+    assert_raises(Minestrone::NoSuchTaskError) { @config.find_and_execute_task("path:to:task") }
+  end
+
+  def test_find_and_execute_task_should_execute_task_when_task_is_found
+    @config.expects(:find_task).with("path:to:task").returns(:found)
+    @config.expects(:execute_task).with(:found)
+    assert_nothing_raised { @config.find_and_execute_task("path:to:task") }
+  end
+
+  def test_find_and_execute_task_with_before_option_should_trigger_callback
+    @config.expects(:find_task).with("path:to:task").returns(:found)
+    @config.expects(:trigger).with(:incoming, :found)
+    @config.expects(:execute_task).with(:found)
+    @config.find_and_execute_task("path:to:task", :before => :incoming)
+  end
+
+  def test_find_and_execute_task_with_after_option_should_trigger_callback
+    @config.expects(:find_task).with("path:to:task").returns(:found)
+    @config.expects(:trigger).with(:outgoing, :found)
+    @config.expects(:execute_task).with(:found)
+    @config.find_and_execute_task("path:to:task", :after => :outgoing)
+  end
+
+  private
+
+  def stack_inspector
+    Proc.new do
+      (state[:trail] ||= []) << current_task.fully_qualified_name
+      data = state[current_task.name] = {}
+      data[:stack] = task_call_frames.map { |frame| frame.task.fully_qualified_name }
+      data[:history] = rollback_requests && rollback_requests.map { |frame| frame.task.fully_qualified_name }
+    end
+  end
+
+  def new_task(namespace, name, options = {}, &block)
+    block ||= stack_inspector
+    namespace.tasks[name] = Minestrone::TaskDefinition.new(name, namespace, &block)
+  end
+end