taskinator 0.2.0 → 0.3.0

data/lib/taskinator/process.rb

@@ -4,7 +4,10 @@ require 'thwait'
 module Taskinator
   class Process
     include ::Comparable
-    include ::Workflow
+
+    include Workflow
+    include Persistence
+    include Instrumentation
 
     class << self
       def define_sequential_process_for(definition, options={})
@@ -24,6 +27,8 @@ module Taskinator
     attr_reader :definition
     attr_reader :options
     attr_reader :queue
+    attr_reader :created_at
+    attr_reader :updated_at
 
     # in the case of sub process tasks, the containing task
     attr_accessor :parent
@@ -36,12 +41,18 @@ module Taskinator
       @definition = definition
       @options = options
       @queue = options.delete(:queue)
+      @created_at = Time.now.utc
+      @updated_at = created_at
     end
 
     def tasks
       @tasks ||= Tasks.new
     end
 
+    def no_tasks_defined?
+      tasks.empty?
+    end
+
     def accept(visitor)
       visitor.visit_attribute(:uuid)
       visitor.visit_task_reference(:parent)
@@ -49,6 +60,8 @@ module Taskinator
       visitor.visit_tasks(tasks)
       visitor.visit_args(:options)
       visitor.visit_attribute(:queue)
+      visitor.visit_attribute_time(:created_at)
+      visitor.visit_attribute_time(:updated_at)
     end
 
     def <=>(other)
@@ -59,58 +72,79 @@ module Taskinator
       "#<#{self.class.name}:#{uuid}>"
     end
 
-    workflow do
-      state :initial do
-        event :enqueue, :transitions_to => :enqueued
-        event :start, :transitions_to => :processing
-        event :complete, :transitions_to => :completed
-        event :cancel, :transitions_to => :cancelled
-        event :fail, :transitions_to => :failed
-      end
+    def enqueue!
+      return if paused? || cancelled?
 
-      state :enqueued do
-        event :start, :transitions_to => :processing
-        event :complete, :transitions_to => :completed
-        event :cancel, :transitions_to => :cancelled
-        event :fail, :transitions_to => :failed
+      transition(:enqueued) do
+        instrument('taskinator.process.enqueued', enqueued_payload) do
+          enqueue
+        end
       end
+    end
+
+    def start!
+      return if paused? || cancelled?
 
-      state :processing do
-        event :pause, :transitions_to => :paused
-        event :complete, :transitions_to => :completed
-        event :fail, :transitions_to => :failed
+      transition(:processing) do
+        instrument('taskinator.process.processing', processing_payload) do
+          start
+        end
       end
+    end
+
+    def pause!
+      return unless enqueued? || processing?
 
-      state :paused do
-        event :resume, :transitions_to => :processing
-        event :cancel, :transitions_to => :cancelled
-        event :fail, :transitions_to => :failed
+      transition(:paused) do
+        instrument('taskinator.process.paused', paused_payload) do
+          pause if respond_to?(:pause)
+        end
       end
+    end
 
-      state :cancelled
-      state :completed
-      state :failed
+    def resume!
+      return unless paused?
 
-      on_transition do |from, to, event, *args|
-        Taskinator.logger.debug("PROCESS: #{self.class.name}:#{uuid} :: #{from} => #{to}")
+      transition(:processing) do
+        instrument('taskinator.process.resumed', resumed_payload) do
+          resume if respond_to?(:resume)
+        end
       end
+    end
 
+    def complete!
+      transition(:completed) do
+        instrument('taskinator.process.completed', completed_payload) do
+          complete if respond_to?(:complete)
+          # notify the parent task (if there is one) that this process has completed
+          # note: parent may be a proxy, so explicity check for nil?
+          parent.complete! unless parent.nil?
+        end
+      end
     end
 
-    def no_tasks_defined?
-      tasks.empty?
+    def tasks_completed?
+      # TODO: optimize this
+      tasks.all?(&:completed?)
     end
 
-    # callback for when the process was cancelled
-    def on_cancelled_entry(*args)
-      Taskinator.instrumenter.instrument('taskinator.process.cancelled', instrumentation_payload) do
-        # intentionally left empty
+    def cancel!
+      transition(:cancelled) do
+        instrument('taskinator.process.cancelled', cancelled_payload) do
+          cancel if respond_to?(:cancel)
+        end
       end
     end
 
