taskinator 0.0.15 → 0.0.16

data/lib/taskinator/queues/sidekiq.rb

@@ -9,11 +9,12 @@ module Taskinator
 
     class SidekiqAdapter
       def initialize(config={})
-        @config = {
-          :process_queue => :default,
-          :task_queue => :default,
-          :job_queue => :default
-        }.merge(config)
+        @config = Taskinator::Queues::DefaultConfig.merge(config)
+      end
+
+      def enqueue_create_process(definition, uuid, args)
+        queue = definition.queue || @config[:definition_queue]
+        ProcessWorker.client_push('class' => CreateProcessWorker, 'args' => [definition.name, uuid, Taskinator::Persistence.serialize(args)], 'queue' => queue)
       end
 
       def enqueue_process(process)
@@ -31,6 +32,14 @@ module Taskinator
         JobWorker.client_push('class' => JobWorker, 'args' => [job.uuid], 'queue' => queue)
       end
 
+      class CreateProcessWorker
+        include ::Sidekiq::Worker
+
+        def perform(definition_name, uuid, args)
+          Taskinator::CreateProcessWorker.new(definition_name, uuid, args).perform
+        end
+      end
+
       class ProcessWorker
         include ::Sidekiq::Worker
 

data/lib/taskinator/queues.rb

@@ -1,6 +1,13 @@
 module Taskinator
   module Queues
 
+    DefaultConfig = {
+      :definition_queue => :default,
+      :process_queue => :default,
+      :task_queue => :default,
+      :job_queue => :default,
+    }.freeze
+
     def self.create_adapter(adapter, config={})
       begin
         LoggedAdapter.new(send("create_#{adapter}_adapter", config))
@@ -22,6 +29,11 @@ module Taskinator
         adapter
       end
 
+      def enqueue_create_process(definition, uuid, args)
+        Taskinator.logger.info("Enqueuing process creation for #{definition}")
+        adapter.enqueue_create_process(definition, uuid, args)
+      end
+
       def enqueue_process(process)
         Taskinator.logger.info("Enqueuing process #{process}")
         adapter.enqueue_process(process)

data/lib/taskinator/task.rb

@@ -24,6 +24,7 @@ module Taskinator
     attr_reader :process
     attr_reader :uuid
     attr_reader :options
+    attr_reader :queue
 
     # the next task in the sequence
     attr_accessor :next
@@ -34,6 +35,7 @@ module Taskinator
       @uuid = SecureRandom.uuid
       @process = process
       @options = options
+      @queue = options.delete(:queue)
     end
 
     def accept(visitor)
@@ -41,6 +43,7 @@ module Taskinator
       visitor.visit_process_reference(:process)
       visitor.visit_task_reference(:next)
       visitor.visit_args(:options)
+      visitor.visit_attribute(:queue)
     end
 
     def <=>(other)
@@ -51,10 +54,6 @@ module Taskinator
       "#<#{self.class.name}:#{uuid}>"
     end
 
-    def queue
-      options[:queue]
-    end
-
     workflow do
       state :initial do
         event :enqueue, :transitions_to => :enqueued
@@ -150,7 +149,9 @@ module Taskinator
 
       def start
         # ASSUMPTION: when the method returns, the task is considered to be complete
-        executor.send(method, *args)
+        Taskinator.instrumenter.instrument(:execute_step_task, :uuid => uuid) do
+          executor.send(method, *args)
+        end
         @is_complete = true
       end
 
@@ -189,8 +190,10 @@ module Taskinator
         Taskinator.queue.enqueue_job(self)
       end
 
-      def perform(&block)
-        yield(job, args)
+      def perform
+        Taskinator.instrumenter.instrument(:execute_job_task, :uuid => uuid) do
+          yield(job, args)
+        end
         @is_complete = true
       end
 
@@ -220,7 +223,9 @@ module Taskinator
       end
 
       def start
-        sub_process.start!
+        Taskinator.instrumenter.instrument(:execute_subprocess, :uuid => uuid) do
+          sub_process.start!
+        end
       end
 
       def can_complete_task?
@@ -233,5 +238,13 @@ module Taskinator
         visitor.visit_process(:sub_process)
       end
     end
+
+    # reloads the task from storage
+    # NB: only implemented by LazyLoader so that
+    #   the task can be lazy loaded, thereafter
+    #    it has no effect
+    def reload
+      false
+    end
   end
 end

data/lib/taskinator/task_worker.rb

