module Ecluse.Core.Registry.Metadata.EntryFloor (
entryFloorBytes,
releaseFloorBytes,
RetainedEntries (..),
noRetainedEntries,
entryFloorCharge,
countingEntries,
readFlooredWalk,
) where
import Control.Monad.ST (RealWorld, ST, stToIO)
import Data.ByteString qualified as BS
import Data.JsonStream.Lexer (Cursor)
import Data.Primitive.PrimVar (PrimVar, newPrimVar, readPrimVar, writePrimVar)
import Ecluse.Core.Registry.Json.Walk (readJsonWalkST)
import Ecluse.Core.Registry.JsonStream (Steps, StreamResult, maxChunkBytes)
import Ecluse.Core.Security (BodyLimit, LimitError)
import Ecluse.Core.Server.Admission.Budget (scaleCharge)
entryFloorBytes :: Int
entryFloorBytes :: Int
entryFloorBytes = Int
512
releaseFloorBytes :: Int
releaseFloorBytes :: Int
releaseFloorBytes = Int
1152
data RetainedEntries = RetainedEntries
{ RetainedEntries -> Int
retainedReleases :: Int
, RetainedEntries -> Int
retainedOthers :: Int
}
deriving stock (RetainedEntries -> RetainedEntries -> Bool
(RetainedEntries -> RetainedEntries -> Bool)
-> (RetainedEntries -> RetainedEntries -> Bool)
-> Eq RetainedEntries
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RetainedEntries -> RetainedEntries -> Bool
== :: RetainedEntries -> RetainedEntries -> Bool
$c/= :: RetainedEntries -> RetainedEntries -> Bool
/= :: RetainedEntries -> RetainedEntries -> Bool
Eq, Int -> RetainedEntries -> ShowS
[RetainedEntries] -> ShowS
RetainedEntries -> String
(Int -> RetainedEntries -> ShowS)
-> (RetainedEntries -> String)
-> ([RetainedEntries] -> ShowS)
-> Show RetainedEntries
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RetainedEntries -> ShowS
showsPrec :: Int -> RetainedEntries -> ShowS
$cshow :: RetainedEntries -> String
show :: RetainedEntries -> String
$cshowList :: [RetainedEntries] -> ShowS
showList :: [RetainedEntries] -> ShowS
Show)
noRetainedEntries :: RetainedEntries
noRetainedEntries :: RetainedEntries
noRetainedEntries = Int -> Int -> RetainedEntries
RetainedEntries Int
0 Int
0
entryFloorCharge :: RetainedEntries -> Int
entryFloorCharge :: RetainedEntries -> Int
entryFloorCharge RetainedEntries
entries
| Int
releases Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
bound Bool -> Bool -> Bool
|| Int
others Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
bound = Int
forall a. Bounded a => a
maxBound
| Bool
otherwise = Int
releaseFloorBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
releases Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
entryFloorBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
others
where
releases :: Int
releases = RetainedEntries -> Int
retainedReleases RetainedEntries
entries
others :: Int
others = RetainedEntries -> Int
retainedOthers RetainedEntries
entries
bound :: Int
bound = Int
forall a. Bounded a => a
maxBound Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
releaseFloorBytes)
countingEntries :: PrimVar st Int -> (s -> RetainedEntries) -> (Either LimitError s -> ST st r) -> Either LimitError s -> ST st r
countingEntries :: forall st s r.
PrimVar st Int
-> (s -> RetainedEntries)
-> (Either LimitError s -> ST st r)
-> Either LimitError s
-> ST st r
countingEntries PrimVar st Int
owed s -> RetainedEntries
entries Either LimitError s -> ST st r
next Either LimitError s
taken = do
(s -> ST st ()) -> Either LimitError s -> ST st ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (PrimVar (PrimState (ST st)) Int -> Int -> ST st ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar st Int
PrimVar (PrimState (ST st)) Int
owed (Int -> ST st ()) -> (s -> Int) -> s -> ST st ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RetainedEntries -> Int
entryFloorCharge (RetainedEntries -> Int) -> (s -> RetainedEntries) -> s -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> RetainedEntries
entries) Either LimitError s
taken
Either LimitError s -> ST st r
next Either LimitError s
taken
{-# INLINE countingEntries #-}
readFlooredWalk ::
(Int -> IO ()) ->
Int ->
BodyLimit ->
(PrimVar RealWorld Int -> Cursor -> ST RealWorld (Steps (ST RealWorld) s)) ->
IO ByteString ->
IO (Either LimitError (StreamResult s))
readFlooredWalk :: forall s.
(Int -> IO ())
-> Int
-> BodyLimit
-> (PrimVar RealWorld Int
-> Cursor -> ST RealWorld (Steps (ST RealWorld) s))
-> IO ByteString
-> IO (Either LimitError (StreamResult s))
readFlooredWalk Int -> IO ()
pay Int
permille BodyLimit
bound PrimVar RealWorld Int
-> Cursor -> ST RealWorld (Steps (ST RealWorld) s)
walk IO ByteString
readChunk = do
owed <- Int -> IO (PrimVar (PrimState IO) Int)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
a -> m (PrimVar (PrimState m) a)
newPrimVar Int
0
seen <- newPrimVar 0
held <- newIORef BS.empty
let piece = do
floors <- PrimVar (PrimState IO) Int -> IO Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar RealWorld Int
PrimVar (PrimState IO) Int
owed
bytes <- readPrimVar seen
let shortfall = Int
floors Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int -> Int -> Int
scaleCharge Int
permille Int
bytes
when (shortfall > 0) (pay shortfall)
pending <- readIORef held
chunk <- if BS.null pending then readChunk else pure pending
let (next, rest) = BS.splitAt maxChunkBytes chunk
writeIORef held rest
writePrimVar seen (bytes + BS.length next)
pure next
readJsonWalkST stToIO bound (walk owed) piece
{-# INLINE readFlooredWalk #-}