cogworker 0.1.0 → 0.2.1

data/lib/cogworker/web/routes/dead.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Cogworker
-  class Web
-    module Routes
-      # Lists jobs that exhausted their retries, with delete and retry
-      # (requeue) actions.
-      module Dead
-        CONTENT_ID = 'dead-content'
-
-        module_function
-
-        def registered(app)
-          app.get('/dead') do
-            content = Dead.render_content(request.script_name)
-            if hx_request?
-              content
-            else
-              Layout.wrap('Dead', Layout.poll_div(CONTENT_ID, request.script_name, 'dead', content),
-                          script_name: request.script_name)
-            end
-          end
-
-          app.post('/dead/delete') do
-            Cogworker.config.redis { |c| c.zrem(RedisKeys::DEAD, params['raw']) }
-            Dead.respond(self)
-          end
-
-          app.post('/dead/delete_all') do
-            Cogworker.config.redis { |c| c.del(RedisKeys::DEAD) }
-            Dead.respond(self)
-          end
-
-          # Puts the job back on its original queue for one more attempt —
-          # same "graduate out of this ZSET, back onto cogworker:queue:<q>"
-          # move `Routes::Retries#retry_now` does for `cogworker:retry`,
-          # and `Cogworker::Scheduled#graduate` does for both `cogworker:
-          # schedule`/`cogworker:retry`. `zrem` winning (not losing) is what
-          # actually gates the requeue: without it, two browser tabs (or a
-          # slow double-click) retrying the same entry at once could both
-          # see it and each push a copy. NOTE: for a single (non-Array)
-          # member, the `redis` gem's `#zrem` returns a **Boolean**, not the
-          # raw `1`/`0` integer reply — `== 1` would always be false here
-          # (`true == 1` is `false` in Ruby); check truthiness instead, the
-          # same way `Cogworker::Scheduled#graduate`'s `next unless won` does.
-          app.post('/dead/retry') do
-            raw = params['raw']
-            Cogworker.config.redis do |c|
-              if c.zrem(RedisKeys::DEAD, raw)
-                job = JSON.parse(raw)
-                c.sadd(RedisKeys::QUEUES, job['queue'])
-                c.lpush(RedisKeys.queue(job['queue']), raw)
-              end
-            end
-            Dead.respond(self)
-          end
-        end
-
-        # After an action, htmx gets the refreshed fragment swapped into
-        # #dead-content in place; a plain form submission (no JS) falls back
-        # to a normal redirect back to the full page.
-        def respond(action)
-          if action.hx_request?
-            render_content(action.request.script_name)
-          else
-            action.redirect(Layout.path(action.request.script_name, 'dead'))
-          end
-        end
-
-        def render_content(script_name)
-          # Newest DiedAt first — `zrevrange` (`cogworker:dead`'s score is
-          # the epoch it died at), not `zrange`.
-          entries = Cogworker.config.redis { |c| c.zrevrange(RedisKeys::DEAD, 0, -1, withscores: true) }
-          delete_path = Layout.path(script_name, 'dead/delete')
-          retry_path = Layout.path(script_name, 'dead/retry')
-          rows = entries.map do |raw, score|
-            job = JSON.parse(raw)
-            [job['jid'], Layout.h(job['class']), Layout.time_tag(score),
-             Layout.form_button(retry_path, 'raw', raw, 'retry', hx_target: "##{CONTENT_ID}", variant: :primary),
-             Layout.form_button(delete_path, 'raw', raw, 'delete', hx_target: "##{CONTENT_ID}", variant: :danger)]
-          end
-          delete_all_path = Layout.path(script_name, 'dead/delete_all')
-          delete_all_button = Layout.action_button(delete_all_path, 'delete all', hx_target: "##{CONTENT_ID}",
-                                                                                  variant: :danger)
-          %(<div class="mb-3 flex justify-end">#{delete_all_button}</div>) +
-            Layout.table(%w[JID Class DiedAt Retry Delete], rows, empty_message: 'No dead jobs.')
-        end
-      end
-    end
-  end
-end
-
-Cogworker::Web.register(Cogworker::Web::Routes::Dead)

data/lib/cogworker/web/routes/periodic.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'fugit'
-require 'json'
-
-module Cogworker
-  class Web
-    module Routes
-      # Read-only: lists every registered `config.periodic { |mgr|
-      # mgr.register(...) }` entry and when it last/next fires. Sourced
-      # entirely from Redis (`periodic:schedule`/`periodic:last_slot:<pjid>`),
-      # not from any in-process `Periodic::Manager` — those are only
-      # published once an actual worker process's `Periodic::Ticker` has
-      # booted (see `Ticker#publish_schedule!`), so a Web-UI-only process
-      # (no worker ever started) shows the empty state here, same as Busy
-      # shows no processes with no worker running.
-      module Periodic
-        CONTENT_ID = 'periodic-content'
-
-        module_function
-
-        def registered(app)
-          app.get('/periodic') do
-            content = Routes::Periodic.render_content
-            if hx_request?
-              content
-            else
-              Layout.wrap('Periodic', Layout.poll_div(CONTENT_ID, request.script_name, 'periodic', content),
-                          script_name: request.script_name)
-            end
-          end
-        end
-
-        def render_content
-          schedule = Cogworker.config.redis { |c| c.hgetall(RedisKeys::PERIODIC_SCHEDULE) }
-          rows = schedule.map { |pjid, raw| row_for(pjid, JSON.parse(raw)) }
-          Layout.table(%w[Class Cron Args NextRun LastRun Unique], rows,
-                       empty_message: 'Nothing registered yet (no worker process has booted the periodic ' \
-                                      'scheduler — periodic jobs are published to Redis by ' \
-                                      'Periodic::Ticker on worker startup, not by the Web UI process).')
-        end
-
-        def row_for(pjid, entry)
-          [Layout.h(entry['class']), Layout.h(entry['cron']), Layout.h(entry['args'].to_json),
-           next_run_tag(entry['cron']), last_run_tag(pjid), unique_cell(entry['unique'])]
-        end
-
-        def next_run_tag(cron)
-          Layout.time_tag(Fugit::Cron.parse(cron)&.next_time(Time.now)&.to_t)
-        rescue StandardError
-          Layout.h('invalid cron')
-        end
-
-        def last_run_tag(pjid)
-          last_slot = Cogworker.config.redis { |c| c.get(RedisKeys.periodic_last_slot(pjid)) }
-          last_slot ? Layout.time_tag(last_slot.to_f) : %(<span class="text-gray-400 italic">never</span>)
-        end
-
-        def unique_cell(unique)
-          unique.nil? || unique.empty? ? '' : Layout.badge(unique, variant: :warning)
-        end
-      end
-    end
-  end
-end
-
-Cogworker::Web.register(Cogworker::Web::Routes::Periodic)

data/lib/cogworker/web/routes/queues.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Cogworker
-  class Web
-    module Routes
-      # Lists every known queue with its size/latency, and a per-queue drill
-      # down page listing that queue's pending jobs.
-      module Queues
-        CONTENT_ID = 'queues-content'
-        QUEUE_CONTENT_ID = 'queue-content'
-
-        module_function
-
-        def registered(app)
-          app.get('/queues') do
-            content = Queues.render_content(request.script_name)
-            if hx_request?
-              content
-            else
-              Layout.wrap('Queues', Layout.poll_div(CONTENT_ID, request.script_name, 'queues', content),
-                          script_name: request.script_name)
-            end
-          end
-
-          app.get('/queues/:name') do
-            name = url_params('name')
-            content = Queues.render_queue_content(name, request.script_name)
-            if hx_request?
-              content
-            else
-              Layout.wrap("Queue: #{Layout.h(name)}",
-                          Layout.poll_div(QUEUE_CONTENT_ID, request.script_name, "queues/#{name}", content),
-                          script_name: request.script_name)
-            end
-          end
-
-          # `raw` is the exact JSON string the job entry was pushed with —
-          # same "raw" identity `Routes::Dead`/`Routes::Retries` already key
-          # their own per-row delete off — so `Queue#delete` can `LREM` it
-          # back out of the list.
-          app.post('/queues/:name/delete') do
-            name = url_params('name')
-            Cogworker::Queue.new(name).delete(params['raw'])
-            Queues.respond(self, name)
-          end
-
-          app.post('/queues/:name/delete_all') do
-            name = url_params('name')
-            Cogworker::Queue.new(name).clear
-            Queues.respond(self, name)
-          end
-        end
-
-        # After an action, htmx gets the refreshed fragment swapped into
-        # #queue-content in place; a plain form submission (no JS) falls
-        # back to a normal redirect back to the queue's own page.
-        def respond(action, name)
-          if action.hx_request?
-            render_queue_content(name, action.request.script_name)
-          else
-            action.redirect(Layout.path(action.request.script_name, "queues/#{name}"))
-          end
-        end
-
-        def render_content(script_name)
-          names = Cogworker.config.redis { |c| c.smembers(RedisKeys::QUEUES) }.sort
-          rows = names.map do |name|
-            q = Cogworker::Queue.new(name)
-            link = Layout.path(script_name, "queues/#{Layout.h(name)}")
-            [%(<a class="text-indigo-600 dark:text-indigo-400 hover:underline font-medium" href="#{link}">#{Layout.h(name)}</a>),
-             q.size, q.latency.round(2)]
-          end
-          Layout.table(%w[Name Size Latency], rows, empty_message: 'No queues yet — push a job to create one.')
-        end
-
-        def render_queue_content(name, script_name)
-          delete_path = Layout.path(script_name, "queues/#{name}/delete")
-          rows = Cogworker::Queue.new(name).map do |r|
-            [r.jid, Layout.h(r.klass), Layout.h(r.args.to_s),
-             Layout.form_button(delete_path, 'raw', r.value, 'delete', hx_target: "##{QUEUE_CONTENT_ID}",
-                                                                       variant: :danger)]
-          end
-          delete_all_button(name, script_name, rows.empty?) +
-            Layout.table(%w[JID Class Args Delete], rows, empty_message: 'This queue is empty.')
-        end
-
-        # Nothing to bulk-delete once the queue is already empty.
-        def delete_all_button(name, script_name, empty)
-          return '' if empty
-
-          delete_all_path = Layout.path(script_name, "queues/#{name}/delete_all")
-          button = Layout.action_button(delete_all_path, 'delete all', hx_target: "##{QUEUE_CONTENT_ID}",
-                                                                       variant: :danger)
-          %(<div class="mb-3 flex justify-end">#{button}</div>)
-        end
-      end
-    end
-  end
-end
-
-Cogworker::Web.register(Cogworker::Web::Routes::Queues)

data/lib/cogworker/web/routes/retries.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Cogworker
-  class Web
-    module Routes
-      # Lists jobs currently scheduled for retry, with delete and
-      # retry-now (skip the backoff) actions.
-      module Retries
-        CONTENT_ID = 'retries-content'
-
-        module_function
-
-        def registered(app)
-          app.get('/retries') do
-            content = Retries.render_content(request.script_name)
-            if hx_request?
-              content
-            else
-              Layout.wrap('Retries', Layout.poll_div(CONTENT_ID, request.script_name, 'retries', content),
-                          script_name: request.script_name)
-            end
-          end
-
-          app.post('/retries/delete') do
-            Cogworker.config.redis { |c| c.zrem(RedisKeys::RETRY, params['raw']) }
-            Retries.respond(self)
-          end
-
-          app.post('/retries/retry_now') do
-            raw = params['raw']
-            Cogworker.config.redis do |c|
-              # For a single (non-Array) member, the `redis` gem's `#zrem`
-              # returns a **Boolean**, not the raw `1`/`0` integer reply —
-              # `== 1` is always false here (`true == 1` is `false` in
-              # Ruby); check truthiness instead, matching
-              # `Cogworker::Scheduled#graduate`'s `next unless won`.
-              if c.zrem(RedisKeys::RETRY, raw)
-                job = JSON.parse(raw)
-                c.sadd(RedisKeys::QUEUES, job['queue'])
-                c.lpush(RedisKeys.queue(job['queue']), raw)
-              end
-            end
-            Retries.respond(self)
-          end
-        end
-
-        # After an action, htmx gets the refreshed fragment swapped into
-        # #retries-content in place; a plain form submission (no JS) falls
-        # back to a normal redirect back to the full page.
-        def respond(action)
-          if action.hx_request?
-            render_content(action.request.script_name)
-          else
-            action.redirect(Layout.path(action.request.script_name, 'retries'))
-          end
-        end
-
-        def render_content(script_name)
-          entries = Cogworker.config.redis { |c| c.zrange(RedisKeys::RETRY, 0, -1) }
-          rows = entries.map do |raw|
-            job = JSON.parse(raw)
-            [job['jid'], Layout.h(job['class']), error_cell(job), delete_form(script_name, raw),
-             retry_now_form(script_name, raw)]
-          end
-          Layout.table(%w[JID Class Error Delete RetryNow], rows, empty_message: 'No retries pending.')
-        end
-
-        def error_cell(job)
-          <<~HTML
-            <div class="font-mono text-xs text-red-700 dark:text-red-400">#{Layout.h(job['error_class'])}</div>
-            <div class="text-xs text-gray-500 dark:text-gray-400 truncate max-w-xs">#{Layout.h(job['error_message'])}</div>
-          HTML
-        end
-
-        def delete_form(script_name, raw)
-          action = Layout.path(script_name, 'retries/delete')
-          Layout.form_button(action, 'raw', raw, 'delete', hx_target: "##{CONTENT_ID}", variant: :danger)
-        end
-
-        def retry_now_form(script_name, raw)
-          action = Layout.path(script_name, 'retries/retry_now')
-          Layout.form_button(action, 'raw', raw, 'retry now', hx_target: "##{CONTENT_ID}", variant: :primary)
-        end
-      end
-    end
-  end
-end
-
-Cogworker::Web.register(Cogworker::Web::Routes::Retries)

data/lib/cogworker/web/routes/scheduled.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Cogworker
-  class Web
-    module Routes
-      # Lists jobs pushed with `perform_in`/`perform_at`, still waiting for
-      # their run-at time, with a delete action.
-      module Scheduled
-        CONTENT_ID = 'scheduled-content'
-
-        module_function
-
-        def registered(app)
-          app.get('/scheduled') do
-            content = Scheduled.render_content(request.script_name)
-            if hx_request?
-              content
-            else
-              Layout.wrap('Scheduled', Layout.poll_div(CONTENT_ID, request.script_name, 'scheduled', content),
-                          script_name: request.script_name)
-            end
-          end
-
-          app.post('/scheduled/delete') do
-            Cogworker.config.redis { |c| c.zrem(RedisKeys::SCHEDULE, params['raw']) }
-            if hx_request?
-              Scheduled.render_content(request.script_name)
-            else
-              redirect Layout.path(request.script_name, 'scheduled')
-            end
-          end
-        end
-
-        def render_content(script_name)
-          entries = Cogworker.config.redis { |c| c.zrange(RedisKeys::SCHEDULE, 0, -1, withscores: true) }
-          delete_path = Layout.path(script_name, 'scheduled/delete')
-          rows = entries.map do |raw, score|
-            job = JSON.parse(raw)
-            [job['jid'], Layout.h(job['class']), Layout.time_tag(score),
-             Layout.form_button(delete_path, 'raw', raw, 'delete', hx_target: "##{CONTENT_ID}", variant: :danger)]
-          end
-          Layout.table(%w[JID Class RunAt Delete], rows, empty_message: 'Nothing scheduled.')
-        end
-      end
-    end
-  end
-end
-
-Cogworker::Web.register(Cogworker::Web::Routes::Scheduled)