@@ -1,5 +1,7 @@
 module Taskinator
   class TaskWorker
+    attr_reader :uuid
+
     def initialize(uuid)
       @uuid = uuid
     end
@@ -10,7 +12,7 @@ module Taskinator
       begin
         task.start!
         task.complete! if task.can_complete?
-      rescue Exception => e
+      rescue => e
         Taskinator.logger.error(e)
         task.fail!(e)
         raise e

data/lib/taskinator/tasks.rb

@@ -31,7 +31,7 @@ module Taskinator
       @head.nil?
     end
 
-    def each(&block)
+    def each
       return to_enum(__method__) unless block_given?
 
       current = @head

data/lib/taskinator/version.rb

@@ -1,3 +1,3 @@
 module Taskinator
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/lib/taskinator.rb

@@ -21,6 +21,7 @@ require 'taskinator/process'
 require 'taskinator/task_worker'
 require 'taskinator/job_worker'
 require 'taskinator/process_worker'
+require 'taskinator/create_process_worker'
 
 require 'taskinator/executor'
 require 'taskinator/queues'
@@ -46,7 +47,7 @@ module Taskinator
     ##
     # Configuration for Taskinator client, use like:
     #
-    #   Taskinator.configure_client do |config|
+    #   Taskinator.configure do |config|
     #     config.redis = { :namespace => 'myapp', :pool_size => 1, :url => 'redis://myhost:8877/0' }
     #     config.queue_config = { :process_queue => 'processes', :task_queue => 'tasks' }
     #   end
@@ -101,5 +102,23 @@ module Taskinator
       config = queue_config || {}
       @queue ||= Taskinator::Queues.create_adapter(adapter, config)
     end
+
+    # set the instrumenter to use.
+    # can be ActiveSupport::Notifications
+    def instrumenter
+      @instrumenter ||= NoOpInstrumenter.new
+    end
+    def instrumenter=(value)
+      @instrumenter = value
+    end
+
   end
+
+  class NoOpInstrumenter
+    # just yield to the given block
+    def instrument(event, payload={})
+      yield(payload) if block_given?
+    end
+  end
+
 end

data/spec/examples/queue_adapter_examples.rb

@@ -10,6 +10,16 @@ shared_examples_for "a queue adapter" do |adapter_name, adapter_type|
     expect(Taskinator.queue.adapter).to be_a(adapter_type)
   end
 
+  describe "#enqueue_create_process" do
+    it { expect(subject).to respond_to(:enqueue_create_process) }
+
+    it "should enqueue a create process" do
+      expect {
+        subject.enqueue_create_process(double('definition', :name => 'definition', :queue => nil), 'xx-xx-xx-xx', :foo => :bar)
+      }.to_not raise_error
+    end
+  end
+
   describe "#enqueue_process" do
     it { expect(subject).to respond_to(:enqueue_process) }
 

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ Bundler.setup
 require 'simplecov'
 require 'coveralls'
 require 'pry'
+require 'active_support/notifications'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
@@ -26,6 +27,16 @@ ResqueSpec.disable_ext = false
 
 require 'taskinator'
 
+Taskinator.configure do |config|
+
+  # use active support for instrumentation
+  config.instrumenter = ActiveSupport::Notifications
+
+  # use a "null stream" for logging
+  config.logger = Logger.new(File::NULL)
+
+end
+
 # require supporting files with custom matchers and macros, etc
 Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f }
 

data/spec/support/mock_definition.rb

@@ -0,0 +1,22 @@
+module MockDefinition
+
+  class << self
+    def create(queue=nil)
+
+      definition = Module.new do
+        extend Taskinator::Definition
+
+        define_process :foo_hash do
+          # empty on purpose
+        end
+      end
+
+      definition.queue = queue
+
+      # create a constant, so that the mock definition isn't anonymous
+      Object.const_set("Mock#{SecureRandom.hex}Definition", definition)
+
+    end
+  end
+
+end

data/spec/support/spec_support.rb

@@ -1,7 +1,9 @@
 module SpecSupport
   class Block
     def to_proc
-      lambda { |*args| call(*args) }
+      lambda { |*args|
+        call(*args)
+      }
     end
 
     # the call method must be provided by in specs

data/spec/support/test_definition.rb

@@ -0,0 +1,3 @@
+module TestDefinition
+  extend Taskinator::Definition
+end

data/spec/support/test_process.rb

@@ -0,0 +1,2 @@
+class TestProcess < Taskinator::Process
+end

