jumbotron 0.1.1

data/app/scheduling/jumbotron/scheduling/clock.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Scheduling
+    class Clock
+      MINUTE = 17
+      HOUR = 6
+      WEEKDAY = 3
+      WEEKDAY_NAME = "wednesday"
+
+      def self.clock_time
+        "#{HOUR}:#{format('%02d', MINUTE)} am"
+      end
+
+      def self.fugit(cadence)
+        every = cadence.every
+        case canonical_unit(cadence.unit)
+        when :second then every == 1 ? "every second" : "every #{every} seconds"
+        when :minute then every == 1 ? "every minute" : "every #{every} minutes"
+        when :hour then hour_fugit(every)
+        when :day then day_fugit(every)
+        when :week then "every #{WEEKDAY_NAME} at #{clock_time}"
+        else
+          raise ArgumentError, "unsupported cadence unit: #{cadence.unit}"
+        end
+      end
+
+      def self.cron(cadence)
+        every = cadence.every
+        case canonical_unit(cadence.unit)
+        when :minute then "*/#{every} * * * *"
+        when :hour then hour_cron(every)
+        when :day then day_cron(every)
+        when :week then "#{MINUTE} #{HOUR} * * #{WEEKDAY}"
+        else
+          raise ArgumentError, "unsupported cadence unit: #{cadence.unit}"
+        end
+      end
+
+      def self.canonical_unit(unit)
+        unit.to_s.sub(/s\z/, "").to_sym
+      end
+
+      def self.hour_fugit(every)
+        every == 1 ? "every hour at minute #{MINUTE}" : "every #{every} hours at minute #{MINUTE}"
+      end
+
+      def self.day_fugit(every)
+        every == 1 ? "every day at #{clock_time}" : "every #{every} days at #{clock_time}"
+      end
+
+      def self.hour_cron(every)
+        every == 1 ? "#{MINUTE} * * * *" : "#{MINUTE} */#{every} * * *"
+      end
+
+      def self.day_cron(every)
+        every == 1 ? "#{MINUTE} #{HOUR} * * *" : "#{MINUTE} #{HOUR} */#{every} * *"
+      end
+    end
+  end
+end

data/app/scheduling/jumbotron/scheduling/desired_schedules.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Scheduling
+    module DesiredSchedules
+      GAME_JOB_CLASS_NAME = "Jumbotron::GameUpdateJob"
+      LINE_JOB_CLASS_NAME = "Jumbotron::LineUpdateJob"
+
+      module_function
+
+      def call
+        ensure_adapters_loaded!
+        Adapters::Registry.registered.flat_map { |adapter| schedules_for(adapter) }
+      end
+
+      def schedules_for(adapter)
+        adapter.policies.values.filter_map { |policy| definition_for(adapter, policy) }
+      end
+
+      def definition_for(adapter, policy)
+        return if adapter.discovery_ids.include?(policy.id)
+        return if policy.cadence.nil?
+
+        job_class_name = job_class_name_for(policy)
+        return if job_class_name.nil?
+
+        ScheduleDefinition.new(
+          id: Owned.id(adapter.adapter_id, policy.id),
+          job_class_name: job_class_name,
+          arguments: {
+            "adapter_id" => adapter.adapter_id.to_s,
+            "policy_id" => policy.id.to_s
+          },
+          cadence: policy.cadence
+        )
+      end
+
+      def job_class_name_for(policy)
+        if Services::Adapters::ResolveGameUpdatePolicy::UPDATE_POLICY_TYPES.include?(policy.type)
+          GAME_JOB_CLASS_NAME
+        elsif Services::Adapters::ResolveLineUpdatePolicy::LINE_POLICY_TYPES.include?(policy.type)
+          LINE_JOB_CLASS_NAME
+        end
+      end
+
+      def ensure_adapters_loaded!
+        Adapters::Registry.ensure_loaded!
+      end
+    end
+  end
+end

data/app/scheduling/jumbotron/scheduling/detect_integration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Scheduling
+    class UnsupportedIntegrationError < StandardError; end
+
+    module DetectIntegration
+      SUPPORTED = "Solid Queue, Sidekiq + Sidekiq-Cron"
+
+      module_function
+
+      def call
+        name = adapter_name
+        return Backends::SolidQueue.new if name == :solid_queue
+        return sidekiq_backend! if name == :sidekiq
+
+        raise_unsupported(name)
+      end
+
+      def adapter_name
+        return ActiveJob::Base.queue_adapter_name.to_s.to_sym if ActiveJob::Base.respond_to?(:queue_adapter_name)
+
+        configured = Rails.application.config.active_job.queue_adapter
+        return configured.to_sym if configured.is_a?(Symbol)
+
+        ActiveJob::Base.queue_adapter.class.name.to_s.demodulize.underscore.sub(/_adapter\z/, "").to_sym
+      end
+
+      def sidekiq_backend!
+        return Backends::SidekiqCron.new if defined?(::Sidekiq::Cron::Job)
+
+        raise UnsupportedIntegrationError,
+              "Jumbotron recurring schedules cannot be materialized for ActiveJob adapter :sidekiq " \
+              "because no supported recurring scheduler is present. " \
+              "Supported scheduling integrations: #{SUPPORTED}."
+      end
+
+      def raise_unsupported(name)
+        raise UnsupportedIntegrationError,
+              "Jumbotron recurring schedules cannot be materialized for ActiveJob adapter :#{name}. " \
+              "Supported scheduling integrations: #{SUPPORTED}."
+      end
+    end
+  end
+end

data/app/scheduling/jumbotron/scheduling/materializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Scheduling
+    class Materializer
+      def self.call(schedules: nil, backend: nil, solid_queue_path: nil)
+        schedules ||= DesiredSchedules.call
+        backend ||= DetectIntegration.call
+        backend.materialize(schedules, path: solid_queue_path)
+      end
+    end
+  end
+end

data/app/scheduling/jumbotron/scheduling/owned.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Scheduling
+    module Owned
+      PREFIX = "jumbotron:"
+
+      module_function
+
+      def key?(name)
+        name.to_s.start_with?(PREFIX)
+      end
+
+      def id(adapter_id, policy_id)
+        "#{PREFIX}#{adapter_id}:#{policy_id}"
+      end
+    end
+  end
+end

data/app/scheduling/jumbotron/scheduling/schedule_definition.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Scheduling
+    ScheduleDefinition = Data.define(:id, :job_class_name, :arguments, :cadence)
+  end
+end

