ultra_marathon 0.0.1

data/lib/ultra_marathon/logging.rb

@@ -0,0 +1,40 @@
+require 'forwardable'
+require 'ultra_marathon/logger'
+require 'active_support/concern'
+
+module UltraMarathon
+  module Logging
+    extend ActiveSupport::Concern
+
+    ## Private Instance Methods
+
+    def logger
+      @logger ||= self.class.logger_class.new
+    end
+
+    module ClassMethods
+
+      ## Public Class Methods
+
+      # If the instance variable is callable, the result of invoking that block
+      # is set to be the instance variable. Otherwise returns it, defaulting
+      # to the included Logger class
+      def logger_class
+        if @logger_class && @logger_class.respond_to?(:call)
+          @logger_class = @logger_class.call
+        else
+          @logger_class ||= Logger
+        end
+      end
+
+      ## Private Class Methods
+
+      private
+
+      # Sets the log class. Can take a callable object or class
+      def log_class(log_class)
+        @logger_class = log_class
+      end
+    end
+  end
+end

data/lib/ultra_marathon/store.rb

@@ -0,0 +1,79 @@
+require 'set'
+require 'forwardable'
+
+module UltraMarathon
+  class Store
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :store, :[], :[]=, :delete, :empty?, :length, :size
+
+    ## Public Instance Methods
+
+    def initialize(new_runners=[])
+      new_runners.each do |new_runner|
+        add(new_runner)
+      end
+    end
+
+    def <<(runner)
+      store[runner.name] = runner
+    end
+    alias_method :add, :<<
+
+    def each(&block)
+      runners.each(&block)
+    end
+
+    def pluck(&block)
+      runners.map(&block)
+    end
+
+    def names
+      Set.new(store.keys)
+    end
+
+    def includes_all?(query_names)
+      (Set.new(query_names) - self.names).empty?
+    end
+
+    # When determining attributes, the user should always check for existence.
+    # If they don't, return nil.
+    def success?(name)
+      if exists? name
+        store[name].success
+      end
+    end
+
+    def failed?(name)
+      if exists? name
+        !success? name
+      end
+    end
+
+    def exists?(name)
+      store.key? name
+    end
+    alias_method :exist?, :exists?
+
+    def ==(other)
+      if other.is_a? self.class
+        other.names == self.names
+      else
+        false
+      end
+    end
+
+    private
+
+    ## Private Instance Methods
+
+    def runners
+      store.values
+    end
+
+    def store
+      @store ||= Hash.new
+    end
+  end
+end

data/lib/ultra_marathon/sub_runner.rb

@@ -0,0 +1,93 @@
+require 'set'
+require 'active_support/core_ext/proc'
+require 'ultra_marathon/callbacks'
+require 'ultra_marathon/logging'
+
+module UltraMarathon
+  class SubRunner
+    include Callbacks
+    include Logging
+    attr_accessor :run_block, :success
+    attr_reader :sub_context, :options, :name
+
+    callbacks :before_run, :after_run, :after_all, :on_error, :on_reset
+    after_all :log_header_and_sub_context
+
+    on_error lambda { self.success = false }
+    on_error lambda { |error| logger.error error }
+
+    # The :context option is required, because you'll never want to run a
+    # SubRunner in context of itself.
+    # SubContext is necessary because we want to run in the context of the
+    # other class, but do other things (like log) in the context of this one.
+    def initialize(options, run_block)
+      @name = options[:name]
+      @options = options
+      @sub_context = SubContext.new(options[:context], run_block)
+    end
+
+    def run!
+      begin
+        self.success = true
+        run_sub_context
+      rescue StandardError => error
+        invoke_on_error_callbacks(error)
+      ensure
+        invoke_after_all_callbacks
+      end
+    end
+
+    def reset
+      invoke_on_reset_callbacks
+    end
+
+    # Set of all sub runners that should be run before this one.
+    # This class cannot do anything with this information, but it is useful
+    # to the enveloping runner.
+    def parents
+      @parents ||= Set.new(options[:requires])
+    end
+
+    private
+
+    def run_sub_context
+      invoke_before_run_callbacks
+      sub_context.call
+      invoke_after_run_callbacks
+    end
+
+    def log_header_and_sub_context
+      logger.info log_header
+      log_sub_context
+    end
+
+    def log_sub_context
+      logger.info sub_context.logger.contents
+    end
+
+    def log_header
+      "Running '#{name}' SubRunner"
+    end
+  end
+
+  class SubContext
+    include Logging
+    attr_reader :context, :run_block
+
+    def initialize(context, run_block)
+      @context = context
+      # Ruby cannot marshal procs or lambdas, so we need to define a method.
+      # Binding to self allows us to intercept logging calls.
+      define_singleton_method :call, &run_block.bind(self)
+    end
+
+    # If the original context responds, delegate to it
+    def method_missing(method, *args, &block)
+      if context.respond_to? method
+        context.send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/ultra_marathon/version.rb

