flight_control 2.0.0.beta.1

data/lib/flight_control/engine.rb

@@ -0,0 +1,102 @@
+require "importmap-rails"
+require "turbo-rails"
+require "stimulus-rails"
+
+module FlightControl
+  class Engine < ::Rails::Engine
+    isolate_namespace FlightControl
+
+    rake_tasks do
+      load "flight_control/tasks.rb"
+    end
+
+    initializer "flight_control.middleware" do |app|
+      if app.config.api_only
+        config.middleware.use ActionDispatch::Flash
+        config.middleware.use ::Rack::MethodOverride
+      end
+    end
+
+    config.flight_control = ActiveSupport::OrderedOptions.new unless config.try(:flight_control)
+
+    config.before_initialize do
+      config.flight_control.applications = FlightControl::Applications.new
+      config.flight_control.backtrace_cleaner ||= Rails::BacktraceCleaner.new
+
+      config.flight_control.each do |key, value|
+        FlightControl.public_send("#{key}=", value)
+      end
+
+      if FlightControl.adapters.empty?
+        FlightControl.adapters << (config.active_job.queue_adapter || :solid_queue)
+      end
+
+      unless FlightControl.adapters.all? { |adapter| adapter.to_sym == :solid_queue }
+        unsupported = FlightControl.adapters.reject { |adapter| adapter.to_sym == :solid_queue }
+        raise FlightControl::Errors::UnsupportedAdapter,
+          "Flight Control only supports Solid Queue, but the following adapters are configured: #{unsupported.join(", ")}"
+      end
+    end
+
+    initializer "flight_control.http_basic_auth" do |app|
+      FlightControl.http_basic_auth_user ||= app.credentials.dig(:flight_control, :http_basic_auth_user)
+      FlightControl.http_basic_auth_password ||= app.credentials.dig(:flight_control, :http_basic_auth_password)
+    end
+
+    initializer "flight_control.active_job.extensions" do
+      ActiveSupport.on_load :active_job do
+        include ActiveJob::Querying
+        include ActiveJob::Executing
+        include ActiveJob::Failed
+        ActiveJob.extend ActiveJob::Querying::Root
+      end
+    end
+
+    config.before_initialize do
+      ActiveJob::QueueAdapters::SolidQueueAdapter.prepend ActiveJob::QueueAdapters::SolidQueueExt
+    end
+
+    config.after_initialize do |app|
+      if FlightControl.applications.empty?
+        queue_adapters_by_name = FlightControl.adapters.each_with_object({}) do |adapter, hsh|
+          hsh[adapter] = ActiveJob::QueueAdapters.lookup(adapter).new
+        end
+
+        FlightControl.applications.add(app.class.module_parent.name, queue_adapters_by_name)
+      end
+    end
+
+    console do
+      require "irb"
+
+      IRB::Command.register :connect_to, Console::ConnectTo
+      IRB::Command.register :jobs_help, Console::JobsHelp
+
+      IRB::Context.prepend(FlightControl::Console::Context)
+
+      FlightControl.delay_between_bulk_operation_batches = 2
+      FlightControl.logger = ActiveSupport::Logger.new($stdout)
+
+      if FlightControl.show_console_help
+        puts "\n\nType 'jobs_help' to see how to connect to the available job servers to manage jobs\n\n"
+      end
+    end
+
+    initializer "flight_control.assets" do |app|
+      app.config.assets.paths << root.join("app/assets/stylesheets")
+      app.config.assets.paths << root.join("app/javascript")
+      app.config.assets.precompile += %w[flight_control_manifest]
+    end
+
+    initializer "flight_control.importmap", after: "importmap" do |app|
+      FlightControl.importmap.draw(root.join("config/importmap.rb"))
+      if app.config.importmap.sweep_cache && app.config.reloading_enabled?
+        FlightControl.importmap.cache_sweeper(watches: root.join("app/javascript"))
+
+        ActiveSupport.on_load(:action_controller_base) do
+          before_action { FlightControl.importmap.cache_sweeper.execute_if_updated }
+        end
+      end
+    end
+  end
+end

data/lib/flight_control/errors/incompatible_adapter.rb

@@ -0,0 +1,2 @@
+class FlightControl::Errors::IncompatibleAdapter < StandardError
+end

data/lib/flight_control/errors/resource_not_found.rb

@@ -0,0 +1,2 @@
+class FlightControl::Errors::ResourceNotFound < StandardError
+end

