async-background 1.1.0 → 1.1.1

data/lib/async/background/web/auth.rb

@@ -11,10 +11,10 @@ module Async
 
         def authorized?(env)
           !!@callable.call(env)
-        rescue StandardError => error
+        rescue StandardError => e
           @logger&.warn(
-            "[async-background-web] auth callable raised: " \
-            "#{error.class}: #{error.message}"
+            '[async-background-web] auth callable raised: ' \
+            "#{e.class}: #{e.message}"
           )
           false
         end

data/lib/async/background/web/configuration.rb

@@ -57,37 +57,37 @@ module Async
           [:queue_path, ->(value, _) { !value.nil? && !value.to_s.empty? }, 'queue_path must be set'],
           [:auth, ->(value, _) { !value.nil? }, 'auth must be configured (gem ships no permissive default)'],
           [:auth, ->(value, _) { value.respond_to?(:call) },
-            'auth must respond to #call(env) and return truthy on success'],
+           'auth must respond to #call(env) and return truthy on success'],
           [:list_limit, ->(value, _) { value.is_a?(Integer) && value.between?(1, MAX_LIST_LIMIT) },
-            "list_limit must be an Integer between 1 and #{MAX_LIST_LIMIT}"],
+           "list_limit must be an Integer between 1 and #{MAX_LIST_LIMIT}"],
           [:counts_cache_ttl, ->(value, _) { value.is_a?(Numeric) && value >= 0 },
-            'counts_cache_ttl must be a non-negative Numeric'],
+           'counts_cache_ttl must be a non-negative Numeric'],
           [:poll_interval_ms, ->(value, _) { value.is_a?(Integer) && value >= 200 },
-            'poll_interval_ms must be an Integer >= 200'],
+           'poll_interval_ms must be an Integer >= 200'],
           [:transport, ->(value, _) { TRANSPORTS.include?(value) },
-            "transport must be one of #{TRANSPORTS.inspect}"],
+           "transport must be one of #{TRANSPORTS.inspect}"],
           [:stream_poll_seconds, ->(value, _) { value.is_a?(Numeric) && value >= 0.1 },
-            'stream_poll_seconds must be a Numeric >= 0.1'],
+           'stream_poll_seconds must be a Numeric >= 0.1'],
           [:stream_heartbeat_seconds, ->(value, _) { value.is_a?(Numeric) && value >= 5 },
-            'stream_heartbeat_seconds must be a Numeric >= 5'],
+           'stream_heartbeat_seconds must be a Numeric >= 5'],
           [:stream_retry_ms, ->(value, _) { value.is_a?(Integer) && value >= 500 },
-            'stream_retry_ms must be an Integer >= 500'],
+           'stream_retry_ms must be an Integer >= 500'],
           [:redact_args, ->(value, config) { !config.expose_args || value.nil? || value.respond_to?(:call) },
-            'redact_args must respond to #call(args)'],
-          [:total_workers, ->(value, config) {
+           'redact_args must respond to #call(args)'],
+          [:total_workers, lambda { |value, config|
             !config.metrics_enabled? || (value.is_a?(Integer) && value.positive?)
           }, 'metrics_path requires total_workers to be a positive Integer'],
           [:mount_path, ->(value, _) { value.is_a?(String) }, 'mount_path must be a String'],
           [:mount_path, ->(value, _) { value.empty? || value.start_with?('/') },
-            'mount_path must start with "/" or be empty'],
+           'mount_path must start with "/" or be empty'],
           [:mount_path, ->(value, _) { value.empty? || !value.end_with?('/') },
-            'mount_path must not end with "/"'],
+           'mount_path must not end with "/"'],
           [:mount_path, ->(value, _) { value.empty? || !value.match?(/[[:cntrl:]]/) },
-            'mount_path must not contain control characters'],
+           'mount_path must not contain control characters'],
           [:mount_path, ->(value, _) { value.empty? || !value.match?(/\s/) },
-            'mount_path must not contain whitespace'],
+           'mount_path must not contain whitespace'],
           [:logger, ->(value, _) { value.nil? || (value.respond_to?(:warn) && value.respond_to?(:error)) },
-            'logger must respond to #warn and #error']
+           'logger must respond to #warn and #error']
         ].freeze
 
         def validate!

