module Ecluse.Core.Fault.RetryAfter (
parseRetryAfter,
upstreamRetryCap,
responseRetryAfter,
) where
import Data.ByteString qualified as BS
import Data.Char (isDigit)
import Data.List (lookup)
import Data.Text qualified as T
import Data.Time (UTCTime, diffUTCTime, getCurrentTime)
import Network.HTTP.Types (ResponseHeaders)
import Ecluse.Core.Fault (RetryAfter (RetryAfter))
import Ecluse.Core.Text (readDecimalText)
import Ecluse.Core.Text.HttpDate (parseHttpDateAt)
parseRetryAfter :: UTCTime -> RetryAfter -> Maybe ByteString -> Maybe RetryAfter
parseRetryAfter :: UTCTime -> RetryAfter -> Maybe ByteString -> Maybe RetryAfter
parseRetryAfter UTCTime
now (RetryAfter Int
cap) Maybe ByteString
header = do
Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
cap Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0)
raw <- (Char -> Bool) -> Text -> Text
T.dropAround (\Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\t') (Text -> Text) -> (ByteString -> Text) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
forall a b. ConvertUtf8 a b => b -> a
decodeUtf8 (ByteString -> Text) -> Maybe ByteString -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ByteString
header
seconds <- cappedDecimal cap raw <|> (ceiling . (`diffUTCTime` now) <$> parseHttpDateAt now raw)
guard (seconds > (0 :: Integer))
pure (RetryAfter (fromInteger (min (toInteger cap) seconds)))
upstreamRetryCap :: RetryAfter
upstreamRetryCap :: RetryAfter
upstreamRetryCap = Int -> RetryAfter
RetryAfter Int
600
responseRetryAfter :: ResponseHeaders -> IO (Maybe RetryAfter)
responseRetryAfter :: ResponseHeaders -> IO (Maybe RetryAfter)
responseRetryAfter ResponseHeaders
headers = do
now <- IO UTCTime
getCurrentTime
pure (parseRetryAfter now upstreamRetryCap (lookup "Retry-After" headers))
cappedDecimal :: Int -> Text -> Maybe Integer
cappedDecimal :: Int -> Text -> Maybe Integer
cappedDecimal Int
cap Text
raw = do
Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Text -> Bool
T.null Text
raw) Bool -> Bool -> Bool
&& (Char -> Bool) -> Text -> Bool
T.all Char -> Bool
isDigit Text
raw)
let digits :: Text
digits = (Char -> Bool) -> Text -> Text
T.dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'0') Text
raw
if Text -> Bool
T.null Text
digits
then Integer -> Maybe Integer
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Integer
0
else
if Text -> Int -> Ordering
T.compareLength Text
digits (ByteString -> Int
BS.length (Int -> ByteString
forall b a. (Show a, IsString b) => a -> b
show Int
cap)) Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT
then Integer -> Maybe Integer
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
cap)
else Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
min (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
cap) (Integer -> Integer) -> Maybe Integer -> Maybe Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Integer
forall a. Integral a => Text -> Maybe a
readDecimalText Text
digits