This PR deprecates wisp's FakeLeaseManager, and moves the functionality

exclusive to it over to misk's FakeLeaseManager

GitOrigin-RevId: 1ce45b74bd58317e8164a32ddcd08508aa9d924f

Author: sw-square

misk-clustering/api/misk-clustering.api

@@ -145,8 +145,26 @@ public final class misk/clustering/fake/FakeClusterModule : misk/inject/KAbstrac
 	public fun <init> ()V
 }
 
-public final class misk/clustering/fake/lease/FakeLeaseManager : wisp/lease/FakeLeaseManager {
+public final class misk/clustering/fake/lease/FakeLease : wisp/lease/Lease {
+	public fun <init> (Ljava/lang/String;Lmisk/clustering/fake/lease/FakeLeaseManager;)V
+	public fun acquire ()Z
+	public fun addListener (Lwisp/lease/Lease$StateChangeListener;)V
+	public fun checkHeld ()Z
+	public fun checkHeldElsewhere ()Z
+	public fun getName ()Ljava/lang/String;
+	public final fun notifyAfterAcquire ()V
+	public final fun notifyBeforeRelease ()V
+	public fun release ()Z
+}
+
+public final class misk/clustering/fake/lease/FakeLeaseManager : misk/testing/FakeFixture, wisp/lease/LeaseManager {
 	public fun <init> ()V
+	public final fun isLeaseHeld (Ljava/lang/String;)Z
+	public final fun isLeaseHeldElsewhere (Ljava/lang/String;)Z
+	public final fun markLeaseHeld (Ljava/lang/String;)V
+	public final fun markLeaseHeldElsewhere (Ljava/lang/String;)V
+	public fun releaseAll ()V
+	public fun requestLease (Ljava/lang/String;)Lwisp/lease/Lease;
 }
 
 public final class misk/clustering/fake/lease/FakeLeaseModule : misk/inject/KAbstractModule {

misk-clustering/build.gradle.kts

@@ -11,7 +11,6 @@ dependencies {
   api(libs.jakartaInject)
   api(libs.loggingApi)
   api(project(":wisp:wisp-config"))
-  api(project(":wisp:wisp-lease-testing"))
   api(project(":misk-inject"))
   implementation(libs.guice)
   implementation(libs.kubernetesClient)

misk-clustering/src/main/kotlin/misk/clustering/fake/lease/FakeLease.kt

@@ -0,0 +1,59 @@
+package misk.clustering.fake.lease
+
+import wisp.lease.Lease
+
+class FakeLease(
+  override val name: String,
+  private val manager: FakeLeaseManager
+) : Lease {
+  private val listeners = mutableListOf<Lease.StateChangeListener>()
+
+  override fun checkHeld() = manager.isLeaseHeld(name)
+
+  /**
+   * @return true if the other process holds the lease.
+   */
+  override fun checkHeldElsewhere() = manager.isLeaseHeldElsewhere(name)
+
+  /**
+   * @return true if this process acquires the lease.
+   */
+  override fun acquire(): Boolean {
+    val result = checkHeld()
+    if (checkHeld()) {
+      notifyAfterAcquire()
+    }
+    return result
+  }
+
+  /**
+   * Release the lease.  This will return true if released.  Note that it will return false
+   * if the lease was not held.
+   */
+  override fun release(): Boolean {
+    if (!checkHeld()) {
+      return false
+    }
+    notifyBeforeRelease()
+    return true
+  }
+
+  override fun addListener(listener: Lease.StateChangeListener) {
+    listeners.add(listener)
+    if (checkHeld()) {
+      listener.afterAcquire(this)
+    }
+  }
+
+  fun notifyAfterAcquire() {
+    listeners.forEach {
+      it.afterAcquire(this)
+    }
+  }
+
+  fun notifyBeforeRelease() {
+    listeners.forEach {
+      it.beforeRelease(this)
+    }
+  }
+}

misk-clustering/src/main/kotlin/misk/clustering/fake/lease/FakeLeaseManager.kt

@@ -1,12 +1,44 @@
 package misk.clustering.fake.lease
 
-import wisp.lease.FakeLeaseManager
 import jakarta.inject.Inject
 import jakarta.inject.Singleton
+import misk.testing.FakeFixture
+import wisp.lease.Lease
+import wisp.lease.LeaseManager
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * A [FakeLeaseManager] provides explicit control over leases for the purposes of testing. By
  * default a lease is considered held, but it can be explicitly marked as not held if desired
  */
 @Singleton
-class FakeLeaseManager @Inject constructor() : FakeLeaseManager()
+class FakeLeaseManager @Inject constructor() : LeaseManager, FakeFixture() {
+  private val leasesHeldElsewhere by resettable { ConcurrentHashMap<String, Int>() }
+  private val leases by resettable { ConcurrentHashMap<String, FakeLease>() }
+
+  override fun requestLease(name: String): Lease {
+    return leases.computeIfAbsent(name) {
+      FakeLease(name, this)
+    }
+  }
+
+  override fun releaseAll() {
+    leases.forEachValue(1) {
+      it.release()
+    }
+  }
+
+  fun isLeaseHeldElsewhere(name: String) = leasesHeldElsewhere.containsKey(name)
+
+  fun isLeaseHeld(name: String) = !leasesHeldElsewhere.containsKey(name)
+
+  fun markLeaseHeld(name: String) {
+    leasesHeldElsewhere.remove(name)
+    (requestLease(name) as FakeLease).acquire()
+  }
+
+  fun markLeaseHeldElsewhere(name: String) {
+    (requestLease(name) as FakeLease).release()
+    leasesHeldElsewhere[name] = 1
+  }
+}

misk-clustering/src/test/kotlin/misk/clustering/fake/lease/FakeLeaseManagerTest.kt

@@ -0,0 +1,28 @@
+package misk.clustering.fake.lease
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class FakeLeaseManagerTest {
+
+  private var leaseManager = FakeLeaseManager()
+
+  @Test
+  fun leaseRespectsAuthority() {
+    val lease = leaseManager.requestLease("my-lease")
+    val otherLease = leaseManager.requestLease("my-other-lease")
+
+    // leases are held by the current process by default
+    assertThat(lease.checkHeld()).isTrue()
+    assertThat(otherLease.checkHeld()).isTrue()
+
+    leaseManager.markLeaseHeldElsewhere("my-lease")
+    assertThat(lease.checkHeld()).isFalse()
+    assertThat(lease.acquire()).isFalse()
+    assertThat(otherLease.checkHeld()).isTrue()
+
+    leaseManager.markLeaseHeld("my-lease")
+    assertThat(lease.checkHeld()).isTrue()
+    assertThat(otherLease.checkHeld()).isTrue()
+  }
+}

wisp/wisp-lease-testing/src/main/kotlin/wisp/lease/FakeLeaseManager.kt

@@ -7,6 +7,13 @@ import java.util.concurrent.ConcurrentHashMap
  * A [FakeLeaseManager] provides explicit control over leases for the purposes of testing. By
  * default, a fake lease is considered held, but it can be explicitly marked as not held if desired
  */
+@Deprecated(
+  message = "Duplicate implementations in Wisp are being migrated to the unified type in Misk.",
+  replaceWith = ReplaceWith(
+    expression = "FakeLeaseManager()",
+    imports = ["misk.clustering.fake.lease"]
+  )
+)
 open class FakeLeaseManager : LeaseManager, FakeFixture() {
   private val leasesHeldElsewhere by resettable { ConcurrentHashMap<String, Int>() }
   private val leases by resettable { ConcurrentHashMap<String, FakeLease>() }