resque_jobs_tree 0.1.0 → 0.2.0

data/lib/resque_jobs_tree/job.rb

@@ -3,15 +3,17 @@ class ResqueJobsTree::Job
   class << self
 
     def perform *args
-      node, resources = tree_node_and_resources(args)
+      node, resources = node_and_resources(args)
       node.perform.call resources
     end
 
     private
 
     def after_perform_enqueue_parent *args
-      node, resources = tree_node_and_resources(args)
-      unless node.root?
+      node, resources = node_and_resources(args)
+      if node.root?
+        ResqueJobsTree::Storage.release_launch node.tree, resources
+      else
         ResqueJobsTree::Storage.remove(node, resources) do
           parent_job_args = ResqueJobsTree::Storage.parent_job_args node, resources
           Resque.enqueue_to node.tree.name, ResqueJobsTree::Job, *parent_job_args
@@ -20,20 +22,20 @@ class ResqueJobsTree::Job
     end
 
     def on_failure_cleanup exception, *args
-      node, resources = tree_node_and_resources args
+      node, resources = node_and_resources args
       if node.options[:continue_on_failure]
         begin
           after_perform_enqueue_parent *args
         ensure
-          ResqueJobsTree::Storage.cleanup node, resources
+          ResqueJobsTree::Storage.failure_cleanup node, resources
         end
       else
-        ResqueJobsTree::Storage.cleanup node, resources, global: true
+        ResqueJobsTree::Storage.failure_cleanup node, resources, global: true
         raise exception
       end
     end
 
-    def tree_node_and_resources args
+    def node_and_resources args
       tree_name , job_name = args[0..1]
       tree                 = ResqueJobsTree::Factory.find_tree_by_name tree_name
       node                 = tree.find_node_by_name job_name

data/lib/resque_jobs_tree/node.rb

@@ -82,4 +82,8 @@ class ResqueJobsTree::Node
     node_childs+node_childs.map(&:nodes)
   end
 
+  def inspect
+    "<ResqueJobsTree::Node @name=#{name}>"
+  end
+
 end

data/lib/resque_jobs_tree/storage.rb

@@ -2,32 +2,35 @@
 module ResqueJobsTree::Storage
   extend self
 
-  PARENTS_KEY = "JobsTree:Node:Parents" 
+  PARENTS_KEY = "ResqueJobsTree:Node:Parents" 
+  LAUNCHED_TREES = "ResqueJobsTree:Tree:Launched"
 
   def store node, resources, parent, parent_resources
     node_key = key node, resources
     parent_key = key parent, parent_resources
-    Resque.redis.hset PARENTS_KEY, node_key, parent_key
+    redis.hset PARENTS_KEY, node_key, parent_key
     childs_key = childs_key parent, parent_resources
-    unless Resque.redis.sadd childs_key, node_key
+    unless redis.sadd childs_key, node_key
       raise ResqueJobsTree::JobNotUniq,
         "Job #{parent.name} already has the child #{node.name} with resources: #{resources}"
     end
   end
 
   def remove node, resources
-    lock_with parent_lock_key(node, resources) do
+    lock node, resources do
       siblings_key = siblings_key node, resources
-      Resque.redis.srem siblings_key, key(node, resources)
-      yield if Resque.redis.scard(siblings_key) == 0 && block_given?
+      redis.srem siblings_key, key(node, resources)
+      yield if redis.scard(siblings_key) == 0 && block_given?
     end
   end
 
-  def cleanup node, resources, option={}
+  def failure_cleanup node, resources, options={}
     cleanup_childs node, resources
-    unless node.root?
+    if node.root?
+      release_launch node.tree, resources
+    else
       remove_from_siblings node, resources
-      option[:global] ?  cleanup_parent(node, resources) : remove_parent_key(node, resources)
+      options[:global] ?  cleanup_parent(node, resources, options) : remove_parent_key(node, resources)
     end
   end
 
@@ -35,13 +38,21 @@ module ResqueJobsTree::Storage
     args_from_key parent_key(node, resources)
   end
 
+  def track_launch *tree_info
+    yield if redis.sadd LAUNCHED_TREES, tree_reference(*tree_info)
+  end
+
+  def release_launch *tree_info
+    redis.srem LAUNCHED_TREES, tree_reference(*tree_info)
+  end
+
   private
 
   def key node, resources
     job_args = ResqueJobsTree::ResourcesSerializer.to_args(resources)
     job_args.unshift node.name
     job_args.unshift node.tree.name
-    "JobsTree:Node:#{job_args.to_json}"
+    "ResqueJobsTree:Node:#{job_args.to_json}"
   end
 
   def childs_key node, resources
@@ -50,7 +61,7 @@ module ResqueJobsTree::Storage
 
   def parent_key node, resources
     node_key = key node, resources
-    Resque.redis.hget PARENTS_KEY, node_key
+    redis.hget PARENTS_KEY, node_key
   end
 
   def siblings_key node, resources
@@ -61,45 +72,54 @@ module ResqueJobsTree::Storage
     "#{parent_key node, resources}:lock"
   end
 
-  def lock_with key
-    while !Resque.redis.setnx(key, 'locked')
+  def lock *node_info
+    key = parent_lock_key *node_info
+    while !redis.setnx(key, 'locked')
       sleep 0.05 # 50 ms
     end
     yield
   ensure