data/spec/support/test_queue.rb

@@ -2,11 +2,12 @@ module Taskinator
   module Queues
 
     def self.create_test_queue_adapter(config={})
-      TestQueueAdapter::new()
+      TestQueueAdapter.new
     end
 
     class TestQueueAdapter
 
+      attr_reader :creates
       attr_reader :processes
       attr_reader :tasks
       attr_reader :jobs
@@ -16,11 +17,16 @@ module Taskinator
       end
 
       def clear
+        @creates = []
         @processes = []
         @tasks = []
         @jobs = []
       end
 
+      def enqueue_create_process(definition, uuid, args)
+        @creates << [definition, uuid, args]
+      end
+
       def enqueue_process(process)
         @processes << process
       end

data/spec/support/test_task.rb

@@ -0,0 +1,2 @@
+class TestTask < Taskinator::Task
+end

data/spec/taskinator/api_spec.rb

@@ -8,7 +8,7 @@ describe Taskinator::Api, :redis => true do
 
     describe "#each" do
       it "does not enumerate when there aren't any processes" do
-        block = SpecSupport::Block.new()
+        block = SpecSupport::Block.new
         expect(block).to_not receive(:call)
         subject.each(&block)
       end
@@ -22,7 +22,7 @@ describe Taskinator::Api, :redis => true do
           end
         end
 
-        block = SpecSupport::Block.new()
+        block = SpecSupport::Block.new
         expect(block).to receive(:call).exactly(3).times
 
         subject.each(&block)

data/spec/taskinator/create_process_worker_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Taskinator::CreateProcessWorker do
+
+  let(:definition) { MockDefinition.create }
+  let(:uuid) { SecureRandom.uuid }
+  let(:args) { {:foo => :bar} }
+
+  subject { Taskinator::CreateProcessWorker.new(definition.name, uuid, Taskinator::Persistence.serialize(:foo => :bar)) }
+
+  describe "#initialize" do
+    it {
+      expect(subject.definition).to eq(definition)
+    }
+
+    it {
+      MockDefinition.const_set(definition.name, definition)
+      Taskinator::CreateProcessWorker.new("MockDefinition::#{definition.name}", uuid, Taskinator::Persistence.serialize(:foo => :bar))
+      expect(subject.definition).to eq(definition)
+    }
+
+    it {
+      expect(subject.uuid).to eq(uuid)
+    }
+
+    it {
+      expect(subject.args).to eq(args)
+    }
+  end
+
+  describe "#perform" do
+    it "should create the process" do
+      expect(definition).to receive(:_create_process_).with(*args, :uuid => uuid).and_return(double('process', :enqueue! => nil))
+      subject.perform
+    end
+
+    it "should enqueue the process" do
+      expect_any_instance_of(Taskinator::Process).to receive(:enqueue!)
+      subject.perform
+    end
+  end
+
+
+end

data/spec/taskinator/definition/builder_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Taskinator::Definition::Builder do
 
   let(:definition) do
-    Module.new() do
+    Module.new do
       extend Taskinator::Definition
 
       def iterator_method(*); end
@@ -17,7 +17,7 @@ describe Taskinator::Definition::Builder do
 
   let(:args) { [:arg1, :arg2, {:option => 1, :another => false}] }
 
-  let(:block) { SpecSupport::Block.new() }
+  let(:block) { SpecSupport::Block.new }
 
   let(:define_block) {
     the_block = block
@@ -64,7 +64,7 @@ describe Taskinator::Definition::Builder do
 
     it "fails if block isn't given" do
       expect {
-        subject.sequential()
+        subject.sequential
       }.to raise_error(ArgumentError)
     end
   end
@@ -83,7 +83,7 @@ describe Taskinator::Definition::Builder do
 
     it "fails if block isn't given" do
       expect {
-        subject.concurrent()
+        subject.concurrent
       }.to raise_error(ArgumentError)
     end
   end
@@ -187,7 +187,7 @@ describe Taskinator::Definition::Builder do
 
   describe "#sub_process" do
     let(:sub_definition) do
-      Module.new() do
+      Module.new do
         extend Taskinator::Definition
 
         define_process :some_arg1, :some_arg2, :some_arg3 do

data/spec/taskinator/definition_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Taskinator::Definition do
 
   subject do
-    Module.new() do
+    Module.new do
       extend Taskinator::Definition
     end
   end
@@ -23,21 +23,28 @@ describe Taskinator::Definition do
     end
 
     it "should not invoke the given block" do
-      block = SpecSupport::Block.new()
+      block = SpecSupport::Block.new
       expect(block).to_not receive(:call)
       subject.define_process(&block)
     end
+
+    it "should raise ProcessAlreadyDefinedError error if already defined" do
+      subject.define_process
+      expect {
+        subject.define_process
+      }.to raise_error(Taskinator::Definition::ProcessAlreadyDefinedError)
+    end
   end
 
   describe "#create_process" do
-    it "raises UndefinedProcessError" do
+    it "raises ProcessUndefinedError" do
       expect {
         subject.create_process
-      }.to raise_error(Taskinator::Definition::UndefinedProcessError)
+      }.to raise_error(Taskinator::Definition::ProcessUndefinedError)
     end
 
     it "returns a process" do
