acpc_table_manager 3.0.18 → 4.0.0

data/lib/acpc_table_manager/config.rb

@@ -1,11 +1,6 @@
 require 'socket'
 require 'json'
-require 'mongoid'
-require 'moped'
-require 'rusen'
-require 'contextual_exceptions'
-require 'acpc_dealer'
-require 'redis'
+require 'fileutils'
 
 require_relative 'simple_logging'
 using AcpcTableManager::SimpleLogging::MessageFormatting
@@ -24,9 +19,21 @@ module AcpcTableManager
     THIS_MACHINE = Socket.gethostname
     DEALER_HOST = THIS_MACHINE
 
-    attr_reader :file, :log_directory, :my_log_directory, :match_log_directory, :proxy_pids_file
+    attr_reader(
+      :file,
+      :log_directory,
+      :my_log_directory,
+      :match_log_directory,
+      :data_directory
+    )
 
-    def initialize(file_path, log_directory_, match_log_directory_, proxy_pids_file_, interpolation_hash)
+    def initialize(
+        file_path,
+        log_directory_,
+        match_log_directory_,
+        data_directory_,
+        interpolation_hash
+    )
       @file = file_path
       JSON.parse(File.read(file_path)).each do |constant, val|
         define_singleton_method(constant.to_sym) do
@@ -36,8 +43,9 @@ module AcpcTableManager
       @log_directory = log_directory_
       @match_log_directory = match_log_directory_
       @my_log_directory = File.join(@log_directory, 'acpc_table_manager')
-      @proxy_pids_file = proxy_pids_file_
-      @logger = Logger.from_file_name(File.join(@my_log_directory, 'config.log'))
+      @logger = Logger.from_file_name(File.join(@my_log_directory, 'table_manager.log'))
+      @data_directory = data_directory_
+      FileUtils.mkdir_p @data_directory unless File.directory?(@data_directory)
     end
 
     def this_machine() THIS_MACHINE end
@@ -49,7 +57,11 @@ module AcpcTableManager
 
     attr_reader :file
 
-    def initialize(file_path, interpolation_hash, logger = Logger.new(STDOUT))
+    def initialize(
+      file_path,
+      interpolation_hash,
+      logger = Logger.new(STDOUT)
+    )
       @logger = logger
       @file = file_path
       JSON.parse(File.read(file_path)).each do |constant, val|
@@ -81,141 +93,19 @@ module AcpcTableManager
             bot_map
           end
         else
-          log(__method__, {warning: "Game '#{game_def_key}' has no opponents."}, Logger::Severity::WARN)
+          log(
+            __method__, {warning: "Game '#{game_def_key}' has no opponents."},
+            Logger::Severity::WARN
+          )
           {}
         end
       else
-        log(__method__, {warning: "Unrecognized game, '#{game_def_key}'."}, Logger::Severity::WARN)
+        log(
+          __method__, {warning: "Unrecognized game, '#{game_def_key}'."},
+          Logger::Severity::WARN
+        )
         {}
       end
     end
   end
