jamie 0.1.0.alpha21 → 0.1.0.beta1

data/.travis.yml

@@ -1,6 +1,14 @@
 language: ruby
+
 rvm:
   - 1.9.3
+  - jruby-19mode
+  - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+
 notifications:
   irc:
     channels:

data/Rakefile

@@ -1,24 +1,38 @@
 require 'bundler/gem_tasks'
-require 'cane/rake_task'
 require 'rake/testtask'
-require 'tailor/rake_task'
-
-desc "Run cane to check quality metrics"
-Cane::RakeTask.new do |cane|
-  cane.abc_exclude = %w(
-    Jamie::RakeTasks#define
-    Jamie::ThorTasks#define
-    Jamie::CLI#pry_prompts
-  )
-  cane.style_exclude = %w(
-    lib/vendor/hash_recursive_merge.rb
-  )
-  cane.doc_exclude = %w(
-    lib/vendor/hash_recursive_merge.rb
-  )
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
 end
 
-Tailor::RakeTask.new
+task :default => [ :test ]
+
+unless RUBY_ENGINE == 'jruby'
+  require 'cane/rake_task'
+  require 'tailor/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new do |cane|
+    cane.abc_exclude = %w(
+      Jamie::RakeTasks#define
+      Jamie::ThorTasks#define
+      Jamie::CLI#pry_prompts
+      Jamie::Instance#synchronize_or_call
+    )
+    cane.style_exclude = %w(
+      lib/vendor/hash_recursive_merge.rb
+    )
+    cane.doc_exclude = %w(
+      lib/vendor/hash_recursive_merge.rb
+    )
+  end
+
+  Tailor::RakeTask.new
+
+  Rake::Task[:default].enhance [ :cane, :tailor ]
+end
 
 desc "Display LOC stats"
 task :stats do
@@ -28,10 +42,4 @@ task :stats do
   sh "countloc -r spec"
 end
 
-Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.test_files = FileList['spec/**/*_spec.rb']
-  t.verbose = true
-end
-
-task :default => [ :test, :cane, :tailor, :stats ]
+Rake::Task[:default].enhance [ :stats ]

data/jamie.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = ">= 1.9.1"
 
+  gem.add_dependency 'celluloid'
   gem.add_dependency 'thor'
   gem.add_dependency 'net-ssh'
   gem.add_dependency 'net-scp'

data/lib/jamie.rb

@@ -18,6 +18,7 @@
 
 require 'base64'
 require 'benchmark'
+require 'celluloid'
 require 'delegate'
 require 'digest'
 require 'erb'
@@ -29,6 +30,7 @@ require 'net/https'
 require 'net/scp'
 require 'net/ssh'
 require 'pathname'
+require 'thread'
 require 'socket'
 require 'stringio'
 require 'vendor/hash_recursive_merge'
@@ -41,6 +43,8 @@ module Jamie
   class << self
 
     attr_accessor :logger
+    attr_accessor :crashes
+    attr_accessor :mutex
 
     # Returns the root path of the Jamie gem source code.
     #
@@ -49,10 +53,15 @@ module Jamie
       @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
     end
 
+    def crashes?
+      ! crashes.empty?
+    end
+
     def default_logger
       env_log = ENV['JAMIE_LOG'] && ENV['JAMIE_LOG'].downcase.to_sym
+      env_log = Util.to_logger_level(env_log) unless env_log.nil?
 
-      Logger.new(:console => STDOUT, :level => env_log)
+      Logger.new(:stdout => STDOUT, :level => env_log)
     end
   end
 
@@ -101,9 +110,7 @@ module Jamie
     # @return [Array<Instance>] all instances, resulting from all platform and
     #   suite combinations
     def instances
-      @instances ||= Collection.new(suites.map { |suite|
-        platforms.map { |platform| new_instance(suite, platform) }
-      }.flatten)
+      instances_array(load_instances)
     end
 
     # @return [String] path to the Jamie YAML file
@@ -162,6 +169,24 @@ module Jamie
 
     private
 
+    def load_instances
+      return @instance_count if @instance_count && @instance_count > 0
+
+      results = []
+      suites.product(platforms).each_with_index do |arr, index|
+        results << new_instance(arr[0], arr[1], index)
+      end
+      @instance_count = results.size
+    end
+
+    def instances_array(instance_count)
+      results = []
+      instance_count.times do |index|
+        results << Celluloid::Actor["instance_#{index}".to_sym]
+      end
+      Collection.new(results)
+    end
+
     def new_suite(hash)
       path_hash = {
         :data_bags_path => calculate_path("data_bags", hash[:name]),
@@ -182,19 +207,24 @@ module Jamie
       Driver.for_plugin(hash[:driver_plugin], hash[:driver_config])
     end
 
-    def new_instance(suite, platform)
-      log_root = File.expand_path(File.join(jamie_root, ".jamie", "logs"))
+    def new_instance(suite, platform, index)
       platform_hash = platform_driver_hash(platform.name)
       driver = new_driver(merge_driver_hash(platform_hash))
       FileUtils.mkdir_p(log_root)
 
-      Instance.new(
+      supervisor = Instance.supervise_as(
+        "instance_#{index}".to_sym,
         :suite    => suite,
         :platform => platform,
         :driver   => driver,
         :jr       => Jr.new(suite.name),
-        :logger   => new_instance_logger(log_root)
+        :logger   => new_instance_logger(index)
       )
+      supervisor.actors.first
+    end
+
+    def log_root
+      File.expand_path(File.join(jamie_root, ".jamie", "logs"))
     end
 
     def platform_driver_hash(platform_name)
@@ -203,13 +233,14 @@ module Jamie
       h.select { |key, value| [ :driver_plugin, :driver_config ].include?(key) }
     end
 
-    def new_instance_logger(log_root)
+    def new_instance_logger(index)
       level = Util.to_logger_level(self.log_level)
+      color = Color::COLORS[index % Color::COLORS.size].to_sym
 
       lambda do |name|
         logfile = File.join(log_root, "#{name}.log")
 
-        Logger.new(:stdout => STDOUT, :logdev => logfile,
+        Logger.new(:stdout => STDOUT, :color => color, :logdev => logfile,
           :level => level, :progname => name)
       end
     end
@@ -276,6 +307,31 @@ module Jamie
   # Default log level verbosity
   DEFAULT_LOG_LEVEL = :info
 
+  module Color
+    ANSI = {
+      :reset => 0, :black => 30, :red => 31, :green => 32, :yellow => 33,
+      :blue => 34, :magenta => 35, :cyan => 36, :white => 37,
+      :bright_black => 30, :bright_red => 31, :bright_green => 32,
+      :bright_yellow => 33, :bright_blue => 34, :bright_magenta => 35,
+      :bright_cyan => 36, :bright_white => 37
+    }.freeze
+
+    COLORS = %w(
+      cyan yellow green magenta red blue bright_cyan bright_yellow
+      bright_green bright_magenta bright_red, bright_blue
+    ).freeze
+
+    def self.escape(name)
+      return "" if name.nil?
+      return "" unless ansi = ANSI[name]
+      "\e[#{ansi}m"
+    end
+
+    def self.colorize(str, name)
+      "#{escape(name)}#{str}#{escape(:reset)}"
+    end
+  end
+
   # Logging implementation for Jamie. By default the console/stdout output will
   # be displayed differently than the file log output. Therefor, this class
   # wraps multiple loggers that conform to the stdlib `Logger` class behavior.
@@ -286,10 +342,12 @@ module Jamie
     include ::Logger::Severity
 
     def initialize(options = {})
+      color = options[:color] || :bright_white
+
       @loggers = []
       @loggers << logdev_logger(options[:logdev]) if options[:logdev]
-      @loggers << stdout_logger(options[:stdout]) if options[:stdout]
-      @loggers << stdout_logger(STDOUT) if @loggers.empty?
+      @loggers << stdout_logger(options[:stdout], color) if options[:stdout]
+      @loggers << stdout_logger(STDOUT, color) if @loggers.empty?
 
       self.progname = options[:progname] || "Jamie"
       self.level = options[:level] || default_log_level
@@ -318,10 +376,10 @@ module Jamie
       Util.to_logger_level(Jamie::DEFAULT_LOG_LEVEL)
     end
 
-    def stdout_logger(stdout)
+    def stdout_logger(stdout, color)
       logger = StdoutLogger.new(stdout)
       logger.formatter = proc do |severity, datetime, progname, msg|
-        "#{msg}\n"
+        Color.colorize("#{msg}\n", color)
       end
       logger
     end
@@ -500,8 +558,13 @@ module Jamie
   # @author Fletcher Nichol <fnichol@nichol.ca>
   class Instance
 
+    include Celluloid
     include Logging
 
+    class << self
+      attr_accessor :mutexes
+    end
+
     # @return [Suite] the test suite configuration
     attr_reader :suite
 
@@ -538,6 +601,7 @@ module Jamie
       @logger = logger.is_a?(Proc) ? logger.call(name) : logger
 
       @driver.instance = self
+      setup_driver_mutex
     end
 
     # @return [String] name of this instance
@@ -643,7 +707,7 @@ module Jamie
         destroy if destroy_mode == :passing
       end
       info "Finished testing #{to_str} (#{elapsed.real} seconds)."
-      self
+      Actor.current
     ensure
       destroy if destroy_mode == :always
     end
@@ -670,6 +734,15 @@ module Jamie
       end
     end
 
+    def setup_driver_mutex
+      if driver.class.serial_actions
+        Jamie.mutex.synchronize do
+          self.class.mutexes ||= Hash.new
+          self.class.mutexes[driver.class] = Mutex.new
+        end
+      end
+    end
+
     def transition_to(desired)
       result = nil
       FSM.actions(last_action, desired).each do |transition|
@@ -704,13 +777,13 @@ module Jamie
       info("Finished #{output_verb.downcase} #{to_str}" +
            " (#{elapsed.real} seconds).")
       yield if block_given?
-      self
+      Actor.current
     end
 
-    def action(what)
+    def action(what, &block)
       state = load_state
       elapsed = Benchmark.measure do
-        yield state if block_given?
+        synchronize_or_call(what, state, &block)
       end
       state[:last_action] = what.to_s
       elapsed
@@ -718,6 +791,18 @@ module Jamie
       dump_state(state)
     end
 
+    def synchronize_or_call(what, state, &block)
+      if Array(driver.class.serial_actions).include?(what)
+        debug("#{to_str} is synchronizing on #{driver.class}##{what}")
+        self.class.mutexes[driver.class].synchronize do
+          debug("#{to_str} is messaging #{driver.class}##{what}")
+          block.call(state)
+        end
+      else
+        block.call(state)
+      end
+    end
+
     def load_state
       if File.exists?(statefile)
         Util.symbolized_hash(YAML.load_file(statefile))
@@ -1037,6 +1122,10 @@ module Jamie
 
       attr_writer :instance
 
+      class << self
+        attr_reader :serial_actions
+      end
+
       def initialize(config = {})
         @config = config
         self.class.defaults.each do |attr, value|
@@ -1096,6 +1185,9 @@ module Jamie
 
       attr_reader :config, :instance
 
+      ACTION_METHODS = %w{create converge setup verify destroy}.
+        map(&:to_sym).freeze
+
       def logger
         instance.logger
       end
@@ -1122,6 +1214,17 @@ module Jamie
       def self.default_config(attr, value)
         defaults[attr] = value
       end
+
+      def self.no_parallel_for(*methods)
+        Array(methods).each do |meth|
+          if ! ACTION_METHODS.include?(meth)
+            raise ArgumentError, "##{meth} is not a whitelisted method."
+          end
+        end
+
+        @serial_actions ||= []
+        @serial_actions += methods
+      end
     end
 
     # Base class for a driver that uses SSH to communication with an instance.
@@ -1435,4 +1538,15 @@ module Jamie
   end
 end
 
+# Initialize the base logger and use that for Celluloid's logger
 Jamie.logger = Jamie.default_logger
+Celluloid.logger = Jamie.logger
+
+# Setup a collection of instance crash exceptions for error reporting
+Jamie.crashes = []
+Celluloid.exception_handler do |exception|
+  Jamie.logger.debug("An instance crashed because of #{exception.inspect}")
+  Jamie.crashes << exception
+end
+
+Jamie.mutex = Mutex.new

data/lib/jamie/cli.rb

@@ -35,6 +35,7 @@ module Jamie
     # Constructs a new instance.
     def initialize(*args)
       super
+      $stdout.sync = true
       @config = Jamie::Config.new(ENV['JAMIE_YAML'])
     end
 
@@ -46,9 +47,11 @@ module Jamie
 
     [:create, :converge, :setup, :verify, :destroy].each do |action|
       desc(
-        "#{action} [(all|<REGEX>)]",
+        "#{action} [(all|<REGEX>)] [opts]",
         "#{action.capitalize} one or more instances"
       )
+      method_option :parallel, :aliases => "-p", :type => :boolean,
+        :desc => "Perform action against all matching instances in parallel"
       define_method(action) { |*args| exec_action(action) }
     end
 
@@ -63,17 +66,26 @@ module Jamie
       * always: instances will always be destroyed afterwards.\n
       * never: instances will never be destroyed afterwards.
     DESC
+    method_option :parallel, :aliases => "-p", :type => :boolean,
+      :desc => "Perform action against all matching instances in parallel"
     method_option :destroy, :aliases => "-d", :default => "passing",
       :desc => "Destroy strategy to use after testing (passing, always, never)."
     def test(*args)
+      if ! %w{passing always never}.include?(options[:destroy])
+        raise ArgumentError, "Destroy mode must be passing, always, or never."
+      end
+
       banner "Starting Jamie"
       elapsed = Benchmark.measure do
-        destroy_mode = options[:destroy]
-        if ! %w{passing always never}.include?(options[:destroy])
-          raise ArgumentError, "Destroy mode must be passing, always, or never."
+        destroy_mode = options[:destroy].to_sym
+        @task = :test
+        results = parse_subcommand(args.first)
+
+        if options[:parallel]
+          run_parallel(results, destroy_mode)
+        else
+          run_serial(results, destroy_mode)
         end
-        result = parse_subcommand(args.first)
-        Array(result).each { |instance| instance.test(destroy_mode.to_sym) }
       end
       banner "Jamie is finished. (#{elapsed.real} seconds)"
     end
@@ -132,12 +144,21 @@ module Jamie
       banner "Starting Jamie"
       elapsed = Benchmark.measure do
         @task = action
-        result = parse_subcommand(args.first)
-        Array(result).each { |instance| instance.send(task) }
+        results = parse_subcommand(args.first)
+        options[:parallel] ? run_parallel(results) : run_serial(results)
       end
       banner "Jamie is finished. (#{elapsed.real} seconds)"
     end
 
+    def run_serial(instances, *args)
+      Array(instances).map { |i| i.public_send(task, *args) }
+    end
+
+    def run_parallel(instances, *args)
+      futures = Array(instances).map { |i| i.future.public_send(task) }
+      futures.map { |i| i.value }
+    end
+
     def parse_subcommand(arg = nil)
       arg == "all" ? get_all_instances : get_filtered_instances(arg)
     end

data/lib/jamie/version.rb

@@ -18,5 +18,5 @@
 
 module Jamie
 
-  VERSION = "0.1.0.alpha21"
+  VERSION = "0.1.0.beta1"
 end

data/spec/jamie_spec.rb

@@ -28,8 +28,10 @@ end
 SimpleCov.start 'gem'
 
 require 'fakefs/spec_helpers'
+require 'logger'
 require 'minitest/autorun'
 require 'ostruct'
+require 'stringio'
 
 require 'jamie'
 require 'jamie/driver/dummy'
@@ -391,6 +393,10 @@ describe Jamie::Instance do
 
   let(:instance) { Jamie::Instance.new(opts) }
 
+  before do
+    Celluloid.logger = Logger.new(StringIO.new)
+  end
+
   it "raises an ArgumentError if suite is missing" do
     opts.delete(:suite)
     proc { Jamie::Instance.new(opts) }.must_raise ArgumentError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jamie
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha21
+  version: 0.1.0.beta1
   prerelease: 6
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-09 00:00:00.000000000 Z
+date: 2013-01-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement