add before_started, after_completed and after_failed functionality

Author: virtualstaticvoid

lib/taskinator/persistence.rb

@@ -222,7 +222,6 @@ def cleanup(expire_in=EXPIRE_IN)
 
         end
       end
-
     end
 
     class RedisSerializationVisitor < Taskinator::Visitor::Base
@@ -750,7 +749,6 @@ def __getobj__
         # and memoize for subsequent calls
         @instance ||= @type.fetch(@uuid, @instance_cache)
       end
-
     end
 
     class << self

lib/taskinator/task.rb

@@ -15,13 +15,13 @@ def define_job_task(process, job, args, options={})
         Job.new(process, job, args, options)
       end
 
-      def define_hook_task(process, method, args, options={})
-        Hook.new(process, method, args, options)
-      end
-
       def define_sub_process_task(process, sub_process, options={})
         SubProcess.new(process, sub_process, options)
       end
+
+      def define_hook_task(process, method, args, options={})
+        Hook.new(process, method, args, options)
+      end
     end
 
     attr_reader :process
@@ -214,65 +214,6 @@ def inspect
 
     #--------------------------------------------------
 
-    # a task which invokes the specified method on the definition
-    # the task is executed independently of the process, so there isn't any further
-    # processing once it completes (or fails)
-    # the args must be intrinsic types, since they are serialized to YAML
-    class Hook < Task
-      attr_reader :method
-      attr_reader :args
-
-      def initialize(process, method, args, options={})
-        super(process, options)
-
-        raise ArgumentError, 'method' if method.nil?
-        raise NoMethodError, method unless executor.respond_to?(method)
-
-        @method = method
-        @args = args
-      end
-
-      def enqueue
-        Taskinator.queue.enqueue_task(self)
-      end
-
-      def start
-        executor.send(method, *args)
-        # ASSUMPTION: when the method returns, the task is considered to be complete
-        complete!
-
-      rescue => e
-        Taskinator.logger.error(e)
-        Taskinator.logger.debug(e.backtrace)
-        fail!(e)
-        raise e
-      end
-
-      def accept(visitor)
-        super
-        visitor.visit_attribute(:method)
-        visitor.visit_args(:args)
-      end
-
-      def executor
-        @executor ||= Taskinator::Executor.new(definition, self)
-      end
-
-      def incr_count?
-        false
-      end
-
-      def notify_process?
-        false
-      end
-
-      def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", definition=:#{definition}, method=:#{method}, args=#{args}, current_state=:#{current_state}>)
-      end
-    end
-
-    #--------------------------------------------------
-
     # a task which invokes the specified background job
     # the args must be intrinsic types, since they are serialized to YAML
     class Job < Task
@@ -370,5 +311,64 @@ def inspect
         %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", definition=:#{definition}, sub_process=#{sub_process.inspect}, current_state=:#{current_state}>)
       end
     end
+
+    #--------------------------------------------------
+
+    # a task which invokes the specified method on the definition
+    # the task is executed independently of the process, so there isn't any further
+    # processing once it completes (or fails)
+    # the args must be intrinsic types, since they are serialized to YAML
+    class Hook < Task
+      attr_reader :method
+      attr_reader :args
+
+      def initialize(process, method, args, options={})
+        super(process, options)
+
+        raise ArgumentError, 'method' if method.nil?
+        raise NoMethodError, method unless executor.respond_to?(method)
+
+        @method = method
+        @args = args
+      end
+
+      def enqueue
+        Taskinator.queue.enqueue_task(self)
+      end
+
+      def start
+        executor.send(method, *args)
+        # ASSUMPTION: when the method returns, the task is considered to be complete
+        complete!
+
+      rescue => e
+        Taskinator.logger.error(e)
+        Taskinator.logger.debug(e.backtrace)
+        fail!(e)
+        raise e
+      end
+
+      def accept(visitor)
+        super
+        visitor.visit_attribute(:method)
+        visitor.visit_args(:args)
+      end
+
+      def executor
+        @executor ||= Taskinator::Executor.new(definition, self)
+      end
+
+      def incr_count?
+        false
+      end
+
+      def notify_process?
+        false
+      end
+
+      def inspect
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", definition=:#{definition}, method=:#{method}, args=#{args}, current_state=:#{current_state}>)
+      end
+    end
   end
 end

spec/examples/visitor_examples.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+shared_examples_for "a visitor" do |visitor|
+
+  visitor_methods = visitor.instance_methods
+
+  # visit_process(attribute)
+  it { expect(visitor_methods.include?(:visit_process)).to be }
+
+  # visit_tasks(tasks)
+  it { expect(visitor_methods.include?(:visit_tasks)).to be }
+
+  # visit_before_started_tasks(tasks)
+  it { expect(visitor_methods.include?(:visit_before_started_tasks)).to be }
+
+  # visit_after_completed_tasks(tasks)
+  it { expect(visitor_methods.include?(:visit_after_completed_tasks)).to be }
+
+  # visit_after_failed_tasks(tasks)
+  it { expect(visitor_methods.include?(:visit_after_failed_tasks)).to be }
+
+  # visit_attribute(attribute)
+  it { expect(visitor_methods.include?(:visit_attribute)).to be }
+
+  # visit_attribute_time(attribute)
+  it { expect(visitor_methods.include?(:visit_attribute_time)).to be }
+
+  # visit_attribute_enum(attribute, type)
+  it { expect(visitor_methods.include?(:visit_attribute_enum)).to be }
+
+  # visit_process_reference(attribute)
+  it { expect(visitor_methods.include?(:visit_process_reference)).to be }
+
+  # visit_task_reference(attribute)
+  it { expect(visitor_methods.include?(:visit_task_reference)).to be }
+
+  # visit_type(attribute)
+  it { expect(visitor_methods.include?(:visit_type)).to be }
+
+  # visit_args(attribute)
+  it { expect(visitor_methods.include?(:visit_args)).to be }
+
+  # task_count
+  it { expect(visitor_methods.include?(:task_count)).to be }
+
+end

spec/taskinator/persistence_spec.rb

@@ -554,4 +554,5 @@ def initialize
 
     end
   end
+
 end

spec/taskinator/visitor_spec.rb

@@ -1,14 +1,11 @@
 require 'spec_helper'
 
-describe Taskinator::Visitor::Base do
+describe "Visitors" do
 
-  it { respond_to(:visit_process) }
-  it { respond_to(:visit_tasks) }
-  it { respond_to(:visit_attribute) }
-  it { respond_to(:visit_process_reference) }
-  it { respond_to(:visit_task_reference) }
-  it { respond_to(:visit_type) }
-  it { respond_to(:visit_args) }
-  it { respond_to(:task_count) }
+  it_should_behave_like "a visitor", Taskinator::Visitor::Base
+  it_should_behave_like "a visitor", Taskinator::Persistence::RedisSerializationVisitor
+  it_should_behave_like "a visitor", Taskinator::Persistence::XmlSerializationVisitor
+  it_should_behave_like "a visitor", Taskinator::Persistence::RedisDeserializationVisitor
+  it_should_behave_like "a visitor", Taskinator::Persistence::RedisCleanupVisitor
 
 end