game_machine 0.0.11 → 1.0.2

data/lib/game_machine/console/server.rb

@@ -12,82 +12,27 @@ module GameMachine
         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
+          exit 1
         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.initialize!
         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).",
@@ -95,23 +40,11 @@ module GameMachine
           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
 

data/lib/game_machine/data_store.rb

@@ -3,20 +3,35 @@ require_relative 'data_stores/memory'
 require_relative 'data_stores/couchbase'
 require_relative 'data_stores/mapdb'
 require_relative 'data_stores/redis'
+require_relative 'data_stores/jdbc'
+require_relative 'data_stores/gamecloud'
 
 module GameMachine
   class DataStore
     include Singleton
     extend Forwardable
 
-    def_delegators :@store, :delete, :delete_all, :shutdown, :keys, :dump, :load
+    def_delegators :@store, :delete_all, :shutdown, :keys, :dump, :load
 
-    attr_reader :store
+    attr_reader :store, :serialization, :classmap
     def initialize
-      @store_name = Application.config.data_store
+      @store_name = Application.config.datastore.store
+      @serialization = Application.config.datastore.serialization
+      @classmap = {}
       connect
     end
 
+    def class_cache(classname)
+      return MessageLib::Entity if classname.nil?
+
+      if cached = classmap.fetch(classname,nil)
+        return cached
+      else
+        classmap[classname] = "GameMachine::MessageLib::#{classname}".constantize
+        classmap[classname]
+      end
+    end
+
     def set_store(store_name)
       @store = nil
       @store_name = store_name
@@ -24,23 +39,94 @@ module GameMachine
     end
 
 
-    def get(key)
-      value = @store.get(key)
+    # for get/set/delete, backend stores return a value or nil, and raise on any underlying error
+    # Propogating the error could mess up actor states so we don't do that.  
+    # Callers should treat nil/false as a failure.  We log errors so they
+    # can be dealt with
+    
+    def get(key,classname='Entity')
+      value = nil
+      begin
+        value = @store.get(key)
+      rescue Exception => e
+         GameMachine.logger.error(e.message+"\n"+e.backtrace.join("\n"))
+        return nil
+      end
+
       return nil if value.nil?
-      if value.is_a?(String)
-        MessageLib::Entity.new.set_id(key).set_json_storage(
-          MessageLib::JsonStorage.new.set_json(value)
-        )
+      klass = class_cache(classname)
+
+      if serialization == 'json'
+        klass.parse_from_json(value)
       else
-        MessageLib::Entity.parse_from(value)
+        klass.parse_from(value)
       end
     end
 
-    def set(key,value)
-      if value.has_json_storage
-        @store.set(key,value.json_storage.json)
+    def query(scope,query_string,limit,classname)
+      query_string = scope + "##" + query_string
+      values = []
+      begin
+        # Returns an array
+        values = @store.query(query_string,limit)
+      rescue Exception => e
+         GameMachine.logger.error(e.message+"\n"+e.backtrace.join("\n"))
+        return values
+      end
+
+      return values if values.empty?
+      klass = class_cache(classname)
+
+      if serialization == 'json'
+        messages = values.map do |r|
+          message = klass.parse_from_json(r)
+          if message.id.match(/##/)
+            message.setId(klass.unscopeId(message.id))
+          end
+          message
+        end
       else
-        @store.set(key,value.to_byte_array)
+        messages = values.map do |r|
+          message = klass.parse_from(r.to_byte_array)
+          if message.id.match(/##/)
+            message.setId(klass.unscopeId(message.id))
+          end
+          message
+        end
+      end
+
+      messages
+    end
+
+    def set(key,value)
+      begin
+        if serialization == 'json'
+          @store.set(key,value.to_json)
+        else
+          @store.set(key,value.to_byte_array)
+        end
+      rescue Exception => e
+        GameMachine.logger.error(e.message+"\n"+e.backtrace.join("\n"))
+        return false
+      end
+    end
+
+    def delete(key)
+      begin
+        @store.delete(key)
+      rescue Exception => e
+        GameMachine.logger.error(e.message+"\n"+e.backtrace.join("\n"))
+        return false
+      end
+    end
+
+    def delete_matching(scope,query_string)
+      query_string = scope + "##" + query_string
+      begin
+        @store.delete_matching(query_string)
+      rescue Exception => e
+        GameMachine.logger.error(e.message+"\n"+e.backtrace.join("\n"))
+        return false
       end
     end
 
@@ -51,8 +137,18 @@ module GameMachine
       send("connect_#{@store_name}")
     end
 
+    def connect_gamecloud
+      @store = DataStores::Gamecloud.new(serialization)
+      @store.connect
+    end
+
+    def connect_jdbc
+      @store = DataStores::Jdbc.new(serialization)
+      @store.connect
+    end
+
     def connect_couchbase
-      @store = DataStores::Couchbase.new
+      @store = DataStores::Couchbase.new(serialization)
       @store.connect
     end
 

data/lib/game_machine/data_stores/couchbase.rb

@@ -6,16 +6,21 @@ module GameMachine
 
       def_delegators :@client, :get, :set, :delete, :shutdown
 
+      attr_reader :serialization
+      def initialize(serialization)
+        @serialization = serialization
+      end
+      
       def connect
         @client ||= JavaLib::CouchbaseClient.new(builder)
       end
 
       def bucket
-       Application.config.couchbase_bucket || 'default'
+       Application.config.couchbase.bucket || 'default'
       end
 
       def password
-       Application.config.couchbase_password || ''
+       Application.config.couchbase.password || ''
       end
 
       def builder
@@ -28,7 +33,7 @@ module GameMachine
       end
 
       def servers
-        Application.config.couchbase_servers.map {|server| java.net.URI.new(server)}
+        Application.config.couchbase.servers.map {|server| java.net.URI.new(server)}
       end
     end
   end

data/lib/game_machine/data_stores/gamecloud.rb

@@ -0,0 +1,93 @@
+module GameMachine
+  module DataStores
+    class Gamecloud
+
+      attr_reader :serialization
+      def initialize(serialization)
+        @serialization = serialization
+      end
+
+      def connect
+        JavaLib::CloudClient.get_instance.set_credentials(
+          Application.config.gamecloud.host,
+          Application.config.gamecloud.user,
+          Application.config.gamecloud.api_key
+        )
+      end
+
+      def handle_entity_response(response)
+        if response.status == 200
+          serialization == 'json' ? response.stringBody : response.byteBody
+        elsif response.status == 404
+          nil
+        else
+          raise "Gamecloud.get returned status: #{response.status}"
+        end
+      end
+
+      def handle_response(response)
+        if [200,204].include?(response.status)
+          true
+        elsif response.status == 404
+          false
+        else
+          raise "Gamecloud.get returned status: #{response.status}"
+        end
+      end
+
+      def query(query,limit)
+        response = JavaLib::CloudClient.get_instance.query(query,limit,serialization)
+        if response.status == 200
+          query_response = MessageLib::CloudQueryResponse.parse_from(response.byteBody)
+
+          if serialization == 'json'
+            if query_response.getJsonMessageList.nil?
+              messages = []
+            else
+              messages = query_response.getJsonMessageList
+            end
+          else
+            if query_response.getByteMessageList.nil?
+              messages = []
+            else
+              messages = query_response.getByteMessageList
+            end
+          end
+          messages
+        elsif response.status == 404
+          []
+        else
+          raise "Gamecloud.get returned status: #{response.status}"
+        end
+      end
+
+      def get(id)
+        if serialization == 'json'
+          response = JavaLib::CloudClient.get_instance.getString(id)
+        else
+          response = JavaLib::CloudClient.get_instance.getBytes(id)
+        end
+        handle_entity_response(response)
+      end
+
+      def delete(id)
+        response = JavaLib::CloudClient.get_instance.delete(id)
+        handle_response(response)
+      end
+
+      def delete_matching(query_string)
+        response = JavaLib::CloudClient.get_instance.delete_matching(query_string)
+        handle_response(response)
+      end
+
+      def set(id,value)
+        if serialization == 'json'
+          response = JavaLib::CloudClient.get_instance.putString(id,value)
+        else
+          response = JavaLib::CloudClient.get_instance.putBytes(id,value)
+        end
+        handle_response(response)
+      end
+    end
+  end
+end

data/lib/game_machine/data_stores/jdbc.rb

@@ -0,0 +1,98 @@
+module GameMachine
+  module DataStores
+    class Jdbc
+
+      attr_reader :serialization
+      def initialize(serialization)
+        @serialization = serialization
+      end
+      
+      def dbname
+        'game_machine'
+      end
+
+      def dbtype
+        @dbtype ||= case Application.config.jdbc_driver
+          when 'org.postgresql.Driver'
+            :postgres
+          when 'com.mysql.jdbc.Driver'
+            :mysql
+          else
+            raise "Unknown JDBC driver #{Application.config.jdbc_driver}"
+          end
+      end
+        
+      def connect
+        @pool ||= GameMachine::JavaLib::DbConnectionPool.getInstance
+        unless @pool.connect(
+          dbname,
+          Application.config.jdbc.hostname,
+          Application.config.jdbc.port,
+          Application.config.jdbc.database,
+          Application.config.jdbc.ds,
+          Application.config.jdbc.username,
+          Application.config.jdbc.password || ''
+        )
+          GameMachine.logger.error "Unable to establish database connection, exiting"
+          System.exit 1
+        end
+        @pool
+      end
+
+      # type 0 = string, 1 = byte array
+      def set(id,value)
+        connection = @pool.get_connection(dbname)
+        if value.is_a?(String)
+          value = value.to_java_bytes
+          type = 0
+        else
+          type = 1
+        end
+
+        if dbtype == :mysql
+          s = connection.prepare_statement("INSERT INTO entities (id,value,datatype) VALUES (?,?,?) ON DUPLICATE KEY UPDATE value=VALUES(value)")
+        else
+          s = connection.prepare_statement("INSERT INTO entities (id,value,datatype) VALUES (?,?,?)")
+        end
+        
+        s.setString(1,id.to_java_string)
+        s.setBytes(2,value)
+        s.setInt(3,type)
+        s.execute_update
+        s.close
+        connection.close
+      end
+
+      def delete(id)
+        connection = @pool.get_connection(dbname)
+        s = connection.prepare_statement("DELETE from entities where id = ?")
+        s.setString(1,id.to_java_string)
+        s.execute_update
+        s.close
+        connection.close
+      end
+
+      def get(key)
+        value = nil
+        type = nil
+        connection = @pool.get_connection(dbname)
+        s = connection.create_statement
+        res = s.execute_query("SELECT value,datatype from entities where id = '#{key}' LIMIT 1")
+        if res.next
+          value = res.get_bytes('value')
+          type = res.get_int("datatype")
+        end
+
+        s.close
+        connection.close
+
+        if type == 0
+          value.to_s
+        else
+          value
+        end
+      end
+
+    end
+  end
+end