-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

-- | Bounded durable records recheck stored source fragments rather than reconstructing policy facts.
module Ecluse.Core.Mirror.State.Codec (
    encodeProjectRecord,
    projectRecordWeight,
    projectRecordWorkWeight,
    chargedDecodeProjectRecord,
    chargedEncodeProjectRecord,
    stateExchangeCharge,
    mirrorInventoryWeight,

    -- * Stored source entries
    sourceEntries,
    parseSourceEntries,
    sourceEntriesCharge,
    forceSourceEntries,
) where

import Control.Exception (evaluate)
import Data.Aeson (Object, Value (..), encode, object, (.:), (.:?), (.=))
import Data.Aeson.Key (Key)
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Aeson.Types (Pair, Parser, parseEither, withObject)
import Data.ByteString qualified as BS
import Data.ByteString.Lazy qualified as LBS
import Data.JsonStream.Parser qualified as J
import Data.Map.Strict qualified as Map
import Data.Set qualified as Set
import Data.Traversable (for)

import Ecluse.Core.Ecosystem (ecosystemName, parseEcosystem)
import Ecluse.Core.Mirror.State.Format (MirrorStateFormat (..), ProjectEnvelope (envelopeCheck))
import Ecluse.Core.Mirror.State.Internal
import Ecluse.Core.Mirror.State.Weight (retainedRecordWeight)
import Ecluse.Core.Package
import Ecluse.Core.Package.Entry (EntryKey (..), distinctKeys, validEntryKey)
import Ecluse.Core.Registry.CachedDocument (estimateValueBytes)
import Ecluse.Core.Registry.JsonStream (StreamResult (..), readJsonStream, retainedValue)
import Ecluse.Core.Registry.Metadata (VersionDoc (..), VersionRead (..))
import Ecluse.Core.Registry.MirrorUpload (MirrorInventory, MirrorReadData, expectedArtifact, inventoryDetails, inventoryReadData, mirrorReadDocument)
import Ecluse.Core.Registry.MirrorUpload.Internal (restoreMirrorFragment)
import Ecluse.Core.Security
import Ecluse.Core.Server.Cache.VersionWeight (weighVersion)
import Ecluse.Core.Server.MemoryModel (bufferedChunkCharge, decodedDocumentCharge, expandWireBytes, saturatingCharge)
import Ecluse.Core.Text (textStorageBytes)
import Ecluse.Core.Version (mkVersion, renderVersion)

-- | Account for declared companion bytes as well as encoded source records before writing. Another format's source refuses the write.
encodeProjectRecord :: MirrorStateFormat -> Limits -> ProjectMirrorRecord -> Either MirrorStateFault ByteString
encodeProjectRecord :: MirrorStateFormat
-> Limits
-> ProjectMirrorRecord
-> Either MirrorStateFault ByteString
encodeProjectRecord MirrorStateFormat
format Limits
limits ProjectMirrorRecord
record = do
    let remaining :: Integer
remaining = Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Limits -> Int
maxMetadataBytes Limits
limits) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- ProjectMirrorRecord -> Integer
companionBytes ProjectMirrorRecord
record
    Bool -> Either MirrorStateFault () -> Either MirrorStateFault ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
remaining Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0) (MirrorStateFault -> Either MirrorStateFault ()
forall a b. a -> Either a b
Left (LimitError -> MirrorStateFault
StateBound (BodyLimit -> LimitError
BodyTooLarge (Int -> BodyLimit
MetadataBodyLimit (Limits -> Int
maxMetadataBytes Limits
limits)))))
    value <- MirrorStateFault -> Maybe Value -> Either MirrorStateFault Value
forall l r. l -> Maybe r -> Either l r
maybeToRight (Text -> MirrorStateFault
StateInvalid Text
"a stored source belongs to another format") (MirrorStateFormat -> ProjectMirrorRecord -> Maybe Value
recordValue MirrorStateFormat
format ProjectMirrorRecord
record)
    let bytes = LazyByteString -> ByteString
LBS.toStrict (Int64 -> LazyByteString -> LazyByteString
LBS.take (Integer -> Int64
forall a. Num a => Integer -> a
fromInteger Integer
remaining Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
1) (Value -> LazyByteString
forall a. ToJSON a => a -> LazyByteString
encode Value
value))
    checkRecord limits (BS.length bytes) record
    void (boundedValue limits bytes)
    pure bytes

decodeProjectValue :: Limits -> ByteString -> Either MirrorStateFault Value
decodeProjectValue :: Limits -> ByteString -> Either MirrorStateFault Value
decodeProjectValue Limits
limits ByteString
bytes = Limits -> ByteString -> Either MirrorStateFault ()
checkDimensions Limits
limits ByteString
bytes Either MirrorStateFault ()
-> Either MirrorStateFault Value -> Either MirrorStateFault Value
forall a b.
Either MirrorStateFault a
-> Either MirrorStateFault b -> Either MirrorStateFault b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Limits -> ByteString -> Either MirrorStateFault Value
boundedValue Limits
limits ByteString
bytes

restoreProjectValue :: MirrorStateFormat -> Limits -> StateTarget -> PackageName -> Int -> Value -> Either MirrorStateFault ProjectMirrorRecord
restoreProjectValue :: MirrorStateFormat
-> Limits
-> StateTarget
-> PackageName
-> Int
-> Value
-> Either MirrorStateFault ProjectMirrorRecord
restoreProjectValue MirrorStateFormat
format Limits
limits StateTarget
target PackageName
name Int
size Value
value = do
    record <- (String -> MirrorStateFault)
-> Either String ProjectMirrorRecord
-> Either MirrorStateFault ProjectMirrorRecord
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Text -> MirrorStateFault
StateInvalid (Text -> MirrorStateFault)
-> (String -> Text) -> String -> MirrorStateFault
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. ToText a => a -> Text
toText) ((Value -> Parser ProjectMirrorRecord)
-> Value -> Either String ProjectMirrorRecord
forall a b. (a -> Parser b) -> a -> Either String b
parseEither (MirrorStateFormat -> Value -> Parser ProjectMirrorRecord
parseRecord MirrorStateFormat
format) Value
value)
    unless (recordTarget record == target && recordPackage record == name) (Left StateIdentityMismatch)
    checkRecord limits size record
    pure record

boundedValue :: Limits -> ByteString -> Either MirrorStateFault Value
boundedValue :: Limits -> ByteString -> Either MirrorStateFault Value
boundedValue Limits
limits ByteString
bytes
    | ByteString -> Int
BS.length ByteString
bytes Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Limits -> Int
maxMetadataBytes Limits
limits = MirrorStateFault -> Either MirrorStateFault Value
forall a b. a -> Either a b
Left (LimitError -> MirrorStateFault
StateBound (BodyLimit -> LimitError
BodyTooLarge (Int -> BodyLimit
MetadataBodyLimit (Limits -> Int
maxMetadataBytes Limits
limits))))
    | Bool
otherwise = case Parser Value -> ByteString -> ParseOutput Value
forall a. Parser a -> ByteString -> ParseOutput a
J.runParser' (Int -> Parser Value
retainedValue (Limits -> Int
maxNestingDepth Limits
limits)) ByteString
bytes of
        J.ParseYield Value
value (J.ParseDone ByteString
rest) | (Word8 -> Bool) -> ByteString -> Bool
BS.all (\Word8
byte -> Word8
byte Word8 -> [Word8] -> Bool
forall (f :: * -> *) a.
(Foldable f, DisallowElem f, Eq a) =>
a -> f a -> Bool
`elem` [Word8
9, Word8
10, Word8
13, Word8
32]) ByteString
rest -> Value -> Either MirrorStateFault Value
forall a b. b -> Either a b
Right Value
value
        ParseOutput Value
_ -> MirrorStateFault -> Either MirrorStateFault Value
forall a b. a -> Either a b
Left (Text -> MirrorStateFault
StateInvalid Text
"malformed or excessively nested state JSON")

