queue_dispatcher 1.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in queue_dispatcher.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2012 Philip Kurmann
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,55 @@
+= QueueDispatcher for Rails3
+
+This Rails3 Gem implements a method to perform long running methods in the background.
+Background tasks will be executed by persistent workers.
+
+== Install
+
+Inside your Gemfile:
+
+  gem "queue_dispatcher"
+
+and then run:
+
+* bundle install
+* rake queue_dispatcher:sync
+
+=== Gem Dependencies
+
+Please check if all those requirements are satisfied on your environment.
+
+* rails >= 3.0.0
+* sys-proctable >= 0.9.1
+
+
+== Inside your application
+
+To enqueue a long running task, simple call a method through enque:
+E.g.: 
+  Assume, you have a long running job:
+  LongRunningMailJob.send_mail
+
+  Now we'd like to execute it in the background by simply calling: 
+  task = LongRunningMailJob.enqueue.send_mail
+
+  If you like to put the job in a queue, you can do this by execute it the following way:
+  task = LongRunningMailJob.enqueue(queue: 'queue_name').send_mail
+
+  Jobs inside a queue are executed serialized, not in parallel. You can define dependencies. A task is then executed only after all dependent tasks are finished. Code to add Task dependencies:
+  task.dependent_tasks = another_task
+
+== Generators
+
+* rails generate queue_dispatcher:migration
+
+=== Database Setup
+
+Use
+
+  rails g queue_dispatcher:migration
+
+This will create a database migration for the models Task and TaskQueues.
+
+== Copyright
+
+Copyright (c) 2011 - 2012 Philip Kurmann. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/assets/javascript/tasks.js.coffee

@@ -0,0 +1,8 @@
+jQuery ->
+  if jQuery('.pagination').length
+    jQuery(window).scroll ->
+      url = jQuery('.pagination .next_page').attr('href')
+      if url && jQuery(window).scrollTop() > jQuery(document).height() - jQuery(window).height() - 50
+        jQuery('.pagination').text('Fetching more events...')
+        jQuery.getScript(url)
+    jQuery(window).scroll

data/app/helpers/tasks_helper.rb

@@ -0,0 +1,28 @@
+module TasksHelper
+  def icon_for_task task
+    icon = 'icon_warning.gif'
+    alt  = 'Unknwon'
+
+    if task.pending?
+      icon = 'icon_pending.gif'
+      alt  = 'Pending'
+    elsif task.init_queue?
+      icon = 'icon_init_queue.gif'
+      alt  = 'Initialize Queue'
+    elsif task.acquire_lock?
+      icon = 'icon_acquire_lock.png'
+      alt  = 'Acquire Lock'
+    elsif task.running?
+      icon = 'icon_running.gif'
+      alt  = 'Running'
+    elsif task.successful?
+      icon = 'icon_successful.png'
+      alt  = 'Successful'
+    elsif task.error?
+      icon = 'icon_error.png'
+      alt  = 'Error!'
+    end
+
+    image_tag(icon, :alt => alt)
+  end
+end

data/app/models/task_dependency.rb

@@ -0,0 +1,2 @@
+class TaskDependency < ActiveRecord::Base
+end

data/app/views/queue_dispatcher_views/_search_results_events.html.haml

@@ -0,0 +1,4 @@
+#events
+  %table#events_table.table.table-striped
+    - @tasks.each do |task|
+      = render :partial => 'queue_dispatcher_views/task_event', :locals => { :task => task }

data/app/views/queue_dispatcher_views/_search_results_my_events.html.haml

@@ -0,0 +1,4 @@
+#events
+  %table#events_table.table.table-striped
+    - @tasks.each do |task|
+      = render :partial => 'queue_dispatcher_views/task_my_event', :locals => { :task => task }

data/app/views/queue_dispatcher_views/_task_event.html.haml

@@ -0,0 +1,24 @@
+- if task.error_msg.blank?
+  - event_class = "event"
+  - event_onclick = ""
+- else
+  - event_class = "event pointer"
+  - event_onclick = onclick_to_remote :url => {:controller => 'tasks', :action => 'expand_event'}, :with => "'id=#{task.id}'"
+
+- if @expanded_events.include? task.id
+  - event_style = ""
+- else
+  - event_style = "display:none"
+
+%tr{:id => "task_#{task.id}", :class => event_class, :onclick => event_onclick }
+  %td.qd_icon
+    = icon_for_task task
+    = "#{task.perc_finished}%" if task.running?
+  %td.qd_date= task.updated_at.to_s :history
+  %td.qd_prosa
+    = task.prosa
+    - unless task.error_msg.blank?
+      = image_tag 'icon_expand.gif' 
+      %div{:id => "task_#{task.id}_details", :class => 'qd_error_msg', :style => event_style}
+        = task.error_msg
+        %br

data/app/views/queue_dispatcher_views/_task_footer.html.erb

@@ -0,0 +1 @@
+</table>

data/app/views/queue_dispatcher_views/_task_header.html.erb

@@ -0,0 +1,12 @@
+<table>
+  <tr>
+    <th>ID</th>
+    <th>Action</th>
+    <th>Target Object</th>
+    <th>Remark</th>
+    <th>Task List</th>
+    <th>Priority</th>
+    <th>State</th>
+    <th>Message</th>
+    <th>Error Message</th>
+  </tr>

data/app/views/queue_dispatcher_views/_task_my_event.html.haml

@@ -0,0 +1,24 @@
+- if task.error_msg.blank?
+  - event_class = "event"
+  - event_onclick = ""
+- else
+  - event_class = "event pointer"
+  - event_onclick = onclick_to_remote :url => {:action => 'expand_event'}, :with => "'id=#{task.id}'"
+
+- if @expanded_events.include? task.id
+  - event_style = ""
+- else
+  - event_style = "display:none"
+
+%tr{:id => "task_#{task.id}", :class => event_class, :onclick => event_onclick }
+  %td.qd_icon
+    = icon_for_task task
+    = task.perc_finished if task.running?
+  %td.qd_date= task.updated_at.to_s :history
+  %td.qd_prosa
+    = task.prosa
+    - unless task.error_msg.blank?
+      = image_tag 'icon_expand.gif' 
+      %div{:id => "task_#{task.id}_details", :class => 'qd_error_msg', :style => event_style}
+        = task.error_msg
+        %br

data/app/views/queue_dispatcher_views/expand_event.js.rjs

@@ -0,0 +1 @@
+page.visual_effect :toggle_blind, "task_#{@task.id}_details", :duration => 0.1

data/app/views/queue_dispatcher_views/my_events.html.haml

@@ -0,0 +1,7 @@
+- title "Tasks and Events"
+= periodically_call_remote :url => {:action => 'my_events'},
+                           :frequency => 5,
+                           :condition => 'running_task_queues'
+= render :partial => 'queue_dispatcher_views/search_results_my_events'
+%br/
+= will_paginate @tasks

data/app/views/queue_dispatcher_views/my_events.js.erb

@@ -0,0 +1,6 @@
+jQuery('#events').append('<%= j render(partial: "queue_dispatcher_views/search_results_my_events") %>');
+<% if @tasks.next_page %>
+jQuery('.pagination').replaceWith('<%= j will_paginate(@tasks) %>');
+<% else %>
+jQuery('.pagination').remove();
+<% end %>

data/app/views/queue_dispatcher_views/update_events.js.erb

