gamespy_query 0.1.5 → 0.2.0pre

data/.gitignore

@@ -2,3 +2,8 @@
 .bundle
 Gemfile.lock
 pkg/*
+
+/.idea/
+/.yardoc/
+/doc/
+*.log

data/README.md

@@ -1,4 +1,7 @@
-GamespyQuery
-=============
-
-This library provides access to GameSpy master server (through gslist utility) and to GameSpy enabled game servers directly through UDPSocket.
+GamespyQuery
+=============
+
+This library provides access to GameSpy master server (through gslist utility) and to GameSpy enabled game servers directly through UDPSocket.
+
+Requires the gslist utility for GamespyMaster operations: http://aluigi.org/papers.htm#gslist
+

data/Rakefile

@@ -1 +1,15 @@
 require "bundler/gem_tasks"
+
+require 'rake'
+require 'rake/testtask'
+
+desc "Run all our tests"
+task :test do
+  Rake::TestTask.new do |t|
+    t.libs << "test"
+    t.pattern = "test/**/*_test.rb"
+    t.verbose = false
+  end
+end
+
+task :default => :test

data/bin/gamespy_query

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# This binary is mostly intended for testing gamespy_query implementation
+
+require 'gamespy_query'
+
+# Parse commandline arguments
+options = GamespyQuery::Options.parse

data/gamespy_query.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "cri"
+  s.add_development_dependency "riot"
+  s.add_development_dependency "yard"
 end

data/lib/gamespy_query.rb

@@ -1,11 +1,26 @@
 require_relative "gamespy_query/version"
-require_relative "gamespy_query/base"
-require_relative "gamespy_query/socket"
-require_relative "gamespy_query/socket_master"
-require_relative "gamespy_query/master"
 
+# GamespyQuery provides access to GameSpy master server (through gslist utility)
+# and to GameSpy enabled game servers directly through UDPSocket.
 module GamespyQuery
-  # Your code goes here...
+  autoload :Base, "gamespy_query/base"
+  autoload :Funcs, "gamespy_query/base"
+  autoload :Tools, "gamespy_query/base"
+
+  autoload :Options, "gamespy_query/options"
+
+  autoload :Parser, "gamespy_query/parser"
+  autoload :Socket, "gamespy_query/socket"
+  autoload :MultiSocket, "gamespy_query/socket"
+  autoload :SocketMaster, "gamespy_query/socket_master"
+  autoload :Master, "gamespy_query/master"
+
+  module_function
+
+  # Retrieve full product version string
+  def product_version
+    "GamespyQuery version #{VERSION}"
+  end
 end
 
 

data/lib/gamespy_query/base.rb

@@ -9,52 +9,75 @@ module GamespyQuery
 
   DEBUG = false
 
+  # Contains basic Tools set to work with logging, debugging, etc.
   module Tools
     STR_EMPTY = ""
     CHAR_N = "\n"
   
     module_function
+    # Provides access to the logger object
+    # Will use ActionController::Base.logger if available
     def logger
       @logger ||= if defined?(::Tools); ::Tools.logger; else; defined?(ActionController) ? ActionController::Base.logger || Logger.new("logger.log") : Logger.new("logger.log"); end
     end
 
+    # Create debug message from Exception
+    # @param [Exception] e Exception to create debug message from
     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?}"
+      <<STR
+#{e.class}: #{e.message if e.respond_to?(:backtrace)}
+BackTrace: #{e.backtrace.join(CHAR_N) unless !e.respond_to?(:backtrace) || e.backtrace.nil?}
+STR
     end
 
-
+    # Log exception
+    # @param [Exception] e Exception to log
+    # @param [Boolean] as_error Log the exception as error in the log
+    # @param [String] msg Include custom error message
     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")}"
+        puts "Error: #{e.class} #{e.message}, #{e.backtrace.join("\n") unless e.backtrace.nil? }"
         logger.error "#{"#{msg}:" unless msg.empty?}#{e.class} #{e.message}" if as_error
         logger.debug dbg_msg(e)
       end
     end
 
+    # Log to debug log if DEBUG enabled
+    # @param [Block] block Block to yield string from
     def debug(&block)
       return unless DEBUG
-      logger.debug yield
+      out = yield
+      logger.debug out
+      puts out
     rescue Exception => e
       puts "Error: #{e.class} #{e.message}, #{e.backtrace.join("\n")}"
     end
   end
 
+  # Contains basic Funcs used throughout the classes
   module Funcs
+    # Provides TimeOutError exception
     class TimeOutError < StandardError
     end
 
+    # Strips tags from string
+    # @param [String] str
     def strip_tags(str)
       # TODO: Strip tags!!
       str
     end
 
