sidekiq-web_custom 0.2.0

data/lib/sidekiq/views/scheduled.erb

@@ -0,0 +1,97 @@
+<header class="row">
+  <div class="col-sm-5">
+    <h3><%= t('ScheduledJobs') %></h3>
+  </div>
+  <% if @scheduled.size > 0 && @total_size > @count %>
+    <div class="col-sm-4">
+      <%= erb :_paging, locals: { url: "#{root_path}scheduled" } %>
+    </div>
+  <% end %>
+  <%= filtering('scheduled') %>
+</header>
+
+<% if @scheduled.size > 0 %>
+
+  <form action="<%= root_path %>scheduled" method="post">
+    <%= csrf_tag %>
+    <div class="table_container">
+      <table class="table table-striped table-bordered">
+        <thead>
+          <tr>
+            <th class="checkbox-column">
+              <input type="checkbox" class="check_all" />
+            </th>
+            <th><%= t('When') %></th>
+            <th><%= t('Queue') %></th>
+            <th><%= t('Job') %></th>
+            <th><%= t('Arguments') %></th>
+            <th><%= t('Actions') %></th>
+          </tr>
+        </thead>
+        <% @scheduled.each do |entry| %>
+          <tr>
+            <td>
+              <input type='checkbox' name='key[]' value='<%= job_params(entry.item, entry.score) %>' />
+            </td>
+            <td>
+               <a href="<%= root_path %>scheduled/<%= job_params(entry.item, entry.score) %>"><%= relative_time(entry.at) %></a>
+            </td>
+            <td>
+              <a href="<%= root_path %>queues/<%= entry.queue %>"><%= entry.queue %></a>
+            </td>
+            <td>
+              <%= entry.display_class %>
+              <%= display_tags(entry, "scheduled") %>
+            </td>
+            <td>
+               <div class="args"><%= display_args(entry.display_args) %></div>
+            </td>
+            <td>
+              __sidekiq_web_custom_replacement__
+            </td>
+          </tr>
+        <% end %>
+      </table>
+    </div>
+    <input class="btn btn-danger pull-right flip" type="submit" name="delete" value="<%= t('Delete') %>" />
+    <input class="btn btn-danger pull-right flip" type="submit" name="add_to_queue" value="<%= t('AddToQueue') %>" />
+  </form>
+<% else %>
+  <div class="alert alert-success"><%= t('NoScheduledFound') %></div>
+<% end %>
+
+<div id="_sidekiq_web_block_screen_div_" style='display: none'>
+  <div id="_sidekiq_web_block_screen_text_"></div>
+</div>
+
+<script type="text/javascript">
+  function _sidekiq_web_block_screen(text) {
+    document.getElementById('_sidekiq_web_block_screen_text_').innerHTML = text
+    document.getElementById('_sidekiq_web_block_screen_div_').style.display = "block";
+  }
+</script>
+
+<style>
+#_sidekiq_web_block_screen_div_ {
+  position: fixed;
+  display: none;
+  width: 100%;
+  height: 100%;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: rgba(0,0,0,0.8);
+  z-index: 2;
+}
+
+#_sidekiq_web_block_screen_text_{
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  font-size: 50px;
+  color: white;
+  transform: translate(-50%,-50%);
+  -ms-transform: translate(-50%,-50%);
+}
+</style>

