Fix/close connections (#94)

* Client: Always close stream, consume connection whenever appropriate

* Tests: Add a test to ensure KeepAlive is working

Author: PLNech

algoliasearch/src/main/java/com/algolia/search/saas/Client.java

@@ -659,10 +659,12 @@ private byte[] _requestRaw(Method m, String url, String json, List<String> hosts
                     throw new IllegalArgumentException("Method " + m + " is not supported");
             }
 
+            InputStream stream = null;
+            HttpURLConnection hostConnection = null;
             // set URL
             try {
                 URL hostURL = new URL("https://" + host + url);
-                HttpURLConnection hostConnection = (HttpURLConnection) hostURL.openConnection();
+                hostConnection = (HttpURLConnection) hostURL.openConnection();
 
                 //set timeouts
                 hostConnection.setRequestMethod(requestMethod);
@@ -694,8 +696,7 @@ private byte[] _requestRaw(Method m, String url, String json, List<String> hosts
                 // read response
                 int code = hostConnection.getResponseCode();
                 final boolean codeIsError = code / 100 != 2;
-                InputStream stream = codeIsError ?
-                        hostConnection.getErrorStream() : hostConnection.getInputStream();
+                stream = codeIsError ? hostConnection.getErrorStream() : hostConnection.getInputStream();
                 // As per the official Java docs (not the Android docs):
                 // - `getErrorStream()` may return null => we have to handle this case.
                 //   See <https://docs.oracle.com/javase/7/docs/api/java/net/HttpURLConnection.html#getErrorStream()>.
@@ -716,27 +717,36 @@ private byte[] _requestRaw(Method m, String url, String json, List<String> hosts
                 // handle http errors
                 if (codeIsError) {
                     if (code / 100 == 4) {
-                        String message = _getJSONObject(rawResponse).getString("message");
                         consumeQuietly(hostConnection);
-                        throw new AlgoliaException(message, code);
+                        throw new AlgoliaException(_getJSONObject(rawResponse).getString("message"), code);
                     } else {
-                        final String errorMessage = _toCharArray(stream);
                         consumeQuietly(hostConnection);
-                        errors.add(new AlgoliaException(errorMessage, code));
+                        errors.add(new AlgoliaException(_toCharArray(stream), code));
                         continue;
                     }
                 }
                 return rawResponse;
 
             }
             catch (JSONException e) { // fatal
+                consumeQuietly(hostConnection);
                 throw new AlgoliaException("Invalid JSON returned by server", e);
             }
             catch (UnsupportedEncodingException e) { // fatal
+                consumeQuietly(hostConnection);
                 throw new AlgoliaException("Invalid encoding returned by server", e);
             }
             catch (IOException e) { // host error, continue on the next host
+                consumeQuietly(hostConnection);
                 errors.add(e);
+            } finally {
+                if (stream != null) {
+                    try {
+                        stream.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
             }
         }
 

algoliasearch/src/test/java/com/algolia/search/saas/IndexTest.java

@@ -478,6 +478,70 @@ public void testSNI() throws Exception {
         testSearchAsync();
     }
 
+    @Test
+    public void testKeepAlive() throws Exception {
+        final int nbTimes = 10;
+
+        // Given all hosts being the same one
+        String appId = (String) Whitebox.getInternalState(client, "applicationID");
+        List<String> hostsArray = (List<String>) Whitebox.getInternalState(client, "readHosts");
+        hostsArray.set(0, appId + "-1.algolianet.com");
+        hostsArray.set(1, appId + "-1.algolianet.com");
+        hostsArray.set(2, appId + "-1.algolianet.com");
+        hostsArray.set(3, appId + "-1.algolianet.com");
+        Whitebox.setInternalState(client, "readHosts", hostsArray);
+
+        //And an index that does not cache search queries
+        index.disableSearchCache();
+
+
+        // Expect first successful search
+        final long[] startEndTimeArray = new long[2];
+        startEndTimeArray[0] = System.nanoTime();
+        final CountDownLatch signal = new CountDownLatch(1);
+        index.searchAsync(new Query("Francisco"), new CompletionHandler() {
+            @Override
+            public void requestCompleted(JSONObject content, AlgoliaException error) {
+                if (error == null) {
+                    assertEquals(1, content.optInt("nbHits"));
+                    startEndTimeArray[1] = System.nanoTime();
+                } else {
+                    fail(error.getMessage());
+                }
+                signal.countDown();
+            }
+        });
+        assertTrue("No callback was called", signal.await(Helpers.wait, TimeUnit.SECONDS));
+
+        final long firstDurationNanos = startEndTimeArray[1] - startEndTimeArray[0];
+        System.out.println("First query duration: " + firstDurationNanos);
+
+        final CountDownLatch signal2 = new CountDownLatch(nbTimes);
+        for (int i = 0; i < nbTimes; i++) {
+            startEndTimeArray[0] = System.nanoTime();
+            final int finalIter = i;
+            index.searchAsync(new Query("Francisco"), new CompletionHandler() {
+                @Override
+                public void requestCompleted(JSONObject content, AlgoliaException error) {
+                    if (error == null) {
+                        startEndTimeArray[1] = System.nanoTime();
+                        final long iterDiff = startEndTimeArray[1] - startEndTimeArray[0];
+                        final String iterString = String.format("iteration %d: %d < %d", finalIter, iterDiff, firstDurationNanos);
+
+                        // And successful fastest subsequent calls
+                        assertEquals(1, content.optInt("nbHits"));
+                        assertTrue("Subsequent calls should be fastest than first (" + iterString + ")", startEndTimeArray[1] - startEndTimeArray[0] < firstDurationNanos);
+                    } else {
+                        fail(error.getMessage());
+                    }
+                    signal2.countDown();
+                }
+            });
+        }
+        assertTrue("No callback was called", signal2.await(Helpers.wait, TimeUnit.SECONDS));
+    }
+
+
     private void addDummyObjects(int objectCount) throws Exception {
         // Construct an array of dummy objects.
         objects = new ArrayList<JSONObject>();