vrowser 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,49 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/LICENSE.txt

@@ -0,0 +1 @@
+Copyright (c) 2012 kimoto

data/README.rdoc

@@ -0,0 +1,7 @@
+= vrowser
+Server browser for many games (left4Dead2, TeamFortress2, etc)
+
+== Copyright
+Copyright (c) 2012 kimoto. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "vrowser"
+    gem.summary = %Q{TODO: one-line summary of your gem}
+    gem.description = %Q{TODO: longer description of your gem}
+    gem.email = "sub+peerler@gmail.com"
+    gem.homepage = "http://github.com/kimoto/vrowser"
+    gem.authors = ["kimoto"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "vrowser #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/vrowser

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# Author: kimoto
+require 'vrowser'
+require 'optparse'
+
+options = {}
+parser = OptionParser.new{ |opts|
+  opts.banner = "Usage: #{File.basename($0)}"
+  opts.on("-f", "--config-file=PATH", "specify config file"){ |v|
+    options[:config_path] = v
+  }
+}
+parser.parse!
+
+if options[:config_path].nil?
+  parser.help.display
+  exit(1)
+end
+
+Vrowser.load_file(options[:config_path]) do |vrowser|
+  case sub_command = ARGV.shift
+  when "fetch"
+    vrowser.fetch
+  when "update"
+    vrowser.update
+    vrowser.clear
+  when "list"
+    puts vrowser.servers.map(&:name).join($/)
+  when "json"
+    vrowser.active_servers.select(:name, :host, :ping, :num_players, :type, :map, :players).order(:host).map(&:values).to_json.display
+  else
+    raise ArgumentError
+  end
+end

data/examples/config.yml

@@ -0,0 +1,14 @@
+qstat:
+  master_server: "hl2master.steampowered.com:27011"
+  gametype: stm
+  gamename: left4dead2
+  maxping:  100
+  protocol: a2s
+plugins: 
+ - l4d2
+database:
+  adapter: sqlite
+  database: /tmp/server.db
+  pool: 5
+  timeout: 5000
+

data/lib/plugins/l4d2.rb

@@ -0,0 +1,52 @@
+class Vrowser
+  def self.recommend_game_type(info)
+    server_name = info.server_name
+    game_type = info.suggest_game_type
+    if game_type != 'unknown'
+      return game_type
+    end
+
+    if server_name =~ /co\-?op/i
+      return 'coop'
+    elsif server_name =~ /scavenge/i
+      return 'scavenge'
+    elsif server_name =~ /survival/i
+      return 'survival'
+    elsif server_name =~ /realism/i
+      return 'realism'
+    elsif server_name =~ /versus/i
+      return 'versus'
+    elsif server_name =~ /hard(eight|six|twelve)/i
+      return 'coop'
+    elsif server_name =~ /(exp(ert)?|advance|easy|normal)/i
+      return 'coop'
+    elsif server_name =~ /RPG/
+      return 'coop'
+    elsif server_name =~ /4vs4/i
+      return 'versus'
+    elsif server_name =~ /vs/i
+      return 'versus'
+    elsif server_name =~ /team/i
+      return 'versus'
+    elsif server_name =~ /confogl/i
+      return 'versus'
+    elsif server_name =~ /fresh(\s*config)?/i
+      return 'versus'
+    elsif server_name =~ /skullsaba/i
+      return 'versus'
+    elsif server_name =~ /S A M U R A i/i
+      return 'versus'
+    elsif info.number_of_max_players == '4'
+      return 'coop'
+    elsif info.number_of_max_players == '8'
+      return 'versus'
+    else
+      return 'unknown'
+    end
+  end
+
+  def self.before_update(server_info)
+    server_info.game_type = recommend_game_type(server_info)
+    server_info
+  end
+end

data/lib/vrowser.rb

@@ -0,0 +1,309 @@
+# encoding: utf-8
+require 'ruby-qstat'
+require 'sequel'
+require 'logger'
+require 'retry-handler'
+require 'active_support/core_ext'
+require 'yaml'
+require 'json'
+
+module VrowserModel
+  def self.connect(options={})
+    Sequel::Model.plugin(:schema)
+    Sequel.connect(options)
+    self.define_models
+    Servers.plugin :timestamps, :create=>:created_at, :update=>:updated_at
+  end
+
+  def self.define_models
+    module_eval %{
+      class Servers < Sequel::Model
+        unless table_exists?
+          set_schema do
+            primary_key :id
+            string :name
+            string :host, :unique => true
+            string :status
+            integer :ping
+            string :num_players
+            string :type
+            string :map
+            string :players
+            timestamp :created_at
+            timestamp :updated_at
+          end
+          create_table
+        end
+      end
+    }
+  end
+end
+
+class Vrowser
+  include VrowserModel
+
+  @@logger = Logger.new(STDOUT)
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def self.qstat_path=(path)
+    QStat.qstat_path = path
+  end
+
+  def self.update_serverlist(host, gametype, gamename, maxping)
+    inserted = updated = 0
+
+    servers = self.fetch_serverlist(host, gametype, gamename, maxping)
+    servers.each{ |sv|
+      if sv.rules.empty?
+        game_type = "unknown"
+      else
+        game_type = sv.rules.first.game_tags.first
+      end
+      @@logger.info "game_type is #{game_type}"
+
+      @@logger.info "finding hostname: #{sv.addr}"
+      record = Servers.find(:host => sv.addr)
+      @@logger.info "record result: #{record.inspect}"
+
+      if record.nil?
+        @@logger.info "new record for #{sv.addr}"
+        Servers.insert(:name => sv.server_name, :host => sv.addr,
+                       :status => sv.status, :ping => sv.ping, :num_players => sv.number_of_players,
+                       :type => game_type, :map => sv.map, :players => sv.players.map(&:name).join(',')
+                      )
+                      inserted += 1
+      else
+        @@logger.info "already exist hostname, record update: #{sv.addr}"
+        record.update(
+          :name => sv.server_name, :status => sv.status, 
+          :ping => sv.ping,
+          #:num_players => sv.number_of_players,
+          #:type => game_type,
+          #:map => sv.map,
+          #:players => sv.players.map(&:name).join(',')
+        )
+        updated += 1
+      end
+    }
+    @@logger.info "updated exit: inserted:#{inserted}, updated:#{updated}"
+    servers
+  end
+
+  def self.update_registered_all(protocol)
+    updated = 0
+    begin
+      Servers.all.each{ |server|
+        @@logger.info "trying to update: #{server.host}, #{server.name}"
+        self.update(server.host, protocol)
+        updated += 1
+      }
+    rescue
+      @@logger.error $!
+    ensure
+      @@logger.info "updated #{updated} servers"
+    end
+  end
+
+  def self.update_info_registered_all(protocol)
+    updated = 0
+    begin
+      Servers.all.each{ |server|
+        @@logger.info "trying to update_info: #{server.host}, #{server.name}"
+        self.update_info(server.host, protocol)
+        updated += 1
+      }
+    rescue
+      @@logger.error $!
+    ensure
+      @@logger.info "updated #{updated} servers"
+    end
+  end
+
+  def self.update(host, protocol)
+    new_info = QStat.query(host, protocol)
+    if new_info.nil? or new_info.no_response? or new_info.down?
+      @@logger.info "server is downing"
+      Servers.find(:host => host).update(:status => 'DOWN')
+      return
+    end
+
+    new_info = self.before_update(new_info)
+    @@logger.info "game_type is #{new_info.game_type}"
+
+    record = Servers.find(:host => host)
+    if record
+      record.update(:name => new_info.server_name,
+                    :status => 'UP', :ping => new_info.ping,
+                    :num_players => new_info.number_of_players,
+                    :type => new_info.game_type,
+                    :map => new_info.map,
+                    :players => new_info.players.map(&:name).join(','))
+      @@logger.info "updated: #{new_info.addr}, #{new_info.server_name}"
+    else
+      @@logger.info "not found record: #{record.inspect.players}"
+      @@logger.info "#{new_info.server_name}"
+      Servers.insert(:host => new_info.addr, :name => new_info.server_name,
+                     :status => 'UP', :ping => new_info.ping, :num_players => new_info.number_of_players,
+                     :type => new_info.game_type, :map => new_info.map,
+                     :players => new_info.players.map(&:name).join(','))
+                     @@logger.info "inserted: #{new_info.addr}, #{new_info.server_name}"
+    end
+  end
+
+  def self.before_update(server_info)
+    server_info
+  end
+
+  def self.update_info(host, protocol)
+    new_info = QStat.query_serverinfo(host, protocol)
+    if new_info.nil? or new_info.no_response? or new_info.down?
+      @@logger.info "server is downing"
+      Servers.find(:host => host).update(:status => 'DOWN')
+      return
+    end
+
+    new_info = self.before_update(new_info)
+    @@logger.info "game_type is #{new_info.game_type}"
+
+    record = Servers.find(:host => host)
+    if record
+      record.update(:name => new_info.server_name,
+                    :status => 'UP', :ping => new_info.ping,
+                    :type => new_info.game_type,
+                    :map => new_info.map)
+      @@logger.info "updated: #{new_info.addr}, #{new_info.server_name}"
+    else
+      @@logger.info "not found record: #{record.inspect.players}"
+      @@logger.info "#{new_info.server_name}"
+      Servers.insert(:host => new_info.addr, :name => new_info.server_name,
+                     :status => 'UP', :ping => new_info.ping, 
+                     :type => new_info.game_type, :map => new_info.map)
+                     @@logger.info "inserted: #{new_info.addr}, #{new_info.server_name}"
+    end
+  end
+
+  def self.servers
+    Servers.all
+  end
+
+  def self.active_servers
+    Servers.filter(:status => 'UP')
+  end
+
+  def self.remove_all
+    o = Servers.delete
+    @@logger.info "remove all records: #{o}"
+  end
+
+  def self.remove_debris
+    records = Servers.filter(:status => 'DOWN')
+    @@logger.info "remove debris: count #{records.count}"
+    records.delete
+    @@logger.info "removed"
+  end
+
+  def self.fetch_serverlist(host, gametype, gamename, maxping)
+    proc{
+      @@logger.info "try to fetch server list"
+      return QStat.query_serverlist(host, gametype, gamename, maxping)
+    }.retry(:accept_exception => StandardError, :logger => @@logger)
+  rescue => ex
+    @@logger.error "error: #{ex}"
+    return []
+  end
+
+  def self.read_serverlist_from_xml(path)
+    QStat.read_from_xml(path)
+  end
+
+  def self.debug_list
+    Servers.all.each{ |server|
+      puts "#{server.name}, #{server.host}"
+    }
+  end
+
+  def self.update_server_types
+    active_servers.each{ |sv|
+      update(sv.host)
+    }
+  end
+
+  def self.plugin_dir
+    File.expand_path(File.join(File.dirname(__FILE__), "./plugins"))
+  end
+
+  def self.plugin_path(plugin_name)
+    File.expand_path(File.join(self.plugin_dir, plugin_name + ".rb"))
+  end
+
+  def self.load_all_plugins
+    self.load_plugins(self.plugin_dir)
+  end
+
+  def self.load_plugins(dir)
+    Dir.entries(dir).each{ |entry|
+      next if entry == "." or entry == ".."
+      load File.join(dir, entry)
+    }
+  end
+
+  def self.load_plugin(plugin_name)
+    load self.plugin_path(plugin_name.to_s)
+  end
+
+  def self.load_config(config)
+    raise ArgumentError.new("config['plugins']") unless config["plugins"]
+    raise ArgumentError.new("config['qstat']") unless config["qstat"]
+    raise ArgumentError.new("config['database']") unless config["database"]
+
+    VrowserModel.connect(config["database"])
+
+    config['plugins'].each{ |plugin_symbol|
+      Vrowser.load_plugin plugin_symbol
+    }
+
+    Vrowser.new(config['qstat'].symbolize_keys)
+  end
+
+  def self.load_file(path)
+    instance = self.load_config YAML.load_file(path)
+    yield(instance) if block_given?
+    instance
+  end
+
+  #### ==== instance methods
+  def initialize(options={})
+    @master_server = options[:master_server] or raise ArgumentError("master_server")
+    @gametype = options[:gametype] or raise ArgumentError("gametype")
+    @gamename = options[:gamename] or raise ArgumentError("gamename")
+    @protocol = options[:protocol] or raise ArgumentError("protocol")
+    @maxping  = options[:maxping] ||= 130
+    yield(self) if block_given?
+  end
+
+  def fetch
+    self.class.update_serverlist(@master_server, @gametype, @gamename, @maxping)
+  end
+
+  def update
+    self.class.update_registered_all(@protocol)
+  end
+
+  def update_only_info
+    self.class.update_info_registered_all(@protocol)
+  end
+
+  def clear
+    self.class.remove_debris
+  end
+
+  def servers
+    self.class.servers
+  end
+
+  def active_servers
+    self.class.active_servers
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'vrowser'
+
+class Test::Unit::TestCase
+end

data/test/test_vrowser.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestVrowser < Test::Unit::TestCase
+  should "do not anything" do
+    true
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: vrowser
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- kimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-06 00:00:00 +09:00
+default_executable: vrowser
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  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: Server browser for many games (Left4Dead2, TeamFortress2, etc)
+email: sub+peerler@gmail.com
+executables: 
+- vrowser
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/vrowser
+- examples/config.yml
+- lib/plugins/l4d2.rb
+- lib/vrowser.rb
+- test/helper.rb
+- test/test_vrowser.rb
+has_rdoc: true
+homepage: http://github.com/kimoto/vrowser
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Server browser for many games
+test_files: 
+- test/helper.rb
+- test/test_vrowser.rb