-    # subclasses must implement this method
-    def tasks_completed?(*args)
-      raise NotImplementedError
+    def fail!(error)
+      transition(:failed) do
+        instrument('taskinator.process.failed', failed_payload(error)) do
+          fail(error) if respond_to?(:fail)
+          # notify the parent task (if there is one) that this process has failed
+          # note: parent may be a proxy, so explicity check for nil?
+          parent.fail!(error) unless parent.nil?
+        end
+      end
     end
 
     def task_failed(task, error)
@@ -118,47 +152,39 @@ module Taskinator
       fail!(error)
     end
 
-    # include after defining the workflow
-    # since the load and persist state methods
-    # need to override the ones defined by workflow
-    include Persistence
+    #--------------------------------------------------
+    # subclasses must implement the following methods
+    #--------------------------------------------------
 
-    def complete
-      Taskinator.instrumenter.instrument('taskinator.process.completed', instrumentation_payload) do
-        # notify the parent task (if there is one) that this process has completed
-        # note: parent may be a proxy, so explicity check for nil?
-        parent.complete! unless parent.nil?
-      end
+    def enqueue
+      raise NotImplementedError
     end
 
-    # callback for when the process has failed
-    def on_failed_entry(*args)
-      Taskinator.instrumenter.instrument('taskinator.process.failed', instrumentation_payload) do
-        # notify the parent task (if there is one) that this process has failed
-        # note: parent may be a proxy, so explicity check for nil?
-        parent.fail!(*args) unless parent.nil?
-      end
+    def start
+      raise NotImplementedError
     end
 
+    def task_completed(task)
+      raise NotImplementedError
+    end
+
+    #--------------------------------------------------
+
     class Sequential < Process
       def enqueue
-        Taskinator.instrumenter.instrument('taskinator.process.enqueued', instrumentation_payload) do
-          if tasks.empty?
-            complete! # weren't any tasks to start with
-          else
-            tasks.first.enqueue!
-          end
+        if tasks.empty?
+          complete! # weren't any tasks to start with
+        else
+          tasks.first.enqueue!
         end
       end
 
       def start
-        Taskinator.instrumenter.instrument('taskinator.process.started', instrumentation_payload) do
-          task = tasks.first
-          if task
-            task.start!
-          else
-            complete! # weren't any tasks to start with
-          end
+        task = tasks.first
+        if task
+          task.start!
+        else
+          complete! # weren't any tasks to start with
         end
       end
 
@@ -167,20 +193,17 @@ module Taskinator
         if next_task
           next_task.enqueue!
         else
-          complete!
+          complete! # aren't any more tasks
         end
       end
 
-      def tasks_completed?(*args)
-        # TODO: optimize this
-        tasks.all?(&:completed?)
-      end
-
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", state=:#{current_state.name}, tasks=[#{tasks.inspect}]>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", state=:#{current_state}, tasks=[#{tasks.inspect}]>)
       end
     end
 
+    #--------------------------------------------------
+
     class Concurrent < Process
       attr_reader :complete_on
       attr_reader :concurrency_method
@@ -192,35 +215,31 @@ module Taskinator
       end
 
       def enqueue
-        Taskinator.instrumenter.instrument('taskinator.process.enqueued', instrumentation_payload) do
-          if tasks.empty?
-            complete! # weren't any tasks to start with
-          else
-            tasks.each(&:enqueue!)
-          end
+        if tasks.empty?
+          complete! # weren't any tasks to start with
+        else
+          tasks.each(&:enqueue!)
         end
       end
 
       def start
-        Taskinator.instrumenter.instrument('taskinator.process.started', instrumentation_payload) do
-          if tasks.empty?
-            complete! # weren't any tasks to start with
-          else
-            if concurrency_method == :fork
-              tasks.each do |task|
-                fork do
-                  task.start!
-                end
+        if tasks.empty?
+          complete! # weren't any tasks to start with
+        else
+          if concurrency_method == :fork
+            tasks.each do |task|
+              fork do
+                task.start!
               end
-              Process.waitall
-            else
-              threads = tasks.map do |task|
-                Thread.new do
-                  task.start!
-                end
+            end
+            Process.waitall
+          else
+            threads = tasks.map do |task|
+              Thread.new do
+                task.start!
               end
-              ThreadsWait.all_waits(*threads)
             end
+            ThreadsWait.all_waits(*threads)
           end
         end
       end
@@ -231,21 +250,21 @@ module Taskinator
         complete!
       end
 
-      def tasks_completed?(*args)
+      def tasks_completed?
         if (complete_on == CompleteOn::First)
           tasks.any?(&:completed?)
         else
-          tasks.all?(&:completed?)
+          super # all
         end
       end
 
       def accept(visitor)
         super
-        visitor.visit_attribute(:complete_on)
+        visitor.visit_attribute_enum(:complete_on, CompleteOn)
       end
 
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", state=:#{current_state.name}, complete_on=:#{complete_on}, tasks=[#{tasks.inspect}]>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", state=:#{current_state}, complete_on=:#{complete_on}, tasks=[#{tasks.inspect}]>)
       end
     end
   end

data/lib/taskinator/queues/delayed_job.rb

@@ -22,12 +22,6 @@ module Taskinator
         ::Delayed::Job.enqueue TaskWorker.new(task.uuid), :queue => queue
       end
 
-      def enqueue_job(job)
-        # delayed jobs don't define the queue so use the configured queue instead
-        queue = job.queue || @config[:job_queue]
-        ::Delayed::Job.enqueue JobWorker.new(job.uuid), :queue => queue
-      end
-
       CreateProcessWorker = Struct.new(:definition_name, :uuid, :args) do
         def perform
           Taskinator::CreateProcessWorker.new(definition_name, uuid, args).perform
@@ -40,14 +34,6 @@ module Taskinator
         end
       end
 
-      JobWorker = Struct.new(:job_uuid) do
-        def perform
-          Taskinator::JobWorker.new(job_uuid).perform do |job, args|
-            job.new(*args).perform
-          end
-        end
-      end
-
     end
   end
 end

data/lib/taskinator/queues/resque.rb

@@ -19,9 +19,6 @@ module Taskinator
           @queue = config[:task_queue]
         end
 
-        JobWorker.class_eval do
-          @queue = config[:job_queue]
-        end
       end
 
       def enqueue_create_process(definition, uuid, args)
@@ -34,14 +31,6 @@ module Taskinator
         Resque.enqueue_to(queue, TaskWorker, task.uuid)
       end
 
-      def enqueue_job(job)
-        queue = job.queue ||
-                  Resque.queue_from_class(job.job) ||
-                    Resque.queue_from_class(JobWorker)
-
-        Resque.enqueue_to(queue, JobWorker, job.uuid)
-      end
-
       class CreateProcessWorker
         def self.perform(definition_name, uuid, args)
           Taskinator::CreateProcessWorker.new(definition_name, uuid, args).perform
@@ -54,13 +43,6 @@ module Taskinator
         end
       end
 
-      class JobWorker
-        def self.perform(job_uuid)
-          Taskinator::JobWorker.new(job_uuid).perform do |job, args|
-            job.perform(*args)
-          end
-        end
-      end
     end
   end
 end

data/lib/taskinator/queues/sidekiq.rb

@@ -22,11 +22,6 @@ module Taskinator
         TaskWorker.client_push('class' => TaskWorker, 'args' => [task.uuid], 'queue' => queue)
       end
 
-      def enqueue_job(job)
-        queue = job.queue || job.job.get_sidekiq_options[:queue] || @config[:job_queue]
-        JobWorker.client_push('class' => JobWorker, 'args' => [job.uuid], 'queue' => queue)
-      end
-
       class CreateProcessWorker
         include ::Sidekiq::Worker
 
@@ -43,15 +38,6 @@ module Taskinator
         end
       end
 
-      class JobWorker
-        include ::Sidekiq::Worker
-
-        def perform(job_uuid)
-          Taskinator::JobWorker.new(job_uuid).perform do |job, args|
-            job.new.perform(*args)
-          end
-        end
-      end
     end
   end
 end

data/lib/taskinator/queues.rb

@@ -39,11 +39,6 @@ module Taskinator
         adapter.enqueue_task(task)
       end
 
-      def enqueue_job(job)
-        Taskinator.logger.info("Enqueuing job #{job}")
-        adapter.enqueue_job(job)
-      end
-
     end
 
   end