goshrine_bot 0.1.0

data/lib/goshrine_bot/gtp_stdio_client.rb

@@ -0,0 +1,130 @@
+# Provides a command line GTP interface
+require 'timeout'
+
+module GoshrineBot
+  module GtpProcess
+    def post_init
+      @command_id = 0
+      @results = Queue.new
+      @cmd_queue = Queue.new
+      @data = ""
+    end
+    
+    def logfile=(logfile)
+      @logfile = logfile
+    end
+    
+    def log(str)
+      File.open(@logfile, "a") do |f|
+        f.write "#{Time.now} - #{str}\n"
+      end
+    end
+
+    def send(command)
+      @command_id += 1
+      # if we're waiting on results, don't send data just yet; queue it.
+      if @results.size > 0
+        @cmd_queue.enq command
+      else
+        log "O: #{command.inspect}"
+        send_data("#{command}\n")
+      end
+      res = EM::DefaultDeferrable.new
+      @results.enq res
+      res
+    end
+    
+    def receive_data(data)
+      log "I: #{data.inspect}"
+      @data += data
+      while (match_data = @data.match(/^([?=])(\d+)?\s(.*?)\n\n/m))      
+        @data = @data[match_data[0].size..-1]
+
+        res = @results.deq
+        status = match_data[1]
+        if status == '?'
+          res.fail(match_data[3])
+        else
+          res.succeed(match_data[3])
+        end
+        if @cmd_queue.size > 0
+          command = @cmd_queue.deq
+          log "O: #{command.inspect}"
+          send_data("#{command}\n")
+        end
+      end
+    end
+    
+    def unbind
+      log "gtp process exited with status: #{get_status.exitstatus.inspect}"
+    end
+  end
+  
+  class GtpStdioClient
+    attr_accessor :command_id
+    attr_accessor :boardsize
+    attr_accessor :command_line
+  
+    def initialize(command_line, logfile="gtp.log")
+      @command_line = command_line
+      puts "Opening #{command_line.inspect}"
+      @gtp = EM.popen(@command_line, GtpProcess, "args!")
+      @gtp.logfile = logfile
+      @logfile = logfile
+      log "Starting #{command_line.inspect}"
+    end
+
+    def log(str)
+      File.open(@logfile, "a") do |f|
+        f.write "#{Time.now} - #{str}\n"
+      end
+    end
+  
+    def close
+      log "Closing #{command_line.inspect}"
+      @gtp.close_connection
+    end
+  
+    def kill
+      log "Kill #{command_line.inspect}"
+      Process.kill 'TERM', @gtp.get_pid
+    end
+  
+    def boardsize(size)
+      @boardsize = size
+      send("boardsize #{size}")
+    end
+  
+    def play(color, move)
+      #puts "Going to play #{color} #{move}"
+      send("play #{color} #{move}")
+    end
+
+    def final_status_list(t)
+      Timeout::timeout(10) do
+        res = send("final_status_list #{t}")
+        res.split.map {|c| Position.create(@boardsize, c)}
+      end
+    end
+  
+    def method_missing(methodname, *args)
+      args = args.map {|a| a.to_s}.join(" ")
+      send("#{methodname.to_s} #{args}")
+    end
+  
+    private
+
+    def gtp_color(rgo_color)
+      if rgo_color == 'b'
+        "black"
+      elsif rgo_color == "w"
+        "white"
+      end
+    end
+  
+    def send(command)
+      @gtp.send(command)
+    end
+  end  
+end
+

data/lib/goshrine_bot/httpclient.rb

