game_machine 0.0.11 → 1.0.2

data/java/{gradle.properties → project/gradle.properties}

@@ -2,5 +2,5 @@
 version=0.0.1
 
 scala_version=2.11
-akka_version=2.3.4
+akka_version=2.3.6
 

data/java/{gradle → project/gradle}/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Tue Sep 03 19:32:06 PDT 2013
+#Thu Aug 21 21:28:37 PDT 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.0-bin.zip

data/java/project/model.erb

@@ -0,0 +1,99 @@
+package com.game_machine.orm.models;
+
+import org.javalite.activejdbc.DB;
+import org.javalite.activejdbc.Model;
+import org.javalite.activejdbc.annotations.IdName;
+
+import com.game_machine.core.DbConnectionPool;
+import com.zaxxer.hikari.HikariDataSource;
+
+/*
+Postgresql
+
+Database/user creation
+CREATE ROLE gamemachine WITH ENCRYPTED PASSWORD 'gamemachine' LOGIN CREATEDB CREATEROLE;
+CREATE DATABASE gamemachine WITH OWNER=gamemachine ENCODING='UTF8';
+
+Table
+CREATE TABLE <%= klass.underscore.pluralize %> (
+  id bigserial NOT NULL,
+  <% message.getFields.each do |field| %>
+  <%= sql_field(klass,field,'postgres') %>
+  <% end %>
+  
+  <% message_fields.each do |message_field| %>
+  	<% klass_message = messages_index[message_field] %>
+  	<% klass_message.getFields.each do |field| %>
+  <%= sql_field(message_field,field,'postgres',true) %>
+  	<% end %>
+  <% end %>
+  
+  player_id character varying(128) NOT NULL,
+  CONSTRAINT <%=klass.underscore%>_pkey PRIMARY KEY (id),
+  CONSTRAINT <%=klass.underscore%>_id_player_id_idx UNIQUE (<%=klass.underscore%>_id,player_id)
+);
+alter table <%= klass.underscore.pluralize %> owner to gamemachine;
+
+
+Mysql
+
+Database/user creation
+CREATE DATABASE IF NOT EXISTS gamemachine CHARACTER SET utf8 COLLATE utf8_general_ci;
+GRANT ALL PRIVILEGES ON gamemachine.* TO 'gamemachine'@'%' IDENTIFIED BY 'gamemachine' WITH GRANT OPTION;
+FLUSH PRIVILEGES;
+
+Table
+CREATE TABLE `<%= klass.underscore.pluralize %>` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  <% message.getFields.each do |field| %>
+  <%= sql_field(klass,field,'mysql') %>
+  <% end %>
+  
+  <% message_fields.each do |message_field| %>
+  	<% klass_message = messages_index[message_field] %>
+  	<% klass_message.getFields.each do |field| %>
+  <%= sql_field(message_field,field,'mysql',true) %>
+  	<% end %>
+  <% end %>
+  
+  `player_id` varchar(128) NOT NULL,
+  PRIMARY KEY(`id`),
+  UNIQUE KEY `<%=klass.underscore%>_id_player_id_idx` (`<%=klass.underscore%>_id`,`player_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+*/
+
+public class <%= klass %> extends Model {
+	
+	public static void openTransaction() {
+		open();
+		DB db = new DB("default");
+		db.openTransaction();
+	}
+	
+	public static void commitTransaction() {
+		DB db = new DB("default");
+		db.commitTransaction();
+		close();
+	}
+	
+	public static void rollbackTransaction() {
+		DB db = new DB("default");
+		db.rollbackTransaction();
+		close();
+	}
+	
+	public static void close() {
+		DB db = new DB("default");
+		if(db.hasConnection()) {
+			db.close();
+		}
+	}
+	
+	public static void open() {
+		DB db = new DB("default");
+		if(!db.hasConnection()) {
+			HikariDataSource ds = DbConnectionPool.getInstance().getDataSource("game_machine_orm");
+			db.open(ds);
+		}
+	}
+}

data/java/project/src/main/java/com/game_machine/authentication/DefaultAuthenticator.java

