acts_as_executor 1.0.0.beta2 → 1.0.0.rc1

data/lib/acts_as_executor/validators/class_exists_validator.rb

@@ -1,7 +1,7 @@
 class ClassExistsValidator < ActiveModel::EachValidator
   def validate_each record, attribute, value
     begin
-      value.constantize.new
+      Object.const_get(value).new
     rescue NameError
       record.errors[attribute] << "does not exist as a Class"
     end

data/lib/acts_as_executor/validators/class_includes_validator.rb

@@ -0,0 +1,10 @@
+class ClassIncludesValidator < ActiveModel::EachValidator
+  def validate_each record, attribute, value
+    begin
+      throw TypeError unless Object.const_get(value).new.kind_of? options[:includes]
+    rescue NameError
+    rescue TypeError
+      record.errors[attribute] << "does not include " + options[:includes].to_s
+    end
+  end
+end

data/lib/acts_as_executor/version.rb

@@ -1,3 +1,3 @@
 module ActsAsExecutor
-  VERSION = "1.0.0.beta2"
+  VERSION = "1.0.0.rc1"
 end

data/lib/generators/{executor_generator.rb → acts_as_executor_generator.rb}

@@ -1,12 +1,8 @@
-class ExecutorGenerator < Rails::Generators::NamedBase
+class ActsAsExecutorGenerator < Rails::Generators::NamedBase
   include Rails::Generators::Migration
 
   source_root File.expand_path("../templates", __FILE__)
 
-  def initializer
-    template File.join("initializer", "acts_as_executor.rb"), File.join("config", "initializers", "acts_as_executor.rb")
-  end
-
   def models
     template File.join("models", "executor.rb"), File.join("app", "models", file_name + ".rb")
     template File.join("models", "executor_task.rb"), File.join("app", "models", file_name + "_task.rb")

data/lib/generators/templates/migration/create_executors.rb

@@ -2,8 +2,8 @@ class Create<%= class_name.pluralize %> < ActiveRecord::Migration
   def self.up
     create_table :<%= table_name %> do |t|
       t.string   :name
-      t.string   :kind
-      t.integer  :size
+      t.integer  :max_tasks
+      t.boolean  :schedulable
       t.timestamps
     end
 

data/spec/acts_as_executor_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe ActsAsExecutor do
+	it { ActsAsExecutor::VERSION.should == "1.0.0.rc1" }
+
+  describe "#rails_initialized?" do
+    context "when rails initialized" do
+      it "should return true" do
+        $0 = "rails"
+
+        ActsAsExecutor.rails_initialized?.should be_true
+      end
+    end
+    context "when rails not initialized" do
+      it "should return false" do
+        $0 = "rake"
+
+        ActsAsExecutor.rails_initialized?.should be_false
+      end
+    end
+  end
+end

data/spec/common/future_task_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Common::FutureTask do
+  before(:each) { @model = ActsAsExecutor::Common::FutureTask.new Clazz.make, nil }
+
+  it { @model.should be_a Java::java.util.concurrent.FutureTask }
+
+  describe "#done" do
+    context "when done handler exists" do
+      it "should invoke handler" do
+        handler = double "Handler"
+        handler.stub :done_handler
+        @model.done_handler = handler.method :done_handler
+
+        handler.should_receive :done_handler
+
+        @model.done
+      end
+    end
+  end
+end

data/spec/common/instance_support_methods_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Common::InstanceSupportMethods do
+  before(:each) { @model = InstanceSupportMethods.make }
+
+  it { @model.should_not allow_public_access_for_methods :log_statement, :log_message }
+
+  describe "#log_statement" do
+    it "should return a string" do
+      @model.send(:log_statement, "name", "statement").should == log_statement("name", "statement")
+    end
+  end
+
+  describe "#log_message" do
+    it "should return a string" do
+      @model.send(:log_message, "name", "doing", 1.to_s, "clazz", "message").should == log_message("name", "doing", 1.to_s, "clazz", "message")
+    end
+
+    context "when message is a hash" do
+      it "should return a string" do
+        @model.send(:log_message, "name", "doing", 1.to_s, "clazz", {:attribute_one => "attribute_one_value", :attribute_two => "attribute_two_value"}).should == log_message("name", "doing", 1.to_s, "clazz", {:attribute_one => "attribute_one_value", :attribute_two => "attribute_two_value"})
+      end
+    end
+  end
+end

