game_machine 0.0.8

data/integration_tests/mono_spec.rb

@@ -0,0 +1,16 @@
+require 'integration_helper'
+
+module GameMachine
+
+  describe MonoTest do
+
+    it "runs ok" do
+      100000.times do
+      MonoTest.find.tell(Helpers::GameMessage.new('test').to_byte_array)
+      #MonoTest.find_remote('seed01').tell(Helpers::GameMessage.new('test').to_byte_array)
+      end
+    end
+  end
+
+end
+

data/integration_tests/objectdb_spec.rb

@@ -0,0 +1,55 @@
+
+require 'integration_helper'
+require_relative '../spec/boot.rb'
+
+module GameMachine
+  describe ObjectDb do 
+
+    describe "stress" do
+
+      it "stress with small payload" do
+        measure(10,10000) do
+          e = entity
+          id = e.id
+          ObjectDb.put(e)
+          if returned_entity = ObjectDb.get(id)
+            returned_entity.id.should == id
+          end
+        end
+      end
+
+      it "stress get" do
+        measure(10,10000) do
+          e = entity
+          id = e.id
+          if returned_entity = ObjectDb.get(id)
+            returned_entity.id.should == id
+          end
+        end
+      end
+
+      it "stress dbproc" do
+        measure(10,10000) do
+          e = entity
+          id = e.id
+          if returned_entity = ObjectDb.call_dbproc(:update, e.id,true)
+            returned_entity.id.should == id
+          end
+        end
+      end
+
+      it "stress with large payload" do
+        measure(10,10000) do
+          e = large_entity
+          id = e.id
+          ObjectDb.put(e)
+          if returned_entity = ObjectDb.get(id)
+            returned_entity.id.should == id
+          end
+        end
+      end
+    end
+
+  end
+end
+

data/integration_tests/tcp_client_spec.rb

@@ -0,0 +1,71 @@
+require 'integration_helper'
+ENV['GAME_ENV'] = 'test'
+require 'rubygems'
+
+begin
+  require 'game_machine'
+rescue LoadError
+  require_relative '../lib/game_machine'
+end
+
+def echo_test
+  GameMachine::MessageLib::EchoTest.new.set_message('testing')
+end
+
+def entity
+  GameMachine::MessageLib::Entity.new.set_id('1').set_echo_test(echo_test)
+end
+
+def message_for(client_message)
+  String.from_java_bytes(client_message.to_prefixed_byte_array)
+end
+
+def player_for(id)
+  GameMachine::MessageLib::Player.new.set_id(id).set_name(id).
+    set_authtoken('authorized')
+end
+
+def client_message_for(player)
+  GameMachine::MessageLib::ClientMessage.new.add_entity(entity).
+    set_player(player)
+end
+
+module GameMachine
+
+  describe 'tcp client' do 
+
+
+    describe "sending and receiving messages" do
+      it "should receive reply" do
+        threads = []
+        1.times do |i|
+          threads << Thread.new do
+            player = player_for("player_#{i}")
+            Application.auth_handler.add_user(player.id,player.authtoken)
+            message = message_for(client_message_for(player))
+            client = Clients::TcpClient.new('localhost',8700)
+            results = []
+            count = 0
+            100000.times do
+              #sleep 0.100
+              results << Benchmark.realtime do
+                client.send_message(message)
+                if bytes = client.receive_message.to_java_bytes
+                  #client_message = MessageLib::ClientMessage.parse_from(bytes)
+                end
+              end
+              count += 1
+              if count > 1000
+                puts "Number = #{results.number} Average #{results.mean} Standard deviation #{results.standard_deviation}"
+                count = 0
+                results = []
+              end
+            end
+            puts "Number = #{results.number} Average #{results.mean} Standard deviation #{results.standard_deviation}"
+          end
+        end
+        threads.map(&:join)
+      end
+    end
+  end
+end

data/integration_tests/udp_client_spec.rb

