resque-job_history 0.0.2

data/lib/resque/plugins/job_history/history_list.rb

@@ -0,0 +1,88 @@
+module Resque
+  module Plugins
+    module JobHistory
+      # JobHistory cleanup functions to allow the user to cleanup Redis for histories.
+      class HistoryList < HistoryBase
+        attr_accessor :list_name
+
+        def initialize(class_name, list_name)
+          super(class_name)
+
+          @list_name = list_name
+        end
+
+        def add_job(job_id)
+          add_to_history
+
+          job_count = redis.lpush(job_list_key, job_id)
+          redis.incr(total_jobs_key)
+
+          delete_old_jobs(job_count)
+
+          job_count
+        end
+
+        def remove_job(job_id)
+          redis.lrem(job_list_key, 0, job_id)
+        end
+
+        def paged_jobs(page_num = 1, page_size = nil)
+          page_size ||= class_page_size
+          page_size = Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE if page_size.to_i < 1
+          start     = (page_num - 1) * page_size
+          start     = 0 if start >= num_jobs
+
+          jobs(start, start + page_size - 1)
+        end
+
+        def jobs(start = 0, stop = -1)
+          job_ids(start, stop).map do |job_id|
+            Resque::Plugins::JobHistory::Job.new(class_name, job_id)
+          end
+        end
+
+        def job_ids(start = 0, stop = -1)
+          redis.lrange(job_list_key, start, stop)
+        end
+
+        def num_jobs
+          redis.llen(job_list_key)
+        end
+
+        def total
+          redis.get(total_jobs_key).to_i
+        end
+
+        def latest_job
+          job_id = redis.lrange(job_list_key, 0, 0).first
+
+          Resque::Plugins::JobHistory::Job.new(class_name, job_id) if job_id
+        end
+
+        private
+
+        def add_to_history
+          redis.sadd(job_history_key, class_name)
+        end
+
+        def delete_old_jobs(job_count)
+          max_jobs = class_history_len
+
+          while job_count > max_jobs
+            Resque::Plugins::JobHistory::Job.new(class_name, redis.rpop(job_list_key)).purge
+
+            job_count -= 1
+          end
+        end
+
+        def total_jobs_key
+          "#{job_history_base_key}.total_#{list_name}_jobs"
+        end
+
+        def job_list_key
+          "#{job_history_base_key}.#{list_name}_jobs"
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_history/job.rb

@@ -0,0 +1,144 @@
+module Resque
+  module Plugins
+    module JobHistory
+      # a class encompassing a single job.
+      class Job < HistoryBase
+        attr_accessor :job_id
+
+        def initialize(class_name, job_id)
+          super(class_name)
+
+          @job_id = job_id
+        end
+
+        def job_key
+          "#{job_history_base_key}.#{job_id}"
+        end
+
+        def start_time
+          stored_values[:start_time].try(:to_time)
+        end
+
+        def finished?
+          stored_values[:end_time].present?
+        end
+
+        def succeeded?
+          error.blank?
+        end
+
+        def duration
+          (end_time || Time.now) - start_time
+        end
+
+        def end_time
+          stored_values[:end_time].try(:to_time)
+        end
+
+        def args
+          decode_args(stored_values[:args])
+        end
+
+        def error
+          stored_values[:error]
+        end
+
+        def start(*args)
+          num_jobs = running_list.add_job(job_id)
+
+          record_num_jobs(num_jobs)
+          record_job_start(*args)
+        end
+
+        def finish
+          redis.hset(job_key, "end_time", Time.now.utc.to_s)
+
+          finished_list.add_job(job_id)
+          running_list.remove_job(job_id)
+        end
+
+        def failed(exception)
+          redis.hset(job_key, "error", exception.message)
+
+          finish
+        end
+
+        def cancel
+          redis.hset(job_key,
+                     "error",
+                     "Unknown - Job failed to signal ending after the configured purge time or "\
+                       "was canceled manually.")
+
+          finish
+        end
+
+        def retry
+          return unless described_class
+
+          Resque.enqueue described_class, *args
+        end
+
+        def purge
+          running_list.remove_job(job_id)
+          finished_list.remove_job(job_id)
+
+          redis.del(job_key)
+        end
+
+        def max_jobs
+          redis.get(max_running_key).to_i
+        end
+
+        private
+
+        def record_job_start(*args)
+          redis.hset(job_key, "start_time", Time.now.utc.to_s)
+          redis.hset(job_key, "args", encode_args(*args))
+        end
+
+        def stored_values
+          unless @stored_values
+            @stored_values = redis.hgetall(job_key).with_indifferent_access
+          end
+
+          @stored_values
+        end
+
+        def encode_args(*args)
+          Resque.encode(args)
+        end
+
+        def decode_args(args_string)
+          Resque.decode(args_string)
+        end
+
+        def record_num_jobs(num_jobs)
+          if redis.get(max_running_key).to_i < num_jobs
+            redis.set(max_running_key, num_jobs)
+          end
+
+          return unless num_jobs > class_history_len
+
+          clean_old_running_jobs
+        end
+
+        def max_running_key
+          "#{job_history_base_key}.max_jobs"
+        end
+
+        def clean_old_running_jobs
+          too_old_time = class_purge_age.ago
+
+          running_list.jobs.each do |job|
+            job_start = job.start_time
+
+            if job_start.blank? || job_start.to_time < too_old_time
+              job.start(*job.args) if job_start.blank?
+              job.cancel
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_history/job_list.rb

