game_machine 0.0.8

data/lib/game_machine/console/server.rb

@@ -0,0 +1,120 @@
+require 'optparse'
+module GameMachine
+  module Console
+    class Server
+
+      attr_reader :options
+      def initialize(argv)
+        @options = parse_arguments(argv)
+      end
+
+      def check_start_dir
+        java_dir = File.join(File.expand_path(Dir.pwd),'java')
+        unless File.directory?(java_dir)
+          puts "Please run game_machine from your game directory"
+          exit 0
+        end
+      end
+
+      def set_environment
+        ENV['GAME_ENV'] = options[:environment]
+        if options[:config]
+          ENV['CONFIG_FILE'] = options[:config]
+        end
+      end
+
+
+      def self.exit!
+        clear_restart_file
+        System.exit(0)
+      end
+
+      def self.ensure_tmp
+        tmp_path = File.join(ENV['APP_ROOT'],'tmp')
+        FileUtils.mkdir_p tmp_path
+      end
+
+      def self.restart?
+        File.exists?(restart_file)
+      end
+
+      def self.restart!
+        FileUtils.touch restart_file
+      end
+
+      def self.clear_restart_file
+        if File.exists?(restart_file)
+          FileUtils.rm(restart_file)
+        end
+      end
+
+      def self.restart_file
+        File.join(ENV['APP_ROOT'],'tmp','gm_restart.txt')
+      end
+
+      def self.run_in_loop
+        ensure_tmp
+        clear_restart_file
+
+        build_cmd = "jruby bin/game_machine build"
+        run_cmd = "jruby bin/game_machine s -r"
+        loop do
+          system(build_cmd)
+          system(run_cmd)
+        end
+      end
+
+      def run!
+        check_start_dir
+
+        GameMachine.logger.info "Starting with options = #{options.inspect}"
+        GameMachine::Application.initialize!(options[:server],true)
+        GameMachine::Application.start
+      end
+
+      def load_server_from_file
+        path = File.join(File.expand_path(Dir.pwd),'servername.txt')
+        if File.exists?(path)
+          return File.read(path).chomp
+        else
+          nil
+        end
+      end
+
+      def parse_arguments(arguments)
+        options = {}
+
+        OptionParser.new do |opt|
+          opt.banner = "Usage: game_machine server [options]"
+          opt.on('-r', '--restartable', 'If tmp/gm_restart.txt should trigger a restart') { |v| options[:restartable] = v }
+          opt.on('-s', '--server=name', String, 'Server name') { |v| options[:server] = v.strip }
+          opt.on('-c', '--config=name', String, 'Configuration file') { |v| options[:config] = v.strip }
+          opt.on("-e", "--environment=name", String,
+                  "Specifies the environment to run under (development/production).",
+                  "Default: development") { |v| options[:environment] = v.strip }
+          opt.parse!(arguments)
+        end
+        
+        if options.has_key?(:restartable)
+          ENV['RESTARTABLE'] = 'true'
+        end
+
+        unless options.has_key?(:environment)
+          options[:environment] = 'development'
+        end
+
+        unless options.has_key?(:server)
+          options[:server] = 'default'
+        end
+
+        if server = load_server_from_file
+          options[:server] = server
+          puts "server name #{server} set from servername.txt"
+        end
+
+        options
+      end
+
+    end
+  end
+end

data/lib/game_machine/data_store.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+require_relative 'data_stores/memory'
+require_relative 'data_stores/couchbase'
+require_relative 'data_stores/mapdb'
+require_relative 'data_stores/redis'
+
+module GameMachine
+  class DataStore
+    include Singleton
+    extend Forwardable
+
+    def_delegators :@store, :get, :set, :delete, :delete_all, :shutdown, :keys, :dump, :load
+
+    attr_reader :store
+    def initialize
+      @store_name = Application.config.data_store
+      connect
+    end
+
+    def set_store(store_name)
+      @store = nil
+      @store_name = store_name
+      connect
+    end
+
+    private
+
+    def connect
+      raise "already connected" if @store
+      send("connect_#{@store_name}")
+    end
+
+    def connect_couchbase
+      @store = DataStores::Couchbase.new
+      @store.connect
+    end
+
+    def connect_mapdb
+      @store = DataStores::Mapdb.new
+      @store.connect
+    end
+
+    def connect_redis
+      @store = DataStores::Redis.new
+      @store.connect
+    end
+
+    def connect_memory
+      @store = DataStores::Memory.new
+    end
+  end
+end

data/lib/game_machine/data_stores/couchbase.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+module GameMachine
+  module DataStores
+    class Couchbase
+      extend Forwardable
+
+      def_delegators :@client, :get, :set, :delete, :shutdown
+
+      def connect
+        @client ||= JavaLib::CouchbaseClient.new(servers, 'default'.to_java_string, ''.to_java_string)
+      end
+
+      def servers
+        Application.config.couchbase_servers.map {|server| java.net.URI.new(server)}
+      end
+    end
+  end
+end

data/lib/game_machine/data_stores/mapdb.rb

@@ -0,0 +1,49 @@
+require 'forwardable'
+
+module GameMachine
+  module DataStores
+    include_package 'org.mapdb'
+    class Mapdb
+      extend Forwardable
+
+      def_delegators :@client, :get
+
+      def shutdown
+        @client.close
+      end
+
+      def keys
+        @client.keys
+      end
+
+      def dump(path,format=:yaml)
+        raise NotImplementedError
+      end
+
+      def load(path,format=:yaml)
+        raise NotImplementedError
+      end
+
+      def set(key,value)
+        @client.put(key,value)
+        @db.commit
+      end
+
+      def dbfile
+        File.join(GameMachine.app_root,'db','mapdb.db')
+      end
+
+      def connect
+        unless @client
+          @db = DataStores::DBMaker.newFileDB(java.io.File.new(dbfile)).
+            closeOnJvmShutdown.
+            make
+          @client = @db.getTreeMap("entities")
+        end
+        @client
+      end
+
+    end
+  end
+end
+

data/lib/game_machine/data_stores/memory.rb

@@ -0,0 +1,35 @@
+module GameMachine
+  module DataStores
+    class Memory
+
+      def initialize
+        @data = {}
+      end
+
+      def set(key,value)
+        @data[key] = value
+      end
+
+      def get(key)
+        @data.fetch(key,nil)
+      end
+
+      def delete(key)
+        @data.delete(key)
+      end
+
+      def delete_all
+        @data = {}
+      end
+
+      def shutdown
+      end
+
+      private
+
+      def connect
+      end
+
+    end
+  end
+end

data/lib/game_machine/data_stores/redis.rb

@@ -0,0 +1,46 @@
+require 'forwardable'
+module GameMachine
+  module DataStores
+    class Redis
+      extend Forwardable
+
+      def connect
+        @pool = RedisLib::JedisPool.new(RedisLib::JedisPoolConfig.new, "localhost");
+      end
+
+      def delete(key)
+        query(:del,key)
+      end
+
+      def get(key)
+       query(:get,key)
+      end
+
+      def set(key,value)
+        query(:set,key, value)
+      end
+
+      def query(command,key,value=nil)
+        jedis = @pool.get_resource
+        case command
+        when :get
+          jedis.get(key)
+        when :set
+          res = jedis.set(key,value)
+          res == 'OK' ? true : false
+        when :del
+          res = jedis.del(key)
+          res == 1 ? true : false
+        end
+      rescue RedisLib::JedisConnectionException => e
+        @pool.return_broken_resource(jedis)
+      ensure
+        @pool.return_resource(jedis)
+      end
+
+      def shutdown
+        @pool.destroy
+      end
+    end
+  end
+end

data/lib/game_machine/endpoints.rb

@@ -0,0 +1,6 @@
+require_relative 'endpoints/tcp_handler'
+require_relative 'endpoints/udp'
+require_relative 'endpoints/tcp'
+require_relative 'endpoints/mono_gateway'
+require_relative 'endpoints/udp_incoming'
+require_relative 'endpoints/udp_outgoing'

data/lib/game_machine/endpoints/mono_gateway.rb

@@ -0,0 +1,87 @@
+module GameMachine
+  module Endpoints
+    class MonoGateway < Actor::Base
+
+      def post_init(*args)
+        @clients = {}
+        @sender = nil
+        @socket = nil
+        @mono_connected = false
+        @last_mono_ping = nil
+      end
+
+      def preStart
+        mgr = JavaLib::Udp.get(getContext.system).getManager
+        inet = JavaLib::InetSocketAddress.new(
+          Application.config.mono_gateway_host,
+          Application.config.mono_gateway_port
+        )
+        mgr.tell( JavaLib::UdpMessage.bind(getSelf,inet), getSelf)
+      end
+
+      def on_receive(message)
+        if message.kind_of?(JavaLib::Udp::Bound)
+          @socket = getSender
+        elsif message.is_a?(MessageLib::Entity)
+          handle_outgoing(message)
+        elsif message.kind_of?(JavaLib::Udp::Received)
+          handle_incoming(message)
+        elsif message == JavaLib::UdpMessage::unbind
+          @socket.tell(message, get_self)
+        elsif message.kind_of?(JavaLib::Udp::Unbound)
+          get_context.stop(get_self)
+        else
+          unhandled(message)
+        end
+      end
+
+      private
+
+      def handle_outgoing(message)
+        if message.has_destination
+          if @sender
+            byte_string = JavaLib::ByteString.from_array(message.to_byte_array)
+            udp_message = JavaLib::UdpMessage.send(byte_string, @sender)
+            @socket.tell(udp_message, get_self)
+          else
+            GameMachine.logger.error "#{self.class.name} cannot send outgoing message (no sender) "
+          end
+        else
+          GameMachine.logger.error "#{self.class.name} destination missing (outgoing)"
+        end
+      rescue Exception => e
+        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
+      end
+
+      def handle_incoming(message)
+        @sender = message.sender
+        entity = MessageLib::Entity.parse_from(message.data.to_array)
+        if entity.id == 'ping'
+          unless @mono_connected
+            GameMachine.logger.info "Mono server connected"
+          end
+          @mono_connected = true
+          @last_mono_ping = Time.now.to_i
+          echo(message)
+        elsif entity.has_destination
+          destination = entity.destination.sub(/^\//,'')
+          destination = destination.gsub('/','::')
+          entity.set_destination(nil)
+          GameMachine.logger.info "#{self.class.name} incoming to #{destination}"
+          Actor::Base.find(destination).tell(entity,get_self)
+        else
+          GameMachine.logger.error "#{self.class.name} destination missing (incoming)"
+        end
+      rescue Exception => e
+        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
+      end
+
+      def echo(message)
+        byte_string = JavaLib::ByteString.from_array(message.data.to_array)
+        udp_message = JavaLib::UdpMessage.send(byte_string, message.sender)
+        @socket.tell(udp_message,get_self)
+      end
+
+    end
+  end
+end

data/lib/game_machine/endpoints/tcp.rb

@@ -0,0 +1,51 @@
+module GameMachine
+  module Endpoints
+    class Tcp < Actor::Base
+
+      def post_init(*args)
+        @clients = {}
+        @mgr = nil
+      end
+
+      def preStart
+        @mgr = JavaLib::Tcp.get(getContext.system).getManager
+        inet = JavaLib::InetSocketAddress.new(
+          Application.config.tcp_host,
+          Application.config.tcp_port
+        )
+        @mgr.tell( JavaLib::TcpMessage.bind(getSelf,inet,100), getSelf)
+      end
+
+      def sanitize_address(name)
+        name.gsub!('/','')
+        name.gsub!('.','')
+        name.gsub!(':','_')
+        name
+      end
+
+      def on_receive(message)
+        if message.is_a?(MessageLib::ClientMessage)
+          if handler_ref = @clients.fetch(message.client_connection.id,nil)
+            handler_ref.tell(message)
+          else
+            GameMachine.logger.warn("No handler found for #{message.client_connection}")
+          end
+        elsif message.kind_of?(JavaLib::Tcp::Bound)
+          @mgr.tell(message,get_self)
+        elsif message.kind_of?(JavaLib::Tcp::CommandFailed)
+          getContext.stop(get_self)
+        elsif message.kind_of?(JavaLib::Tcp::Connected)
+          @mgr.tell(message,get_self)
+          handler_name = sanitize_address(message.remote_address.to_s)
+          handler_ref = Actor::Builder.new(TcpHandler,handler_name).with_name(handler_name).start
+          @clients[message.remote_address.to_s] = handler_ref
+          handler_ref.tell(message,get_sender)
+          get_sender.tell(JavaLib::TcpMessage.register(handler_ref), get_self)
+        else
+          unhandled(message)
+        end
+      end
+
+    end
+  end
+end