ServiceUnavailableException: add getDelayUntil (#67)

* Add support for sending additional headers with put requests

* Add retry delay calculation for ServiceUnavailableException

Author: rfc2822

src/main/kotlin/at/bitfire/dav4jvm/DavResource.kt

@@ -6,15 +6,27 @@
 
 package at.bitfire.dav4jvm
 
+import at.bitfire.dav4jvm.DavResource.Companion.MAX_REDIRECTS
 import at.bitfire.dav4jvm.XmlUtils.insertTag
 import at.bitfire.dav4jvm.XmlUtils.propertyName
-import at.bitfire.dav4jvm.exception.*
+import at.bitfire.dav4jvm.exception.ConflictException
+import at.bitfire.dav4jvm.exception.DavException
+import at.bitfire.dav4jvm.exception.ForbiddenException
+import at.bitfire.dav4jvm.exception.HttpException
+import at.bitfire.dav4jvm.exception.NotFoundException
+import at.bitfire.dav4jvm.exception.PreconditionFailedException
+import at.bitfire.dav4jvm.exception.ServiceUnavailableException
+import at.bitfire.dav4jvm.exception.UnauthorizedException
 import at.bitfire.dav4jvm.property.caldav.NS_CALDAV
 import at.bitfire.dav4jvm.property.carddav.NS_CARDDAV
 import at.bitfire.dav4jvm.property.webdav.NS_WEBDAV
 import at.bitfire.dav4jvm.property.webdav.SyncToken
-import okhttp3.*
+import okhttp3.Headers
+import okhttp3.HttpUrl
 import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import org.xmlpull.v1.XmlPullParser

src/main/kotlin/at/bitfire/dav4jvm/exception/ServiceUnavailableException.kt

@@ -7,27 +7,33 @@
 package at.bitfire.dav4jvm.exception
 
 import at.bitfire.dav4jvm.HttpUtils
+import at.bitfire.dav4jvm.exception.ServiceUnavailableException.Companion.DELAY_UNTIL_DEFAULT
+import at.bitfire.dav4jvm.exception.ServiceUnavailableException.Companion.DELAY_UNTIL_MAX
+import at.bitfire.dav4jvm.exception.ServiceUnavailableException.Companion.DELAY_UNTIL_MIN
 import okhttp3.Response
 import java.net.HttpURLConnection
 import java.time.Instant
 import java.util.logging.Level
 import java.util.logging.Logger
 
-class ServiceUnavailableException: HttpException {
+class ServiceUnavailableException : HttpException {
 
     private val logger
         get() = Logger.getLogger(javaClass.name)
 
-    var retryAfter: Instant? = null
+    val retryAfter: Instant?
 
-    constructor(message: String?): super(HttpURLConnection.HTTP_UNAVAILABLE, message)
+    constructor(message: String?) : super(HttpURLConnection.HTTP_UNAVAILABLE, message) {
+        retryAfter = null
+    }
 
-    constructor(response: Response): super(response) {
+    constructor(response: Response) : super(response) {
         // Retry-After  = "Retry-After" ":" ( HTTP-date | delta-seconds )
         // HTTP-date    = rfc1123-date | rfc850-date | asctime-date
 
+        var retryAfterValue: Instant? = null
         response.header("Retry-After")?.let { after ->
-            retryAfter = HttpUtils.parseDate(after) ?:
+            retryAfterValue = HttpUtils.parseDate(after) ?:
                 // not a HTTP-date, must be delta-seconds
                 try {
                     val seconds = after.toLong()
@@ -37,6 +43,41 @@ class ServiceUnavailableException: HttpException {
                     null
                 }
         }
+
+        retryAfter = retryAfterValue
+    }
+
+
+    /**
+     * Returns appropriate sync retry delay in seconds, considering the servers suggestion
+     * in [retryAfter] ([DELAY_UNTIL_DEFAULT] if no server suggestion).
+     *
+     * Takes current time into account to calculate intervals. Interval
+     * will be restricted to values between [DELAY_UNTIL_MIN] and [DELAY_UNTIL_MAX].
+     *
+     * @param start   timestamp to calculate the delay from (default: now)
+     *
+     * @return until when to wait before sync can be retried
+     */
+    fun getDelayUntil(start: Instant = Instant.now()): Instant {
+        if (retryAfter == null)
+            return start.plusSeconds(DELAY_UNTIL_DEFAULT)
+
+        // take server suggestion, but restrict to plausible min/max values
+        return retryAfter.coerceIn(
+            minimumValue = start.plusSeconds(DELAY_UNTIL_MIN),
+            maximumValue = start.plusSeconds(DELAY_UNTIL_MAX)
+        )
+    }
+
+
+    companion object {
+
+        // default values for getDelayUntil
+        const val DELAY_UNTIL_DEFAULT = 15 * 60L    // 15 min
+        const val DELAY_UNTIL_MIN = 1 * 60L         // 1 min
+        const val DELAY_UNTIL_MAX = 2 * 60 * 60L    // 2 hours
+
     }
 
-}
+}