data/lib/sidekiq/web_custom.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'byebug'
+require_relative 'web_custom/version'
+
+# require sidekiq/web first to ensure web_Action will prepend correctly
+require 'sidekiq/web'
+require 'sidekiq/web_custom/configuration'
+require 'sidekiq/web_custom/web_action'
+require 'sidekiq/web_custom/queue'
+require 'sidekiq/web_custom/job'
+require 'sidekiq/web_custom/web_app'
+
+module Sidekiq
+  module WebCustom
+    class Error < StandardError; end
+    class ArgumentError < Error; end
+    class FileNotFound < Error; end
+    class StopExecution < Error; end
+    class ExecutionTimeExceeded < Error; end
+    class ConfigurationEstablished < Error; end
+
+    BREAK_BIT = '__sidekiq-web_custom-breakbit__'
+
+    def self.default_available_actions_mapping
+      @available_actions_mapping ||= begin
+        temp = {}
+        Dir["#{actions_root}/**/*.erb"].map do |erb_path|
+          base_path = File.basename(erb_path).split('.')[0]
+          second_half = erb_path.split(actions_root)[1]
+          action_type = second_half.split(base_path)[0]
+          action_type = action_type.delete('/').to_sym
+          temp[action_type] ||= {}
+          temp[action_type][base_path.to_sym] = erb_path
+        end
+        temp
+      end
+    end
+
+    def self.default_local_erb_mapping
+      @local_erb_mapping ||= Dir["#{local_erbs_root}/*.erb"].map do |erb_path|
+        [File.basename(erb_path).split('.')[0].to_sym, erb_path]
+      end.to_h
+    end
+
+    def self.actions_root
+      @actions_root ||= "#{local_erbs_root}/actions"
+    end
+
+    def self.local_erbs_root
+      @local_erbs_root ||= "#{root_path}/views"
+    end
+
+    def self.root_path
+      @root_path ||= File.dirname(__FILE__)
+    end
+
+    def self.config
+      @config ||= Configuration.new.tap do |t|
+        t.merge(base: :actions, params: default_available_actions_mapping)
+        t.merge(base: :local_erbs, params: default_local_erb_mapping)
+      end
+    end
+
+    def self.configure
+      yield config if block_given?
+
+      config.validate!
+      __inject_dependencies
+    end
+
+    def self.local_erb_mapping
+      config.local_erbs
+    end
+
+    def self.reset!
+      @config = nil
+    end
+
+    private
+
+    def self.__inject_dependencies
+      return if @__already_called
+
+      @__already_called = true
+      ::Sidekiq::WebAction.prepend WebAction
+      ::Sidekiq::Queue.prepend Queue
+      ::Sidekiq::Job.prepend Job
+      ::Sidekiq::Web.register WebApp
+    end
+  end
+end
+
+# dependent the error classes loaded on boot, requie after code is loaded
+require 'sidekiq/web_custom/timeout'

data/lib/sidekiq/web_custom/configuration.rb