-      block = SpecSupport::Block.new()
+      block = SpecSupport::Block.new
       allow(block).to receive(:to_proc) {
         Proc.new {|*args| }
       }
@@ -47,7 +54,7 @@ describe Taskinator::Definition do
     end
 
     it "invokes the given block in the context of a ProcessBuilder" do
-      block = SpecSupport::Block.new()
+      block = SpecSupport::Block.new
       expect(block).to receive(:call)
 
       subject.define_process do
@@ -67,6 +74,96 @@ describe Taskinator::Definition do
         subject.create_process
       }.to_not raise_error
     end
+
+    context "is instrumented" do
+      subject { MockDefinition.create }
+
+      it "for create process" do
+        instrumentation_block = SpecSupport::Block.new
+        expect(instrumentation_block).to receive(:call)
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /create_process/) do
+          subject.create_process :foo
+        end
+      end
+
+      it "for save process" do
+        instrumentation_block = SpecSupport::Block.new
+        expect(instrumentation_block).to receive(:call)
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /save_process/) do
+          subject.create_process :foo
+        end
+      end
+    end
+  end
+
+  describe "#create_process_remotely" do
+    it "raises ProcessUndefinedError" do
+      expect {
+        subject.create_process_remotely
+      }.to raise_error(Taskinator::Definition::ProcessUndefinedError)
+    end
+
+    it "returns the process uuid" do
+      block = SpecSupport::Block.new
+      allow(block).to receive(:to_proc) {
+        Proc.new {|*args| }
+      }
+      subject.define_process(&block)
+
+      process = subject.create_process_remotely
+
+      expect(process).to_not be_nil
+      expect(process.uuid).to_not be_nil
+    end
+
+    it "enqueues" do
+      block = SpecSupport::Block.new
+      allow(block).to receive(:to_proc) {
+        Proc.new {|*args| }
+      }
+      subject.define_process(&block)
+
+      expect(Taskinator.queue).to receive(:enqueue_create_process)
+
+      subject.create_process_remotely
+    end
+
+    describe "reloading" do
+      it "returns false if not persisted yet" do
+        block = SpecSupport::Block.new
+        allow(block).to receive(:to_proc) {
+          Proc.new {|*args| }
+        }
+        subject.define_process(&block)
+        process = subject.create_process_remotely
+
+        expect(process.reload).to eq(false)
+      end
+
+      it "returns true if persisted" do
+        definition = MockDefinition.create
+        process = definition.create_process_remotely(:foo)
+        definition._create_process_(:foo, :uuid => process.uuid).save
+
+        expect(process.reload).to eq(true)
+      end
+    end
+
+  end
+
+  describe "#queue" do
+    it {
+      expect(subject.queue).to be_nil
+    }
+
+    it {
+      subject.queue = :foo
+      expect(subject.queue).to eq(:foo)
+    }
   end
 
 end

data/spec/taskinator/executor_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Taskinator::Executor do
 
   let(:definition) do
-    Module.new() do
+    Module.new do
       def method; end
     end
   end

data/spec/taskinator/job_worker_spec.rb

@@ -63,11 +63,11 @@ describe Taskinator::JobWorker do
   it "should fail if job raises an error" do
     job = mock_job
     allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
-    allow(job).to receive(:start!) { raise NotImplementedError }
-    expect(job).to receive(:fail!).with(NotImplementedError)
+    allow(job).to receive(:start!) { raise StandardError }
+    expect(job).to receive(:fail!).with(StandardError)
     expect {
       subject.perform
-    }.to raise_error(NotImplementedError)
+    }.to raise_error(StandardError)
   end
 
 end