data Dimension = VersionStart | ArtifactStart | FragmentStart | SourceStart | CompanionStart | VerifiedStart | ContainerEnd

checkDimensions :: Limits -> ByteString -> Either MirrorStateFault ()
checkDimensions :: Limits -> ByteString -> Either MirrorStateFault ()
checkDimensions Limits
limits ByteString
bytes = do
    result <-
        (LimitError -> MirrorStateFault)
-> Either LimitError (StreamResult (Int, Int, Int, Int, Int, Int))
-> Either
     MirrorStateFault (StreamResult (Int, Int, Int, Int, Int, Int))
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first LimitError -> MirrorStateFault
StateBound (Either LimitError (StreamResult (Int, Int, Int, Int, Int, Int))
 -> Either
      MirrorStateFault (StreamResult (Int, Int, Int, Int, Int, Int)))
-> Either LimitError (StreamResult (Int, Int, Int, Int, Int, Int))
-> Either
     MirrorStateFault (StreamResult (Int, Int, Int, Int, Int, Int))
forall a b. (a -> b) -> a -> b
$
            State
  [ByteString]
  (Either LimitError (StreamResult (Int, Int, Int, Int, Int, Int)))
-> [ByteString]
-> Either LimitError (StreamResult (Int, Int, Int, Int, Int, Int))
forall s a. State s a -> s -> a
evalState
                (BodyLimit
-> Parser Dimension
-> ((Int, Int, Int, Int, Int, Int)
    -> Dimension -> Either LimitError (Int, Int, Int, Int, Int, Int))
-> (Int, Int, Int, Int, Int, Int)
-> StateT [ByteString] Identity ByteString
-> State
     [ByteString]
     (Either LimitError (StreamResult (Int, Int, Int, Int, Int, Int)))
forall (m :: * -> *) a s.
Monad m =>
BodyLimit
-> Parser a
-> (s -> a -> Either LimitError s)
-> s
-> m ByteString
-> m (Either LimitError (StreamResult s))
readJsonStream (Int -> BodyLimit
MetadataBodyLimit (Limits -> Int
maxMetadataBytes Limits
limits)) Parser Dimension
dimensions (Int, Int, Int, Int, Int, Int)
-> Dimension -> Either LimitError (Int, Int, Int, Int, Int, Int)
count (Int
0, Int
0, Int
0, Int
0, Int
0, Int
0) StateT [ByteString] Identity ByteString
next)
                [ByteString
bytes]
    first (const (StateInvalid "malformed state dimensions")) (streamValue result) $> ()
  where
    next :: StateT [ByteString] Identity ByteString
next = ([ByteString] -> (ByteString, [ByteString]))
-> StateT [ByteString] Identity ByteString
forall a.
([ByteString] -> (a, [ByteString]))
-> StateT [ByteString] Identity a
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (([ByteString] -> (ByteString, [ByteString]))
 -> StateT [ByteString] Identity ByteString)
-> ([ByteString] -> (ByteString, [ByteString]))
-> StateT [ByteString] Identity ByteString
forall a b. (a -> b) -> a -> b
$ \case
        [] -> (ByteString
BS.empty, [])
        ByteString
chunk : [ByteString]
rest -> (ByteString
chunk, [ByteString]
rest)
    dimensions :: Parser Dimension
dimensions = Text -> Parser Dimension -> Parser Dimension
forall a. Text -> Parser a -> Parser a
J.objectWithKey Text
"versions" (Parser Dimension -> Parser Dimension
forall a. Parser a -> Parser a
J.arrayOf (Dimension -> Dimension -> Parser Dimension -> Parser Dimension
forall a. a -> a -> Parser a -> Parser a
J.objectFound Dimension
VersionStart Dimension
ContainerEnd ((Text -> Parser Dimension) -> Parser Dimension
forall a. (Text -> Parser a) -> Parser a
J.objectKeyValues Text -> Parser Dimension
forall {a}. (Eq a, IsString a) => a -> Parser Dimension
versionField)))
    versionField :: a -> Parser Dimension
versionField a
"fragments" = Parser Dimension -> Parser Dimension
forall a. Parser a -> Parser a
J.arrayOf (Dimension -> Dimension -> Parser Dimension -> Parser Dimension
forall a. a -> a -> Parser a -> Parser a
J.objectFound Dimension
FragmentStart Dimension
ContainerEnd ((Text -> Parser Dimension) -> Parser Dimension
forall a. (Text -> Parser a) -> Parser a
J.objectKeyValues Text -> Parser Dimension
forall {a}. (Eq a, IsString a) => a -> Parser Dimension
fragmentField))
    versionField a
"companions" = Parser Dimension -> Parser Dimension
forall a. Parser a -> Parser a
J.arrayOf (Dimension -> Dimension -> Parser Dimension -> Parser Dimension
forall a. a -> a -> Parser a -> Parser a
J.objectFound Dimension
CompanionStart Dimension
ContainerEnd Parser Dimension
forall a. Monoid a => a
mempty)
    versionField a
"verified" = Parser Dimension -> Parser Dimension
forall a. Parser a -> Parser a
J.arrayOf (Dimension -> Dimension -> Parser Dimension -> Parser Dimension
forall a. a -> a -> Parser a -> Parser a
J.objectFound Dimension
VerifiedStart Dimension
ContainerEnd Parser Dimension
forall a. Monoid a => a
mempty)
    versionField a
_ = Parser Dimension
forall a. Monoid a => a
mempty
    fragmentField :: a -> Parser Dimension
fragmentField a
"details" = Text -> Parser Dimension -> Parser Dimension
forall a. Text -> Parser a -> Parser a
J.objectWithKey Text
"artifacts" (Parser Dimension -> Parser Dimension
forall a. Parser a -> Parser a
J.arrayOf (Dimension -> Dimension -> Parser Dimension -> Parser Dimension
forall a. a -> a -> Parser a -> Parser a
J.objectFound Dimension
ArtifactStart Dimension
ContainerEnd Parser Dimension
forall a. Monoid a => a
mempty))
    fragmentField a
"source" = Text -> Parser Dimension -> Parser Dimension
forall a. Text -> Parser a -> Parser a
J.objectWithKey Text
"entries" (Parser Dimension -> Parser Dimension
forall a. Parser a -> Parser a
J.arrayOf (Dimension -> Dimension -> Parser Dimension -> Parser Dimension
forall a. a -> a -> Parser a -> Parser a
J.objectFound Dimension
SourceStart Dimension
ContainerEnd Parser Dimension
forall a. Monoid a => a
mempty))
    fragmentField a
_ = Parser Dimension
forall a. Monoid a => a
mempty
    count :: (Int, Int, Int, Int, Int, Int)
-> Dimension -> Either LimitError (Int, Int, Int, Int, Int, Int)
count (Int
versions, Int
artifacts, Int
fragments, Int
sources, Int
companions, Int
verified) Dimension
dimension = do
        let updated :: (Int, Int, Int, Int, Int, Int)
updated@(Int
v, Int
a, Int
f, Int
s, Int
c, Int
h) = case Dimension
dimension of
                Dimension
VersionStart -> (Int
versions Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, Int
artifacts, Int
fragments, Int
sources, Int
companions, Int
verified)
                Dimension
ArtifactStart -> (Int
versions, Int
artifacts Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, Int
fragments, Int
sources, Int
companions, Int
verified)
                Dimension
FragmentStart -> (Int
versions, Int
artifacts, Int
fragments Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, Int
sources, Int
companions, Int
verified)
                Dimension
SourceStart -> (Int
versions, Int
artifacts, Int
fragments, Int
sources Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, Int
companions, Int
verified)
                Dimension
CompanionStart -> (Int
versions, Int
artifacts, Int
fragments, Int
sources, Int
companions Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, Int
verified)
                Dimension
