scripted 0.0.1

data/lib/scripted/output/logger.rb

@@ -0,0 +1,139 @@
+require 'scripted/output/command_logger'
+
+module Scripted
+  module Output
+    class Logger
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        if block_given?
+          begin
+            yield self
+          ensure
+            close
+          end
+        end
+      end
+
+      def command_loggers
+        @command_loggers ||= Hash.new { |h,k| h[k] = CommandLogger.new(self, k) }
+      end
+
+      def self.delegate_to_formatters(name)
+        define_method(name) { |*args, &block|
+          sync
+          send_to_formatters(name, *args, &block)
+        }
+      end
+
+      delegate_to_formatters :stop
+      delegate_to_formatters :done
+      delegate_to_formatters :halted
+      delegate_to_formatters :execute
+      delegate_to_formatters :exception
+
+      def start(commands, runner)
+        # create all the command loggers
+        commands.each { |c| command_loggers[c] }
+        sync
+        send_to_formatters :start, commands, runner
+      end
+
+      def to_io(command)
+        command_loggers[command].to_io
+      end
+
+      def send_to_formatters(*args, &block)
+        formatters.each { |formatter| formatter.send(*args, &block) }
+      end
+
+      private
+
+      def sync
+        command_loggers.each { |c, l| l.sync }
+      end
+
+      def close
+        command_loggers.each { |c, l| l.close }
+        send_to_formatters :close
+      end
+
+      def formatters
+        @formatters ||= build_formatters
+      end
+
+      def build_formatters
+        formatter_names = configuration.formatters
+        if formatter_names.empty?
+          formatter_names = [ {:name => "default"} ]
+        end
+        formatters = formatter_names.uniq { |fn| fn[:name] }.map do |formatter|
+          find_formatter(formatter.fetch(:name)).new(formatter.fetch(:out, STDERR), configuration)
+        end
+        formatters
+      end
+
+      def find_formatter(name)
+        built_in_formatter(name) || custom_formatter(name)
+      end
+
+      def built_in_formatter(formatter_ref)
+        case formatter_ref.to_s.downcase
+        when 'announcer', 'a', 'ann', 'announce'
+          require 'scripted/formatters/announcer'
+          Scripted::Formatters::Announcer
+        when 'blank'
+          require 'scripted/formatters/blank'
+          Scripted::Formatters::Blank
+        when 'default', 'd'
+          require 'scripted/formatters/default'
+          Scripted::Formatters::Default
+        when 'table', 't'
+          require 'scripted/formatters/table'
+          Scripted::Formatters::Table
+        when 'stats', 's', 'stat'
+          require 'scripted/formatters/stats'
+          Scripted::Formatters::Stats
+        when 'websockets', 'w', 'web', 'websocket'
+          require 'scripted/formatters/websocket'
+          Scripted::Formatters::Websocket
+        end
+      end
+
+      def custom_formatter(formatter_ref)
+        if Class === formatter_ref
+          formatter_ref
+        elsif string_const?(formatter_ref)
+          begin
+            eval(formatter_ref)
+          rescue NameError
+            require path_for(formatter_ref)
+            eval(formatter_ref)
+          end
+        end
+      end
+
+      def string_const?(str)
+        str.is_a?(String) && /\A[A-Z][a-zA-Z0-9_:]*\z/ =~ str
+      end
+
+      def path_for(const_ref)
+        underscore(const_ref)
+      end
+
+      # activesupport/lib/active_support/inflector/methods.rb, line 48
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+    end
+  end
+end

data/lib/scripted/rake_task.rb

@@ -0,0 +1,24 @@
+require 'scripted'
+
+require 'rake'
+require 'rake/tasklib'
+
+module Scripted
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    def initialize(name, *group_names, &block)
+      group_names = [:default] if group_names.empty?
+      unless Rake.application.last_description
+        desc "Run scripted groups: #{group_names.map(&:to_s).join(', ')}"
+      end
+      task name do
+        config = Scripted.configure(&block)
+        config.with_default_config_file!
+        config.load_files
+        Scripted.run(config, *group_names)
+      end
+    end
+
+  end
+end

data/lib/scripted/runner.rb

@@ -0,0 +1,19 @@
+require "scripted/output/logger"
+require "scripted/running/select_commands"
+require "scripted/running/run_commands"
+
+module Scripted
+  class Runner
+
+    def self.start!(configuration, *group_names)
+      Output::Logger.new(configuration) do |logger|
+        select_commands = Running::SelectCommands.new(configuration, logger)
+        commands = select_commands.commands(group_names)
+        run_commands = Running::RunCommands.new(logger)
+        run_commands.run(commands)
+        raise RunningFailed, "One or more commands have failed" if run_commands.failed?
+      end
+    end
+
+  end
+end

data/lib/scripted/running/execute.rb

@@ -0,0 +1,16 @@
+module Scripted
+  module Running
+    module Execute
+
+      def self.call(command, delegate, logger)
+        command.execute!(logger.to_io(delegate))
+        delegate.success!
+      rescue Exception => exception
+        logger.exception(delegate, exception)
+        delegate.failed!(exception)
+        return false
+      end
+
+    end
+  end
+end

data/lib/scripted/running/run_command.rb

@@ -0,0 +1,101 @@
+require "scripted/running/execute"
+
+module Scripted
+  module Running
+    class RunCommand
+
+      attr_reader :command, :logger
+      attr_reader :started_at, :ended_at, :runtime, :exception, :delegate
+
+      def initialize(command, logger)
+        @command = command
+        @logger = logger
+      end
+
+      def execute!(delegate)
+        return if executed?
+        @delegate = delegate
+        @running = true
+        @started_at = Time.now
+        logger.execute(self)
+        Execute.call(command, self, logger)
+      end
+
+      def done
+        @executed = true
+        @running  = false
+        @ended_at = Time.now
+        @runtime  = @ended_at - @started_at
+        delegate.done(self)
+      end
+
+      def success!
+        @success = true
+        done
+      end
+
+      def failed!(exception)
+        @success = false
+        @exception = exception
+        if important?
+          @halted = true
+          delegate.halt!(self)
+        end
+        done
+      end
+
+      def important?
+        command.important?
+      end
+
+      def success?
+        executed? && !!@success
+      end
+
+      def failed?
+        executed? && !unimportant? && !@success
+      end
+
+      def running?
+        !!@running
+      end
+
+      def executed?
+        !!@executed
+      end
+
+      def halted?
+        !!@halted
+      end
+
+      def unimportant?
+        command.unimportant?
+      end
+
+      def failed_but_unimportant?
+        executed? && !@success && unimportant?
+      end
+
+      def parallel_id
+        command.parallel_id
+      end
+
+      def parallel?
+        command.parallel?
+      end
+
+      def only_when_failed?
+        command.only_when_failed?
+      end
+
+      def forced?
+        command.forced?
+      end
+
+      def name
+        command.name
+      end
+
+    end
+  end
+end

data/lib/scripted/running/run_commands.rb

@@ -0,0 +1,98 @@
+module Scripted
+  module Running
+    class RunCommands
+
+      attr_reader :logger
+
+      attr_reader :started_at, :ended_at, :runtime
+
+      def initialize(logger)
+        @logger = logger
+        @executed = false
+        @halted = false
+        @running = false
+      end
+
+      def run(commands)
+        logged commands do
+          per_parallel_id commands do |parallel_commands|
+            threads = []
+            parallel_commands.each do |command|
+              if should_execute?(command)
+                threads << Thread.new do
+                  command.execute!(self)
+                end
+              end
+            end
+            threads.each(&:join)
+          end
+        end
+      end
+
+      def completed
+        @completed ||= []
+      end
+
+      def done(command)
+        logger.done(command)
+        completed << command
+      end
+
+      def failed?
+        completed.any?(&:failed?)
+      end
+
+      def halt!(command)
+        logger.halted(command)
+        @halted = true
+      end
+
+      def halted?
+        @halted
+      end
+
+      def running?
+        @running
+      end
+
+      def executed?
+        @executed
+      end
+
+      private
+
+      # these are re-sorted, because in Ruby 1.8, hashes aren't sorted
+      def per_parallel_id(commands)
+        commands.group_by(&:parallel_id).values.sort_by { |commands|
+          commands.first.parallel_id
+        }.each { |commands|
+          yield commands
+        }
+      end
+
+      def logged(commands)
+        @started_at = Time.now
+        @running = true
+        logger.start(commands, self)
+        yield
+      ensure
+        @executed = true
+        @running = false
+        @ended_at = Time.now
+        @runtime = @ended_at - @started_at
+        logger.stop(commands, self)
+      end
+
+      def should_execute?(command)
+        if halted?
+          command.forced? or command.only_when_failed?
+        elsif failed?
+          true
+        else
+          not command.only_when_failed?
+        end
+      end
+
+    end
+  end
+end

data/lib/scripted/running/select_commands.rb

@@ -0,0 +1,22 @@
+require "scripted/running/run_command"
+
+module Scripted
+  module Running
+    class SelectCommands
+
+      attr_reader :configuration, :logger
+
+      def initialize(configuration, logger)
+        @configuration = configuration
+        @logger = logger
+      end
+
+      def commands(group_names)
+        group_names = [:default] if group_names.empty?
+        groups = configuration.groups.values_at(*group_names.map(&:to_sym))
+        groups.map { |group| group.commands }.flatten.map { |command| RunCommand.new(command, logger) }
+      end
+
+    end
+  end
+end

data/lib/scripted/version.rb

@@ -0,0 +1,3 @@
+module Scripted
+  VERSION = "0.0.1"
+end

data/scripted.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/scripted/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["iain"]
+  gem.email         = ["iain@iain.nl"]
+  gem.description   = %q{Easily specify which scripts to run, which ones to run in parallel, control their exit status and stream their output to a websockt.}
+  gem.summary       = %q{A framework for organizing scripts}
+  gem.homepage      = "https://github.com/iain/scripted"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "scripted"
+  gem.require_paths = ["lib"]
+  gem.version       = Scripted::VERSION
+
+  gem.add_runtime_dependency "childprocess", ">= 0.3.4"
+
+  # For testing
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "cucumber"
+  gem.add_development_dependency "aruba"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "fivemat"
+
+  # For the websockets example
+  gem.add_development_dependency "thin"
+  gem.add_development_dependency "faye"
+  gem.add_development_dependency "launchy"
+  gem.add_development_dependency "sinatra"
+  gem.add_development_dependency "coffee-script"
+  gem.add_development_dependency "sass"
+
+end