@@ -0,0 +1,61 @@
+
+ENV['GAME_ENV'] = 'test'
+require 'rubygems'
+
+begin
+  require 'game_machine'
+rescue LoadError
+  require_relative '../lib/game_machine'
+end
+module GameMachine
+
+  describe 'udt client' do 
+
+    let(:player) do
+      Player.new.set_id('player').set_name('player').
+        set_authtoken('authorized')
+    end
+
+    let(:echo_test) do
+      EchoTest.new.set_message('testing')
+    end
+
+    let(:entity) do
+      MessageLib::Entity.new.set_id('1').set_echo_test(echo_test)
+    end
+
+    let(:client_message) do
+      ClientMessage.new.add_entity(entity).
+        set_player(player)
+    end
+
+    let(:message) do
+      String.from_java_bytes(client_message.to_byte_array)
+    end
+
+    let(:logout_message) do
+      String.from_java_bytes(
+        client_message.set_player_logout(
+          PlayerLogout.new.set_player_id('player')
+        ).to_byte_array
+      )
+    end
+
+    let(:client) {Clients::UdpClient.new(:seed01)}
+
+
+    describe "sending and receiving messages" do
+      it "should receive reply" do
+        1.times do
+        client.send_message(message)
+        if bytes = client.receive_message.to_java_bytes
+          client_message = ClientMessage.parse_from(bytes)
+          #puts client_message.client_connection.id
+          #puts client_message.client_connection.gateway
+          client.send_message(logout_message)
+        end
+        end
+      end
+    end
+  end
+end

data/integration_tests/udp_spec.rb

@@ -0,0 +1,20 @@
+require 'integration_helper'
+
+module GameMachine
+  describe "udp" do 
+
+    describe "sending messages via udp" do
+      it "should do" do
+        measure(10,10000) do
+          Thread.current['bytes'] ||= client_message.to_byte_array
+          Thread.current['c'] ||= Clients::Client.new(:seed01)
+          Thread.current['c'].send_message(Thread.current['bytes'])
+          message = Thread.current['c'].receive_message
+          ClientMessage.parse_from(message.to_java_bytes)
+        end
+      end
+    end
+
+  end
+end
+

data/integration_tests/udt_client_spec.rb

@@ -0,0 +1,23 @@
+require 'integration_helper'
+
+module GameMachine
+
+  describe "basic" do 
+    let(:client) {Clients::UdtClient.new(:seed01)}
+
+    describe "Sending and receiving messages" do
+      it "works" do
+        message = Helpers::GameMessage.new('player')
+        message.echo_test('hi')
+        client.connect
+        client.send_message(message.to_byte_array)
+        result = client.receive
+        logout = Helpers::GameMessage.new('player')
+        logout.player_logout
+        client.send_message(logout.to_byte_array)
+        client.disconnect
+      end
+
+    end
+  end
+end

data/integration_tests/udt_spec.rb

@@ -0,0 +1,31 @@
+require 'integration_helper'
+
+module GameMachine
+  describe "basic" do 
+    let(:client) {Client.new(:seed01)}
+
+    describe "udt" do
+
+      it "stress with small payload" do
+        measure(10,10000) do
+          Thread.current['bytes'] ||= client_message.to_byte_array
+          Thread.current['s'] ||= Clients::Client.connect_udt
+          result = Clients::Client.send_udt(Thread.current['s'],Thread.current['bytes'])
+          ClientMessage.parse_from(result)
+        end
+      end
+
+      it "stress with large payload" do
+        measure(10,10000) do
+          Thread.current['bytes'] ||= client_message.to_byte_array
+          Thread.current['s'] ||= Clients::Client.connect_udt
+          result = Clients::Client.send_udt(Thread.current['s'],Thread.current['bytes'])
+          ClientMessage.parse_from(result)
+        end
+      end
+
+    end
+
+  end
+end
+

data/java/.gitignore

@@ -0,0 +1 @@
+/bin

data/java/build.gradle

@@ -0,0 +1,93 @@
+apply plugin: 'java'
+apply plugin: 'maven'
+apply plugin: 'eclipse'
+apply plugin:'application'
+apply plugin:'scala'
+
+group = 'game_machine'
+  version = '0.0.1'
+  
+
+description = """"""
+
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
+
+repositories {
+  flatDir(dirs: 'third_party') 
+  mavenRepo url: "http://repo.typesafe.com/typesafe/releases/"
+  mavenRepo url: "http://files.couchbase.com/maven2/"
+  mavenRepo url: "http://repo.maven.apache.org/maven2"
+}
+
+dependencies {
+  compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.+'
+  //compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.+'
+  compile group: 'com.typesafe.akka', name: "akka-actor_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-remote_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-testkit_$scala_version", version:"$akka_version"
+  //compile group: 'com.typesafe.akka', name: "akka-camel_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-kernel_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-agent_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-contrib_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-cluster_$scala_version", version:"$akka_version"
+  //compile group: 'com.typesafe.akka', name: "akka-zeromq_$scala_version", version:"$akka_version"
+  
+  compile 'com.dyuproject.protostuff:protostuff-uberjar:1.0.7'
+  compile 'com.dyuproject.protostuff:protostuff:1.0.7'
+  //compile 'com.dyuproject.protostuff:protostuff-compiler:1.0.7'
+  compile 'com.dyuproject.protostuff:protostuff-json:1.0.7'
+  //compile 'com.dyuproject.protostuff:protostuff-yaml:1.0.7'
+  //compile 'com.dyuproject.protostuff:protostuff-xml:1.0.7'
+  
+  //compile group: 'com.barchart.udt', name: 'barchart-udt-bundle', version:'2.3.0'
+  compile group: 'com.google.code.findbugs', name: 'jsr305', version:'2.0.1'
+  compile group: 'org.javassist', name: 'javassist', version:'3.17.1-GA'
+  //compile(group: 'io.netty', name: 'netty-all', version:'4.0.11.Final')
+  //compile 'org.apache.camel:camel-jetty:2.10.3'
+  compile(group: 'couchbase', name: 'couchbase-client', version:'1.1.7')
+  compile 'redis.clients:jedis:2.2.1'
+  compile 'org.mapdb:mapdb:1.0.3'
+  compile 'io.netty:netty-testsuite:4.0.20.Final'
+  
+}
+
+task wrapper(type: Wrapper) {
+  gradleVersion = '1.7'
+}
+task uberjar(type: Jar) {
+  from files(sourceSets.main.output.classesDir)
+  from configurations.runtime.asFileTree.files.collect { zipTree(it) }
+}
+
+task codegen(type: Exec) {
+	File templateFile = file('protogen.rb')
+    commandLine 'jruby',templateFile
+}
+
+task protogen(type: Exec)  {
+  File configFile = file('src/main/resources/protostuff.properties')
+  File jar = file('protostuff-compiler-1.0.7-jarjar.jar')
+  commandLine 'java','-jar',jar,configFile
+}
+
+test {
+  useTestNG()
+  //outputs.upToDateWhen { false }
+  testLogging.showStandardStreams = true
+  dependsOn cleanTest
+  testLogging { exceptionFormat "full" }
+}
+  
+task install_libs(type: Copy) {
+  into "$buildDir/../lib"
+  from configurations.runtime
+  from "$buildDir/libs"
+}
+
+task install_libs_ruby(type: Copy) {
+  into "$buildDir/../lib"
+  from configurations.runtime
+  from "$buildDir/libs"
+}
+

data/java/component.erb

@@ -0,0 +1,396 @@
+
+package GameMachine.Messages;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.dyuproject.protostuff.ByteString;
+import com.dyuproject.protostuff.GraphIOUtil;
+import com.dyuproject.protostuff.Input;
+import com.dyuproject.protostuff.Message;
+import com.dyuproject.protostuff.Output;
+import com.dyuproject.protostuff.ProtobufOutput;
+
+import java.io.ByteArrayOutputStream;
+import com.dyuproject.protostuff.JsonIOUtil;
+import com.dyuproject.protostuff.LinkedBuffer;
+import com.dyuproject.protostuff.ProtobufIOUtil;
+import com.dyuproject.protostuff.ProtostuffIOUtil;
+import com.dyuproject.protostuff.runtime.RuntimeSchema;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import GameMachine.Messages.Entity;
+
+import com.dyuproject.protostuff.Pipe;
+import com.dyuproject.protostuff.Schema;
+import com.dyuproject.protostuff.UninitializedMessageException;
+
+public final class <%=klass%>  implements Externalizable, Message<<%=klass%>>, Schema<<%=klass%>>
+{
+
+<%- message.nestedEnumGroups.each do |group| -%>
+	public enum <%=group.name %> implements com.dyuproject.protostuff.EnumLite<<%=group.name %>>
+    {
+    	<%- group.values.each do |value| -%>
+    	<%= "#{value.getName}(#{value.getNumber})" %><%= value.getNumber == (group.values.length - 1) ? ";" : "," %>
+    	<%- end -%>
+        
+        public final int number;
+        
+        private Corpus (int number)
+        {
+            this.number = number;
+        }
+        
+        public int getNumber()
+        {
+            return number;
+        }
+        
+        public static Corpus valueOf(int number)
+        {
+            switch(number) 
+            {
+            	<%- group.values.each do |value| -%>
+    			case <%= "#{value.getNumber}: return (#{value.getName})" %>;
+    			<%- end -%>
+                default: return null;
+            }
+        }
+    }
+<%- end -%>
+
+
+    public static Schema<<%=klass%>> getSchema()
+    {
+        return DEFAULT_INSTANCE;
+    }
+
+    public static <%=klass%> getDefaultInstance()
+    {
+        return DEFAULT_INSTANCE;
+    }
+
+    static final <%=klass%> DEFAULT_INSTANCE = new <%=klass%>();
+
+<%- message.getFields.each do |field| -%>
+    <%- if field.isRepeated -%>
+    public List<<%=get_type(field)%>> <%=field.name -%>;
+	<%- else -%>
+    public <%=get_type(field)%> <%=field.name -%>;
+    <%- end -%>
+<%- end -%>
+    
+
+
+    public <%=klass%>()
+    {
+        
+    }
+
+
+<%- if klass == 'Entity' -%>
+	public ArrayList<String> componentNames() {
+		ArrayList<String> names = new ArrayList<String>();
+	<%- messages.each do |m| -%>
+	  <%- if message.getFields.collect {|f| f.name}.include?(varname(m.getName)) -%>
+		if (this.has<%=m.getName%>()) {
+			names.add(this.<%=varname(m.getName)%>.getClass().getSimpleName());
+		}
+	  <%- end -%>
+	<%- end -%>
+		return names;
+	}
+<%- end -%>
+
+<%- message.getFields.each do |field| -%>
+	<%- field_name = field.name.slice(0,1).capitalize + field.name.slice(1..-1) -%>
+    
+	<%- if field.isRepeated -%>
+	public List<<%=get_type(field)%>> get<%=field_name -%>List() {
+		return <%= field.name %>;
+	}
+
+	public <%=klass%> set<%=field_name %>List(List<<%=get_type(field)%>> <%=field.name%>) {
+		this.<%=field.name%> = <%=field.name%>;
+		return this;
+	}
+
+	public <%=get_type(field) %> get<%=field_name %>(int index)  {
+        return <%=field.name%> == null ? null : <%=field.name%>.get(index);
+    }
+
+    public int get<%=field_name %>Count()  {
+        return <%=field.name%> == null ? 0 : <%=field.name%>.size();
+    }
+
+    public <%=klass%> add<%=field_name %>(<%=get_type(field) %> <%=field.name%>)  {
+        if(this.<%=field.name%> == null)
+            this.<%=field.name%> = new ArrayList<<%=get_type(field) %>>();
+        this.<%=field.name%>.add(<%=field.name%>);
+        return this;
+    }
+    
+	<%- else -%>
+	public <%=get_type(field)%> get<%=field_name -%>() {
+		return <%= field.name %>;
+	}
+	
+	public <%= field_name == '_EntityId' ? 'void' : klass%> set<%=field_name %>(<%=get_type(field)%> <%=field.name%>) {
+		this.<%=field.name%> = <%=field.name%>;
+		<%= field_name == '_EntityId' ? '' : 'return this;'%>
+	}
+	
+	public Boolean has<%=field_name %>()  {
+        return <%=field.name%> == null ? false : true;
+    }
+	<%- end -%>
+<%- end -%>
+
+  
+    // java serialization
+
+    public void readExternal(ObjectInput in) throws IOException
+    {
+        GraphIOUtil.mergeDelimitedFrom(in, this, this);
+    }
+
+    public void writeExternal(ObjectOutput out) throws IOException
+    {
+        GraphIOUtil.writeDelimitedTo(out, this, this);
+    }
+
+    // message method
+
+    public Schema<<%=klass%>> cachedSchema()
+    {
+        return DEFAULT_INSTANCE;
+    }
+
+    // schema methods
+
+    public <%=klass%> newMessage()
+    {
+        return new <%=klass%>();
+    }
+
+    public Class<<%=klass%>> typeClass()
+    {
+        return <%=klass%>.class;
+    }
+
+    public String messageName()
+    {
+        return <%=klass%>.class.getSimpleName();
+    }
+
+    public String messageFullName()
+    {
+        return <%=klass%>.class.getName();
+    }
+
+    public boolean isInitialized(<%=klass%> message)
+    {
+        return true;
+    }
+
+    public void mergeFrom(Input input, <%=klass%> message) throws IOException
+    {
+        for(int number = input.readFieldNumber(this);; number = input.readFieldNumber(this))
+        {
+            switch(number)
+            {
+                case 0:
+                    return;
+                <%- message.getFields.each do |field| -%>
+            	case <%=field.number%>:
+            	<%- if field.isRepeated -%>
+            		if(message.<%=field.name%> == null)
+                        message.<%=field.name%> = new ArrayList<<%=get_type(field)%>>();
+                    <%- if field.isMessageField -%>
+                    message.<%=field.name%>.add(input.mergeObject(null, <%=get_type(field)%>.getSchema()));
+                    <%- elsif field.enumField -%>
+                    message.<%=field.name%>.add(<%=get_type(field)%>.valueOf(input.readEnum()));
+                    <%- else -%>
+                	message.<%=field.name%>.add(input.read<%=field.getClass.getSimpleName%>());
+                	<%- end -%>
+                    break;
+                <%- else -%>
+                	<%- if field.isMessageField -%>
+                	message.<%=field.name%> = input.mergeObject(message.<%=field.name%>, <%=get_type(field)%>.getSchema());
+                    break;
+                    <%- elsif field.enumField -%>
+                    message.<%=field.name%> = <%=classname(field.name)%>.valueOf(input.readEnum());
+                    break;
+                	<%- else -%>
+                	message.<%=field.name%> = input.read<%=field.getClass.getSimpleName%>();
+                	break;
+                	<%- end -%>
+                	
+                <%- end -%>
+            	<%- end -%>
+            
+                default:
+                    input.handleUnknownField(number, this);
+            }   
+        }
+    }
+
+
+    public void writeTo(Output output, <%=klass%> message) throws IOException
+    {
+    	<%- message.getFields.each do |field| -%>
+    	
+    	<%- if field.isRequired -%>
+    	if(message.<%=field.name%> == null)
+            throw new UninitializedMessageException(message);
+    	<%- end %>
+    	
+    	<%- if field.isRepeated -%>
+    	if(message.<%=field.name%> != null)
+        {
+            for(<%=get_type(field)%> <%=field.name%> : message.<%=field.name%>)
+            {
+                if(<%=field.name%> != null) {
+                   	<%- if field.isMessageField -%>
+    				output.writeObject(<%=field.number%>, <%=field.name%>, <%=get_type(field)%>.getSchema(), true);
+    				<%- elsif field.enumField -%>
+    				output.writeEnum(<%=field.number%>, <%=field.name%>.number, true);
+    				<%- else -%>
+            		output.write<%=field.getClass.getSimpleName%>(<%=field.number%>, <%=field.name%>, true);
+    				<%- end -%>
+    			}
+            }
+        }
+    	<%- else -%>
+    	<%- if field.isMessageField -%>
+    	if(message.<%=field.name%> != null)
+    		output.writeObject(<%=field.number%>, message.<%=field.name%>, <%=get_type(field)%>.getSchema(), false);
+    	<%- elsif field.enumField -%>
+    	 	output.writeEnum(<%=field.number%>, message.<%=field.name%>.number, false);
+    	<%- else -%>
+    	if(message.<%=field.name%> != null)
+            output.write<%=field.getClass.getSimpleName%>(<%=field.number%>, message.<%=field.name%>, false);
+    	<%- end -%>
+    	
+    	<%- end -%>
+        <%- end -%>
+    	
+    }
+
+    public String getFieldName(int number)
+    {
+        switch(number)
+        {
+        	<%- message.getFields.each do |field| -%>
+        	case <%=field.number%>: return "<%=field.name%>";
+        	<%- end -%>
+            default: return null;
+        }
+    }
+
+    public int getFieldNumber(String name)
+    {
+        final Integer number = __fieldMap.get(name);
+        return number == null ? 0 : number.intValue();
+    }
+
+    private static final java.util.HashMap<String,Integer> __fieldMap = new java.util.HashMap<String,Integer>();
+    static
+    {
+    	<%- message.getFields.each do |field| -%>
+    	__fieldMap.put("<%=field.name%>", <%=field.number%>);
+    	<%- end -%>
+    }
+   
+   public static List<String> getFields() {
+	ArrayList<String> fieldNames = new ArrayList<String>();
+	String fieldName = null;
+	Integer i = 1;
+	
+    while(true) { 
+		fieldName = <%=klass%>.getSchema().getFieldName(i);
+		if (fieldName == null) {
+			break;
+		}
+		fieldNames.add(fieldName);
+		i++;
+	}
+	return fieldNames;
+}
+
+public static <%=klass%> parseFrom(byte[] bytes) {
+	<%=klass%> message = new <%=klass%>();
+	ProtobufIOUtil.mergeFrom(bytes, message, RuntimeSchema.getSchema(<%=klass%>.class));
+	return message;
+}
+
+public <%=klass%> clone() {
+	byte[] bytes = this.toByteArray();
+	<%=klass%> <%=varname(klass)%> = <%=klass%>.parseFrom(bytes);
+	return <%=varname(klass)%>;
+}
+	
+public byte[] toByteArray() {
+	return toProtobuf();
+	//return toJson();
+}
+
+public byte[] toJson() {
+	boolean numeric = false;
+	ByteArrayOutputStream out = new ByteArrayOutputStream();
+	try {
+		JsonIOUtil.writeTo(out, this, <%=klass%>.getSchema(), numeric);
+	} catch (IOException e) {
+		e.printStackTrace();
+		throw new RuntimeException("Json encoding failed");
+	}
+	return out.toByteArray();
+}
+
+public byte[] toPrefixedByteArray() {
+	LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
+  Schema<<%=klass%>> schema = RuntimeSchema.getSchema(<%=klass%>.class);
+    
+	final ByteArrayOutputStream out = new ByteArrayOutputStream();
+    final ProtobufOutput output = new ProtobufOutput(buffer);
+    try
+    {
+    	schema.writeTo(output, this);
+        final int size = output.getSize();
+        ProtobufOutput.writeRawVarInt32Bytes(out, size);
+        final int msgSize = LinkedBuffer.writeTo(out, buffer);
+        assert size == msgSize;
+        
+        buffer.clear();
+        return out.toByteArray();
+    }
+    catch (IOException e)
+    {
+        throw new RuntimeException("Serializing to a byte array threw an IOException " + 
+                "(should never happen).", e);
+    }
+ 
+}
+
+public byte[] toProtobuf() {
+	LinkedBuffer buffer = LinkedBuffer.allocate(8024);
+	byte[] bytes = null;
+
+	try {
+		bytes = ProtobufIOUtil.toByteArray(this, RuntimeSchema.getSchema(<%=klass%>.class), buffer);
+		buffer.clear();
+	} catch (Exception e) {
+		e.printStackTrace();
+		throw new RuntimeException("Protobuf encoding failed");
+	}
+	return bytes;
+}
+
+}