game_machine 0.0.8

data/lib/game_machine/actor/factory.rb

@@ -0,0 +1,35 @@
+module GameMachine
+  module Actor
+
+    class Factory
+      include JavaLib::IActorFactory
+
+      def initialize(klass,args)
+        @klass = klass
+        @args = args
+      end
+
+      def create
+        if @klass.respond_to?(:reload_on_change?)
+          if @klass.reload_on_change?
+            GameMachine.logger.info "Checking if #{@klass.name} should be reloaded"
+            GameMachine::Actor::Reloadable.reload_if_changed(@klass.name)
+            @klass = @klass.name.constantize
+          end
+        end
+        actor = @klass.new
+        if actor.respond_to?(:initialize_states)
+          actor.initialize_states
+        end
+        if actor.respond_to?(:post_init)
+          actor.post_init(*@args)
+        end
+        actor
+      end
+
+      def self.create
+      end
+
+    end
+  end
+end

data/lib/game_machine/actor/mono_actor.rb

@@ -0,0 +1,89 @@
+require 'base64'
+module GameMachine
+  module Actor
+    class MonoActor < Base
+
+      def self.images
+        @@images ||= java.util.concurrent.ConcurrentHashMap.new
+      end
+
+      def self.call_mono(message,image,domain,namespace,klass)
+        thread_id = JRuby.reference(Thread.current).native_thread.id
+        #Mono.attach_current_thread(domain)
+        bytes = message.to_byte_array
+        byte_string = bytes.to_s
+        encoded_bytes = Base64.encode64(byte_string)
+        encoded_bytes_size = encoded_bytes.size
+        actor_id = thread_id.to_s
+        if actor_id == '' or actor_id.nil?
+          puts "actor_id invalid #{actor_id}"
+          return
+        end
+
+        ns_mem_buf = FFI::MemoryPointer.new(:string, namespace.size)
+        ns_mem_buf.put_string(0, namespace)
+        klass_mem_buf = FFI::MemoryPointer.new(:string, klass.size)
+        klass_mem_buf.put_string(0, klass)
+        bytes_mem_buf = FFI::MemoryPointer.new(:string, encoded_bytes_size)
+        bytes_mem_buf.put_string(0, encoded_bytes)
+        mem_buf = FFI::MemoryPointer.new(:string, actor_id.size)
+        mem_buf.put_string(0, actor_id)
+
+        #puts "ENCODED #{encoded_bytes} = #{encoded_bytes_size}"
+        #res = Mono.ftest(@namespace,@klass,actor_id, encoded_bytes, encoded_bytes_size)
+        #puts 'before_on_receive'
+        res = Mono.on_receive2(domain,image,ns_mem_buf,klass_mem_buf,mem_buf, bytes_mem_buf, encoded_bytes_size)
+        #puts 'after_on_receive'
+        #res = Mono.on_receive(@mono_object,bytes.to_s,bytes.size)
+        if res == 0
+          raise "Mono managed code threw exception, restarting actor"
+        end
+      end
+
+      def post_init(*args)
+        @path = args[0]
+        @namespace = args[1]
+        @klass = args[2]
+        @domain = args[3]
+        @image = args[4]
+      end
+
+      def create_mono_object
+        @thread_id = JRuby.reference(Thread.current).native_thread.id
+        if @path.nil? or @namespace.nil? or @klass.nil?
+          raise "Missing post_init args"
+        end
+        Mono.attach_current_thread(@domain)
+        @image = Mono.load_assembly(@domain,@path)
+        #@mono_object = Mono.create_object(image,namespace,klass)
+        #if @mono_object == 0
+        #  raise "Mono.create_object failed"
+        #end
+      end
+
+      def ensure_image
+        thread_id = JRuby.reference(Thread.current).native_thread.id
+        image = self.class.images.fetch(thread_id,nil)
+        if image.nil?
+          Mono.attach_current_thread(@domain)
+          image = Mono.load_assembly(@domain,@path)
+          self.class.images[thread_id] = image
+        end
+        image
+      end
+
+      def postStop
+        puts 'postStop'
+        #Mono.destroy_object(@mono_object)
+      end
+
+      def on_receive(message)
+        Mono.attach_current_thread(@domain)
+
+        self.class.call_mono(message,@image,@domain,@namespace,@klass)
+        sender.tell(message,self)
+      end
+
+    end
+  end
+end

data/lib/game_machine/actor/ref.rb

@@ -0,0 +1,81 @@
+module GameMachine
+  module Actor
+
+    class Ref
+
+      def initialize(path_or_actor_ref,metric_name=nil)
+        @path_or_actor_ref = path_or_actor_ref
+        @metric_name = metric_name
+      end
+
+      def send_message(message,options={})
+        options = default_options.merge(options)
+        sender = sender_for(options[:sender])
+
+        if options[:blocking]
+          ask(message,options[:timeout])
+        else
+          tell(message,sender)
+          true
+        end
+      end
+
+      def actor
+        @actor ||= @path_or_actor_ref.is_a?(JavaLib::ActorRef) ? @path_or_actor_ref : actor_selection
+      end
+
+      def path
+        @path_or_actor_ref.is_a?(String) ? @path_or_actor_ref : nil
+      end
+
+      def tell(message,sender=nil)
+        message = convert_if_model(message)
+        actor.tell(message,sender_for(sender))
+        true
+      end
+
+      def ask(message,timeout)
+        message = convert_if_model(message)
+        duration = duration_in_ms(timeout)
+        t = JavaLib::Timeout.new(duration)
+        if actor.is_a?(JavaLib::ActorSelection)
+          sel = JavaLib::AskableActorSelection.new(actor)
+          future = sel.ask(message,t)
+        else
+          future = JavaLib::Patterns::ask(actor,message,t)
+        end
+        JavaLib::Await.result(future, duration)
+      rescue Java::JavaUtilConcurrent::TimeoutException => e
+        GameMachine.logger.debug("TimeoutException caught in ask (timeout = #{timeout})")
+        false
+      end
+
+      private
+
+      def convert_if_model(message)
+        if message.is_a?(GameMachine::Model)
+          message.to_entity
+        else
+          message
+        end
+      end
+
+      def duration_in_ms(ms)
+        JavaLib::Duration.create(ms, java.util.concurrent.TimeUnit::MILLISECONDS)
+      end
+
+      def sender_for(sender)
+        @sender_for ||= sender.is_a?(Actor::Base) ? sender.get_self : sender
+      end
+
+      def default_options
+        {:sender => nil, :timeout => 100, :blocking => false}
+      end
+
+      def actor_selection
+        Akka.instance.actor_system.actor_selection(@path_or_actor_ref)
+      end
+
+    end
+  end
+end

data/lib/game_machine/actor/reloadable.rb

@@ -0,0 +1,98 @@
+require 'set'
+module GameMachine
+  module Actor
+    class Reloadable
+
+      class << self
+
+        def paths
+          if @paths
+            @paths
+          else
+            @paths = java.util.concurrent.ConcurrentHashMap.new
+          end
+        end
+
+        def registered_actors
+          if @registered_actors
+            @registered_actors
+          else
+            @registered_actors = java.util.concurrent.ConcurrentHashMap.new
+          end
+        end
+
+        def register(name)
+          registered_actors[File.basename(name.underscore)] = name
+        end
+
+        def reload_actor(basename)
+          if klassname = registered_actors.fetch(basename,nil)
+            Base.find(klassname).tell('reload_because_changed')
+          end
+        end
+
+        def update_paths(first_run=false)
+          Dir.glob(File.join(GameLoader.games_root,'**','*.rb')).each do |file|
+            mtime = File.mtime(file)
+            basename = File.basename(file,'.rb')
+
+            # existing file
+            if fileinfo = paths.fetch(basename,nil)
+              if mtime != fileinfo[:mtime]
+                fileinfo[:changed] = true
+                fileinfo[:mtime] = mtime
+                GameMachine.logger.info "Game actor #{basename} changed"
+                reload_actor(basename)
+              end
+
+            # new file
+            else
+              File.open(file,'rb') do |f|
+                str = f.read
+                if str.match(/Actor\:\:Development/)
+                  fileinfo = {:changed => true, :file => file, :mtime => mtime}
+                  if first_run
+                    fileinfo[:changed] = false
+                  end
+                  GameMachine.logger.info "Game actor #{basename} added to watch list changed=#{fileinfo[:changed]}"
+                  paths[basename] = fileinfo
+                end
+              end
+            end
+
+          end
+        end
+
+        def actor_changed?(name)
+          path = File.basename(name.underscore)
+          if fileinfo = paths.fetch(path,nil)
+            if fileinfo[:changed]
+              return true
+            end
+          end
+          false
+        end
+
+        def reload_if_changed(name)
+          filename = File.basename(name.underscore)
+          if fileinfo = paths.fetch(filename,nil)
+            if fileinfo[:changed]
+              GameMachine.logger.info "Reloading #{name} (#{fileinfo[:file]})"
+              path = fileinfo[:file]
+              klassname = name.split('::').last
+              module_name = name.sub("::#{klassname}",'')
+              module_name.constantize.send(:remove_const,klassname.to_sym)
+              load "#{path}"
+              fileinfo[:changed] = false
+            else
+              GameMachine.logger.info "Not reloading #{name} as it has not changed"
+            end
+          else
+            GameMachine.logger.info "#{filename} not found in watch list"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/game_machine/actor/system.rb

@@ -0,0 +1,32 @@
+module GameMachine
+  module Actor
+
+    class System
+
+      attr_reader :name, :actor_system
+      def initialize(name,config_str)
+        @config_str = config_str
+        @name = name
+      end
+
+      def address
+        actor_system.to_string
+      end
+
+      def config
+        @config ||= JavaLib::ConfigFactory.parseString(@config_str).
+          getConfig(name).withFallback(JavaLib::ConfigFactory.load)
+      end
+
+      def create!
+        @actor_system ||= JavaLib::ActorSystem.create(name, config)
+      end
+
+      def shutdown!
+        actor_system.shutdown
+        actor_system.await_termination
+      end
+
+    end
+  end
+end

data/lib/game_machine/akka.rb

@@ -0,0 +1,98 @@
+require 'singleton'
+module GameMachine
+  class Akka
+    include Singleton
+    extend Forwardable
+
+    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
+      "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])
+    end
+
+    def init_cluster!(address)
+      @address = address
+      @hashring = Hashring.new([address])
+    end
+
+    def cluster?
+      app_config.config.cluster ? true : false
+    end
+
+    def actor_system
+      @actor_system.actor_system
+    end
+
+    def config_name
+      cluster? ? 'cluster' : 'standalone'
+    end
+
+    def akka_config
+      cluster? ? akka_cluster_config : akka_server_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
+    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
+    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}\""
+      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")
+        )
+      )
+    end
+
+    def start_camel_extension
+      if app_config.config.http_enabled
+        camel = JavaLib::CamelExtension.get(Akka.instance.actor_system)
+        camel_context = camel.context
+      end
+    end
+
+  end
+end

data/lib/game_machine/app_config.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+require_relative 'settings'
+module GameMachine
+  class AppConfig
+    include Singleton
+
+    attr_reader :config
+
+    def initialize
+      @config = OpenStruct.new
+    end
+
+    def reload
+      @config = OpenStruct.new
+      load_config
+    end
+
+    def server_config(server)
+      Settings.servers.send(server)
+    end
+
+    def set_defaults
+      unless config.request_handler_routers
+        config.request_handler_routers = 10
+      end
+      unless config.game_handler_routers
+        config.game_handler_routers = 10
+      end
+      unless config.udp_routers
+        config.udp_routers = 10
+      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