@@ -0,0 +1,28 @@
+package com.game_machine.authentication;
+
+import org.mindrot.jbcrypt.BCrypt;
+
+import GameMachine.Messages.Player;
+
+public class DefaultAuthenticator implements PlayerAuthenticator {
+
+	private static String scope = "players";
+	public Player player;
+
+	public DefaultAuthenticator(Player player) {
+		this.player = player;
+	}
+
+	public void setPassword(String password) {
+		player.setPasswordHash(BCrypt.hashpw(password, BCrypt.gensalt()));
+		player.storeSet(scope);
+	}
+
+	public boolean authenticate(String password) {
+		if (player.hasPasswordHash()) {
+			return BCrypt.checkpw(password, player.getPasswordHash());
+		} else {
+			return false;
+		}
+	}
+}

data/java/project/src/main/java/com/game_machine/authentication/PlayerAuthenticator.java

@@ -0,0 +1,6 @@
+package com.game_machine.authentication;
+
+public interface PlayerAuthenticator {
+	void setPassword(String password);
+	boolean authenticate(String password);
+}

data/java/project/src/main/java/com/game_machine/authentication/PublicAuthenticator.java

@@ -0,0 +1,20 @@
+package com.game_machine.authentication;
+
+import GameMachine.Messages.Player;
+
+public class PublicAuthenticator implements PlayerAuthenticator {
+
+	public PublicAuthenticator(Player player) {
+		
+	}
+	
+	@Override
+	public void setPassword(String password) {
+	}
+
+	@Override
+	public boolean authenticate(String password) {
+		return true;
+	}
+
+}

data/java/{src → project/src}/main/java/com/game_machine/core/ActorUtil.java

@@ -2,17 +2,30 @@ package com.game_machine.core;
 
 import akka.actor.ActorSelection;
 import akka.actor.ActorSystem;
+import akka.actor.Address;
+import akka.cluster.Cluster;
 
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 
 public class ActorUtil {
 
+	public static void joinCluster(String protocol, String name, String host, int port) {
+		ActorSystem system = GameMachineLoader.getActorSystem();
+		Address address = new Address(protocol,name,host,port);
+		Cluster.get(system).join(address);
+	}
 	
 	public static ActorSelection getSelectionByClass(Class<?> klass) {
 		return GameMachineLoader.getActorSystem().actorSelection("/user/"+ klass.getSimpleName());
 	}
 	
+	public static ActorSelection findDistributed(String name, String id) {
+		String server = Hashring.getHashring("servers").nodeFor(id);
+		String actorName = Hashring.getHashring(name).nodeFor(id);
+		return GameMachineLoader.getActorSystem().actorSelection(server+"/user/"+ actorName);
+	}
+	
 	public static ActorSelection getSelectionByName(String name) {
 		return GameMachineLoader.getActorSystem().actorSelection("/user/"+ name);
 	}

data/java/project/src/main/java/com/game_machine/core/AuthorizedPlayers.java

@@ -0,0 +1,23 @@
+package com.game_machine.core;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class AuthorizedPlayers {
+	public ConcurrentHashMap<String, Boolean> authorized = new ConcurrentHashMap<String, Boolean>();
+	
+	public void setAuthorized(String playerId) {
+		authorized.put(playerId, true);
+	}
+	
+	public void remove(String playerId) {
+		authorized.remove(playerId);
+	}
+	
+	public Boolean isAuthorized(String playerId) {
+		if (authorized.containsKey(playerId)) {
+			return true;
+		} else {
+			return false;
+		}
+		
+	}
+}

data/java/project/src/main/java/com/game_machine/core/ClientMessageDecoder.java

@@ -0,0 +1,36 @@
+package com.game_machine.core;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler.Sharable;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageDecoder;
+
+import java.util.List;
+
+import GameMachine.Messages.ClientMessage;
+
+import com.dyuproject.protostuff.ProtobufIOUtil;
+import com.dyuproject.protostuff.runtime.RuntimeSchema;
+
+@Sharable
+public class ClientMessageDecoder extends MessageToMessageDecoder<ByteBuf> {
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
+        final byte[] array;
+        final int offset;
+        final int length = msg.readableBytes();
+        if (msg.hasArray()) {
+            array = msg.array();
+            offset = msg.arrayOffset() + msg.readerIndex();
+        } else {
+            array = new byte[length];
+            msg.getBytes(msg.readerIndex(), array, 0, length);
+            offset = 0;
+        }
+        
+        ClientMessage message = new ClientMessage();
+        ProtobufIOUtil.mergeFrom(array, offset, length, message, RuntimeSchema.getSchema(ClientMessage.class));
+        out.add(message);
+    }
+}

data/java/project/src/main/java/com/game_machine/core/ClientMessageEncoder.java

@@ -0,0 +1,19 @@
+package com.game_machine.core;
+
+import static io.netty.buffer.Unpooled.wrappedBuffer;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageEncoder;
+
+import java.util.List;
+
+import GameMachine.Messages.ClientMessage;
+
+public class ClientMessageEncoder extends MessageToMessageEncoder<ClientMessage> {
+	@Override
+    protected void encode(ChannelHandlerContext ctx, ClientMessage msg, List<Object> out) throws Exception {
+        if (msg instanceof ClientMessage) {
+            out.add(wrappedBuffer(msg.toPrefixedByteArray()));
+            return;
+        }
+    }
+}

data/java/project/src/main/java/com/game_machine/core/CloudClient.java

@@ -0,0 +1,298 @@
+package com.game_machine.core;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.ResponseHandler;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.entity.ByteArrayEntity;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import GameMachine.Messages.NodeStatus;
+
+public class CloudClient {
+
+	public ConcurrentHashMap<String, CloseableHttpClient> clients = new ConcurrentHashMap<String, CloseableHttpClient>();
+	private PoolingHttpClientConnectionManager cm;
+	private String gamecloudApiKey;
+	private String gamecloudUser;
+	private String host;
+	private static final Logger logger = LoggerFactory.getLogger(CloudClient.class);
+
+	public class CloudResponse {
+		public int status;
+		public byte[] byteBody;
+		public String stringBody;
+	}
+
+	private CloudClient() {
+		// Some freaking moron at apache.org decided it was a good idea to ignore log level and force WIRE
+		// level whenever Hyperic sigar is detected.
+		System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.NoOpLog");
+		
+		cm = new PoolingHttpClientConnectionManager();
+		cm.setMaxTotal(10);
+		// Increase default max connection per route to 20
+		cm.setDefaultMaxPerRoute(10);
+		// Increase max connections for localhost:80 to 50
+		// HttpHost localhost = new HttpHost("locahost", 80);
+		// cm.setMaxPerRoute(new HttpRoute(localhost), 50);
+	}
+
+	private static class LazyHolder {
+		private static final CloudClient INSTANCE = new CloudClient();
+	}
+
+	public static CloudClient getInstance() {
+		return LazyHolder.INSTANCE;
+	}
+
+	/**
+	 * Sets the credentials for the gamecloud that are used in all requests
+	 * 
+	 * @param host
+	 * @param username
+	 * @param apiKey
+	 */
+	public void setCredentials(String host, String username, String apiKey) {
+		gamecloudApiKey = apiKey;
+		gamecloudUser = username;
+		this.host = host;
+	}
+
+	/**
+	 * Performs a left anchored fuzzy search by id
+	 * 
+	 * @param query
+	 * @param limit
+	 * @param format
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse query(String query, int limit, String format) throws ClientProtocolException, IOException {
+		String url = "http://" + host + "/api/db-query/" + gamecloudUser + "/" + encodeURIComponent(query) + "/" + limit + "/" + format;
+		String token = hash256(gamecloudUser + query + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpGet request = new HttpGet(url);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new ByteArrayResponseHandler());
+	}
+	
+	/**
+	 * Performs mass delete based on a left anchored fuzzy search by id
+	 * 
+	 * @param query
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse deleteMatching(String query) throws ClientProtocolException, IOException {
+		String url = "http://" + host + "/api/db-delete-matching/" + gamecloudUser + "/" + encodeURIComponent(query);
+		String token = hash256(gamecloudUser + query + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpDelete request = new HttpDelete(url);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new StringResponseHandler());
+	}
+	
+	/**
+	 * 
+	 * @param nodeStatus
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse updateNodeStatus(NodeStatus nodeStatus) throws ClientProtocolException, IOException {
+		String url = "http://" + host + "/api/update_node_status";
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpPost request = new HttpPost(url);
+		ByteArrayEntity input = new ByteArrayEntity(nodeStatus.toByteArray(), ContentType.APPLICATION_OCTET_STREAM);
+		request.setEntity(input);
+		return httpClient.execute(request, new StringResponseHandler());
+	}
+	
+	/**
+	 * 
+	 * @param id
+	 * @param bytes
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse putBytes(String id, byte[] bytes) throws ClientProtocolException, IOException {
+		String url = urlFrom(id, "bytes");
+		String token = hash256(gamecloudUser + id + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpPut request = new HttpPut(url);
+		ByteArrayEntity input = new ByteArrayEntity(bytes, ContentType.APPLICATION_OCTET_STREAM);
+		request.setEntity(input);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new StringResponseHandler());
+	}
+
+	/**
+	 * 
+	 * @param id
+	 * @param value
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse putString(String id, String value) throws ClientProtocolException, IOException {
+		String url = urlFrom(id, "json");
+		String token = hash256(gamecloudUser + id + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpPut request = new HttpPut(url);
+		StringEntity input = new StringEntity(value, ContentType.TEXT_PLAIN);
+		request.setEntity(input);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new StringResponseHandler());
+	}
+
+	/**
+	 * 
+	 * @param id
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse delete(String id) throws ClientProtocolException, IOException {
+		String url = urlFrom(id, null);
+		String token = hash256(gamecloudUser + id + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpDelete request = new HttpDelete(url);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new StringResponseHandler());
+	}
+
+	/**
+	 * 
+	 * @param id
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse getBytes(String id) throws ClientProtocolException, IOException {
+		String url = urlFrom(id, "bytes");
+		String token = hash256(gamecloudUser + id + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpGet request = new HttpGet(url);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new ByteArrayResponseHandler());
+	}
+
+	/**
+	 * 
+	 * @param id
+	 * @return
+	 * @throws ClientProtocolException
+	 * @throws IOException
+	 */
+	public CloudResponse getString(String id) throws ClientProtocolException, IOException {
+		String url = urlFrom(id, "json");
+		String token = hash256(gamecloudUser + id + gamecloudApiKey);
+		CloseableHttpClient httpClient = getClient("gamemachine");
+		HttpGet request = new HttpGet(url);
+		request.setHeader("X-Auth", token);
+		return httpClient.execute(request, new StringResponseHandler());
+	}
+
+	private CloseableHttpClient getClient(String id) {
+		CloseableHttpClient httpClient;
+		if (clients.containsKey(id)) {
+			httpClient = clients.get(id);
+		} else {
+			httpClient = HttpClients.custom().setConnectionManager(cm).build();
+			clients.put(id, httpClient);
+		}
+		return httpClient;
+	}
+
+	private String hash256(String data) {
+		try {
+			MessageDigest md;
+			md = MessageDigest.getInstance("SHA-256");
+			md.update(data.getBytes());
+			return bytesToHex(md.digest());
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	private String bytesToHex(byte[] bytes) {
+		StringBuffer result = new StringBuffer();
+		for (byte byt : bytes)
+			result.append(Integer.toString((byt & 0xff) + 0x100, 16).substring(1));
+		return result.toString();
+	}
+
+	private String encodeURIComponent(String s) {
+		String result;
+
+		try {
+			result = URLEncoder.encode(s, "UTF-8").replaceAll("\\+", "%20").replaceAll("\\%21", "!")
+					.replaceAll("\\%27", "'").replaceAll("\\%28", "(").replaceAll("\\%29", ")")
+					.replaceAll("\\%7E", "~");
+		} catch (UnsupportedEncodingException e) {
+			result = s;
+		}
+
+		return result;
+	}
+
+	private String urlFrom(String id, String format) throws UnsupportedEncodingException {
+		if (format == null) {
+			return "http://" + host + "/api/db/" + gamecloudUser + "/" + encodeURIComponent(id);
+		} else {
+			return "http://" + host + "/api/db/" + gamecloudUser + "/" + encodeURIComponent(id) + "/" + format;
+		}
+
+	}
+	
+	private class StringResponseHandler implements ResponseHandler<CloudResponse> {
+		public CloudResponse handleResponse(final HttpResponse response) throws IOException {
+			CloudResponse couchResponse = new CloudResponse();
+			int status = response.getStatusLine().getStatusCode();
+			couchResponse.status = status;
+			HttpEntity entity = response.getEntity();
+			if (entity != null) {
+				couchResponse.stringBody = EntityUtils.toString(entity);
+			}
+			return couchResponse;
+		}
+	}
+
+	private class ByteArrayResponseHandler implements ResponseHandler<CloudResponse> {
+		public CloudResponse handleResponse(final HttpResponse response) throws IOException {
+			int status = response.getStatusLine().getStatusCode();
+			CloudResponse couchResponse = new CloudResponse();
+			couchResponse.status = status;
+			HttpEntity entity = response.getEntity();
+			if (entity != null) {
+				couchResponse.byteBody = EntityUtils.toByteArray(entity);
+			}
+			return couchResponse;
+		}
+	}
+
+}