resque_admin-scheduler 1.0.4 → 1.0.5

data/lib/resque_admin/scheduler/plugin.rb

@@ -1,31 +0,0 @@
-# vim:fileencoding=utf-8
-
-module ResqueAdmin
-  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_admin/scheduler/scheduling_extensions.rb

@@ -1,141 +0,0 @@
-# vim:fileencoding=utf-8
-
-module ResqueAdmin
-  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_envs 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.
-      #
-      #    ResqueAdmin.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
-      def remove_schedule(name)
-        non_persistent_schedules.delete(name)
-        redis.hdel(:persistent_schedules, name)
-        redis.sadd(:schedules_changed, name)
-
-        reload_schedule!
-      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_admin/scheduler/server.rb

@@ -1,268 +0,0 @@
-# vim:fileencoding=utf-8
-require 'resque-scheduler'
-require 'resque_admin/server'
-require 'tilt/erb'
-require 'json'
-
-# Extend ResqueAdmin::Server to add tabs
-module ResqueAdmin
-  module Scheduler
-    module Server
-      TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'.freeze
-
-      unless defined?(::ResqueAdmin::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
-          ResqueAdmin.reload_schedule! if ResqueAdmin::Scheduler.dynamic
-          erb scheduler_template('scheduler')
-        end
-
-        def schedule_requeue
-          @job_name = params['job_name'] || params[:job_name]
-          config = ResqueAdmin.schedule[@job_name]
-          @parameters = config['parameters'] || config[:parameters]
-          if @parameters
-            erb scheduler_template('requeue-params')
-          else
-            ResqueAdmin::Scheduler.enqueue_from_config(config)
-            redirect u('/overview')
-          end
-        end
-
-        def schedule_requeue_with_params
-          job_name = params['job_name'] || params[:job_name]
-          config = ResqueAdmin.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)
-          ResqueAdmin::Scheduler.enqueue_from_config(config)
-          redirect u('/overview')
-        end
-
-        def delete_schedule
-          if ResqueAdmin::Scheduler.dynamic
-            job_name = params['job_name'] || params[:job_name]
-            ResqueAdmin.remove_schedule(job_name)
-          end
-          redirect u('/schedule')
-        end
-
-        def delayed
-          erb scheduler_template('delayed')
-        end
-
-        def delayed_jobs_klass
-          begin
-            klass = ResqueAdmin::Scheduler::Util.constantize(params[:klass])
-            @args = JSON.load(URI.decode(params[:args]))
-            @timestamps = ResqueAdmin.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(
-            ::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT
-          )
-
-          if timestamp > 0
-            unless ResqueAdmin::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 = ResqueAdmin::Scheduler::Util.constantize(params['klass'])
-          timestamp = params['timestamp']
-          args = ResqueAdmin.decode params['args']
-          ResqueAdmin.remove_delayed_job_from_timestamp(timestamp, klass, *args)
-          redirect u('/delayed')
-        end
-
-        def delayed_clear
-          ResqueAdmin.reset_delayed_queue
-          redirect u('delayed')
-        end
-      end
-
-      module HelperMethods
-        def format_time(t)
-          t.strftime(::ResqueAdmin::Scheduler::Server::TIMESTAMP_FORMAT)
-        end
-
-        def show_job_arguments(args)
-          Array(args).map(&:inspect).join("\n")
-        end
-
-        def queue_from_class_name(class_name)
-          ResqueAdmin.queue_from_class(
-            ResqueAdmin::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
-
-          ResqueAdmin.queues.each do |queue|
-            queued = ResqueAdmin.peek(queue, 0, ResqueAdmin.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?(ResqueAdmin::Scheduler.env)
-        end
-
-        def rails_env(name)
-          ResqueAdmin.schedule[name]['rails_env'] || ResqueAdmin.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 = [*ResqueAdmin.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 = ResqueAdmin.delayed_queue_schedule_size
-            ResqueAdmin.delayed_queue_peek(0, schedule_size).each do |d|
-              ResqueAdmin.delayed_timestamp_peek(
-                d, 0, ResqueAdmin.delayed_timestamp_size(d)
-              ).each do |j|
-                dels << j.merge!('timestamp' => d)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ResqueAdmin::Server.tabs << 'Schedule'
-ResqueAdmin::Server.tabs << 'Delayed'
-
-ResqueAdmin::Server.class_eval do
-  include ResqueAdmin::Scheduler::Server
-end

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

@@ -1,63 +0,0 @@
-<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/#{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 %>