@@ -0,0 +1,18 @@
+module UltraMarathon
+  class Version
+    MAJOR = 0 unless defined? MAJOR
+    MINOR = 0 unless defined? MINOR
+    PATCH = 1 unless defined? PATCH
+    PRE = nil unless defined? PRE
+
+    class << self
+
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+      end
+
+    end
+
+  end
+end

data/lib/ultra_marathon.rb

@@ -0,0 +1,10 @@
+require 'ultra_marathon/abstract_runner'
+require 'ultra_marathon/callbacks'
+require 'ultra_marathon/instrumentation'
+require 'ultra_marathon/logging'
+require 'ultra_marathon/sub_runner'
+require 'ultra_marathon/store'
+
+module UltraMarathon
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'awesome_print'
+require 'timecop'
+require 'ultra_marathon'
+require 'rspec'
+require 'rspec/autorun'
+require 'support/test_helpers'
+
+include TestHelpers

data/spec/support/file_mutexes.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+module TestHelpers
+
+  def wait_for_lock(mutex)
+    ensure_path_to_mutex(mutex)
+    total_wait_time = 0.0
+    while File.exists?(mutex_path(mutex))
+      sleep(0.1)
+      total_wait_time += 0.1
+      if total_wait_time > 60 * 5
+        raise "Took too long to obtain a lock"
+      end
+    end
+    File.open(mutex_path(mutex), "w") {}
+  end
+
+  def release_lock(mutex)
+    File.delete(mutex_path(mutex)) if File.exists? mutex_path(mutex)
+  end
+
+  private
+
+  # returns the mutext path, making sure to only dump crap in tmp/
+  def mutex_path(mutex)
+    if mutex.start_with? 'tmp'
+      mutex
+    else
+      'tmp/' << mutex
+    end
+  end
+
+  # Given a mutex 'log/maintenance/walrus_maintenance.log',
+  # ensures that 'tmp/log/maintenance/' directory exists
+  def ensure_path_to_mutex(mutex)
+    path = mutex_path(mutex)
+    if path =~ /\Atmp\/.+\/([^\/]+)\z/
+      FileUtils.mkdir_p path[0...-$1.length]
+    end
+  end
+end
+

data/spec/support/test_helpers.rb

@@ -0,0 +1,11 @@
+require 'support/file_mutexes'
+
+module TestHelpers
+
+  # create an anonymous test class so we don't pollute the global namespace
+  def anonymous_test_class(inherited_class=Object, &block)
+    Class.new(inherited_class).tap do |klass|
+      klass.class_eval(&block) if block_given?
+    end
+  end
+end

data/spec/ultra_marathon/abstract_runner_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe UltraMarathon::AbstractRunner do
+  let(:test_class) { anonymous_test_class(UltraMarathon::AbstractRunner) }
+  let(:test_instance) { test_class.new }
+
+  describe '#run!' do
+    subject { test_instance.run! }
+
+    describe 'with one run block' do
+      before(:each) { test_class.send :run, &run_block }
+
+      context 'when everything is fine' do
+        let(:run_block) { Proc.new { logger.info 'Look at me go!' } }
+
+        it 'should run the given block in the context of the instance' do
+          subject
+          test_instance.logger.contents.should include "Look at me go!\n"
+        end
+
+        it 'should be a success' do
+          subject
+          test_instance.success.should be
+        end
+      end
+
+      context 'when things go wrong' do
+        let(:run_block) { Proc.new { raise 'Benoit!' } }
+
+        it 'should catch the error' do
+          expect { subject }.to_not raise_error
+        end
+
+        it 'should logger.info the error message' do
+          subject
+          test_instance.logger.contents.should include 'Benoit!'
+        end
+
+        it 'should set success to false' do
+          subject
+          test_instance.success.should_not be
+        end
+      end
+    end
+
+    describe 'with multiple run blocks' do
+
+      context 'when everything is fine' do
+
+        before(:each) do
+          test_class.send(:run, &->{ logger.info 'I am the Walrus' })
+          test_class.send(:run, :yolo, &->{ logger.info 'Koo koo ka choo' })
+        end
+
+        it 'should run both blocks' do
+          subject
+          test_instance.logger.contents.should include 'I am the Walrus'
+          test_instance.logger.contents.should include 'Koo koo ka choo'
+        end
+      end
+
+      context 'when one goes awry' do
+        before(:each) do
+          test_class.send(:run, :walrus, &->{ raise 'I am the Walrus' })
+          test_class.send(:run, :wat, &->{ logger.info 'Koo koo ka choo' })
+        end
+
+        it 'should still run the other' do
+          subject
+          test_instance.logger.contents.should include 'I am the Walrus'
+          test_instance.logger.contents.should include 'Koo koo ka choo'
+        end
+      end
+
+      context 'when one run relies on another' do
+        context 'when everything is okay' do
+          before(:each) do
+            test_class.send(:run, :wat, requires: [:walrus], &->{ logger.info 'Koo koo ka choo' })
+            test_class.send(:run, :walrus, &->{ logger.info 'I am the Walrus' })
+          end
+
+          it 'should run both blocks' do
+            subject
+            test_instance.logger.contents.should include 'I am the Walrus'
+            test_instance.logger.contents.should include 'Koo koo ka choo'
+          end
+
+          it 'should run the parents before the children' do
+            subject
+            walrus_log_position = test_instance.logger.contents.index('I am the Walrus')
+            wat_log_position = test_instance.logger.contents.index('Koo koo ka choo')
+            walrus_log_position.should be < wat_log_position
+          end
+        end
+
+        context 'when the parent fails' do
+          before(:each) do
+            test_class.send(:run, :wat, requires: [:walrus], &->{ logger.info 'Koo koo ka choo' })
+            test_class.send(:run, :walrus, &->{ raise 'I am the Walrus!' })
+          end
+
+          it 'should logger.info the error' do
+            subject
+            test_instance.logger.contents.should include 'I am the Walrus!'
+          end
+
+          it 'should not run the child' do
+            subject
+            test_instance.logger.contents.should_not include 'Koo koo ka choo'
+          end
+        end
+      end
+    end
+  end
+
+  describe 'callbacks' do
+    before(:each) { test_class.send :run, &run_block }
+
+    subject { test_instance.run! }
+
+    describe 'before_run callback' do
+      let(:run_block) { Proc.new { logger.info 'Blastoff!' } }
+
+      before(:each) do
+        test_class.before_run ->{ logger.info '3-2-1' }
+      end
+
+      it 'should invoke before_run callbacks before run!' do
+        subject
+        test_instance.logger.contents.should include '3-2-1'
+        test_instance.logger.contents.index('3-2-1').should be < test_instance.logger.contents.index('Blastoff!')
+      end
+    end
+
+    describe 'after_run callback' do
+      let(:run_block) { Proc.new { logger.info 'Blastoff!' } }
+
+      before(:each) do
+        test_class.after_run ->{ logger.info 'We have liftoff!' }
+      end
+
+      it 'should invoke before_run callbacks before run!' do
+        subject
+        test_instance.logger.contents.should include 'We have liftoff!'
+        test_instance.logger.contents.index('We have liftoff!').should be > test_instance.logger.contents.index('Blastoff!')
+      end
+    end
+  end
+
+  describe '#reset' do
+    it 'should change success to true' do
+      test_instance.success = false
+      test_instance.reset
+      test_instance.success.should be
+    end
+
+    it 'returns itself' do
+      test_instance.reset.should be test_instance
+    end
+  end
+end