data/lib/async/background/web/cursor.rb

@@ -23,24 +23,31 @@ module Async
           timestamp, id = decode(value)
           return unless timestamp
 
-          {key => timestamp, :id => id}
+          { key => timestamp, :id => id }
         end
 
         def decode(value)
           return if value.nil? || value.to_s.empty?
 
-          timestamp_raw, id_raw, extra = Base64.urlsafe_decode64(value.to_s).split(':', 3)
+          decode_fields(Base64.urlsafe_decode64(value.to_s))
+        rescue ArgumentError, TypeError
+          raise RequestError, 'invalid cursor'
+        end
+
+        def decode_fields(payload)
+          timestamp_raw, id_raw, extra = payload.split(':', 3)
           raise RequestError, 'invalid cursor' if timestamp_raw.nil? || id_raw.nil? || extra
 
           timestamp = Float(timestamp_raw)
           id = Integer(id_raw)
-          raise RequestError, 'invalid cursor' unless timestamp.finite? && id.positive?
-
+          validate_fields!(timestamp, id)
           [timestamp, id]
-        rescue ArgumentError, TypeError
-          raise RequestError, 'invalid cursor'
         end
-        private_class_method :decode, :decode_as
+
+        def validate_fields!(timestamp, id)
+          raise RequestError, 'invalid cursor' unless timestamp.finite? && id.positive?
+        end
+        private_class_method :decode, :decode_as, :decode_fields, :validate_fields!
       end
     end
   end

data/lib/async/background/web/metrics_reader.rb

@@ -23,12 +23,10 @@ module Async
         LATEST_FIELD = :last_run_at
         LATEST_COMPANION = :last_duration_ms
 
-        EMPTY_TOTALS = (
-          SUMMED_FIELDS.to_h { |field| [field, 0] }
-            .merge(LATEST_FIELD => 0, LATEST_COMPANION => nil)
-        ).freeze
+        EMPTY_TOTALS = SUMMED_FIELDS.to_h { |field| [field, 0] }
+                                    .merge(LATEST_FIELD => 0, LATEST_COMPANION => nil).freeze
 
-        UNAVAILABLE = {available: false, workers: EMPTY_WORKERS, totals: EMPTY_TOTALS}.freeze
+        UNAVAILABLE = { available: false, workers: EMPTY_WORKERS, totals: EMPTY_TOTALS }.freeze
 
         def initialize(path:, total_workers:, ttl: DEFAULT_TTL)
           @path = path
@@ -60,7 +58,7 @@ module Async
           return unavailable unless Metrics.available? && File.file?(@path)
 
           workers = Metrics.read_all(total_workers: @total_workers, path: @path)
-          {available: true, workers: workers, totals: aggregate(workers)}
+          { available: true, workers: workers, totals: aggregate(workers) }
         rescue StandardError
           unavailable
         end

data/lib/async/background/web/response.rb

@@ -49,7 +49,7 @@ module Async
         ERROR_BODY = ERRORS.to_h { |name, (_, code)| [name, JSON.generate(error: code).freeze] }.freeze
 
         def headers(content_type, cache_control, security = BASE_SECURITY_HEADERS)
-          {'content-type' => content_type, 'cache-control' => cache_control}.merge(security)
+          { 'content-type' => content_type, 'cache-control' => cache_control }.merge(security)
         end
 
         def no_store_headers(content_type) = headers(content_type, NO_STORE)

data/lib/async/background/web/serializer.rb

@@ -55,7 +55,7 @@ module Async
           pending: %i[created_at run_at].freeze
         }.freeze
 