-
-  class UninitializedError < StandardError
-    include ContextualExceptions::ContextualError
-  end
-
-  def self.raise_uninitialized
-    raise UninitializedError.new(
-      "Unable to complete with AcpcTableManager uninitialized. Please initialize AcpcTableManager with configuration settings by calling AcpcTableManager.load! with a (YAML) configuration file name."
-    )
-  end
-
-  @@config = nil
-
-  def self.config
-    if @@config
-      @@config
-    else
-      raise_uninitialized
-    end
-  end
-
-  @@exhibition_config = nil
-  def self.exhibition_config
-    if @@exhibition_config
-      @@exhibition_config
-    else
-      raise_uninitialized
-    end
-  end
-
-  @@is_initialized = false
-
-  @@redis_config_file = nil
-  def self.redis_config_file() @@redis_config_file end
-
-  @@redis = nil
-  def self.redis() @@redis end
-
-  @@config_file = nil
-  def self.config_file() @@config_file end
-
-  @@notifier = nil
-  def self.notifier() @@notifier end
-
-  def self.load_config!(config_data, yaml_directory = File.pwd)
-    interpolation_hash = {
-      pwd: yaml_directory,
-      home: Dir.home,
-      :~ => Dir.home,
-      dealer_directory: AcpcDealer::DEALER_DIRECTORY
-    }
-    config = interpolate_all_strings(config_data, interpolation_hash)
-
-    @@config = Config.new(
-      config['table_manager_constants'],
-      config['log_directory'],
-      config['match_log_directory'],
-      config['proxy_pids_file'],
-      interpolation_hash
-    )
-    @@exhibition_config = ExhibitionConfig.new(
-      config['exhibition_constants'],
-      interpolation_hash,
-      Logger.from_file_name(File.join(@@config.my_log_directory, 'exhibition_config.log'))
-    )
-
-    # Moped.logger = Logger.from_file_name(File.join(@@config.log_directory, 'moped.log'))
-    # Mongoid.logger = Logger.from_file_name(File.join(@@config.log_directory, 'mongoid.log'))
-    # TODO: These should be set in configuration files
-    Moped.logger.level = ::Logger::FATAL
-    Mongoid.logger.level = ::Logger::FATAL
-    Mongoid.load!(config['mongoid_config'], config['mongoid_env'].to_sym)
-
-    if config['error_report']
-      Rusen.settings.sender_address = config['error_report']['sender']
-      Rusen.settings.exception_recipients = config['error_report']['recipients']
-
-      Rusen.settings.outputs = config['error_report']['outputs'] || [:pony]
-      Rusen.settings.sections = config['error_report']['sections'] || [:backtrace]
-      Rusen.settings.email_prefix = config['error_report']['email_prefix'] || '[ERROR] '
-      Rusen.settings.smtp_settings = config['error_report']['smtp']
-
-      @@notifier = Rusen
-    else
-      @@config.log(__method__, {warning: "Email reporting disabled. Please set email configuration to enable this feature."}, Logger::Severity::WARN)
-    end
-
-    if config['redis_config_file']
-      @@redis_config_file = config['redis_config_file']
-      redis_config = YAML.load_file(@@redis_config_file).symbolize_keys
-      dflt = redis_config[:default].symbolize_keys
-      @@redis = Redis.new(
-        if config['redis_environment_mode'] && redis_config[config['redis_environment_mode'].to_sym]
-          dflt.merge(redis_config[config['redis_environment_mode'].to_sym].symbolize_keys)
-        else
-          dflt
-        end
-      )
-    end
-
-    @@is_initialized = true
-  end
-
-  def self.load!(config_file_path)
-    @@config_file = config_file_path
-    load_config! YAML.load_file(config_file_path), File.dirname(config_file_path)
-  end
-
-  def self.notify(exception)
-    @@notifier.notify(exception) if @@notifier
-  end
-
-  def self.initialized?
-    @@is_initialized
-  end
-
-  def self.raise_if_uninitialized
-    raise_uninitialized unless initialized?
-  end
-
-  def self.new_log(log_file_name)
-    raise_if_uninitialized
-    Logger.from_file_name(File.join(@@config.my_log_directory, log_file_name)).with_metadata!
-  end
-
-  def self.unload!
-    @@is_initialized = false
-  end
 end

data/lib/acpc_table_manager/match.rb

@@ -1,71 +1,45 @@
-require 'mongoid'
 require 'zaru'
 
 require 'acpc_poker_types/game_definition'
 require 'acpc_poker_types/match_state'
 require 'acpc_dealer'
-
-require_relative 'match_slice'
 require_relative 'config'
 
-module AcpcTableManager
-module TimeRefinement
-  refine Time.class() do
-    def now_as_string
-      now.strftime('%b%-d_%Y-at-%-H_%-M_%-S')
-    end
-  end
-end
-end
-using AcpcTableManager::TimeRefinement
-
 module AcpcTableManager
 class Match
-  include Mongoid::Document
-  include Mongoid::Timestamps::Updated
-
-  embeds_many :slices, class_name: "AcpcTableManager::MatchSlice"
-
   # Scopes