data/lib/flight_control/errors/unsupported_adapter.rb

@@ -0,0 +1,2 @@
+class FlightControl::Errors::UnsupportedAdapter < StandardError
+end

data/lib/flight_control/i18n_config.rb

@@ -0,0 +1,17 @@
+class FlightControl::I18nConfig < ::I18n::Config
+  AVAILABLE_LOCALES = [:en]
+  AVAILABLE_LOCALES_SET = [:en, "en"]
+  DEFAULT_LOCALE = :en
+
+  def available_locales
+    AVAILABLE_LOCALES
+  end
+
+  def available_locales_set
+    AVAILABLE_LOCALES_SET
+  end
+
+  def default_locale
+    DEFAULT_LOCALE
+  end
+end

data/lib/flight_control/identified_by_name.rb

@@ -0,0 +1,18 @@
+module FlightControl::IdentifiedByName
+  extend ActiveSupport::Concern
+
+  included do
+    attr_reader :name
+    alias_method :to_s, :name
+  end
+
+  def initialize(name:)
+    @name = name.to_s
+  end
+
+  def id
+    name.parameterize
+  end
+
+  alias_method :to_param, :id
+end

data/lib/flight_control/identified_elements.rb

@@ -0,0 +1,24 @@
+# A collection of elements offering a Hash-like access based on
+# their +id+.
+class FlightControl::IdentifiedElements
+  include Enumerable
+
+  delegate :[], :empty?, to: :elements
+  delegate :each, :last, :length, to: :to_a
+
+  def initialize
+    @elements = HashWithIndifferentAccess.new
+  end
+
+  def <<(item)
+    @elements[item.id] = item
+  end
+
+  def to_a
+    @elements.values
+  end
+
+  private
+
+  attr_reader :elements
+end

data/lib/flight_control/server/recurring_tasks.rb

@@ -0,0 +1,15 @@
+module FlightControl::Server::RecurringTasks
+  def recurring_tasks
+    queue_adapter.recurring_tasks.collect do |task|
+      FlightControl::RecurringTask.new(queue_adapter: queue_adapter, **task)
+    end.sort_by(&:id)
+  end
+
+  def find_recurring_task(task_id)
+    if (task = queue_adapter.find_recurring_task(task_id))
+      FlightControl::RecurringTask.new(queue_adapter: queue_adapter, **task)
+    else
+      raise FlightControl::Errors::ResourceNotFound, "Recurring task with id '#{task_id}' not found"
+    end
+  end
+end

data/lib/flight_control/server/serializable.rb

@@ -0,0 +1,24 @@
+module FlightControl::Server::Serializable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Loads a server from a locator string with the format +<application>:<server>+. For example:
+    #
+    #   bc4:us_east
+    #
+    # When the +<server>+ fragment is omitted it will return the first server for the application.
+    def from_global_id(global_id)
+      app_id, server_id = global_id.split(":")
+
+      application = FlightControl.applications[app_id] or raise FlightControl::Errors::ResourceNotFound, "No application with id #{app_id} found"
+      server = server_id ? application.servers[server_id] : application.servers.first
+
+      server or raise FlightControl::Errors::ResourceNotFound, "No server for #{global_id} found"
+    end
+  end
+
+  def to_global_id
+    suffix = ":#{id}" if application.servers.many?
+    "#{application&.id}#{suffix}"
+  end
+end

data/lib/flight_control/server/workers.rb

@@ -0,0 +1,13 @@
+module FlightControl::Server::Workers
+  def workers_relation
+    FlightControl::WorkersRelation.new(queue_adapter: queue_adapter)
+  end
+
+  def find_worker(worker_id)
+    if (worker = queue_adapter.find_worker(worker_id))
+      FlightControl::Worker.new(queue_adapter: queue_adapter, **worker)
+    else
+      raise FlightControl::Errors::ResourceNotFound, "Worker with id '#{worker_id}' not found"
+    end
+  end
+end

data/lib/flight_control/server.rb

