add OpenJDK 7 build + fix test race condition + javadoc fix (#42)

.circleci/config.yml

@@ -1,10 +1,27 @@
-version: 2
+version: 2.1
+
+workflows:
+  test:
+    jobs:
+      - openjdk8
+      - openjdk7
+
 jobs:
-   build:
-     docker:
-       - image: circleci/openjdk:8
-     environment:
-       - TERM: dumb
-     steps:
-       - checkout
-       - run: ./gradlew test sourcesJar javadocJar
+  openjdk8:
+    docker:
+      - image: circleci/openjdk:8
+    environment:
+      - TERM: dumb
+    steps:
+      - checkout
+      - run: ./gradlew test sourcesJar javadocJar
+
+  openjdk7:
+    # This build uses LaunchDarkly's ld-jdk7-jdk8 image which has both OpenJDK 7 and
+    # OpenJDK 8 installed, with 8 being the default that is used to run Gradle.
+    # See: https://github.com/launchdarkly/sdks-ci-docker
+    docker:
+      - image: ldcircleci/ld-jdk7-jdk8
+    steps:
+      - checkout
+      - run: ./gradlew -i -Dorg.gradle.project.overrideJavaHome=$JDK7_HOME test sourcesJar javadocJar

build.gradle

@@ -146,3 +146,34 @@ nexusPublishing {
 signing {
     sign publishing.publications.mavenJava
 }
+
+// Overriding JAVA_HOME/executable paths allows us to build/test under Java 7 even though
+// Gradle itself has to run in Java 8+.
+
+tasks.withType(AbstractCompile) {
+  options.with {
+    if (overrideJavaHome != "") {
+      System.out.println("Building with JAVA_HOME=" + overrideJavaHome)
+      fork = true
+      forkOptions.javaHome = file(overrideJavaHome)
+    }
+  }
+}
+
+tasks.withType(Javadoc) {
+  if (overrideJavaHome != "") {
+    executable = new File(overrideJavaHome, "bin/javadoc")
+  }
+}
+
+tasks.withType(Test) {
+  if (overrideJavaHome != "") {
+    executable = new File(overrideJavaHome, "bin/java")
+  }
+}
+
+tasks.withType(JavaExec) {
+  if (overrideJavaHome != "") {
+    executable = new File(overrideJavaHome, "bin/java")
+  }
+}

gradle.properties

@@ -2,5 +2,8 @@ version=1.11.1
 ossrhUsername=
 ossrhPassword=
 
+# See build.gradle
+overrideJavaHome=
+
 # See https://github.com/gradle/gradle/issues/11308 regarding the following property
 systemProp.org.gradle.internal.publish.checksums.insecure=true

src/main/java/com/launchdarkly/eventsource/EventSource.java

@@ -336,10 +336,12 @@ private void connect() {
 
           // Reset the backoff if we had a successful connection that stayed good for at least
           // backoffResetThresholdMs milliseconds.
-          if (connectedTime >= 0 && (System.currentTimeMillis() - connectedTime) >= backoffResetThresholdMs) {
-            reconnectAttempts = 0;
+          if (nextState != SHUTDOWN) {
+            if (connectedTime >= 0 && (System.currentTimeMillis() - connectedTime) >= backoffResetThresholdMs) {
+              reconnectAttempts = 0;
+            }
+            maybeWaitWithBackoff(++reconnectAttempts);
           }
-          maybeWaitWithBackoff(++reconnectAttempts);
         }
       }
     } catch (RejectedExecutionException ignored) {

src/main/java/com/launchdarkly/eventsource/ModernTLSSocketFactory.java

@@ -70,7 +70,7 @@ public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddre
    * If the socket does not make these modern TLS protocols available at all, then just return the socket unchanged.
    *
    * @param s the socket
-   * @return
+   * @return the updated socket
    */
   static Socket setModernTlsVersionsOnSocket(Socket s) {
     if (s != null && (s instanceof SSLSocket)) {

src/test/java/com/launchdarkly/eventsource/EventSourceHttpTest.java

@@ -203,13 +203,11 @@ public void eventSourceReconnectsAgainAfterErrorOnFirstReconnect() throws Except
 
   @Test
   public void streamDoesNotReconnectIfConnectionErrorHandlerSaysToStop() throws Exception {
-    final AtomicBoolean calledHandler = new AtomicBoolean(false);
-    final AtomicReference<Throwable> receivedError = new AtomicReference<Throwable>();
+    final BlockingQueue<Throwable> receivedError = new ArrayBlockingQueue<Throwable>(1);
 
     ConnectionErrorHandler connectionErrorHandler = new ConnectionErrorHandler() {
       public Action onConnectionError(Throwable t) {
-        calledHandler.set(true);
-        receivedError.set(t);
+        receivedError.add(t);
         return Action.SHUTDOWN;
       }
     };
@@ -222,19 +220,18 @@ public Action onConnectionError(Throwable t) {
           .reconnectTimeMs(10)
           .build()) {
         es.start();
-
-        // If a ConnectionErrorHandler returns SHUTDOWN, EventSource does not call onClosed() or onError()
-        // on the regular event handler, since it assumes that the caller already knows what happened.
-        // Therefore we don't expect to see any items in eventSink.
-        eventSink.assertNoMoreLogItems();
+
+        Throwable t = receivedError.poll(500, TimeUnit.MILLISECONDS);
+        assertNotNull(t);
+        assertEquals(UnsuccessfulResponseException.class, t.getClass());
+
+        // There's no way to know exactly when EventSource has transitioned its state to
+        // SHUTDOWN after calling the error handler, so this is an arbitrary delay
+        Thread.sleep(100);
 
         assertEquals(ReadyState.SHUTDOWN, es.getState());
       }
     }
-
-    assertTrue(calledHandler.get());
-    assertNotNull(receivedError.get());
-    assertEquals(UnsuccessfulResponseException.class, receivedError.get().getClass());
   }
 
   @Test