@@ -0,0 +1,90 @@
+module Resque
+  module Plugins
+    module JobHistory
+      # A class encompassing tasks about the jobs as a whole.
+      #
+      # This class gets a list of the classes and can provide a summary for each.
+      class JobList < HistoryBase
+        def initialize
+          super("")
+        end
+
+        def order_param(sort_option, current_sort, current_order)
+          current_order ||= "asc"
+
+          if sort_option == current_sort
+            current_order == "asc" ? "desc" : "asc"
+          else
+            "asc"
+          end
+        end
+
+        def job_summaries(sort_key = :class_name,
+                          sort_order = "asc",
+                          page_num = 1,
+                          page_size = Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE)
+          jobs = sorted_job_summaries(sort_key)
+
+          page_start = (page_num - 1) * page_size
+          page_start = 0 if page_start > jobs.length
+
+          (sort_order == "desc" ? jobs.reverse : jobs)[page_start..page_start + page_size - 1]
+        end
+
+        def job_classes
+          redis.smembers(job_history_key)
+        end
+
+        def job_class_summary(class_name)
+          history = Resque::Plugins::JobHistory::HistoryBase.new(class_name)
+
+          running_list  = history.running_list
+          finished_list = history.finished_list
+
+          class_summary_hash(class_name, finished_list, running_list)
+        end
+
+        private
+
+        def latest_job(running_list, finished_list)
+          running_list.latest_job || finished_list.latest_job
+        end
+
+        def sorted_job_summaries(sort_key)
+          job_classes.map { |class_name| job_class_summary(class_name) }.sort_by do |job_summary|
+            summary_sort_value(job_summary, sort_key)
+          end
+        end
+
+        def summary_sort_value(job_summary, sort_key)
+          case sort_key.to_sym
+            when :class_name,
+                :running_jobs,
+                :finished_jobs,
+                :total_finished_jobs,
+                :total_run_jobs,
+                :max_running_jobs
+              job_summary[sort_key.to_sym]
+            when :start_time
+              job_summary[:last_run].start_time
+            when :durration
+              job_summary[:last_run].duration
+            when :success
+              job_summary[:last_run].succeeded?
+          end
+        end
+
+        def class_summary_hash(class_name, finished_list, running_list)
+          { class_name:          class_name,
+            class_name_valid:    running_list.class_name_valid?,
+            running_jobs:        running_list.num_jobs,
+            finished_jobs:       finished_list.num_jobs,
+            total_run_jobs:      running_list.total,
+            total_finished_jobs: finished_list.total,
+            max_running_jobs:    Resque::Plugins::JobHistory::Job.new(class_name, "").max_jobs,
+            last_run:            latest_job(running_list, finished_list) }
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/version.rb

@@ -0,0 +1,7 @@
+module Resque
+  module Plugins
+    module JobHistory
+      VERSION = "0.0.2"
+    end
+  end
+end

data/lib/resque/server/public/job_history.css

@@ -0,0 +1,29 @@
+.job_history_pagination_block {
+    width:           100%;
+    display:         flex;
+    justify-content: space-between;
+    margin-bottom:   5px;
+}
+
+.job_history_first_page {
+    margin-right: 5px;
+}
+
+.job_history_prev_page {
+    margin-right: 5px;
+    margin-left:  5px;
+}
+
+.job_history_page {
+    margin-right: 5px;
+    margin-left:  5px;
+}
+
+.job_history_next_page {
+    margin-right: 5px;
+    margin-left:  5px;
+}
+
+.job_history_last_page {
+    margin-left: 5px;
+}

data/lib/resque/server/views/_job_class_pagination.erb