-  scope :old, ->(lifespan) do
-    where(:updated_at.lt => (Time.new - lifespan))
-  end
-  scope :inactive, ->(lifespan) do
-    started.and.old(lifespan)
-  end
-  scope :active_between, ->(lifespan, reference_time=Time.now) do
-    started.and.where(
-      { 'slices.updated_at' => { '$gt' => (reference_time - lifespan)}}
-    ).and.where(
-      { 'slices.updated_at' => { '$lt' => reference_time}}
-    )
-  end
-  scope :with_slices, ->(has_slices) do
-    where({ 'slices.0' => { '$exists' => has_slices }})
-  end
-  scope :started, -> { with_slices(true) }
-  scope :not_started, -> { with_slices(false) }
-  scope :ready_to_start, -> { where(ready_to_start: true) }
-  scope(
-    :possibly_running,
-    where(:proxy_pid.gt => 0).and.where(:dealer_pid.gt => 0)
-  )
-  # @return The matches to be started (have not been started and not
-  #   currently running) ordered from newest to oldest.
-  scope :queue, not_started.and.ready_to_start.desc(:updated_at)
-
-  index({ game_definition_key: 1 })
-  index({ proxy_pid: 1, dealer_pid: 1 })
-  index({ user_name: 1 })
+  # scope :old, ->(lifespan) do
+  #   where(:updated_at.lt => (Time.new - lifespan))
+  # end
+  # scope :inactive, ->(lifespan) do
+  #   started.and.old(lifespan)
+  # end
+  # scope :active_between, ->(lifespan, reference_time=Time.now) do
+  #   started.and.where(
+  #     { 'slices.updated_at' => { '$gt' => (reference_time - lifespan)}}
+  #   ).and.where(
+  #     { 'slices.updated_at' => { '$lt' => reference_time}}
+  #   )
+  # end
+  # scope :with_slices, ->(has_slices) do
+  #   where({ 'slices.0' => { '$exists' => has_slices }})
+  # end
+  # scope :started, -> { with_slices(true) }
+  # scope :not_started, -> { with_slices(false) }
+  # scope :ready_to_start, -> { where(ready_to_start: true) }
+  # scope(
+  #   :possibly_running,
+  #   where(:proxy_pid.gt => 0).and.where(:dealer_pid.gt => 0)
+  # )
+  # # @return The matches to be started (have not been started and not
+  # #   currently running) ordered from newest to oldest.
+  # scope :queue, not_started.and.ready_to_start.desc(:updated_at)
+  #
+  # index({ game_definition_key: 1 })
+  # index({ proxy_pid: 1, dealer_pid: 1 })
+  # index({ user_name: 1 })
 
   class << self
-    # @todo Move to AcpcDealer
-    def safe_kill(pid)
-      if pid && pid > 0
-        AcpcDealer::kill_process pid
-        sleep 1 # Give the process a chance to exit
-      end
-    end
     def kill_process_if_running(pid)
       if pid && pid > 0
         begin
@@ -229,29 +203,28 @@ class Match
   end
 
   # Schema
-  field :port_numbers, type: Array
-  field :random_seed, type: Integer, default: new_random_seed
-  field :last_slice_viewed, type: Integer, default: -1
-  field :dealer_pid, type: Integer, default: nil
-  field :proxy_pid, type: Integer, default: nil
-  field :ready_to_start, type: Boolean, default: false
-  field :unable_to_start_dealer, type: Boolean, default: false
-  field :dealer_options, type: String, default: (
-    [
-      '-a', # Append logs with the same name rather than overwrite
-      "--t_response 80000", # 80 seconds per action
-      '--t_hand -1',
-      '--t_per_hand -1'
-    ].join(' ')
-  )
-  include_name
-  include_name_from_user
-  include_user_name
-  include_game_definition
-  include_number_of_hands
-  include_opponent_names
-  include_seat
-
+  # field :port_numbers, type: Array
+  # field :random_seed, type: Integer, default: new_random_seed
+  # field :last_slice_viewed, type: Integer, default: -1
+  # field :dealer_pid, type: Integer, default: nil
+  # field :proxy_pid, type: Integer, default: nil
+  # field :ready_to_start, type: Boolean, default: false
+  # field :unable_to_start_dealer, type: Boolean, default: false
+  # field :dealer_options, type: String, default: (
+  #   [
+  #     '-a', # Append logs with the same name rather than overwrite
+  #     "--t_response 80000", # 80 seconds per action
+  #     '--t_hand -1',
+  #     '--t_per_hand -1'
+  #   ].join(' ')
+  # )
+  # include_name
+  # include_name_from_user
+  # include_user_name
+  # include_game_definition
+  # include_number_of_hands
+  # include_opponent_names
+  # include_seat
 
   def bots(dealer_host)
     bot_info_from_config_that_match_opponents = ::AcpcTableManager.exhibition_config.bots(game_definition_key, *opponent_names)

data/lib/acpc_table_manager/proxy_utils.rb

@@ -0,0 +1,290 @@
+require 'json'
+require 'acpc_poker_types'
+include AcpcPokerTypes
+require 'acpc_poker_player_proxy'
+include AcpcPokerPlayerProxy
+require 'acpc_dealer'
+include AcpcDealer
+
+module AcpcTableManager
+  module ProxyUtils
+    def exit_and_del_saved
+      @communicator.del_saved
+      exit
+    end
+
+    def start_proxy(
+      game_info,
+      seat,
+      port,
+      must_send_ready = false
+    )
+      game_definition = GameDefinition.parse_file(game_info['file'])
+
+      PlayerProxy.new(
+        ConnectionInformation.new(
+          port,
+          AcpcTableManager.config.dealer_host
+        ),
+        game_definition,
+        seat,
+        must_send_ready
+      ) do |patt|
+        if patt.match_state
+          log __method__, msg: 'Sending match state'
+          @communicator.publish(
+            ProxyUtils.players_at_the_table_to_json(
+              patt,
+              game_info['num_hands_per_match'],
+              @state_index
+            )
+          )
+          @state_index += 1
+        else
+          log __method__, msg: 'Before first match state'
+        end
+      end
+    end
+
+    def play_check_fold!(proxy)
+      log __method__
+      if proxy.users_turn_to_act?
+        action = if (
+          proxy.legal_actions.any? do |a|
+            a == AcpcPokerTypes::PokerAction::FOLD
+          end
+        )
+          AcpcPokerTypes::PokerAction::FOLD
+        else
+          AcpcPokerTypes::PokerAction::CALL
+        end
+        proxy.play!(action) do |patt|
+          log __method__, msg: 'Sending match state'
+          @communicator.publish to_json(patt)
+        end
+      end
+    end
+
+    def self.chip_contributions_in_previous_rounds(player, round)
+      if round > 0
+        player['chip_contributions'][0..round-1].inject(:+)
+      else
+        0
+      end
+    end
+
+    def self.opponents(players, users_seat)
+      opp = players.dup.rotate(users_seat)
+      opp.delete_at(users_seat)
+      opp
+    end
+
+    # Over round
+    def self.pot_fraction_wager_to_over_round(proxy, fraction=1)
+      return 0 if proxy.hand_ended?
+
+      [
+        [
+          (
+            (fraction * pot_after_call(proxy.match_state, proxy.game_def)) +
+            chip_contribution_after_calling(proxy.match_state, proxy.game_def)
+          ),
+          minimum_wager_to
+        ].max,
+        all_in
+      ].min.floor
+    end
+
+    def self.players_at_the_table_to_json(
+      patt,
+      max_num_hands_per_match,
+      state_index = 0
+    )
+      players_ = players(patt)
+      {
+        status: {
+          hand_has_ended: patt.hand_ended?,
+          match_has_ended: (
+            if patt.match_state.stack_sizes
+              patt.match_ended?
+            else
+              patt.match_ended?(max_num_hands_per_match)
+            end
+          ),
+          hand_index: patt.match_state.hand_number,
+          state_index: state_index
+        },
+        legal_actions: patt.legal_actions.map do |action|
+          {type: action.to_s, cost: action.cost}
+        end,
+        table: {
+          board_cards: (
+            patt.match_state.community_cards.flatten.map do |c|
+              {rank: c.rank.to_s, suit: c.suit.to_s}
+            end
+          ),
+          pot_chips: pot_at_start_of_round(patt.match_state, patt.game_def).to_i,
+          user: players_[patt.seat],
+          opponents: opponents(players_, patt.seat)
+        }
+      }.to_json
+    end
+
+    def self.betting_sequence(match_state, game_def)
+      sequence = ''
+      match_state.betting_sequence(game_def).each_with_index do |actions_per_round, round|
+        actions_per_round.each_with_index do |action, action_index|
+          adjusted_action = adjust_action_amount(
+            action,
+            round,
+            match_state,
+            game_def
+          )
+
+          sequence << if (
+            match_state.player_acting_sequence(game_def)[round][action_index].to_i ==
+            match_state.position_relative_to_dealer
+          )
+            adjusted_action.capitalize
+          else
+            adjusted_action
+          end
+        end
+        sequence << '/' unless round == match_state.betting_sequence(game_def).length - 1
+      end
+      sequence
+    end
+
+    def self.pot_at_start_of_round(match_state, game_def)
+      return 0 if match_state.round == 0
+
+      match_state.players(game_def).inject(0) do |sum, pl|
+        sum += pl.contributions[0..match_state.round - 1].inject(:+)
+      end
+    end
+
+    # @return [Array<Hash>] Player information ordered by seat.
+    # Each player hash should contain
+    # values for the following keys:
+    # 'seat'
+    # 'chip-stack-amount'
+    # 'contributions'
+    # 'chip-balance-amount'
+    # 'hole-cards'
+    # 'winnings'
+    # 'dealer'
+    # 'acting'
+    def self.players(patt)
+      patt.players.map do |player|
+        hole_cards = if player.folded?
+          []
+        elsif player.hand.empty?
+          [{}] * patt.game_def.number_of_hole_cards
+        else
+          player.hand.map do |c|
+            {rank: c.rank.to_acpc, suit: c.suit.to_acpc}
+          end
+        end
+
+        {
+          seat: player.seat.to_i,
+          chipStackAmount: player.stack.to_i,
+          contribution: (
+            if player.contributions.length <= patt.match_state.round
+              0
+            else
+              player.contributions.last.to_i
+            end
+          ),
+          contributionFromPreviousRounds: (
+            patt.match_state.round.times.inject(0) do |s, i|
+              s += player.contributions[i].to_i
+            end
+          ),
+          chipBalanceAmount: player.balance,
+          holeCards: hole_cards,
+          winnings: player.winnings.to_f,
+          dealer: player.seat == patt.dealer_player.seat.to_i,
+          acting: (
+            patt.next_player_to_act && (
+              player.seat == patt.next_player_to_act.seat
+            )
+          )
+        }
+      end
+    end
+
+    # Over round
+    def self.minimum_wager_to(state, game_def)
+      return 0 unless state.next_to_act(game_def)
+
+      min_wager = [
+        (
+          state.min_wager_by(game_def) +
+          chip_contribution_after_calling(state, game_def)
+        ).ceil,
+        state.players(game_def)[state.next_to_act(game_def)].stack
+      ].min
+      if chip_contribution_after_calling(state, game_def) < state.players(game_def)[state.next_to_act(game_def)].stack
+        min_wager
+      else
+        nil
+      end
+    end
+
+    # Over round
+    def self.chip_contribution_after_calling(state, game_def)
+      return 0 unless state.next_to_act(game_def)
+
+      (
+        (
+          state.players(game_def)[
+            state.next_to_act(game_def)
+          ].contributions[state.round] || 0
+        ) + amount_to_call(state, game_def)
+      )
+    end
+
+    # Over round
+    def self.pot_after_call(state, game_def)
+      return state.pot(game_def) if state.hand_ended?(game_def)
+
+      state.pot(game_def) + state.players(game_def).amount_to_call(state.next_to_act(game_def))
+    end
+
+    # Over round
+    def self.all_in(state, game_def)
+      return 0 if state.hand_ended?(game_def)
+
+      (
+        state.players(game_def)[state.next_to_act(game_def)].stack +
+        (
+          state.players(game_def)[state.next_to_act(game_def)]
+            .contributions[state.round] || 0
+        )
+      ).floor
+    end
+
+    def self.amount_to_call(state, game_def)
+      return 0 if state.next_to_act(game_def).nil?
+
+      state.players(game_def).amount_to_call(state.next_to_act(game_def))
+    end
+
+    private
+
+    def self.adjust_action_amount(action, round, match_state, game_def)
+      amount_to_over_hand = action.modifier
+      if amount_to_over_hand.nil? || amount_to_over_hand.strip.empty?
+        action
+      else
+        amount_to_over_round = (
+          amount_to_over_hand.to_i - match_state.players(game_def)[
+            match_state.position_relative_to_dealer
+          ].contributions_before(round).to_i
+        )
+        "#{action[0]}#{amount_to_over_round}"
+      end
+    end
+  end
+end