acpc_table_manager 0.0.1

data/lib/acpc_table_manager/simple_logging.rb

@@ -0,0 +1,54 @@
+require 'awesome_print'
+require 'logger'
+require 'fileutils'
+
+# @todo Move to its own gem the next time I find I need easier logging faculties
+
+class Logger
+  # Defaults correspond to Logger#new defaults
+  def self.from_file_name(file_name, shift_age = 0, shift_size = 1048576)
+    unless File.exists?(file_name)
+      FileUtils.mkdir_p File.dirname(file_name)
+      FileUtils.touch file_name
+    end
+
+    logger = new(file_name, shift_age, shift_size)
+  end
+
+  def path
+    @logdev.filename
+  end
+end
+
+module SimpleLogging
+  module MessageFormatting
+    refine Logger do
+      def sanitize_all_messages!
+        original_formatter = Logger::Formatter.new
+        @formatter = proc { |severity, datetime, progname, msg|
+          original_formatter.call(severity, datetime, progname, msg.dump)
+        }
+        self
+      end
+      def with_metadata!
+        original_formatter = Logger::Formatter.new
+        @formatter = proc { |severity, datetime, progname, msg|
+          original_formatter.call(severity, datetime, progname, msg)
+        }
+        self
+      end
+    end
+  end
+
+  def logger(stream = STDOUT)
+    @logger ||= Logger.new(stream)
+  end
+  def log_with(logger_, method, variables = nil, msg_type = Logger::Severity::INFO)
+    msg = "#{self.class}: #{method}"
+    msg << ": #{variables.awesome_inspect}" if variables
+    logger_.log(msg_type, msg)
+  end
+  def log(method, variables = nil, msg_type = Logger::Severity::INFO)
+    log_with(logger, method, variables, msg_type)
+  end
+end

data/lib/acpc_table_manager/table_manager.rb

@@ -0,0 +1,260 @@
+require_relative 'dealer'
+require_relative 'match'
+
+require_relative 'simple_logging'
+using SimpleLogging::MessageFormatting
+
+module AcpcTableManager
+  class Null
+    def method_missing(*args, &block) self end
+  end
+  module HandleException
+    protected
+
+    # @param [String] match_id The ID of the match in which the exception occurred.
+    # @param [Exception] e The exception to log.
+    def handle_exception(match_id, e)
+      log(
+        __method__,
+        {
+          match_id: match_id,
+          message: e.message,
+          backtrace: e.backtrace
+        },
+        Logger::Severity::ERROR
+      )
+    end
+  end
+
+  class Maintainer
+    include ParamRetrieval
+    include SimpleLogging
+    include HandleException
+
+    def initialize(logger_)
+      @logger = logger_
+
+      @table_queues = {}
+      enqueue_waiting_matches
+
+      log(__method__)
+    end
+
+    def enqueue_waiting_matches(game_definition_key=nil)
+      if game_definition_key
+        @table_queues[game_definition_key] ||= ::AcpcTableManager::TableQueue.new(game_definition_key)
+        @table_queues[game_definition_key].my_matches.not_running.and.not_started.each do |m|
+          @table_queues[game_definition_key].enqueue! m.id.to_s, m.dealer_options
+        end
+      else
+        ::AcpcTableManager.exhibition_config.games.keys.each do |game_definition_key|
+          enqueue_waiting_matches game_definition_key
+        end
+      end
+    end
+
+    def maintain!
+      log __method__, msg: "Starting maintenance"
+
+      begin
+        enqueue_waiting_matches
+        @table_queues.each { |key, queue| queue.check_queue! }
+        clean_up_matches!
+      rescue => e
+        handle_exception nil, e
+        Rusen.notify e # Send an email notification
+      end
+      log __method__, msg: "Finished maintenance"
+    end
+
+    def kill_match!(match_id)
+      log(__method__, match_id: match_id)
+
+      @table_queues.each do |key, queue|
+        queue.kill_match!(match_id)
+      end
+    end
+
+    def clean_up_matches!
+      ::AcpcTableManager::Match.delete_matches_older_than! 1.day
+    end
+
+    def enqueue_match!(match_id, options)
+      begin
+        m = ::AcpcTableManager::Match.find match_id
+      rescue Mongoid::Errors::DocumentNotFound
+        return kill_match!(match_id)
+      else
+        @table_queues[m.game_definition_key.to_s].enqueue! match_id, options
+      end
+    end
+
+    def start_proxy!(match_id)
+      begin
+        match = ::AcpcTableManager::Match.find match_id
+      rescue Mongoid::Errors::DocumentNotFound
+        return kill_match!(match_id)
+      else
+        @table_queues[match.game_definition_key.to_s].start_proxy match
+      end
+    end
+
+    def play_action!(match_id, action)
+      log __method__, {
+        match_id: match_id,
+        action: action
+      }
+      begin
+        match = ::AcpcTableManager::Match.find match_id
+      rescue Mongoid::Errors::DocumentNotFound
+        log(
+          __method__,
+          {
+            msg: "Request to play in match #{match_id} when no such proxy exists! Killed match.",
+            match_id: match_id,
+            action: action
+          },
+          Logger::Severity::ERROR
+        )
+        return kill_match!(match_id)
+      end
+      unless @table_queues[match.game_definition_key.to_s].running_matches[match_id]
+        log(
+          __method__,
+          {
+            msg: "Request to play in match #{match_id} in seat #{match.seat} when no such proxy exists! Killed match.",
+            match_id: match_id,
+            match_name: match.name,
+            last_updated_at: match.updated_at,
+            running?: match.running?,
+            last_slice_viewed: match.last_slice_viewed,
+            last_slice_present: match.slices.length - 1,
+            action: action
+          },
+          Logger::Severity::ERROR
+        )
+        return kill_match!(match_id)
+      end
+      log __method__, {
+        match_id: match_id,
+        action: action,
+        running?: !@table_queues[match.game_definition_key.to_s].running_matches[match_id].nil?
+      }
+      proxy = @table_queues[match.game_definition_key.to_s].running_matches[match_id][:proxy]
+      if proxy
+        proxy.play! action
+      else
+        log(
+          __method__,
+          {
+            msg: "Request to play in match #{match_id} in seat #{match.seat} when no such proxy exists! Killed match.",
+            match_id: match_id,
+            match_name: match.name,
+            last_updated_at: match.updated_at,
+            running?: match.running?,
+            last_slice_viewed: match.last_slice_viewed,
+            last_slice_present: match.slices.length - 1,
+            action: action
+          },
+          Logger::Severity::ERROR
+        )
+      end
+      kill_match!(match_id) if proxy.nil? || proxy.match_ended?
+    end
+  end
+
+  class TableManager
+    include ParamRetrieval
+    include SimpleLogging
+    include HandleException
+
+    attr_accessor :maintainer
+
+    def initialize
+      @logger = AcpcTableManager.new_log 'table_manager.log'
+      log __method__, "Starting new #{self.class()}"
+      @maintainer = Maintainer.new @logger
+    end
+
+    def maintain!
+      begin
+        @maintainer.maintain!
+      rescue => e
+        log(
+          __method__,
+          {
+            message: e.message,
+            backtrace: e.backtrace
+          },
+          Logger::Severity::ERROR
+        )
+        Rusen.notify e # Send an email notification
+      end
+    end
+
+    def perform!(request, params=nil)
+      match_id = nil
+      begin
+        log(__method__, {request: request, params: params})
+
+        case request
+        # when START_MATCH_REQUEST_CODE
+          # @todo Put bots in erb yaml and have them reread here
+        when ::AcpcTableManager.config.delete_irrelevant_matches_request_code
+          return @maintainer.clean_up_matches!
+        end
+
+        match_id = retrieve_match_id_or_raise_exception params
+
+        log(__method__, {request: request, match_id: match_id})
+
+        do_request!(request, match_id, params)
+      rescue => e
+        handle_exception match_id, e
+        Rusen.notify e # Send an email notification
+      end
+    end
+
+    protected
+
+    def do_request!(request, match_id, params)
+      case request
+      when ::AcpcTableManager.config.start_match_request_code
+        log(__method__, {request: request, match_id: match_id, msg: 'Enqueueing match'})
+
+        @maintainer.enqueue_match!(
+          match_id,
+          retrieve_parameter_or_raise_exception(params, ::AcpcTableManager.config.options_key)
+        )
+      when ::AcpcTableManager.config.start_proxy_request_code
+        log(
+          __method__,
+          request: request,
+          match_id: match_id,
+          msg: 'Starting proxy'
+        )
+
+        @maintainer.start_proxy! match_id
+      when ::AcpcTableManager.config.play_action_request_code
+        log(
+          __method__,
+          request: request,
+          match_id: match_id,
+          msg: 'Taking action'
+        )
+
+        @maintainer.play_action! match_id, retrieve_parameter_or_raise_exception(params, ::AcpcTableManager.config.action_key)
+      when ::AcpcTableManager.config.kill_match
+        log(
+          __method__,
+          request: request,
+          match_id: match_id,
+          msg: "Killing match #{match_id}"
+        )
+        @maintainer.kill_match! match_id
+      else
+        raise StandardError.new("Unrecognized request: #{request}")
+      end
+    end
+  end
+end