VerifiedStart -> (Int
versions, Int
artifacts, Int
fragments, Int
sources, Int
companions, Int
verified Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                Dimension
ContainerEnd -> (Int
versions, Int
artifacts, Int
fragments, Int
sources, Int
companions, Int
verified)
        Limits -> Int -> Either LimitError ()
checkVersionCountOf Limits
limits Int
v
        (Int -> Either LimitError ()) -> [Int] -> Either LimitError ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (Limits -> Int -> Either LimitError ()
checkStateFiles Limits
limits) [Int
a, Int
f, Int
s, Int
c, Int
h]
        (Int, Int, Int, Int, Int, Int)
-> Either LimitError (Int, Int, Int, Int, Int, Int)
forall a. a -> Either LimitError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int, Int, Int, Int, Int, Int)
updated

-- | Charge the durable graph separately from active-work reservations.
projectRecordWeight :: MirrorStateFormat -> Limits -> ProjectMirrorRecord -> Either MirrorStateFault Int
projectRecordWeight :: MirrorStateFormat
-> Limits -> ProjectMirrorRecord -> Either MirrorStateFault Int
projectRecordWeight MirrorStateFormat
format Limits
limits ProjectMirrorRecord
record = Limits -> Int -> ProjectMirrorRecord -> Either MirrorStateFault ()
checkRecord Limits
limits Int
0 ProjectMirrorRecord
record Either MirrorStateFault () -> Int -> Either MirrorStateFault Int
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Integer -> Int
saturatingCharge (MirrorStateFormat -> ProjectMirrorRecord -> Integer
retainedRecordWeight MirrorStateFormat
format ProjectMirrorRecord
record)

-- | Preserve the conservative selected-release allowance for update, worker and encoding overlap.
projectRecordWorkWeight :: Limits -> ProjectMirrorRecord -> Either MirrorStateFault Int
projectRecordWorkWeight :: Limits -> ProjectMirrorRecord -> Either MirrorStateFault Int
projectRecordWorkWeight Limits
limits ProjectMirrorRecord
record = do
    Limits -> Int -> ProjectMirrorRecord -> Either MirrorStateFault ()
checkRecord Limits
limits Int
0 ProjectMirrorRecord
record
    Int -> Either MirrorStateFault Int
forall a. a -> Either MirrorStateFault a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Either MirrorStateFault Int)
-> (Integer -> Int) -> Integer -> Either MirrorStateFault Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
saturatingCharge (Integer -> Either MirrorStateFault Int)
-> Integer -> Either MirrorStateFault Int
forall a b. (a -> b) -> a -> b
$
        Integer
4096
            Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Int
expandWireBytes (Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Value -> Int64
estimateValueBytes (Object -> Value
Object (ProjectMirrorRecord -> Object
recordEnvelope ProjectMirrorRecord
record)))))
            Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ [Integer] -> Integer
forall a (f :: * -> *). (Foldable f, Num a) => f a -> a
sum
                [ Integer
256
                    Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Text -> Int
textStorageBytes Text
key)
                    Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ [Integer] -> Integer
forall a (f :: * -> *). (Foldable f, Num a) => f a -> a
sum [Integer
256 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (PackageDetails -> MirrorReadData -> Int
fragmentWeight PackageDetails
details MirrorReadData
source) | StoredMirrorFragment PackageDetails
details MirrorReadData
source NonEmpty ExpectedMirrorFile
_ <- NonEmpty StoredMirrorFragment -> [StoredMirrorFragment]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (MirrorVersion -> NonEmpty StoredMirrorFragment
versionFragments MirrorVersion
version)]
                    Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
256 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Map Text Hash -> Int
forall k a. Map k a -> Int
Map.size (MirrorVersion -> Map Text Hash
versionVerifiedIdentities MirrorVersion
version) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Map Text CompanionState -> Int
forall k a. Map k a -> Int
Map.size (MirrorVersion -> Map Text CompanionState
versionCompanions MirrorVersion
version))
                | (Text
key, MirrorVersion
version) <- Map Text MirrorVersion -> [(Text, MirrorVersion)]
forall k a. Map k a -> [(k, a)]
Map.toList (ProjectMirrorRecord -> Map Text MirrorVersion
recordVersions ProjectMirrorRecord
record)
                ]

-- | The admitted input already belongs to the caller. This estimates state-update scratch from its shape.
mirrorInventoryWeight :: MirrorInventory -> Int
mirrorInventoryWeight :: MirrorInventory -> Int
mirrorInventoryWeight MirrorInventory
inventory = PackageDetails -> MirrorReadData -> Int
fragmentWeight (MirrorInventory -> PackageDetails
inventoryDetails MirrorInventory
inventory) (MirrorInventory -> MirrorReadData
inventoryReadData MirrorInventory
inventory)

fragmentWeight :: PackageDetails -> MirrorReadData -> Int
fragmentWeight :: PackageDetails -> MirrorReadData -> Int
fragmentWeight PackageDetails
details MirrorReadData
source = VersionRead -> Int
weighVersion (Maybe VersionDoc -> Int -> Maybe Version -> VersionRead
VersionRead (VersionDoc -> Maybe VersionDoc
forall a. a -> Maybe a
Just (PackageDetails -> Maybe CachedDoc -> VersionDoc
VersionDoc PackageDetails
details (CachedDoc -> Maybe CachedDoc
forall a. a -> Maybe a
Just (MirrorReadData -> CachedDoc
mirrorReadDocument MirrorReadData
source)))) Int
0 Maybe Version
forall a. Maybe a
Nothing)

-- | Materialise source fields and domain weights under the reservation. Callers keep it until they release the returned record.
chargedDecodeProjectRecord :: MirrorStateFormat -> StateCharge -> Limits -> StateTarget -> PackageName -> ByteString -> IO (Either MirrorStateFault ProjectMirrorRecord)
chargedDecodeProjectRecord :: MirrorStateFormat
-> StateCharge
-> Limits
-> StateTarget
-> PackageName
-> ByteString
-> IO (Either MirrorStateFault ProjectMirrorRecord)
chargedDecodeProjectRecord MirrorStateFormat
format StateCharge
charge Limits
limits StateTarget
target PackageName
name ByteString
bytes = do
    let treeCharge :: Integer
treeCharge = Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
stateExchangeCharge Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Int
bufferedChunkCharge (ByteString -> Int
BS.length ByteString
bytes)) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (ByteString -> Int
decodedDocumentCharge ByteString
bytes)
    StateCharge
charge (Integer -> Int
saturatingCharge Integer
treeCharge)
    Either MirrorStateFault Value -> IO (Either MirrorStateFault Value)
forall a. a -> IO a
evaluate (Limits -> ByteString -> Either MirrorStateFault Value
decodeProjectValue Limits
limits ByteString
bytes) IO (Either MirrorStateFault Value)
-> (Either MirrorStateFault Value
    -> IO (Either MirrorStateFault ProjectMirrorRecord))
-> IO (Either MirrorStateFault ProjectMirrorRecord)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Left MirrorStateFault
fault -> Either MirrorStateFault ProjectMirrorRecord
-> IO (Either MirrorStateFault ProjectMirrorRecord)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MirrorStateFault -> Either MirrorStateFault ProjectMirrorRecord
forall a b. a -> Either a b
Left MirrorStateFault
fault)
        Right Value
value -> do
            materialised <- Value -> IO Value
forall a. a -> IO a
evaluate (Value -> Value
forall a. NFData a => a -> a
force Value
value)
            charge (saturatingCharge (treeCharge + domainDecodeCharge format materialised))
            evaluate (restoreProjectValue format limits target name (BS.length bytes) materialised) >>= \case
                Left MirrorStateFault
fault -> Either MirrorStateFault ProjectMirrorRecord
-> IO (Either MirrorStateFault ProjectMirrorRecord)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MirrorStateFault -> Either MirrorStateFault ProjectMirrorRecord
forall a b. a -> Either a b
Left MirrorStateFault
fault)
                Right ProjectMirrorRecord
record -> case MirrorStateFormat
-> Limits -> ProjectMirrorRecord -> Either MirrorStateFault Int
projectRecordWeight MirrorStateFormat
format Limits
limits ProjectMirrorRecord
record of
                    Left MirrorStateFault
fault -> Either MirrorStateFault ProjectMirrorRecord
-> IO (Either MirrorStateFault ProjectMirrorRecord)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MirrorStateFault -> Either MirrorStateFault ProjectMirrorRecord
forall a b. a -> Either a b
Left MirrorStateFault
fault)
                    Right Int
retained -> do
                        IO Int -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Int -> IO Int
forall a. a -> IO a
evaluate Int
retained)
                        () -> IO ()
forall a. a -> IO a
evaluate (MirrorStateFormat -> ProjectMirrorRecord -> ()
forceRecordSources MirrorStateFormat
format ProjectMirrorRecord
record)
                        Either MirrorStateFault ProjectMirrorRecord
-> IO (Either MirrorStateFault ProjectMirrorRecord)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectMirrorRecord -> Either MirrorStateFault ProjectMirrorRecord
forall a b. b -> Either a b
Right ProjectMirrorRecord
record)

-- Reuse VersionWeight's allowances at schema-owned coordinates, never at arbitrary publisher fields with the same name.
domainDecodeCharge :: MirrorStateFormat -> Value -> Integer
domainDecodeCharge :: MirrorStateFormat -> Value -> Integer
domainDecodeCharge MirrorStateFormat
format Value
value = Integer
4096 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
8 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Value -> Int64
estimateValueBytes Value
value) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Key -> Value -> (Value -> Integer) -> Integer
sumArray Key
"versions" Value
value Value -> Integer
versionCharge
  where
    versionCharge :: Value -> Integer
versionCharge Value
version = Key -> Value -> (Value -> Integer) -> Integer
sumArray Key
"fragments" Value
version Value -> Integer
fragmentCharge
    fragmentCharge :: Value -> Integer
fragmentCharge Value
fragment = Integer -> (Value -> Integer) -> Maybe Value -> Integer
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Integer
0 Value -> Integer
detailsCharge (Key -> Value -> Maybe Value
fieldValue Key
"details" Value
fragment) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer -> (Value -> Integer) -> Maybe Value -> Integer
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Integer
0 (MirrorStateFormat -> Value -> Integer
msfDecodeCharge MirrorStateFormat
format) (Key -> Value -> Maybe Value
fieldValue Key
"source" Value
fragment)
    detailsCharge :: Value -> Integer
detailsCharge Value
details = Integer
16 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
1024 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Key -> Value -> Integer
textCharge Key
"version" Value
details

-- | Charge each stored entry's @filename@ at the retained text allowance.
sourceEntriesCharge :: Value -> Integer
sourceEntriesCharge :: Value -> Integer
sourceEntriesCharge Value
source = Key -> Value -> (Value -> Integer) -> Integer
sumArray Key
"entries" Value
source (Integer -> (Value -> Integer) -> Maybe Value -> Integer
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Integer
0 (Key -> Value -> Integer
textCharge Key
"filename") (Maybe Value -> Integer)
-> (Value -> Maybe Value) -> Value -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Key -> Value -> Maybe Value
fieldValue Key
"value")

textCharge :: Key -> Value -> Integer
textCharge :: Key -> Value -> Integer
textCharge Key
key Value
parent = case Key -> Value -> Maybe Value
fieldValue Key
key Value
parent of
    Just (String Text
text) -> Integer
256 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Text -> Int
textStorageBytes Text
text)
    Maybe Value
_ -> Integer
0

sumArray :: Key -> Value -> (Value -> Integer) -> Integer
sumArray :: Key -> Value -> (Value -> Integer) -> Integer
sumArray Key
key Value
parent Value -> Integer
itemCharge = case Key -> Value -> Maybe Value
fieldValue Key
key Value
parent of
    Just (Array Array
values) -> (Integer -> Value -> Integer) -> Integer -> Array -> Integer
forall b a. (b -> a -> b) -> b -> Vector a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Integer
total Value
child -> Integer
total Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Value -> Integer
itemCharge Value
child) Integer
0 Array
values
    Maybe Value
_ -> Integer
0

fieldValue :: Key -> Value -> Maybe Value
fieldValue :: Key -> Value -> Maybe Value
fieldValue Key
key (Object Object
fields) = Key -> Object -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
key Object
fields
fieldValue Key
_ Value
_ = Maybe Value
forall a. Maybe a
Nothing

-- | Reserve retained input, encoded output and validation overlap before creating the encoding tree.
chargedEncodeProjectRecord :: MirrorStateFormat -> StateCharge -> Limits -> ProjectMirrorRecord -> IO (Either MirrorStateFault ByteString)
chargedEncodeProjectRecord :: MirrorStateFormat
-> StateCharge
-> Limits
-> ProjectMirrorRecord
-> IO (Either MirrorStateFault ByteString)
chargedEncodeProjectRecord MirrorStateFormat
format StateCharge
charge Limits
limits ProjectMirrorRecord
record = case Limits -> ProjectMirrorRecord -> Either MirrorStateFault Int
projectRecordWorkWeight Limits
limits ProjectMirrorRecord
record of
    Left MirrorStateFault
fault -> Either MirrorStateFault ByteString
-> IO (Either MirrorStateFault ByteString)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MirrorStateFault -> Either MirrorStateFault ByteString
forall a b. a -> Either a b
Left MirrorStateFault
fault)
    Right Int
retained -> do
        StateCharge
charge (Integer -> Int
saturatingCharge (Integer
4 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
retained Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
32768))
        result <- Either MirrorStateFault ByteString
-> IO (Either MirrorStateFault ByteString)
forall a. a -> IO a
evaluate (MirrorStateFormat
-> Limits
-> ProjectMirrorRecord
-> Either MirrorStateFault ByteString
encodeProjectRecord MirrorStateFormat
format Limits
limits ProjectMirrorRecord
record)
        traverse (\ByteString
bytes -> Int -> IO Int
forall a. a -> IO a
evaluate (ByteString -> Int
BS.length ByteString
bytes) IO Int -> ByteString -> IO ByteString
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ByteString
bytes) result

forceRecordSources :: MirrorStateFormat -> ProjectMirrorRecord -> ()
forceRecordSources :: MirrorStateFormat -> ProjectMirrorRecord -> ()
forceRecordSources MirrorStateFormat
format ProjectMirrorRecord
record = Object -> Object
forall a. NFData a => a -> a
force (ProjectMirrorRecord -> Object
recordEnvelope ProjectMirrorRecord
record) Object -> () -> ()
forall a b. a -> b -> b
`seq` (() -> MirrorVersion -> ()) -> () -> [MirrorVersion] -> ()
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' () -> MirrorVersion -> ()
forceVersion () (Map Text MirrorVersion -> [MirrorVersion]
forall k a. Map k a -> [a]
Map.elems (ProjectMirrorRecord -> Map Text MirrorVersion
recordVersions ProjectMirrorRecord
record))
  where
    forceVersion :: () -> MirrorVersion -> ()
forceVersion () MirrorVersion
version = (() -> StoredMirrorFragment -> ())
-> () -> NonEmpty StoredMirrorFragment -> ()
forall b a. (b -> a -> b) -> b -> NonEmpty a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' () -> StoredMirrorFragment -> ()
forceFragment () (MirrorVersion -> NonEmpty StoredMirrorFragment
versionFragments MirrorVersion
version)
    forceFragment :: () -> StoredMirrorFragment -> ()
forceFragment () (StoredMirrorFragment PackageDetails
_ MirrorReadData
source NonEmpty ExpectedMirrorFile
_) = MirrorStateFormat -> MirrorReadData -> ()
msfForceSource MirrorStateFormat
format MirrorReadData
source

