game_machine 0.0.8

data/lib/game_machine/application.rb

@@ -0,0 +1,181 @@
+module GameMachine
+  class Application
+
+    class << self
+
+      def initialize!(name='default', cluster=false)
+        AppConfig.instance.load_config(name)
+        config.cluster = cluster
+        akka.initialize!
+      end
+
+      def auth_handler
+        AuthHandlers::Base.instance
+      end
+
+      def data_store
+        DataStore.instance
+      end
+
+      def akka
+        Akka.instance
+      end
+
+      def config
+        @config ||= AppConfig.instance.config
+      end
+
+      def registered
+        @@registered ||= Set.new
+      end
+
+      def register(system_class)
+        registered << system_class
+        GameMachine.logger.debug "#{system_class} registered"
+      end
+
+      def start_actor_system
+        akka.start
+      end
+
+      def stop_actor_system
+        akka.stop
+      end
+
+      def stop
+        stop_actor_system
+        DataStore.instance.shutdown
+      end
+
+      def start
+        create_grids
+        game_preload
+        GameMachine::Actor::Reloadable.update_paths(true)
+        start_actor_system
+        data_store
+        start_endpoints
+        start_core_systems
+        start_handlers
+
+        if GameMachine.env == 'development'
+          start_development_systems
+        end
+
+        start_game_systems
+        GameLoader.new.load_all
+        auth_handler
+        start_mono
+
+        GameMachine.stdout("Game Machine start successful")
+
+        # This call blocks, make it the last thing we do
+        if config.http_enabled
+          start_http
+        end
+      end
+
+      def create_grids
+        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
+      end
+
+      def start_http
+        require_relative '../../web/app'
+      end
+
+      def start_mono
+        if config.mono_enabled
+          GameMachine.logger.info "Starting mono server"
+          MonoServer.new.run!
+        end
+      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}"
+          )
+        end
+
+        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}"
+          #)
+        end
+
+      end
+
+      def start_handlers
+        Actor::Builder.new(Handlers::Request).with_router(
+          JavaLib::RoundRobinRouter,config.request_handler_routers
+        ).start
+        Actor::Builder.new(Handlers::Game).with_router(
+          JavaLib::RoundRobinRouter,config.game_handler_routers
+        ).start
+      end
+
+      def start_development_systems
+      end
+
+      # TODO configurize router sizes
+      def start_core_systems
+        Actor::Builder.new(ClusterMonitor).start
+        Actor::Builder.new(ObjectDb).distributed(2).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(ClientManager).start
+        Actor::Builder.new(GameSystems::EntityLoader).start
+        Actor::Builder.new(SystemStats).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 ENV.has_key?('RESTARTABLE')
+          GameMachine.logger.info "restartable=true.  Will respond to tmp/gm_restart.txt"
+          Actor::Builder.new(RestartWatcher).start
+        end
+      end
+
+      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::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::ChatManager).start
+      end
+
+    end
+  end
+end

data/lib/game_machine/auth_handlers/base.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+
+module GameMachine
+  module AuthHandlers
+    class Base
+      include Singleton
+      extend Forwardable
+
+      def_delegators :@handler, :authorize, :authtoken_for
+
+      def initialize
+        @handler = Application.config.auth_handler.constantize.new
+      end
+
+      def set_handler(handler_name)
+        @handler = handler_name.constantize.new
+      end
+    end
+  end
+end
+

data/lib/game_machine/auth_handlers/public.rb

@@ -0,0 +1,34 @@
+require 'digest/md5'
+module GameMachine
+  module AuthHandlers
+    class Public
+
+      def initialize
+        @sessions = {}
+      end
+
+      def add_user(username,authtoken)
+        @sessions[username] = authtoken
+      end
+
+      def authorize(user,pass)
+        authtoken(user,'public')
+      end
+
+      def authtoken_for(user)
+        if @sessions.has_key?(user)
+          @sessions[user]
+        else
+          @sessions[user] = authtoken(user,'public')
+        end
+      end
+
+      private
+
+      def authtoken(user,pass)
+        Digest::MD5.hexdigest("#{user}#{pass}#{rand(10000)}")
+      end
+    end
+  end
+end
+

data/lib/game_machine/bot/chat.rb

@@ -0,0 +1,66 @@
+module GameMachine
+  module Bot
+    class Chat < Actor::Base
+
+      CHAT_CHANNELS = ['region','global','help','group1']
+
+      def post_init(*args)
+        @client = args.first
+        @ctx = args[1]
+        @player_id = args[2]
+        @scheduler = get_context.system.scheduler
+        @dispatcher = get_context.system.dispatcher
+        #login
+        join_chat_groups
+        #schedule_activities
+        #echo
+      end
+
+      
+      def schedule_activities
+        sleep(rand(10))
+        duration = JavaLib::Duration.create(rand(10) + 1, java.util.concurrent.TimeUnit::SECONDS)
+        @scheduler.schedule(duration, duration, get_self, "send_chat_message", @dispatcher, nil)
+      end
+
+      def echo
+        message = GameMachine::Helpers::GameMessage.new(@player_id)
+        message.echo_test('testing')
+        send_to_server(message)
+      end
+
+      def login
+        message = GameMachine::Helpers::GameMessage.new(@player_id)
+      end
+
+      def send_to_server(message)
+        @client.send_to_server(message.client_message.to_byte_array,@ctx)
+      end
+
+      def join_chat_groups
+        message = GameMachine::Helpers::GameMessage.new(@player_id)
+        CHAT_CHANNELS.each do |name|
+          message.join_chat(name)
+        end
+        send_to_server(message)
+      end
+
+
+      def send_chat_message
+        message = GameMachine::Helpers::GameMessage.new(@player_id)
+        CHAT_CHANNELS.each do |name|
+          message.chat_message('group','testing',name)
+        end
+        send_to_server(message)
+      end
+
+      def on_receive(message)
+        if message == 'send_chat_message'
+          send_chat_message
+        else
+        end
+      end
+
+    end
+  end
+end

data/lib/game_machine/bot/client.rb

@@ -0,0 +1,54 @@
+module GameMachine
+  module Bot
+    class Client < Actor::Base
+
+      def self.start_udt_client(name,port)
+        UdtClient.start(name,'localhost',port)
+      end
+
+      def self.start(name,port)
+        Actor::Builder.new(self).with_name(name).start
+        client = start_udt_client(name,port)
+        master_ref = self.find(name)
+        master_ref.tell(client)
+        ctx = nil
+        loop do
+         ctx = master_ref.ask('ctx',10)
+         break if ctx
+        end
+        master_ref.tell('start_players')
+      end
+
+      def post_init(*args)
+        @client = nil
+        @ctx = nil
+      end
+
+      def start_player
+        name = "player#{@player_id}"
+        child = Actor::Builder.new(Bot::Chat,@client,@ctx,name,@player_id).with_parent(context).with_name(name).start
+        @player = child
+      end
+
+      def on_receive(message)
+        if message.is_a?(JavaLib::DefaultChannelHandlerContext)
+          @ctx = message
+        elsif message.is_a?(UdtClient)
+          @client = message
+        elsif message == 'ctx'
+          sender.tell(@ctx) if @ctx
+        elsif message == 'start_players'
+          GameMachine.logger.info "#{@player_id} started"
+          #start_player
+          player_id = rand(10000).to_s
+          m = GameMachine::Helpers::GameMessage.new(player_id)
+          m.player_logout
+          @client.send_to_server(m.to_byte_array,@ctx)
+        else
+          client_message = ClientMessage.parse_from(message.bytes)
+          #@player.tell(client_message,get_self)
+        end
+      end
+    end
+  end
+end

data/lib/game_machine/client_manager.rb

