resque_jobs_tree 0.3.4 → 0.4.0

data/lib/resque_jobs_tree.rb

@@ -1,6 +1,10 @@
 require "resque_jobs_tree/version"
 require 'resque'
 
+require 'resque_jobs_tree/storage'
+require 'resque_jobs_tree/storage/tree'
+require 'resque_jobs_tree/storage/node'
+
 require 'resque_jobs_tree/factory'
 require 'resque_jobs_tree/tree'
 require 'resque_jobs_tree/node'
@@ -8,8 +12,26 @@ require 'resque_jobs_tree/job'
 require 'resque_jobs_tree/resources_serializer'
 require 'resque_jobs_tree/storage'
 
+require 'resque_jobs_tree/definitions'
+require 'resque_jobs_tree/definitions/tree'
+require 'resque_jobs_tree/definitions/node'
+
 module ResqueJobsTree
-  class TreeInvalid < Exception ; end
-  class NodeInvalid < Exception ; end
-  class JobNotUniq  < Exception ; end
+  extend self
+  class TreeDefinitionInvalid < Exception ; end
+  class NodeDefinitionInvalid < Exception ; end
+  class JobNotUniq            < Exception ; end
+
+  def find name
+    Factory.find name.to_s
+  end
+
+  def launch name, *resources
+    tree_definition = find name
+    tree_definition ? tree_definition.spawn(resources).launch : raise("Can't find tree `#{name}`")
+  end
+
+  def create *resources
+    Factory.create *resources
+  end
 end

data/lib/resque_jobs_tree/definitions.rb

@@ -0,0 +1,15 @@
+class ResqueJobsTree::Definitions
+
+  def on_failure &block
+    @on_failure ||= block
+  end
+	
+	def before_perform &block
+    @before_perform ||= block
+	end
+
+	def after_perform &block
+    @before_perform ||= block
+	end
+
+end

data/lib/resque_jobs_tree/definitions/node.rb

@@ -0,0 +1,77 @@
+class ResqueJobsTree::Definitions::Node < ResqueJobsTree::Definitions
+
+  attr_accessor :tree, :parent, :name, :node_childs, :options
+
+  def initialize name, tree, parent=nil
+    @tree        = tree
+    @name        = name.to_s
+    @parent      = parent
+    @node_childs = []
+    @options     = {}
+  end
+
+  def node name, options={}, &block
+    ResqueJobsTree::Definitions::Node.new(name, tree, self).tap do |node|
+      node.options = options
+      @node_childs << node
+      node.instance_eval(&block) if block_given?
+    end
+  end
+
+	def spawn resources, parent=nil
+		ResqueJobsTree::Node.new self, resources, parent
+	end
+
+  def childs &block
+    @childs ||= block
+  end
+
+	def perform &block
+    @perform ||= block
+	end
+
+  def leaf?
+		@node_childs.empty?
+  end
+
+  def root?
+    parent.nil?
+  end
+
+  def siblings
+    root? ? [] : (parent.node_childs - [self])
+  end
+
+  def find _name
+    if name == _name.to_s
+      self
+    else
+      node_childs.inject(nil){|result,node| result ||= node.find _name }
+    end
+  end
+
+  def validate!
+    if (childs.kind_of?(Proc) && node_childs.empty?) || (childs.nil? && !node_childs.empty?)
+      raise ResqueJobsTree::NodeDefinitionInvalid,
+        "node `#{name}` from tree `#{tree.name}` should defines childs and child nodes"
+    end
+    unless perform.kind_of? Proc
+      raise ResqueJobsTree::NodeDefinitionInvalid,
+        "node `#{name}` from tree `#{tree.name}` has no perform block"
+    end
+    if (tree.nodes - [self]).map(&:name).include? name
+      raise ResqueJobsTree::NodeDefinitionInvalid,
+        "node name `#{name}` is already taken in tree `#{tree.name}`"
+    end
+    node_childs.each &:validate!
+  end
+
+  def nodes
+    node_childs+node_childs.map(&:nodes)
+  end
+
+  def inspect
+    "<ResqueJobsTree::Node @name=#{name}>"
+  end
+
+end

data/lib/resque_jobs_tree/definitions/tree.rb

@@ -0,0 +1,39 @@
+class ResqueJobsTree::Definitions::Tree < ResqueJobsTree::Definitions
+
+  attr_accessor :name, :root
+
+  def initialize name
+    @name = name
+  end
+
+	def spawn resources
+		ResqueJobsTree::Tree.new self, resources
+	end
+
+  def root name=nil, &block
+    @root ||= Node.new(name, self).tap do |root|
+      root.instance_eval &block
+    end
+  end
+
+  def find name
+    root.find name.to_s
+  end
+
+  def validate!
+		if @root
+			root.validate!
+		else
+    	raise ResqueJobsTree::TreeDefinitionInvalid, "`#{name}` has no root node"
+		end
+  end
+
+  def nodes
+    [root, root.nodes].flatten
+  end
+
+  def inspect
+    "<ResqueJobsTree::Definitions::Tree @name=#{name}>"
+  end
+
+end

data/lib/resque_jobs_tree/factory.rb

@@ -3,21 +3,21 @@ module ResqueJobsTree::Factory
   extend self
 
   def create name, &block
-    @trees ||= []
-    @trees.delete_if{|tree| tree.name == name.to_s}
-    ResqueJobsTree::Tree.new(name).tap do |tree|
-      @trees << tree
+    name = name.to_s
+    @trees ||= {}
+    ResqueJobsTree::Definitions::Tree.new(name).tap do |tree|
       tree.instance_eval &block
       tree.validate!
+      @trees[name] = tree
     end
   end
 
   def trees
-    @trees
+    @trees ||= {}
   end
 
-  def find_tree_by_name name
-    @trees.detect{ |tree| tree.name == name.to_s }
+  def find name
+    trees[name.to_s]
   end
 
 end

data/lib/resque_jobs_tree/job.rb

@@ -3,45 +3,27 @@ class ResqueJobsTree::Job
   class << self
 
     def perform *args
-      node, resources = node_and_resources(args)
-      node.perform.call resources
+      node(*args).perform
     end
 
     protected
 
-    def after_perform_enqueue_parent *args
-      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
-        end
-      end
+    def before_perform_run_callback *args
+      node(*args).before_perform
     end
 
-    def on_failure_cleanup exception, *args
-      node, resources = node_and_resources args
-      if node.options[:continue_on_failure]
-        begin
-          after_perform_enqueue_parent *args
-        ensure
-          ResqueJobsTree::Storage.failure_cleanup node, resources
-        end
-      else
-        ResqueJobsTree::Storage.failure_cleanup node, resources, global: true
-        node.tree.on_failure.call(resources) if node.tree.on_failure.kind_of?(Proc)
-        raise exception
-      end
+    def after_perform_run_callback *args
+      node(*args).after_perform
     end
 
-    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
-      resources            = ResqueJobsTree::ResourcesSerializer.to_resources args[2..-1]
-      [node, resources]
+    def on_failure_run_callback exception, *args
+      node(*args).on_failure
+    end
+
+    def node tree_name, job_name, *resources_arguments
+      node_definition = ResqueJobsTree.find(tree_name).find job_name
+      resources       = ResqueJobsTree::ResourcesSerializer.instancize resources_arguments
+      node_definition.spawn resources
     end
 
   end

data/lib/resque_jobs_tree/node.rb

@@ -1,92 +1,96 @@
 class ResqueJobsTree::Node
 
-  attr_accessor :tree, :parent, :name, :node_childs, :options
-
-  def initialize name, tree, parent=nil
-    @tree        = tree
-    @name        = name.to_s
-    @parent      = parent
-    @node_childs = []
-    @options     = {}
+  include ResqueJobsTree::Storage::Node
+
+  attr_reader :resources, :definition, :tree
+
+  def initialize definition, resources, parent=nil, tree=nil
+    @childs     = []
+    @definition = definition
+    @resources  = resources
+    @parent     = parent
+    @tree       = tree
+  end
+
+  def enqueue
+    Resque.enqueue_to definition.tree.name, ResqueJobsTree::Job, *argumentize
   end
 
-  def resources &block
-    @resources_block ||= block
+  def perform
+    definition.perform.call *resources
   end
 
-  def perform &block
-    @perform_block ||= block
+  def before_perform
+    run_callback :before_perform
   end
 
-  def childs &block
-    @childs ||= block
+  def after_perform
+    run_callback :after_perform
+    if root?
+      tree.finish
+    else
+      lock do
+        parent.enqueue if only_stored_child?
+        unstore
+      end
+    end
   end
 
-  # Defines a child node.
-  def node name, options={}, &block
-    ResqueJobsTree::Node.new(name, tree, self).tap do |node|
-      node.options = options
-      @node_childs << node
-      node.instance_eval(&block) if block_given?
+  def on_failure
+    if definition.options[:continue_on_failure]
+      after_perform
+    else
+      root.tree.on_failure
+      root.cleanup
     end
   end
 
-  def leaf? resources
-    childs.kind_of?(Proc) ?  childs.call(resources).empty? : true
+  def tree
+    @tree ||= root? ? definition.tree.spawn(resources) : @parent.tree
+  end
+
+  def name
+    definition.name
+  end
+
+  def leaf?
+    childs.empty?
   end
 
   def root?
-    parent == nil
+    definition.root?
   end
 
-  def siblings
-    return [] unless parent
-    parent.node_childs - [self]
+  def root
+    @root ||= root? ? self : parent.root
   end
 
-  def launch resources, parent_resources=nil
-    unless root?
-      ResqueJobsTree::Storage.store self, resources, parent, parent_resources
-    end
-    if node_childs.empty?
-      @tree.enqueue(name, *resources) unless options[:async]
-    else
-      childs.call(resources).each do |name, *child_resources|
-        find_node_by_name(name).launch child_resources, resources
-      end
-    end
+  def childs
+    return @childs unless @childs.empty?
+    @childs = definition.leaf? ?  [] : definition.childs.call(*resources)
   end
 
-  def find_node_by_name _name
-    if name == _name.to_s
-      self
+  def launch
+    store unless root?
+    if leaf?
+      tree.register_a_leaf self
     else
-      node_childs.inject(nil){|result,node| result ||= node.find_node_by_name _name }
+      childs.each do |node_name, *resources|
+        node = definition.find(node_name).spawn resources, self
+        node.launch
+      end
     end
   end
 
-  def validate!
-    if (childs.kind_of?(Proc) && node_childs.empty?) || (childs.nil? && !node_childs.empty?)
-      raise ResqueJobsTree::NodeInvalid,
-        "node `#{name}` from tree `#{tree.name}` should defines childs and child nodes"
-    end
-    unless perform.kind_of? Proc
-      raise ResqueJobsTree::NodeInvalid,
-        "node `#{name}` from tree `#{tree.name}` has no perform block"
-    end
-    if (tree.nodes - [self]).map(&:name).include? name
-      raise ResqueJobsTree::NodeInvalid,
-        "node name `#{name}` is already taken in tree `#{tree.name}`"
-    end
-    node_childs.each &:validate!
+  def inspect
+    "<ResqueJobsTree::Node @name=#{name} @resources=#{resources}>"
   end
 
-  def nodes
-    node_childs+node_childs.map(&:nodes)
-  end
+  private
 
-  def inspect
-    "<ResqueJobsTree::Node @name=#{name}>"
+  def run_callback callback
+    callback_block = definition.send callback
+    callback_block.call(*resources) if callback_block.kind_of? Proc
   end
 
 end

data/lib/resque_jobs_tree/resources_serializer.rb

@@ -1,10 +1,9 @@
 module ResqueJobsTree::ResourcesSerializer
-
   extend self
 
   # in: [<Localisation id=1>, :pdf]
   # out: [[Localisation, 1], :pdf]
-  def to_args resources
+  def argumentize resources
     resources.to_a.map do |resource|
       resource.respond_to?(:id) ? [resource.class.name, resource.id] : resource
     end
@@ -12,7 +11,7 @@ module ResqueJobsTree::ResourcesSerializer
 
   # in: [['Localisation', 1], :pdf]
   # out: [<Localisation id=1>, :pdf]
-  def to_resources args
+  def instancize args
     args.to_a.map do |arg|
       if arg.kind_of? Array
         eval(arg[0]).find(arg[1]) rescue arg

data/lib/resque_jobs_tree/storage.rb

@@ -1,127 +1,20 @@
-# put expire on every key
 module ResqueJobsTree::Storage
-  extend self
 
   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
-    redis.hset PARENTS_KEY, node_key, parent_key
-    childs_key = childs_key parent, parent_resources
-    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 node, resources do
-      siblings_key = siblings_key node, resources
-      node_key = key(node, resources)
-      redis.srem siblings_key, node_key
-      yield if redis.scard(siblings_key) == 0 && block_given?
-      redis.hdel PARENTS_KEY, node_key
-    end
-  end
-
-  def failure_cleanup node, resources, options={}
-    cleanup_childs node, resources
-    if node.root?
-      release_launch node.tree, resources
-    else
-      remove_from_siblings node, resources
-      options[:global] ?  cleanup_parent(node, resources, options) : remove_parent_key(node, resources)
-    end
-  end
-
-  def parent_job_args node, resources
-    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
-    "ResqueJobsTree:Node:#{job_args.to_json}"
-  end
-
-  def childs_key node, resources
-    "#{key node, resources}:childs"
-  end
-
-  def parent_key node, resources
-    node_key = key node, resources
-    redis.hget PARENTS_KEY, node_key
-  end
-
-  def siblings_key node, resources
-    "#{parent_key node, resources}:childs"
+  def serialize
+    argumentize.to_json
   end
 
-  def parent_lock_key node, resources
-    "#{parent_key node, resources}:lock"
-  end
-
-  def lock *node_info
-    key = parent_lock_key *node_info
-    while !redis.setnx(key, 'locked')
-      sleep 0.05 # 50 ms
-    end
-    yield
-  ensure
-    redis.del key
-  end
-
-  def cleanup_childs *node_info
-    key = childs_key *node_info
-    redis.smembers(key).each do |child_key|
-      failure_cleanup *node_info_from_key(child_key)
-    end
-    redis.del key
-  end
-
-  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
-    redis.hdel PARENTS_KEY, key(*node_info)
-  end
-
-  def remove_from_siblings *node_info
-    redis.srem siblings_key(*node_info), key(*node_info)
-  end
-
-  def args_from_key key
-    JSON.load key.gsub(/ResqueJobsTree:Node:/, '')
-  end
-
-  def node_info_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]
+  def argumentize
+    main_arguments + ResqueJobsTree::ResourcesSerializer.argumentize(resources)
   end
 
   def redis
     Resque.redis
   end
-
-  def tree_reference tree, resources
-    [tree.name, ResqueJobsTree::ResourcesSerializer.to_args(resources)].to_json
-  end
-
+  
 end