gamespy_query 0.1.0 → 0.1.1

data/lib/gamespy_query/base.rb

@@ -1,5 +1,4 @@
 #require 'six/tools'
-require 'action_controller'
 require 'logger'
 
 module GamespyQuery
@@ -12,12 +11,29 @@ module GamespyQuery
 
   module Tools
     STR_EMPTY = ""
+    CHAR_N = "\n"
   
     module_function
     def logger
-      @logger ||= ActionController::Base.logger || Logger.new("logger.log")
+      @logger ||= if defined?(::Tools); ::Tools.logger; else; defined?(ActionController) ? ActionController::Base.logger || Logger.new("logger.log") : Logger.new("logger.log"); end
     end
-  
+
+    def dbg_msg(e)
+      "#{e.class}: #{e.message if e.respond_to?(:backtrace)}
+BackTrace: #{e.backtrace.join(CHAR_N) unless !e.respond_to?(:backtrace) || e.backtrace.nil?}"
+    end
+
+
+    def log_exception(e, as_error = true, msg = "")
+      if defined?(::Tools)
+        ::Tools.log_exception(e, as_error, msg)
+      else
+        puts "Error: #{e.class} #{e.message}, #{e.backtrace.join("\n")}"
+        logger.error "#{"#{msg}:" unless msg.empty?}#{e.class} #{e.message}" if as_error
+        logger.debug dbg_msg(e)
+      end
+    end
+
     def debug(&block)
       return unless DEBUG
       logger.debug yield
@@ -59,7 +75,7 @@ module GamespyQuery
     end
 
     def get_string(*params)
-      puts "Getting string #{params}"
+      Tools.debug {"Getting string #{params}"}
       _get_string(*params)
     end
 
@@ -67,14 +83,14 @@ module GamespyQuery
       include System::Net
       include System::Net::Sockets
 
-      def _get_string(str)
-        str.map {|e| e.chr}.join  #  begin; System::Text::Encoding.USASCII.GetString(reply[0]).to_s; rescue nil, Exception => e; Tools.log_exception(e); reply[0].map {|e| e.chr}.join; end
+      def get_string(str)
+        System::Text::Encoding.UTF8.GetString(System::Array.of(System::Byte).new(str.bytes.to_a)).to_s # #  begin; System::Text::Encoding.USASCII.GetString(reply[0]).to_s; rescue nil, Exception => e; Tools.log_exception(e); reply[0].map {|e| e.chr}.join; end
       end
     else
       require 'socket'
       require 'timeout'
-
-      def _get_string(str)
+      def get_string(str)
+        #(str + '  ').encode("UTF-8", :invalid => :replace, :undef => :replace)[0..-2]
         str
       end
     end

data/lib/gamespy_query/master.rb

@@ -5,7 +5,7 @@ module GamespyQuery
     PARAMS = [:hostname, :gamever, :gametype, :gamemode, :numplayers, :maxplayers, :password, :equalModRequired, :mission, :mapname,
               :mod, :signatures, :verifysignatures, :gamestate, :dedicated, :platform, :sv_battleeye, :language, :difficulty]
 
-    # TODO: Gspy v3 multipacket
+    RX_ADDR_LINE = /([\d\.]+)[\s\t]*(\d+)/
 
     DELIMIT = case RUBY_PLATFORM
       when /-mingw32$/, /-mswin32$/
@@ -38,7 +38,7 @@ module GamespyQuery
       addrs = []
       list = %x[gslist -n #{@game}] if list.nil?
       list.split("\n").each do |line|
-        addrs << "#{$1}:#{$2}" if line =~ /([\d\.]+)[\s\t]*(\d+)/
+        addrs << "#{$1}:#{$2}" if line =~ RX_ADDR_LINE
       end
       addrs
     end
@@ -46,8 +46,7 @@ module GamespyQuery
     def read
       geo = @geo ? @geo : "-Q 11 "
       unless File.exists?(File.join(geoip_path, "GeoIP.dat"))
-        puts
-        puts "Warning: GeoIP.dat database missing. Can't parse countries. #{geoip_path}"
+        Tools.logger.warn "Warning: GeoIP.dat database missing. Can't parse countries. #{geoip_path}"
         geo = nil
       end
       reply = %x[gslist -p "#{geoip_path}" -n #{@game} #{geo}-X #{PARAMS.clone.map{|e| "#{DELIMIT}#{e}"}.join("")}]
@@ -67,7 +66,7 @@ module GamespyQuery
         i = 0
         content.map! do |e|
           i += 1
-          i % 2 == 0 ? e : clean(e)
+          i % 2 == 0 ? e : clean_string(e)
         end
         addr = "#{ip}:#{port}"
         if @list.has_key?(addr)

data/lib/gamespy_query/parser.rb

@@ -10,7 +10,7 @@
 require_relative 'base'
 
 module GamespyQuery
-  class Parser
+  class Parser < Base
     STR_SPLIT = STR_X0
     STR_ID = "\x00\x04\x05\x06\a"
 
@@ -76,17 +76,6 @@ module GamespyQuery
       data
     end
 
-    if RUBY_PLATFORM =~ /mswin32/
-      def get_string(str)
-        System::Text::Encoding.UTF8.GetString(System::Array.of(System::Byte).new(str.bytes.to_a)).to_s
-      end
-    else
-      def get_string(str)
-        #(str + '  ').encode("UTF-8", :invalid => :replace, :undef => :replace)[0..-2]
-        str
-      end
-    end
-
     def clean_packet(packet)
       packet = packet.clone
       packet.sub!(STR_ID, STR_EMPTY) # Cut off the identity
@@ -99,7 +88,7 @@ module GamespyQuery
       get_string(packet)
     end
     
-    def clean(str)
+    def clean_string(str)
       str.encode("UTF-8", invalid: :replace, undef: :replace)
     end
 
@@ -111,9 +100,9 @@ module GamespyQuery
 
       packet.split(STR_SPLIT).each_with_index do |data, index|
         if (index % 2) == 0
-          key = clean data
+          key = clean_string data
         else
-          game_data[key] = data.is_a?(String) ? clean(data) : data
+          game_data[key] = data.is_a?(String) ? clean_string(data) : data
         end
       end
 
@@ -171,7 +160,7 @@ module GamespyQuery
           # Parse the data - \x00 is printed after a non-nil entry, otherwise \x00 means nil (e.g empty team)
           until str.empty?
             entry = str[RX_X0_SPEC]
-            player_data[player_data.keys[i]] << clean(entry.sub(STR_X0, STR_EMPTY))
+            player_data[player_data.keys[i]] << clean_string(entry.sub(STR_X0, STR_EMPTY))
             str.sub!(entry, STR_EMPTY)
           end
           

data/lib/gamespy_query/socket.rb

@@ -1,32 +1,31 @@
 # encoding: utf-8
 # GameSpy query class by Sickboy [Patrick Roza] (sb_at_dev-heaven.net)
 
-
-
 require 'yaml'
 require_relative 'base'
 require_relative 'parser'
 require 'socket'
 
 module GamespyQuery
+  # TODO
   module MultiSocket
     def create_socket(*params)
-      puts "Creating socket #{params}"
+      Tools.debug {"Creating socket #{params}"}
       _create_socket(*params)
     end
 
     def socket_send(*params)
-      puts "Sending socket #{params}"
+      Tools.debug {"Sending socket #{params}"}
       _socket_send(*params)
     end
 
     def socket_receive(*params)
-      puts "Receiving socket #{params}"
+      Tools.debug {"Receiving socket #{params}"}
       _socket_receive(*params)
     end
 
     def socket_close(*params)
-      puts "Closing socket #{params}"
+      Tools.debug {"Closing socket #{params}"}
       _socket_close(*params)
     end
 
@@ -136,32 +135,32 @@ module GamespyQuery
     def valid?; @state == STATE_READY; end
 
     def handle_write
-      #STDOUT.puts "Write: #{self.inspect}, #{self.state}"
+      #Tools.debug {"Write: #{self.inspect}, #{self.state}"}
 
       r = true
       begin
         case self.state
           when STATE_INIT
-            STDOUT.puts "Write (0): #{self.inspect}"
+            Tools.debug {"Write (0): #{self.inspect}"}
             # Send Challenge
             self.puts @packet
             self.state = STATE_SENT_CHALLENGE
           when STATE_RECEIVED_CHALLENGE
-            STDOUT.puts "Write (2): #{self.inspect}"
+            Tools.debug {"Write (2): #{self.inspect}"}
             # Send Challenge response
             self.puts self.needs_challenge ? BASE_PACKET + @id_packet + self.needs_challenge + FULL_INFO_PACKET_MP : BASE_PACKET + @id_packet + FULL_INFO_PACKET_MP
             self.state = STATE_SENT_CHALLENGE_RESPONSE
         end
       rescue => e
-        STDOUT.puts "Error: #{e.message}, #{self.inspect}"
+        Tools.log_exception e
         self.failed = true
         r = false
-        close
+        close unless closed?
       end
 
 =begin
     if Time.now - self.stamp > @timeout
-      STDOUT.puts "TimedOut: #{self.inspect}"
+      Tools.debug {"TimedOut: #{self.inspect}"}
       self.failed = true
       r = false
       close unless closed?
@@ -171,28 +170,28 @@ module GamespyQuery
     end
 
     def handle_read
-      #STDOUT.puts "Read: #{self.inspect}, #{self.state}"
+      # Tools.debug {"Read: #{self.inspect}, #{self.state}"}
 
       r = true
       case self.state
         when STATE_SENT_CHALLENGE
           begin
             data = self.recvfrom_nonblock(RECEIVE_SIZE)
-            STDOUT.puts "Read (1): #{self.inspect}: #{data}"
+            Tools.debug {"Read (1): #{self.inspect}: #{data}"}
 
             handle_challenge get_string(data[0])
 
             self.state = STATE_RECEIVED_CHALLENGE
           rescue => e
-            STDOUT.puts "Error: #{e.message}, #{self.inspect}"
+            Tools.log_exception e
             self.failed = true
             r = false
-            close
+            close unless closed?
           end
         when STATE_SENT_CHALLENGE_RESPONSE, STATE_RECEIVE_DATA
           begin
             data = self.recvfrom_nonblock(RECEIVE_SIZE)
-            STDOUT.puts "Read (3,4): #{self.inspect}: #{data}"
+            Tools.debug {"Read (3,4): #{self.inspect}: #{data}"}
             self.state = STATE_RECEIVE_DATA
 
             game_data = get_string(data[0])
@@ -203,30 +202,29 @@ module GamespyQuery
             self.data[index] = game_data
 
             if self.data.size >= self.max_packets # OR we received the end-packet and all packets required
-              STDOUT.puts "Received packet limit: #{self.inspect}"
+              Tools.debug {"Received packet limit: #{self.inspect}"}
               self.state = STATE_READY
               r = false
               close unless closed?
             end
           rescue => e
-            STDOUT.puts "Error: #{e.message}, #{self.inspect}"
+            Tools.log_exception(e)
             self.failed = true
             r = false
-            close
+            close unless closed?
           end
       end
       r
     end
 
     def handle_exc
-      STDOUT.puts "Exception: #{self.inspect}"
-      close
+      Tools.debug {"Exception: #{self.inspect}"}
+      close unless closed?
       self.failed = true
 
       false
     end
 
-
     def handle_splitnum game_data
       index = 0
       if game_data.sub(STR_GARBAGE, STR_EMPTY)[RX_SPLITNUM]
@@ -236,7 +234,7 @@ module GamespyQuery
         last = flag & 0x80 > 0
         # Data could be received out of order, use the "index" id when "last" flag is true, to determine total packet_count
         self.max_packets = index + 1 if last # update the max
-        STDOUT.puts "Splitnum: #{splitnum.inspect} (#{splitnum}) (#{flag}, #{index}, #{last}) Max: #{self.max_packets}"
+        Tools.debug {"Splitnum: #{splitnum.inspect} (#{splitnum}) (#{flag}, #{index}, #{last}) Max: #{self.max_packets}"}
       else
         self.max_packets = 1
       end
@@ -245,7 +243,7 @@ module GamespyQuery
     end
 
     def handle_challenge str
-      #STDOUT.puts "Received challenge response (#{str.length}): #{str.inspect}"
+      # Tools.debug{"Received challenge response (#{str.length}): #{str.inspect}"}
       need_challenge = !(str.sub(STR_X0, STR_EMPTY) =~ RX_NO_CHALLENGE)
       if need_challenge
         str = str.sub(RX_CHALLENGE, STR_EMPTY).gsub(RX_CHALLENGE2, STR_EMPTY).to_i
@@ -257,8 +255,8 @@ module GamespyQuery
     def handle_state; [STATE_INIT, STATE_RECEIVED_CHALLENGE].include? state; end
 
     # Supports challenge/response and multi-packet
-    def sync
-      game_data, key, reply = {}, nil, self.fetch
+    def sync reply = self.fetch
+      game_data, key = {}, nil
       return game_data if reply.nil?
 
       parser = Parser.new(reply)
@@ -297,12 +295,13 @@ module GamespyQuery
         pings_c = 0
         pings.each { |ping| pings_c += ping }
 
-        ping = pings.size == 0 ? nil : pings_c / pings.sizeha
+        ping = pings.size == 0 ? nil : pings_c / pings.size
         Tools.debug{"Gamespy pings: #{pings}, #{ping}"}
         @ping = ping
       rescue => e
-        STDOUT.puts "Error during fetch #{self.inspect}: #{e.message}"
+        Tools.log_exception(e)
         r = nil
+        close unless closed?
       end
       r
     end

data/lib/gamespy_query/socket_master.rb

@@ -35,13 +35,13 @@ module GamespyQuery
           write_sockets, read_sockets = queue.reject {|s| s.valid? }.partition {|s| s.handle_state }
 
           unless ready = IO.select(read_sockets, write_sockets, nil, @timeout)
-            puts "Timeout, no usable sockets in current queue, within timeout period"
+            Tools.logger.warn "Timeout, no usable sockets in current queue, within timeout period (#{@timeout}s)"
             queue.each{|s| s.close unless s.closed?}
             queue = []
             next
           end
 
-          puts "Sockets: #{queue.size}, AddrsLeft: #{@addrs.size}, ReadReady: #{"#{ready[0].size} / #{read_sockets.size}, WriteReady: #{ready[1].size} / #{write_sockets.size}, ExcReady: #{ready[2].size} / #{queue.size}" unless ready.nil?}"
+          Tools.debug {"Sockets: #{queue.size}, AddrsLeft: #{@addrs.size}, ReadReady: #{"#{ready[0].size} / #{read_sockets.size}, WriteReady: #{ready[1].size} / #{write_sockets.size}, ExcReady: #{ready[2].size} / #{queue.size}" unless ready.nil?}"}
 
           # Read
           ready[0].each { |s| queue.delete(s) unless s.handle_read() }

data/lib/gamespy_query/version.rb

@@ -1,3 +1,3 @@
 module GamespyQuery
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/gamespy_query.rb

@@ -10,10 +10,16 @@ end
 
 
 if $0 == __FILE__
-  host = ARGV[0]
-  port = ARGV[1]
-  g = GamespyQuery::Socket.new(host, port)
+  host, port = if ARGV.size > 1
+                 ARGV
+               else
+                 ARGV[0].split(":")
+               end
+  time_start = Time.now
+  g = GamespyQuery::Socket.new("#{host}:#{port}")
   r = g.sync
+  time_taken = Time.now - time_start
+  puts "Took: #{time_taken}s"
   exit unless r
   puts r.to_yaml
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gamespy_query
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors: