game_machine 0.0.11 → 1.0.2

data/lib/game_machine/akka.rb

@@ -6,25 +6,21 @@ module GameMachine
 
     attr_reader :hashring, :address, :app_config
 
-    def self.address_for(server)
-      host = AppConfig.instance.server_config(server).akka_host
-      port = AppConfig.instance.server_config(server).akka_port
+    def self.address
+      host = AppConfig.instance.config.akka.host
+      port = AppConfig.instance.config.akka.port
       "akka.tcp://#{Akka.instance.config_name}@#{host}:#{port}"
     end
 
     def initialize!
       @app_config = AppConfig.instance
-      @address = self.class.address_for(app_config.config.name)
-      @hashring = Hashring.new([@address])
+      @address = self.class.address
+      @hashring = JavaLib::Hashring.new('servers',[address],3)
     end
 
     def init_cluster!(address)
       @address = address
-      @hashring = Hashring.new([address])
-    end
-
-    def cluster?
-      app_config.config.cluster ? true : false
+      @hashring = JavaLib::Hashring.new('servers',[address],3)
     end
 
     def actor_system
@@ -32,54 +28,52 @@ module GameMachine
     end
 
     def config_name
-      cluster? ? 'cluster' : 'standalone'
+      'cluster'
     end
 
     def akka_config
-      cluster? ? akka_cluster_config : akka_server_config
+      config = load_akka_config(config_name)
+      config = set_address(config)
+      config = set_seeds(config)
     end
 
     def start
       @actor_system = Actor::System.new(config_name,akka_config)
       @actor_system.create!
-      JavaLib::GameMachineLoader.new.run(actor_system,Application.config.game_handler)
-      #start_camel_extension
+      JavaLib::GameMachineLoader.new.run(actor_system)
+      if Application.config.seeds.size >= 1
+        Application.config.seeds.each do |seed|
+          host,port = seed.split(':')
+          GameMachine.logger.info "JOINING REMOTE #{host} #{port}"
+          JavaLib::ActorUtil.joinCluster("akka.tcp", config_name, host, port.to_i)
+        end
+      else
+        GameMachine.logger.info "JOINING SELF"
+        JavaLib::ActorUtil.joinCluster("akka.tcp", config_name, app_config.config.akka.host, app_config.config.akka.port)
+      end
     end
 
     def stop
       @actor_system.shutdown!
-      Actor::Base.reset_hashrings
     end
 
     private
 
     def set_address(config)
-      config.sub!('HOST',app_config.config.akka_host)
-      config.sub!('PORT',app_config.config.akka_port.to_s)
+      config.sub!('HOST',app_config.config.akka.host)
+      config.sub!('PORT',app_config.config.akka.port.to_s)
       config
     end
 
     def set_seeds(config)
-      seeds = Application.config.seeds.map do |seed| 
-        seed_host = app_config.server_config(seed).akka_host
-        seed_port = app_config.server_config(seed).akka_port
-        "\"akka.tcp://cluster@#{seed_host}:#{seed_port}\""
+      seeds = Application.config.seeds.map do |seed|
+        host,port = seed.split(':')
+        "\"akka.tcp://cluster@#{host}:#{port}\""
       end
       config.sub!('SEEDS',seeds.join(','))
       config
     end
 
-    def akka_cluster_config
-      config = load_akka_config('cluster')
-      config = set_address(config)
-      config = set_seeds(config)
-    end
-
-    def akka_server_config
-      config = load_akka_config('standalone')
-      config = set_address(config)
-    end
-
     def load_akka_config(name)
       File.read(File.expand_path(File.join(
           GameMachine.app_root,"config/#{name}.conf")

data/lib/game_machine/app_config.rb

@@ -1,49 +1,62 @@
 require 'singleton'
-require_relative 'settings'
+require_relative 'hocon_config'
 module GameMachine
   class AppConfig
     include Singleton
 
-    attr_reader :config
+    attr_reader :config, :loaded
 
     def initialize
+      @loaded = false
       @config = OpenStruct.new
     end
 
-    def reload
-      @config = OpenStruct.new
-      load_config
+    def load_config
+      @config = HoconConfig.config
+      if ENV['NODE_HOST']
+        set_config_from_env
+      end
+      @loaded = true
     end
 
-    def server_config(server)
-      Settings.servers.send(server)
-    end
+    def set_config_from_env
+      GameMachine.logger.info "Setting config from ENV"
+      config.http.host = ENV['NODE_HOST']
+      config.http.port = ENV['WWW_PORT'].to_i
+
+      config.tcp.host = ENV['NODE_HOST']
+      config.tcp.port = ENV['TCP_PORT'].to_i
+
+      config.udp.host = ENV['NODE_HOST']
+      config.udp.port = ENV['UDP_PORT'].to_i
+
+      config.akka.host = ENV['NODE_HOST']
+      config.akka.port = ENV['AKKA_PORT'].to_i
 
-    def set_defaults
-      unless config.request_handler_routers
-        config.request_handler_routers = 10
+      if ENV['CLOUD_HOST'] && ENV['CLOUD_USER'] && ENV['API_KEY']
+        GameMachine.logger.info "Found gamecloud config in ENV"
+        config.gamecloud.host = ENV['CLOUD_HOST']
+        config.gamecloud.user = ENV['CLOUD_USER']
+        config.gamecloud.api_key = ENV['API_KEY']
       end
-      unless config.game_handler_routers
-        config.game_handler_routers = 10
+
+      if ENV['DB_HOST'] && ENV['DB_PORT']  && ENV['DB_NAME'] && ENV['DB_USER'] && ENV['DB_PASS']
+        GameMachine.logger.info "Found database config in ENV"
+        config.jdbc.hostname =  ENV['DB_HOST']
+        config.jdbc.port =      ENV['DB_PORT']
+        config.jdbc.database =  ENV['DB_NAME']
+        config.jdbc.username =  ENV['DB_USER']
+        config.jdbc.password =  ENV['DB_PASS']
       end
-      unless config.udp_routers
-        config.udp_routers = 10
+
+      if ENV['AKKA_SEED_HOST'] && ENV['AKKA_SEED_PORT']
+        GameMachine.logger.info "Found Seed in ENV"
+        Application.config.seeds << "#{ENV['AKKA_SEED_HOST']}:#{ENV['AKKA_SEED_PORT']}"
       end
-    end
 
-    def load_config(name)
-      config.name = name
-      set_defaults
-      load_settings(name)
     end
 
     private
 
-    def load_settings(name)
-      Settings.servers.send(name).each do |key,value|
-        config.send("#{key}=",value)
-      end
-    end
-
   end
 end

data/lib/game_machine/application.rb

@@ -3,16 +3,11 @@ module GameMachine
 
     class << self
 
-      def initialize!(name='default', cluster=false)
-        AppConfig.instance.load_config(name)
-        config.cluster = cluster
+      def initialize!
+        AppConfig.instance.load_config
         akka.initialize!
       end
 
-      def auth_handler
-        AuthHandlers::Base.instance
-      end
-
       def data_store
         DataStore.instance
       end
@@ -22,7 +17,7 @@ module GameMachine
       end
 
       def config
-        @config ||= AppConfig.instance.config
+        AppConfig.instance.config
       end
 
       def registered
@@ -51,12 +46,12 @@ module GameMachine
         create_grids
 
         unless GameMachine.env == 'test'
-          game_preload
           GameMachine::Actor::Reloadable.update_paths(true)
         end
 
         start_actor_system
         data_store
+        orm_connect
         start_endpoints
         start_core_systems
         start_handlers
@@ -66,19 +61,34 @@ module GameMachine
         end
 
         start_game_systems
-
-        unless GameMachine.env == 'test'
-          GameLoader.new.load_all
-        end
-
-        auth_handler
+        load_games
         start_mono
 
-        GameMachine.stdout("Game Machine start successful")
-
+        GameMachine.logger.info("Game Machine start successful")
+        
         # This call blocks, make it the last thing we do
-        if config.http_enabled
-          start_http
+        if config.http.enabled
+          Thread.new do
+            start_http
+          end
+        end
+      end
+
+      def orm_connect
+        if config.orm
+          pool = GameMachine::JavaLib::DbConnectionPool.getInstance
+          unless pool.connect(
+            'game_machine_orm',
+            config.jdbc.hostname,
+            config.jdbc.port,
+            config.jdbc.database,
+            config.jdbc.ds,
+            config.jdbc.username,
+            config.jdbc.password || ''
+          )
+            GameMachine.logger.error "Unable to establish database connection, exiting"
+            System.exit 1
+          end
         end
       end
 
@@ -86,12 +96,9 @@ module GameMachine
         Grid.load_from_config
       end
 
-      def game_preload
-        begin
-          require_relative '../../games/preload.rb'
-        rescue LoadError => e
-          GameMachine.logger.info "preload.rb not found"
-        end
+      def load_games
+        require_relative '../../games/routes.rb'
+        require_relative '../../games/boot.rb'
       end
 
       def start_http
@@ -106,40 +113,26 @@ module GameMachine
       end
 
       def start_endpoints
-        if config.mono_enabled
-          Actor::Builder.new(Endpoints::MonoGateway).start
-          GameMachine.stdout(
-            "MonoGateway starting on #{config.mono_gateway_host}:#{config.mono_gateway_port}"
-          )
-        end
-        if config.tcp_enabled
-          Actor::Builder.new(Endpoints::Tcp).start
-          GameMachine.stdout(
-            "Tcp starting on #{config.tcp_host}:#{config.tcp_port}"
+        if config.tcp.enabled
+          JavaLib::TcpServer.start(config.tcp.host, config.tcp.port);
+          GameMachine.logger.info(
+            "Tcp starting on #{config.tcp.host}:#{config.tcp.port}"
           )
         end
 
-        if config.udp_enabled
-          JavaLib::UdpServer.start(config.udp_host,config.udp_port)
+        if config.udp.enabled
+          JavaLib::UdpServer.start(config.udp.host,config.udp.port)
           Actor::Builder.new(Endpoints::UdpIncoming).with_router(
-            JavaLib::RoundRobinRouter,10).start
-
-          # Built in Akka udp. Performed badly we have more control by working
-          # directly with Netty
-          #Actor::Builder.new(Endpoints::Udp).start
-          #GameMachine.stdout(
-          #  "UDP starting on #{config.udp_host}:#{config.udp_port}"
-          #)
+            JavaLib::RoundRobinRouter,config.routers.udp).start
         end
-
       end
 
       def start_handlers
         Actor::Builder.new(Handlers::Request).with_router(
-          JavaLib::RoundRobinRouter,config.request_handler_routers
+          JavaLib::RoundRobinRouter,config.routers.request_handler
         ).start
         Actor::Builder.new(Handlers::Game).with_router(
-          JavaLib::RoundRobinRouter,config.game_handler_routers
+          JavaLib::RoundRobinRouter,config.routers.game_handler
         ).start
       end
 
@@ -148,24 +141,26 @@ module GameMachine
 
       # TODO configurize router sizes
       def start_core_systems
+        JavaLib::GameMachineLoader.StartMessageGateway
+        Actor::Builder.new(CloudUpdater).start
         Actor::Builder.new(ClusterMonitor).start
-        Actor::Builder.new(ObjectDb).distributed(2).start
+        Actor::Builder.new(ObjectDb).distributed(config.routers.objectdb).start
         Actor::Builder.new(MessageQueue).start
         Actor::Builder.new(SystemMonitor).start
         Actor::Builder.new(ReloadableMonitor).start
         Actor::Builder.new(Scheduler).start
-        Actor::Builder.new(WriteBehindCache).distributed(2).start
-        Actor::Builder.new(GridReplicator).start
+        Actor::Builder.new(WriteBehindCache).distributed(config.routers.objectdb).start
         Actor::Builder.new(ClientManager).start
-        Actor::Builder.new(GameSystems::EntityLoader).start
         Actor::Builder.new(SystemStats).start
+        Actor::Builder.new(GameSystems::RemoteEcho).with_router(JavaLib::RoundRobinRouter,config.routers.game_handler).start
 
-        # Our cluster singleton for managing regions
-        Actor::Builder.new(GameSystems::RegionManager).singleton
-
-        # Hands out current region info to clients/other actors
-        Actor::Builder.new(GameSystems::RegionService).start
+        if config.use_regions
+          # Our cluster singleton for managing regions
+          Actor::Builder.new(GameSystems::RegionManager).singleton
 
+          # Hands out current region info to clients/other actors
+          Actor::Builder.new(GameSystems::RegionService).start
+        end
 
         if ENV.has_key?('RESTARTABLE')
           GameMachine.logger.info "restartable=true.  Will respond to tmp/gm_restart.txt"
@@ -175,12 +170,11 @@ module GameMachine
 
       def start_game_systems
         Actor::Builder.new(GameSystems::Devnull).start#.with_router(JavaLib::RoundRobinRouter,4).start
-        Actor::Builder.new(GameSystems::ObjectDbProxy).with_router(JavaLib::RoundRobinRouter,4).start
-        Actor::Builder.new(GameSystems::EntityTracking).with_router(JavaLib::RoundRobinRouter,10).start
-        Actor::Builder.new(GameSystems::LocalEcho).with_router(JavaLib::RoundRobinRouter,2).start
+        Actor::Builder.new(GameSystems::ObjectDbProxy).with_router(JavaLib::RoundRobinRouter,2).start
+        JavaLib::GameMachineLoader.StartEntityTracking
+        Actor::Builder.new(GameSystems::LocalEcho).with_router(JavaLib::RoundRobinRouter,1).start
         Actor::Builder.new(GameSystems::LocalEcho).with_name('DistributedLocalEcho').distributed(2).start
-        Actor::Builder.new(GameSystems::RemoteEcho).with_router(JavaLib::RoundRobinRouter,10).start
-        Actor::Builder.new(GameSystems::StressTest).with_router(JavaLib::RoundRobinRouter,10).start
+        Actor::Builder.new(GameSystems::StressTest).with_router(JavaLib::RoundRobinRouter,1).start
         Actor::Builder.new(GameSystems::ChatManager).start
         Actor::Builder.new(GameSystems::TeamManager).start
         Actor::Builder.new(GameSystems::JsonModelPersistence).start

data/lib/game_machine/client_manager.rb

@@ -32,7 +32,7 @@ module GameMachine
     end
 
     def post_init(*args)
-      @server = Application.config.name
+      @server = Akka.instance.address
       @channel = 'client_events'
       @local_actors = {}
       @remote_clients = {}
@@ -40,7 +40,7 @@ module GameMachine
       @players = {}
       @client_to_player = {}
       subscribe(channel)
-      ClusterMonitor.find.tell('notify_on_up')
+      ClusterMonitor.find.tell('notify_on_up',get_self)
       @cluster = JavaLib::Cluster.get(getContext.system)
     end
 
@@ -50,7 +50,11 @@ module GameMachine
 
         # Outgoing message to player
         if message.send_to_player
-          send_to_remote_player(message)
+          if self.class.local_players.has_key?(message.player.id)
+            Actor::Base.find(message.player.id).tell(message)
+          else
+           send_to_remote_player(message)
+          end
 
         # client events come from other client managers
         elsif message.has_client_event
@@ -107,13 +111,13 @@ module GameMachine
         remote_clients.delete(client_event.client_id)
         client_to_player.delete(client_event.client_id)
         players.delete(client_event.player_id)
-        GameMachine.logger.info("#{self.class.name} client #{client_event.client_id} disconnected")
+        GameMachine.logger.debug("#{self.class.name} client #{client_event.client_id} disconnected")
       elsif client_event.event == 'connected'
         remote_ref = sender_id_to_actor_ref(client_event.sender_id)
         remote_clients[client_event.client_id] = remote_ref
         players[client_event.player_id] = client_event.client_id
         client_to_player[client_event.client_id] = client_event.player_id
-        GameMachine.logger.info("#{self.class.name} #{Application.config.name} client #{client_event.client_id} connected")
+        GameMachine.logger.debug("#{self.class.name} #{Application.config.name} client #{client_event.client_id} connected")
       end
     end
 
@@ -143,7 +147,7 @@ module GameMachine
         local_clients.delete(name)
         players.delete(message.player.id)
         self.class.local_players.delete(message.player.id)
-        GameMachine.logger.info("#{self.class.name} client #{name} unregistered")
+        GameMachine.logger.debug("#{self.class.name} client #{name} unregistered")
       end
     end
 
@@ -162,9 +166,10 @@ module GameMachine
         players[message.player.id] = name
         self.class.local_players[message.player.id] = message.client_connection.type
         get_sender.tell(message,get_self)
-        GameMachine.logger.info("#{self.class.name} client #{name} registered")
+        GameMachine.logger.debug("#{self.class.name} client #{name} registered")
       # Actor register
       elsif register_type == 'actor'
+        GameMachine.logger.debug "#{self.class.name} Actor #{name} registered"
         local_actors[name] = events
       end
     end
@@ -174,6 +179,7 @@ module GameMachine
       local_actors.each do |name,events|
         client_manager_event = create_client_manager_event(client_id,player_id,event)
         Actor::Base.find(name).tell(client_manager_event)
+        GameMachine.logger.info "#{self.class.name} Send #{event} to #{name}"
       end
     end
 
@@ -185,7 +191,7 @@ module GameMachine
     def create_client_event(client_id,player_id,event)
       client_event = MessageLib::ClientEvent.new.set_client_id(client_id).
         set_event(event).set_player_id(player_id)
-      client_event.set_sender_id(Application.config.name + '|' + self.class.name)
+      client_event.set_sender_id(Akka.instance.address + '|' + self.class.name)
     end
 
     def send_client_event(client_id,player_id,event)