Cleanup code

Author: ribasco

core/src/main/java/com/ibasco/agql/core/AbstractClient.java

@@ -32,10 +32,11 @@
 import java.io.IOException;
 import java.util.concurrent.CompletableFuture;
 
-abstract public class AbstractClient<Req extends AbstractRequest,
-        Res extends AbstractResponse,
-        M extends AbstractMessenger<Req, Res>>
-        implements Client<Req, Res> {
+abstract public class AbstractClient<R extends AbstractRequest,
+        S extends AbstractResponse,
+        M extends AbstractMessenger<R, S>>
+        implements Client<R, S> {
+
     private M messenger;
 
     private static final Logger log = LoggerFactory.getLogger(AbstractClient.class);
@@ -45,19 +46,14 @@ public AbstractClient(M messenger) {
     }
 
     @Override
-    public <V> CompletableFuture<V> sendRequest(Req message) {
-        return sendRequest(message, AbstractMessenger.DEFAULT_REQUEST_PRIORITY);
-    }
-
-    protected <V> CompletableFuture<V> sendRequest(Req message, RequestPriority priority) {
+    public <V> CompletableFuture<V> sendRequest(R message) {
         log.debug("Client '{}' Sending request : {}", this.getClass().getSimpleName(), message);
         //Send the request then transform the result once a response is received
-        ConcurrentUtils.sleepUninterrupted(10);
-        return messenger.send(message, priority).thenApply(this::convertToResultType);
+        return messenger.send(message).thenApply(this::convertToResultType);
     }
 
     @SuppressWarnings("unchecked")
-    private <V> V convertToResultType(Res message) {
+    private <V> V convertToResultType(S message) {
         return (V) message.getMessage();
     }
 

core/src/main/java/com/ibasco/agql/core/AbstractMessenger.java

@@ -27,6 +27,6 @@
 import java.io.Closeable;
 import java.util.concurrent.CompletableFuture;
 
-public interface Client<Req extends AbstractRequest, Res extends AbstractResponse> extends Closeable {
-    <V> CompletableFuture<V> sendRequest(Req message);
+public interface Client<R extends AbstractRequest, S extends AbstractResponse> extends Closeable {
+    <V> CompletableFuture<V> sendRequest(R message);
 }

core/src/main/java/com/ibasco/agql/core/Client.java

@@ -31,7 +31,8 @@
 /**
  * {@link Messenger} is responsible for sending and receiving messages from clients.
  */
-public interface Messenger<Req extends AbstractRequest, Response extends AbstractResponse>
-        extends BiConsumer<Response, Throwable>, Closeable {
-    CompletableFuture<Response> send(Req request);
+public interface Messenger<R extends AbstractRequest, S extends AbstractResponse> extends Closeable {
+    CompletableFuture<S> send(R request);
+
+    void receive(S response, Throwable error);
 }

core/src/main/java/com/ibasco/agql/core/Messenger.java

@@ -24,7 +24,6 @@
 
 package com.ibasco.agql.core;
 
-import com.ibasco.agql.core.enums.RequestPriority;
 import com.ibasco.agql.core.enums.RequestStatus;
 import org.apache.commons.lang3.builder.EqualsBuilder;
 import org.apache.commons.lang3.builder.HashCodeBuilder;
@@ -38,23 +37,22 @@
 
 /**
  * Contains all the properties associated with this request
+ *
+ * @deprecated
  */
-public class RequestDetails<Req extends AbstractRequest, Res extends AbstractResponse> implements Comparable<RequestDetails> {
+public class RequestDetails<R extends AbstractRequest, S extends AbstractResponse> {
     private static final Logger log = LoggerFactory.getLogger(RequestDetails.class);
-    private Req request;
-    private CompletableFuture<Res> clientPromise;
+    private R request;
+    private CompletableFuture<S> promise;
     private RequestStatus status;
-    private RequestPriority priority;
-    private Transport<Req> transport;
-    private Class<Res> expectedResponseClass;
+    private Transport<R> transport;
     private AtomicInteger retries = new AtomicInteger(0);
     private long timeCreated;
 
-    public RequestDetails(Req request, CompletableFuture<Res> clientPromise, RequestPriority priority, Transport<Req> transport) {
+    public RequestDetails(R request, CompletableFuture<S> promise, Transport<R> transport) {
         this.status = RequestStatus.NEW;
         this.request = request;
-        this.clientPromise = clientPromise;
-        this.priority = priority;
+        this.promise = promise;
         this.transport = transport;
         this.timeCreated = System.currentTimeMillis();
     }
@@ -64,48 +62,32 @@ public RequestDetails(Req request, CompletableFuture<Res> clientPromise, Request
      *
      * @param requestDetails An {@link RequestDetails} that will be used as reference for the copy
      */
-    public RequestDetails(RequestDetails<Req, Res> requestDetails) {
+    public RequestDetails(RequestDetails<R, S> requestDetails) {
         this.request = requestDetails.getRequest();
-        this.clientPromise = requestDetails.getClientPromise();
+        this.promise = requestDetails.getPromise();
         this.status = requestDetails.getStatus();
-        this.priority = requestDetails.getPriority();
+        this.transport = requestDetails.getTransport();
+        this.timeCreated = System.currentTimeMillis();
         this.retries = new AtomicInteger(requestDetails.getRetries());
-        this.expectedResponseClass = requestDetails.getExpectedResponseClass();
-    }
-
-    public Class<Res> getExpectedResponseClass() {
-        return expectedResponseClass;
     }
 
-    public void setExpectedResponseClass(Class<Res> expectedResponseClass) {
-        this.expectedResponseClass = expectedResponseClass;
+    public synchronized CompletableFuture<S> getPromise() {
+        return promise;
     }
 
-    public synchronized CompletableFuture<Res> getClientPromise() {
-        return clientPromise;
-    }
-
-    public synchronized void setClientPromise(CompletableFuture<Res> clientPromise) {
-        this.clientPromise = clientPromise;
-    }
-
-    public synchronized RequestPriority getPriority() {
-        return priority;
-    }
-
-    public synchronized void setPriority(RequestPriority priority) {
-        this.priority = priority;
+    public synchronized void setPromise(CompletableFuture<S> promise) {
+        this.promise = promise;
     }
 
     public int getRetries() {
         return retries.get();
     }
 
-    public synchronized void setRequest(Req request) {
+    public synchronized void setRequest(R request) {
         this.request = request;
     }
 
-    public synchronized Req getRequest() {
+    public synchronized R getRequest() {
         return request;
     }
 
@@ -121,7 +103,7 @@ public int incrementRetry() {
         return this.retries.getAndAdd(1);
     }
 
-    public Transport<Req> getTransport() {
+    public Transport<R> getTransport() {
         return transport;
     }
 
@@ -143,7 +125,7 @@ public boolean equals(Object o) {
             return false;
         if (!(o instanceof RequestDetails))
             return false;
-        final RequestDetails rhs = (RequestDetails) o;
+        RequestDetails rhs = (RequestDetails) o;
         return new EqualsBuilder()
                 .append(this.getClass(), rhs.getClass())
                 .append(this.getRequest(), rhs.getRequest())
@@ -160,17 +142,11 @@ public int hashCode() {
                 .toHashCode();
     }
 
-    @Override
-    public int compareTo(RequestDetails o) {
-        return this.priority.compareTo(o.getPriority());
-    }
-
     @Override
     public String toString() {
         return new ToStringBuilder(this, ToStringStyle.NO_CLASS_NAME_STYLE)
                 .append("Request", this.getRequest().getClass().getSimpleName())
                 .append("Created", this.getTimeCreated())
-                .append("Priority", this.getPriority())
                 .append("Status", this.getStatus())
                 .toString();
     }

core/src/main/java/com/ibasco/agql/core/RequestDetails.java

@@ -27,27 +27,26 @@
 import com.ibasco.agql.core.AbstractGameServerRequest;
 import com.ibasco.agql.core.AbstractGameServerResponse;
 import com.ibasco.agql.core.AbstractMessenger;
-import com.ibasco.agql.core.enums.ProcessingMode;
-import com.ibasco.agql.core.session.AbstractSessionIdFactory;
-import com.ibasco.agql.core.session.SessionManager;
+import com.ibasco.agql.core.enums.QueueStrategy;
+import com.ibasco.agql.core.session.SessionIdFactory;
 
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ExecutorService;
 
 /**
  * Messenger using the UDP Transport protocol
  */
 abstract public class GameServerMessenger<A extends AbstractGameServerRequest, B extends AbstractGameServerResponse>
         extends AbstractMessenger<A, B> {
 
-    public GameServerMessenger(ProcessingMode processingMode) {
-        super(processingMode);
+    public GameServerMessenger(QueueStrategy queueStrategy, ExecutorService executorService) {
+        this(null, queueStrategy, executorService);
     }
 
-    public GameServerMessenger(AbstractSessionIdFactory keyFactory, ProcessingMode processingMode) {
-        super(keyFactory, processingMode);
+    public GameServerMessenger(SessionIdFactory idFactory, QueueStrategy queueStrategy) {
+        this(idFactory, queueStrategy, null);
     }
 
-    public GameServerMessenger(SessionManager sessionManager, ProcessingMode processingMode, int initQueueCapacity, ScheduledExecutorService executorService) {
-        super(sessionManager, processingMode, initQueueCapacity, executorService);
+    public GameServerMessenger(SessionIdFactory idFactory, QueueStrategy queueStrategy, ExecutorService executorService) {
+        super(idFactory, queueStrategy, executorService);
     }
 }