@@ -0,0 +1,112 @@
+module Sidekiq
+  module WebCustom
+    class Configuration
+
+      ALLOWED_BASED = [ACTIONS = :actions, LOCAL_ERBS = :local_erbs]
+      INTEGERS = [:drain_rate, :max_execution_time, :warn_execution_time]
+
+      DEFAULT_DRAIN_RATE = 10
+      DEFAULT_EXEC_TIME = 6
+      DEFAULT_WARN_TIME = 5
+
+      attr_reader *ALLOWED_BASED
+      attr_reader *INTEGERS
+
+      def initialize
+        ALLOWED_BASED.each do |var|
+          instance_variable_set(:"@#{var}", {})
+        end
+
+        @drain_rate = DEFAULT_DRAIN_RATE
+        @max_execution_time = DEFAULT_EXEC_TIME
+        @warn_execution_time = DEFAULT_WARN_TIME
+      end
+
+      INTEGERS.each do |int|
+         self.define_method("#{int}=") do |val|
+          unless _allow_write_block?
+            raise Sidekiq::WebCustom::ConfigurationEstablished, "Unable to assign [#{int}]. Assignment must happen on boot"
+          end
+
+          unless [Integer, Float].include?(val.class)
+            raise Sidekiq::WebCustom::ArgumentError, "Expected #{int} to be an integer or float"
+          end
+
+          instance_variable_set(:"@#{int}", val)
+        end
+      end
+
+      def merge(base:, params:, action_type: nil)
+        unless _allow_write_block?
+          raise Sidekiq::WebCustom::ConfigurationEstablished, "Unable to assign base [#{base}]. Assignment must happen on boot"
+        end
+        raise Sidekiq::WebCustom::ArgumentError, "Unexpected base: #{base}" unless ALLOWED_BASED.include?(base)
+        raise Sidekiq::WebCustom::ArgumentError, "Expected object for #{base} to be a Hash" unless params.is_a?(Hash)
+
+        value = instance_variable_get(:"@#{base}")
+        value =
+          if action_type && base == ACTIONS
+            value[action_type.to_sym] ||= {}
+            value[action_type.to_sym].merge!(params)
+            value
+          else
+            value.merge(params)
+          end
+        instance_variable_set(:"@#{base}", value)
+      end
+
+      def validate!
+        ALLOWED_BASED.each do |key|
+          value = instance_variable_get(:"@#{key}")
+
+          _validate!(value, key)
+        end
+
+        unless @warn_execution_time <= @max_execution_time
+          raise Sidekiq::WebCustom::ArgumentError, "Expected warn_execution_time to be less than max_execution_time"
+        end
+
+        unless actions.keys.all? { |k| local_erbs.keys.include?(k) }
+          raise Sidekiq::WebCustom::ArgumentError, "Unexpected actions keys#{actions.keys} -- Expected to be part of #{local_erbs.keys}"
+        end
+
+        define_convenienve_methods!
+        _unset_allow_write!
+      end
+
+      private
+
+      def _allow_write_block?
+        true
+      end
+
+      def _unset_allow_write!
+        define_singleton_method('_allow_write_block?') do
+          false
+        end
+      end
+
+      def define_convenienve_methods!
+        actions.keys.each do |key|
+          define_singleton_method("actions_for_#{key.to_s}") do
+            actions[key]
+          end
+        end
+      end
+
+      def _validate!(params, key, add: [])
+        params.each do |k, file|
+          return _validate!(file, k, add: add << key) if file.is_a? Hash
+          passed = [add, k].flatten.compact.join(':')
+
+
+          next if File.exist?(file)
+
+          raise Sidekiq::WebCustom::FileNotFound,
+             "#{key}.merge passed #{passed}: #{file}.\n" \
+            "The absolute file path does not exist."
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/web_custom/job.rb

@@ -0,0 +1,11 @@
+require 'sidekiq/web_custom/processor'
+
+module Sidekiq
+  module WebCustom
+    module Job
+      def execute
+        Sidekiq::WebCustom::Processor.execute_job(job: self)
+      end
+    end
+  end
+end

data/lib/sidekiq/web_custom/processor.rb

@@ -0,0 +1,82 @@
+require 'sidekiq/processor'
+
+module Sidekiq
+  module WebCustom
+    class Processor < ::Sidekiq::Processor
+
+      def self.execute(max:, queue:, options: Sidekiq.options)
+        __processor__(queue: queue, options: options).__execute(max: max)
+      end
+
+      def self.execute_job(job:, options: Sidekiq.options)
+        __processor__(queue: job.queue, options: options).__execute_job(job: job)
+      rescue StandardError => _
+        false # error gets loggged downstream
+      end
+
+      def self.__processor__(queue:, options: Sidekiq.options)
+        options_temp = options.clone
+        queue = queue.is_a?(String) ? Sidekiq::Queue.new(queue) : queue
+
+        options_temp[:queues] = [queue.name]
+        klass = options_temp[:fetch]&.class || BasicFetch
+        options_temp[:fetch] = klass.new(options_temp)
+        new(manager: nil, options: options_temp, queue: queue)
+      end
+
+      def initialize(manager:, options:, queue:)
+        @__queue = queue
+        @__basic_fetch = options[:fetch].class == BasicFetch
+
+        super(manager, options)
+      end
+
+      def __execute_job(job:)
+        queue_name = "queue:#{job.queue}"
+        work_unit = Sidekiq::BasicFetch::UnitOfWork.new(queue_name, job.item.to_json)
+        begin
+          Sidekiq.logger.info "Manually processing individual work unit for #{work_unit.queue_name}"
+          process(work_unit)
+        rescue StandardError => e
+          Sidekiq.logger.error "Manually processed work unit failed with #{e.message}. Work unit will not be dequeued"
+          raise e
+        end
+
+        begin
+          job.delete
+          Sidekiq.logger.info { "Manually processed work unit sucessfully dequeued." }
+        rescue StandardError => e
+          Sidekiq.logger.fatal "Manually processed work unit failed to be dequeued. #{e.message}."
+          raise e
+        end
+
+        true
+      end
+
+      def __execute(max:)
+        count = 0
+        max.times do
+          break if @__queue.size <= 0
+
+          if Thread.current[Sidekiq::WebCustom::BREAK_BIT]
+            Sidekiq.logger.warn "Yikes -- Break bit has been set. Attempting to return in time. Completed #{count} of attempted #{max}"
+            break
+          end
+
+          Sidekiq.logger.info { "Manually processing next item in queue:[#{@__queue.name}]" }
+          process_one
+          count += 1
+
+        end
+        count
+      rescue Exception => ex
+        if @job && @__basic_fetch
+          Sidekiq.logger.fatal "Processor Execution interrupted. Lost Job #{@job.job}"
+        end
+        Sidekiq.logger.warn "Manual execution has terminated. Received error [#{ex.message}]"
+        return count
+      end
+    end
+  end
+end
+

