Merge pull request #217 from floralvikings/v0.7.0-alpha-release

V0.7.0 alpha release

README.md

@@ -1,4 +1,4 @@
-Jenjin ![Build Status](https://travis-ci.org/floralvikings/jenjin.svg?branch=jenjin-184)
+Jenjin ![Build Status](https://travis-ci.org/floralvikings/jenjin.svg?branch=master)
 =====
 
 The Jenjin is a flexible server architecture designed for use in MMORPGs.
@@ -46,7 +46,7 @@ the Travis automated building is helping with that a great deal.
 
 Special thanks go out to:
 
-* [This blog](http://seamless-pixels.blogspot.co.uk/), which supplied all the textures used in the demo application.  These
+* [This blog](http://seamless-pixels.blogspot.co.uk/), which supplied all the textures used in early testing versions of the demo application.  These
 textures are high-resolution, tileable, and very, very nice.  They are completely free but there is an option to download the entire
 archive for as little as $1.99 should you desire to support an open-source artist. (You should.)
 
@@ -58,3 +58,4 @@ The Jenjin itself does not use any third party dependencies; however, the tests
 
 * The Jenjin uses [TestNG](http://testng.org/doc/index.html) for unit tests. ([License](http://testng.org/license/))
 * For database integration tests, [H2Database](http://h2database.com/html/main.html) is used. ([License](http://h2database.com/html/license.html))
+* The Jenjin World modules make use of [Gson](https://code.google.com/p/google-gson/). ([License](http://www.apache.org/licenses/LICENSE-2.0))

build.gradle

@@ -2,12 +2,11 @@ allprojects {
     apply plugin: 'maven'
 
     group = 'com.jenjinstudios'
-    version = '0.6.0-alpha'
+    version = '0.7.0-alpha'
 }
 
 subprojects {
     apply plugin: 'java'
-    //apply plugin: 'jacoco'
 
     repositories {
         mavenLocal()

jenjin-core-client/build.gradle

@@ -1,4 +1,4 @@
-description = ''
+description = 'Jenjin Core Client'
 
 dependencies {
     compile project(':jenjin-core')

jenjin-core-client/src/main/java/com/jenjinstudios/client/message/ClientExecutableMessage.java

@@ -1,13 +1,14 @@
 package com.jenjinstudios.client.message;
 
-import com.jenjinstudios.core.message.ExecutableMessage;
-import com.jenjinstudios.core.io.Message;
 import com.jenjinstudios.client.net.Client;
+import com.jenjinstudios.core.io.Message;
+import com.jenjinstudios.core.message.ExecutableMessage;
 
 /**
  * Superclass of ExecutableMessages used by the client.
  * @author Caleb Brinkman
  */
+// TODO This class can probably be refactored away; should the subclasses just cast the constructor arguments?
 public abstract class ClientExecutableMessage extends ExecutableMessage
 {
 	/** The client invoking this ExecutableMessage. */

jenjin-core-client/src/main/java/com/jenjinstudios/client/message/ClientMessageFactory.java

@@ -2,27 +2,31 @@
 
 import com.jenjinstudios.client.net.ClientUser;
 import com.jenjinstudios.core.io.Message;
+import com.jenjinstudios.core.io.MessageRegistry;
 import com.jenjinstudios.core.util.MessageFactory;
 
 /**
  * Used to generate messages for the Jenjin core client.
+ *
  * @author Caleb Brinkman
  */
 public class ClientMessageFactory extends MessageFactory
 {
 
 	/**
 	 * Generate a LogoutRequest message.
+	 *
 	 * @return The LogoutRequestMessage.
 	 */
-	public Message generateLogoutRequest() {return getMessageRegistry().createMessage("LogoutRequest");}
+	public Message generateLogoutRequest() { return MessageRegistry.getInstance().createMessage("LogoutRequest");}
 
 	/**
 	 * Generate a LoginRequest message.  This message will be encrypted if possible.
+	 *
 	 * @return The LoginRequest message.
 	 */
 	public Message generateLoginRequest(ClientUser user) {// Create the login request.
-		Message loginRequest = getMessageRegistry().createMessage("LoginRequest");
+		Message loginRequest = MessageRegistry.getInstance().createMessage("LoginRequest");
 		loginRequest.setArgument("username", user.getUsername());
 		loginRequest.setArgument("password", user.getPassword());
 		return loginRequest;

jenjin-core-client/src/main/java/com/jenjinstudios/client/net/Client.java

@@ -3,13 +3,15 @@
 import com.jenjinstudios.client.message.ClientMessageFactory;
 import com.jenjinstudios.core.Connection;
 import com.jenjinstudios.core.MessageIO;
+import com.jenjinstudios.core.util.MessageFactory;
 
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Timer;
 
 /**
  * The base class for any client.  This class uses a similar system to the JGSA.
+ *
  * @author Caleb Brinkman
  */
 public class Client extends Connection
@@ -20,6 +22,7 @@ public class Client extends Connection
 	private final ClientMessageFactory messageFactory;
 	/** The timer that manages the update loop. */
 	private Timer sendMessagesTimer;
+	private ClientLoop clientLoop = new ClientLoop(this);
 
 	/**
 	 * Construct a new client and attempt to connect to the server over the specified port.
@@ -32,6 +35,7 @@ protected Client(MessageIO messageIO) {
 
 	/**
 	 * Add a task to the repeated queue of this client.  Should be called to extend client functionality.
+	 *
 	 * @param r The task to be performed.
 	 */
 	public void addRepeatedTask(Runnable r) {
@@ -52,16 +56,15 @@ public void shutdown() {
 	}
 
 	@Override
-	public void run() {
+	public void start() {
 		int period = 1000 / 60;
-
 		// Finally, send a ping request to establish latency.
-		queueOutgoingMessage(messageFactory.generatePingRequest());
+		getMessageIO().queueOutgoingMessage(MessageFactory.generatePingRequest());
 
 		sendMessagesTimer = new Timer("Client Update Loop", false);
-		sendMessagesTimer.scheduleAtFixedRate(new ClientLoop(this), 0, period);
+		sendMessagesTimer.scheduleAtFixedRate(clientLoop, 0, period);
 
-		super.run();
+		super.start();
 	}
 
 	/** Run the repeated synchronized tasks. */
@@ -72,4 +75,6 @@ protected void runRepeatedTasks() {
 				r.run();
 		}
 	}
+
+	public double getAverageUPS() { return 1d / clientLoop.getAverageRunTime(); }
 }

jenjin-core-client/src/main/java/com/jenjinstudios/client/net/ClientLoop.java

@@ -1,19 +1,25 @@
 package com.jenjinstudios.client.net;
 
+import java.io.IOException;
 import java.util.TimerTask;
 
 /**
  * The ClientLoop class is essentially what amounts to the output thread.
+ *
  * @author Caleb Brinkman
  */
 
 class ClientLoop extends TimerTask
 {
 	/** The Client for this loop. */
 	private final Client client;
+	private int updateCount = 0;
+	private long lastStart = System.nanoTime();
+	private final long[] updateTimesNanos = new long[50];
 
 	/**
 	 * Construct a ClientLoop for the given client.
+	 *
 	 * @param client The client for this ClientLoop
 	 */
 	public ClientLoop(Client client) {
@@ -22,9 +28,34 @@ public ClientLoop(Client client) {
 
 	@Override
 	public void run() {
+		updateCount++;
+		saveUpdateTime();
 		client.runRepeatedTasks();
-		client.runQueuedExecutableMessages();
-		client.writeAllMessages();
+		client.getExecutableMessageQueue().runQueuedExecutableMessages();
+		try
+		{
+			client.getMessageIO().writeAllMessages();
+		} catch (IOException e)
+		{
+			client.shutdown();
+		}
+	}
+
+	private void saveUpdateTime() {
+		long newStart = System.nanoTime();
+		long timeElapsed = newStart - lastStart;
+		lastStart = newStart;
+		updateTimesNanos[updateCount % updateTimesNanos.length] = timeElapsed;
+	}
+
+	public double getAverageRunTime() {
+		double maxIndex = Math.min(updateCount, updateTimesNanos.length);
+		double total = 0;
+		for (int i = 0; i < maxIndex; i++)
+		{
+			total += updateTimesNanos[i];
+		}
+		return (total / maxIndex) / 1000000000;
 	}
 
 }

jenjin-core-client/src/main/java/com/jenjinstudios/client/net/LoginTracker.java

@@ -34,7 +34,7 @@ public void setLoggedIn(boolean loggedIn) {
 	protected void sendLoginRequest() {
 		waitingForResponse = true;
 		Message message = ((ClientMessageFactory) client.getMessageFactory()).generateLoginRequest(client.getUser());
-		client.queueOutgoingMessage(message);
+		client.getMessageIO().queueOutgoingMessage(message);
 	}
 
 	public boolean sendLoginRequestAndWaitForResponse() {
@@ -59,7 +59,7 @@ public void sendLogoutRequestAndWaitForResponse() {
 	private void sendLogoutRequest() {
 		waitingForResponse = true;
 		Message message = ((ClientMessageFactory) client.getMessageFactory()).generateLogoutRequest();
-		client.queueOutgoingMessage(message);
+		client.getMessageIO().queueOutgoingMessage(message);
 	}
 
 	private void waitTenMillis() {

jenjin-core-client/src/main/resources/com/jenjinstudios/client/Messages.xml

@@ -1,26 +1,26 @@
 <?xml version="1.0" ?>
 
-<messages>
+<messages xmlns="https://www.jenjinstudios.com">
 
-    <message name="LoginRequest" id="101">
+<message name="LoginRequest" id="101">
         <argument type="String" name="username" encrypt="true" />
         <argument type="String" name="password" encrypt="true" />
-        <executable language="java">com.jenjinstudios.server.message.ExecutableLoginRequest</executable>
+        <executable>com.jenjinstudios.server.message.ExecutableLoginRequest</executable>
     </message>
 
     <message name="LoginResponse" id="102">
         <argument type="boolean" name="success" />
         <argument type="long" name="loginTime" />
-        <executable language="java">com.jenjinstudios.client.message.ExecutableLoginResponse</executable>
+        <executable>com.jenjinstudios.client.message.ExecutableLoginResponse</executable>
     </message>
 
     <message name="LogoutRequest" id="103">
-        <executable language="java">com.jenjinstudios.server.message.ExecutableLogoutRequest</executable>
+        <executable>com.jenjinstudios.server.message.ExecutableLogoutRequest</executable>
     </message>
 
     <message name="LogoutResponse" id="104">
         <argument type="boolean" name="success" />
-        <executable language="java">com.jenjinstudios.client.message.ExecutableLogoutResponse</executable>
+        <executable>com.jenjinstudios.client.message.ExecutableLogoutResponse</executable>
     </message>
 
 </messages>

jenjin-core-client/src/test/java/com/jenjinstudios/client/net/AuthClientTest.java

@@ -7,7 +7,6 @@
 import org.testng.annotations.Test;
 
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 /**
  * @author Caleb Brinkman
@@ -16,11 +15,9 @@ public class AuthClientTest
 {
 	@Test
 	public void testIsLoggedIn() {
-		MessageIO messageIO = mock(MessageIO.class);
 		MessageInputStream mis = mock(MessageInputStream.class);
 		MessageOutputStream mos = mock(MessageOutputStream.class);
-		when(messageIO.getIn()).thenReturn(mis);
-		when(messageIO.getOut()).thenReturn(mos);
+		MessageIO messageIO = new MessageIO(mis, mos);
 		ClientUser clientUser = mock(ClientUser.class);
 		boolean random = Math.random() * 10 % 2 == 0;
 		AuthClient authClient = new AuthClient(messageIO, clientUser);
@@ -31,11 +28,9 @@ public void testIsLoggedIn() {
 
 	@Test
 	public void testLoggedInTime() {
-		MessageIO messageIO = mock(MessageIO.class);
 		MessageInputStream mis = mock(MessageInputStream.class);
 		MessageOutputStream mos = mock(MessageOutputStream.class);
-		when(messageIO.getIn()).thenReturn(mis);
-		when(messageIO.getOut()).thenReturn(mos);
+		MessageIO messageIO = new MessageIO(mis, mos);
 		ClientUser clientUser = mock(ClientUser.class);
 		long random = (long) (Math.random() * 1000);
 		AuthClient authClient = new AuthClient(messageIO, clientUser);
@@ -46,11 +41,9 @@ public void testLoggedInTime() {
 
 	@Test
 	public void testGetUser() {
-		MessageIO messageIO = mock(MessageIO.class);
 		MessageInputStream mis = mock(MessageInputStream.class);
 		MessageOutputStream mos = mock(MessageOutputStream.class);
-		when(messageIO.getIn()).thenReturn(mis);
-		when(messageIO.getOut()).thenReturn(mos);
+		MessageIO messageIO = new MessageIO(mis, mos);
 		ClientUser clientUser = mock(ClientUser.class);
 		AuthClient authClient = new AuthClient(messageIO, clientUser);
 

jenjin-core-client/src/test/java/com/jenjinstudios/client/net/ClientTest.java

@@ -5,7 +5,8 @@
 import com.jenjinstudios.core.io.MessageOutputStream;
 import org.testng.annotations.Test;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 /**
  * @author Caleb Brinkman
@@ -14,11 +15,9 @@ public class ClientTest
 {
 	@Test
 	public void testAddRepeatedTask() {
-		MessageIO messageIO = mock(MessageIO.class);
 		MessageInputStream mis = mock(MessageInputStream.class);
 		MessageOutputStream mos = mock(MessageOutputStream.class);
-		when(messageIO.getIn()).thenReturn(mis);
-		when(messageIO.getOut()).thenReturn(mos);
+		MessageIO messageIO = new MessageIO(mis, mos);
 		Runnable r = mock(Runnable.class);
 		Client client = new Client(messageIO);
 		client.addRepeatedTask(r);

jenjin-core-server/build.gradle

@@ -1,4 +1,4 @@
-description = ''
+description = 'Jenjin Core Server'
 
 
 dependencies {

jenjin-core-server/src/main/java/com/jenjinstudios/server/message/ExecutableLoginRequest.java

@@ -11,6 +11,7 @@
 
 /**
  * Executes the necessary actions to deal with a login response.
+ *
  * @author Caleb Brinkman
  */
 @SuppressWarnings("unused")
@@ -22,6 +23,7 @@ public class ExecutableLoginRequest extends ServerExecutableMessage
 
 	/**
 	 * Construct a new ExecutableLoginRequest.
+	 *
 	 * @param clientHandler The handler which created this executable message.
 	 * @param loginRequest The request sent by the client.
 	 */
@@ -55,14 +57,14 @@ public void runImmediate() {
 
 	private void queueLoginSuccessResponse(long loggedInTime) {
 		Message loginResponse = getClientHandler().getMessageFactory().generateLoginResponse(true, loggedInTime);
-		getClientHandler().queueOutgoingMessage(loginResponse);
+		getClientHandler().getMessageIO().queueOutgoingMessage(loginResponse);
 	}
 
 	private void queueLoginFailureResponse() {
 		ClientHandler clientHandler = getClientHandler();
 		ServerMessageFactory messageFactory = clientHandler.getMessageFactory();
 		Message loginResponse = messageFactory.generateLoginResponse(false, 0);
-		clientHandler.queueOutgoingMessage(loginResponse);
+		clientHandler.getMessageIO().queueOutgoingMessage(loginResponse);
 	}
 
 }