data/app/serializers/jumbotron/serializers/clients/espn/competition_odds/get.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Serializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class Get
+            def self.call(_input)
+              CommandTower::Clients::SerializedRequest.build(query: {})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/jumbotron/serializers/clients/espn/scoreboard/get.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Serializers
+    module Clients
+      module Espn
+        module Scoreboard
+          class Get
+            def self.call(input)
+              query = {}
+              query["seasontype"] = input.season_type unless input.season_type.nil?
+              query["week"] = input.week unless input.week.nil?
+              query["dates"] = input.dates unless input.dates.nil?
+
+              CommandTower::Clients::SerializedRequest.build(query: query)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/jumbotron/serializers/clients/espn/teams/get.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Serializers
+    module Clients
+      module Espn
+        module Teams
+          class Get
+            def self.call(input)
+              query = {}
+              query["limit"] = input.limit unless input.limit.nil?
+
+              CommandTower::Clients::SerializedRequest.build(query: query)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/build_acquisition_scopes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class BuildAcquisitionScopes < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :games, required: true
+
+        def call
+          seen = {}
+          scopes = []
+          incomplete = 0
+          Array(games).each do |game|
+            scope = adapter.acquisition_scope_for(game)
+            if scope.nil?
+              incomplete += 1
+              next
+            end
+
+            key = [
+              scope.fetch(:endpoint),
+              Synchronization::Lease.normalized_acquisition_parts(scope.fetch(:acquisition))
+            ]
+            next if seen[key]
+
+            seen[key] = true
+            scopes << { endpoint: scope.fetch(:endpoint), acquisition: scope.fetch(:acquisition) }
+          end
+
+          context.scopes = scopes
+          context.skipped_incomplete_scope = incomplete
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/build_line_acquisition_scopes.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class BuildLineAcquisitionScopes < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :games, required: true
+
+        def call
+          seen = {}
+          scopes = []
+          incomplete = 0
+          games_by_id = Game.where(id: Array(games).map(&:id)).includes(:provider_identities).index_by(&:id)
+          Array(games).each do |game|
+            scoped_game = games_by_id[game.id] || game
+            scope = adapter.line_acquisition_scope_for(scoped_game)
+            if scope.nil?
+              incomplete += 1
+              next
+            end
+
+            key = [
+              scope.fetch(:endpoint),
+              Synchronization::Lease.normalized_acquisition_parts(scope.fetch(:acquisition))
+            ]
+            next if seen[key]
+
+            seen[key] = true
+            scopes << { endpoint: scope.fetch(:endpoint), acquisition: scope.fetch(:acquisition) }
+          end
+
+          context.scopes = scopes
+          context.skipped_incomplete_scope = incomplete
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/ensure_league.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class EnsureLeague < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+
+        def call
+          sport = find_or_create_sport
+          league = find_or_create_league(sport)
+          context.league = league
+        end
+
+        private
+
+        def find_or_create_sport
+          existing = Jumbotron::Sport.where("LOWER(name) = ?", adapter.sport.downcase).first
+          existing || Jumbotron::Sport.create!(name: adapter.sport)
+        end
+
+        def find_or_create_league(sport)
+          existing = sport.leagues.where("LOWER(name) = ?", adapter.league.downcase).first
+          existing || sport.leagues.create!(name: adapter.league)
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/execute_endpoint.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class ExecuteEndpoint < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :endpoint, required: true
+        validate :observed_at, required: true
+        validate :acquisition, is_a: Hash, required: false
+
+        def call
+          operation = adapter.operation(endpoint)
+          provider_result = operation.acquire(**(acquisition || {}))
+          unless provider_result.success?
+            fail_acquisition!(provider_result)
+            return
+          end
+
+          begin
+            context.sync_input = operation.transform(provider_result.output, observed_at: observed_at)
+          rescue Jumbotron::Adapters::TransformError => e
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::NormalizationFailedError.new(
+                details: { message: e.message }
+              )
+            )
+          end
+        end
+
+        private
+
+        def fail_acquisition!(provider_result)
+          error = provider_result.error
+          if error.is_a?(Jumbotron::Providers::Espn::CooldownActiveError)
+            context.fail!(application_error: Jumbotron::Errors::Adapters::ProviderCooldownActiveError.new)
+            return
+          end
+
+          context.fail!(
+            application_error: Jumbotron::Errors::Adapters::AcquisitionFailedError.new(
+              details: { message: error&.message || "provider acquisition failed" }
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/execute_line_acquisition_scope.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class ExecuteLineAcquisitionScope < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :acquisition, is_a: Hash, required: true
+
+        def call
+          if adapter.provider_cooling_down?
+            context.outcome = :cooldown_active
+            return
+          end
+
+          lease = Synchronization::Lease.new
+          lease_scope = Synchronization::Lease.scope(
+            adapter_id: adapter.adapter_id,
+            endpoint: :competition_odds,
+            acquisition: acquisition
+          )
+          held = lease.acquire(lease_scope)
+          unless held.acquired?
+            context.outcome = :contention
+            return
+          end
+
+          begin
+            execute_held
+          ensure
+            lease.release(lease_scope, token: held.token)
+          end
+        end
+
+        private
+
+        def execute_held
+          provider_result = adapter.acquire_line_odds(acquisition)
+          unless provider_result.success?
+            record_acquisition_failure(provider_result)
+            return
+          end
+
+          ingest = adapter.translate_line_odds(
+            provider_result.output,
+            observed_at: Time.current,
+            acquisition: acquisition
+          )
+          persisted = Canonical::PersistLineObservations.call(ingest: ingest)
+          unless persisted.success?
+            context.outcome = :failed
+            context.failure_class = "mutation"
+            return
+          end
+
+          context.outcome = :succeeded
+        rescue Jumbotron::Adapters::TransformError
+          context.outcome = :failed
+          context.failure_class = "mutation"
+        end
+
+        def record_acquisition_failure(provider_result)
+          error = provider_result.error
+          if error.is_a?(Jumbotron::Providers::Espn::CooldownActiveError)
+            context.outcome = :cooldown_active
+            return
+          end
+
+          context.outcome = :failed
+          context.failure_class = "acquisition"
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/execute_synchronization_scope.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      # Isolates lease + existing SynchronizeAdapterWorkflow.call. The workflow-calls-workflow
+      # rule remains deferred; do not invent a SharedSequence here.
+      class ExecuteSynchronizationScope < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :league, required: true
+        validate :endpoint, required: true
+        validate :acquisition, is_a: Hash, required: true
+
+        def call
+          lease = Synchronization::Lease.new
+          lease_scope = Synchronization::Lease.scope(
+            adapter_id: adapter.adapter_id,
+            endpoint: endpoint,
+            acquisition: acquisition
+          )
+          held = lease.acquire(lease_scope)
+          unless held.acquired?
+            context.outcome = :contention
+            return
+          end
+
+          begin
+            record_sync_outcome(
+              Workflows::SynchronizeAdapterWorkflow.call(
+                adapter: adapter,
+                endpoint: endpoint,
+                league_id: league.id,
+                acquisition: acquisition
+              )
+            )
+          ensure
+            lease.release(lease_scope, token: held.token)
+          end
+        end
+
+        private
+
+        def record_sync_outcome(result)
+          if result.success?
+            context.outcome = :succeeded
+            return
+          end
+
+          code = Array(result.errors).first
+          code = code[:code] if code.is_a?(Hash)
+          code = code.code if code.respond_to?(:code)
+
+          if code.to_s == "provider_cooldown_active"
+            context.outcome = :cooldown_active
+            return
+          end
+
+          context.outcome = :failed
+          context.failure_class = result.meta[:failure_class]
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/resolve_discovery.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class ResolveDiscovery < CommandTower::Services::ApplicationService
+        validate :adapter_id, required: true
+        validate :discovery_id, required: true
+
+        def call
+          Jumbotron::Adapters::Registry.ensure_loaded!
+          adapter = Jumbotron::Adapters::Registry.find(adapter_id)
+          if adapter.nil?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::UnknownAdapterError.new(
+                details: { adapter_id: adapter_id }
+              )
+            )
+            return
+          end
+
+          unless adapter.registered?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::NotRegisteredError.new(
+                details: { adapter: adapter.to_s }
+              )
+            )
+            return
+          end
+
+          definition = lookup_discovery(adapter)
+          return if definition.nil?
+
+          context.adapter = adapter
+          context.definition = definition
+        end
+
+        private
+
+        def lookup_discovery(adapter)
+          adapter.discovery(discovery_id.to_sym)
+        rescue Jumbotron::Adapters::UnknownDiscoveryError
+          context.fail!(
+            application_error: Jumbotron::Errors::Adapters::UnknownDiscoveryError.new(
+              details: { discovery_id: discovery_id }
+            )
+          )
+          nil
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/resolve_game_update_policy.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class ResolveGameUpdatePolicy < CommandTower::Services::ApplicationService
+        UPDATE_POLICY_TYPES = %i[
+          future_game_update
+          live_game_update
+          interrupted_game_update
+        ].freeze
+
+        validate :adapter_id, required: true
+        validate :policy_id, required: true
+
+        def call
+          Jumbotron::Adapters::Registry.ensure_loaded!
+          adapter = Jumbotron::Adapters::Registry.find(adapter_id)
+          if adapter.nil?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::UnknownAdapterError.new(
+                details: { adapter_id: adapter_id }
+              )
+            )
+            return
+          end
+
+          unless adapter.registered?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::NotRegisteredError.new(
+                details: { adapter: adapter.to_s }
+              )
+            )
+            return
+          end
+
+          key = policy_id.to_sym
+          if adapter.discovery_ids.include?(key)
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::DiscoveryNotExecutableError.new(
+                details: { policy_id: policy_id }
+              )
+            )
+            return
+          end
+
+          policy = lookup_policy(adapter, key)
+          return if policy.nil?
+
+          unless UPDATE_POLICY_TYPES.include?(policy.type)
+            context.fail!(application_error: Jumbotron::Errors::Adapters::InvalidPolicyTypeError.new)
+            return
+          end
+
+          context.adapter = adapter
+          context.policy = policy
+        end
+
+        private
+
+        def lookup_policy(adapter, key)
+          adapter.policy(key)
+        rescue Jumbotron::Adapters::UnknownPolicyError
+          context.fail!(
+            application_error: Jumbotron::Errors::Adapters::UnknownPolicyError.new(
+              details: { policy_id: policy_id }
+            )
+          )
+          nil
+        end
+      end
+    end
+  end
+end