@@ -0,0 +1,67 @@
+<div class="job_history_pagination_block">
+  <% total_pages = job_list.job_classes.length / page_size %>
+  <% total_pages += 1 if job_list.job_classes.length % page_size > 0 %>
+  <% page_num = 1 if page_num > total_pages %>
+  <% first_page = [1, page_num - 3].max %>
+  <% last_page = [total_pages, page_num + 3].min %>
+  <% last_page = page_num < 4 ? [total_pages, last_page + (4 - page_num)].min : last_page %>
+  <% first_page = page_num > total_pages - 3 ? [1, first_page + ((total_pages - page_num) - 3)].max : first_page %>
+
+  <% if total_pages > 1 %>
+    <div class="job_history_prev_links">
+      <a href="job%20history?<%= { sort:      @sort_by,
+                                   page_size: page_size,
+                                   page_num:  1,
+                                   order:     @sort_order }.to_param %>"
+         class="job_history_first_page"
+         disabled="<%= first_page > 1 %>">
+        &lt;&lt; First
+      </a>
+
+      <a href="job%20history?<%= { sort:      @sort_by,
+                                   page_size: page_size,
+                                   page_num:  page_num - 1,
+                                   order:     @sort_order }.to_param %>"
+         class="job_history_prev_page"
+         disabled="<%= page_num > 1 %>">
+        &lt; Prev
+      </a>
+    </div>
+
+    <div class="job_history_pages">
+      <% (first_page..last_page).each do |page_number| %>
+        <% if page_number != page_num %>
+          <a href="job%20history?<%= { sort:      @sort_by,
+                                       page_size: page_size,
+                                       page_num:  page_number,
+                                       order:     @sort_order }.to_param %>"
+             class="job_history_page">
+            <%= page_number %>
+          </a>
+        <% else %>
+          <%= page_number %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class="job_history_next_links">
+      <a href="job%20history?<%= { sort:      @sort_by,
+                                   page_size: page_size,
+                                   page_num:  page_num + 1,
+                                   order:     @sort_order }.to_param %>"
+         class="job_history_next_page"
+         disabled="<%= page_num < last_page %>">
+        Next &gt;
+      </a>
+
+      <a href="job%20history?<%= { sort:      @sort_by,
+                                   page_size: page_size,
+                                   page_num:  total_pages,
+                                   order:     @sort_order }.to_param %>"
+         class="job_history_last_page"
+         disabled="<%= last_page < total_pages %>">
+        Last &gt;&gt;
+      </a>
+    </div>
+  <% end %>
+</div>

data/lib/resque/server/views/_job_pagination.erb

@@ -0,0 +1,71 @@
+<div class="job_history_pagination_block">
+  <% total_pages = history_list.num_jobs / page_size %>
+  <% total_pages += 1 if history_list.num_jobs % page_size > 0 %>
+  <% first_page = [1, page_num - 3].max %>
+  <% last_page = [total_pages, page_num + 3].min %>
+  <% last_page = page_num < 4 ? [total_pages, last_page + (4 - page_num)].min : last_page %>
+  <% first_page = page_num > total_pages - 3 ? [1, first_page + ((total_pages - page_num) - 3)].max : first_page %>
+
+  <% if total_pages > 1 %>
+    <div class="job_history_prev_links">
+      <a href="job_class_details?<%= { class_name:                   class_name,
+                                       "#{primary_type}_page_size"   => page_size,
+                                       "#{primary_type}_page_num"    => 1,
+                                       "#{secondary_type}_page_size" => secondary_page_size,
+                                       "#{secondary_type}_page_num"  => secondary_page_num }.to_param %>"
+         class="job_history_first_page"
+         disabled="<%= first_page > 1 %>">
+        &lt;&lt; First
+      </a>
+
+      <a href="job_class_details?<%= { class_name:                   class_name,
+                                       "#{primary_type}_page_size"   => page_size,
+                                       "#{primary_type}_page_num"    => [1, page_num - 1].max,
+                                       "#{secondary_type}_page_size" => secondary_page_size,
+                                       "#{secondary_type}_page_num"  => secondary_page_num }.to_param %>"
+         class="job_history_prev_page"
+         disabled="<%= page_num > 1 %>">
+        &lt; Prev
+      </a>
+    </div>
+
+    <div class="job_history_pages">
+      <% (first_page..last_page).each do |page_number| %>
+        <% if page_number != page_num %>
+          <a href="job_class_details?<%= { class_name:                   class_name,
+                                           "#{primary_type}_page_size"   => page_size,
+                                           "#{primary_type}_page_num"    => page_number,
+                                           "#{secondary_type}_page_size" => secondary_page_size,
+                                           "#{secondary_type}_page_num"  => secondary_page_num }.to_param %>"
+             class="job_history_page">
+            <%= page_number %>
+          </a>
+        <% else %>
+          <%= page_number %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class="job_history_next_links">
+      <a href="job_class_details?<%= { class_name:                   class_name,
+                                       "#{primary_type}_page_size"   => page_size,
+                                       "#{primary_type}_page_num"    => [total_pages, page_num + 1].min,
+                                       "#{secondary_type}_page_size" => secondary_page_size,
+                                       "#{secondary_type}_page_num"  => secondary_page_num }.to_param %>"
+         class="job_history_next_page"
+         disabled="<%= page_num < last_page %>">
+        Next &gt;
+      </a>
+
+      <a href="job_class_details?<%= { class_name:                   class_name,
+                                       "#{primary_type}_page_size"   => page_size,
+                                       "#{primary_type}_page_num"    => total_pages,
+                                       "#{secondary_type}_page_size" => secondary_page_size,
+                                       "#{secondary_type}_page_num"  => secondary_page_num }.to_param %>"
+         class="job_history_last_page"
+         disabled="<%= last_page < total_pages %>">
+        Last &gt;&gt;
+      </a>
+    </div>
+  <% end %>
+</div>