goshrine_bot 0.1.0

data/lib/goshrine_bot/faye/server.rb

@@ -0,0 +1,266 @@
+module Faye
+  class Server
+    def initialize(options = {})
+      @options   = options
+      @channels  = Channel::Tree.new
+      @clients   = {}
+      @namespace = Namespace.new
+      @security_policy = options[:security_policy]
+    end
+    
+    # Notifies the server of stale connections that should be deleted
+    def update(message, client)
+      return unless message == :stale_client
+      destroy_client(client)
+    end
+    
+    def client_ids
+      @clients.keys
+    end
+    
+    def process(messages, transport_authentication = nil, local = false, &callback)
+      messages = [messages].flatten
+      processed, responses = 0, []
+      
+      messages.each do |message|
+        handle(message, transport_authentication, local) do |reply|
+          reply = [reply].flatten
+          responses.concat(reply)
+          processed += 1
+          callback[responses] if processed == messages.size
+        end
+      end
+    end
+    
+    def flush_connection(messages)
+      [messages].flatten.each do |message|
+        client = @clients[message['clientId']]
+        client.flush! if client
+      end
+    end
+    
+  private
+    
+    def connection(id)
+      return @clients[id] if @clients.has_key?(id)
+      client = Connection.new(id, @options)
+      client.add_observer(self)
+      @clients[id] = client
+    end
+    
+    def destroy_client(client)
+      client.disconnect!
+      client.delete_observer(self)
+      @namespace.release(client.id)
+      @clients.delete(client.id)
+    end
+    
+    def handle(message, transport_authentication = nil, local = false, &callback)
+      client_id = message['clientId']
+      channel   = message['channel']
+      
+      allowed_to_publish = local || @security_policy.nil? || Channel.meta?(channel) || @security_policy.can_publish(transport_authentication, channel, message)
+      
+      if !allowed_to_publish
+        response =  { 'channel'    => channel,
+                      'version'    => BAYEUX_VERSION,
+                      'id'         => message['id'],
+                      'error'      => Error.channel_forbidden(channel),
+                      'successful' => false }
+        return callback[response]
+      end
+            
+      @channels.glob(channel).each do |c| 
+        c << message 
+      end
+      
+      if Channel.meta?(channel)
+        response = __send__(Channel.parse(channel)[1], message, transport_authentication, local)
+        
+        client_id = response['clientId']
+        response['advice'] ||= {}
+        response['advice']['reconnect'] ||= @clients.has_key?(client_id) ? 'retry' : 'handshake'
+        response['advice']['interval']  ||= (Connection::INTERVAL * 1000).floor
+        
+        return callback[response] unless response['channel'] == Channel::CONNECT and
+                                         response['successful'] == true
+        
+        return connection(response['clientId']).connect(transport_authentication) do |events|
+          callback[[response] + events]
+        end
+      end
+      
+      return callback[[]] if message['clientId'].nil? or Channel.service?(channel)
+      
+      response = make_response(message)
+      response['successful'] = true
+      callback[response]
+    end
+    
+    def make_response(message)
+      response = {}
+      %w[id clientId channel].each do |field|
+        if message[field]
+          response[field] = message[field]
+        end
+      end
+      response
+    end
+    
+    # MUST contain  * version
+    #               * supportedConnectionTypes
+    # MAY contain   * minimumVersion
+    #               * ext
+    #               * id
+    def handshake(message, transport_authentication, local = false)
+      response = make_response(message)
+      response['version'] = BAYEUX_VERSION
+      
+      response['error'] = Error.parameter_missing('version') if message['version'].nil?
+      
+      unless local
+        response['supportedConnectionTypes'] = CONNECTION_TYPES
+        
+        client_conns = message['supportedConnectionTypes']
+
+        # This is a fix for the (non-spec following) cometd.js client
+        client_conns = client_conns.values if client_conns.is_a?(Hash)
+ 
+        if client_conns
+          common_conns = client_conns.select { |c| CONNECTION_TYPES.include?(c) }
+          response['error'] = Error.conntype_mismatch(*client_conns) if common_conns.empty?
+        else
+          response['error'] = Error.parameter_missing('supportedConnectionTypes')
+        end
+      end
+      
+      response['successful'] = response['error'].nil?
+      return response unless response['successful']
+      
+      client_id = @namespace.generate
+      response['clientId'] = connection(client_id).id
+      connection_listener = @options[:connection_listener]
+      if connection_listener
+        connection_listener.connected(client_id, transport_authentication)
+      end
+      response
+    end
+    
+    # MUST contain  * clientId
+    #               * connectionType
+    # MAY contain   * ext
+    #               * id
+    def connect(message, transport_authentication, local = false)
+      response  = make_response(message)
+      
+      client_id = message['clientId']
+      client    = client_id ? @clients[client_id] : nil
+      
+      response['error'] = Error.client_unknown(client_id) if client.nil?
+      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+      response['error'] = Error.parameter_missing('connectionType') if message['connectionType'].nil?
+      
+      response['successful'] = response['error'].nil?
+      response.delete('clientId') unless response['successful']
+      return response unless response['successful']
+      
+      response['clientId'] = client.id
+      response
+    end
+    
+    # MUST contain  * clientId
+    # MAY contain   * ext
+    #               * id
+    def disconnect(message, transport_authentication, local = false)
+      response  = make_response(message)
+      
+      client_id = message['clientId']
+      client    = client_id ? @clients[client_id] : nil
+      
+      response['error'] = Error.client_unknown(client_id) if client.nil?
+      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+      
+      response['successful'] = response['error'].nil?
+      response.delete('clientId') unless response['successful']
+      return response unless response['successful']
+      
+      destroy_client(client)
+      
+      response['clientId'] = client_id
+      response
+    end
+    
+    # MUST contain  * clientId
+    #               * subscription
+    # MAY contain   * ext
+    #               * id
+    def subscribe(message, transport_authentication, local = false)
+      response      = make_response(message)
+      
+      client_id     = message['clientId']
+      client        = client_id ? @clients[client_id] : nil
+      
+      subscription  = message['subscription']
+      subscription  = [subscription].flatten
+      
+      response['error'] = Error.client_unknown(client_id) if client.nil?
+      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+      response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
+        
+      response['subscription'] = subscription.compact
+      
+      subscription.each do |channel|
+        next if response['error']
+        response['error'] = Error.channel_forbidden(channel) unless local or Channel.subscribable?(channel)
+        response['error'] = Error.channel_invalid(channel) unless Channel.valid?(channel)
+        if @security_policy
+          response['error'] = Error.channel_forbidden(channel) unless @security_policy.can_subscribe(transport_authentication, channel, message)
+        end
+        
+        next if response['error']
+        channel = @channels[channel] ||= Channel.new(channel)
+        client.subscribe(channel)
+      end
+      
+      response['successful'] = response['error'].nil?
+      response
+    end
+    
+    # MUST contain  * clientId
+    #               * subscription
+    # MAY contain   * ext
+    #               * id
+    def unsubscribe(message, transport_authentication, local = false)
+      response      = make_response(message)
+      
+      client_id     = message['clientId']
+      client        = client_id ? @clients[client_id] : nil
+      
+      subscription  = message['subscription']
+      subscription  = [subscription].flatten
+      
+      response['error'] = Error.client_unknown(client_id) if client.nil?
+      response['error'] = Error.parameter_missing('clientId') if client_id.nil?
+      response['error'] = Error.parameter_missing('subscription') if message['subscription'].nil?
+      
+      response['subscription'] = subscription.compact
+      
+      subscription.each do |channel|
+        next if response['error']
+        
+        if not Channel.valid?(channel)
+          response['error'] = Error.channel_invalid(channel)
+          next
+        end
+        
+        channel = @channels[channel]
+        client.unsubscribe(channel) if channel
+      end
+      
+      response['successful'] = response['error'].nil?
+      response
+    end
+    
+  end
+end
+

data/lib/goshrine_bot/faye/timeouts.rb

@@ -0,0 +1,21 @@
+module Faye
+  module Timeouts
+    def add_timeout(name, delay, &block)
+      @timeouts ||= {}
+      return if @timeouts.has_key?(name)
+      @timeouts[name] = EventMachine.add_timer(delay) do
+        @timeouts.delete(name)
+        block.call
+      end
+    end
+    
+    def remove_timeout(name)
+      @timeouts ||= {}
+      timeout = @timeouts[name]
+      return if timeout.nil?
+      EventMachine.cancel_timer(timeout)
+      @timeouts.delete(name)
+    end
+  end
+end
+

data/lib/goshrine_bot/faye/transport.rb

@@ -0,0 +1,123 @@
+#require 'em-http'
+require 'json'
+require 'uri'
+
+module Faye
+  
+  class Transport
+    def initialize(client, endpoint, cookie = nil)
+      @client   = client
+      @endpoint = endpoint
+      @cookie = cookie
+    end
+    
+    def connection_type
+      self.class.connection_type
+    end
+    
+    def send(message, &block)
+      if message.is_a?(Hash) and not message.has_key?('id')
+        message['id'] = @client.namespace.generate
+      end
+      
+      request(message) { |responses|
+        if block_given?
+          messages, deliverable = [], true
+          [responses].flatten.each do |response|
+            
+            if message.is_a?(Hash) and response['id'] == message['id']
+              deliverable = false if block.call(response) == false
+            end
+            
+            if response['advice']
+              @client.handle_advice(response['advice'])
+            end
+            
+            if response['data'] and response['channel']
+              messages << response
+            end
+            
+          end
+          
+          @client.deliver_messages(messages) if deliverable
+        end
+      }
+    end
+    
+    @transports = {}
+    
+    class << self
+      attr_accessor :connection_type
+
+      def get(client, connection_types = nil)
+        endpoint = client.endpoint
+        connection_types ||= supported_connection_types
+
+        candidate_class = @transports.find do |type, klass|
+          connection_types.include?(type) and
+          klass.usable?(endpoint)
+        end
+
+        unless candidate_class
+          raise "Could not find a usable connection type for #{ endpoint }"
+        end
+
+        candidate_class.last.new(client, endpoint, client.cookie)
+      end
+      
+      def register(type, klass)
+        @transports[type] = klass
+        klass.connection_type = type
+      end
+      
+      def supported_connection_types
+        @transports.keys
+      end
+    end
+  end
+  
+  class HttpTransport < Transport
+    def self.usable?(endpoint)
+      endpoint.is_a?(String)
+    end
+    
+    def request(message, &block)
+      content = JSON.unparse(message)
+      
+      url = URI.parse(@endpoint)
+      headers = {'Accept' => 'application/json', :host => url.host, :cookie => @cookie}
+      request = GoshrineBot::HttpClient.request(
+        :host => url.host,
+        :port => url.port,
+        :contenttype => 'application/json',
+        :request => url.path,
+        :verb => 'POST',
+        :content => content,
+        :custom_headers => headers)
+      
+      request.callback do |response|
+        begin
+          block.call(JSON.parse(response[:content]))
+        rescue JSON::ParserError => e
+          puts "Bad JSON: #{response[:content].inspect}"
+        end
+      end
+    end
+  end
+  Transport.register 'long-polling', HttpTransport
+  
+  class LocalTransport < Transport
+    def self.usable?(endpoint)
+      endpoint.is_a?(Server)
+    end
+    
+    def request(message, &block)
+      @endpoint.process(message, nil, true) do |response|
+        block.call(response)
+      end
+    end
+  end
+  Transport.register 'in-process', LocalTransport
+  
+end
+

data/lib/goshrine_bot/faye.rb

@@ -0,0 +1,36 @@
+# This is a hacked up (and old) version of jcoglan's excellent Faye library.
+# Hacks include adding cookie support (so we can use the cookies from a rails login),
+# and avoiding use of em-http-request
+
+require 'forwardable'
+require 'observer'
+require 'set'
+require 'rubygems'
+require 'eventmachine'
+
+module Faye
+  VERSION = '0.3.2'
+  
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  
+  BAYEUX_VERSION   = '1.0'
+  ID_LENGTH        = 128
+  JSONP_CALLBACK   = 'jsonpcallback'
+  CONNECTION_TYPES = %w[long-polling callback-polling]
+  
+  %w[ timeouts grammar namespace
+      server channel connection
+      error client transport
+  ].each do |lib|
+    require File.join(ROOT, 'faye', lib)
+  end
+  
+  autoload :RackAdapter, File.join(ROOT, 'faye', 'rack_adapter')
+  
+  def self.random(bitlength = ID_LENGTH)
+    field  = 2 ** bitlength
+    strlen = bitlength / 4
+    ("%0#{strlen}s" % rand(field).to_s(16)).gsub(' ', '0')
+  end
+end
+

data/lib/goshrine_bot/game.rb

@@ -0,0 +1,252 @@
+module GoshrineBot
+  class GameInProgress
+    attr_accessor :state
+    attr_accessor :board_size
+    attr_accessor :proposed_by_id
+    attr_accessor :white_player_id
+    attr_accessor :black_player_id
+    attr_accessor :challenge_id
+    attr_accessor :token
+    attr_accessor :game_id
+    attr_accessor :gtp_client
+    attr_accessor :move_number
+    attr_accessor :turn
+    attr_accessor :komi
+    attr_accessor :moves
+    attr_accessor :handicap
+    attr_accessor :handicap_stones
+    attr_accessor :last_activity
+    
+    def initialize(client)
+      @client = client
+    end
+        
+    def play_message(m)
+      return unless m
+      #puts "Got game play message: #{m.inspect}"
+      case m["action"]
+      when 'user_arrive'
+        user_id = m["id"].to_i
+        puts "User arrived (#{token}): #{m["login"]}"
+        if state == 'new' && (user_id == black_player_id || user_id == white_player_id)
+          http = @client.http_post("/game/#{token}/attempt_start")
+        end
+      when 'game_started'
+        self.state = "in-play"
+        make_move
+      when 'updateBoard'
+        handle_move(m["data"])
+        #puts "Going to update board"
+      when 'resignedBy'
+        puts "Game resigned by #{m["data"]}"
+        stop_gtp_client
+      when 'updateForUndo'
+        # TODO - handle undos?
+        puts "Undo not currently supported"
+      when 'pleaseWait'
+        # ignore
+      when 'user_leave'
+        # ignore
+      when 'gameFinished'
+        stop_gtp_client
+        if m['data'].nil?
+          puts "Missing data: #{m.inspect}"
+          return
+        elsif m['data']['scoring_info'].nil?
+          puts "Missing scoring_info: #{m.inspect}"
+          return
+        end
+        score = m['data']['scoring_info']['score']
+        winner = score['black'] > score['white'] ? 'B' : 'W'
+        if my_color == winner
+          puts "I Won!"
+        else
+          puts "I Lost."
+        end
+        puts "Score: #{score.inspect}"
+      else
+        puts "Unhandled game play message #{m.inspect}"
+      end
+    end
+    
+    def handle_move(m)
+      # {"captures"=>[], "move_number"=>1, "color"=>"b", "move"=>"ir", "black_seconds_left"=>1900, "white_seconds_left"=>1900, "turn_started_at"=>"Sat, 05 Dec 2009 00:44:19 -0600"}
+      pos = m["move"]
+      color = m["color"].upcase
+      if pos && color && color != my_color
+        pos = sgf_coord_to_gtp_coord(pos, board_size)
+        puts "Received move #{pos}"
+        res = gtp_client.play(color, pos)
+        res.callback {
+          self.moves << [color, pos]
+          self.move_number = m["move_number"].to_i
+          self.turn = m["color"] == "b" ? "w" : "b"
+          make_move
+        }
+      end
+    end
+    
+    def idle_check
+      if @last_gtp_access && @last_gtp_access + 60 < Time.now
+        puts "Shutting down gtp client #{self.token} for idle."
+        stop_gtp_client
+      end
+    end
+        
+    def private_message(m)
+      puts "Got private game message: #{m.inspect}"
+      case m["type"]
+      when 'undo_requested'
+        @client.http_post("/game/accept_undo/" + m["request_id"])
+      end
+    end
+    
+    def handle_messages
+      msg = @queue.pop
+      args = msg[1..-1]
+      self.send(msg.first, *args)
+    end
+    
+    def my_turn?
+      @client.my_user_id == players_turn
+    end
+    
+    def started?
+      state != 'new'
+    end
+    
+    def update_from_match_request(attrs)
+      self.state = attrs['state']
+      self.board_size = attrs['board_size'].to_i
+      self.proposed_by_id = attrs['proposed_by_id'].to_i
+      self.white_player_id = attrs['white_player_id'].to_i
+      self.black_player_id = attrs['black_player_id'].to_i
+      self.challenge_id = attrs['id'].to_i
+      self.handicap = attrs['handicap'].to_i
+      self.handicap_stones = attrs['handicap_stones']
+      self.turn = handicap > 1 ? 'w' : 'b'
+      self.move_number = 0
+      self.moves = []
+    end
+    
+    def update_from_game_list(attrs)
+      #puts "attrs = #{attrs.inspect}"
+      self.state = attrs['state']
+      self.token = attrs['token']
+      self.game_id = attrs['id'].to_i
+      self.komi = attrs['komi'].to_f
+      self.white_player_id = attrs['white_player_id'].to_i
+      self.black_player_id = attrs['black_player_id'].to_i
+      self.turn = attrs['turn']
+      self.board_size = attrs['board']['size'].to_i
+      self.move_number = attrs['move_number'].to_i
+      self.handicap = attrs['handicap'].to_i rescue 0
+      self.handicap_stones = attrs['handicap_stones']
+      self.moves = []
+      move_colors = ["B", "W"]
+      handicap_offset = self.handicap > 0 ? 1 : 0
+      if attrs['moves']
+        attrs['moves'].each_with_index do |m,idx|
+          self.moves << [move_colors[(idx+handicap_offset) % 2], sgf_coord_to_gtp_coord(m, board_size)]
+        end
+      end
+      
+      if state == 'new'
+        http = @client.http_post("/game/#{token}/attempt_start")
+      end
+      
+    end
+    
+    def my_color
+      @client.my_user_id == white_player_id ? "W" : "B"
+    end
+    
+    def opponents_color
+      @client.my_user_id == white_player_id ? "B" : "W"
+    end
+    
+    def make_move
+      return unless started? && my_turn?
+      
+      res = gtp_client.genmove(turn)
+      res.callback { |response_move|
+        puts "Generated move: #{response_move} (#{token})"
+        self.move_number += 1
+        if response_move.upcase == 'PASS'
+          http = @client.http_post("/game/#{token}/pass")
+        elsif response_move.upcase == 'RESIGN'
+          http = @client.http_post("/game/#{token}/resign")
+        else
+          rgo_coord = gtp_coord_to_goshrine_coord(response_move.upcase, board_size)
+          http = @client.http_post("/game/#{token}/move/#{rgo_coord}")
+        end
+        http.callback {|response|
+          if response[:status] == 200
+            self.moves << [my_color, response_move]
+          else
+            puts "Could not make move: #{response.inspect}"
+          end
+        }
+      }
+    end    
+    
+    def start_engine
+      gtp = GtpStdioClient.new(@client.gtp_cmd_line, "gtp_#{token}.log")
+      gtp.boardsize(@board_size)
+      gtp.clear_board
+      #if @handicap > 1
+      #  gtp.fixed_handicap(@handicap)
+      #end
+      @handicap_stones.each do |s|
+        puts "Placing handicap stone at #{s}"
+        gtp.play('B', sgf_coord_to_gtp_coord(s, board_size))
+      end
+      if @moves
+        @moves.each do |m|
+          #puts "Going to play #{m.first}, #{m.last}"
+          gtp.play(m.first, m.last)
+        end
+      end
+      gtp
+    end
+    
+    def gtp_client
+      @last_gtp_access = Time.now
+      @gtp_client ||= start_engine
+    end
+    
+    def stop_gtp_client
+      @gtp_client.close if @gtp_client
+      @gtp_client = nil
+      @last_gtp_access = nil
+    end
+        
+    def players_turn
+      self.turn == 'b' ? black_player_id : white_player_id
+    end
+    
+    def sgf_coord_to_gtp_coord(value, board_size)
+      return 'pass' if value.downcase == 'pass'
+      x = value[0].ord - 97
+      y = value[1].ord - 97
+      x += 1 if x >= 8
+      [x+65].pack('c') + (board_size - y).to_s
+    end
+    
+    def goshrine_coord_to_gtp_coord(value, board_size)
+      x = value[0].ord - 97
+      y = value[1].ord - 97
+      x += 1 if x >= 8
+      [x+65].pack('c') + (board_size - y).to_s
+    end
+
+    def gtp_coord_to_goshrine_coord(value, board_size)
+      x = value[0].ord - 65
+      x -= 1 if x >= 8
+      y = board_size - (value[1..-1].to_i)
+      [x+97, y+97].pack('cc')
+    end
+    
+    
+  end
+end