sidekiq-tasks 0.1.0

data/lib/sidekiq/tasks/strategies/base.rb

@@ -0,0 +1,91 @@
+module Sidekiq
+  module Tasks
+    module Strategies
+      class Base
+        include Sidekiq::Tasks::Validations
+
+        # A set of rules to fetch tasks.
+        #
+        # @return [Array<Sidekiq::Tasks::Strategies::Rules::Base>]
+        # @see Sidekiq::Tasks::Strategies::Base#filtered_tasks
+        attr_reader :rules
+
+        # Initializes a strategy with the given rules.
+        #
+        # @param rules [Array<Sidekiq::Tasks::Strategies::Rules::Base>] List of rule instances to be applied.
+        # @raise [Sidekiq::Tasks::ArgumentError] If the rules are not valid instances.
+        def initialize(rules: [])
+          @rules = rules
+
+          validate_array_classes!(rules, [Sidekiq::Tasks::Strategies::Rules::Base], "rules")
+        end
+
+        # Returns the name of the strategy.
+        #
+        # @return [String] The name of the class without module namespaces.
+        def name
+          self.class.name.split("::").last
+        end
+
+        # Returns all the raw tasks that should be filtered.
+        #
+        # @abstract Subclasses must implement this method.
+        # @return [Array] A list of tasks to be filtered.
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def load_tasks
+          raise NotImplementedError, "Strategy must implement #load_tasks"
+        end
+
+        # Executes a task with the given parameters.
+        #
+        # @note Consider accepting a `Sidekiq::Tasks::Task` instead of a task name.
+        #
+        # @param name [String] The name of the task to execute.
+        # @param args [Hash, NilClass] Arguments to pass to the task.
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def execute_task(_name, _args = nil)
+          raise NotImplementedError, "Strategy must implement #execute_task"
+        end
+
+        # Enqueues a task with the given parameters and returns the JID.
+        #
+        # @param name [String] The name of the task to enqueue.
+        # @param params [Hash] Parameters to pass to the task.
+        # @return [String] The JID of the sidekiq job that will execute the task.
+        def enqueue_task(name, params = {})
+          Sidekiq::Tasks::Job.perform_async(name, params.to_json)
+        end
+
+        # Returns all the tasks that should be executed.
+        #
+        # @return [Array<Sidekiq::Tasks::Task>]
+        def tasks
+          filtered_tasks = load_tasks.select { |task| respects_rules?(task) }
+
+          filtered_tasks.map { |task| Sidekiq::Tasks::Task.new(metadata: build_task_metadata(task), strategy: self) }
+        end
+
+        # Factory method to build the metadata for a task.
+        #
+        # @abstract Subclasses must implement this method.
+        # @param task [Object] The task to build the metadata for.
+        # @return [Sidekiq::Tasks::TaskMetadata] The metadata for the task.
+        def build_task_metadata(_task)
+          raise NotImplementedError, "Strategy must implement #build_task_metadata"
+        end
+
+        private
+
+        # Checks if a task respects all the defined rules.
+        #
+        # @param task [Sidekiq::Tasks::Task] The task to validate against the rules.
+        # @return [Boolean] `true` if the task respects all rules, `false` otherwise.
+        def respects_rules?(task)
+          rules.all? do |rule|
+            rule.respected?(task)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/strategies/rake_task.rb

@@ -0,0 +1,26 @@
+module Sidekiq
+  module Tasks
+    module Strategies
+      class RakeTask < Base
+        def load_tasks
+          Rake::TaskManager.record_task_metadata = true
+          Rake.application.load_rakefile
+          Rake::Task.tasks
+        end
+
+        def build_task_metadata(task)
+          Sidekiq::Tasks::TaskMetadata.new(
+            name: task.name,
+            desc: task.full_comment,
+            file: task.locations.first.split(":").first,
+            args: task.arg_names
+          )
+        end
+
+        def execute_task(name, args = nil)
+          Rake::Task[name].execute(args)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/strategies/rules/base.rb