-- | Materialise stored entries and their source coordinates.
forceSourceEntries :: [(EntryKey, Value)] -> ()
forceSourceEntries :: [(EntryKey, Value)] -> ()
forceSourceEntries = (() -> (EntryKey, Value) -> ()) -> () -> [(EntryKey, Value)] -> ()
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\() (EntryKey
key, Value
value) -> EntryKey -> ()
forceKey EntryKey
key () -> () -> ()
forall a b. a -> b -> b
`seq` Value -> Value
forall a. NFData a => a -> a
force Value
value Value -> () -> ()
forall a b. a -> b -> b
`seq` ()) ()
  where
    forceKey :: EntryKey -> ()
forceKey (ArrayEntry Int
position) = Int -> Int
forall a. NFData a => a -> a
force Int
position Int -> () -> ()
forall a b. a -> b -> b
`seq` ()
    forceKey (RecordEntry Int
position) = Int -> Int
forall a. NFData a => a -> a
force Int
position Int -> () -> ()
forall a b. a -> b -> b
`seq` ()
    forceKey (ObjectEntry Text
name) = Text -> Text
forall a. NFData a => a -> a
force Text
name Text -> () -> ()
forall a b. a -> b -> b
`seq` ()
    forceKey EntryKey
SingletonEntry = ()

-- | Fixed per-exchange metadata bookkeeping, independent of the configured maximum object size.
stateExchangeCharge :: Int
stateExchangeCharge :: Int
stateExchangeCharge = Int
4096

checkRecord :: Limits -> Int -> ProjectMirrorRecord -> Either MirrorStateFault ()
checkRecord :: Limits -> Int -> ProjectMirrorRecord -> Either MirrorStateFault ()
checkRecord Limits
limits Int
size ProjectMirrorRecord
record = do
    Bool -> Either MirrorStateFault () -> Either MirrorStateFault ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
size Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ ProjectMirrorRecord -> Integer
companionBytes ProjectMirrorRecord
record Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Limits -> Int
maxMetadataBytes Limits
limits)) (Either MirrorStateFault () -> Either MirrorStateFault ())
-> Either MirrorStateFault () -> Either MirrorStateFault ()
forall a b. (a -> b) -> a -> b
$
        MirrorStateFault -> Either MirrorStateFault ()
forall a b. a -> Either a b
Left (LimitError -> MirrorStateFault
StateBound (BodyLimit -> LimitError
BodyTooLarge (Int -> BodyLimit
MetadataBodyLimit (Limits -> Int
maxMetadataBytes Limits
limits))))
    (LimitError -> MirrorStateFault)
-> Either LimitError () -> Either MirrorStateFault ()
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first LimitError -> MirrorStateFault
StateBound (Limits -> Int -> Either LimitError ()
checkVersionCountOf Limits
limits (Map Text MirrorVersion -> Int
forall k a. Map k a -> Int
Map.size (ProjectMirrorRecord -> Map Text MirrorVersion
recordVersions ProjectMirrorRecord
record)))
    (LimitError -> MirrorStateFault)
-> Either LimitError () -> Either MirrorStateFault ()
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first LimitError -> MirrorStateFault
StateBound (Limits -> Int -> Either LimitError ()
checkStateFiles Limits
limits ([Int] -> Int
forall a (f :: * -> *). (Foldable f, Num a) => f a -> a
sum ((MirrorVersion -> Int) -> [MirrorVersion] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map MirrorVersion -> Int
countFiles (Map Text MirrorVersion -> [MirrorVersion]
forall k a. Map k a -> [a]
Map.elems (ProjectMirrorRecord -> Map Text MirrorVersion
recordVersions ProjectMirrorRecord
record)))))
  where
    countFiles :: MirrorVersion -> Int
countFiles MirrorVersion
version = [Int] -> Int
forall a (f :: * -> *). (Foldable f, Num a) => f a -> a
sum [NonEmpty Artifact -> Int
forall a. NonEmpty a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (PackageDetails -> NonEmpty Artifact
pkgArtifacts PackageDetails
details) | StoredMirrorFragment PackageDetails
details MirrorReadData
_ NonEmpty ExpectedMirrorFile
_ <- NonEmpty StoredMirrorFragment -> [StoredMirrorFragment]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (MirrorVersion -> NonEmpty StoredMirrorFragment
versionFragments MirrorVersion
version)]

companionBytes :: ProjectMirrorRecord -> Integer
companionBytes :: ProjectMirrorRecord -> Integer
companionBytes ProjectMirrorRecord
record =
    [Integer] -> Integer
forall a (f :: * -> *). (Foldable f, Num a) => f a -> a
sum
        [Int -> Integer
forall a. Integral a => a -> Integer
toInteger (CompanionRef -> Int
companionSize CompanionRef
reference) | MirrorVersion
version <- Map Text MirrorVersion -> [MirrorVersion]
forall k a. Map k a -> [a]
Map.elems (ProjectMirrorRecord -> Map Text MirrorVersion
recordVersions ProjectMirrorRecord
record), CompanionRetained CompanionRef
reference <- Map Text CompanionState -> [CompanionState]
forall k a. Map k a -> [a]
Map.elems (MirrorVersion -> Map Text CompanionState
versionCompanions MirrorVersion
version)]

-- Each fragment's source encodes before the record does, so a source of another format refuses the whole record.
recordValue :: MirrorStateFormat -> ProjectMirrorRecord -> Maybe Value
recordValue :: MirrorStateFormat -> ProjectMirrorRecord -> Maybe Value
recordValue MirrorStateFormat
format ProjectMirrorRecord
record = do
    versions <- [(Text, MirrorVersion)]
-> ((Text, MirrorVersion) -> Maybe Value) -> Maybe [Value]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map Text MirrorVersion -> [(Text, MirrorVersion)]
forall k a. Map k a -> [(k, a)]
Map.toList (ProjectMirrorRecord -> Map Text MirrorVersion
recordVersions ProjectMirrorRecord
record)) (((Text, MirrorVersion) -> Maybe Value) -> Maybe [Value])
-> ((Text, MirrorVersion) -> Maybe Value) -> Maybe [Value]
forall a b. (a -> b) -> a -> b
$ \(Text
key, MirrorVersion
version) -> do
        fragments <- (StoredMirrorFragment -> Maybe Value)
-> [StoredMirrorFragment] -> Maybe [Value]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse StoredMirrorFragment -> Maybe Value
fragmentValue (NonEmpty StoredMirrorFragment -> [StoredMirrorFragment]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (MirrorVersion -> NonEmpty StoredMirrorFragment
versionFragments MirrorVersion
version))
        pure (object ["version" .= key, "fragments" .= fragments, "verified" .= [object ["filename" .= name, "digest" .= hashValueWire digest] | (name, digest) <- Map.toList (versionVerifiedIdentities version)], "companions" .= map companionValue (Map.toList (versionCompanions version))])
    pure $
        object
            [ "schema" .= (2 :: Int)
            , "target" .= targetKey (recordTarget record)
            , "package" .= nameValue (recordPackage record)
            , "envelope" .= recordEnvelope record
            , "versions" .= versions
            ]
  where
    fragmentValue :: StoredMirrorFragment -> Maybe Value
fragmentValue (StoredMirrorFragment PackageDetails
details MirrorReadData
source NonEmpty ExpectedMirrorFile
_) = (\Value
stored -> [Pair] -> Value
object [Key
"details" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PackageDetails -> Value
detailsValue PackageDetails
details, Key
"source" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
stored]) (Value -> Value) -> Maybe Value -> Maybe Value
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MirrorStateFormat -> MirrorReadData -> Maybe Value
msfEncodeSource MirrorStateFormat
format MirrorReadData
source

parseRecord :: MirrorStateFormat -> Value -> Parser ProjectMirrorRecord
parseRecord :: MirrorStateFormat -> Value -> Parser ProjectMirrorRecord
parseRecord MirrorStateFormat
format = String
-> (Object -> Parser ProjectMirrorRecord)
-> Value
-> Parser ProjectMirrorRecord
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"project mirror state" ((Object -> Parser ProjectMirrorRecord)
 -> Value -> Parser ProjectMirrorRecord)