@@ -0,0 +1,15 @@
+<% @new_tasks.each do |task| %>
+  jQuery('#events_table').prepend('<%=j render(partial: 'queue_dispatcher_views/task_event', locals: {task: task}) %>');
+  jQuery('#task_<%= task.id %>').effect('highlight');
+<% end %>
+
+<% @updated_tasks.each do |task| %>
+  jQuery('#task_<%= task.id %>').replaceWith('<%=j render(partial: 'queue_dispatcher_views/task_event', locals: {task: task}) %>');
+  jQuery('#task_<%= task.id %>').effect('highlight');
+<% end %>
+
+<% @deleted_task_ids.each do |id| %>
+  jQuery('#task_<%= id %>).fadeOut();
+<% end %>
+
+<%= update_flash %>

data/lib/generators/queue_dispatcher/migration/migration_generator.rb

@@ -0,0 +1,51 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module QueueDispatcher
+  class MigrationGenerator < Rails::Generators::Base
+    desc "The queue_dispatcher migration generator creates a database migration for the task_queue model."
+    include Rails::Generators::Migration
+    source_root File.join(File.dirname(__FILE__), 'templates')
+
+    class_option :task_queues_table_name,
+      :type => :string,
+      :desc => "Name for the TaskQueue Table",
+      :required => false,
+      :default => "task_queues"
+
+    class_option :tasks_table_name,
+      :type => :string,
+      :desc => "Name for the Task Table",
+      :required => false,
+      :default => "tasks"
+
+    class_option :task_dependencies_table_name,
+      :type => :string,
+      :desc => "Name for the Task Dependency Table",
+      :required => false,
+      :default => "task_dependencies"
+
+    def initialize(args = [], options = {}, config = {})
+      super
+    end
+
+    #attr_reader :lock_table_name
+
+    # Implement the required interface for Rails::Generators::Migration.
+    # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % (current_migration_number(dirname) + 1)].max
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      migration_template 'task_queues.rb', 'db/migrate/create_task_queues.rb'
+      migration_template 'tasks.rb', 'db/migrate/create_tasks.rb'
+      migration_template 'task_dependencies.rb', 'db/migrate/create_task_dependencies.rb'
+    end
+
+  end
+end

data/lib/generators/queue_dispatcher/migration/templates/task_dependencies.rb

@@ -0,0 +1,16 @@
+class CreateTaskDependencies < ActiveRecord::Migration
+  def self.up
+    create_table "<%= options[:task_dependencies_table_name] %>" do |t|
+      t.integer :task_id
+      t.integer :dependent_task_id
+
+      t.timestamps
+    end
+    add_index "<%= options[:task_dependencies_table_name] %>", :task_id
+    add_index "<%= options[:task_dependencies_table_name] %>", :dependent_task_id
+  end
+
+  def self.down
+    drop_table "<%= options[:task_dependencies_table_name] %>"
+  end
+end

data/lib/generators/queue_dispatcher/migration/templates/task_queues.rb

@@ -0,0 +1,18 @@
+class CreateTaskQueues < ActiveRecord::Migration
+  def self.up
+    create_table "<%= options[:task_queues_table_name] %>" do |t|
+      t.string :name
+      t.string :state
+      t.integer :pid
+      t.boolean :terminate_immediately
+
+      t.timestamps
+    end
+
+    add_index "<%= options[:task_queues_table_name] %>", :name
+  end
+
+  def self.down
+    drop_table "<%= options[:task_queues_table_name] %>"
+  end
+end

data/lib/generators/queue_dispatcher/migration/templates/tasks.rb

@@ -0,0 +1,25 @@
+class CreateTasks < ActiveRecord::Migration
+  def self.up
+    create_table "<%= options[:tasks_table_name] %>" do |t|
+      t.text :target
+      t.string :method_name
+      t.text :args
+      t.string :state
+      t.integer :priority
+      t.string :message
+      t.integer :perc_finished
+      t.string :remark
+      t.text :output
+      t.text :error_msg
+      t.integer :task_queue_id
+  
+      t.timestamps
+    end
+
+    add_index "<%= options[:tasks_table_name] %>", :task_queue_id
+  end
+
+  def self.down
+    drop_table "<%= options[:tasks_table_name] %>"
+  end
+end

data/lib/queue_dispatcher/acts_as_task.rb

@@ -0,0 +1,194 @@
+module QueueDispatcher
+  module ActsAsTask
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+
+    class Config
+      attr_reader :task_queue_class_name
+
+      def initialize(task_queue_class_name)
+        @task_queue_class_name = task_queue_class_name.to_s.underscore
+      end
+    end
+
+
+    module ClassMethods
+      def acts_as_task args = {}
+        # Include number-helper for number_to_human_size method
+        include ActionView::Helpers::NumberHelper
+
+        include QueueDispatcher::ActsAsTask::InstanceMethods
+        extend QueueDispatcher::ActsAsTask::SingletonMethods
+
+        @acts_as_task_config = QueueDispatcher::ActsAsTask::Config.new(args[:task_queue_model] || :task_queue)
+
+        belongs_to            acts_as_task_config.task_queue_class_name
+        has_many              :task_dependencies, :dependent => :destroy, :foreign_key => :task_id
+        has_many              :dependent_tasks, :through => :task_dependencies
+        has_many              :inverse_task_dependencies, :class_name => 'TaskDependency', :foreign_key => 'dependent_task_id', :dependent => :destroy
+        has_many              :inverse_dependent_tasks, :through => :inverse_task_dependencies, :source => :task
+        validates_presence_of :target, :method_name, :state
+        serialize             :target
+        serialize             :args
+
+        # Add dynamic associations to task_dependency and task_property according to the class name
+        TaskDependency.instance_eval %Q{
+          belongs_to :task, :class_name => '#{self.name}'
+          belongs_to :dependent_task, :class_name => '#{self.name}'
+        }
+      end
+    end
+
+
+    module SingletonMethods
+      def acts_as_task_config
+        @acts_as_task_config
+      end
+    end
+
+
+    module InstanceMethods
+      def acts_as_task_task_queue
+        self.send(self.class.acts_as_task_config.task_queue_class_name)
+      end
+
+
+      # Add task_id to the args
+      def args
+        a = super
+        a[-1] = a.last.merge(task_id: self.id) if a && a.instance_of?(Array) && a.last.instance_of?(Hash)
+        a
+      end
+
+
+      # This method updates the task state according to the return code of their corresponding command
+      def update_state(rc_and_msg)
+        rc = output = error_msg = nil
+
+        if rc_and_msg.kind_of?(QueueDispatcher::RcAndMsg)
+          rc = rc_and_msg.rc
+          output = rc_and_msg.output
+          error_msg = rc_and_msg.error_msg
+        elsif rc_and_msg.kind_of?(Hash)
+          rc = rc_and_msg[:rc]
+          output = rc_and_msg[:output]
+          error_msg = rc_and_msg[:error_msg]
+        end
+
+        if rc.nil? || rc == 0
+          self.update_attributes :state => "successful",
+                                 :perc_finished => 100,
+                                 :message => output
+        else
+          self.update_attributes :state => "error",
+                                 :error_msg => error_msg,
+                                 :message => output
+        end
+      end
+
+
+      # Update the attributes perc_finished and message according to the args
+      def update_message args = {}
+        msg = args[:msg]
+        perc_finished = args[:perc_finished]
+
+        self.update_attribute :message, msg if msg
+        self.update_attribute :perc_finished, perc_finished if perc_finished
+      end
+
+
+      # Is this task new?
+      def new?
+         state == 'new' || state == 'new_popped'
+      end
+
+
+      # Is this task pending?
+      def pending?
+        acts_as_task_task_queue && state == 'new'
+      end
+
+
+      # Is this task pending?
+      def acquire_lock?
+        acts_as_task_task_queue && acts_as_task_task_queue.running? && state == 'acquire_lock'
+      end
+
+
+      # Is this task running?
+      def running?
+        acts_as_task_task_queue && acts_as_task_task_queue.running? && state == 'running'
+      end
+
+
+      # Was this task finsihed successful?
+      def successful?
+        state == 'successful' || state == 'finished'
+      end
+
+
+      # Had this task error(s)?
+      def error?
+        state == 'error' || state.blank?
+      end
+
+
+      # Was this task aborted?
+      def aborted?
+        state == 'aborted'
+      end
+
+
+      # Is this task waiting until the queue is initialized?
+      def init_queue?
+        state == 'init_queue'
+      end
+
+
+      # Was this task already executed?
+      def executed?
+        successful? || error? || aborted?
+      end
+
+
+      # Are all dependent_tasks executed?
+      def dependent_tasks_executed?
+        state = true
+        dependent_tasks.each{ |dt| state = false unless dt.executed? }
+        state
+      end
+
+
+      # Check recursive, if one or more of the tasks, which this task is dependent on had errors
+      def dependent_tasks_had_errors
+        error = false
+        dependent_tasks.each do |t|
+          error = true if t.state == 'error' || t.dependent_tasks_had_errors
+        end
+        error
+      end
+
+
+      # Placeholder. Please override it in your model.
+      def prosa
+      end
+
+
+      # Calculate md5-Checksum
+      def md5
+        attr_str = ""
+        Task.attribute_names.each{ |a| attr_str += self.send(a).to_s }
+        Digest('MD5').digest(attr_str)
+      end
+
+
+      # Execute task
+      def execute!
+        target.send(method_name, *args)
+      end
+
+    end
+  end
+end

data/lib/queue_dispatcher/acts_as_task_controller.rb

@@ -0,0 +1,95 @@
+module QueueDispatcher
+  module ActsAsTaskController
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+
+    class Config
+      attr_reader :task_class_name
+
+      def initialize(task_class_name)
+        @task_class_name = task_class_name.to_s.underscore
+      end
+    end
+
+
+    module ClassMethods
+      def acts_as_task_controller args = {}
+        include QueueDispatcher::ActsAsTaskController::InstanceMethods
+        extend QueueDispatcher::ActsAsTaskController::SingletonMethods
+        @acts_as_task_controller_config = QueueDispatcher::ActsAsTaskController::Config.new(args[:task_model] || :task)
+      end
+    end
+
+
+    module SingletonMethods
+      def acts_as_task_controller_config
+        @acts_as_task_controller_config
+      end
+    end
+
+
+    module InstanceMethods
+      def my_events
+        # Remember the selected page, if the AJAX-Request wants to update the current page
+        page = session[:my_events_page] = params[:page] if params[:page] || ! request.xhr?
+        page = session[:my_events_page] if page.nil? && request.xhr?
+        @tasks = current_user.send(self.class.acts_as_task_controller_config.task_class_name.pluralize).order('id DESC').page(page)
+
+        # Check for updated tasks
+        session[:task_updates] ||= {}
+        task_updates = {}
+        @new_tasks = []
+        @updated_tasks = []
+        @deleted_task_ids = []
+
+        if @tasks
+          @tasks.page(1).each do |task|
+            task_updates[task.id] = task.updated_at
+            @new_tasks << task unless session[:task_updates][task.id]
+            @updated_tasks << task if session[:task_updates][task.id] && session[:task_updates][task.id] != task.updated_at
+          end
+          session[:task_updates].each{ |id, updated_at| @deleted_task_ids << id unless eval(self.class.acts_as_task_controller_config.task_class_name.camelize).find_by_id(id) }
+          session[:task_updates] = task_updates
+        end
+
+        if request.xhr?
+          # Load expanded_events from session if this is a AJAX-request
+          @expanded_events = session[:acts_as_task_controller_expanded_events] || []
+        else
+          # Reset expanded_events if this is a regular request
+          @expanded_events = session[:acts_as_task_controller_expanded_events] = []
+        end
+
+        respond_to do |format|
+          format.html { render 'queue_dispatcher_views/my_events' }
+          format.js do
+            if params[:page]
+              render
+            else
+              render 'queue_dispatcher_views/update_events'
+            end
+          end
+        end
+      end
+
+
+      def expand_event
+        @task = eval(self.class.acts_as_task_controller_config.task_class_name.camelize).find(params[:id])
+        @expanded_events = session[:acts_as_task_controller_expanded_events] || []
+        if @expanded_events.include? @task.id
+          @expanded_events -= [@task.id]
+        else
+          @expanded_events |= [@task.id]
+        end
+        session[:acts_as_task_controller_expanded_events] = @expanded_events
+
+        respond_to do |format|
+          format.js { render 'queue_dispatcher_views/expand_event' }
+        end
+      end
+    end
+
+  end
+end