@@ -0,0 +1,288 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 July 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+
+module GoshrineBot
+
+    # === Usage
+    #
+    #  EventMachine.run {
+    #    http = EventMachine::Protocols::HttpClient.request(
+    #      :host => server,
+    #      :port => 80,
+    #      :request => "/index.html",
+    #      :query_string => "parm1=value1&parm2=value2"
+    #    )
+    #    http.callback {|response|
+    #      puts response[:status]
+    #      puts response[:headers]
+    #      puts response[:content]
+    #    }
+    #  }
+    #--
+    # TODO:
+    # Add streaming so we can support enormous POSTs. Current max is 20meg.
+    # Timeout for connections that run too long or hang somewhere in the middle.
+    # Persistent connections (HTTP/1.1), may need a associated delegate object.
+    # DNS: Some way to cache DNS lookups for hostnames we connect to. Ruby's
+    # DNS lookups are unbelievably slow.
+    # HEAD requests.
+    # Chunked transfer encoding.
+    # Convenience methods for requests. get, post, url, etc.
+    # SSL.
+    # Handle status codes like 304, 100, etc.
+    # Refactor this code so that protocol errors all get handled one way (an exception?),
+    # instead of sprinkling set_deferred_status :failed calls everywhere.
+    class HttpClient < EventMachine::Connection
+      include EventMachine::Deferrable
+
+      MaxPostContentLength = 20 * 1024 * 1024
+
+      # === Arg list
+      # :host => 'ip/dns', :port => fixnum, :verb => 'GET', :request => 'path',
+      # :basic_auth => {:username => '', :password => ''}, :content => 'content',
+      # :contenttype => 'text/plain', :query_string => '', :host_header => '',
+      # :cookie => ''
+      def self.request( args = {} )
+        args[:port] ||= 80
+        EventMachine.connect( args[:host], args[:port], self ) {|c|
+          # According to the docs, we will get here AFTER post_init is called.
+          c.instance_eval {@args = args}
+        }
+      end
+
+      def post_init
+        @start_time = Time.now
+        @data = ""
+        @read_state = :base
+      end
+
+      # We send the request when we get a connection.
+      # AND, we set an instance variable to indicate we passed through here.
+      # That allows #unbind to know whether there was a successful connection.
+      # NB: This naive technique won't work when we have to support multiple
+      # requests on a single connection.
+      def connection_completed
+        @connected = true
+        send_request @args
+      end
+
+      def send_request args
+        args[:verb] ||= args[:method] # Support :method as an alternative to :verb.
+        args[:verb] ||= :get # IS THIS A GOOD IDEA, to default to GET if nothing was specified?
+
+        verb = args[:verb].to_s.upcase
+        unless ["GET", "POST", "PUT", "DELETE", "HEAD"].include?(verb)
+          set_deferred_status :failed, {:status => 0} # TODO, not signalling the error type
+          return # NOTE THE EARLY RETURN, we're not sending any data.
+        end
+
+        request = args[:request] || "/"
+        unless request[0,1] == "/"
+          request = "/" + request
+        end
+
+        qs = args[:query_string] || ""
+        if qs.length > 0 and qs[0,1] != '?'
+          qs = "?" + qs
+        end
+
+        version = args[:version] || "1.1"
+
+        # Allow an override for the host header if it's not the connect-string.
+        host = args[:host_header] || args[:host] || "_"
+        # For now, ALWAYS tuck in the port string, although we may want to omit it if it's the default.
+        port = args[:port]
+
+        # POST items.
+        postcontenttype = args[:contenttype] || "application/octet-stream"
+        postcontent = args[:content] || ""
+        raise "oversized content in HTTP POST" if postcontent.length > MaxPostContentLength
+
+        # ESSENTIAL for the request's line-endings to be CRLF, not LF. Some servers misbehave otherwise.
+        # TODO: We ASSUME the caller wants to send a 1.1 request. May not be a good assumption.
+        req = [
+          "#{verb} #{request}#{qs} HTTP/#{version}",
+          "Host: #{host}:#{port}",
+          "User-agent: Ruby EventMachine",
+        ]
+
+          if verb == "POST" || verb == "PUT"
+            req << "Content-type: #{postcontenttype}"
+            req << "Content-length: #{postcontent.length}"
+          end
+
+          # TODO, this cookie handler assumes it's getting a single, semicolon-delimited string.
+          # Eventually we will want to deal intelligently with arrays and hashes.
+          if args[:cookie]
+            req << "Cookie: #{args[:cookie]}"
+          end
+          
+          # Allow custom HTTP headers, e.g. SOAPAction
+          args[:custom_headers].each do |k,v|
+            req << "#{k}: #{v}"
+          end
+
+          # Basic-auth stanza contributed by Matt Murphy.
+          if args[:basic_auth]
+            basic_auth_string = ["#{args[:basic_auth][:username]}:#{args[:basic_auth][:password]}"].pack('m').strip.gsub(/\n/,'')
+            req << "Authorization: Basic #{basic_auth_string}"
+          end
+
+          req << ""
+          reqstring = req.map {|l| "#{l}\r\n"}.join
+          send_data reqstring
+
+          if verb == "POST" || verb == "PUT"
+            send_data postcontent
+          end
+      end
+
+
+      def receive_data data
+        while data and data.length > 0
+          case @read_state
+          when :base
+            # Perform any per-request initialization here and don't consume any data.
+            @data = ""
+            @headers = []
+            @content_length = nil # not zero
+            @content = ""
+            @status = nil
+            @read_state = :header
+            @connection_close = nil
+          when :header
+            ary = data.split( /\r?\n/m, 2 )
+            if ary.length == 2
+              data = ary.last
+              if ary.first == ""
+                if (@content_length and @content_length > 0) || @chunked || @connection_close
+                  @read_state = :content
+                else
+                  dispatch_response
+                  @read_state = :base
+                end
+              else
+                @headers << ary.first
+                if @headers.length == 1
+                  parse_response_line
+                elsif ary.first =~ /\Acontent-length:\s*/i
+                  # Only take the FIRST content-length header that appears,
+                  # which we can distinguish because @content_length is nil.
+                  # TODO, it's actually a fatal error if there is more than one
+                  # content-length header, because the caller is presumptively
+                  # a bad guy. (There is an exploit that depends on multiple
+                  # content-length headers.)
+                  @content_length ||= $'.to_i
+                elsif ary.first =~ /\Aconnection:\s*close/i
+                  @connection_close = true
+                elsif ary.first =~ /\Atransfer-encoding:\s*chunked/i
+                  @chunked = true
+                end
+              end
+            else
+              @data << data
+              data = ""
+            end
+          when :content
+            if @chunked && @chunk_length
+              bytes_needed = @chunk_length - @chunk_read
+              new_data = data[0, bytes_needed]
+              @chunk_read += new_data.length
+              @content += new_data
+              data = data[bytes_needed..-1] || ""
+              if @chunk_length == @chunk_read && data[0,2] == "\r\n"
+                @chunk_length = nil
+                data = data[2..-1]
+              end
+            elsif @chunked
+              if (m = data.match(/\A(\S*)\r\n/m))
+                data = data[m[0].length..-1]
+                @chunk_length = m[1].to_i(16)
+                @chunk_read = 0
+                if @chunk_length == 0
+                  dispatch_response
+                  @read_state = :base
+                end
+              end
+            elsif @content_length
+              # If there was no content-length header, we have to wait until the connection
+              # closes. Everything we get until that point is content.
+              # TODO: Must impose a content-size limit, and also must implement chunking.
+              # Also, must support either temporary files for large content, or calling
+              # a content-consumer block supplied by the user.
+              bytes_needed = @content_length - @content.length
+              @content += data[0, bytes_needed]
+              data = data[bytes_needed..-1] || ""
+              if @content_length == @content.length
+                dispatch_response
+                @read_state = :base
+              end
+            else
+              @content << data
+              data = ""
+            end
+          end
+        end
+      end
+
+
+      # We get called here when we have received an HTTP response line.
+      # It's an opportunity to throw an exception or trigger other exceptional
+      # handling.
+      def parse_response_line
+        if @headers.first =~ /\AHTTP\/1\.[01] ([\d]{3})/
+          @status = $1.to_i
+        else
+          set_deferred_status :failed, {
+            :status => 0 # crappy way of signifying an unrecognized response. TODO, find a better way to do this.
+          }
+          close_connection
+        end
+      end
+      private :parse_response_line
+
+      def dispatch_response
+        @read_state = :base
+        set_deferred_status :succeeded, {
+          :content => @content,
+          :headers => @headers,
+          :status => @status
+        }
+        # TODO, we close the connection for now, but this is wrong for persistent clients.
+        close_connection
+      end
+
+      def unbind
+        if !@connected
+          set_deferred_status :failed, {:status => 0} # YECCCCH. Find a better way to signal no-connect/network error.
+        elsif (@read_state == :content and @content_length == nil)
+          dispatch_response
+        end
+      end
+    end
+
+end

data/lib/goshrine_bot/runner.rb

@@ -0,0 +1,91 @@
+require 'optparse'
+require 'yaml'
+require 'erb'
+
+module GoshrineBot
+  class Runner
+    attr_accessor :options
+    
+    class << self
+      def run
+        self.new
+      end
+    end
+    
+    def initialize
+      # defaults
+      self.options = {
+        :server_url => "http://goshrine.com/",
+        :gtp_cmd_line => "gnugo --mode gtp",
+        :debug => false,
+        :pid_path => "./goshrine_bot.pid",
+        :log_path => "./goshrine_bot.log",
+      }
+      
+      cmd_line_options = parse_options
+      
+      if !File.exists?(config_path)
+        puts "You must generate a config file."
+        exit
+      end
+      
+      config = YAML::load(ERB.new(IO.read(config_path)).result)
+      #puts "config = #{config.inspect}"
+      bot_name = ARGV[0] || config.keys.first
+      #puts "bot_name = #{ARGV[0]}"
+      if config[bot_name].nil?
+        puts "No config found for #{bot_name.inspect}"
+        exit
+      end
+      options.merge!(config[bot_name])
+      #puts "Options = #{options.inspect}"
+      options[:bot_name] = bot_name
+      
+      start
+    end
+    
+    def config_path
+      options[:config_path] || "./goshrine_bot.yml"
+    end
+    
+    def start
+      puts "Starting GoShrine bot client: #{options[:bot_name]}."
+      
+      client = Client.new(options)
+      client.run      
+    end
+    
+    def parse_options
+      OptionParser.new do |opts|
+        opts.summary_width = 25
+        opts.banner = "GoShrineBot (1.0)\n\n",
+                      "Usage: goshrine_bot [-c configfile] [bot_name]\n",
+                      "       goshrine_bot --help\n"
+        
+        opts.separator ""
+        opts.separator ""; opts.separator "Configuration:"
+        
+        opts.on("-c", "--config FILE", String, "Path to configuration file.", "(default: #{options[:config_path]})") do |v|
+          options[:config_path] = File.expand_path(v)
+        end
+        
+        opts.separator ""; opts.separator "Miscellaneous:"
+        
+        opts.on_tail("-?", "--help", "Display this usage information.") do
+          puts "#{opts}\n"
+          exit
+        end
+        
+      end.parse!
+      options
+    end
+    
+    private
+    
+    def store_pid(pid)
+      FileUtils.mkdir_p(File.dirname(pid_path))
+      File.open(pid_path, 'w'){|f| f.write("#{pid}\n")}
+    end
+    
+  end
+end

data/lib/goshrine_bot.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'json'
+require 'eventmachine'
+
+module GoshrineBot
+
+  VERSION = "0.1.0"
+
+  STDOUT.sync = true
+  
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  
+  %w[ client
+      gtp_stdio_client
+      runner
+      game
+      core_ext/hash
+      faye
+      httpclient
+      
+  ].each do |lib|
+    require File.join(ROOT, 'goshrine_bot', lib)
+  end
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: goshrine_bot
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Pete Schwamb
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-22 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: The GoShrine bot client is a library that allows you connect a local Go playing program that speaks GTP (like gnugo) to http://goshrine.com.
+email: 
+- pete@schwamb.net
+executables: 
+- goshrine_bot
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- TODO.txt
+- bin/goshrine_bot
+- goshrine_bot.gemspec
+- goshrine_bot.yml
+- lib/goshrine_bot.rb
+- lib/goshrine_bot/client.rb
+- lib/goshrine_bot/core_ext/hash.rb
+- lib/goshrine_bot/faye.rb
+- lib/goshrine_bot/faye/channel.rb
+- lib/goshrine_bot/faye/client.rb
+- lib/goshrine_bot/faye/connection.rb
+- lib/goshrine_bot/faye/error.rb
+- lib/goshrine_bot/faye/grammar.rb
+- lib/goshrine_bot/faye/namespace.rb
+- lib/goshrine_bot/faye/rack_adapter.rb
+- lib/goshrine_bot/faye/server.rb
+- lib/goshrine_bot/faye/timeouts.rb
+- lib/goshrine_bot/faye/transport.rb
+- lib/goshrine_bot/game.rb
+- lib/goshrine_bot/gtp_stdio_client.rb
+- lib/goshrine_bot/httpclient.rb
+- lib/goshrine_bot/runner.rb
+has_rdoc: true
+homepage: http://github.com/ps2/goshrine_bot
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A client to connect GTP go programs to GoShrine
+test_files: []
+