-    RX_F = /\A\-?[0-9][0-9]*\.[0-9]*\Z/
-    RX_I = /\A\-?[0-9][0-9]*\Z/
+    # Float Regex
+    RX_F = /\A\-?[0-9]+\.[0-9]*\Z/
+    # Integer Regex
+    RX_I = /\A\-?[0-9]+\Z/
+    # Integer / Float actually String Regex
     RX_S = /\A\-?0[0-9]+.*\Z/
 
+    # Clean value, convert if possible
+    # @param [String] value String to convert
     def clean(value) # TODO: Force String, Integer, Float etc?
       case value
         when STR_X0
@@ -68,39 +91,37 @@ BackTrace: #{e.backtrace.join(CHAR_N) unless !e.respond_to?(:backtrace) || e.bac
       end
     end
 
-    def clean_string(str)
-      str.encode("UTF-8", invalid: :replace, undef: :replace)
-    end
-
+    # Handle char
+    # @param [Integer] number Integer to convert
     def handle_chr(number)
       number = ((number % 256)+256) if number < 0
       number = number % 256 if number > 255
       number
     end
 
-    def get_string(*params)
-      Tools.debug {"Getting string #{params}"}
-      _get_string(*params)
+    # Convert string to UTF-8, stripping out all invalid/undefined characters
+    # @param [String] str String to convert
+    def encode_string(str)
+      #Tools.debug {"Getting string #{str}"}
+      _encode_string str
     end
 
     if RUBY_PLATFORM =~ /mswin32/
-      include System::Net
-      include System::Net::Sockets
-
-      def get_string(str)
+      # Get UTF-8 string from string
+      # @param [String] str
+      def _encode_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)
-        #(str + '  ').encode("UTF-8", :invalid => :replace, :undef => :replace)[0..-2]
-        str
+      # Get UTF-8 string from string
+      # @param [String] str
+      def _encode_string(str)
+        (str + '  ').encode("UTF-8", invalid: :replace, undef: :replace)[0..-3]
       end
     end
   end
 
-
+  # Base class from which all others derrive
   class Base
     include Funcs
   end

data/lib/gamespy_query/master.rb

@@ -1,6 +1,5 @@
-require_relative 'base'
-
 module GamespyQuery
+  # Provides access to the Gamespy Master browser
   class Master < Base
     PARAMS = [:hostname, :gamever, :gametype, :gamemode, :numplayers, :maxplayers, :password, :equalModRequired, :mission, :mapname,
               :mod, :signatures, :verifysignatures, :gamestate, :dedicated, :platform, :sv_battleeye, :language, :difficulty]
@@ -14,29 +13,33 @@ module GamespyQuery
         "\\\\"
     end
 
-    def geoip_path
-      return File.join(Dir.pwd, "config") unless defined?(Rails)
+    # Geo settings
+    attr_reader :geo
 
-      case RUBY_PLATFORM
-      when /-mingw32$/, /-mswin32$/
-        File.join(Rails.root, "config").gsub("/", "\\")
-      else
-        File.join(Rails.root, "config")
-      end
-    end
+    # Game
+    attr_reader :game
 
+    # Initializes the instance
+    # @param [String] geo Geo string
+    # @param [String] game Game string
     def initialize(geo = nil, game = "arma2oapc")
       @geo, @game = geo, game
     end
 
+    # Convert the master browser data to hash
     def process list = self.read
       self.to_hash list
     end
 
+    # Gets list of PARAMS, delimited by {DELIMIT}
     def get_params
       PARAMS.clone.map{|e| "#{DELIMIT}#{e}"}.join("")
     end
 
+    # Gets list of server addressses and optionally data
+    # @param [String] list Specify list or nil to fetch the list
+    # @param [Boolean] include_data Should server info data from the master browser be included
+    # @param [String] geo Geo String
     def get_server_list list = nil, include_data = false, geo = nil
       addrs = []
       list = %x[gslist -p "#{geoip_path}"#{" #{geo}-X #{get_params}" if include_data} -n #{@game}] if list.nil?
@@ -50,6 +53,7 @@ module GamespyQuery
       addrs
     end
 
+    # Read the server list from gamespy
     def read
       geo = @geo ? @geo : "-Q 11 "
       unless geo.nil? || geo.empty? || File.exists?(File.join(geoip_path, "GeoIP.dat"))
@@ -59,13 +63,22 @@ module GamespyQuery
       get_server_list(nil, true, geo)
     end
 
+    # Handle reply data from gamespy master browser
+    # @param [String] reply Reply from gamespy
+    # @param [String] geo Geo String
     def handle_data(reply, geo = nil)
       reply = reply.gsub("\\\\\\", "") if geo
       reply.split("\n").select{|line| line =~ RX_ADDR_LINE }
     end
 
+
+    # Address and Data regex
     RX_H = /\A([\.0-9]*):([0-9]*) *\\(.*)/
+    # Split string
     STR_SPLIT = "\\"
+
+    # Convert array of data to hash
+    # @param [Array] ar Array to convert
     def to_hash(ar)
       list = Hash.new
       ar.each_with_index do |entry, index|
@@ -77,7 +90,7 @@ module GamespyQuery
         i = 0
         content.map! do |e|
           i += 1
-          i % 2 == 0 ? e : clean_string(e)
+          i % 2 == 0 ? e : encode_string(e)
         end
         addr = "#{ip}:#{port}"
         if list.has_key?(addr)
@@ -86,6 +99,7 @@ module GamespyQuery
           e = Hash.new
           e[:ip] = ip
           e[:port] = port
+          e[:gamename] = @game
           list[addr] = e
         end
         if e[:gamedata]
@@ -96,6 +110,19 @@ module GamespyQuery
       end
       list
     end
+
+
+    # Get geoip_path
+    def geoip_path
+      return File.join(Dir.pwd, "config") unless defined?(Rails)
+
+      case RUBY_PLATFORM
+        when /-mingw32$/, /-mswin32$/
+          File.join(Rails.root, "config").gsub("/", "\\")
+        else
+          File.join(Rails.root, "config")
+      end
+    end
   end
 end
 
@@ -103,4 +130,4 @@ if $0 == __FILE__
   master = GamespyQuery::Master.new
   r = master.read
   puts r
-end
+end

data/lib/gamespy_query/options.rb

@@ -0,0 +1,140 @@
+require 'cri'
+require 'ostruct'
+
+module GamespyQuery
+  # Handles commandline parameters for the Main tool
+  class Options
+    class <<self
+      # Parse given args
+      # @param [Array] args Parse given args
+      def parse args = ARGV
+        _parse.run(args)
+      end
+
+      # Defaults for options
+      # @param [Hash] opts Options
+      def setup_master_opts opts
+        opts = opts.clone
+        opts[:geo] ||= ""
+        opts[:game] ||= "arma2oapc"
+        opts
+      end
+
+      private
+      # Parser definition
+      def _parse
+        #root_command = Cri::Command.new_basic_root # Bug with h self.help -> cmd.help etc
+        root_command = Cri::Command.define do
+          name        'gamespy_query'
+          usage       'gamespy_query [options]'
+          summary     'Gamespy Protocol'
+          description 'This command provides the basic functionality'
+
+
+          option :h, :help, 'show help for this command' do |value, cmd|
+            puts cmd.help
+            exit 0
+          end
+
+          subcommand Cri::Command.new_basic_help
+
+          option nil, :version, 'Show version' do |value, cmd|
+            puts GamespyQuery.product_version
+            exit 0
+          end
+
+          flag :v, :verbose, 'Verbose'
+        end
+
+        root_command.define_command do
+          name    'sync'
+          usage   'sync ip:port [options]'
+          summary 'Sync data'
+          aliases :s
+
+          run do |opts, args, cmd|
+            puts "Running Sync, #{opts}, #{args}, #{cmd}"
+            if args.empty?
+              puts "Missing ip:port"
+              exit 1
+            end
+            host, port = if args.size > 1
+                           args
+                         else
+                           args[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
+        end
+
+        root_command.add_command _parse_master_command
+
+        root_command
+      end
+
+      def _parse_master_command
+        master_command = Cri::Command.define do
+          name    'master'
+          usage   'master COMMAND [options]'
+          aliases :m
+
+          option :g, :game, 'Specify game', :argument => :required
+          option nil, :geo, 'Specify geo', :argument => :required
+
+          subcommand Cri::Command.new_basic_help
+
+          run do |opts, args, cmd|
+            puts "Running Master, #{opts}, #{args}, #{cmd}"
+          end
+        end
+
+        master_command.define_command do
+          name 'list'
+          usage 'list [options]'
+          aliases :l
+
+          run do |opts, args, cmd|
+            opts = GamespyQuery::Options.setup_master_opts opts
+            master = GamespyQuery::Master.new(opts[:geo], opts[:game])
+            list = master.read
+            puts list
+          end
+        end
+
+        master_command.define_command do
+          name 'process'
+          usage 'process [options]'
+          aliases :p
+
+          run do |opts, args, cmd|
+            opts = GamespyQuery::Options.setup_master_opts opts
+
+            master = GamespyQuery::Master.new(opts[:geo], opts[:game])
+            process = master.process
+            puts process
+          end
+        end
+
+        master_command.define_command do
+          name 'process_master'
+          usage 'process_master [options]'
+          aliases :m
+
+          run do |opts, args, cmd|
+            opts = GamespyQuery::Options.setup_master_opts opts
+            process = GamespyQuery::SocketMaster.process_master(opts[:game], opts[:geo])
+            puts process
+          end
+        end
+
+        master_command
+      end
+    end
+  end
+end