data/lib/acpc_table_manager/table_queue.rb

@@ -0,0 +1,379 @@
+require 'acpc_poker_types'
+require 'acpc_dealer'
+require 'timeout'
+
+require_relative 'proxy'
+
+require_relative 'dealer'
+require_relative 'opponents'
+require_relative 'config'
+require_relative 'match'
+
+require_relative 'simple_logging'
+using SimpleLogging::MessageFormatting
+
+require 'contextual_exceptions'
+using ContextualExceptions::ClassRefinement
+
+module AcpcTableManager
+  class TableQueue
+    include SimpleLogging
+
+    attr_reader :running_matches
+
+    exceptions :no_port_for_dealer_available
+
+    def initialize(game_definition_key_)
+      @logger = AcpcTableManager.new_log 'queue.log'
+      @matches_to_start = []
+      @running_matches = {}
+      @game_definition_key = game_definition_key_
+
+      log(
+        __method__,
+        {
+          game_definition_key: @game_definition_key,
+          max_num_matches: AcpcTableManager.exhibition_config.games[@game_definition_key]['max_num_matches']
+        }
+      )
+
+      # Clean up old matches
+      my_matches.running_or_started.each do |m|
+        m.delete
+      end
+    end
+
+    def start_players!(match)
+      opponents = match.bots(AcpcTableManager.config.dealer_host)
+
+      if opponents.empty?
+        kill_match! match.id.to_s
+        raise StandardError.new("No opponents found to start for #{match.id.to_s}! Killed match.")
+      end
+
+      Opponents.start(
+        *opponents.map { |name, info| [info[:runner], info[:host], info[:port]] }
+      )
+      log(__method__, msg: "Opponents started for #{match.id.to_s}")
+
+      start_proxy match
+      self
+    end
+
+    def start_proxy(match)
+      log(__method__, msg: "Starting proxy for #{match.id.to_s}")
+      @running_matches[match.id.to_s][:proxy] = Proxy.start(match)
+    end
+
+    def my_matches
+      Match.where(game_definition_key: @game_definition_key.to_sym)
+    end
+
+    def change_in_number_of_running_matches?
+      prevNumMatchesRunning = @running_matches.length
+      yield if block_given?
+      prevNumMatchesRunning != @running_matches.length
+    end
+
+    def length
+      @matches_to_start.length
+    end
+
+    def ports_in_use
+      @running_matches.values.inject([]) do |ports, m|
+        if m[:dealer] && m[:dealer][:port_numbers]
+          m[:dealer][:port_numbers].each { |n| ports << n.to_i }
+        end
+        ports
+      end
+    end
+
+    def available_special_ports
+      if AcpcTableManager.exhibition_config.special_ports_to_dealer
+        AcpcTableManager.exhibition_config.special_ports_to_dealer - ports_in_use
+      else
+        []
+      end
+    end
+
+    # @return (@see #dequeue!)
+    def enqueue!(match_id, dealer_options)
+      log(
+        __method__,
+        {
+          match_id: match_id,
+          running_matches: @running_matches.map { |r| r.first },
+          game_definition_key: @game_definition_key,
+          max_num_matches: AcpcTableManager.exhibition_config.games[@game_definition_key]['max_num_matches']
+        }
+      )
+
+      if @running_matches[match_id]
+        return log(
+          __method__,
+          msg: "Match #{match_id} already started!"
+        )
+      end
+
+      @matches_to_start << {match_id: match_id, options: dealer_options}
+
+      check_queue!
+    end
+
+    # @return (@see #dequeue!)
+    def check_queue!
+      log __method__
+
+      kill_matches!
+
+      log __method__, {num_running_matches: @running_matches.length, num_matches_to_start: @matches_to_start.length}
+
+      if @running_matches.length < AcpcTableManager.exhibition_config.games[@game_definition_key]['max_num_matches']
+        dequeue!
+      else
+        nil
+      end
+    end
+
+    # @todo Shouldn't be necessary, so this method isn't called right now, but I've written it so I'll leave it for now
+    def fix_running_matches_statuses!
+      log __method__
+      my_matches.running do |m|
+        if !(@running_matches[m.id.to_s] && AcpcDealer::dealer_running?(@running_matches[m.id.to_s][:dealer]))
+          m.is_running = false
+          m.save
+        end
+      end
+    end
+
+    def kill_match!(match_id)
+      return unless match_id
+
+      begin
+        match = Match.find match_id
+      rescue Mongoid::Errors::DocumentNotFound
+      else
+        match.is_running = false
+        match.save!
+      end
+
+      match_info = @running_matches[match_id]
+      if match_info
+        @running_matches.delete(match_id)
+      end
+      @matches_to_start.delete_if { |m| m[:match_id] == match_id }
+
+      kill_dealer!(match_info[:dealer]) if match_info && match_info[:dealer]
+
+      log __method__, match_id: match_id, msg: 'Match successfully killed'
+    end
+
+    def force_kill_match!(match_id)
+      log __method__, match_id: match_id
+      kill_match! match_id
+      ::AcpcTableManager::Match.delete_match! match_id
+      log __method__, match_id: match_id, msg: 'Match successfully deleted'
+    end
+
+    protected
+
+    def kill_dealer!(dealer_info)
+      log(
+        __method__,
+        pid: dealer_info[:pid],
+        was_running?: true,
+        dealer_running?: AcpcDealer::dealer_running?(dealer_info)
+      )
+
+      if AcpcDealer::dealer_running? dealer_info
+        AcpcDealer.kill_process dealer_info[:pid]
+
+        sleep 1 # Give the dealer a chance to exit
+
+        log(
+          __method__,
+          pid: dealer_info[:pid],
+          msg: 'After TERM signal',
+          dealer_still_running?: AcpcDealer::dealer_running?(dealer_info)
+        )
+
+        if AcpcDealer::dealer_running?(dealer_info)
+          AcpcDealer.force_kill_process dealer_info[:pid]
+          sleep 1
+
+          log(
+            __method__,
+            pid: dealer_info[:pid],
+            msg: 'After KILL signal',
+            dealer_still_running?: AcpcDealer::dealer_running?(dealer_info)
+          )
+
+          if AcpcDealer::dealer_running?(dealer_info)
+            raise(
+              StandardError.new(
+                "Dealer process #{dealer_info[:pid]} couldn't be killed!"
+              )
+            )
+          end
+        end
+      end
+    end
+
+    def kill_matches!
+      log __method__
+      running_matches_array = @running_matches.to_a
+      running_matches_array.each_index do |i|
+        match_id, match_info = running_matches_array[i]
+
+        unless (AcpcDealer::dealer_running?(match_info[:dealer]) && Match.id_exists?(match_id))
+          log(
+            __method__,
+            {
+              match_id_being_killed: match_id
+            }
+          )
+
+          kill_match! match_id
+        end
+      end
+      @matches_to_start.delete_if do |m|
+        !Match.id_exists?(m[:match_id])
+      end
+    end
+
+    def match_queued?(match_id)
+      @matches_to_start.any? { |m| m[:match_id] == match_id }
+    end
+
+    def port(available_ports_)
+      port_ = available_ports_.pop
+      while !AcpcDealer::port_available?(port_)
+        if available_ports_.empty?
+          raise NoPortForDealerAvailable.new("None of the special ports (#{available_special_ports}) are open")
+        end
+        port_ = available_ports_.pop
+      end
+      unless port_
+        raise NoPortForDealerAvailable.new("None of the special ports (#{available_special_ports}) are open")
+      end
+      port_
+    end
+
+    # @return [Object] The match that has been started or +nil+ if none could
+    # be started.
+    def dequeue!
+      log(
+        __method__,
+        num_matches_to_start: @matches_to_start.length
+      )
+      return nil if @matches_to_start.empty?
+
+      match_info = nil
+      match_id = nil
+      match = nil
+      loop do
+        match_info = @matches_to_start.shift
+        match_id = match_info[:match_id]
+        begin
+          match = Match.find match_id
+        rescue Mongoid::Errors::DocumentNotFound
+          return self if @matches_to_start.empty?
+        else
+          break
+        end
+      end
+      return self unless match_id
+
+      options = match_info[:options]
+
+      log(
+        __method__,
+        msg: "Starting dealer for match #{match_id}",
+        options: options
+      )
+
+      @running_matches[match_id] ||= {}
+
+      special_port_requirements = match.bot_special_port_requirements
+
+      # Add user's port
+      special_port_requirements.insert(match.seat - 1, false)
+
+      available_ports_ = available_special_ports
+      ports_to_be_used = special_port_requirements.map do |r|
+        if r then port(available_ports_) else 0 end
+      end
+
+      match.is_running = true
+      match.save!
+
+      num_repetitions = 0
+      while @running_matches[match_id][:dealer].nil? do
+        log(
+          __method__,
+          msg: "Added #{match_id} list of running matches",
+          available_special_ports: available_ports_,
+          special_port_requirements: special_port_requirements,
+          :'ports_to_be_used_(zero_for_random)' => ports_to_be_used
+        )
+        begin
+          @running_matches[match_id][:dealer] = Dealer.start(
+            options,
+            match,
+            port_numbers: ports_to_be_used
+          )
+        rescue Timeout::Error => e
+          log(
+            __method__,
+            {warning: "The dealer for match #{match_id} timed out."},
+            Logger::Severity::WARN
+          )
+          begin
+            ports_to_be_used = special_port_requirements.map do |r|
+              if r then port(available_ports_) else 0 end
+            end
+          rescue NoPortForDealerAvailable => e
+            available_ports_ = available_special_ports
+            log(
+              __method__,
+              {warning: "#{ports_to_be_used} ports unavailable, retrying with all special ports, #{available_ports_}."},
+              Logger::Severity::WARN
+            )
+          end
+          if num_repetitions < 1
+            sleep 1
+            log(
+              __method__,
+              {warning: "Retrying with all special ports, #{available_ports_}."},
+              Logger::Severity::WARN
+            )
+            num_repetitions += 1
+          else
+            log(
+              __method__,
+              {warning: "Unable to start match after retry, force killing match."},
+              Logger::Severity::ERROR
+            )
+            force_kill_match! match_id
+            raise e
+          end
+        end
+      end
+
+      begin
+        match = Match.find match_id
+      rescue Mongoid::Errors::DocumentNotFound => e
+        kill_match! match_id
+        raise e
+      end
+
+      log(
+        __method__,
+        msg: "Dealer started for #{match_id} with pid #{@running_matches[match_id][:dealer][:pid]}",
+        ports: match.port_numbers
+      )
+
+      start_players! match
+    end
+  end
+end