@@ -0,0 +1,19 @@
+module Sidekiq
+  module Tasks
+    module Strategies
+      module Rules
+        class Base
+          # Checks if the given task respects the rule
+          #
+          # @abstract Subclasses must implement this method.
+          # @param task [Sidekiq::Tasks::Task] The task to validate.
+          # @return [Boolean] `true` if the task respects the rule, `false` otherwise.
+          # @raise [NotImplementedError] If the method is not implemented in a subclass.
+          def respected?(_task)
+            raise NotImplementedError, "Rule must implement #respected?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/strategies/rules/enable_with_comment.rb

@@ -0,0 +1,29 @@
+module Sidekiq
+  module Tasks
+    module Strategies
+      module Rules
+        class EnableWithComment < Base
+          MAGIC_COMMENT_REGEX = /sidekiq-tasks:enable/
+
+          def respected?(task)
+            file, start_line = task.locations.first.split(":")
+            start_line_counting_desc = start_line.to_i > 2 ? start_line.to_i - 3 : 0
+            lines = File.read(file).split("\n")[start_line_counting_desc..start_line_counting_desc + 1].reverse
+
+            valid_magic_comment_line?(lines)
+          rescue Errno::ENOENT
+            raise ArgumentError, "File '#{file}' not found"
+          end
+
+          private
+
+          def valid_magic_comment_line?(lines)
+            return false if lines.first.match?(/namespace/)
+
+            lines.any? { |line| line.strip.match?(MAGIC_COMMENT_REGEX) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/strategies/rules/task_from_lib.rb

@@ -0,0 +1,13 @@
+module Sidekiq
+  module Tasks
+    module Strategies
+      module Rules
+        class TaskFromLib < Base
+          def respected?(task)
+            task.locations.first.start_with?("#{Rake.application.original_dir}/lib")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/strategies/rules.rb

@@ -0,0 +1,11 @@
+module Sidekiq
+  module Tasks
+    module Strategies
+      module Rules
+        autoload :Base, "sidekiq/tasks/strategies/rules/base"
+        autoload :TaskFromLib, "sidekiq/tasks/strategies/rules/task_from_lib"
+        autoload :EnableWithComment, "sidekiq/tasks/strategies/rules/enable_with_comment"
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/strategies.rb

@@ -0,0 +1,10 @@
+require_relative "strategies/rules"
+
+module Sidekiq
+  module Tasks
+    module Strategies
+      autoload :Base, "sidekiq/tasks/strategies/base"
+      autoload :RakeTask, "sidekiq/tasks/strategies/rake_task"
+    end
+  end
+end

data/lib/sidekiq/tasks/task.rb

@@ -0,0 +1,42 @@
+require "forwardable"
+
+module Sidekiq
+  module Tasks
+    class Task
+      extend Forwardable
+      include Sidekiq::Tasks::Validations
+
+      def_delegators :metadata, :name, :desc, :file, :args
+      def_delegators :storage, :last_enqueue_at, :last_execution_at, :history
+
+      attr_reader :metadata, :strategy
+
+      # @param metadata [Sidekiq::Tasks::TaskMetadata] The metadata for the task.
+      # @param strategy [Sidekiq::Tasks::Strategies::Base] The strategy to use to execute the task.
+      # @raise [Sidekiq::Tasks::ArgumentError] If the metadata or strategy are not valid instances.
+      def initialize(metadata:, strategy:)
+        @metadata = metadata
+        @strategy = strategy
+
+        validate_class!(metadata, [Sidekiq::Tasks::TaskMetadata], "metadata")
+        validate_class!(strategy, [Sidekiq::Tasks::Strategies::Base], "strategy")
+      end
+
+      def enqueue(params = {})
+        jid = strategy.enqueue_task(name, params)
+
+        storage.store_enqueue(jid, params)
+      end
+
+      def execute(params = {}, jid: nil)
+        strategy.execute_task(name, params)
+
+        storage.store_execution(jid)
+      end
+
+      def storage
+        @_storage ||= Sidekiq::Tasks::Storage.new(name)
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/task_metadata.rb

@@ -0,0 +1,27 @@
+module Sidekiq
+  module Tasks
+    class TaskMetadata
+      include Sidekiq::Tasks::Validations
+
+      attr_reader :name, :desc, :file, :args
+
+      def initialize(name:, file:, desc: "", args: [])
+        @name = name
+        @file = file
+        @desc = desc
+        @args = args
+
+        validate_params!
+      end
+
+      private
+
+      def validate_params!
+        validate_class!(name, [String, Symbol], "name")
+        validate_class!(file, [String, NilClass], "file")
+        validate_class!(desc, [String, NilClass], "desc")
+        validate_array_classes!(args, [String, Symbol], "args")
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/validations.rb

@@ -0,0 +1,37 @@
+module Sidekiq
+  module Tasks
+    module Validations
+      def validate_class!(object, classes, name = nil)
+        return if classes.any? { |klass| object.is_a?(klass) }
+
+        expected_classes = classes.map(&:name).join(" or ")
+        name ||= object
+
+        raise Sidekiq::Tasks::ArgumentError,
+              "'#{name}' must be an instance of #{expected_classes} but received #{object.class}"
+      end
+      module_function :validate_class!
+
+      def validate_array_classes!(objects, classes, name = nil)
+        validate_class!(objects, [Array], name)
+
+        objects.each { |object| validate_class!(object, classes) }
+      end
+      module_function :validate_array_classes!
+
+      def validate_hash_option!(options, key, classes = [])
+        validate_class!(options, [Hash])
+        validate_class!(options[key], classes, key)
+      end
+      module_function :validate_hash_option!
+
+      def validate_expected_values!(value, expected_values, name = nil)
+        return if expected_values.any? { |expected_value| value == expected_value }
+
+        raise Sidekiq::Tasks::ArgumentError,
+              "'#{name}' must be one of #{expected_values.map(&:inspect).join(" or ")} but received #{value.inspect}"
+      end
+      module_function :validate_expected_values!
+    end
+  end
+end

data/lib/sidekiq/tasks/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Tasks
+    VERSION = "0.1.0"
+  end
+end

data/lib/sidekiq/tasks/web/extension.rb

@@ -0,0 +1,45 @@
+module Sidekiq
+  module Tasks
+    module Web
+      class Extension
+        LOCALES_PATH = File.expand_path("../web/locales", __dir__).freeze
+
+        def self.registered(app)
+          app.settings.locales << File.join(LOCALES_PATH)
+
+          app.helpers do
+            include Sidekiq::Tasks::Web::Helpers::ApplicationHelper
+            include Sidekiq::Tasks::Web::Helpers::TaskHelper
+          end
+
+          app.get "/tasks" do
+            @search = Sidekiq::Tasks::Web::Search.new(params)
+
+            erb(read_view(:tasks), locals: {search: @search})
+          end
+
+          app.get "/tasks/:name" do
+            @task = find_task!(params["name"])
+
+            erb(read_view(:_task), locals: {task: @task})
+          rescue Sidekiq::Tasks::NotFoundError
+            throw :halt, [404, {Rack::CONTENT_TYPE => "text/plain"}, ["Task not found"]]
+          end
+
+          app.post "/tasks/:name/enqueue" do
+            task = find_task!(params["name"])
+            args = Sidekiq::Tasks::Web::Params.new(task, params["args"]).permit!
+
+            task.enqueue(args)
+
+            redirect(task_url(root_path, task))
+          rescue Sidekiq::Tasks::ArgumentError => e
+            throw :halt, [400, {Rack::CONTENT_TYPE => "text/plain"}, [e.message]]
+          rescue Sidekiq::Tasks::NotFoundError
+            throw :halt, [404, {Rack::CONTENT_TYPE => "text/plain"}, ["Task not found"]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/web/helpers/application_helper.rb

@@ -0,0 +1,17 @@
+module Sidekiq
+  module Tasks
+    module Web
+      module Helpers
+        module ApplicationHelper
+          extend self
+
+          VIEW_PATH = File.expand_path("../../web/views", __dir__).freeze
+
+          def read_view(name)
+            File.read(File.join(VIEW_PATH, "#{name}.html.erb"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/web/helpers/task_helper.rb

@@ -0,0 +1,29 @@
+module Sidekiq
+  module Tasks
+    module Web
+      module Helpers
+        module TaskHelper
+          extend self
+
+          def parameterize_task_name(task_name)
+            task_name.gsub(":", "-")
+          end
+
+          def unparameterize_task_name(task_name)
+            task_name.gsub("-", ":")
+          end
+
+          def find_task!(parameterized_name)
+            name = unparameterize_task_name(parameterized_name)
+
+            Sidekiq::Tasks.tasks.find_by!(name: name)
+          end
+
+          def task_url(root_path, task)
+            "#{root_path}tasks/#{parameterize_task_name(task.name)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/web/locales/en.yml

@@ -0,0 +1,19 @@
+en:
+  prev: "Prev"
+  next: "Next"
+  tasks: "Tasks"
+  filter: "Filter"
+  no_tasks:  "No tasks found"
+  name: "Name"
+  last_enqueued: "Last enqueued"
+  history: "History"
+  no_history: "No history"
+  jid: "JID"
+  args: "Arguments"
+  enqueued_at: "Enqueued at"
+  executed_at: "Executed at"
+  task: "Task"
+  desc: "Description"
+  strategy: "Strategy"
+  run_task: "Run task"
+  enqueue: "Enqueue"

data/lib/sidekiq/tasks/web/locales/fr.yml

@@ -0,0 +1,19 @@
+fr:
+  prev: "Précédent"
+  next: "Suivant"
+  tasks: "Tâches"
+  filter: "Filtrer"
+  no_tasks:  "Aucune tâche trouvée"
+  name: "Nom"
+  last_enqueued: "Dernière mise en file d'attente"
+  history: "Historique"
+  no_history: "Aucun historique"
+  jid: "JID"
+  args: "Arguments"
+  enqueued_at: "Mise en file d'attente le"
+  executed_at: "Exécuté le"
+  task: "Tâche"
+  desc: "Description"
+  strategy: "Stratégie"
+  run_task: "Exécuter la tâche"
+  enqueue: "Mettre en file d'attente"

data/lib/sidekiq/tasks/web/params.rb

@@ -0,0 +1,44 @@
+module Sidekiq
+  module Tasks
+    module Web
+      class Params
+        attr_reader :task, :params
+
+        # @param task [Sidekiq::Tasks::Task] The task to validate the params against.
+        # @param params [Hash] The params to validate.
+        def initialize(task, params)
+          @task = task
+          @params = params
+        end
+
+        # Returns the permitted params.
+        #
+        # @return [Hash] The permitted params.
+        # @raise [Sidekiq::Tasks::ArgumentError] If the params are not NilClass or Hash.
+        def permit!
+          case params
+          when NilClass then {}
+          when Hash then permit_hash!
+          else
+            raise Sidekiq::Tasks::ArgumentError, "Invalid parameters: #{params.inspect}"
+          end
+        end
+
+        private
+
+        # Validates and returns the permitted params as a hash.
+        #
+        # @return [Hash] The permitted params as a hash.
+        # @raise [Sidekiq::Tasks::ArgumentError] If given params does not match the task args.
+        def permit_hash!
+          permitted_keys = task.args.map(&:to_s)
+          invalid_keys = params.keys - permitted_keys
+
+          raise Sidekiq::Tasks::ArgumentError, "Invalid parameters: #{invalid_keys.join(", ")}" if invalid_keys.any?
+
+          params.slice(*permitted_keys)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/web/search.rb

@@ -0,0 +1,53 @@
+module Sidekiq
+  module Tasks
+    module Web
+      class Search
+        DEFAULT_COUNT = 25
+
+        def self.count_options
+          (1..4).map { |index| index * DEFAULT_COUNT }
+        end
+
+        attr_reader :params
+
+        def initialize(params)
+          @params = params
+        end
+
+        def tasks
+          @_tasks ||= filtered_collection.sort_by(&:file).slice(offset, count) || []
+        end
+
+        def filtered_collection
+          @_filtered_collection ||= Sidekiq::Tasks.tasks.where(name: filter)
+        end
+
+        def filter
+          request_filter = params[:filter]
+
+          ["", nil].include?(request_filter) ? nil : request_filter
+        end
+
+        def count
+          requested_count = params[:count].to_i
+
+          requested_count.positive? ? requested_count : DEFAULT_COUNT
+        end
+
+        def page
+          requested_page = params[:page].to_i
+
+          requested_page.positive? ? requested_page : 1
+        end
+
+        def total_pages
+          (filtered_collection.size.to_f / count).ceil
+        end
+
+        def offset
+          (page - 1) * count
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/web/views/_pagination.html.erb

@@ -0,0 +1,25 @@
+<% if search.total_pages > 1 %>
+  <ul class="pagination pull-right">
+    <% if search.page > 1 %>
+      <li>
+        <a href="<%= "#{root_path}tasks?filter=#{ERB::Util.url_encode(search.filter)}&count=#{search.count}&page=#{search.page - 1}" %>">
+          <%= t("prev") %>
+        </a>
+      </li>
+    <% end %>
+
+    <% (0..(search.total_pages - 1)).each.with_index(1) do |_page, index| %>
+      <li class="<%= 'active' if index == search.page %>">
+        <a href="<%= "#{root_path}tasks?filter=#{ERB::Util.url_encode(search.filter)}&count=#{search.count}&page=#{index}" %>"><%= index %></a>
+      </li>
+    <% end %>
+
+    <% if search.tasks.any? && search.tasks.size == search.count %>
+      <li>
+        <a href="<%= "#{root_path}tasks?filter=#{ERB::Util.url_encode(search.filter)}&count=#{search.count}&page=#{search.page + 1}" %>">
+          <%= t("next") %>
+        </a>
+      </li>
+    <% end %>
+  </ul>
+<% end %>

data/lib/sidekiq/tasks/web/views/_task.html.erb

@@ -0,0 +1,84 @@
+<header class="row">
+  <div class="span col-sm-5 pull-left">
+    <h1><%= t("task") %></h1>
+  </div>
+</header>
+
+<table class="table table-bordered table-striped">
+  <tbody>
+    <tr>
+      <th><%= t("name") %></th>
+      <td><%= task.name %></td>
+    </tr>
+    <tr>
+      <th><%= t("desc") %></th>
+      <td><%= task.desc %></td>
+    </tr>
+    <tr>
+      <th><%= t("strategy") %></th>
+      <td><%= task.strategy.name %></td>
+    </tr>
+    <tr>
+      <th><%= t("last_enqueued") %></th>
+      <td><%= task.last_enqueue_at ? relative_time(task.last_enqueue_at) : "-" %></td>
+    </tr>
+  </tbody>
+</table>
+
+<header class="row">
+  <div class="col-sm-12">
+    <h2><%= t("history") %></h2>
+  </div>
+</header>
+
+<% if task.history.empty? %>
+  <p><%= t("no_history") %></p>
+<% else %>
+  <table class="table table-hover table-bordered table-striped">
+    <thead>
+    <tr>
+      <th><%= t("jid") %></th>
+      <th><%= t("args") %></th>
+      <th><%= t("enqueued_at") %></th>
+      <th><%= t("executed_at") %></th>
+    </tr>
+    </thead>
+    <tbody>
+      <% task.history.each do |jid_history| %>
+        <tr>
+          <td><%= jid_history["jid"] %></td>
+          <td><%= jid_history["args"] %></td>
+          <td><%= jid_history["enqueued_at"] ? relative_time(jid_history["enqueued_at"]) : "-" %></td>
+          <td><%= jid_history["executed_at"] ? relative_time(jid_history["executed_at"]) : "-" %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>
+
+<header class="row">
+  <div class="col-sm-12">
+    <h2><%= t("run_task") %></h2>
+  </div>
+</header>
+
+<form action="<%= task_url(root_path, task) %>/enqueue" method="post">
+  <%= csrf_tag %>
+
+  <div class="container">
+    <div class="row">
+      <% task.args.each do |arg| %>
+        <div class="col-md-6 mb-3">
+          <div class="form-group">
+            <label for="<%= arg %>" class="form-label"><%= arg %></label>
+            <input type="text" class="form-control" name="args[<%= arg %>]" id="<%= arg %>" />
+          </div>
+        </div>
+      <% end %>
+    </div>
+  </div>
+
+  <button type="submit" class="btn btn-primary">
+    <%= t("enqueue") %>
+  </button>
+</form>