@@ -0,0 +1,33 @@
+require "active_job/queue_adapter"
+
+class FlightControl::Server
+  include FlightControl::IdentifiedByName
+  include Workers
+  include RecurringTasks
+  include Serializable
+
+  attr_reader :name, :queue_adapter, :application, :backtrace_cleaner
+
+  def initialize(name:, queue_adapter:, application:, backtrace_cleaner: nil)
+    super(name: name)
+    unless queue_adapter.is_a?(ActiveJob::QueueAdapters::SolidQueueAdapter)
+      raise FlightControl::Errors::UnsupportedAdapter,
+        "Flight Control only supports Solid Queue, can't register server #{name} with #{queue_adapter.class}"
+    end
+    @queue_adapter = queue_adapter
+    @application = application
+    @backtrace_cleaner = backtrace_cleaner || FlightControl.backtrace_cleaner
+  end
+
+  def activating(&block)
+    previous_adapter = ActiveJob::Base.current_queue_adapter
+    ActiveJob::Base.current_queue_adapter = queue_adapter
+    queue_adapter.activating(&block)
+  ensure
+    ActiveJob::Base.current_queue_adapter = previous_adapter
+  end
+
+  def queue_adapter_name
+    ActiveJob.adapter_name(queue_adapter).underscore.to_sym
+  end
+end

data/lib/flight_control/tasks.rb

@@ -0,0 +1,6 @@
+namespace :flight_control do
+  desc "Configure HTTP Basic Authentication"
+  task "authentication:configure" => :environment do
+    FlightControl::Authentication.configure
+  end
+end

data/lib/flight_control/version.rb

@@ -0,0 +1,3 @@
+module FlightControl
+  VERSION = "2.0.0.beta.1"
+end

data/lib/flight_control/workers_relation.rb

@@ -0,0 +1,79 @@
+# A relation of workers.
+#
+# Relations are enumerable, so you can use +Enumerable+ methods on them.
+# Notice however that using these methods will imply loading all the relation
+# in memory, which could introduce performance concerns.
+class FlightControl::WorkersRelation
+  include Enumerable
+
+  attr_accessor :offset_value, :limit_value
+
+  delegate :last, :[], :to_s, :reverse, to: :to_a
+
+  ALL_WORKERS_LIMIT = 100_000_000 # When no limit value it defaults to "all workers"
+
+  def initialize(queue_adapter:)
+    @queue_adapter = queue_adapter
+
+    set_defaults
+  end
+
+  def offset(offset)
+    clone_with offset_value: offset
+  end
+
+  def limit(limit)
+    clone_with limit_value: limit
+  end
+
+  def each(&block)
+    workers.each(&block)
+  end
+
+  def reload
+    @count = @workers = nil
+    self
+  end
+
+  def count
+    if loaded?
+      to_a.length
+    else
+      query_count
+    end
+  end
+
+  def empty?
+    count == 0
+  end
+
+  alias_method :length, :count
+  alias_method :size, :count
+
+  private
+
+  def set_defaults
+    self.offset_value = 0
+    self.limit_value = ALL_WORKERS_LIMIT
+  end
+
+  def workers
+    @workers ||= @queue_adapter.fetch_workers(self)
+  end
+
+  def query_count
+    @count ||= @queue_adapter.count_workers(self)
+  end
+
+  def loaded?
+    !@workers.nil?
+  end
+
+  def clone_with(**properties)
+    dup.reload.tap do |relation|
+      properties.each do |key, value|
+        relation.send("#{key}=", value)
+      end
+    end
+  end
+end

data/lib/flight_control.rb

@@ -0,0 +1,39 @@
+require "solid_queue"
+
+require "flight_control/version"
+require "flight_control/engine"
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.new
+loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
+loader.push_dir(__dir__)
+loader.ignore("#{__dir__}/flight_control/tasks.rb")
+loader.setup
+
+module FlightControl
+  mattr_accessor :adapters, default: Set.new
+  mattr_accessor :applications, default: FlightControl::Applications.new
+  mattr_accessor :base_controller_class, default: "::ApplicationController"
+
+  mattr_accessor :internal_query_count_limit, default: 500_000 # Hard limit to keep unlimited count queries fast enough
+  mattr_accessor :delay_between_bulk_operation_batches, default: 0
+  mattr_accessor :scheduled_job_delay_threshold, default: 1.minute
+
+  mattr_accessor :logger, default: ActiveSupport::Logger.new(nil)
+
+  mattr_accessor :show_console_help, default: true
+  mattr_accessor :backtrace_cleaner
+
+  mattr_accessor :importmap, default: Importmap::Map.new
+
+  mattr_accessor :http_basic_auth_user
+  mattr_accessor :http_basic_auth_password
+  mattr_accessor :http_basic_auth_enabled, default: true
+
+  mattr_accessor :filter_arguments, default: []
+
+  def self.job_arguments_filter
+    FlightControl::ArgumentsFilter.new(filter_arguments)
+  end
+end