data/spec/common/units_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Common::Units do
+  it { ActsAsExecutor::Common::Units::NANOSECONDS.should == "nanoseconds" }
+  it { ActsAsExecutor::Common::Units::MICROSECONDS.should == "microseconds" }
+  it { ActsAsExecutor::Common::Units::MILLISECONDS.should == "milliseconds" }
+  it { ActsAsExecutor::Common::Units::SECONDS.should == "seconds" }
+  it { ActsAsExecutor::Common::Units::MINUTES.should == "minutes" }
+  it { ActsAsExecutor::Common::Units::HOURS.should == "hours" }
+  it { ActsAsExecutor::Common::Units::DAYS.should == "days" }
+  it { ActsAsExecutor::Common::Units::ALL.should include ActsAsExecutor::Common::Units::NANOSECONDS,
+                                                         ActsAsExecutor::Common::Units::MICROSECONDS,
+                                                         ActsAsExecutor::Common::Units::MILLISECONDS,
+                                                         ActsAsExecutor::Common::Units::SECONDS,
+                                                         ActsAsExecutor::Common::Units::MINUTES,
+                                                         ActsAsExecutor::Common::Units::HOURS,
+                                                         ActsAsExecutor::Common::Units::DAYS
+  }
+end

data/spec/executor/factory_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Executor::Factory do
+  describe "#create" do
+    it "should return a scheduled executor" do
+      executor = ActsAsExecutor::Executor::Factory.create 5, true
+
+      executor.should be_a Java::java.util.concurrent.ScheduledExecutorService
+      executor.core_pool_size.should == 5
+    end
+
+    it "should return a single scheduled executor" do
+      ActsAsExecutor::Executor::Factory.create(1, true).should be_a Java::java.util.concurrent.ScheduledExecutorService
+    end
+
+    it "should return a cached executor" do
+      ActsAsExecutor::Executor::Factory.create(nil, nil).should be_a Java::java.util.concurrent.ExecutorService
+    end
+
+    it "should return a fixed executor" do
+      executor = ActsAsExecutor::Executor::Factory.create 5, nil
+
+      executor.should be_a Java::java.util.concurrent.ExecutorService
+      executor.core_pool_size.should == 5
+    end
+
+    it "should return a single executor" do
+      ActsAsExecutor::Executor::Factory.create(1, nil).should be_a Java::java.util.concurrent.ExecutorService
+    end
+  end
+end

data/spec/executor/model/class_methods_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Executor::Model::ClassMethods do
+  subject { ActiveRecord::Base }
+  it { should be_a ActsAsExecutor::Executor::Model::ClassMethods }
+
+  describe "#acts_as_executor" do
+    subject { Executor }
+    it { should include ActsAsExecutor::Common::InstanceSupportMethods }
+    it { should include ActsAsExecutor::Executor::Model::InstanceMethods }
+    it { should include ActsAsExecutor::Executor::Model::InstanceSupportMethods }
+
+    context "when arguments exist" do
+      before :all do
+        @log = Logger.new
+
+        ExecutorWithoutActsAsExecutor.acts_as_executor :log => @log
+      end
+
+      it "should set log" do
+        Rails.should_not_receive(:logger)
+        ExecutorWithoutActsAsExecutor.log.should == @log
+      end
+    end
+  end
+
+  describe "#log" do
+    after(:each) { Executor.log = Logger.new }
+
+    it "should return log" do
+      log = Logger.new
+      Executor.log = log
+
+      Rails.should_not_receive(:logger)
+      Executor.log.should == log
+    end
+
+    context "when log has not been set" do
+      it "should return Rails.logger" do
+        log = Logger.new
+
+        Executor.log = nil
+
+        Rails.should_receive(:logger).at_most(:twice).and_return log
+        Executor.log.should == Rails.logger
+      end
+    end
+  end
+end

