acpc_table_manager 2.2.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b376930c2cd6abae33b0d051a193f702875ee8c0
-  data.tar.gz: 57cd5d0c6808245502902a7adafdf0bec0d4ee85
+  metadata.gz: b7ccf8130e5686e105baea868fb25168df10a64b
+  data.tar.gz: 48a25e5be4a4d5fc18b2c4e96044e7f40f5b30d6
 SHA512:
-  metadata.gz: 7d5876d01e63cf3269791e7f1f11a9b3c3d8ebaeedcb85e5247666e321a3f43c5ccf5d66498dc8fc0a14d583e1b78203102d4f1d84f4af75b1939e3748e6a91e
-  data.tar.gz: 8fa1e0feec7a8ec273b7ac93fb55480accd682e27cb8819d885e118bd64a71e3bd078124fa6c90445a71845abb8c688e3956c96a18fdf489f3166b2ab9691f90
+  metadata.gz: 6b26c482c1625469524e338fee40457b0efae1ea24521252f0fa45edf64b7e31bb44939d52b5347fca0812daf608e712bb4c29161d84742e5171b2fb943c9c0c
+  data.tar.gz: c163fbf0a7717da2dc35e389e5892fbb8e7a1d27102b0b9733894ff16584ef181830bf733d9add44e68f0c20feff0d226b19707e5a2c1b7d4468a6b7564be3c7

data/exe/acpc_proxy

@@ -71,6 +71,8 @@ begin
         proxy.play! action
       end
       last_message_received = Time.now
+    elsif !proxy.users_turn_to_act?
+      last_message_received = Time.now
     elsif (
       AcpcTableManager.config.proxy_timeout_s &&
       (
@@ -82,16 +84,11 @@ begin
       # @todo Allow different behaviour on timeout
       proxy.play_check_fold!
     end
-    if proxy.match_ended?
-      AcpcTableManager.redis.rpush(
-        'table-manager',
-        {
-          'request' => AcpcTableManager.config.kill_match,
-          'params' => {
-            AcpcTableManager.config.match_id_key => options[:match_id]
-          }
-        }.to_json
-      )
+    match = AcpcTableManager::Match.find options[:match_id]
+    if proxy.match_ended? or !match.dealer_running?
+      match.proxy_pid = -1
+      match.dealer_pid = -1
+      match.save!
       exit
     end
   end

data/exe/acpc_table_manager

@@ -4,6 +4,7 @@ require 'acpc_table_manager'
 require 'redis'
 require 'json'
 require 'optparse'
+require 'acpc_table_manager/match'
 
 
 ARGV << '-h' if ARGV.empty?
@@ -42,25 +43,17 @@ loop do
       table_manager.log(__method__, {data: data})
 
       case data['request']
-      when AcpcTableManager.config.start_match_request_code
-        table_manager.enqueue_match!(
-          data['params'][AcpcTableManager.config.match_id_key],
-          data['params'][AcpcTableManager.config.options_key]
-        )
+      when AcpcTableManager.config.check_matches
       when AcpcTableManager.config.kill_match
-        table_manager.kill_match! data['params'][AcpcTableManager.config.match_id_key]
+        match = AcpcTableManager::Match.quiet_find data['params'][AcpcTableManager.config.match_id_key]
+        if match then match.kill_proxy! end
       when 'reload'
         AcpcTableManager.load! CONFIG_FILE
-      when AcpcTableManager.config.check_match
-        table_manager.check_match data['params'][AcpcTableManager.config.match_id_key]
-      when AcpcTableManager.config.delete_irrelevant_matches_request_code
-        table_manager.clean_up_matches!
       else
         raise StandardError.new("Unrecognized request: #{data['request']}")
       end
-    else
-      table_manager.maintain!
     end
+    table_manager.maintain!
   rescue => e
     table_manager.log(
       __method__,

data/lib/acpc_table_manager/config.rb

@@ -61,7 +61,7 @@ module AcpcTableManager
           instance_variable_get("@#{constant}".to_sym)
         end
       end
-      unless @special_ports_to_dealer
+      unless special_ports_to_dealer
         @special_ports_to_dealer = []
         log(__method__, {adding: {method: 'special_ports_to_dealer', value: @special_ports_to_dealer}})
         define_singleton_method(:special_ports_to_dealer) do

data/lib/acpc_table_manager/dealer.rb

@@ -15,21 +15,22 @@ module Dealer
 
   # @return [Hash<Symbol, Object>] The dealer information
   # @note Saves the actual port numbers used by the dealer instance in +match+
-  def self.start(options, match, port_numbers: nil)
+  def self.start(match, port_numbers: nil)
     @logger ||= ::AcpcTableManager.new_log 'dealer.log'
-    log __method__, options: options, match: match
+    log __method__, match: match
 
     dealer_arguments = {
-      match_name: Zaru.sanitize!(Shellwords.escape(match.name.gsub(/\s+/, '_'))),
+      match_name: match.sanitized_name,
       game_def_file_name: Shellwords.escape(match.game_definition_file_name),
       hands: Shellwords.escape(match.number_of_hands),
       random_seed: Shellwords.escape(match.random_seed.to_s),
       player_names: match.player_names.map { |name| Shellwords.escape(name.gsub(/\s+/, '_')) }.join(' '),
-      options: (options.split(' ').map { |o| Shellwords.escape o }.join(' ') || '')
+      options: match.dealer_options
     }
 
     log __method__, {
       match_id: match.id,
+      match_name: match.name,
       dealer_arguments: dealer_arguments,
       log_directory: ::AcpcTableManager.config.match_log_directory,
       port_numbers: port_numbers,
@@ -44,11 +45,14 @@ module Dealer
       )
     end
 
-    match.port_numbers = dealer_info[:port_numbers]
+    match.dealer_pid = dealer_info[:pid]
+    match.port_numbers = dealer_info[:port_numbers].map { |e| e.to_i }
     match.save!
 
     log __method__, {
       match_id: match.id,
+      match_name: match.name,
+      dealer_pid: match.dealer_pid,
       saved_port_numbers: match.port_numbers
     }
 

data/lib/acpc_table_manager/maintainer.rb

@@ -1,6 +1,7 @@
 require 'yaml'
 require_relative 'dealer'
 require_relative 'match'
+require_relative 'table_queue'
 
 require_relative 'simple_logging'
 using AcpcTableManager::SimpleLogging::MessageFormatting
@@ -9,239 +10,26 @@ module AcpcTableManager
   class Maintainer
     include SimpleLogging
 
-    def self.proxy_pids(pids_file)
-      if !File.exists?(pids_file)
-        File.open(pids_file, 'w') do |pids_file|
-          yield pids_file, {} if block_given?
-        end
-      else
-        File.open(pids_file, 'r+') do |pids_file|
-          pids = YAML.safe_load(pids_file) || {}
-          pids_file.seek(0, IO::SEEK_SET)
-          pids_file.truncate(0)
-          yield pids_file, pids if block_given?
-        end
-      end
-    end
-
-    def self.kill_process_if_running(pid)
-      begin
-        AcpcDealer::kill_process pid
-        sleep 1 # Give the process a chance to exit
-
-        if AcpcDealer::process_exists?(pid)
-          AcpcDealer::force_kill_process pid
-          sleep 1 # Give the process a chance to exit
-
-          if AcpcDealer::process_exists?(pid)
-            yield if block_given?
-          end
-        end
-      rescue Errno::ESRCH
-      end
-    end
-
-    def self.kill_orphan_proxies(pids, pids_file)
-      new_pids = []
-      pids.each do |pid_pair|
-        proxy_running = AcpcDealer::process_exists?(pid_pair['proxy'])
-        if proxy_running && AcpcDealer::process_exists?(pid_pair['dealer'])
-          new_pids << pid_pair
-        elsif proxy_running
-          kill_process_if_running pid_pair['proxy'] do
-            raise(
-              StandardError.new(
-                "Proxy process #{pid_pair['proxy']} couldn't be killed!"
-              )
-            )
-          end
-        else
-          kill_process_if_running pid_pair['dealer'] do
-            raise(
-              StandardError.new(
-                "Dealer process #{pid_pair['dealer']} couldn't be killed!"
-              )
-            )
-          end
-        end
-      end
-      new_pids
-    end
-
-    def self.update_pids(pids)
-      pids, pids_file = proxy_pids proxy_pids_file do |pids_file, pids|
-        pids = kill_orphan_proxies pids, pids_file
-
-        matches_started = yield if block_given?
-
-        matches_started.each do |info|
-          if info
-            pids << {'dealer' => info[:dealer][:pid], 'proxy' => info[:proxy]}
-          end
-        end
-        pids_file.write(YAML.dump(pids)) unless pids.empty?
-      end
-    end
-
-    def self.proxy_pids_file() ::AcpcTableManager.config.proxy_pids_file end
-
     def initialize(logger_ = AcpcTableManager.new_log('table_manager.log'))
       @logger = logger_
-      @table_queues = {}
-
-      maintain!
-
       log(__method__)
-    end
 
-    def enqueue_waiting_matches(game_definition_key=nil)
-      queues_touched = []
-      if game_definition_key
-        @table_queues[game_definition_key] ||= ::AcpcTableManager::TableQueue.new(game_definition_key)
-        matches_to_check = @table_queues[game_definition_key].my_matches.not_running.and.not_started.to_a
-        matches_to_check.each do |m|
-          unless @table_queues[game_definition_key].running_matches[m.id.to_s]
-            queues_touched << @table_queues[game_definition_key].enqueue!(m.id.to_s, m.dealer_options)
-          end
-        end
-      else
-        ::AcpcTableManager.exhibition_config.games.keys.each do |game_definition_key|
-          queues_touched += enqueue_waiting_matches(game_definition_key)
-        end
+      @table_queues = {}
+      ::AcpcTableManager.exhibition_config.games.keys.each do |game_definition_key|
+        @table_queues[game_definition_key] = ::AcpcTableManager::TableQueue.new(game_definition_key)
       end
-      queues_touched
+      maintain!
     end
 
     def maintain!
       log __method__, msg: "Starting maintenance"
 
-      self.class().update_pids self.class().proxy_pids_file do
-        queues_touched = enqueue_waiting_matches
-        matches_started = []
-        queues_touched.each do |queue|
-          matches_started << queue.check_queue!
-        end
-        matches_started
-      end
-
-      clean_up_matches!
-
-      log __method__, msg: "Finished maintenance"
-    end
-
-    def kill_match!(match_id)
-      log(__method__, match_id: match_id)
-
       @table_queues.each do |key, queue|
-        log(__method__, {queue: key, match_id: match_id})
-
-        queue.kill_match!(match_id)
+        log(__method__, {queue: key})
+        queue.check!
       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
-
-        log(
-          __method__,
-          {
-            msg: "Match not found",
-            match_id: match_id
-          },
-          Logger::Severity::ERROR
-        )
-
-        return kill_match!(match_id)
-      else
-        self.class().update_pids self.class().proxy_pids_file do
-          @table_queues[m.game_definition_key.to_s].enqueue! match_id, options
-          @table_queues[m.game_definition_key.to_s].check_queue!
-        end
-      end
-    end
-
-    def start_proxy!(match_id)
-      begin
-        match = ::AcpcTableManager::Match.find match_id
-      rescue Mongoid::Errors::DocumentNotFound
-
-        log(
-          __method__,
-          {
-            msg: "Match not found",
-            match_id: match_id
-          },
-          Logger::Severity::ERROR
-        )
-
-        return kill_match!(match_id)
-      else
-        self.class().update_pids self.class().proxy_pids_file do
-          [@table_queues[match.game_definition_key.to_s].start_proxy(match)]
-        end
-      end
-    end
-
-    def check_match(match_id)
-      log(__method__, {match_id: match_id})
-      begin
-        match = ::AcpcTableManager::Match.find match_id
-      rescue Mongoid::Errors::DocumentNotFound
-        log(
-          __method__,
-          {
-            msg: "Match \"#{match_id}\" doesn't exist! Killing match.",
-            match_id: match_id
-          },
-          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: "Match \"#{match_id}\" in seat #{match.seat} doesn't have a proxy! Killing 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
-          },
-          Logger::Severity::ERROR
-        )
-        return kill_match!(match_id)
-      end
-      proxy_pid = @table_queues[match.game_definition_key.to_s].running_matches[match_id][:proxy]
-
-      log __method__, {
-        match_id: match_id,
-        running?: proxy_pid && AcpcDealer::process_exists?(proxy_pid)
-      }
-
-      unless proxy_pid && AcpcDealer::process_exists?(proxy_pid)
-        log(
-          __method__,
-          {
-            msg: "The proxy for match \"#{match_id}\" in seat #{match.seat} isn't running! Killing 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
-          },
-          Logger::Severity::ERROR
-        )
-        kill_match!(match_id)
-      end
+      log __method__, msg: "Finished maintenance"
     end
   end
 end

data/lib/acpc_table_manager/match.rb

@@ -1,8 +1,9 @@
-
 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'
@@ -32,34 +33,86 @@ class Match
   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 :with_running_status, ->(is_running) do
-    where(is_running: is_running)
-  end
-  scope :running, -> { with_running_status(true) }
-  scope :not_running, -> { with_running_status(false) }
-  scope :running_or_started, -> { any_of([running.selector, started.selector]) }
+  scope :ready_to_start, -> { where(ready_to_start: true) }
 
   class << self
-    def id_exists?(match_id)
-      where(id: match_id).exists?
+    # @todo Move to AcpcDealer
+    def kill_process_if_running(pid)
+      begin
+        AcpcDealer::kill_process pid
+        sleep 1 # Give the process a chance to exit
+
+        if AcpcDealer::process_exists?(pid)
+          AcpcDealer::force_kill_process pid
+          sleep 1 # Give the process a chance to exit
+
+          if AcpcDealer::process_exists?(pid)
+            yield if block_given?
+          end
+        end
+      rescue Errno::ESRCH
+      end
+    end
+
+    def id_exists?(match_id, matches=all)
+      matches.where(id: match_id).exists?
+    end
+
+    def quiet_find(match_id)
+      begin
+        match = Match.find match_id
+      rescue Mongoid::Errors::DocumentNotFound
+        nil
+      end
     end
 
     # Almost scopes
-    def finished
-      all.select { |match| match.finished? }
+    def running(matches=all)
+      matches.select { |match| match.running? }
+    end
+    def not_running(matches=all)
+      matches.select { |match| !match.running? }
+    end
+    def finished(matches=all)
+      matches.select { |match| match.finished? }
     end
     def unfinished(matches=all)
       matches.select { |match| !match.finished? }
     end
-    def started_and_unfinished()
+    def started_and_unfinished
       started.to_a.select { |match| !match.finished? }
     end
 
+    def ports_in_use(matches=all)
+      running(matches).inject([]) { |ports, m| ports += m.port_numbers }
+    end
+
+    # @return The matches to be started (have not been started and not
+    #   currently running) ordered from newest to oldest.
+    def start_queue(matches=all)
+      not_running(matches.not_started.and.ready_to_start.desc(:updated_at))
+    end
+
+    def kill_all_orphan_processes!(matches=all)
+      matches.each { |m| m.kill_orphan_processes! }
+    end
+
+    def kill_all_orphan_proxies!(matches=all)
+      matches.each { |m| m.kill_orphan_proxy! }
+    end
+
     # Schema
     def include_name
       field :name
@@ -163,7 +216,10 @@ class Match
   field :port_numbers, type: Array
   field :random_seed, type: Integer, default: new_random_seed
   field :last_slice_viewed, type: Integer, default: -1
-  field :is_running, type: Boolean, default: false
+  field :dealer_pid, type: Integer, default: -1
+  field :proxy_pid, type: Integer, default: -1
+  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
@@ -206,6 +262,10 @@ class Match
   end
 
   # Initializers
+  def set_dealer_options!(options)
+    self.dealer_options = (options.split(' ').map { |o| Shellwords.escape o }.join(' ') || '')
+    self
+  end
   def set_name!(name_ = self.name_from_user)
     name_from_user_ = name_.strip
     self.name = name_from_user_
@@ -230,6 +290,7 @@ class Match
     set_name!.set_seat!.set_game_definition_file_name!.set_game_definition_hash!
     self.opponent_names ||= self.class().default_opponent_names(game_info['num_players'])
     self.number_of_hands ||= 1
+    self.ready_to_start = true
     save!
     self
   end
@@ -278,14 +339,14 @@ class Match
   def no_limit?
     @is_no_limit ||= game_def.betting_type == AcpcPokerTypes::GameDefinition::BETTING_TYPES[:nolimit]
   end
-  def started?
-    !self.slices.empty?
-  end
-  def finished?
-    started? && self.slices.last.match_ended?
+  def started?() !self.slices.empty? end
+  def finished?() started? && self.slices.last.match_ended? end
+  def running?() dealer_running? && proxy_running? end
+  def dealer_running?
+    self.dealer_pid >= 0 && AcpcDealer::process_exists?(self.dealer_pid)
   end
-  def running?
-    self.is_running
+  def proxy_running?
+    self.proxy_pid >= 0 && AcpcDealer::process_exists?(self.proxy_pid)
   end
   def all_slices_viewed?
     self.last_slice_viewed >= (self.slices.length - 1)
@@ -346,5 +407,43 @@ class Match
       self.class().where(name: self.name).ne(name_from_user: self.name).map { |m| m.seat }
     )
   end
+  def sanitized_name
+    Zaru.sanitize!(Shellwords.escape(self.name.gsub(/\s+/, '_')))
+  end
+  def kill_dealer!
+    self.class().kill_process_if_running(self.dealer_pid) do
+      raise(
+        StandardError.new(
+          "Dealer process #{self.dealer_pid} couldn't be killed!"
+        )
+      )
+    end
+  end
+
+  def defunkt?()
+    (started? and !running? and !finished?) || self.unable_to_start_dealer
+  end
+
+  def kill_proxy!
+    self.class().kill_process_if_running(self.proxy_pid) do
+      raise(
+        StandardError.new(
+          "Proxy process #{self.proxy_pid} couldn't be killed!"
+        )
+      )
+    end
+  end
+
+  def kill_orphan_proxy!
+    kill_proxy! if proxy_running? && !dealer_running?
+  end
+
+  def kill_orphan_processes!
+    if dealer_running? && !proxy_running?
+      kill_dealer!
+    elsif proxy_running && !dealer_running?
+      kill_proxy!
+    end
+  end
 end
 end

data/lib/acpc_table_manager/match_slice.rb

@@ -7,6 +7,7 @@ require_relative 'config'
 module AcpcTableManager
 class MatchSlice
   include Mongoid::Document
+  include Mongoid::Timestamps::Updated
 
   embedded_in :match, inverse_of: :slices
 

data/lib/acpc_table_manager/opponents.rb

@@ -2,6 +2,7 @@ require 'timeout'
 require 'process_runner'
 require_relative 'config'
 require_relative 'simple_logging'
+require 'fileutils'
 
 module AcpcTableManager
 module Opponents
@@ -10,20 +11,41 @@ module Opponents
   @logger = nil
 
   # @return [Array<Integer>] PIDs of the opponents started
-  def self.start(*bot_start_commands)
+  def self.start(match)
     @logger ||= ::AcpcTableManager.new_log 'opponents.log'
-    log __method__, num_opponents: bot_start_commands.length
+
+    opponents = match.bots(AcpcTableManager.config.dealer_host)
+    log __method__, num_opponents: opponents.length
+
+    if opponents.empty?
+      raise StandardError.new("No opponents found to start for \"#{match.name}\" (#{match.id.to_s})!")
+    end
+
+    opponents_log_dir = File.join(AcpcTableManager.config.log_directory, 'opponents')
+    FileUtils.mkdir(opponents_log_dir) unless File.directory?(opponents_log_dir)
+
+    bot_start_commands = opponents.map do |name, info|
+      {
+        args: [info[:runner], info[:host], info[:port]],
+        log: File.join(opponents_log_dir, "#{match.name}.#{match.id}.#{name}.log")
+      }
+    end
 
     bot_start_commands.map do |bot_start_command|
       log(
         __method__,
         {
-          bot_start_command_parameters: bot_start_command,
-          command_to_be_run: bot_start_command.join(' ')
+          bot_start_command_parameters: bot_start_command[:args],
+          command_to_be_run: bot_start_command[:args].join(' ')
         }
       )
       pid = Timeout::timeout(3) do
-        ProcessRunner.go(bot_start_command)
+        ProcessRunner.go(
+          bot_start_command[:args].map { |e| e.to_s },
+          {
+            [:err, :out] => [bot_start_command[:log], File::CREAT|File::WRONLY]
+          }
+        )
       end
       log(
         __method__,

data/lib/acpc_table_manager/proxy.rb

@@ -26,6 +26,7 @@ class Proxy
 
     proxy = new(
       match.id,
+      match.sanitized_name,
       AcpcDealer::ConnectionInformation.new(
         match.port_numbers[match.seat - 1],
         ::AcpcTableManager.config.dealer_host
@@ -43,12 +44,14 @@ class Proxy
   # @todo Reduce the # of params
   #
   # @param [String] match_id The ID of the match in which this player is participating.
+  # @param [String] match_name The name of the match in which this player is participating.
   # @param [DealerInformation] dealer_information Information about the dealer to which this bot should connect.
   # @param [GameDefinition, #to_s] game_definition A game definition; either a +GameDefinition+ or the name of the file containing a game definition.
   # @param [String] player_names The names of the players in this match.
   # @param [Integer] number_of_hands The number of hands in this match.
   def initialize(
     match_id,
+    match_name,
     dealer_information,
     users_seat,
     game_definition,
@@ -56,7 +59,7 @@ class Proxy
     number_of_hands=1,
     must_send_ready=false
   )
-    @logger = AcpcTableManager.new_log File.join('proxies', "#{match_id}.#{users_seat}.log")
+    @logger = AcpcTableManager.new_log File.join('proxies', "#{match_name}.#{match_id}.#{users_seat}.log")
 
     log __method__, {
       dealer_information: dealer_information,
@@ -87,11 +90,13 @@ class Proxy
   def next_hand!
     log __method__
 
-    @player_proxy.next_hand! do |players_at_the_table|
-      update_database! players_at_the_table
+    if @player_proxy.hand_ended?
+      @player_proxy.next_hand! do |players_at_the_table|
+        update_database! players_at_the_table
 
-      yield players_at_the_table if block_given?
-    end
+        yield players_at_the_table if block_given?
+      end
+     end
 
     log(
       __method__,
@@ -107,27 +112,31 @@ class Proxy
   # Player action interface
   # @see PlayerProxy#play!
   def play!(action, fast_forward = false)
-    log __method__, action: action
+    log __method__, users_turn_to_act?: @player_proxy.users_turn_to_act?, action: action
 
-    action = PokerAction.new(action) unless action.is_a?(PokerAction)
+    if @player_proxy.users_turn_to_act?
+      action = PokerAction.new(action) unless action.is_a?(PokerAction)
 
-    @player_proxy.play! action do |players_at_the_table|
-      update_database! players_at_the_table, fast_forward
+      @player_proxy.play! action do |players_at_the_table|
+        update_database! players_at_the_table, fast_forward
 
-      yield players_at_the_table if block_given?
-    end
+        yield players_at_the_table if block_given?
+      end
 
-    log(
-      __method__,
-      {
-        users_turn_to_act?: @player_proxy.users_turn_to_act?,
-        match_ended?: @player_proxy.match_ended?
-      }
-    )
+      log(
+        __method__,
+        {
+          users_turn_to_act?: @player_proxy.users_turn_to_act?,
+          match_ended?: @player_proxy.match_ended?
+        }
+      )
+    end
 
     self
   end
 
+  def users_turn_to_act?() @player_proxy.users_turn_to_act? end
+
   def play_check_fold!
     log __method__
     if @player_proxy.users_turn_to_act?

data/lib/acpc_table_manager/table_queue.rb

@@ -23,8 +23,6 @@ module AcpcTableManager
 
     def initialize(game_definition_key_)
       @logger = AcpcTableManager.new_log 'queue.log'
-      @matches_to_start = []
-      @running_matches = {}
       @game_definition_key = game_definition_key_
 
       log(
@@ -34,31 +32,17 @@ module AcpcTableManager
           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?
-        force_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]] }
-      )
+      Opponents.start(match)
       log(__method__, msg: "Opponents started for #{match.id.to_s}")
 
-      start_proxy match
+      start_proxy! match
     end
 
-    def start_proxy(match)
-      command = "bundle exec acpc_proxy -t #{AcpcTableManager.config_file} -m #{match.id.to_s}"
+    def start_proxy!(match)
+      command = "#{File.expand_path('../../../exe/acpc_proxy', __FILE__)} -t #{AcpcTableManager.config_file} -m #{match.id.to_s}"
       log(
         __method__,
         {
@@ -67,265 +51,75 @@ module AcpcTableManager
         }
       )
 
-      @running_matches[match.id.to_s][:proxy] = Timeout::timeout(3) do
+      match.proxy_pid = Timeout::timeout(3) do
         pid = Process.spawn(command)
         Process.detach(pid)
         pid
       end
+      match.save!
 
       log(
         __method__,
         {
-          msg: "Started proxy for #{match.id.to_s}",
-          pid: @running_matches[match.id.to_s][:proxy]
+          msg: "Started proxy for \"#{match.name}\" (#{match.id.to_s})",
+          pid: match.proxy_pid
         }
       )
-      @running_matches[match.id.to_s]
+      self
     end
 
+    def matches_to_start() Match.start_queue(my_matches) 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
+      prevNumMatchesRunning = Match.running(my_matches).length
       yield if block_given?
-      prevNumMatchesRunning != @running_matches.length
-    end
-
-    def length
-      @matches_to_start.length
+      prevNumMatchesRunning != Match.running(my_matches).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 length() matches_to_start.length end
 
     def available_special_ports
       if AcpcTableManager.exhibition_config.special_ports_to_dealer
-        AcpcTableManager.exhibition_config.special_ports_to_dealer - ports_in_use
+        AcpcTableManager.exhibition_config.special_ports_to_dealer - Match.ports_in_use
       else
         []
       end
     end
 
-    # @return +self+
-    def enqueue!(match_id, dealer_options)
+    def check!
       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']
+            num_running_matches: Match.running(my_matches).length,
+            num_matches_to_start: matches_to_start.length
         }
       )
 
-      if @running_matches[match_id]
-        log(
-          __method__,
-          msg: "Match #{match_id} already started!"
-        )
-      else
-          @matches_to_start << {match_id: match_id, options: dealer_options}
-      end
-      self
-    end
-
-    # @return [Array] The list of PID information about the matches that were dequeued.
-    def check_queue!
-      log __method__
-
-      kill_matches!
-
-      log __method__, {num_running_matches: @running_matches.length, num_matches_to_start: @matches_to_start.length}
-
       matches_started = []
-      while !@matches_to_start.empty? && @running_matches.length < AcpcTableManager.exhibition_config.games[@game_definition_key]['max_num_matches']
-        matches_started << dequeue
-      end
-
-      log __method__, {matches_started: matches_started, num_running_matches: @running_matches.length, num_matches_to_start: @matches_to_start.length}
-
-      matches_started
-    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 }
-
-      if match_info && match_info[:dealer] && match_info[:proxy].nil? then
-        kill_dealer!(match_info[:dealer])
-      end
-      kill_proxy!(match_info[:proxy]) if match_info && match_info[:proxy]
-
-      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)
+      while (
+        !matches_to_start.empty? &&
+        Match.running(my_matches).length < AcpcTableManager.exhibition_config.games[@game_definition_key]['max_num_matches']
       )
-
-      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
+        matches_started << dequeue
       end
-    end
 
-    def kill_proxy!(proxy_pid)
       log(
         __method__,
-        pid: proxy_pid,
-        was_running?: true,
-        proxy_running?: AcpcDealer::process_exists?(proxy_pid)
+        {
+          matches_started: matches_started,
+          num_running_matches: Match.running(my_matches).length,
+          num_matches_to_start: matches_to_start.length
+        }
       )
 
-      if proxy_pid && AcpcDealer::process_exists?(proxy_pid)
-        AcpcDealer.kill_process proxy_pid
-
-        sleep 1 # Give the proxy a chance to exit
-
-        log(
-          __method__,
-          pid: proxy_pid,
-          msg: 'After TERM signal',
-          proxy_still_running?: AcpcDealer::process_exists?(proxy_pid)
-        )
-
-        if AcpcDealer::process_exists?(proxy_pid)
-          AcpcDealer.force_kill_process proxy_pid
-          sleep 1
-
-          log(
-            __method__,
-            pid: proxy_pid,
-            msg: 'After KILL signal',
-            proxy_still_running?: AcpcDealer::process_exists?(proxy_pid)
-          )
-
-          if AcpcDealer::process_exists?(proxy_pid)
-            raise(
-              StandardError.new(
-                "Proxy process #{proxy_pid} couldn't be killed!"
-              )
-            )
-          end
-        end
-      end
-    end
-
-    def kill_matches!
-      log __method__
-
-      unless AcpcTableManager.config.match_lifespan_s < 0
-        Match.running.and.old(AcpcTableManager.config.match_lifespan_s).each do |m|
-          log(
-            __method__,
-            {
-              old_running_match_id_being_killed: m.id.to_s
-            }
-          )
-
-          kill_match! m.id.to_s
-        end
-      end
-
-      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
+      matches_started
     end
 
-    def match_queued?(match_id)
-      @matches_to_start.any? { |m| m[:match_id] == match_id }
-    end
+    protected
 
     def port(available_ports_)
       port_ = available_ports_.pop
@@ -344,38 +138,21 @@ module AcpcTableManager
     # @return [Object] The match that has been started or +nil+ if none could
     #   be started.
     def dequeue
+      my_matches_to_start = matches_to_start
       log(
         __method__,
-        num_matches_to_start: @matches_to_start.length
+        num_matches_to_start: my_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 nil if @matches_to_start.empty?
-        else
-          break
-        end
-      end
-      return nil unless match_id
+      return nil if my_matches_to_start.empty?
 
-      options = match_info[:options]
+      match = my_matches_to_start.pop
 
       log(
         __method__,
-        msg: "Starting dealer for match #{match_id}",
-        options: options
+        msg: "Starting dealer for match \"#{match.name}\" (#{match.id})",
+        options: match.dealer_options
       )
 
-      @running_matches[match_id] ||= {}
-
       special_port_requirements = match.bot_special_port_requirements
 
       # Add user's port
@@ -386,28 +163,23 @@ module AcpcTableManager
         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
+      dealer_info = nil
+
+      while dealer_info.nil? do
         log(
           __method__,
-          msg: "Added #{match_id} list of running matches",
+          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
-          )
+          dealer_info = Dealer.start(match, port_numbers: ports_to_be_used)
         rescue Timeout::Error => e
           log(
             __method__,
-            {warning: "The dealer for match #{match_id} timed out."},
+            {warning: "The dealer for match \"#{match.name}\" (#{match.id}) timed out."},
             Logger::Severity::WARN
           )
           begin
@@ -433,31 +205,28 @@ module AcpcTableManager
           else
             log(
               __method__,
-              {warning: "Unable to start match after retry, force killing match."},
+              {warning: "Unable to start match after retry, giving up."},
               Logger::Severity::ERROR
             )
-            force_kill_match! match_id
+            match.unable_to_start_dealer = true
+            match.save!
             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]}",
+        msg: "Dealer started for \"#{match.name}\" (#{match.id}) with pid #{match.dealer_pid}",
         ports: match.port_numbers
       )
 
+      match.ready_to_start = false
+      match.save!
+
       start_players! match
 
-      @running_matches[match_id]
+      match.id
     end
   end
 end

data/lib/acpc_table_manager/utils.rb

@@ -22,7 +22,16 @@ module AcpcTableManager
 
   def self.interpolate_all_strings(value, interpolation_hash)
     if value.is_a?(String)
-      value % interpolation_hash
+      # $VERBOSE and $DEBUG change '%''s behaviour
+      _v = $VERBOSE
+      $VERBOSE = false
+      r = begin
+        value % interpolation_hash
+      rescue ArgumentError
+        value
+      end
+      $VERBOSE = _v
+      r
     elsif value.respond_to?(:each)
       each_key_value_pair(value) do |k, v|
         value[k] = interpolate_all_strings(v, interpolation_hash)

data/lib/acpc_table_manager/version.rb

@@ -1,3 +1,3 @@
 module AcpcTableManager
-  VERSION = "2.2.3"
+  VERSION = "3.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acpc_table_manager
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 3.0.0
 platform: ruby
 authors:
 - Dustin Morrill
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-27 00:00:00.000000000 Z
+date: 2016-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pony