Created new TimeoutTimer class which makes use of a ScheduledExecutorService (#42)

Author: dsrees

build.gradle

@@ -1,10 +1,10 @@
 buildscript { repositories { jcenter() } }
 plugins {
-    id 'java'
-    id 'org.jetbrains.kotlin.jvm' version '1.2.51'
-    id 'nebula.project' version '4.0.1'
-    id "nebula.maven-publish" version "7.2.4"
-    id 'nebula.nebula-bintray' version '3.5.5'
+  id 'java'
+  id 'org.jetbrains.kotlin.jvm' version '1.2.51'
+  id 'nebula.project' version '4.0.1'
+  id "nebula.maven-publish" version "7.2.4"
+  id 'nebula.nebula-bintray' version '3.5.5'
 }
 
 group 'com.github.dsrees'
@@ -13,45 +13,45 @@ version '0.1.8'
 sourceCompatibility = 1.8
 
 repositories {
-    mavenCentral()
+  mavenCentral()
 }
 
 dependencies {
-    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    compile "com.google.code.gson:gson:2.8.5"
-    compile "com.squareup.okhttp3:okhttp:3.10.0"
+  compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+  compile "com.google.code.gson:gson:2.8.5"
+  compile "com.squareup.okhttp3:okhttp:3.10.0"
 
 
-    testCompile group: 'junit', name: 'junit', version: '4.12'
-    testCompile group: 'com.google.truth', name: 'truth', version: '0.42'
-    testCompile group: 'org.mockito', name: 'mockito-core', version: '2.19.1'
-
+  testCompile group: 'junit', name: 'junit', version: '4.12'
+  testCompile group: 'com.google.truth', name: 'truth', version: '0.42'
+  testCompile group: 'org.mockito', name: 'mockito-core', version: '2.19.1'
+  testCompile group: 'com.nhaarman.mockitokotlin2', name: 'mockito-kotlin', version: '2.1.0'
 }
 
 compileKotlin {
-    kotlinOptions.jvmTarget = "1.8"
+  kotlinOptions.jvmTarget = "1.8"
 }
 compileTestKotlin {
-    kotlinOptions.jvmTarget = "1.8"
+  kotlinOptions.jvmTarget = "1.8"
 }
 
 bintray {
-    user = System.getenv('bintrayUser')
-    key = System.getenv('bintrayApiKey')
-    dryRun = false
-    publish = true
-    pkg {
-        repo = 'java-phoenix-client'
-        name = 'JavaPhoenixClient'
-        userOrg = user
-        websiteUrl = 'https://github.com/dsrees/JavaPhoenixClient'
-        issueTrackerUrl = 'https://github.com/dsrees/JavaPhoenixClient/issues'
-        vcsUrl = 'https://github.com/dsrees/JavaPhoenixClient.git'
-        licenses = ['MIT']
-        version {
-            name = project.version
-            vcsTag = project.version
-        }
+  user = System.getenv('bintrayUser')
+  key = System.getenv('bintrayApiKey')
+  dryRun = false
+  publish = true
+  pkg {
+    repo = 'java-phoenix-client'
+    name = 'JavaPhoenixClient'
+    userOrg = user
+    websiteUrl = 'https://github.com/dsrees/JavaPhoenixClient'
+    issueTrackerUrl = 'https://github.com/dsrees/JavaPhoenixClient/issues'
+    vcsUrl = 'https://github.com/dsrees/JavaPhoenixClient.git'
+    licenses = ['MIT']
+    version {
+      name = project.version
+      vcsTag = project.version
     }
-    publications = ['nebula']
+  }
+  publications = ['nebula']
 }

src/main/kotlin/org/phoenixframework/Socket.kt

@@ -0,0 +1,35 @@
+package org.phoenixframework
+
+import java.util.concurrent.ScheduledThreadPoolExecutor
+
+// Copyright (c) 2019 Daniel Rees <[email protected]>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+class Socket {
+
+    /**
+     * All timers associated with a socket will share the same pool. Used for every Channel or
+     * Push that is sent through or created by a Socket instance. Different Socket instances will
+     * create individual thread pools.
+     */
+    private val timerPool = ScheduledThreadPoolExecutor(8)
+
+
+}

src/main/kotlin/org/phoenixframework/TimeoutTimer.kt

@@ -0,0 +1,75 @@
+package org.phoenixframework
+
+import java.util.Timer
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.ScheduledThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+import kotlin.concurrent.schedule
+
+// Copyright (c) 2019 Daniel Rees <[email protected]>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * A Timer class that schedules a callback to be called in the future. Can be configured
+ * to use a custom retry pattern, such as exponential backoff.
+ */
+class TimeoutTimer(
+  private val scheduledExecutorService: ScheduledExecutorService,
+  private val callback: () -> Unit,
+  private val timerCalculation: (tries: Int) -> Long
+) {
+
+  /** How many tries the Timer has attempted */
+  private var tries: Int = 0
+
+  /** The task that has been scheduled to be executed  */
+  private var futureTask: ScheduledFuture<*>? = null
+
+  /**
+   * Resets the Timer, clearing the number of current tries and stops
+   * any scheduled timeouts.
+   */
+  fun reset() {
+    this.tries = 0
+    this.clearTimer()
+  }
+
+  /** Cancels any previous timeouts and scheduled a new one */
+  fun scheduleTimeout() {
+    this.clearTimer()
+
+    // Schedule a task to be performed after the calculated timeout in milliseconds
+    val timeout = timerCalculation(tries + 1)
+    this.futureTask = scheduledExecutorService.schedule({
+      this.tries += 1
+      this.callback.invoke()
+    }, timeout, TimeUnit.MILLISECONDS)
+  }
+
+  //------------------------------------------------------------------------------
+  // Private
+  //------------------------------------------------------------------------------
+  private fun clearTimer() {
+    // Cancel the task from completing, allowing it to fi
+    this.futureTask?.cancel(true)
+    this.futureTask = null
+  }
+}

src/test/kotlin/org/phoenixframework/TimeoutTimerTest.kt

@@ -0,0 +1,67 @@
+package org.phoenixframework
+
+import com.google.common.truth.Truth.assertThat
+import com.nhaarman.mockitokotlin2.any
+import com.nhaarman.mockitokotlin2.argumentCaptor
+import com.nhaarman.mockitokotlin2.eq
+import com.nhaarman.mockitokotlin2.times
+import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.whenever
+import org.junit.Test
+
+import org.junit.Before
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+
+class TimeoutTimerTest {
+
+  @Mock lateinit var mockFuture: ScheduledFuture<*>
+  @Mock lateinit var mockExecutorService: ScheduledExecutorService
+
+  var callbackCallCount: Int = 0
+  lateinit var timeoutTimer: TimeoutTimer
+
+  @Before
+  fun setUp() {
+    MockitoAnnotations.initMocks(this)
+
+    callbackCallCount = 0
+    whenever(mockExecutorService.schedule(any(), any(), any())).thenReturn(mockFuture)
+
+    timeoutTimer = TimeoutTimer(
+        scheduledExecutorService = mockExecutorService,
+        callback = { callbackCallCount += 1 },
+        timerCalculation = { tries ->
+          if(tries > 3 )  10000 else listOf(1000L, 2000L, 5000L)[tries -1]
+        })
+  }
+
+  @Test
+  fun `scheduleTimeout executes with backoff`() {
+    argumentCaptor<() -> Unit> {
+      timeoutTimer.scheduleTimeout()
+      verify(mockExecutorService).schedule(capture(), eq(1000L), eq(TimeUnit.MILLISECONDS))
+      (lastValue as Runnable).run()
+      assertThat(callbackCallCount).isEqualTo(1)
+
+      timeoutTimer.scheduleTimeout()
+      verify(mockExecutorService).schedule(capture(), eq(2000L), eq(TimeUnit.MILLISECONDS))
+      (lastValue as Runnable).run()
+      assertThat(callbackCallCount).isEqualTo(2)
+
+      timeoutTimer.scheduleTimeout()
+      verify(mockExecutorService).schedule(capture(), eq(5000L), eq(TimeUnit.MILLISECONDS))
+      (lastValue as Runnable).run()
+      assertThat(callbackCallCount).isEqualTo(3)
+
+      timeoutTimer.reset()
+      timeoutTimer.scheduleTimeout()
+      verify(mockExecutorService, times(2)).schedule(capture(), eq(1000L), eq(TimeUnit.MILLISECONDS))
+      (lastValue as Runnable).run()
+      assertThat(callbackCallCount).isEqualTo(4)
+    }
+  }
+}