-> (Object -> Parser ProjectMirrorRecord)
-> Value
-> Parser ProjectMirrorRecord
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    schema <- Object
value Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"schema"
    unless (schema == (2 :: Int)) (fail "unsupported mirror state schema")
    target <- StateTarget <$> value .: "target"
    name <- value .: "package" >>= parseName
    envelope <- value .: "envelope"
    versions <- value .: "versions" >>= traverse (parseVersion format name)
    ensureDistinct (map fst versions)
    for_ (listToMaybe versions) $ \(Text
_, MirrorVersion
version) -> do
        let StoredMirrorFragment PackageDetails
details MirrorReadData
source NonEmpty ExpectedMirrorFile
_ :| [StoredMirrorFragment]
_ = MirrorVersion -> NonEmpty StoredMirrorFragment
versionFragments MirrorVersion
version
        (Text -> Parser ())
-> (() -> Parser ()) -> Either Text () -> Parser ()
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Parser ()
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser ()) -> (Text -> String) -> Text -> Parser ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
forall a. ToString a => a -> String
toString) () -> Parser ()
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectEnvelope
-> Object -> PackageDetails -> MirrorReadData -> Either Text ()
envelopeCheck (MirrorStateFormat -> ProjectEnvelope
msfEnvelope MirrorStateFormat
format) Object
envelope PackageDetails
details MirrorReadData
source)
    pure (ProjectMirrorRecord target name envelope (Map.fromList versions))

parseVersion :: MirrorStateFormat -> PackageName -> Value -> Parser (Text, MirrorVersion)
parseVersion :: MirrorStateFormat
-> PackageName -> Value -> Parser (Text, MirrorVersion)
parseVersion MirrorStateFormat
format PackageName
name = String
-> (Object -> Parser (Text, MirrorVersion))
-> Value
-> Parser (Text, MirrorVersion)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"mirror version" ((Object -> Parser (Text, MirrorVersion))
 -> Value -> Parser (Text, MirrorVersion))
-> (Object -> Parser (Text, MirrorVersion))
-> Value
-> Parser (Text, MirrorVersion)
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    key <- Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"
    fragments <- value .: "fragments" >>= traverse (parseFragment format name key) >>= nonempty "empty version fragments"
    verified <-
        value .: "verified"
            >>= traverse
                ( withObject
                    "verified artifact identity"
                    ( \Object
fields -> do
                        filename <- Object
fields Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"filename"
                        digest <- fields .: "digest" >>= parseHash
                        unless (hashAlg digest == SHA256) (fail "unsupported verified artifact digest")
                        pure (filename, digest)
                    )
                )
    ensureDistinct (map fst verified)
    companions <- value .: "companions" >>= traverse parseCompanion
    ensureDistinct (map fst companions)
    let files = [ExpectedMirrorFile -> Artifact
expectedArtifact ExpectedMirrorFile
file | StoredMirrorFragment PackageDetails
_ MirrorReadData
_ NonEmpty ExpectedMirrorFile
expected <- NonEmpty StoredMirrorFragment -> [StoredMirrorFragment]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty StoredMirrorFragment
fragments, ExpectedMirrorFile
file <- NonEmpty ExpectedMirrorFile -> [ExpectedMirrorFile]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty ExpectedMirrorFile
expected]
        required = [Text] -> Set Text
forall a. Ord a => [a] -> Set a
Set.fromList [Artifact -> Text
artFilename (ExpectedMirrorFile -> Artifact
expectedArtifact ExpectedMirrorFile
file) | StoredMirrorFragment PackageDetails
_ MirrorReadData
_ NonEmpty ExpectedMirrorFile
expected <- NonEmpty StoredMirrorFragment -> [StoredMirrorFragment]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty StoredMirrorFragment
fragments, ExpectedMirrorFile
file <- NonEmpty ExpectedMirrorFile -> [ExpectedMirrorFile]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty ExpectedMirrorFile
expected, CompanionRequirement -> Artifact -> Bool
declaredSourceCompanion (MirrorStateFormat -> CompanionRequirement
msfCompanions MirrorStateFormat
format) (ExpectedMirrorFile -> Artifact
expectedArtifact ExpectedMirrorFile
file)]
    ensureDistinct (map artFilename files)
    unless (Set.fromList (map fst companions) == required) (fail "companion set does not match declared source companions")
    unless (Set.fromList (map fst verified) `Set.isSubsetOf` Set.fromList (map artFilename files)) (fail "verified digest has no expected file")
    pure (key, MirrorVersion fragments (Map.fromList verified) (Map.fromList companions))

parseFragment :: MirrorStateFormat -> PackageName -> Text -> Value -> Parser StoredMirrorFragment
parseFragment :: MirrorStateFormat
-> PackageName -> Text -> Value -> Parser StoredMirrorFragment
parseFragment MirrorStateFormat
format PackageName
name Text
key = String
-> (Object -> Parser StoredMirrorFragment)
-> Value
-> Parser StoredMirrorFragment
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"source fragment" ((Object -> Parser StoredMirrorFragment)
 -> Value -> Parser StoredMirrorFragment)
-> (Object -> Parser StoredMirrorFragment)
-> Value
-> Parser StoredMirrorFragment
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    details <- Object
value Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"details" Parser Value
-> (Value -> Parser PackageDetails) -> Parser PackageDetails
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Parser PackageDetails
parseDetails
    unless (pkgName details == name && renderVersion (pkgVersion details) == key) (fail "fragment identity mismatch")
    source <- value .: "source" >>= parseSource format
    files <- either (const (fail "invalid source fragment pairing")) pure (restoreMirrorFragment details source)
    pure (StoredMirrorFragment details source files)

nameValue :: PackageName -> Value
nameValue :: PackageName -> Value
nameValue PackageName
name = [Pair] -> Value
object [Key
"ecosystem" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Ecosystem -> Text
ecosystemName (PackageName -> Ecosystem
pkgEcosystem PackageName
name), Key
"scope" Key -> Maybe Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Scope -> Text) -> Maybe Scope -> Maybe Text
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scope -> Text
unScope (PackageName -> Maybe Scope
pkgNamespace PackageName
name), Key
"name" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PackageName -> Text
unscopedName PackageName
name]

parseName :: Value -> Parser PackageName
parseName :: Value -> Parser PackageName
parseName = String
-> (Object -> Parser PackageName) -> Value -> Parser PackageName
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"package identity" ((Object -> Parser PackageName) -> Value -> Parser PackageName)
-> (Object -> Parser PackageName) -> Value -> Parser PackageName
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    rawEco <- Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ecosystem"
    eco <- maybe (fail "unknown ecosystem") pure (parseEcosystem rawEco)
    scope <- fmap mkScope <$> value .: "scope"
    name <- value .: "name"
    pure (mkPackageName eco scope name)

