istox-resque-scheduler 1.0.0.pre

data/lib/resque/scheduler/plugin.rb

@@ -0,0 +1,31 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    module Plugin
+      def self.hooks(job, pattern)
+        job.methods.grep(/^#{pattern}/).sort
+      end
+
+      def self.run_hooks(job, pattern, *args)
+        results = hooks(job, pattern).map do |hook|
+          job.send(hook, *args)
+        end
+
+        results.all? { |result| result != false }
+      end
+
+      def self.run_before_delayed_enqueue_hooks(klass, *args)
+        run_hooks(klass, 'before_delayed_enqueue', *args)
+      end
+
+      def self.run_before_schedule_hooks(klass, *args)
+        run_hooks(klass, 'before_schedule', *args)
+      end
+
+      def self.run_after_schedule_hooks(klass, *args)
+        run_hooks(klass, 'after_schedule', *args)
+      end
+    end
+  end
+end

data/lib/resque/scheduler/scheduling_extensions.rb

@@ -0,0 +1,142 @@
+# vim:fileencoding=utf-8
+
+module Resque
+  module Scheduler
+    module SchedulingExtensions
+      # Accepts a new schedule configuration of the form:
+      #
+      #   {
+      #     "MakeTea" => {
+      #       "every" => "1m" },
+      #     "some_name" => {
+      #       "cron"        => "5/* * * *",
+      #       "class"       => "DoSomeWork",
+      #       "args"        => "work on this string",
+      #       "description" => "this thing works it"s butter off" },
+      #     ...
+      #   }
+      #
+      # Hash keys can be anything and are used to describe and reference
+      # the scheduled job. If the "class" argument is missing, the key
+      # is used implicitly as "class" argument - in the "MakeTea" example,
+      # "MakeTea" is used both as job name and resque worker class.
+      #
+      # Any jobs that were in the old schedule, but are not
+      # present in the new schedule, will be removed.
+      #
+      # :cron can be any cron scheduling string
+      #
+      # :every can be used in lieu of :cron. see rufus-scheduler's 'every'
+      # usage for valid syntax. If :cron is present it will take precedence
+      # over :every.
+      #
+      # :class must be a resque worker class. If it is missing, the job name
+      # (hash key) will be used as :class.
+      #
+      # :args can be any yaml which will be converted to a ruby literal and
+      # passed in a params. (optional)
+      #
+      # :rails_env is the list of envs where the job gets loaded. Envs are
+      # comma separated (optional)
+      #
+      # :description is just that, a description of the job (optional). If
+      # params is an array, each element in the array is passed as a separate
+      # param, otherwise params is passed in as the only parameter to
+      # perform.
+      def schedule=(schedule_hash)
+        @non_persistent_schedules = nil
+        prepared_schedules = prepare_schedules(schedule_hash)
+
+        prepared_schedules.each do |schedule, config|
+          set_schedule(schedule, config, false)
+        end
+
+        # ensure only return the successfully saved data!
+        reload_schedule!
+      end
+
+      # Returns the schedule hash
+      def schedule
+        @schedule ||= all_schedules
+        @schedule || {}
+      end
+
+      # reloads the schedule from redis and memory
+      def reload_schedule!
+        @schedule = all_schedules
+      end
+
+      # gets the schedules as it exists in redis
+      def all_schedules
+        non_persistent_schedules.merge(persistent_schedules)
+      end
+
+      # Create or update a schedule with the provided name and configuration.
+      #
+      # Note: values for class and custom_job_class need to be strings,
+      # not constants.
+      #
+      #    Resque.set_schedule('some_job', {:class => 'SomeJob',
+      #                                     :every => '15mins',
+      #                                     :queue => 'high',
+      #                                     :args => '/tmp/poop'})
+      #
+      # Preventing a reload is optional and available to batch operations
+      def set_schedule(name, config, reload = true)
+        persist = config.delete(:persist) || config.delete('persist')
+
+        if persist
+          redis.hset(:persistent_schedules, name, encode(config))
+        else
+          non_persistent_schedules[name] = decode(encode(config))
+        end
+
+        redis.sadd(:schedules_changed, name)
+        reload_schedule! if reload
+      end
+
+      # retrive the schedule configuration for the given name
+      def fetch_schedule(name)
+        schedule[name]
+      end
+
+      # remove a given schedule by name
+      # Preventing a reload is optional and available to batch operations
+      def remove_schedule(name, reload = true)
+        non_persistent_schedules.delete(name)
+        redis.hdel(:persistent_schedules, name)
+        redis.sadd(:schedules_changed, name)
+
+        reload_schedule! if reload
+      end
+
+      private
+
+      # we store our non-persistent schedules in this hash
+      def non_persistent_schedules
+        @non_persistent_schedules ||= {}
+      end
+
+      # reads the persistent schedules from redis
+      def persistent_schedules
+        redis.hgetall(:persistent_schedules).tap do |h|
+          h.each do |name, config|
+            h[name] = decode(config)
+          end
+        end
+      end
+
+      def prepare_schedules(schedule_hash)
+        prepared_hash = {}
+        schedule_hash.each do |name, job_spec|
+          job_spec = job_spec.dup
+          unless job_spec.key?('class') || job_spec.key?(:class)
+            job_spec['class'] = name
+          end
+          prepared_hash[name] = job_spec
+        end
+        prepared_hash
+      end
+    end
+  end
+end

data/lib/resque/scheduler/server.rb

@@ -0,0 +1,268 @@
+# vim:fileencoding=utf-8
+require 'resque-scheduler'
+require 'resque/server'
+require 'tilt/erb'
+require 'json'
+
+# Extend Resque::Server to add tabs
+module Resque
+  module Scheduler
+    module Server
+      TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'.freeze
+
+      unless defined?(::Resque::Scheduler::Server::VIEW_PATH)
+        VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
+      end
+
+      def self.included(base)
+        base.class_eval do
+          helpers { include HelperMethods }
+          include ServerMethods
+
+          get('/schedule') { schedule }
+          post('/schedule/requeue') { schedule_requeue }
+          post('/schedule/requeue_with_params') do
+            schedule_requeue_with_params
+          end
+          delete('/schedule') { delete_schedule }
+          get('/delayed') { delayed }
+          get('/delayed/jobs/:klass') { delayed_jobs_klass }
+          post('/delayed/search') { delayed_search }
+          get('/delayed/:timestamp') { delayed_timestamp }
+          post('/delayed/queue_now') { delayed_queue_now }
+          post('/delayed/cancel_now') { delayed_cancel_now }
+          post('/delayed/clear') { delayed_clear }
+        end
+      end
+
+      module ServerMethods
+        def schedule
+          Resque.reload_schedule! if Resque::Scheduler.dynamic
+          erb scheduler_template('scheduler')
+        end
+
+        def schedule_requeue
+          @job_name = params['job_name'] || params[:job_name]
+          config = Resque.schedule[@job_name]
+          @parameters = config['parameters'] || config[:parameters]
+          if @parameters
+            erb scheduler_template('requeue-params')
+          else
+            Resque::Scheduler.enqueue_from_config(config)
+            redirect u('/overview')
+          end
+        end
+
+        def schedule_requeue_with_params
+          job_name = params['job_name'] || params[:job_name]
+          config = Resque.schedule[job_name]
+          # Build args hash from post data (removing the job name)
+          submitted_args = params.reject do |key, _value|
+            key == 'job_name' || key == :job_name
+          end
+
+          # Merge constructed args hash with existing args hash for
+          # the job, if it exists
+          config_args = config['args'] || config[:args] || {}
+          config_args = config_args.merge(submitted_args)
+
+          # Insert the args hash into config and queue the resque job
+          config = config.merge('args' => config_args)
+          Resque::Scheduler.enqueue_from_config(config)
+          redirect u('/overview')
+        end
+
+        def delete_schedule
+          if Resque::Scheduler.dynamic
+            job_name = params['job_name'] || params[:job_name]
+            Resque.remove_schedule(job_name)
+          end
+          redirect u('/schedule')
+        end
+
+        def delayed
+          erb scheduler_template('delayed')
+        end
+
+        def delayed_jobs_klass
+          begin
+            klass = Resque::Scheduler::Util.constantize(params[:klass])
+            @args = JSON.load(URI.decode(params[:args]))
+            @timestamps = Resque.scheduled_at(klass, *@args)
+          rescue
+            @timestamps = []
+          end
+
+          erb scheduler_template('delayed_schedules')
+        end
+
+        def delayed_search
+          @jobs = find_job(params[:search])
+          erb scheduler_template('search')
+        end
+
+        def delayed_timestamp
+          erb scheduler_template('delayed_timestamp')
+        end
+
+        def delayed_queue_now
+          timestamp = params['timestamp'].to_i
+          formatted_time = Time.at(timestamp).strftime(
+            ::Resque::Scheduler::Server::TIMESTAMP_FORMAT
+          )
+
+          if timestamp > 0
+            unless Resque::Scheduler.enqueue_next_item(timestamp)
+              @error_message = "Unable to remove item at #{formatted_time}"
+            end
+          else
+            @error_message = "Incorrect timestamp #{formatted_time}"
+          end
+
+          erb scheduler_template('delayed')
+        end
+
+        def delayed_cancel_now
+          klass = Resque::Scheduler::Util.constantize(params['klass'])
+          timestamp = params['timestamp']
+          args = Resque.decode params['args']
+          Resque.remove_delayed_job_from_timestamp(timestamp, klass, *args)
+          redirect u('/delayed')
+        end
+
+        def delayed_clear
+          Resque.reset_delayed_queue
+          redirect u('delayed')
+        end
+      end
+
+      module HelperMethods
+        def format_time(t)
+          t.strftime(::Resque::Scheduler::Server::TIMESTAMP_FORMAT)
+        end
+
+        def show_job_arguments(args)
+          Array(args).map(&:inspect).join("\n")
+        end
+
+        def queue_from_class_name(class_name)
+          Resque.queue_from_class(
+            Resque::Scheduler::Util.constantize(class_name)
+          )
+        end
+
+        def find_job(worker)
+          worker = worker.downcase
+          results = working_jobs_for_worker(worker)
+
+          dels = delayed_jobs_for_worker(worker)
+          results += dels.select do |j|
+            j['class'].downcase.include?(worker) &&
+              j.merge!('where_at' => 'delayed')
+          end
+
+          Resque.queues.each do |queue|
+            queued = Resque.peek(queue, 0, Resque.size(queue))
+            queued = [queued] unless queued.is_a?(Array)
+            results += queued.select do |j|
+              j['class'].downcase.include?(worker) &&
+                j.merge!('queue' => queue, 'where_at' => 'queued')
+            end
+          end
+
+          results
+        end
+
+        def schedule_interval(config)
+          if config['every']
+            schedule_interval_every(config['every'])
+          elsif config['cron']
+            'cron: ' + config['cron'].to_s
+          else
+            'Not currently scheduled'
+          end
+        end
+
+        def schedule_interval_every(every)
+          every = [*every]
+          s = 'every: ' << every.first
+
+          return s unless every.length > 1
+
+          s << ' ('
+          meta = every.last.map do |key, value|
+            "#{key.to_s.tr('_', ' ')} #{value}"
+          end
+          s << meta.join(', ') << ')'
+        end
+
+        def schedule_class(config)
+          if config['class'].nil? && !config['custom_job_class'].nil?
+            config['custom_job_class']
+          else
+            config['class']
+          end
+        end
+
+        def scheduler_template(name)
+          File.read(
+            File.expand_path("../server/views/#{name}.erb", __FILE__)
+          )
+        end
+
+        def scheduled_in_this_env?(name)
+          return true if rails_env(name).nil?
+          rails_env(name).split(/[\s,]+/).include?(Resque::Scheduler.env)
+        end
+
+        def rails_env(name)
+          Resque.schedule[name]['rails_env'] || Resque.schedule[name]['env']
+        end
+
+        def scheduler_view(filename, options = {}, locals = {})
+          source = File.read(File.join(VIEW_PATH, "#{filename}.erb"))
+          erb source, options, locals
+        end
+
+        private
+
+        def working_jobs_for_worker(worker)
+          [].tap do |results|
+            working = [*Resque.working]
+            work = working.select do |w|
+              w.job && w.job['payload'] &&
+                w.job['payload']['class'].downcase.include?(worker)
+            end
+            work.each do |w|
+              results += [
+                w.job['payload'].merge(
+                  'queue' => w.job['queue'], 'where_at' => 'working'
+                )
+              ]
+            end
+          end
+        end
+
+        def delayed_jobs_for_worker(_worker)
+          [].tap do |dels|
+            schedule_size = Resque.delayed_queue_schedule_size
+            Resque.delayed_queue_peek(0, schedule_size).each do |d|
+              Resque.delayed_timestamp_peek(
+                d, 0, Resque.delayed_timestamp_size(d)
+              ).each do |j|
+                dels << j.merge!('timestamp' => d)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Resque::Server.tabs << 'Schedule'
+Resque::Server.tabs << 'Delayed'
+
+Resque::Server.class_eval do
+  include Resque::Scheduler::Server
+end

data/lib/resque/scheduler/server/views/delayed.erb

@@ -0,0 +1,63 @@
+<h1>Delayed Jobs</h1>
+<%- size = resque.delayed_queue_schedule_size %>
+
+<%= scheduler_view :search_form, layout: false %>
+
+<p style="font-color: red; font-weight: bold;">
+  <%= @error_message %>
+</p>
+
+<p class='intro'>
+  This list below contains the timestamps for scheduled delayed jobs.
+  Server local time: <%= Time.now %>
+</p>
+
+<p class='sub'>
+  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%= size %></b> timestamps
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Timestamp</th>
+    <th>Job count</th>
+    <th>Class</th>
+    <th>Args</th>
+    <th>All schedules</th>
+  </tr>
+  <% resque.delayed_queue_peek(start, 20).each do |timestamp| %>
+    <tr>
+      <td>
+        <form action="<%= u "/delayed/queue_now" %>" method="post">
+          <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
+          <input type="submit" value="Queue now">
+        </form>
+      </td>
+      <td><a href="<%= u "delayed/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
+      <td><%= delayed_timestamp_size = resque.delayed_timestamp_size(timestamp) %></td>
+      <% job = resque.delayed_timestamp_peek(timestamp, 0, 1).first %>
+      <td>
+        <% if job && delayed_timestamp_size == 1 %>
+          <%= h(job['class']) %>
+        <% else %>
+          <a href="<%= u "delayed/#{timestamp}" %>">see details</a>
+        <% end %>
+      </td>
+      <td><%= h(show_job_arguments(job['args'])) if job && delayed_timestamp_size == 1 %></td>
+      <td>
+        <% if job %>
+          <a href="<%=u URI("/delayed/jobs/#{URI.escape(job['class'])}?args=" + URI.encode(job['args'].to_json)) %>">All schedules</a>
+        <% end %>
+      </td>
+    </tr>
+  <% end %>
+</table>
+
+<% if size > 0 %>
+  <br>
+  <form method="POST" action="<%=u 'delayed/clear'%>" class='clear-delayed'>
+    <input type='submit' name='' value='Clear Delayed Jobs' />
+  </form>
+<% end %>
+
+<%= partial :next_more, :start => start, :size => size %>