-        CURSOR_KEY = {done: :finished_at, failed: :finished_at, pending: :run_at}.freeze
+        CURSOR_KEY = { done: :finished_at, failed: :finished_at, pending: :run_at }.freeze
 
         def item(kind, row)
           args, args_count = args_for(row[:args_raw])
@@ -76,7 +76,7 @@ module Async
           last = items.last
           cursor = last && Cursor.encode(last[CURSOR_KEY.fetch(kind)], last[:id])
 
-          {items: items, next_cursor: cursor}
+          { items: items, next_cursor: cursor }
         end
 
         def args_for(raw)

data/lib/async/background/web/snapshot.rb

@@ -13,11 +13,11 @@ module Async
         include Clock
 
         CacheEntry = Data.define(:value, :created_at)
-        RAW_COLUMNS = {'args' => :args_raw, 'options' => :options_raw}.freeze
+        RAW_COLUMNS = { 'args' => :args_raw, 'options' => :options_raw }.freeze
 
         ROW_KEYS = SQL::EXTRA_COLUMNS.to_h do |status, extra|
           columns = SQL::BASE_COLUMNS + extra
-          [status, columns.map { |column| RAW_COLUMNS.fetch(column, column.to_sym) }.freeze]
+            [status, columns.map { |column| RAW_COLUMNS.fetch(column) { column.to_sym } }.freeze]
         end.freeze
 
         PAGING = {
@@ -109,8 +109,8 @@ module Async
           SQLite3::Database.new(database_uri, uri: true)
         rescue LoadError
           raise
-        rescue StandardError => error
-          raise UnavailableError, "cannot open queue database: #{error.message}"
+        rescue StandardError => e
+          raise UnavailableError, "cannot open queue database: #{e.message}"
         end
 
         def database_uri
@@ -192,7 +192,7 @@ module Async
           require 'sqlite3'
         rescue LoadError
           raise LoadError,
-                "sqlite3 gem is required for Async::Background::Web. " \
+                'sqlite3 gem is required for Async::Background::Web. ' \
                 "Add `gem 'sqlite3', '~> 2.0'` to your Gemfile."
         end
       end

data/lib/async/background/web/sql.rb

@@ -4,11 +4,11 @@ module Async
   module Background
     module Web
       module SQL
-        BEGIN_READ_TRANSACTION = 'BEGIN'.freeze
-        COMMIT = 'COMMIT'.freeze
-        ROLLBACK = 'ROLLBACK'.freeze
-        QUERY_ONLY = 'PRAGMA query_only = ON'.freeze
-        BUSY_TIMEOUT = 'PRAGMA busy_timeout = 2000'.freeze
+        BEGIN_READ_TRANSACTION = 'BEGIN'
+        COMMIT = 'COMMIT'
+        ROLLBACK = 'ROLLBACK'
+        QUERY_ONLY = 'PRAGMA query_only = ON'
+        BUSY_TIMEOUT = 'PRAGMA busy_timeout = 2000'
         BASE_COLUMNS = %w[id class_name args options].freeze
 
         STATUS_PREDICATE = {
@@ -35,8 +35,8 @@ module Async
           failed: ['finished_at', :desc]
         }.freeze
 
-        ORDER_SQL = {asc: 'ORDER BY %<column>s, id', desc: 'ORDER BY %<column>s DESC, id DESC'}.freeze
-        SEEK_SQL = {asc: '(%<column>s, id) > (?, ?)', desc: '(%<column>s, id) < (?, ?)'}.freeze
+        ORDER_SQL = { asc: 'ORDER BY %<column>s, id', desc: 'ORDER BY %<column>s DESC, id DESC' }.freeze
+        SEEK_SQL = { asc: '(%<column>s, id) > (?, ?)', desc: '(%<column>s, id) < (?, ?)' }.freeze
 
         def self.columns_for(status)
           (BASE_COLUMNS + EXTRA_COLUMNS.fetch(status)).join(', ')

data/lib/async/background/web/stream.rb

@@ -26,41 +26,13 @@ module Async
           end
 
           yield frame
-          last_yield = monotonic_now
-          unavailable_announced = false
-
-          loop do
-            sleep_for_poll
-
-            begin
-              new_version = @hub.current_version
-
-              if new_version != version
-                version = new_version
-                yield @hub.frame_for(version)
-                last_yield = monotonic_now
-              elsif (monotonic_now - last_yield) >= @heartbeat_seconds
-                yield EventHub::HEARTBEAT_FRAME
-                last_yield = monotonic_now
-              end
-
-              unavailable_announced = false
-            rescue ClosedError
-              break
-            rescue UnavailableError
-              unless unavailable_announced
-                yield EventHub::UNAVAILABLE_FRAME
-                unavailable_announced = true
-                last_yield = monotonic_now
-              end
-            end
-          end
+          stream_updates(version, monotonic_now) { |event| yield event }
         rescue Errno::EPIPE, Errno::ECONNRESET, IOError
           nil
-        rescue StandardError => error
+        rescue StandardError => e
           @logger&.error(
-            "[async-background-web] SSE stream terminated: " \
-            "#{error.class}: #{error.message}"
+            '[async-background-web] SSE stream terminated: ' \
+            "#{e.class}: #{e.message}"
           )
           nil
         end
@@ -76,6 +48,54 @@ module Async
         def sleep_for_poll
           sleep(@poll_seconds)
         end
+
+        def stream_updates(version, last_yield)
+          unavailable_announced = false
+          loop do
+            sleep_for_poll
+            state = next_state(version, last_yield, unavailable_announced) { |event| yield event }
+            break unless state
+
+            version, last_yield, unavailable_announced = state
+          end
+        end
+
+        def next_state(version, last_yield, unavailable_announced)
+          current_version = @hub.current_version
+          return updated_state(current_version) { |event| yield event } if current_version != version
+          return heartbeat_state(version) { |event| yield event } if heartbeat_due?(last_yield)
+
+          [version, last_yield, false]
+        rescue ClosedError
+          nil
+        rescue UnavailableError
+          announce_unavailable(version, last_yield, unavailable_announced) { |event| yield event }
+        end
+
+        def updated_state(version)
+          yield @hub.frame_for(version)
+          [version, monotonic_now, false]
+        end
+
+        def heartbeat_state(version)
+          yield EventHub::HEARTBEAT_FRAME
+          [version, monotonic_now, false]
+        end
+
+        def heartbeat_due?(last_yield)
+          (monotonic_now - last_yield) >= @heartbeat_seconds
+        end
+
+        def announce_unavailable(version, last_yield, announced)
+          return [version, last_yield, true] if announced
+
+          yield_unavailable { |event| yield event }
+          [version, monotonic_now, true]
+        end
+
+        def yield_unavailable
+          yield EventHub::UNAVAILABLE_FRAME
+        end
       end
     end
   end

data/lib/async/background/web.rb

@@ -37,7 +37,7 @@ module Async
 
       def configuration
         @configuration or raise NotConfiguredError,
-                               'Async::Background::Web is not configured. Call Async::Background::Web.configure.'
+                                'Async::Background::Web is not configured. Call Async::Background::Web.configure.'
       end
 
       def reset!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-background
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Roman Hajdarov
@@ -157,6 +157,7 @@ files:
 - lib/async/background/queue/sql.rb
 - lib/async/background/queue/store.rb
 - lib/async/background/runner.rb
+- lib/async/background/runner/lifecycle.rb
 - lib/async/background/runner/queue_execution.rb
 - lib/async/background/runner/schedule.rb
 - lib/async/background/runtime.rb
@@ -169,6 +170,9 @@ files:
 - lib/async/background/web.rb
 - lib/async/background/web/app.rb
 - lib/async/background/web/assets.rb
+- lib/async/background/web/assets/app.css
+- lib/async/background/web/assets/app.js
+- lib/async/background/web/assets/index.html
 - lib/async/background/web/auth.rb
 - lib/async/background/web/configuration.rb
 - lib/async/background/web/cursor.rb