Fix #7 - allow creation of clients with a given number of http connections, static list of open clients etc

Author: pmcq

src/main/java/com/algorithmia/Algorithmia.java

@@ -8,14 +8,14 @@
  * Instantiate Algorithmia clients for calling algorithms and accessing data
  */
 public final class Algorithmia {
-
+    private static final int DEFAULT_MAX_CONNECTIONS = 10;
     private static AlgorithmiaClient defaultClient = null;
 
     private Algorithmia() {} // Not instantiable
 
     /**
      * Returns the default Algorithmia client which will
-     * look for ALGORITHMI_API_KEY environment variable or java property
+     * look for ALGORITHMIA_API_KEY environment variable or java property
      * If no key is found, then requests will be unauthenticated which only works
      * when making requests from an algorithm running within the Algorithmia cluster
      * @return an Algorithmia client
@@ -24,11 +24,22 @@ public static AlgorithmiaClient client() {
         return getDefaultClient();
     }
 
+    /**
+     * Returns the default Algorithmia client which will
+     * look for ALGORITHMIA_API_KEY environment variable or java property
+     * If no key is found, then requests will be unauthenticated which only works
+     * when making requests from an algorithm running within the Algorithmia cluster
+     * @param maxConnections max number of concurrent connections to hold open to Algorithmia
+     * @return an Algorithmia client
+     */
+    public static AlgorithmiaClient client(int maxConnections) {
+        return new AlgorithmiaClient(null, maxConnections);
+    }
 
     /**
      * Builds an Algorithmia client that makes all requests with your API key
      * If API key is null, the default client is returned, which will
-     * look for ALGORITHMI_API_KEY environment variable or java property
+     * look for ALGORITHMIA_API_KEY environment variable or java property
      * If no key is found, then requests will be unauthenticated which only works
      * when making requests from an algorithm running within the Algorithmia cluster
      * @param simpleKey API Key for simple authentication (prefixed with "sim")
@@ -38,10 +49,29 @@ public static AlgorithmiaClient client(String simpleKey) {
         if(simpleKey == null) {
             return getDefaultClient();
         } else {
-            return new AlgorithmiaClient(new SimpleAuth(simpleKey));
+            return new AlgorithmiaClient(new SimpleAuth(simpleKey), DEFAULT_MAX_CONNECTIONS);
         }
     }
 
+    /**
+     * Builds an Algorithmia client that makes all requests with your API key
+     * If API key is null, the default client is returned, which will
+     * look for ALGORITHMIA_API_KEY environment variable or java property
+     * If no key is found, then requests will be unauthenticated which only works
+     * when making requests from an algorithm running within the Algorithmia cluster
+     * @param simpleKey API Key for simple authentication (prefixed with "sim")
+     * @param maxConnections max number of concurrent connections to hold open to Algorithmia
+     * @return an Algorithmia client
+     */
+    public static AlgorithmiaClient client(String simpleKey, int maxConnections) {
+        if(simpleKey == null) {
+            return getDefaultClient();
+        } else {
+            return new AlgorithmiaClient(new SimpleAuth(simpleKey), maxConnections);
+        }
+    }
+
+
     /**
      * Initialize an Algorithm object using the default client
      * @param algoUri the algorithm's URI, e.g., algo://user/algoname
@@ -71,7 +101,7 @@ public static DataFile file(String path) {
 
     private static AlgorithmiaClient getDefaultClient() {
         if(defaultClient == null) {
-            defaultClient = new AlgorithmiaClient();
+            defaultClient = new AlgorithmiaClient(null, DEFAULT_MAX_CONNECTIONS);
         }
         return defaultClient;
     }

src/main/java/com/algorithmia/AlgorithmiaClient.java

@@ -10,19 +10,13 @@
 public final class AlgorithmiaClient {
     private HttpClient client;
     /**
-     * Instantiate Algorithmia client without credentials
-     * This only works for when running the client on top of the Algorithmia platform
+     * Instantiate Algorithmia client with the given auth and max number of connections
+     * @param auth Algorithmia Auth object, a null auth object is valid, though only
+     * correct for within the Algorithmia platform
+     * @param maxConnections
      */
-    protected AlgorithmiaClient() {
-        this.client = new HttpClient(null);
-    }
-
-    /**
-     * Instantiate Algorithmia client with auth
-     * @param auth Algorithmia Auth object
-     */
-    protected AlgorithmiaClient(Auth auth) {
-        this.client = new HttpClient(auth);
+    protected AlgorithmiaClient(Auth auth, int maxConnections) {
+        this.client = new HttpClient(auth, maxConnections);
     }
 
     /**

src/main/java/com/algorithmia/client/HttpClient.java

@@ -9,6 +9,7 @@
 import org.apache.http.entity.ContentType;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
+import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
 import org.apache.http.impl.nio.client.HttpAsyncClients;
 import org.apache.http.nio.client.methods.AsyncByteConsumer;
 import org.apache.http.nio.client.methods.ZeroCopyConsumer;
@@ -25,6 +26,8 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.CancellationException;
@@ -43,30 +46,37 @@ public class HttpClient {
 
     private static String userAgent = "algorithmia-java/" + "1.0.8";
 
-    private CloseableHttpAsyncClient client;
-
-    public HttpClient(Auth auth) {
-        this.auth = auth;
-        initializeClient();
-    }
-
-    private void initializeClient() {
-        // Note: the default client has a low max number of concurrent connections, can create a
-        // custom client with a higher limit if desired, but at least creating multiple Algorithmia clients
-        // will guaranteed increase parallelization
-        client = HttpAsyncClients.createDefault();
-        client.start();
+    private static List<CloseableHttpAsyncClient> clients = new LinkedList<CloseableHttpAsyncClient>();
 
+    static {
         Runtime.getRuntime().addShutdownHook(new Thread(){
             @Override
             public void run(){
-                try {
-                    client.close();
-                } catch(IOException e) {}
+                synchronized (clients) {
+                    for (CloseableHttpAsyncClient client : clients) {
+                        try {
+                            client.close();
+                        } catch (IOException e) {}
+                    }
+                }
             }
         });
     }
 
+    private final CloseableHttpAsyncClient client;
+    public HttpClient(Auth auth, int maxConnections) {
+        this.auth = auth;
+
+        client = HttpAsyncClientBuilder.create()
+            .setMaxConnTotal(maxConnections)
+            .setMaxConnPerRoute(maxConnections).build();
+
+        synchronized (clients) {
+            clients.add(client);
+        }
+        client.start();
+    }
+
     /**
      * Modifies request in place to add on any query parameters
      */
@@ -254,4 +264,11 @@ protected HttpResponse buildResult(final HttpContext context) throws Exception {
         protected void onByteReceived(final ByteBuffer buf, final IOControl ioctrl) {
         }
     }
+
+    @Override
+    protected void finalize() {
+        synchronized (clients) {
+            clients.remove(client);
+        }
+    }
 }