-    Resque.redis.del key
+    redis.del key
   end
 
   def cleanup_childs *node_info
     key = childs_key *node_info
-    Resque.redis.smembers(key).each do |child_key|
-      cleanup *node_info_from_key(child_key)
+    redis.smembers(key).each do |child_key|
+      failure_cleanup *node_info_from_key(child_key)
     end
-    Resque.redis.del key
+    redis.del key
   end
 
-  def cleanup_parent *node_info
-    parent, parent_resources = node_info_from_key(parent_key(*node_info))
-    remove_parent_key *node_info
-    cleanup parent, parent_resources
+  def cleanup_parent node, resources, options
+    parent, parent_resources = node_info_from_key(parent_key(node, resources))
+    remove_parent_key node, resources
+    failure_cleanup parent, parent_resources, options
   end
 
   def remove_parent_key *node_info
-    Resque.redis.hdel PARENTS_KEY, key(*node_info)
+    redis.hdel PARENTS_KEY, key(*node_info)
   end
 
   def remove_from_siblings *node_info
-    Resque.redis.srem siblings_key(*node_info), key(*node_info)
+    redis.srem siblings_key(*node_info), key(*node_info)
   end
 
   def args_from_key key
-    JSON.load key.gsub(/JobsTree:Node:/, '')
+    JSON.load key.gsub(/ResqueJobsTree:Node:/, '')
   end
 
   def node_info_from_key key
-    tree_name, node_name, resources = args_from_key(key)
+    tree_name, node_name, *resources = args_from_key(key)
     node = ResqueJobsTree::Factory.find_tree_by_name(tree_name).find_node_by_name(node_name)
     [node, resources]
   end
 
+  def redis
+    Resque.redis
+  end
+
+  def tree_reference tree, resources
+    [tree.name, ResqueJobsTree::ResourcesSerializer.to_args(resources)].to_json
+  end
+
 end

data/lib/resque_jobs_tree/tree.rb

@@ -15,8 +15,10 @@ class ResqueJobsTree::Tree
   end
 
   def launch *resources
-    @root.launch resources
-    enqueue_leaves_jobs
+    ResqueJobsTree::Storage.track_launch self, resources do
+      @root.launch resources
+      enqueue_leaves_jobs
+    end
   end
 
   def enqueue *job_args
@@ -37,6 +39,10 @@ class ResqueJobsTree::Tree
     [root, root.nodes].flatten
   end
 
+  def inspect
+    "<ResqueJobsTree::Tree @name=#{name}>"
+  end
+
   private
 
   def enqueue_leaves_jobs

data/lib/resque_jobs_tree/version.rb

@@ -1,3 +1,3 @@
 module ResqueJobsTree
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/job_test.rb

@@ -9,7 +9,7 @@ class JobTest < MiniTest::Unit::TestCase
 
 	def test_tree_node_and_resources
 		result = [@tree.find_node_by_name('job1'), [1, 2, 3]]
-		assert_equal result, ResqueJobsTree::Job.send(:tree_node_and_resources, @args)
+		assert_equal result, ResqueJobsTree::Job.send(:node_and_resources, @args)
 	end
 
 end

data/test/node_test.rb

@@ -137,6 +137,40 @@ class NodeTest < MiniTest::Unit::TestCase
     assert_equal [], Resque.keys
   end
 
+  def test_leaf_failure
+    tree = ResqueJobsTree::Factory.create :tree1 do
+      root :job1 do
+        perform {}
+        childs { [:job2] }
+        node :job2 do
+          perform { raise 'an unexpected failure' }
+        end
+      end
+    end
+    resources = [1, 2, 3]
+    assert_raises RuntimeError, 'an unexpected failure' do
+      tree.launch *resources
+    end
+    assert_equal [], Resque.keys
+  end
+
+  def test_root_failure
+    tree = ResqueJobsTree::Factory.create :tree1 do
+      root :job1 do
+        perform { raise 'an unexpected failure' }
+        childs { [:job2] }
+        node :job2 do
+          perform {}
+        end
+      end
+    end
+    resources = [1, 2, 3]
+    assert_raises RuntimeError, 'an unexpected failure' do
+      tree.launch resources
+    end
+    assert_equal [], Resque.keys
+  end
+
   private
 
   def create_async_tree

data/test/storage_test.rb

@@ -50,6 +50,21 @@ class StorageTest < MiniTest::Unit::TestCase
 		end
 	end
 
+	def test_node_info_from_key
+		key = %Q{ResqueJobsTree:Node:["tree1","job1",1,2,3]}
+		result = [@root, [1, 2, 3]]
+		assert_equal result, ResqueJobsTree::Storage.send(:node_info_from_key, key)
+	end
+
+	def test_track_launch
+		resources = [1, 2, 3]
+		ResqueJobsTree::Storage.track_launch(@tree, resources) {}
+		key = ResqueJobsTree::Storage::LAUNCHED_TREES
+    assert_equal [[@tree.name, resources].to_json], redis.smembers(key)
+		ResqueJobsTree::Storage.release_launch(@tree, resources)
+    assert_equal [], redis.smembers(key)
+	end
+
 	private
 
 	def store

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque_jobs_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors: