goshrine_bot 0.1.0

data/README.rdoc

@@ -0,0 +1,56 @@
+= GoShrine Bot Client
+
+* http://goshrine.com
+* http://github.com/ps2/goshrine_bot
+
+The GoShrine bot client is a library that allows you connect a local Go playing program that speaks GTP (like gnugo) to goshrine.com
+
+The GTP protocol is documented here: http://www.lysator.liu.se/~gunnar/gtp/
+
+== INSTALL:
+
+* gem install goshrine_bot
+
+== USE:
+
+* Create a normal account on goshrine for your bot.
+* Email feedback@goshrine.com with the account name, and request that it be changed to a bot account.
+* Edit goshrine_bot.yml with your account info.
+* Create a database.yml file in the following format:
+
+botname:
+  :login: yourbotlogin
+  :password: yourbotpassword
+  :gtp_cmd_line: gnugo --mode gtp --level 1
+
+* Run goshrine_bot botname
+
+== REQUIREMENTS:
+
+* json
+* eventmachine
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Pete Schwamb
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+# Available options:
+#
+# rake test - Runs all test cases.
+# rake package - Runs test cases and builds packages for distribution.
+# rake rdoc - Builds API documentation in doc dir.
+
+require 'rake'
+require 'rspec/core/rake_task'
+require 'rake/gempackagetask'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |rspec|
+  #rspec.ruby_opts="-w"
+end
+
+load(File.join(File.dirname(__FILE__), "goshrine_bot.gemspec"))
+
+Rake::GemPackageTask.new(SPEC) do |package|
+  # do nothing: I just need a gem but this block is required
+end
+

data/TODO.txt

@@ -0,0 +1,2 @@
+
+* Shutdown idle engines (to be restarted later) to save on resources.

data/bin/goshrine_bot

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'goshrine_bot')
+EventMachine.run {
+  EM.error_handler{ |e|
+    puts  "Error raised during event loop: #{e.message} " + e.backtrace.join("\n")
+  }
+  GoshrineBot::Runner.run
+}
+

data/goshrine_bot.gemspec

@@ -0,0 +1,33 @@
+DIR = File.dirname(__FILE__)
+LIB = File.join(DIR, *%w[lib goshrine_bot.rb])
+VERSION = open(LIB) { |lib|
+  lib.each { |line|
+    if v = line[/^\s*VERSION\s*=\s*(['"])(\d\.\d\.\d)\1/, 2]
+      break v
+    end
+  }
+}
+
+SPEC = Gem::Specification.new do |s|
+  s.name = "goshrine_bot"
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Pete Schwamb"]
+  s.email = ["pete@schwamb.net"]
+  s.homepage = "http://github.com/ps2/goshrine_bot"
+  s.summary = "A client to connect GTP go programs to GoShrine"
+  s.description = <<-END_DESCRIPTION.gsub(/\s+/, " ").strip
+  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.
+  END_DESCRIPTION
+
+  s.required_rubygems_version = "~> 1.9.2"
+  s.required_rubygems_version = "~> 1.3.6"
+
+  s.add_development_dependency "rspec"
+
+  s.executables = ['goshrine_bot']
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec/*_spec.rb`.split("\n")
+  s.require_paths = %w[lib]
+end

data/goshrine_bot.yml

@@ -0,0 +1,5 @@
+botname:
+  :login: yourbotlogin
+  :password: yourbotpass
+  :gtp_cmd_line: gnugo --mode gtp --level 1
+

data/lib/goshrine_bot/client.rb

@@ -0,0 +1,180 @@
+
+module GoshrineBot
+
+  class Client
+
+    class << self
+    end
+
+    def initialize(options)
+      @base_url = URI::parse(options[:server_url])
+      @options = options
+      @password = options[:password]
+      @login = options[:login]
+      @gtp_cmd_line = options[:gtp_cmd_line]
+      @connected = false
+      @cookie = ""
+      @games = {}
+    end
+    
+    def gtp_cmd_line
+      @gtp_cmd_line
+    end
+    
+    def my_user_id
+      @my_user_id
+    end
+    
+    def parse_cookie(headers)
+      cookies = []
+      headers.each do |h|
+        if h.match(/^Set-Cookie: /)
+          pieces = h[12..-1].split("=")
+          cookies << "#{pieces[0]}=#{pieces[1].split(";").first}";
+        end
+      end
+      @cookie = cookies.join("; ") + ';'
+    end
+
+    def login(&blk)
+      # login
+      http = http_post('/sessions/create', {'login' => @login, 'password' => @password})
+      http.callback {|response|
+        #puts "login returned: #{response[:status]}"
+        if response[:status].to_i == 401
+          puts "Invalid Login or Password"
+          EventMachine::stop
+        else
+          parse_cookie(response[:headers])
+          user = JSON.parse(response[:content])
+          @queue_id = user['queue_id']
+          @my_user_id = user['id']
+          if user['user_type'] != 'bot'
+            puts "Account #{user['login']} is not registered as a robot!"
+            EventMachine::stop
+          else
+            puts "Login successful"
+            blk.call
+          end
+        end
+      }
+      http.errback {|response|
+        puts "Login failed (network issue?)";
+      }
+    end
+    
+    def http_post(url, data = nil)
+      headers = {'Accept' => 'application/json', :cookie => @cookie}
+      if data.is_a? Hash
+        data = data.to_params        
+        contenttype = "application/x-www-form-urlencoded"
+      else
+        contenttype = "application/octet-stream"
+      end
+      #puts "Posting #{data}"
+      GoshrineBot::HttpClient.request(
+        :host => @base_url.host,
+        :port => @base_url.port,
+        :contenttype => contenttype,
+        :request => url,
+        :verb => 'POST',
+        :content => data,
+        :custom_headers => headers)
+    end
+
+    def http_get(url)
+      headers = {'Accept' => 'application/json', :cookie => @cookie}
+      GoshrineBot::HttpClient.request(
+        :host => @base_url.host,
+        :port => @base_url.port,
+        :request => url,
+        :custom_headers => headers)
+    end
+    
+    def subscribe
+      @client.subscribe("/user/private/" + @queue_id) do |m|
+        msg_type = m["type"]
+        case msg_type
+        when 'match_requested'
+          handle_match_request(m["match_request"])
+        when 'match_accepted'
+          handle_match_accept(m["game_token"])
+        else
+          puts "Unsupported private message type: #{msg_type}"
+        end
+        #@msg_queue_in.push(doc)
+      end
+      @client.subscribe("/room/1") do |m|
+        #@msg_queue_in.push(doc)
+      end
+    end
+
+    def run
+      login {
+        @client = Faye::Client.new((@base_url + '/events').to_s, :timeout => 120, :cookie => @cookie)
+        subscribe          
+        load_existing_games {
+          EM::add_periodic_timer( 60 ) {
+            @games.each do |token, game|
+              game.idle_check
+            end
+          }
+        }
+      }
+    end
+
+    def load_existing_games(&blk)
+      http = http_get('/game/active')
+      http.callback {|response|
+        #puts "Got #{response.inspect}"
+        parse_cookie(response[:headers])
+        games = JSON.parse(response[:content])
+        puts "#{games.count} game(s) in progress"
+        games.each do |game_attrs|
+          game = GameInProgress.new(self)
+          game.update_from_game_list(game_attrs)
+          if game.move_number != game.moves.size
+            puts "Only #{game.moves.size} available! Expected #{game.move_number} in game #{game.token}"
+          else
+            add_game(game)
+          end
+        end
+        blk.call
+      }
+    end
+    
+    def add_game(game)
+      @games[game.game_id] = game
+      game.make_move # does nothing if its not our turn, or the game is not started
+      @client.subscribe("/game/private/" + game.token + '/' + @queue_id) do |m|
+        game.private_message(m)
+      end
+      @client.subscribe("/game/play/" + game.token) do |m|
+        game.play_message(m)
+      end
+    end
+
+    def handle_match_accept(token)
+      game = GameInProgress.new(self)
+      http = http_get("/g/#{token}")
+      http.callback {|response|
+        attrs = JSON.parse(response[:content])
+        game.update_from_game_list(attrs)
+        add_game(game)
+      }      
+    end
+    
+    def handle_match_request(request)
+      game = GameInProgress.new(self)
+      game.update_from_match_request(request)
+      http = http_get("/match/accept?id=#{game.challenge_id}")
+      http.callback {|response|
+        attrs = JSON.parse(response[:content])
+        game.update_from_game_list(attrs)
+        add_game(game)
+      }
+    end
+    
+  end
+end
+

data/lib/goshrine_bot/core_ext/hash.rb

@@ -0,0 +1,53 @@
+class Hash
+  # Stolen partially from Merb : http://noobkit.com/show/ruby/gems/development/merb/hash/to_params.html
+  # Convert this hash to a query string:
+  #   
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
+  #   #=> "name=Bob&address[city]=Ruby Central&address[phones]=111-111-1111222-222-2222&address[street]=111 Ruby Ave."
+  # 
+  def to_params
+    params = ''
+    stack = []
+    
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      elsif v.is_a?(Array)
+        stack << [k,Hash.from_array(v)]
+      else
+        params << "#{k}=#{v}&"
+      end
+    end
+    
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          params << "#{parent}[#{k}]=#{v}&"
+        end
+      end
+    end
+    
+    params.chop! # trailing &
+    params
+  end
+  
+  ##
+  # Builds a hash from an array with keys as array indices.
+  def self.from_array(array = [])
+    h = Hash.new
+    array.size.times do |t|
+      h[t] = array[t]
+    end
+    h
+  end
+
+end
+

data/lib/goshrine_bot/faye/channel.rb

@@ -0,0 +1,143 @@
+module Faye
+  class Channel
+    
+    include Observable
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def <<(message)
+      changed(true)
+      notify_observers(:message, message)
+    end
+    
+    HANDSHAKE   = '/meta/handshake'
+    CONNECT     = '/meta/connect'
+    SUBSCRIBE   = '/meta/subscribe'
+    UNSUBSCRIBE = '/meta/unsubscribe'
+    DISCONNECT  = '/meta/disconnect'
+    
+    META        = :meta
+    SERVICE     = :service
+    
+    class << self
+      def valid?(name)
+        Grammar::CHANNEL_NAME =~ name or
+        Grammar::CHANNEL_PATTERN =~ name
+      end
+      
+      def parse(name)
+        return nil unless valid?(name)
+        name.split('/')[1..-1].map { |s| s.to_sym }
+      end
+      
+      def meta?(name)
+        segments = parse(name)
+        segments ? (segments.first == META) : nil
+      end
+      
+      def service?(name)
+        segments = parse(name)
+        segments ? (segments.first == SERVICE) : nil
+      end
+      
+      def subscribable?(name)
+        return nil unless valid?(name)
+        not meta?(name) and not service?(name)
+      end
+    end
+    
+    class Tree
+      include Enumerable
+      attr_accessor :value
+      
+      def initialize(value = nil)
+        @value = value
+        @children = {}
+      end
+      
+      # Remove channels that have no subscribers
+      def delete_unobserved_channels
+        total_observers = 0
+        if @value
+          total_observers += @value.count_observers
+          @value = nil if @value.count_observers == 0
+        end
+        
+        @children.delete_if { |key, subtree|
+          num_child_observers = subtree.delete_unobserved_channels
+          total_observers += num_child_observers
+          num_child_observers == 0
+        }
+        total_observers
+      end
+      
+      def each_child
+        @children.each { |key, subtree| yield(key, subtree) }
+      end
+      
+      def each(prefix = [], &block)
+        each_child { |path, subtree| subtree.each(prefix + [path], &block) }
+        yield(prefix, @value) unless @value.nil?
+      end
+      
+      def keys
+        map { |key, value| '/' + key * '/' }
+      end
+      
+      def [](name)
+        subtree = traverse(name)
+        subtree ? subtree.value : nil
+      end
+      
+      def []=(name, value)
+        subtree = traverse(name, true)
+        subtree.value = value unless subtree.nil?
+      end
+      
+      def traverse(path, create_if_absent = false)
+        path = Channel.parse(path) if String === path
+        
+        return nil if path.nil?
+        return self if path.empty?
+        
+        subtree = @children[path.first]
+        return nil if subtree.nil? and not create_if_absent
+        subtree = @children[path.first] = self.class.new if subtree.nil?
+        
+        subtree.traverse(path[1..-1], create_if_absent)
+      end
+      
+      def glob(path = [])
+        path = Channel.parse(path) if String === path
+        
+        return [] if path.nil?
+        return @value.nil? ? [] : [@value] if path.empty?
+        
+        if path == [:*]
+          return @children.inject([]) do |list, (key, subtree)|
+            list << subtree.value unless subtree.value.nil?
+            list
+          end
+        end
+        
+        if path == [:**]
+          list = map { |key, value| value }
+          list.pop unless @value.nil?
+          return list
+        end
+        
+        list = @children.values_at(path.first, :*).
+                         compact.
+                         map { |t| t.glob(path[1..-1]) }
+        
+        list << @children[:**].value if @children[:**]
+        list.flatten
+      end
+    end
+    
+  end
+end
+