@@ -0,0 +1,204 @@
+
+module GameMachine
+  class ClientManager < Actor::Base
+    attr_reader :local_actors, :remote_clients, :local_clients, :channel, :players, :client_to_player
+
+    def self.local_players
+      if @local_players
+        @local_players
+      else
+        @local_players = java.util.concurrent.ConcurrentHashMap.new
+      end
+    end
+
+    # Includes region + combined.
+    def self.local_connections
+      local_players.select {|player_id,type| type != 'cluster'}
+    end
+
+    # Cluster only connections.  We should not be handling things like
+    # entity tracking for this type of connection.  This is for stuff that is
+    # not latency sensitive such as chat, groups, etc..
+    def self.cluster_connections
+      local_players.select {|player_id,type| type == 'cluster'}
+    end
+
+    def self.send_to_player(message)
+      if local_players.has_key?(message.player.id)
+        Actor::Base.find(message.player.id).tell(message)
+      else
+        find.tell(message)
+      end
+    end
+
+    def post_init(*args)
+      @server = Application.config.name
+      @channel = 'client_events'
+      @local_actors = {}
+      @remote_clients = {}
+      @local_clients = {}
+      @players = {}
+      @client_to_player = {}
+      subscribe(channel)
+      ClusterMonitor.find.tell('notify_on_up')
+      @cluster = JavaLib::Cluster.get(getContext.system)
+    end
+
+    def on_receive(message)
+
+      if message.is_a?(MessageLib::Entity)
+
+        # Outgoing message to player
+        if message.send_to_player
+          send_to_remote_player(message)
+
+        # client events come from other client managers
+        elsif message.has_client_event
+          if message.client_event.sender_id.match(/#{@server}/)
+            return
+          end
+          process_client_event(message.client_event)
+        
+        # Unregister requests come from clients only
+        elsif message.has_client_manager_unregister
+          unregister_sender(message)
+
+        # Register requests come from actors and clients
+        elsif message.has_client_manager_register
+          register_sender(message)
+        else
+          unhandled(message)
+        end
+      elsif message.is_a?(JavaLib::ClusterEvent::MemberUp)
+        update_new_member(address)
+      else
+        unhandled(message)
+      end
+    end
+
+    # TODO have the remote ack this, and resend it periodically until we get ack
+    def update_new_member(message)
+      client_events = MessageLib::ClientEvents.new
+      client_to_player.each do |client_id,player_id|
+        client_events.add_client_event(
+          create_client_event(client_id,player_id,'connected')
+        )
+      end
+      entity = MessageLib::Entity.new.set_id('0').set_client_events(client_events)
+      remote_ref = Actor::Base.find_remote(message.member.address.to_string,self.class.name)
+      remote_ref.tell(entity,get_self)
+    end
+
+    def send_to_remote_player(message)
+      if client_id = players.fetch(message.player.id,nil)
+        if remote_ref = remote_clients.fetch(client_id,nil)
+          remote_ref.tell(message)
+        end
+      end
+    end
+
+    def sender_id_to_actor_ref(sender_id)
+      server,name = sender_id.split('|')
+      Actor::Base.find_remote(server,name)
+    end
+
+    def process_client_event(client_event)
+      if client_event.event == 'disconnected'
+        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")
+      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")
+      end
+    end
+
+    def cluster_connection?(client_connection)
+      case client_connection.type
+      when 'cluster'
+        true
+      when 'combined'
+        true
+      else
+        false
+      end
+    end
+
+    def unregister_sender(message)
+      unregister_msg = message.client_manager_unregister
+      register_type = unregister_msg.register_type
+      name = unregister_msg.name
+      if register_type == 'client'
+        if cluster_connection?(message.client_connection)
+          send_client_event(name,message.player.id,'disconnected')
+        end
+
+        # Notify registered actors using a client manager event
+        send_client_manager_event(name,message.player.id,'disconnected')
+
+        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")
+      end
+    end
+
+    def register_sender(message)
+      register_msg = message.client_manager_register
+      register_type = register_msg.register_type
+      name = register_msg.name
+      events = register_msg.events
+
+      # Client register
+      if register_type == 'client'
+        if cluster_connection?(message.client_connection)
+          send_client_event(name,message.player.id,'connected')
+        end
+        local_clients[name] = message.client_connection
+        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")
+      # Actor register
+      elsif register_type == 'actor'
+        local_actors[name] = events
+      end
+    end
+
+
+    def send_client_manager_event(client_id,player_id,event)
+      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)
+      end
+    end
+
+    def create_client_manager_event(client_id,player_id,event)
+      client_manager_event = MessageLib::ClientManagerEvent.new.
+        set_client_id(client_id).set_player_id(player_id).set_event(event)
+    end
+
+    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)
+    end
+
+    def send_client_event(client_id,player_id,event)
+      client_event = create_client_event(client_id,player_id,event)
+      entity = MessageLib::Entity.new.set_id('0').set_client_event(client_event)
+      publish = MessageLib::Publish.new
+      publish.set_topic(channel).set_message(entity)
+      MessageQueue.find.tell(publish,get_self)
+    end
+
+    def subscribe(topic)
+      message = MessageLib::Subscribe.new.set_topic(topic)
+      MessageQueue.find.tell(message,get_self)
+    end
+  end
+end