detailsValue :: PackageDetails -> Value
detailsValue :: PackageDetails -> Value
detailsValue PackageDetails
details =
    [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
        [ Key
"package" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PackageName -> Value
nameValue (PackageDetails -> PackageName
pkgName PackageDetails
details)
        , Key
"version" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Version -> Text
renderVersion (PackageDetails -> Version
pkgVersion PackageDetails
details)
        , Key
"published" Key -> Maybe UTCTime -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PackageDetails -> Maybe UTCTime
pkgPublishedAt PackageDetails
details
        , Key
"install" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= CodeExecSignal -> Value
installValue (PackageDetails -> CodeExecSignal
pkgInstallCode PackageDetails
details)
        , Key
"availability" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Availability -> Text
availabilityValue (PackageDetails -> Availability
pkgAvailability PackageDetails
details)
        , Key
"artifacts" Key -> [Value] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Artifact -> Value) -> [Artifact] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map Artifact -> Value
artifactValue (NonEmpty Artifact -> [Artifact]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (PackageDetails -> NonEmpty Artifact
pkgArtifacts PackageDetails
details))
        ]
            [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> DependencySources -> [Pair]
dependencyValue (PackageDetails -> DependencySources
pkgDependencySources PackageDetails
details)

parseDetails :: Value -> Parser PackageDetails
parseDetails :: Value -> Parser PackageDetails
parseDetails = String
-> (Object -> Parser PackageDetails)
-> Value
-> Parser PackageDetails
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"admission facts" ((Object -> Parser PackageDetails)
 -> Value -> Parser PackageDetails)
-> (Object -> Parser PackageDetails)
-> Value
-> Parser PackageDetails
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    name <- Object
value Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"package" Parser Value -> (Value -> Parser PackageName) -> Parser PackageName
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Parser PackageName
parseName
    version <- mkVersion (pkgEcosystem name) <$> value .: "version"
    PackageDetails name version
        <$> value .: "published"
        <*> (value .: "install" >>= parseInstall)
        <*> (value .:? "dependencies" >>= maybe (pure DependencySourcesUnknown) parseDependencies)
        <*> (value .: "availability" >>= parseAvailability)
        <*> (value .: "artifacts" >>= traverse parseArtifact >>= nonempty "empty source fragment")

installValue :: CodeExecSignal -> Value
installValue :: CodeExecSignal -> Value
installValue CodeExecSignal
NoCodeOnInstall = [Pair] -> Value
object [Key
"kind" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"none" :: Text)]
installValue CodeExecSignal
CodeExecUnknown = [Pair] -> Value
object [Key
"kind" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"unknown" :: Text)]
installValue (RunsCodeOnInstall Text
reason) = [Pair] -> Value
object [Key
"kind" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"runs" :: Text), Key
"reason" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
reason]

parseInstall :: Value -> Parser CodeExecSignal
parseInstall :: Value -> Parser CodeExecSignal
parseInstall = String
-> (Object -> Parser CodeExecSignal)
-> Value
-> Parser CodeExecSignal
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"install fact" ((Object -> Parser CodeExecSignal)
 -> Value -> Parser CodeExecSignal)
-> (Object -> Parser CodeExecSignal)
-> Value
-> Parser CodeExecSignal
forall a b. (a -> b) -> a -> b
$ \Object
value ->
    Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"kind" Parser Text
-> (Text -> Parser CodeExecSignal) -> Parser CodeExecSignal
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Text
"none" -> CodeExecSignal -> Parser CodeExecSignal
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CodeExecSignal
NoCodeOnInstall
        Text
"unknown" -> CodeExecSignal -> Parser CodeExecSignal
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CodeExecSignal
CodeExecUnknown
        Text
"runs" -> Text -> CodeExecSignal
RunsCodeOnInstall (Text -> CodeExecSignal) -> Parser Text -> Parser CodeExecSignal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"reason"
        (Text
_ :: Text) -> String -> Parser CodeExecSignal
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"unknown install fact"

-- Absent when undetermined, as in every record written before the fact existed.
dependencyValue :: DependencySources -> [Pair]
dependencyValue :: DependencySources -> [Pair]
dependencyValue DependencySources
DependencySourcesUnknown = []
dependencyValue DependencySources
RegistryDependencies = [Key
"dependencies" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Key
"kind" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"registry" :: Text)]]
dependencyValue (FetchesOutsideRegistry Text
reason) = [Key
"dependencies" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Key
"kind" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"outside" :: Text), Key
"reason" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
reason]]

parseDependencies :: Value -> Parser DependencySources
parseDependencies :: Value -> Parser DependencySources
parseDependencies = String
-> (Object -> Parser DependencySources)
-> Value
-> Parser DependencySources
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"dependency fact" ((Object -> Parser DependencySources)
 -> Value -> Parser DependencySources)
-> (Object -> Parser DependencySources)
-> Value
-> Parser DependencySources
forall a b. (a -> b) -> a -> b
$ \Object
value ->
    Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"kind" Parser Text
-> (Text -> Parser DependencySources) -> Parser DependencySources
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Text
"registry" -> DependencySources -> Parser DependencySources
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DependencySources
RegistryDependencies
        Text
"outside" -> Text -> DependencySources
FetchesOutsideRegistry (Text -> DependencySources)
-> Parser Text -> Parser DependencySources
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"reason"
        (Text
_ :: Text) -> String -> Parser DependencySources
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"unknown dependency fact"

availabilityValue :: Availability -> Text
availabilityValue :: Availability -> Text
availabilityValue Availability
Available = Text
"available"
availabilityValue Availability
Deprecated = Text
"deprecated"
availabilityValue Availability
Yanked = Text
"yanked"

parseAvailability :: Text -> Parser Availability
parseAvailability :: Text -> Parser Availability
parseAvailability Text
"available" = Availability -> Parser Availability
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Availability
Available
parseAvailability Text
"deprecated" = Availability -> Parser Availability
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Availability
Deprecated
parseAvailability Text
"yanked" = Availability -> Parser Availability
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Availability
Yanked
parseAvailability Text
_ = String -> Parser Availability
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"unknown availability fact"

artifactValue :: Artifact -> Value
artifactValue :: Artifact -> Value
artifactValue Artifact
artifact =
    [Pair] -> Value
object
        [ Key
"key" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EntryKey -> Value
keyValue (Artifact -> EntryKey
artEntryKey Artifact
artifact)
        , Key
"filename" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Artifact -> Text
artFilename Artifact
artifact
        , Key
"url" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Artifact -> Text
artUrl Artifact
artifact
        , Key
"hashes" Key -> [Value] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Hash -> Value) -> [Hash] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map Hash -> Value
hashValueWire (Artifact -> [Hash]
artHashes Artifact
artifact)
        , Key
"size" Key -> Maybe Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Artifact -> Maybe Int
artSize Artifact
artifact
        , Key
"companion" Key -> Maybe Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (CoreMetadata -> Value) -> Maybe CoreMetadata -> Maybe Value
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CoreMetadata -> Value
metadataValue (Artifact -> Maybe CoreMetadata
artCoreMetadata Artifact
artifact)
        ]

parseArtifact :: Value -> Parser Artifact
parseArtifact :: Value -> Parser Artifact
parseArtifact = String -> (Object -> Parser Artifact) -> Value -> Parser Artifact
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"artifact" ((Object -> Parser Artifact) -> Value -> Parser Artifact)
-> (Object -> Parser Artifact) -> Value -> Parser Artifact
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    key <- Object
value Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key" Parser Value -> (Value -> Parser EntryKey) -> Parser EntryKey
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Parser EntryKey
parseKey
    name <- value .: "filename"
    url <- value .: "url"
    metadata <- value .: "companion" >>= traverse parseMetadata
    hashes <- value .: "hashes" >>= traverse parseHash
    size <- value .: "size"
    when (any (< 0) size) (fail "negative artifact size")
    pure Artifact{artEntryKey = key, artFilename = name, artUrl = url, artHashes = hashes, artSize = size, artCoreMetadata = metadata}

hashValueWire :: Hash -> Value
hashValueWire :: Hash -> Value
hashValueWire Hash
digest = [Pair] -> Value
object [Key
"algorithm" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= HashAlg -> Text
renderHashAlg (Hash -> HashAlg
hashAlg Hash
digest), Key
"value" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash -> Text
hashValue Hash
digest]

parseHash :: Value -> Parser Hash
parseHash :: Value -> Parser Hash
parseHash = String -> (Object -> Parser Hash) -> Value -> Parser Hash
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"digest" ((Object -> Parser Hash) -> Value -> Parser Hash)
-> (Object -> Parser Hash) -> Value -> Parser Hash
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    alg <- Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"algorithm" Parser Text -> (Text -> Parser HashAlg) -> Parser HashAlg
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Text -> Parser HashAlg)
-> (HashAlg -> Parser HashAlg)
-> Either Text HashAlg
-> Parser HashAlg
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Parser HashAlg
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser HashAlg)
-> (Text -> String) -> Text -> Parser HashAlg
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
forall a. ToString a => a -> String
toString) HashAlg -> Parser HashAlg
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either Text HashAlg -> Parser HashAlg)
-> (Text -> Either Text HashAlg) -> Text -> Parser HashAlg
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either Text HashAlg
parseHashAlg
    raw <- value .: "value"
    either (fail . toString) pure (mkHash alg raw)

metadataValue :: CoreMetadata -> Value
metadataValue :: CoreMetadata -> Value
metadataValue (MetadataAvailable Bool
available) = Bool -> Value
Bool Bool
available
metadataValue (MetadataDigests Map Text Text
values) = [Pair] -> Value
object [Key
"digests" Key -> Map Text Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Map Text Text
values]

parseMetadata :: Value -> Parser CoreMetadata
parseMetadata :: Value -> Parser CoreMetadata
parseMetadata (Bool Bool
available) = CoreMetadata -> Parser CoreMetadata
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> CoreMetadata
MetadataAvailable Bool
available)
parseMetadata Value
value = String
-> (Object -> Parser CoreMetadata) -> Value -> Parser CoreMetadata
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"companion declaration" ((Map Text Text -> CoreMetadata)
-> Parser (Map Text Text) -> Parser CoreMetadata
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map Text Text -> CoreMetadata
MetadataDigests (Parser (Map Text Text) -> Parser CoreMetadata)
-> (Object -> Parser (Map Text Text))
-> Object
-> Parser CoreMetadata
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Object -> Key -> Parser (Map Text Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"digests")) Value
value

keyValue :: EntryKey -> Value
keyValue :: EntryKey -> Value
keyValue (ArrayEntry Int
position) = [Pair] -> Value
object [Key
"array" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Int
position]
keyValue (RecordEntry Int
position) = [Pair] -> Value
object [Key
"record" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Int
position]
keyValue (ObjectEntry Text
text) = [Pair] -> Value
object [Key
"object" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
text]
keyValue EntryKey
SingletonEntry = Value
Null

parseKey :: Value -> Parser EntryKey
parseKey :: Value -> Parser EntryKey
parseKey Value
Null = EntryKey -> Parser EntryKey
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EntryKey
SingletonEntry
parseKey Value
value =
    String -> (Object -> Parser EntryKey) -> Value -> Parser EntryKey
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject
        String
"source coordinate"
        ( \Object
fields ->
            ( do
                key <- Int -> EntryKey
ArrayEntry (Int -> EntryKey) -> Parser Int -> Parser EntryKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
fields Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"array"
                unless (validEntryKey key) (fail "negative source coordinate")
                pure key
            )
                Parser EntryKey -> Parser EntryKey -> Parser EntryKey
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ( do
                        key <- Int -> EntryKey
RecordEntry (Int -> EntryKey) -> Parser Int -> Parser EntryKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
fields Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"record"
                        unless (validEntryKey key) (fail "negative source coordinate")
                        pure key
                    )
                Parser EntryKey -> Parser EntryKey -> Parser EntryKey
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Text -> EntryKey
ObjectEntry (Text -> EntryKey) -> Parser Text -> Parser EntryKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
fields Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object")
        )
        Value
value

parseSource :: MirrorStateFormat -> Value -> Parser MirrorReadData
parseSource :: MirrorStateFormat -> Value -> Parser MirrorReadData
parseSource MirrorStateFormat
format = String
-> (Object -> Parser MirrorReadData)
-> Value
-> Parser MirrorReadData
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"read source" ((Object -> Parser MirrorReadData)
 -> Value -> Parser MirrorReadData)
-> (Object -> Parser MirrorReadData)
-> Value
-> Parser MirrorReadData
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    kind <- Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"kind"
    unless (kind == msfKind format) (fail "unknown source shape")
    msfDecodeSource format value

-- | Stored entries keep each value under its source coordinate.
sourceEntries :: [(EntryKey, Value)] -> [Value]
sourceEntries :: [(EntryKey, Value)] -> [Value]
sourceEntries [(EntryKey, Value)]
entries = [[Pair] -> Value
object [Key
"key" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EntryKey -> Value
keyValue EntryKey
key, Key
"value" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
value] | (EntryKey
key, Value
value) <- [(EntryKey, Value)]
entries]

-- | Read stored entries under @label@, refusing a repeated coordinate.
parseSourceEntries :: String -> Object -> Parser [(EntryKey, Value)]
parseSourceEntries :: String -> Object -> Parser [(EntryKey, Value)]
parseSourceEntries String
label Object
value = do
    entries <- Object
value Object -> Key -> Parser [Value]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"entries" Parser [Value]
-> ([Value] -> Parser [(EntryKey, Value)])
-> Parser [(EntryKey, Value)]
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Value -> Parser (EntryKey, Value))
-> [Value] -> Parser [(EntryKey, Value)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (String
-> (Object -> Parser (EntryKey, Value))
-> Value
-> Parser (EntryKey, Value)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
label (\Object
entry -> (,) (EntryKey -> Value -> (EntryKey, Value))
-> Parser EntryKey -> Parser (Value -> (EntryKey, Value))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
entry Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key" Parser Value -> (Value -> Parser EntryKey) -> Parser EntryKey
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Parser EntryKey
parseKey) Parser (Value -> (EntryKey, Value))
-> Parser Value -> Parser (EntryKey, Value)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
entry Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"))
    entries <$ ensureDistinct (map fst entries)

companionValue :: (Text, CompanionState) -> Value
companionValue :: (Text, CompanionState) -> Value
companionValue (Text
name, CompanionState
stateValue) = [Pair] -> Value
object [Key
"filename" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
name, Key
"retained" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
reference]
  where
    reference :: Value
reference = case CompanionState
stateValue of
        CompanionState
CompanionPending -> Value
Null
        CompanionRetained (CompanionRef Hash
digest Int
size) -> [Pair] -> Value
object [Key
"digest" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Hash -> Value
hashValueWire Hash
digest, Key
"size" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Int
size]

parseCompanion :: Value -> Parser (Text, CompanionState)
parseCompanion :: Value -> Parser (Text, CompanionState)
parseCompanion = String
-> (Object -> Parser (Text, CompanionState))
-> Value
-> Parser (Text, CompanionState)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"companion state" ((Object -> Parser (Text, CompanionState))
 -> Value -> Parser (Text, CompanionState))
-> (Object -> Parser (Text, CompanionState))
-> Value
-> Parser (Text, CompanionState)
forall a b. (a -> b) -> a -> b
$ \Object
value -> do
    name <- Object
value Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"filename"
    retained <- value .: "retained"
    status <- case retained of
        Value
Null -> CompanionState -> Parser CompanionState
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CompanionState
CompanionPending
        Value
other ->
            String
-> (Object -> Parser CompanionState)
-> Value
-> Parser CompanionState
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject
                String
"retained companion"
                ( \Object
fields -> do
                    digest <- Object
fields Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"digest" Parser Value -> (Value -> Parser Hash) -> Parser Hash
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Parser Hash
parseHash
                    size <- fields .: "size"
                    unless (hashAlg digest == SHA256 && size >= 0) (fail "invalid retained companion identity")
                    pure (CompanionRetained (CompanionRef digest size))
                )
                Value
other
    pure (name, status)

ensureDistinct :: (Ord a) => [a] -> Parser ()
ensureDistinct :: forall a. Ord a => [a] -> Parser ()
ensureDistinct [a]
values = Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([a] -> Bool
forall key. Ord key => [key] -> Bool
distinctKeys [a]
values) (String -> Parser ()
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"duplicate state entry")

nonempty :: String -> [a] -> Parser (NonEmpty a)
nonempty :: forall a. String -> [a] -> Parser (NonEmpty a)
nonempty String
message = Parser (NonEmpty a)
-> (NonEmpty a -> Parser (NonEmpty a))
-> Maybe (NonEmpty a)
-> Parser (NonEmpty a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Parser (NonEmpty a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
message) NonEmpty a -> Parser (NonEmpty a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (NonEmpty a) -> Parser (NonEmpty a))
-> ([a] -> Maybe (NonEmpty a)) -> [a] -> Parser (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (NonEmpty a)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty