game_machine 0.0.11 → 1.0.2

data/spec/java_grid_spec.rb

@@ -26,7 +26,6 @@ module GameMachine
         grid_value = subject.get('blah')
 
         expect(grid_value.id).to eq('blah')
-        expect(grid_value.cell).to eq(0)
         expect(grid_value.x).to eq(0)
         expect(grid_value.y).to eq(0)
         expect(grid_value.z).to eq(3)
@@ -65,7 +64,6 @@ module GameMachine
         subject.set('blah',0,0,0,'player')
         points = subject.neighbors(0,0,25,'player')
         expect(points.first.cell).to eq(0)
-
       end
 
       it "does not return cells out of range" do

data/spec/misc_spec.rb

@@ -1,4 +1,7 @@
 require 'spec_helper'
+require 'benchmark'
+require "net/http"
+require "uri"
 require 'jruby/core_ext'
 module GameMachine
 
@@ -13,6 +16,114 @@ module GameMachine
       entity
     end
 
+    it "ebean test" do
+      config = AppConfig.instance.config
+      pool = GameMachine::JavaLib::DbConnectionPool.getInstance
+      pool.connect(
+        'test',
+        config.jdbc.hostname,
+        config.jdbc.port,
+        config.jdbc.database,
+        config.jdbc.ds,
+        config.jdbc.username,
+        config.jdbc.password || ''
+      )
+      BeanLib::TestModel.set_ds
+      BeanLib::TestModel.test
+    end
+
+    xit "authorizes with cloudclient" do
+      url = "http://localhost:9000/client/login/test"
+      uri = URI.parse(url)
+
+      response = Net::HTTP.post_form(uri, {'username' => 'chris', 'password' => 'pass'})
+      puts response.inspect
+      puts response.body
+
+    end
+
+    xit "serialized to json" do
+      entity = MessageLib::Entity.new.set_id('player')
+      puts entity.to_json
+    end
+
+    xit "couch http client" do
+      entity = MessageLib::Entity.new.set_id('3')
+      client = JavaLib::Couchclient.get_instance
+      10.times do |i|
+        id = "TESTING#{i}"
+        response = client.put(id,entity.to_byte_array)
+        puts response.status
+        #puts response.body
+
+        response = client.get(id)
+        puts response.status
+        if response.status == 200
+          puts MessageLib::Entity.parse_from(response.body)
+        end
+        
+
+        response = client.delete(id)
+        puts response.status
+        #puts response.body
+      end
+    end
+
+    xit "msyql ogbject store stress" do
+      GameMachine::Application.orm_connect
+      ds = Commands::DatastoreCommands.new
+      count = 0
+      puts Benchmark.realtime {
+        10000.times do
+          entity.id = count.to_s
+          entity.db_put
+          count += 1
+          sleep 0.002
+        end
+      }
+    end
+
+    xit "finds model" do
+      GameMachine::Application.orm_connect
+      MessageLib::TestObject.delete_async('player1')
+      if message = MessageLib::TestObject.find_by_player_id("player1")
+        message.set_fvalue(1.9)
+        message.save_async('player1')
+      else
+        message = MessageLib::TestObject.new
+        message.set_required_string('testing')
+        message.set_fvalue(1.9)
+        message.set_bvalue(true)
+        message.set_dvalue(3.4)
+        message.set_numbers64(555)
+        message.save_async('player1')
+      end
+      
+      sleep 2
+    end
+
+    xit "trackdata test" do
+       neighbors = MessageLib::Neighbors.new
+       trackdata = MessageLib::TrackData.new
+       trackdata.x = 100.0
+       trackdata.y = 100.0
+       trackdata.z = 100.0
+       200.times do
+         neighbors.add_track_data(trackdata)
+       end
+
+       tracktest = MessageLib::TrackTest.new
+       200.times do
+         tracktest.add_x(100.0)
+         tracktest.add_y(100.0)
+         tracktest.add_z(100.0)
+       end
+       100000000.times do
+         tracktest.to_byte_array
+         #neighbors.to_byte_array
+       end
+    end
+
     xit "singleton manager" do
       ref = Akka.instance.actor_system.actor_selection('/user/region_manager_proxy')
       ref.tell('HELLO',nil)

data/spec/mono_spec.rb

@@ -4,6 +4,8 @@ require "base64"
 require 'socket'
 require "uri"
 require 'net/http'
+require 'benchmark'
+require 'descriptive_statistics'
 java_import 'java.util.concurrent.ThreadPoolExecutor'
 java_import 'java.util.concurrent.TimeUnit'
 java_import 'java.util.concurrent.LinkedBlockingQueue'
@@ -11,20 +13,65 @@ java_import 'java.util.concurrent.FutureTask'
 java_import 'java.util.concurrent.Callable'
 
 CHARS = [*('a'..'z'),*('0'..'9')].flatten
-STR = Array.new(100) {|i| CHARS.sample}.join
+STR = Array.new(200) {|i| CHARS.sample}.join
 STR2 = Array.new(1000) {|i| CHARS.sample}.join
 
 
 module GameMachine
   describe 'mono' do
 
-    it "mono gateway" do
+    xit "udp gateway" do
+      host = '127.0.0.1'
+      port = 4000
+      message = MessageLib::Entity.new.set_id(STR)
+
+      threads = []
+      proxy = JavaLib::MonoProxy.getInstance
+      1.times do
+        threads <<  Thread.new do
+          results = []
+          errors = 0
+            10000.times do
+              results << Benchmark.realtime {
+                response = proxy.call('MyGame.Echo',message)
+                if response.nil?
+                  puts 'error'
+                  errors += 1
+                end
+              }
+            end
+            puts "Number = #{results.number} Errors = #{errors} Average #{results.mean * 1000000} Standard deviation #{results.standard_deviation * 1000000}"
+        end
+      end
+      threads.map(&:join)
+    end
+
+    xit "calls mono method" do
+
+      Mono::Vm.instance.load
+
+      threads = []
+      4.times do
+        threads <<  Thread.new do
+          str = Array.new(400) {|i| CHARS.sample}.join
+          message = MessageLib::Entity.new.set_id(str)
+          puts Benchmark.realtime {
+          1000000.times do
+            Mono::Vm.instance.call_mono('GameMachine','TestActor',message)
+          end
+          }
+        end
+      end
+      threads.map(&:join)
+    end
+
+    xit "mono gateway" do
       Actor::Builder.new(Endpoints::MonoGateway).start
       sleep 1
       str = Array.new(1000) {|i| CHARS.sample}.join
       message = MessageLib::Entity.new.set_id(STR)
       message.set_destination('GameMachine.TestActor')
-      puts timed = Benchmark.realtime {
+      puts  Benchmark.realtime {
         10.times do
           Endpoints::MonoGateway.find.tell(message)
         end

data/spec/reliable_message_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module GameMachine
+
+  describe "Reliable Messages" do
+    let(:id) {'1'}
+    let(:game_message) do
+      MessageLib::GameMessage.new.set_message_id(id)
+    end
+
+    subject do
+      ref = Actor::Builder.new(GameSystems::Devnull).with_name('devnull').test_ref
+      ref.underlying_actor
+    end
+
+    before(:each) do
+      JavaLib::GameActor.remove_reliable_message(id)
+      subject.set_player_id('player')
+    end
+
+    describe "#exactly_once" do
+      it "should return true exactly once" do
+        expect(subject.exactly_once(game_message)).to be_truthy
+        expect(subject.exactly_once(game_message)).to be_falsy
+      end
+    end
+
+    describe "#set_reply" do
+      it "should return false if message not yet delivered" do
+        expect(subject.set_reply(game_message)).to be_falsy
+      end
+
+      it "should return true if message delivered" do
+        subject.exactly_once(game_message)
+        expect(subject.set_reply(game_message)).to be_truthy
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 
 ENV['APP_ROOT'] ||= File.expand_path(Dir.pwd)
-ENV['JAVA_ROOT'] = File.join(ENV['APP_ROOT'],'java')
+ENV['JAVA_ROOT'] = File.join(ENV['APP_ROOT'],'java','project')
 ENV['GAME_ENV'] = 'test'
 require 'rubygems'
 
@@ -12,17 +12,17 @@ end
 
 RSpec.configure do |config|
   config.before(:suite) do
-    GameMachine::Application.initialize!('default',true)
+    GameMachine::Application.initialize!
   end
 
   config.before(:each) do
-    GameMachine::AuthHandlers::Base.instance
+    GameMachine::AppConfig.instance.load_config
     GameMachine::Application.create_grids
     GameMachine::Application.start_actor_system
     GameMachine::Application.start_core_systems
     GameMachine::Application.start_handlers
     #GameMachine::Application.start_game_systems
-    GameMachine::GameLoader.new.load_all
+    
   end
 
   config.after(:each) do

data/spec/spec_helper_minimal.rb

@@ -0,0 +1,10 @@
+ENV['APP_ROOT'] ||= File.expand_path(Dir.pwd)
+ENV['JAVA_ROOT'] = File.join(ENV['APP_ROOT'],'java','project')
+ENV['GAME_ENV'] = 'test'
+require 'rubygems'
+
+begin
+  require 'game_machine'
+rescue LoadError
+  require_relative '../lib/game_machine'
+end

data/web/app.rb

@@ -1,131 +1,153 @@
 require 'json'
 require 'sinatra/base'
-require 'sinatra/multi_route'
-
-require_relative 'controllers/base_controller'
-require_relative 'controllers/index_controller'
-require_relative 'controllers/messages_controller'
-require_relative 'controllers/auth_controller'
-require_relative 'controllers/log_controller'
-require_relative 'controllers/player_register_controller'
+require 'rack-flash'
 
 
 class WebApp < Sinatra::Base
-  CONTROLLERS = {}
-  set :bind, GameMachine::Application.config.http_host
-  set :port, GameMachine::Application.config.http_port
+  set :bind, GameMachine::Application.config.http.host
+  set :port, GameMachine::Application.config.http.port
   set :root, File.expand_path(File.dirname(__FILE__))
   set :environment, :development
   mime_type :proto, 'application/octet-stream'
+  set :server, :puma
 
-  register Sinatra::MultiRoute
+  enable :sessions
+  set :session_secret, 'dsf5785sadf86876asdf6'
+  use Rack::Flash
 
-  def base_uri
-    host =  GameMachine::Application.config.http_host
-    port = GameMachine::Application.config.http_port
-    "http://#{host}:#{port}"
-  end
+  helpers do
 
-  def controller(name)
-    case name
-    when :index
-      CONTROLLERS[name] ||= Web::Controllers::IndexController.new
-    when :auth
-      CONTROLLERS[name] ||= Web::Controllers::AuthController.new
-    when :messages
-      CONTROLLERS[name] ||= Web::Controllers::MessagesController.new
-    when :log
-      CONTROLLERS[name] ||= Web::Controllers::LogController.new
-    when :player_register
-      CONTROLLERS[name] ||= Web::Controllers::PlayerRegisterController.new
+    def config
+      GameMachine::Application.config
     end
-  end
 
+    def logged_in?
+      session['user']
+    end
 
-  get '/player_register' do
-    @content = {}
-    haml :player_register, :layout => :register_layout
-  end
+    def admin_user
+      config.admin.user
+    end
 
-  post '/player_register.html' do
-    @content = controller(:player_register).set_request(request,params).create
-    if @content['error']
-      haml :player_register, :layout => :register_layout
-    else
-      haml :player_registered, :layout => :register_layout
+    def admin_pass
+      config.admin.pass
     end
+
+    def auth_response(token)
+      response = {
+        :authtoken => token,
+        :protocol => config.client.protocol
+      }
+
+      if config.client.protocol == 'TCP'
+        response['tcp_host'] = config.tcp.host
+        response['tcp_port'] = config.tcp.port
+      elsif config.client.protocol == 'UDP'
+        response['udp_host'] = config.udp.host
+        response['udp_port'] = config.udp.port
+      end
+      response
+    end
+
   end
 
-  post '/player_register.json' do
-    content = controller(:player_register).set_request(request,params).create
-    JSON.generate(content)
+  before do
+    allow = false
+    public = ['/client','/login','/clusterinfo']
+    public.each do |path|
+      if request.path_info.match(path)
+        allow = true
+      end
+    end
+
+    if !allow && !logged_in?
+      redirect to('/login')
+    end
   end
 
   get '/' do
-    if request.params['restarted']
-      @restarted = true
+    erb :index
+  end
+
+  get '/login' do
+    erb :login
+  end
+
+  post '/login' do
+    if params['username'] == admin_user && params['password'] == admin_pass
+      flash[:notice] = "Logged in"
+      session['user'] = true
+      redirect to('/')
+    else
+      flash[:error] = "Invalid username or password"
+      redirect to("/login")
     end
-    haml :index
   end
 
-  get '/alive' do
-    JSON.generate({})
+  get '/players/:id/delete' do
+    GameMachine::MessageLib::Player.store_delete('players',params['id'])
+    redirect to('/players')
   end
 
-  get '/restart' do
-    haml :restart
+  post '/players' do
+    scope,query_string = params['query_string'].split('##')
+    if query_string.nil?
+      query_string = ''
+    end
+    @players = GameMachine::DataStore.instance.query(scope,query_string,200,'Player')
+    @form_query = scope + '##' + query_string
+    erb :players
   end
 
-  get '/logs' do
-    @logtypes = {
-      :app => 'Application',
-      :stdout => 'Standard out',
-      :stderr => 'Standard error'
-    }
-    @logtype = (params['logtype'] || 'app').to_sym
-    @content = controller(:log).set_request(request,params).logs(@logtype)
-    haml :logs
+  get '/players' do
+    @players = GameMachine::DataStore.instance.query("players",'',200,'Player')
+    erb :players
   end
 
-  get '/messages/game' do
-    @content = controller(:messages).set_request(request,params).game
-    @messages = :game
-    haml :game_messages
+  get '/add_player' do
+    erb :add_player
   end
 
-  post '/messages/game' do
-    @content = controller(:messages).set_request(request,params).update
-    if @content == 'restart'
-      haml :restart
+  post '/add_player' do
+    if player = GameMachine::MessageLib::Player.store_get('players',params['username'],500)
+      flash[:error] = "Error creating player (already exists?)"
     else
-      @messages = :game
-      haml :game_messages
+      player = GameMachine::MessageLib::Player.new.set_id(params['username'])
+      authenticator = GameMachine::JavaLib::DefaultAuthenticator.new(player)
+      authenticator.set_password(params['password'])
+      flash[:notice] = "Player created"
     end
+    redirect to('/')
   end
 
-  get '/messages/all' do
-    @content = controller(:messages).set_request(request,params).all
-    @messages = :all
-    @format = params['format']
-    if @format == 'proto'
-      content_type :proto
-      attachment 'messages.proto'
-      @content
-    else
-      haml :game_messages
+  get '/clusterinfo' do
+    info = {}
+    info[:members] = {}
+    GameMachine::ClusterMonitor.cluster_members.keys.each do |key|
+      member = GameMachine::ClusterMonitor.cluster_members[key]
+      info[:members][key] = {:address => member.address, :status => member.status}
     end
+    info[:self_address] = GameMachine::Akka.instance.address
+
+    JSON.generate(info)
   end
 
-  route :get, :post, '/auth' do
-    res = controller(:auth).set_request(request,params).get
-    if res == 'error'
-      status 403
-      body res
+  post '/api/client/login/:game_id' do
+    if authtoken = GameMachine::Handlers::PlayerAuthentication.instance.authorize(params['username'],params['password'])
+      content_type 'text/plain'
+      JSON.generate(auth_response(authtoken))
     else
-      res
+      status 403
+      'error'
     end
   end
+
+  get '/stats' do
+    @stats = {}
+    @stats[:local_player_count] = GameMachine::ClientManager.local_players.size
+    @stats[:local_players] = GameMachine::ClientManager.local_players
+  end
+  
 end
 
 WebApp.run!
-