Drop support for anycast NTP servers

.gitignore

@@ -1,2 +1,3 @@
 build/
 .gradle
+local.properties

build.gradle.kts

@@ -11,10 +11,7 @@ buildscript {
 
 allprojects {
   repositories {
+    google()
     mavenCentral()
   }
 }
-
-tasks.register("clean", Delete::class) {
-  delete(rootProject.buildDir)
-}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-all.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

library/build.gradle.kts

@@ -9,28 +9,40 @@ kotlin {
   targetHierarchy.default()
 
   jvm()
-  androidTarget()
-  ios()
-  linuxX64()
-  macosX64()
-  macosArm64()
-  iosSimulatorArm64()
-  iosX64()
-  linuxArm64()
-  watchosSimulatorArm64()
-  watchosX64()
-  watchosArm32()
-  watchosArm64()
-  tvosSimulatorArm64()
-  tvosX64()
-  tvosArm64()
-  iosArm64()
+  androidTarget {
+    compilations.all {
+      kotlinOptions {
+        jvmTarget = "1.8"
+      }
+    }
+  }
   androidNativeArm32()
   androidNativeArm64()
   androidNativeX86()
   androidNativeX64()
-  mingwX64()
-  watchosDeviceArm64()
+  listOf(
+    macosX64(),
+    macosArm64(),
+    iosX64(),
+    watchosSimulatorArm64(),
+    watchosX64(),
+    watchosArm32(),
+    watchosArm64(),
+    tvosSimulatorArm64(),
+    tvosX64(),
+    tvosArm64(),
+    iosArm64(),
+    watchosDeviceArm64(),
+  ).forEach {
+    it.binaries.framework {
+      baseName = project.name
+    }
+  }
+  js(IR) {
+    browser()
+    nodejs()
+    binaries.executable()
+  }
 
   sourceSets {
     val commonMain by getting {
@@ -42,9 +54,9 @@ kotlin {
 }
 
 android {
-  compileSdk = 34
+  compileSdk = 33
   defaultConfig {
     minSdk = 1
   }
-  namespace = group.toString()
+  namespace = "com.tidal.networktime"
 }

library/src/commonMain/kotlin/com/tidal/networktime/NTPServer.kt

@@ -3,40 +3,39 @@ package com.tidal.networktime
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
-sealed interface NTPServer {
-  val hostName: String
-  val responseTimeout: Duration
-  val dnsResolutionStrategy: DNSResolutionStrategy
-
-  sealed interface Unicast : NTPServer {
-    class Sequential(
-      override val hostName: String,
-      override val responseTimeout: Duration = RESPONSE_TIMEOUT_DEFAULT_SECONDS.seconds,
-      override val dnsResolutionStrategy: DNSResolutionStrategy = DNSResolutionStrategy.ALL,
-      val outgoingRequestGap: Duration = OUTGOING_REQUEST_GAP_DEFAULT_SECONDS.seconds,
-    ) : Unicast
-
-    class Concurrent(
-      override val hostName: String,
-      override val responseTimeout: Duration = RESPONSE_TIMEOUT_DEFAULT_SECONDS.seconds,
-      override val dnsResolutionStrategy: DNSResolutionStrategy = DNSResolutionStrategy.ALL,
-    ) : Unicast
-
-    companion object {
-      private const val RESPONSE_TIMEOUT_DEFAULT_SECONDS = 5
-      private const val OUTGOING_REQUEST_GAP_DEFAULT_SECONDS = 2
-    }
-  }
-
-  class Anycast(
-    override val hostName: String,
-    override val responseTimeout: Duration = 68.seconds,
-    override val dnsResolutionStrategy: DNSResolutionStrategy = DNSResolutionStrategy.ALL,
-  ) : NTPServer
+/**
+ * Describes a host name that can resolve to any number of NTP unicast servers.
+ *
+ * @param hostName The host name.
+ * @param responseTimeout The timeout for receiving responses from servers resolved from [hostName].
+ * @param dnsResolutionStrategy Can be used for filtering resolved address on [hostName] based on
+ * IP version.
+ * @param perAddressRequestGap The amount of time to wait before consecutive requests to the same
+ * resolved address.
+ * @param pinnedPortNumber The port number to send packets on. If null, a random choice of port
+ * be made for every packet, as recommended by RFC 9109.
+ * @param ntpVersion The version number to write in packets.
+ */
+class NTPServer(
+  val hostName: String,
+  val responseTimeout: Duration = 5.seconds,
+  val dnsResolutionStrategy: DNSResolutionStrategy = DNSResolutionStrategy.ALL,
+  val perAddressRequestGap: Duration = 2.seconds,
+  val pinnedPortNumber: Int? = null,
+  val ntpVersion: NTPVersion = NTPVersion.FOUR,
+) {
 
   enum class DNSResolutionStrategy {
     IP_V4,
     IP_V6,
     ALL,
   }
+
+  enum class NTPVersion(val descriptor: Short) {
+    ZERO(0),
+    ONE(1),
+    TWO(2),
+    THREE(3),
+    FOUR(4),
+  }
 }

library/src/commonMain/kotlin/com/tidal/networktime/SNTPClient.kt

@@ -2,30 +2,20 @@ package com.tidal.networktime
 
 import kotlinx.coroutines.CoroutineScope
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.seconds
 
 /**
  * Construct a new SNTP client that can be requested to periodically interact with the provided
  * [ntpServers] to obtain information about their provided time.
  *
- * @param ntpServers Representation of supported NTP sources.
+ * @param ntpServers Representation of supported unicast NTP sources.
  * @param coroutineScope The scope where synchronization will run on.
- * @param ntpVersion The version number to write in packets.
- * @param portSelectionStrategy The strategy for selecting a port to operate on.
- * @param minimumSynchronizationInterval The minimum amount of time between performing time queries
- * on all unicast sources. The actual value used may be larger than this on occasion based on
- * changes to the difference between the time provided by [ntpServers] and [referenceClock] (if it
- * ever changes), but will never be lower than this value.
- * @param referenceClock A clock used to calculate timing differences with the information obtained
- * from [ntpServers]. This clock will never be modified directly.
+ * @param referenceClock A provider of UNIX time, used to calculate timing differences with the
+ * information obtained from [ntpServers].
  */
 class SNTPClient(
   vararg val ntpServers: NTPServer,
   val coroutineScope: CoroutineScope,
-  val ntpVersion: NTPVersion = NTPVersion.FOUR,
-  val portSelectionStrategy: PortSelectionStrategy = PortSelectionStrategy.RFC9109,
-  val minimumSynchronizationInterval: Duration = 64.seconds,
-  val referenceClock: () -> Long,
+  val referenceClock: () -> Duration,
 ) {
 
   val time: Long?
@@ -34,21 +24,4 @@ class SNTPClient(
   fun startSynchronization(): Unit = TODO("Start or return")
 
   fun stopSynchronization(): Unit = TODO("Stop or return")
-
-  enum class NTPVersion(val descriptor: Short) {
-    ZERO(0),
-    ONE(1),
-    TWO(2),
-    THREE(3),
-    FOUR(4),
-  }
-
-  sealed class PortSelectionStrategy(val pinnedPortNumber: Int?) {
-    data object RFC5905 : PortSelectionStrategy(123)
-
-    /**
-     * Make a new selection of a random available port every time a socket is opened.
-     */
-    data object RFC9109 : PortSelectionStrategy(null)
-  }
 }