data/spec/executor/model/instance_methods_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Executor::Model::InstanceMethods do
+  before(:each) { @model = Executor.make }
+
+  it { @model.should_not allow_public_access_for_methods :startup, :execute, :shutdown, :forced_shutdown }
+
+  describe "#startup" do
+    it "should create executor" do
+      @model.send(:executor).should be_nil
+
+      @model.send(:log).should_receive(:debug).with log_statement(@model.name, "startup triggered")
+      @model.send(:log).should_receive(:info).with log_statement(@model.name, "started")
+
+      @model.send :startup
+
+      @model.send(:executor).should_not be_nil
+    end
+  end
+
+  describe "#execute" do
+    before(:each) { @clazz = Clazz.make }
+    after(:each) { @model.send(:executor).shutdown }
+
+    it "should execute a task" do
+      @model.send :startup
+
+      @model.send(:log).should_receive(:debug).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "for execution (one time)")
+      @model.send(:log).should_receive(:info).with log_message(@model.name, "enqueued", 1.to_s, @clazz.class.name)
+
+      future = @model.send :execute, @clazz, 1.to_s
+      future.get
+
+      future.is_done.should be_true
+    end
+
+    it "should execute a one shot task" do
+      @model = Executor.make :max_tasks => 1, :schedulable => true
+      @model.send :startup
+
+      @model.send(:log).should_receive(:debug).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "for execution (one shot)")
+      @model.send(:log).should_receive(:info).with log_message(@model.name, "enqueued", 1.to_s, @clazz.class.name)
+
+      future = @model.send :execute, @clazz, 1.to_s, ActsAsExecutor::Task::Schedules::ONE_SHOT, 0, nil, ActsAsExecutor::Common::Units::SECONDS
+      future.get
+
+      future.is_done.should be_true
+    end
+
+    it "should execute a fixed delay task" do
+      @model = Executor.make :max_tasks => 1, :schedulable => true
+      @model.send :startup
+
+      @model.send(:log).should_receive(:debug).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "for execution (fixed delay)")
+      @model.send(:log).should_receive(:info).with log_message(@model.name, "enqueued", 1.to_s, @clazz.class.name)
+
+      future = @model.send :execute, @clazz, 1.to_s, ActsAsExecutor::Task::Schedules::FIXED_DELAY, 0, 2, ActsAsExecutor::Common::Units::SECONDS
+
+      future.should_not be_nil
+    end
+
+    it "should execute a fixed rate task" do
+      @model = Executor.make :max_tasks => 1, :schedulable => true
+      @model.send :startup
+
+      @model.send(:log).should_receive(:debug).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "for execution (fixed rate)")
+      @model.send(:log).should_receive(:info).with log_message(@model.name, "enqueued", 1.to_s, @clazz.class.name)
+
+      future = @model.send :execute, @clazz, 1.to_s, ActsAsExecutor::Task::Schedules::FIXED_RATE, 0, 2, ActsAsExecutor::Common::Units::SECONDS
+
+      future.should_not be_nil
+    end
+
+    context "when rejected execution exception is thrown" do
+      it "should log exception" do
+        @model.send :startup
+
+        @model.send(:log).should_receive(:debug).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "for execution (one time)")
+        @model.send(:executor).should_receive(:execute).and_raise Java::java.util.concurrent.RejectedExecutionException.new
+        @model.send(:log).should_receive(:warn).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "encountered a rejected execution exception")
+
+        @model.send :execute, @clazz, 1.to_s
+      end
+    end
+
+    context "when any other exception is thrown" do
+      it "should log exception" do
+        @model = Executor.make :max_tasks => 1, :schedulable => true
+        @model.send :startup
+
+        @model.send(:log).should_receive(:debug).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "for execution (one time)")
+        @model.send(:log).should_receive(:error).with log_message(@model.name, "preparing", 1.to_s, @clazz.class.name, "encountered an unexpected exception. java.lang.IllegalArgumentException: No enum const class java.util.concurrent.TimeUnit.RANDOM")
+
+        @model.send :execute, @clazz, 1.to_s, nil, nil, nil, "random"
+      end
+    end
+  end
+
+  describe "#shutdown" do
+    before(:each) { @model.send :startup }
+
+    it "should shutdown executor" do
+      @model.send(:log).should_receive(:debug).with log_statement(@model.name, "shutdown triggered")
+      @model.send(:executor).should_receive :shutdown
+      @model.send(:log).should_receive(:info).with log_statement(@model.name, "shutdown")
+
+      @model.send :shutdown
+
+      @model.send(:executor).should be_nil
+    end
+
+    context "when security exception is thrown" do
+      it "should force shutdown executor" do
+        @model.send(:log).should_receive(:debug).with log_statement(@model.name, "shutdown triggered")
+        @model.send(:executor).should_receive(:shutdown).and_raise Java::java.lang.SecurityException.new
+        @model.send(:log).should_receive(:warn).with log_statement(@model.name, "shutdown encountered a security exception")
+        @model.should_receive :forced_shutdown
+
+        @model.send :shutdown
+      end
+    end
+  end
+
+  describe "#forced_shutdown" do
+    before(:each) { @model.send :startup }
+
+    it "should shutdown executor" do
+      @model.send(:log).should_receive(:debug).with log_statement(@model.name, "forced shutdown triggered")
+      @model.send(:executor).should_receive :shutdown_now
+      @model.send(:log).should_receive(:info).with log_statement(@model.name, "forced shutdown")
+
+      @model.send :forced_shutdown
+
+      @model.send(:executor).should be_nil
+    end
+
+    context "when security exception is thrown" do
+      it "should log exception" do
+        @model.send(:log).should_receive(:debug).with log_statement(@model.name, "forced shutdown triggered")
+        @model.send(:executor).should_receive(:shutdown_now).and_raise Java::java.lang.SecurityException.new
+        @model.send(:log).should_receive(:error).with log_statement(@model.name, "forced shutdown encountered a security exception")
+        @model.send(:log).should_receive(:fatal).with log_statement(@model.name, "forced shutdown failure")
+
+        @model.send :forced_shutdown
+
+        @model.send(:executor).should be_nil
+      end
+    end
+  end
+end

data/spec/executor/model/instance_support_methods_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe ActsAsExecutor::Executor::Model::InstanceSupportMethods do
+  before(:each) { @model = Executor.make }
+
+  it { @model.should_not allow_public_access_for_methods :executor, :executor=, :startupable?, :shutdownable?, :log }
+
+  describe "#executor" do
+    it "should return executor" do
+      executor = double "Executor"
+      @model.send :executor=, executor
+
+      @model.send(:executor).should == executor
+    end
+
+    context "when id has not been set" do
+      it "should raise an argument error" do
+        @model.id = nil
+
+        expect { @model.send :executor=, true }.to raise_error ArgumentError, "cannot reference executor against nil id"
+      end
+    end
+  end
+
+  describe "#startupable?" do
+    context "when rails initialized" do
+      before(:each) { ActsAsExecutor.should_receive(:rails_initialized?).at_most(:once).and_return true }
+
+      context "when executor has not been set" do
+        it "should return true" do
+          @model.should be_startupable
+        end
+      end
+
+      context "when executor has been set" do
+        it "should return false" do
+          @model.send :startup
+
+          @model.should_not be_startupable
+        end
+      end
+    end
+  end
+
+  describe "#shutdownable?" do
+    context "when rails initialized" do
+      before(:each) { ActsAsExecutor.should_receive(:rails_initialized?).at_most(:once).and_return true }
+
+      context "when executor has been set" do
+        it "should return true" do
+          @model.send :startup
+
+          @model.should be_shutdownable
+        end
+      end
+
+      context "when executor has not been set" do
+        it "should return false" do
+          @model.should_not be_shutdownable
+        end
+      end
+    end
+  end
+
+  describe "#log" do
+    it "should return class log" do
+      @model.send(:log).should == Executor.log
+    end
+  end
+end