data/lib/sidekiq/web_custom/queue.rb

@@ -0,0 +1,12 @@
+require 'sidekiq/web_custom/processor'
+
+module Sidekiq
+  module WebCustom
+    module Queue
+      def drain(max:)
+        count = [size, max].min
+        Sidekiq::WebCustom::Processor.execute(max: count, queue: self)
+      end
+    end
+  end
+end

data/lib/sidekiq/web_custom/timeout.rb

@@ -0,0 +1,64 @@
+module Sidekiq
+  module WebCustom
+    module Timeout
+      module_function
+      DEFAULT_EXCEPTION = Sidekiq::WebCustom::ExecutionTimeExceeded
+      PROC = Proc.new do |warn_sec, timeout_sec, proc, exception, message, debug, &block|
+        puts "at: PROC; begining" if debug
+
+        sec_to_raise = timeout_sec - warn_sec
+        begin
+          from = debug ? "from #{caller_locations(1, 1)[0]}" : nil
+          x = Thread.current
+          # do everything in a new thread
+          y = Thread.start {
+            puts "at: PROC; second thread; about to start" if debug
+            Thread.current.name = from
+            # block for warning in new thread
+            begin
+              puts "at: PROC; second thread; starting warn time for #{warn_sec}'s " if debug
+              sleep warn_sec
+            rescue => e
+              x.raise e
+            else
+              # yield back during warning time so downstream can do some prep work
+              puts "at: PROC; second thread; trying to warn in main thread" if debug
+              proc.call(x, warn_sec)
+            end
+
+            # block additional seconds to raise for
+            begin
+              puts "at: PROC; second thread; starting violent exection time for #{sec_to_raise}'s " if debug
+              sleep sec_to_raise
+            rescue => e
+              puts "at: PROC; second thread; Error occured" if debug
+              x.raise e
+            else
+              puts "at: PROC; second thread; trying to raise in main thread" if debug
+              x.raise exception, message
+            end
+          }
+          puts "at: PROC; second thread; fully spooled" if debug
+          # after thread starts, yield back to calle function with max timout
+          block.call(timeout_sec)
+        ensure
+          if y
+            puts "at: PROC; Second thread still exists. Returned in time" if debug
+            y.kill
+            y.join
+          else
+            puts "at: PROC; Second thread no longer exists. Failed to return in time" if debug
+          end
+        end
+      end
+
+      def timeout(warn:, timeout:, proc: ->(_, _) {}, exception: DEFAULT_EXCEPTION, message: nil, debug: false, &block)
+        raise Sidekiq::WebCustom::ArgumentError, 'Block not given' unless block_given?
+
+        puts "at: timeout; valid bock given" if debug
+        message ||= "Execution exceeded #{timeout} seconds." if debug
+        PROC.call(warn, timeout, proc, exception, message, debug, &block)
+      end
+    end
+  end
+end