{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module System.Nix.Store.Remote.Serializer
(
NixSerializer
, mapReaderS
, mapErrorS
, SError(..)
, runSerialT
, runG
, runP
, int
, bool
, byteString
, enum
, text
, maybeText
, time
, list
, set
, hashSet
, mapS
, vector
, json
, protoVersion
, storePath
, maybePath
, storePathHashPart
, storePathName
, pathMetadata
, outputName
, signature
, narSignature
, someHashAlgo
, digest
, namedDigest
, derivation
, derivedPath
, buildMode
, LoggerSError(..)
, activityID
, maybeActivity
, activity
, activityResult
, field
, trace
, basicError
, errorInfo
, loggerOpCode
, logger
, verbosity
, HandshakeSError(..)
, workerMagic
, trustedFlag
, storeText
, workerOp
, RequestSError(..)
, storeRequest
, ReplySError(..)
, opSuccess
, noop
, derivationOutputTyped
, realisation
, realisationWithId
, buildResult
, gcResult
, gcRoot
, missing
, maybePathMetadata
) where
import Control.Monad.Except (MonadError, throwError, )
import Control.Monad.Reader (MonadReader)
import Control.Monad.Trans (MonadTrans, lift)
import Control.Monad.Trans.Reader (ReaderT, runReaderT, withReaderT)
import Control.Monad.Trans.Except (ExceptT, mapExceptT, runExceptT, withExceptT)
import Crypto.Hash (Digest, HashAlgorithm, SHA256)
import Data.Aeson (FromJSON, ToJSON)
import Data.ByteString (ByteString)
import Data.Dependent.Sum (DSum((:=>)))
import Data.Fixed (Uni)
import Data.Hashable (Hashable)
import Data.HashSet (HashSet)
import Data.Map (Map)
import Data.Serializer
import Data.Set (Set)
import Data.Some (Some(Some))
import Data.Text (Text)
import Data.Text.Lazy.Builder (Builder)
import Data.Time (NominalDiffTime, UTCTime)
import Data.Vector (Vector)
import Data.Word (Word8, Word32, Word64)
import GHC.Generics (Generic)
import System.Nix.Base (BaseEncoding(Base16, NixBase32))
import System.Nix.Build (BuildMode, BuildResult(..))
import System.Nix.ContentAddress (ContentAddress)
import System.Nix.Derivation (Derivation(..), DerivationOutput(..))
import System.Nix.DerivedPath (DerivedPath(..), ParseOutputsError)
import System.Nix.Hash (HashAlgo(..))
import System.Nix.JSON ()
import System.Nix.OutputName (OutputName)
import System.Nix.Realisation (DerivationOutputError, Realisation(..), RealisationWithId(..))
import System.Nix.Signature (Signature, NarSignature)
import System.Nix.Store.Types (FileIngestionMethod(..), RepairMode(..))
import System.Nix.StorePath (HasStoreDir(..), InvalidNameError, InvalidPathError, StorePath, StorePathHashPart, StorePathName)
import System.Nix.StorePath.Metadata (Metadata(..), StorePathTrust(..))
import System.Nix.Store.Remote.Types
import qualified Control.Monad
import qualified Control.Monad.Reader
import qualified Data.Aeson
import qualified Data.Attoparsec.Text
import qualified Data.Bifunctor
import qualified Data.Bits
import qualified Data.ByteString
import qualified Data.ByteString.Char8
import qualified Data.ByteString.Lazy
import qualified Data.Coerce
import qualified Data.HashSet
import qualified Data.Map.Strict
import qualified Data.Maybe
import qualified Data.Serialize.Get
import qualified Data.Serialize.Put
import qualified Data.Set
import qualified Data.Some
import qualified Data.Text
import qualified Data.Text.Encoding
import qualified Data.Text.Lazy
import qualified Data.Text.Lazy.Builder
import qualified Data.Time.Clock.POSIX
import qualified Data.Vector
import qualified System.Nix.Base
import qualified System.Nix.ContentAddress
import qualified System.Nix.DerivedPath
import qualified System.Nix.Hash
import qualified System.Nix.OutputName
import qualified System.Nix.Realisation
import qualified System.Nix.Signature
import qualified System.Nix.StorePath
newtype SerialT r e m a = SerialT
{ forall r e (m :: * -> *) a.
SerialT r e m a -> ExceptT e (ReaderT r m) a
_unSerialT :: ExceptT e (ReaderT r m) a }
deriving
( Functor (SerialT r e m)
Functor (SerialT r e m) =>
(forall a. a -> SerialT r e m a)
-> (forall a b.
SerialT r e m (a -> b) -> SerialT r e m a -> SerialT r e m b)
-> (forall a b c.
(a -> b -> c)
-> SerialT r e m a -> SerialT r e m b -> SerialT r e m c)
-> (forall a b.
SerialT r e m a -> SerialT r e m b -> SerialT r e m b)
-> (forall a b.
SerialT r e m a -> SerialT r e m b -> SerialT r e m a)
-> Applicative (SerialT r e m)
forall a. a -> SerialT r e m a
forall a b. SerialT r e m a -> SerialT r e m b -> SerialT r e m a
forall a b. SerialT r e m a -> SerialT r e m b -> SerialT r e m b
forall a b.
SerialT r e m (a -> b) -> SerialT r e m a -> SerialT r e m b
forall a b c.
(a -> b -> c)
-> SerialT r e m a -> SerialT r e m b -> SerialT r e m c
forall r e (m :: * -> *). Monad m => Functor (SerialT r e m)
forall r e (m :: * -> *) a. Monad m => a -> SerialT r e m a
forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> SerialT r e m b -> SerialT r e m a
forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> SerialT r e m b -> SerialT r e m b
forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m (a -> b) -> SerialT r e m a -> SerialT r e m b
forall r e (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> SerialT r e m a -> SerialT r e m b -> SerialT r e m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall r e (m :: * -> *) a. Monad m => a -> SerialT r e m a
pure :: forall a. a -> SerialT r e m a
$c<*> :: forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m (a -> b) -> SerialT r e m a -> SerialT r e m b
<*> :: forall a b.
SerialT r e m (a -> b) -> SerialT r e m a -> SerialT r e m b
$cliftA2 :: forall r e (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> SerialT r e m a -> SerialT r e m b -> SerialT r e m c
liftA2 :: forall a b c.
(a -> b -> c)
-> SerialT r e m a -> SerialT r e m b -> SerialT r e m c
$c*> :: forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> SerialT r e m b -> SerialT r e m b
*> :: forall a b. SerialT r e m a -> SerialT r e m b -> SerialT r e m b
$c<* :: forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> SerialT r e m b -> SerialT r e m a
<* :: forall a b. SerialT r e m a -> SerialT r e m b -> SerialT r e m a
Applicative
, (forall a b. (a -> b) -> SerialT r e m a -> SerialT r e m b)
-> (forall a b. a -> SerialT r e m b -> SerialT r e m a)
-> Functor (SerialT r e m)
forall a b. a -> SerialT r e m b -> SerialT r e m a
forall a b. (a -> b) -> SerialT r e m a -> SerialT r e m b
forall r e (m :: * -> *) a b.
Functor m =>
a -> SerialT r e m b -> SerialT r e m a
forall r e (m :: * -> *) a b.
Functor m =>
(a -> b) -> SerialT r e m a -> SerialT r e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall r e (m :: * -> *) a b.
Functor m =>
(a -> b) -> SerialT r e m a -> SerialT r e m b
fmap :: forall a b. (a -> b) -> SerialT r e m a -> SerialT r e m b
$c<$ :: forall r e (m :: * -> *) a b.
Functor m =>
a -> SerialT r e m b -> SerialT r e m a
<$ :: forall a b. a -> SerialT r e m b -> SerialT r e m a
Functor
, Applicative (SerialT r e m)
Applicative (SerialT r e m) =>
(forall a b.
SerialT r e m a -> (a -> SerialT r e m b) -> SerialT r e m b)
-> (forall a b.
SerialT r e m a -> SerialT r e m b -> SerialT r e m b)
-> (forall a. a -> SerialT r e m a)
-> Monad (SerialT r e m)
forall a. a -> SerialT r e m a
forall a b. SerialT r e m a -> SerialT r e m b -> SerialT r e m b
forall a b.
SerialT r e m a -> (a -> SerialT r e m b) -> SerialT r e m b
forall r e (m :: * -> *). Monad m => Applicative (SerialT r e m)
forall r e (m :: * -> *) a. Monad m => a -> SerialT r e m a
forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> SerialT r e m b -> SerialT r e m b
forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> (a -> SerialT r e m b) -> SerialT r e m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> (a -> SerialT r e m b) -> SerialT r e m b
>>= :: forall a b.
SerialT r e m a -> (a -> SerialT r e m b) -> SerialT r e m b
$c>> :: forall r e (m :: * -> *) a b.
Monad m =>
SerialT r e m a -> SerialT r e m b -> SerialT r e m b
>> :: forall a b. SerialT r e m a -> SerialT r e m b -> SerialT r e m b
$creturn :: forall r e (m :: * -> *) a. Monad m => a -> SerialT r e m a
return :: forall a. a -> SerialT r e m a
Monad
, MonadError e
, MonadReader r
, Monad (SerialT r e m)
Monad (SerialT r e m) =>
(forall a. String -> SerialT r e m a) -> MonadFail (SerialT r e m)
forall a. String -> SerialT r e m a
forall r e (m :: * -> *). MonadFail m => Monad (SerialT r e m)
forall r e (m :: * -> *) a.
MonadFail m =>
String -> SerialT r e m a
forall (m :: * -> *).
Monad m =>
(forall a. String -> m a) -> MonadFail m
$cfail :: forall r e (m :: * -> *) a.
MonadFail m =>
String -> SerialT r e m a
fail :: forall a. String -> SerialT r e m a
MonadFail
)
instance MonadTrans (SerialT r e) where
lift :: forall (m :: * -> *) a. Monad m => m a -> SerialT r e m a
lift = ExceptT e (ReaderT r m) a -> SerialT r e m a
forall r e (m :: * -> *) a.
ExceptT e (ReaderT r m) a -> SerialT r e m a
SerialT (ExceptT e (ReaderT r m) a -> SerialT r e m a)
-> (m a -> ExceptT e (ReaderT r m) a) -> m a -> SerialT r e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT r m a -> ExceptT e (ReaderT r m) a
forall (m :: * -> *) a. Monad m => m a -> ExceptT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT r m a -> ExceptT e (ReaderT r m) a)
-> (m a -> ReaderT r m a) -> m a -> ExceptT e (ReaderT r m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ReaderT r m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
runSerialT
:: Monad m
=> r
-> SerialT r e m a
-> m (Either e a)
runSerialT :: forall (m :: * -> *) r e a.
Monad m =>
r -> SerialT r e m a -> m (Either e a)
runSerialT r
r =
(ReaderT r m (Either e a) -> r -> m (Either e a)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
`runReaderT` r
r)
(ReaderT r m (Either e a) -> m (Either e a))
-> (SerialT r e m a -> ReaderT r m (Either e a))
-> SerialT r e m a
-> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT e (ReaderT r m) a -> ReaderT r m (Either e a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT
(ExceptT e (ReaderT r m) a -> ReaderT r m (Either e a))
-> (SerialT r e m a -> ExceptT e (ReaderT r m) a)
-> SerialT r e m a
-> ReaderT r m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerialT r e m a -> ExceptT e (ReaderT r m) a
forall r e (m :: * -> *) a.
SerialT r e m a -> ExceptT e (ReaderT r m) a
_unSerialT
mapErrorST
:: Functor m
=> (e -> e')
-> SerialT r e m a
-> SerialT r e' m a
mapErrorST :: forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST e -> e'
f =
ExceptT e' (ReaderT r m) a -> SerialT r e' m a
forall r e (m :: * -> *) a.
ExceptT e (ReaderT r m) a -> SerialT r e m a
SerialT
(ExceptT e' (ReaderT r m) a -> SerialT r e' m a)
-> (SerialT r e m a -> ExceptT e' (ReaderT r m) a)
-> SerialT r e m a
-> SerialT r e' m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> e')
-> ExceptT e (ReaderT r m) a -> ExceptT e' (ReaderT r m) a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> e'
f
(ExceptT e (ReaderT r m) a -> ExceptT e' (ReaderT r m) a)
-> (SerialT r e m a -> ExceptT e (ReaderT r m) a)
-> SerialT r e m a
-> ExceptT e' (ReaderT r m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerialT r e m a -> ExceptT e (ReaderT r m) a
forall r e (m :: * -> *) a.
SerialT r e m a -> ExceptT e (ReaderT r m) a
_unSerialT
mapErrorS
:: (e -> e')
-> NixSerializer r e a
-> NixSerializer r e' a
mapErrorS :: forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS e -> e'
f NixSerializer r e a
s = Serializer
{ getS :: SerialT r e' Get a
getS = (e -> e') -> SerialT r e Get a -> SerialT r e' Get a
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST e -> e'
f (SerialT r e Get a -> SerialT r e' Get a)
-> SerialT r e Get a -> SerialT r e' Get a
forall a b. (a -> b) -> a -> b
$ NixSerializer r e a -> SerialT r e Get a
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS NixSerializer r e a
s
, putS :: a -> SerialT r e' PutM ()
putS = (e -> e') -> SerialT r e PutM () -> SerialT r e' PutM ()
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST e -> e'
f (SerialT r e PutM () -> SerialT r e' PutM ())
-> (a -> SerialT r e PutM ()) -> a -> SerialT r e' PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a -> a -> SerialT r e PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS NixSerializer r e a
s
}
mapReaderST
:: Functor m
=> (r' -> r)
-> SerialT r e m a
-> SerialT r' e m a
mapReaderST :: forall (m :: * -> *) r' r e a.
Functor m =>
(r' -> r) -> SerialT r e m a -> SerialT r' e m a
mapReaderST r' -> r
f =
ExceptT e (ReaderT r' m) a -> SerialT r' e m a
forall r e (m :: * -> *) a.
ExceptT e (ReaderT r m) a -> SerialT r e m a
SerialT
(ExceptT e (ReaderT r' m) a -> SerialT r' e m a)
-> (SerialT r e m a -> ExceptT e (ReaderT r' m) a)
-> SerialT r e m a
-> SerialT r' e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((ReaderT r m (Either e a) -> ReaderT r' m (Either e a))
-> ExceptT e (ReaderT r m) a -> ExceptT e (ReaderT r' m) a
forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ExceptT e m a -> ExceptT e' n b
mapExceptT ((ReaderT r m (Either e a) -> ReaderT r' m (Either e a))
-> ExceptT e (ReaderT r m) a -> ExceptT e (ReaderT r' m) a)
-> ((r' -> r)
-> ReaderT r m (Either e a) -> ReaderT r' m (Either e a))
-> (r' -> r)
-> ExceptT e (ReaderT r m) a
-> ExceptT e (ReaderT r' m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r' -> r) -> ReaderT r m (Either e a) -> ReaderT r' m (Either e a)
forall r' r (m :: * -> *) a.
(r' -> r) -> ReaderT r m a -> ReaderT r' m a
withReaderT) r' -> r
f
(ExceptT e (ReaderT r m) a -> ExceptT e (ReaderT r' m) a)
-> (SerialT r e m a -> ExceptT e (ReaderT r m) a)
-> SerialT r e m a
-> ExceptT e (ReaderT r' m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerialT r e m a -> ExceptT e (ReaderT r m) a
forall r e (m :: * -> *) a.
SerialT r e m a -> ExceptT e (ReaderT r m) a
_unSerialT
mapReaderS
:: (r' -> r)
-> NixSerializer r e a
-> NixSerializer r' e a
mapReaderS :: forall r' r e a.
(r' -> r) -> NixSerializer r e a -> NixSerializer r' e a
mapReaderS r' -> r
f NixSerializer r e a
s = Serializer
{ getS :: SerialT r' e Get a
getS = (r' -> r) -> SerialT r e Get a -> SerialT r' e Get a
forall (m :: * -> *) r' r e a.
Functor m =>
(r' -> r) -> SerialT r e m a -> SerialT r' e m a
mapReaderST r' -> r
f (SerialT r e Get a -> SerialT r' e Get a)
-> SerialT r e Get a -> SerialT r' e Get a
forall a b. (a -> b) -> a -> b
$ NixSerializer r e a -> SerialT r e Get a
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS NixSerializer r e a
s
, putS :: a -> SerialT r' e PutM ()
putS = (r' -> r) -> SerialT r e PutM () -> SerialT r' e PutM ()
forall (m :: * -> *) r' r e a.
Functor m =>
(r' -> r) -> SerialT r e m a -> SerialT r' e m a
mapReaderST r' -> r
f (SerialT r e PutM () -> SerialT r' e PutM ())
-> (a -> SerialT r e PutM ()) -> a -> SerialT r' e PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a -> a -> SerialT r e PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS NixSerializer r e a
s
}
type NixSerializer r e = Serializer (SerialT r e)
data SError
= SError
| SError_BadPadding
{ SError -> ByteString
badPaddingStr :: ByteString
, SError -> Int
badPaddingLen :: Int
, SError -> [Word8]
badPaddingPads :: [Word8]
}
| SError_ContentAddress String
| SError_DerivedPath ParseOutputsError
| SError_DerivationOutput DerivationOutputError
| SError_Digest String
| SError_EnumOutOfMinBound Int
| SError_EnumOutOfMaxBound Int
| SError_HashAlgo String
| SError_IllegalBool Word64
| SError_InvalidNixBase32
| SError_JSONDecoding String
| SError_NarHashMustBeSHA256
| SError_NotYetImplemented String (ForPV ProtoVersion)
| SError_Name InvalidNameError
| SError_Path InvalidPathError
| SError_Signature String
deriving (SError -> SError -> Bool
(SError -> SError -> Bool)
-> (SError -> SError -> Bool) -> Eq SError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SError -> SError -> Bool
== :: SError -> SError -> Bool
$c/= :: SError -> SError -> Bool
/= :: SError -> SError -> Bool
Eq, Eq SError
Eq SError =>
(SError -> SError -> Ordering)
-> (SError -> SError -> Bool)
-> (SError -> SError -> Bool)
-> (SError -> SError -> Bool)
-> (SError -> SError -> Bool)
-> (SError -> SError -> SError)
-> (SError -> SError -> SError)
-> Ord SError
SError -> SError -> Bool
SError -> SError -> Ordering
SError -> SError -> SError
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SError -> SError -> Ordering
compare :: SError -> SError -> Ordering
$c< :: SError -> SError -> Bool
< :: SError -> SError -> Bool
$c<= :: SError -> SError -> Bool
<= :: SError -> SError -> Bool
$c> :: SError -> SError -> Bool
> :: SError -> SError -> Bool
$c>= :: SError -> SError -> Bool
>= :: SError -> SError -> Bool
$cmax :: SError -> SError -> SError
max :: SError -> SError -> SError
$cmin :: SError -> SError -> SError
min :: SError -> SError -> SError
Ord, (forall x. SError -> Rep SError x)
-> (forall x. Rep SError x -> SError) -> Generic SError
forall x. Rep SError x -> SError
forall x. SError -> Rep SError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SError -> Rep SError x
from :: forall x. SError -> Rep SError x
$cto :: forall x. Rep SError x -> SError
to :: forall x. Rep SError x -> SError
Generic, Int -> SError -> ShowS
[SError] -> ShowS
SError -> String
(Int -> SError -> ShowS)
-> (SError -> String) -> ([SError] -> ShowS) -> Show SError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SError -> ShowS
showsPrec :: Int -> SError -> ShowS
$cshow :: SError -> String
show :: SError -> String
$cshowList :: [SError] -> ShowS
showList :: [SError] -> ShowS
Show)
data ForPV a
= ForPV_Newer a
| ForPV_Older a
deriving (ForPV a -> ForPV a -> Bool
(ForPV a -> ForPV a -> Bool)
-> (ForPV a -> ForPV a -> Bool) -> Eq (ForPV a)
forall a. Eq a => ForPV a -> ForPV a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ForPV a -> ForPV a -> Bool
== :: ForPV a -> ForPV a -> Bool
$c/= :: forall a. Eq a => ForPV a -> ForPV a -> Bool
/= :: ForPV a -> ForPV a -> Bool
Eq, Eq (ForPV a)
Eq (ForPV a) =>
(ForPV a -> ForPV a -> Ordering)
-> (ForPV a -> ForPV a -> Bool)
-> (ForPV a -> ForPV a -> Bool)
-> (ForPV a -> ForPV a -> Bool)
-> (ForPV a -> ForPV a -> Bool)
-> (ForPV a -> ForPV a -> ForPV a)
-> (ForPV a -> ForPV a -> ForPV a)
-> Ord (ForPV a)
ForPV a -> ForPV a -> Bool
ForPV a -> ForPV a -> Ordering
ForPV a -> ForPV a -> ForPV a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (ForPV a)
forall a. Ord a => ForPV a -> ForPV a -> Bool
forall a. Ord a => ForPV a -> ForPV a -> Ordering
forall a. Ord a => ForPV a -> ForPV a -> ForPV a
$ccompare :: forall a. Ord a => ForPV a -> ForPV a -> Ordering
compare :: ForPV a -> ForPV a -> Ordering
$c< :: forall a. Ord a => ForPV a -> ForPV a -> Bool
< :: ForPV a -> ForPV a -> Bool
$c<= :: forall a. Ord a => ForPV a -> ForPV a -> Bool
<= :: ForPV a -> ForPV a -> Bool
$c> :: forall a. Ord a => ForPV a -> ForPV a -> Bool
> :: ForPV a -> ForPV a -> Bool
$c>= :: forall a. Ord a => ForPV a -> ForPV a -> Bool
>= :: ForPV a -> ForPV a -> Bool
$cmax :: forall a. Ord a => ForPV a -> ForPV a -> ForPV a
max :: ForPV a -> ForPV a -> ForPV a
$cmin :: forall a. Ord a => ForPV a -> ForPV a -> ForPV a
min :: ForPV a -> ForPV a -> ForPV a
Ord, (forall x. ForPV a -> Rep (ForPV a) x)
-> (forall x. Rep (ForPV a) x -> ForPV a) -> Generic (ForPV a)
forall x. Rep (ForPV a) x -> ForPV a
forall x. ForPV a -> Rep (ForPV a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ForPV a) x -> ForPV a
forall a x. ForPV a -> Rep (ForPV a) x
$cfrom :: forall a x. ForPV a -> Rep (ForPV a) x
from :: forall x. ForPV a -> Rep (ForPV a) x
$cto :: forall a x. Rep (ForPV a) x -> ForPV a
to :: forall x. Rep (ForPV a) x -> ForPV a
Generic, Int -> ForPV a -> ShowS
[ForPV a] -> ShowS
ForPV a -> String
(Int -> ForPV a -> ShowS)
-> (ForPV a -> String) -> ([ForPV a] -> ShowS) -> Show (ForPV a)
forall a. Show a => Int -> ForPV a -> ShowS
forall a. Show a => [ForPV a] -> ShowS
forall a. Show a => ForPV a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ForPV a -> ShowS
showsPrec :: Int -> ForPV a -> ShowS
$cshow :: forall a. Show a => ForPV a -> String
show :: ForPV a -> String
$cshowList :: forall a. Show a => [ForPV a] -> ShowS
showList :: [ForPV a] -> ShowS
Show)
runG
:: NixSerializer r e a
-> r
-> ByteString
-> Either (GetSerializerError e) a
runG :: forall r e a.
NixSerializer r e a
-> r -> ByteString -> Either (GetSerializerError e) a
runG NixSerializer r e a
serializer r
r =
Either String (Either e a) -> Either (GetSerializerError e) a
forall customGetError b.
Either String (Either customGetError b)
-> Either (GetSerializerError customGetError) b
transformGetError
(Either String (Either e a) -> Either (GetSerializerError e) a)
-> (ByteString -> Either String (Either e a))
-> ByteString
-> Either (GetSerializerError e) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a
-> (SerialT r e Get a -> Get (Either e a))
-> ByteString
-> Either String (Either e a)
forall (t :: (* -> *) -> * -> *) a b.
(Monad (t Get), MonadTrans t) =>
Serializer t a
-> (t Get a -> Get b) -> ByteString -> Either String b
runGetS
NixSerializer r e a
serializer
(r -> SerialT r e Get a -> Get (Either e a)
forall (m :: * -> *) r e a.
Monad m =>
r -> SerialT r e m a -> m (Either e a)
runSerialT r
r)
runP
:: NixSerializer r e a
-> r
-> a
-> Either e ByteString
runP :: forall r e a. NixSerializer r e a -> r -> a -> Either e ByteString
runP NixSerializer r e a
serializer r
r =
(Either e (), ByteString) -> Either e ByteString
forall customPutError.
(Either customPutError (), ByteString)
-> Either customPutError ByteString
transformPutError
((Either e (), ByteString) -> Either e ByteString)
-> (a -> (Either e (), ByteString)) -> a -> Either e ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a
-> (SerialT r e PutM () -> PutM (Either e ()))
-> a
-> (Either e (), ByteString)
forall (t :: (* -> *) -> * -> *) a b.
(Monad (t PutM), MonadTrans t) =>
Serializer t a -> (t PutM () -> PutM b) -> a -> (b, ByteString)
runPutS
NixSerializer r e a
serializer
(r -> SerialT r e PutM () -> PutM (Either e ())
forall (m :: * -> *) r e a.
Monad m =>
r -> SerialT r e m a -> m (Either e a)
runSerialT r
r)
int :: Integral a => NixSerializer r e a
int :: forall a r e. Integral a => NixSerializer r e a
int = Serializer
{ getS :: SerialT r e Get a
getS = Word64 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> a) -> SerialT r e Get Word64 -> SerialT r e Get a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64 -> SerialT r e Get Word64
forall (m :: * -> *) a. Monad m => m a -> SerialT r e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get Word64
Data.Serialize.Get.getWord64le
, putS :: a -> SerialT r e PutM ()
putS = PutM () -> SerialT r e PutM ()
forall (m :: * -> *) a. Monad m => m a -> SerialT r e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (PutM () -> SerialT r e PutM ())
-> (a -> PutM ()) -> a -> SerialT r e PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Putter Word64
Data.Serialize.Put.putWord64le Putter Word64 -> (a -> Word64) -> a -> PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
}
bool :: NixSerializer r SError Bool
bool :: forall r. NixSerializer r SError Bool
bool = Serializer
{ getS :: SerialT r SError Get Bool
getS = Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Word64) SerialT r SError Get Word64
-> (Word64 -> SerialT r SError Get Bool)
-> SerialT r SError Get Bool
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Word64
0 -> Bool -> SerialT r SError Get Bool
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
Word64
1 -> Bool -> SerialT r SError Get Bool
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
Word64
x -> SError -> SerialT r SError Get Bool
forall a. SError -> SerialT r SError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> SerialT r SError Get Bool)
-> SError -> SerialT r SError Get Bool
forall a b. (a -> b) -> a -> b
$ Word64 -> SError
SError_IllegalBool Word64
x
, putS :: Bool -> SerialT r SError PutM ()
putS = \case
Bool
False -> Serializer (SerialT r SError) Word8
-> Word8 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (forall a r e. Integral a => NixSerializer r e a
int @Word8) Word8
0
Bool
True -> Serializer (SerialT r SError) Word8
-> Word8 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (forall a r e. Integral a => NixSerializer r e a
int @Word8) Word8
1
}
byteString :: NixSerializer r SError ByteString
byteString :: forall r. NixSerializer r SError ByteString
byteString = Serializer
{ getS :: SerialT r SError Get ByteString
getS = do
Int
len <- Serializer (SerialT r SError) Int -> SerialT r SError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int
ByteString
st <- Get ByteString -> SerialT r SError Get ByteString
forall (m :: * -> *) a. Monad m => m a -> SerialT r SError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Get ByteString -> SerialT r SError Get ByteString)
-> Get ByteString -> SerialT r SError Get ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Get ByteString
Data.Serialize.Get.getByteString Int
len
Bool -> SerialT r SError Get () -> SerialT r SError Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.when (Int
len Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
8 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0) (SerialT r SError Get () -> SerialT r SError Get ())
-> SerialT r SError Get () -> SerialT r SError Get ()
forall a b. (a -> b) -> a -> b
$ do
[Word8]
pads <- Int -> SerialT r SError Get [Word8]
forall {t :: (* -> *) -> * -> *}.
(Applicative (t Get), MonadTrans t) =>
Int -> t Get [Word8]
unpad (Int -> SerialT r SError Get [Word8])
-> Int -> SerialT r SError Get [Word8]
forall a b. (a -> b) -> a -> b
$ Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
8 Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
len Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
8)
Bool -> SerialT r SError Get () -> SerialT r SError Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.unless
((Word8 -> Bool) -> [Word8] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0) [Word8]
pads)
(SerialT r SError Get () -> SerialT r SError Get ())
-> SerialT r SError Get () -> SerialT r SError Get ()
forall a b. (a -> b) -> a -> b
$ SError -> SerialT r SError Get ()
forall a. SError -> SerialT r SError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
(SError -> SerialT r SError Get ())
-> SError -> SerialT r SError Get ()
forall a b. (a -> b) -> a -> b
$ ByteString -> Int -> [Word8] -> SError
SError_BadPadding ByteString
st Int
len [Word8]
pads
ByteString -> SerialT r SError Get ByteString
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ByteString
st
, putS :: ByteString -> SerialT r SError PutM ()
putS = \ByteString
x -> do
let len :: Int
len = ByteString -> Int
Data.ByteString.length ByteString
x
Serializer (SerialT r SError) Int
-> Int -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int Int
len
PutM () -> SerialT r SError PutM ()
forall (m :: * -> *) a. Monad m => m a -> SerialT r SError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (PutM () -> SerialT r SError PutM ())
-> PutM () -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Putter ByteString
Data.Serialize.Put.putByteString ByteString
x
Bool -> SerialT r SError PutM () -> SerialT r SError PutM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.when
(Int
len Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
8 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0)
(SerialT r SError PutM () -> SerialT r SError PutM ())
-> SerialT r SError PutM () -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Int -> SerialT r SError PutM ()
forall {t :: (* -> *) -> * -> *}.
(Applicative (t PutM), MonadTrans t) =>
Int -> t PutM ()
pad (Int -> SerialT r SError PutM ())
-> Int -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Int
8 Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
len Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
8)
}
where
unpad :: Int -> t Get [Word8]
unpad Int
count =
Int -> t Get Word8 -> t Get [Word8]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
Control.Monad.replicateM
Int
count
(Get Word8 -> t Get Word8
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get Word8
Data.Serialize.Get.getWord8)
pad :: Int -> t PutM ()
pad Int
count =
Int -> t PutM () -> t PutM ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
Control.Monad.replicateM_
Int
count
(PutM () -> t PutM ()
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (PutM () -> t PutM ()) -> PutM () -> t PutM ()
forall a b. (a -> b) -> a -> b
$ Putter Word8
Data.Serialize.Put.putWord8 Word8
0)
toEnumCheckBoundsM
:: forall a m
. ( Bounded a
, Enum a
, MonadError SError m
)
=> Int
-> m a
toEnumCheckBoundsM :: forall a (m :: * -> *).
(Bounded a, Enum a, MonadError SError m) =>
Int -> m a
toEnumCheckBoundsM = \case
Int
x | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< a -> Int
forall a. Enum a => a -> Int
fromEnum (forall a. Bounded a => a
minBound @a) -> SError -> m a
forall a. SError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> m a) -> SError -> m a
forall a b. (a -> b) -> a -> b
$ Int -> SError
SError_EnumOutOfMinBound Int
x
Int
x | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> a -> Int
forall a. Enum a => a -> Int
fromEnum (forall a. Bounded a => a
maxBound @a) -> SError -> m a
forall a. SError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> m a) -> SError -> m a
forall a b. (a -> b) -> a -> b
$ Int -> SError
SError_EnumOutOfMaxBound Int
x
Int
x | Bool
otherwise -> a -> m a
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> m a) -> a -> m a
forall a b. (a -> b) -> a -> b
$ Int -> a
forall a. Enum a => Int -> a
toEnum Int
x
enum
:: ( Bounded a
, Enum a
)
=> NixSerializer r SError a
enum :: forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum = Serializer
{ getS :: SerialT r SError Get a
getS = Serializer (SerialT r SError) Int -> SerialT r SError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int SerialT r SError Get Int
-> (Int -> SerialT r SError Get a) -> SerialT r SError Get a
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> SerialT r SError Get a
forall a (m :: * -> *).
(Bounded a, Enum a, MonadError SError m) =>
Int -> m a
toEnumCheckBoundsM
, putS :: a -> SerialT r SError PutM ()
putS = Serializer (SerialT r SError) Int
-> Int -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int (Int -> SerialT r SError PutM ())
-> (a -> Int) -> a -> SerialT r SError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum
}
text :: NixSerializer r SError Text
text :: forall r. NixSerializer r SError Text
text = (ByteString -> Text)
-> (Text -> ByteString)
-> Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) Text
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
ByteString -> Text
Data.Text.Encoding.decodeUtf8
Text -> ByteString
Data.Text.Encoding.encodeUtf8
Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString
_textBuilder :: NixSerializer r SError Builder
_textBuilder :: forall r. NixSerializer r SError Builder
_textBuilder = Serializer
{ getS :: SerialT r SError Get Builder
getS = Text -> Builder
Data.Text.Lazy.Builder.fromText (Text -> Builder)
-> SerialT r SError Get Text -> SerialT r SError Get Builder
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
, putS :: Builder -> SerialT r SError PutM ()
putS = Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text (Text -> SerialT r SError PutM ())
-> (Builder -> Text) -> Builder -> SerialT r SError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Data.Text.Lazy.toStrict (Text -> Text) -> (Builder -> Text) -> Builder -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Text
Data.Text.Lazy.Builder.toLazyText
}
maybeText :: NixSerializer r SError (Maybe Text)
maybeText :: forall r. NixSerializer r SError (Maybe Text)
maybeText = (Text -> Maybe Text)
-> (Maybe Text -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) (Maybe Text)
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
(\case
Text
t | Text -> Bool
Data.Text.null Text
t -> Maybe Text
forall a. Maybe a
Nothing
Text
t | Bool
otherwise -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
t
)
(Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Text
forall a. Monoid a => a
mempty)
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
time :: NixSerializer r e UTCTime
time :: forall r e. NixSerializer r e UTCTime
time = Serializer
{ getS :: SerialT r e Get UTCTime
getS =
NominalDiffTime -> UTCTime
Data.Time.Clock.POSIX.posixSecondsToUTCTime
(NominalDiffTime -> UTCTime)
-> (Int -> NominalDiffTime) -> Int -> UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> NominalDiffTime
toPicoSeconds
(Int -> UTCTime) -> SerialT r e Get Int -> SerialT r e Get UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r e) Int -> SerialT r e Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r e) Int
forall a r e. Integral a => NixSerializer r e a
int
, putS :: UTCTime -> SerialT r e PutM ()
putS =
Serializer (SerialT r e) Int -> Int -> SerialT r e PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r e) Int
forall a r e. Integral a => NixSerializer r e a
int
(Int -> SerialT r e PutM ())
-> (UTCTime -> Int) -> UTCTime -> SerialT r e PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NominalDiffTime -> Int
fromPicoSeconds
(NominalDiffTime -> Int)
-> (UTCTime -> NominalDiffTime) -> UTCTime -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> NominalDiffTime
Data.Time.Clock.POSIX.utcTimeToPOSIXSeconds
}
where
toPicoSeconds :: Int -> NominalDiffTime
toPicoSeconds :: Int -> NominalDiffTime
toPicoSeconds Int
n = Uni -> NominalDiffTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac (Int -> Uni
forall a. Enum a => Int -> a
toEnum Int
n :: Uni)
fromPicoSeconds :: NominalDiffTime -> Int
fromPicoSeconds :: NominalDiffTime -> Int
fromPicoSeconds = (Uni -> Int
forall a. Enum a => a -> Int
fromEnum :: Uni -> Int) (Uni -> Int) -> (NominalDiffTime -> Uni) -> NominalDiffTime -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NominalDiffTime -> Uni
forall a b. (Real a, Fractional b) => a -> b
realToFrac
list
:: NixSerializer r e a
-> NixSerializer r e [a]
list :: forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r e a
s = Serializer
{ getS :: SerialT r e Get [a]
getS = do
Int
count <- Serializer (SerialT r e) Int -> SerialT r e Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r e) Int
forall a r e. Integral a => NixSerializer r e a
int
Int -> SerialT r e Get a -> SerialT r e Get [a]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
Control.Monad.replicateM Int
count (NixSerializer r e a -> SerialT r e Get a
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS NixSerializer r e a
s)
, putS :: [a] -> SerialT r e PutM ()
putS = \[a]
xs -> do
Serializer (SerialT r e) Int -> Int -> SerialT r e PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r e) Int
forall a r e. Integral a => NixSerializer r e a
int ([a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs)
(a -> SerialT r e PutM ()) -> [a] -> SerialT r e PutM ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (NixSerializer r e a -> a -> SerialT r e PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS NixSerializer r e a
s) [a]
xs
}
set
:: Ord a
=> NixSerializer r e a
-> NixSerializer r e (Set a)
set :: forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set =
([a] -> Set a)
-> (Set a -> [a])
-> Serializer (SerialT r e) [a]
-> Serializer (SerialT r e) (Set a)
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
[a] -> Set a
forall a. Ord a => [a] -> Set a
Data.Set.fromList
Set a -> [a]
forall a. Set a -> [a]
Data.Set.toList
(Serializer (SerialT r e) [a] -> Serializer (SerialT r e) (Set a))
-> (NixSerializer r e a -> Serializer (SerialT r e) [a])
-> NixSerializer r e a
-> Serializer (SerialT r e) (Set a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a -> Serializer (SerialT r e) [a]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list
hashSet
:: ( Eq a
, Hashable a
)
=> NixSerializer r e a
-> NixSerializer r e (HashSet a)
hashSet :: forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet =
([a] -> HashSet a)
-> (HashSet a -> [a])
-> Serializer (SerialT r e) [a]
-> Serializer (SerialT r e) (HashSet a)
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
[a] -> HashSet a
forall a. (Eq a, Hashable a) => [a] -> HashSet a
Data.HashSet.fromList
HashSet a -> [a]
forall a. HashSet a -> [a]
Data.HashSet.toList
(Serializer (SerialT r e) [a]
-> Serializer (SerialT r e) (HashSet a))
-> (NixSerializer r e a -> Serializer (SerialT r e) [a])
-> NixSerializer r e a
-> Serializer (SerialT r e) (HashSet a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a -> Serializer (SerialT r e) [a]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list
mapS
:: Ord k
=> NixSerializer r e k
-> NixSerializer r e v
-> NixSerializer r e (Map k v)
mapS :: forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r e k
k NixSerializer r e v
v =
([(k, v)] -> Map k v)
-> (Map k v -> [(k, v)])
-> Serializer (SerialT r e) [(k, v)]
-> Serializer (SerialT r e) (Map k v)
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
[(k, v)] -> Map k v
forall k a. Ord k => [(k, a)] -> Map k a
Data.Map.Strict.fromList
Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Data.Map.Strict.toList
(Serializer (SerialT r e) [(k, v)]
-> Serializer (SerialT r e) (Map k v))
-> Serializer (SerialT r e) [(k, v)]
-> Serializer (SerialT r e) (Map k v)
forall a b. (a -> b) -> a -> b
$ NixSerializer r e (k, v) -> Serializer (SerialT r e) [(k, v)]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list
(NixSerializer r e (k, v) -> Serializer (SerialT r e) [(k, v)])
-> NixSerializer r e (k, v) -> Serializer (SerialT r e) [(k, v)]
forall a b. (a -> b) -> a -> b
$ NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (k, v)
forall (t :: (* -> *) -> * -> *) a b.
(Applicative (t Get), Monad (t PutM)) =>
Serializer t a -> Serializer t b -> Serializer t (a, b)
tup NixSerializer r e k
k NixSerializer r e v
v
vector
:: Ord a
=> NixSerializer r e a
-> NixSerializer r e (Vector a)
vector :: forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Vector a)
vector =
([a] -> Vector a)
-> (Vector a -> [a])
-> Serializer (SerialT r e) [a]
-> Serializer (SerialT r e) (Vector a)
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
[a] -> Vector a
forall a. [a] -> Vector a
Data.Vector.fromList
Vector a -> [a]
forall a. Vector a -> [a]
Data.Vector.toList
(Serializer (SerialT r e) [a]
-> Serializer (SerialT r e) (Vector a))
-> (NixSerializer r e a -> Serializer (SerialT r e) [a])
-> NixSerializer r e a
-> Serializer (SerialT r e) (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixSerializer r e a -> Serializer (SerialT r e) [a]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list
json
:: ( FromJSON a
, ToJSON a
)
=> NixSerializer r SError a
json :: forall a r. (FromJSON a, ToJSON a) => NixSerializer r SError a
json =
(ByteString -> Either SError a)
-> (a -> ByteString)
-> Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) a
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
( (String -> SError) -> Either String a -> Either SError a
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
Data.Bifunctor.first String -> SError
SError_JSONDecoding
(Either String a -> Either SError a)
-> (ByteString -> Either String a) -> ByteString -> Either SError a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either String a
forall a. FromJSON a => ByteString -> Either String a
Data.Aeson.eitherDecode
)
a -> ByteString
forall a. ToJSON a => a -> ByteString
Data.Aeson.encode
(Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) a)
-> Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) a
forall a b. (a -> b) -> a -> b
$ (ByteString -> ByteString)
-> (ByteString -> ByteString)
-> Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) ByteString
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
ByteString -> ByteString
Data.ByteString.Lazy.fromStrict
ByteString -> ByteString
Data.ByteString.Lazy.toStrict
Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString
protoVersion :: NixSerializer r e ProtoVersion
protoVersion :: forall r e. NixSerializer r e ProtoVersion
protoVersion = Serializer
{ getS :: SerialT r e Get ProtoVersion
getS = do
Word32
v <- Serializer (SerialT r e) Word32 -> SerialT r e Get Word32
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Word32)
ProtoVersion -> SerialT r e Get ProtoVersion
forall a. a -> SerialT r e Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ProtoVersion
{ protoVersion_major :: Word16
protoVersion_major = Word32 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word16) -> Word32 -> Word16
forall a b. (a -> b) -> a -> b
$ Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
Data.Bits.shiftR Word32
v Int
8
, protoVersion_minor :: Word8
protoVersion_minor = Word32 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word8) -> Word32 -> Word8
forall a b. (a -> b) -> a -> b
$ Word32
v Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
Data.Bits..&. Word32
0x00FF
}
, putS :: ProtoVersion -> SerialT r e PutM ()
putS = \ProtoVersion
p ->
Serializer (SerialT r e) Word32 -> Word32 -> SerialT r e PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (forall a r e. Integral a => NixSerializer r e a
int @Word32)
(Word32 -> SerialT r e PutM ()) -> Word32 -> SerialT r e PutM ()
forall a b. (a -> b) -> a -> b
$ ((Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
Data.Bits.shiftL (Word16 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word32) -> Word16 -> Word32
forall a b. (a -> b) -> a -> b
$ ProtoVersion -> Word16
protoVersion_major ProtoVersion
p :: Word32) Int
8)
Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
Data.Bits..|. Word8 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ProtoVersion -> Word8
protoVersion_minor ProtoVersion
p))
}
storePath :: HasStoreDir r => NixSerializer r SError StorePath
storePath :: forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath = Serializer
{ getS :: SerialT r SError Get StorePath
getS = do
StoreDir
sd <- (r -> StoreDir) -> SerialT r SError Get StoreDir
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> StoreDir
forall r. HasStoreDir r => r -> StoreDir
hasStoreDir
StoreDir -> ByteString -> Either InvalidPathError StorePath
System.Nix.StorePath.parsePath StoreDir
sd (ByteString -> Either InvalidPathError StorePath)
-> SerialT r SError Get ByteString
-> SerialT r SError Get (Either InvalidPathError StorePath)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) ByteString
-> SerialT r SError Get ByteString
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString
SerialT r SError Get (Either InvalidPathError StorePath)
-> (Either InvalidPathError StorePath
-> SerialT r SError Get StorePath)
-> SerialT r SError Get StorePath
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
(InvalidPathError -> SerialT r SError Get StorePath)
-> (StorePath -> SerialT r SError Get StorePath)
-> Either InvalidPathError StorePath
-> SerialT r SError Get StorePath
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
(SError -> SerialT r SError Get StorePath
forall a. SError -> SerialT r SError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> SerialT r SError Get StorePath)
-> (InvalidPathError -> SError)
-> InvalidPathError
-> SerialT r SError Get StorePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InvalidPathError -> SError
SError_Path)
StorePath -> SerialT r SError Get StorePath
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
, putS :: StorePath -> SerialT r SError PutM ()
putS = \StorePath
p -> do
StoreDir
sd <- (r -> StoreDir) -> SerialT r SError PutM StoreDir
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> StoreDir
forall r. HasStoreDir r => r -> StoreDir
hasStoreDir
Serializer (SerialT r SError) ByteString
-> ByteString -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS
Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString
(ByteString -> SerialT r SError PutM ())
-> ByteString -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ StoreDir -> StorePath -> ByteString
System.Nix.StorePath.storePathToRawFilePath StoreDir
sd StorePath
p
}
maybePath
:: HasStoreDir r
=> NixSerializer r SError (Maybe StorePath)
maybePath :: forall r. HasStoreDir r => NixSerializer r SError (Maybe StorePath)
maybePath = Serializer
{ getS :: SerialT r SError Get (Maybe StorePath)
getS = do
Serializer (SerialT r SError) (Maybe Text)
-> SerialT r SError Get (Maybe Text)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Maybe Text)
forall r. NixSerializer r SError (Maybe Text)
maybeText SerialT r SError Get (Maybe Text)
-> (Maybe Text -> SerialT r SError Get (Maybe StorePath))
-> SerialT r SError Get (Maybe StorePath)
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Maybe Text
Nothing -> Maybe StorePath -> SerialT r SError Get (Maybe StorePath)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe StorePath
forall a. Maybe a
Nothing
Just Text
t -> do
StoreDir
sd <- (r -> StoreDir) -> SerialT r SError Get StoreDir
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> StoreDir
forall r. HasStoreDir r => r -> StoreDir
hasStoreDir
(InvalidPathError -> SerialT r SError Get (Maybe StorePath))
-> (StorePath -> SerialT r SError Get (Maybe StorePath))
-> Either InvalidPathError StorePath
-> SerialT r SError Get (Maybe StorePath)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
(SError -> SerialT r SError Get (Maybe StorePath)
forall a. SError -> SerialT r SError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> SerialT r SError Get (Maybe StorePath))
-> (InvalidPathError -> SError)
-> InvalidPathError
-> SerialT r SError Get (Maybe StorePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InvalidPathError -> SError
SError_Path)
(Maybe StorePath -> SerialT r SError Get (Maybe StorePath)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe StorePath -> SerialT r SError Get (Maybe StorePath))
-> (StorePath -> Maybe StorePath)
-> StorePath
-> SerialT r SError Get (Maybe StorePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> Maybe StorePath
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure)
(Either InvalidPathError StorePath
-> SerialT r SError Get (Maybe StorePath))
-> Either InvalidPathError StorePath
-> SerialT r SError Get (Maybe StorePath)
forall a b. (a -> b) -> a -> b
$ StoreDir -> Text -> Either InvalidPathError StorePath
System.Nix.StorePath.parsePathFromText StoreDir
sd Text
t
, putS :: Maybe StorePath -> SerialT r SError PutM ()
putS = \case
Maybe StorePath
Nothing -> Serializer (SerialT r SError) (Maybe Text)
-> Maybe Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Maybe Text)
forall r. NixSerializer r SError (Maybe Text)
maybeText Maybe Text
forall a. Maybe a
Nothing
Just StorePath
p -> do
StoreDir
sd <- (r -> StoreDir) -> SerialT r SError PutM StoreDir
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> StoreDir
forall r. HasStoreDir r => r -> StoreDir
hasStoreDir
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text (Text -> SerialT r SError PutM ())
-> Text -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ StoreDir -> StorePath -> Text
System.Nix.StorePath.storePathToText StoreDir
sd StorePath
p
}
storePathHashPart :: NixSerializer r SError StorePathHashPart
storePathHashPart :: forall r. NixSerializer r SError StorePathHashPart
storePathHashPart =
(ByteString -> StorePathHashPart)
-> (StorePathHashPart -> ByteString)
-> Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) StorePathHashPart
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
ByteString -> StorePathHashPart
System.Nix.StorePath.unsafeMakeStorePathHashPart
StorePathHashPart -> ByteString
System.Nix.StorePath.unStorePathHashPart
(Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) StorePathHashPart)
-> Serializer (SerialT r SError) ByteString
-> Serializer (SerialT r SError) StorePathHashPart
forall a b. (a -> b) -> a -> b
$ (Text -> Either SError ByteString)
-> (ByteString -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) ByteString
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((String -> SError)
-> Either String ByteString -> Either SError ByteString
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
Data.Bifunctor.first (SError -> String -> SError
forall a. a -> String -> a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SError
SError_InvalidNixBase32)
(Either String ByteString -> Either SError ByteString)
-> (Text -> Either String ByteString)
-> Text
-> Either SError ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BaseEncoding -> Text -> Either String ByteString
System.Nix.Base.decodeWith BaseEncoding
NixBase32)
(BaseEncoding -> ByteString -> Text
System.Nix.Base.encodeWith BaseEncoding
NixBase32)
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
storePathName :: NixSerializer r SError StorePathName
storePathName :: forall r. NixSerializer r SError StorePathName
storePathName =
(Text -> Either SError StorePathName)
-> (StorePathName -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) StorePathName
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((InvalidNameError -> SError)
-> Either InvalidNameError StorePathName
-> Either SError StorePathName
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
Data.Bifunctor.first InvalidNameError -> SError
SError_Name
(Either InvalidNameError StorePathName
-> Either SError StorePathName)
-> (Text -> Either InvalidNameError StorePathName)
-> Text
-> Either SError StorePathName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either InvalidNameError StorePathName
System.Nix.StorePath.mkStorePathName)
StorePathName -> Text
System.Nix.StorePath.unStorePathName
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
pathMetadata
:: HasStoreDir r
=> NixSerializer r SError (Metadata StorePath)
pathMetadata :: forall r.
HasStoreDir r =>
NixSerializer r SError (Metadata StorePath)
pathMetadata = Serializer
{ getS :: SerialT r SError Get (Metadata StorePath)
getS = do
Maybe StorePath
metadataDeriverPath <- Serializer (SerialT r SError) (Maybe StorePath)
-> SerialT r SError Get (Maybe StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Maybe StorePath)
forall r. HasStoreDir r => NixSerializer r SError (Maybe StorePath)
maybePath
Digest SHA256
digest' <- Serializer (SerialT r SError) (Digest SHA256)
-> SerialT r SError Get (Digest SHA256)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) (Digest SHA256)
-> SerialT r SError Get (Digest SHA256))
-> Serializer (SerialT r SError) (Digest SHA256)
-> SerialT r SError Get (Digest SHA256)
forall a b. (a -> b) -> a -> b
$ BaseEncoding -> Serializer (SerialT r SError) (Digest SHA256)
forall a r.
HashAlgorithm a =>
BaseEncoding -> NixSerializer r SError (Digest a)
digest BaseEncoding
Base16
let metadataNarHash :: DSum HashAlgo Digest
metadataNarHash = HashAlgo SHA256
System.Nix.Hash.HashAlgo_SHA256 HashAlgo SHA256 -> Digest SHA256 -> DSum HashAlgo Digest
forall {k} (tag :: k -> *) (f :: k -> *) (a :: k).
tag a -> f a -> DSum tag f
:=> Digest SHA256
digest'
HashSet StorePath
metadataReferences <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath))
-> Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall a b. (a -> b) -> a -> b
$ NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
UTCTime
metadataRegistrationTime <- Serializer (SerialT r SError) UTCTime
-> SerialT r SError Get UTCTime
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) UTCTime
forall r e. NixSerializer r e UTCTime
time
Maybe Word64
metadataNarBytes <-
(\case
Word64
0 -> Maybe Word64
forall a. Maybe a
Nothing
Word64
size -> Word64 -> Maybe Word64
forall a. a -> Maybe a
Just Word64
size
) (Word64 -> Maybe Word64)
-> SerialT r SError Get Word64
-> SerialT r SError Get (Maybe Word64)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int
StorePathTrust
metadataTrust <- Serializer (SerialT r SError) StorePathTrust
-> SerialT r SError Get StorePathTrust
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePathTrust
forall r. NixSerializer r SError StorePathTrust
storePathTrust
Set NarSignature
metadataSigs <- Serializer (SerialT r SError) (Set NarSignature)
-> SerialT r SError Get (Set NarSignature)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) (Set NarSignature)
-> SerialT r SError Get (Set NarSignature))
-> Serializer (SerialT r SError) (Set NarSignature)
-> SerialT r SError Get (Set NarSignature)
forall a b. (a -> b) -> a -> b
$ NixSerializer r SError NarSignature
-> Serializer (SerialT r SError) (Set NarSignature)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError NarSignature
forall r. NixSerializer r SError NarSignature
narSignature
Maybe ContentAddress
metadataContentAddress <- Serializer (SerialT r SError) (Maybe ContentAddress)
-> SerialT r SError Get (Maybe ContentAddress)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Maybe ContentAddress)
forall r. NixSerializer r SError (Maybe ContentAddress)
maybeContentAddress
Metadata StorePath -> SerialT r SError Get (Metadata StorePath)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Metadata StorePath -> SerialT r SError Get (Metadata StorePath))
-> Metadata StorePath -> SerialT r SError Get (Metadata StorePath)
forall a b. (a -> b) -> a -> b
$ Metadata{Maybe Word64
Maybe ContentAddress
Maybe StorePath
UTCTime
Set NarSignature
DSum HashAlgo Digest
StorePathTrust
HashSet StorePath
metadataDeriverPath :: Maybe StorePath
metadataNarHash :: DSum HashAlgo Digest
metadataReferences :: HashSet StorePath
metadataRegistrationTime :: UTCTime
metadataNarBytes :: Maybe Word64
metadataTrust :: StorePathTrust
metadataSigs :: Set NarSignature
metadataContentAddress :: Maybe ContentAddress
metadataDeriverPath :: Maybe StorePath
metadataNarHash :: DSum HashAlgo Digest
metadataReferences :: HashSet StorePath
metadataRegistrationTime :: UTCTime
metadataNarBytes :: Maybe Word64
metadataTrust :: StorePathTrust
metadataSigs :: Set NarSignature
metadataContentAddress :: Maybe ContentAddress
..}
, putS :: Metadata StorePath -> SerialT r SError PutM ()
putS = \Metadata{Maybe Word64
Maybe ContentAddress
Maybe StorePath
UTCTime
Set NarSignature
DSum HashAlgo Digest
StorePathTrust
HashSet StorePath
metadataDeriverPath :: forall a. Metadata a -> Maybe a
metadataNarHash :: forall a. Metadata a -> DSum HashAlgo Digest
metadataReferences :: forall a. Metadata a -> HashSet a
metadataRegistrationTime :: forall a. Metadata a -> UTCTime
metadataNarBytes :: forall a. Metadata a -> Maybe Word64
metadataTrust :: forall a. Metadata a -> StorePathTrust
metadataSigs :: forall a. Metadata a -> Set NarSignature
metadataContentAddress :: forall a. Metadata a -> Maybe ContentAddress
metadataDeriverPath :: Maybe StorePath
metadataNarHash :: DSum HashAlgo Digest
metadataReferences :: HashSet StorePath
metadataRegistrationTime :: UTCTime
metadataNarBytes :: Maybe Word64
metadataTrust :: StorePathTrust
metadataSigs :: Set NarSignature
metadataContentAddress :: Maybe ContentAddress
..} -> do
Serializer (SerialT r SError) (Maybe StorePath)
-> Maybe StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Maybe StorePath)
forall r. HasStoreDir r => NixSerializer r SError (Maybe StorePath)
maybePath Maybe StorePath
metadataDeriverPath
let putNarHash
:: DSum HashAlgo Digest
-> SerialT r SError PutM ()
putNarHash :: forall r. DSum HashAlgo Digest -> SerialT r SError PutM ()
putNarHash = \case
HashAlgo a
System.Nix.Hash.HashAlgo_SHA256 :=> Digest a
d
-> Serializer (SerialT r SError) (Digest SHA256)
-> Digest SHA256 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (forall a r.
HashAlgorithm a =>
BaseEncoding -> NixSerializer r SError (Digest a)
digest @SHA256 BaseEncoding
Base16) Digest a
Digest SHA256
d
DSum HashAlgo Digest
_ -> SError -> SerialT r SError PutM ()
forall a. SError -> SerialT r SError PutM a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError SError
SError_NarHashMustBeSHA256
DSum HashAlgo Digest -> SerialT r SError PutM ()
forall r. DSum HashAlgo Digest -> SerialT r SError PutM ()
putNarHash DSum HashAlgo Digest
metadataNarHash
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
metadataReferences
Serializer (SerialT r SError) UTCTime
-> UTCTime -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) UTCTime
forall r e. NixSerializer r e UTCTime
time UTCTime
metadataRegistrationTime
Serializer (SerialT r SError) Word64
-> Word64 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int (Word64 -> SerialT r SError PutM ())
-> Word64 -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Word64 -> Maybe Word64 -> Word64
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Word64
0 Maybe Word64
metadataNarBytes
Serializer (SerialT r SError) StorePathTrust
-> StorePathTrust -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePathTrust
forall r. NixSerializer r SError StorePathTrust
storePathTrust StorePathTrust
metadataTrust
Serializer (SerialT r SError) (Set NarSignature)
-> Set NarSignature -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError NarSignature
-> Serializer (SerialT r SError) (Set NarSignature)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError NarSignature
forall r. NixSerializer r SError NarSignature
narSignature) Set NarSignature
metadataSigs
Serializer (SerialT r SError) (Maybe ContentAddress)
-> Maybe ContentAddress -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Maybe ContentAddress)
forall r. NixSerializer r SError (Maybe ContentAddress)
maybeContentAddress Maybe ContentAddress
metadataContentAddress
}
where
maybeContentAddress
:: NixSerializer r SError (Maybe ContentAddress)
maybeContentAddress :: forall r. NixSerializer r SError (Maybe ContentAddress)
maybeContentAddress =
(Maybe Text -> Either SError (Maybe ContentAddress))
-> (Maybe ContentAddress -> Maybe Text)
-> Serializer (SerialT r SError) (Maybe Text)
-> Serializer (SerialT r SError) (Maybe ContentAddress)
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
(Either SError (Maybe ContentAddress)
-> (Text -> Either SError (Maybe ContentAddress))
-> Maybe Text
-> Either SError (Maybe ContentAddress)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(Maybe ContentAddress -> Either SError (Maybe ContentAddress)
forall a. a -> Either SError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ContentAddress
forall a. Maybe a
Nothing)
((Text -> Either SError (Maybe ContentAddress))
-> Maybe Text -> Either SError (Maybe ContentAddress))
-> (Text -> Either SError (Maybe ContentAddress))
-> Maybe Text
-> Either SError (Maybe ContentAddress)
forall a b. (a -> b) -> a -> b
$ (String -> SError)
-> (ContentAddress -> Maybe ContentAddress)
-> Either String ContentAddress
-> Either SError (Maybe ContentAddress)
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
Data.Bifunctor.bimap
String -> SError
SError_ContentAddress
ContentAddress -> Maybe ContentAddress
forall a. a -> Maybe a
Just
(Either String ContentAddress
-> Either SError (Maybe ContentAddress))
-> (Text -> Either String ContentAddress)
-> Text
-> Either SError (Maybe ContentAddress)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either String ContentAddress
System.Nix.ContentAddress.parseContentAddress
)
((ContentAddress -> Text) -> Maybe ContentAddress -> Maybe Text
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ContentAddress -> Text
System.Nix.ContentAddress.buildContentAddress)
Serializer (SerialT r SError) (Maybe Text)
forall r. NixSerializer r SError (Maybe Text)
maybeText
storePathTrust
:: NixSerializer r SError StorePathTrust
storePathTrust :: forall r. NixSerializer r SError StorePathTrust
storePathTrust =
(Bool -> StorePathTrust)
-> (StorePathTrust -> Bool)
-> Serializer (SerialT r SError) Bool
-> Serializer (SerialT r SError) StorePathTrust
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
(\case Bool
False -> StorePathTrust
BuiltElsewhere; Bool
True -> StorePathTrust
BuiltLocally)
(\case StorePathTrust
BuiltElsewhere -> Bool
False; StorePathTrust
BuiltLocally -> Bool
True)
Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
outputName :: NixSerializer r SError OutputName
outputName :: forall r. NixSerializer r SError OutputName
outputName =
(Text -> Either SError OutputName)
-> (OutputName -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) OutputName
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((InvalidNameError -> SError)
-> Either InvalidNameError OutputName -> Either SError OutputName
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
Data.Bifunctor.first InvalidNameError -> SError
SError_Name
(Either InvalidNameError OutputName -> Either SError OutputName)
-> (Text -> Either InvalidNameError OutputName)
-> Text
-> Either SError OutputName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either InvalidNameError OutputName
System.Nix.OutputName.mkOutputName)
OutputName -> Text
System.Nix.OutputName.unOutputName
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
signature
:: NixSerializer r SError Signature
signature :: forall r. NixSerializer r SError Signature
signature =
(Text -> Either SError Signature)
-> (Signature -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) Signature
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((String -> SError)
-> Either String Signature -> Either SError Signature
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
Data.Bifunctor.first String -> SError
SError_Signature
(Either String Signature -> Either SError Signature)
-> (Text -> Either String Signature)
-> Text
-> Either SError Signature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser Signature -> Text -> Either String Signature
forall a. Parser a -> Text -> Either String a
Data.Attoparsec.Text.parseOnly
Parser Signature
System.Nix.Signature.signatureParser)
(Signature -> Text
System.Nix.Signature.signatureToText)
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
narSignature
:: NixSerializer r SError NarSignature
narSignature :: forall r. NixSerializer r SError NarSignature
narSignature =
(Text -> Either SError NarSignature)
-> (NarSignature -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) NarSignature
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((String -> SError)
-> Either String NarSignature -> Either SError NarSignature
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
Data.Bifunctor.first String -> SError
SError_Signature
(Either String NarSignature -> Either SError NarSignature)
-> (Text -> Either String NarSignature)
-> Text
-> Either SError NarSignature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser NarSignature -> Text -> Either String NarSignature
forall a. Parser a -> Text -> Either String a
Data.Attoparsec.Text.parseOnly
Parser NarSignature
System.Nix.Signature.narSignatureParser)
(NarSignature -> Text
System.Nix.Signature.narSignatureToText)
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
someHashAlgo :: NixSerializer r SError (Some HashAlgo)
someHashAlgo :: forall r. NixSerializer r SError (Some HashAlgo)
someHashAlgo =
(Text -> Either SError (Some HashAlgo))
-> (Some HashAlgo -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) (Some HashAlgo)
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((String -> SError)
-> Either String (Some HashAlgo) -> Either SError (Some HashAlgo)
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
Data.Bifunctor.first String -> SError
SError_HashAlgo
(Either String (Some HashAlgo) -> Either SError (Some HashAlgo))
-> (Text -> Either String (Some HashAlgo))
-> Text
-> Either SError (Some HashAlgo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either String (Some HashAlgo)
System.Nix.Hash.textToAlgo)
((forall a. HashAlgo a -> Text) -> Some HashAlgo -> Text
forall {k} (tag :: k -> *) b.
(forall (a :: k). tag a -> b) -> Some tag -> b
Data.Some.foldSome HashAlgo a -> Text
forall a. HashAlgo a -> Text
System.Nix.Hash.algoToText)
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
digest
:: forall a r
. HashAlgorithm a
=> BaseEncoding
-> NixSerializer r SError (Digest a)
digest :: forall a r.
HashAlgorithm a =>
BaseEncoding -> NixSerializer r SError (Digest a)
digest BaseEncoding
base =
(Digest a -> Digest a)
-> (Digest a -> Digest a)
-> Serializer (SerialT r SError) (Digest a)
-> Serializer (SerialT r SError) (Digest a)
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer
Digest a -> Digest a
forall a b. Coercible a b => a -> b
Data.Coerce.coerce
Digest a -> Digest a
forall a b. Coercible a b => a -> b
Data.Coerce.coerce
(Serializer (SerialT r SError) (Digest a)
-> Serializer (SerialT r SError) (Digest a))
-> Serializer (SerialT r SError) (Digest a)
-> Serializer (SerialT r SError) (Digest a)
forall a b. (a -> b) -> a -> b
$ (Text -> Either SError (Digest a))
-> (Digest a -> Text)
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) (Digest a)
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
((String -> SError)
-> Either String (Digest a) -> Either SError (Digest a)
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
Data.Bifunctor.first String -> SError
SError_Digest
(Either String (Digest a) -> Either SError (Digest a))
-> (Text -> Either String (Digest a))
-> Text
-> Either SError (Digest a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
HashAlgorithm a =>
BaseEncoding -> Text -> Either String (Digest a)
System.Nix.Hash.decodeDigestWith @a BaseEncoding
base)
(BaseEncoding -> Digest a -> Text
forall a. BaseEncoding -> Digest a -> Text
System.Nix.Hash.encodeDigestWith BaseEncoding
base)
(Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) (Digest a))
-> Serializer (SerialT r SError) Text
-> Serializer (SerialT r SError) (Digest a)
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
namedDigest :: NixSerializer r SError (DSum HashAlgo Digest)
namedDigest :: forall r. NixSerializer r SError (DSum HashAlgo Digest)
namedDigest = Serializer
{ getS :: SerialT r SError Get (DSum HashAlgo Digest)
getS = do
Text
sriHash <- Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
let (Text
sriName, Text
_h) = HasCallStack => Text -> Text -> (Text, Text)
Text -> Text -> (Text, Text)
Data.Text.breakOn (Char -> Text
Data.Text.singleton Char
'-') Text
sriHash
case Text -> Text -> Either String (DSum HashAlgo Digest)
System.Nix.Hash.mkNamedDigest Text
sriName Text
sriHash of
Left String
e -> SError -> SerialT r SError Get (DSum HashAlgo Digest)
forall a. SError -> SerialT r SError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> SerialT r SError Get (DSum HashAlgo Digest))
-> SError -> SerialT r SError Get (DSum HashAlgo Digest)
forall a b. (a -> b) -> a -> b
$ String -> SError
SError_Digest String
e
Right DSum HashAlgo Digest
x -> DSum HashAlgo Digest -> SerialT r SError Get (DSum HashAlgo Digest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DSum HashAlgo Digest
x
, putS :: DSum HashAlgo Digest -> SerialT r SError PutM ()
putS = \(HashAlgo a
algo :=> Digest a
d) -> do
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
(Text -> SerialT r SError PutM ())
-> Text -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ HashAlgo a -> Text
forall a. HashAlgo a -> Text
System.Nix.Hash.algoToText HashAlgo a
algo
Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (Char -> Text
Data.Text.singleton Char
'-')
Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> BaseEncoding -> Digest a -> Text
forall a. BaseEncoding -> Digest a -> Text
System.Nix.Hash.encodeDigestWith BaseEncoding
NixBase32 Digest a
d
}
derivationOutput
:: HasStoreDir r
=> NixSerializer r SError (DerivationOutput StorePath Text)
derivationOutput :: forall r.
HasStoreDir r =>
NixSerializer r SError (DerivationOutput StorePath Text)
derivationOutput = Serializer
{ getS :: SerialT r SError Get (DerivationOutput StorePath Text)
getS = do
StorePath
path <- Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
Text
hashAlgo <- Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
Text
hash <- Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
DerivationOutput StorePath Text
-> SerialT r SError Get (DerivationOutput StorePath Text)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DerivationOutput{Text
StorePath
path :: StorePath
hashAlgo :: Text
hash :: Text
path :: StorePath
hashAlgo :: Text
hash :: Text
..}
, putS :: DerivationOutput StorePath Text -> SerialT r SError PutM ()
putS = \DerivationOutput{Text
StorePath
path :: forall fp txt. DerivationOutput fp txt -> fp
hashAlgo :: forall fp txt. DerivationOutput fp txt -> txt
hash :: forall fp txt. DerivationOutput fp txt -> txt
path :: StorePath
hashAlgo :: Text
hash :: Text
..} -> do
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
hashAlgo
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
hash
}
derivation
:: HasStoreDir r
=> NixSerializer r SError (Derivation StorePath Text)
derivation :: forall r.
HasStoreDir r =>
NixSerializer r SError (Derivation StorePath Text)
derivation = Serializer
{ getS :: SerialT r SError Get (Derivation StorePath Text)
getS = do
Map Text (DerivationOutput StorePath Text)
outputs <- Serializer
(SerialT r SError) (Map Text (DerivationOutput StorePath Text))
-> SerialT
r SError Get (Map Text (DerivationOutput StorePath Text))
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError Text
-> NixSerializer r SError (DerivationOutput StorePath Text)
-> Serializer
(SerialT r SError) (Map Text (DerivationOutput StorePath Text))
forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text NixSerializer r SError (DerivationOutput StorePath Text)
forall r.
HasStoreDir r =>
NixSerializer r SError (DerivationOutput StorePath Text)
derivationOutput)
Map StorePath (Set Text)
inputDrvs <- Map StorePath (Set Text)
-> SerialT r SError Get (Map StorePath (Set Text))
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Map StorePath (Set Text)
forall a. Monoid a => a
mempty
Set StorePath
inputSrcs <- Serializer (SerialT r SError) (Set StorePath)
-> SerialT r SError Get (Set StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (Set StorePath)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
Text
platform <- NixSerializer r SError Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text
Text
builder <- NixSerializer r SError Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text
Vector Text
args <- Serializer (SerialT r SError) (Vector Text)
-> SerialT r SError Get (Vector Text)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError Text
-> Serializer (SerialT r SError) (Vector Text)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Vector a)
vector NixSerializer r SError Text
forall r. NixSerializer r SError Text
text)
Map Text Text
env <- Serializer (SerialT r SError) (Map Text Text)
-> SerialT r SError Get (Map Text Text)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError Text
-> NixSerializer r SError Text
-> Serializer (SerialT r SError) (Map Text Text)
forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text NixSerializer r SError Text
forall r. NixSerializer r SError Text
text)
Derivation StorePath Text
-> SerialT r SError Get (Derivation StorePath Text)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Derivation{Map Text Text
Map Text (DerivationOutput StorePath Text)
Map StorePath (Set Text)
Text
Vector Text
Set StorePath
outputs :: Map Text (DerivationOutput StorePath Text)
inputDrvs :: Map StorePath (Set Text)
inputSrcs :: Set StorePath
platform :: Text
builder :: Text
args :: Vector Text
env :: Map Text Text
outputs :: Map Text (DerivationOutput StorePath Text)
inputDrvs :: Map StorePath (Set Text)
inputSrcs :: Set StorePath
platform :: Text
builder :: Text
args :: Vector Text
env :: Map Text Text
..}
, putS :: Derivation StorePath Text -> SerialT r SError PutM ()
putS = \Derivation{Map Text Text
Map Text (DerivationOutput StorePath Text)
Map StorePath (Set Text)
Text
Vector Text
Set StorePath
outputs :: forall fp txt.
Derivation fp txt -> Map txt (DerivationOutput fp txt)
inputDrvs :: forall fp txt. Derivation fp txt -> Map fp (Set txt)
inputSrcs :: forall fp txt. Derivation fp txt -> Set fp
platform :: forall fp txt. Derivation fp txt -> txt
builder :: forall fp txt. Derivation fp txt -> txt
args :: forall fp txt. Derivation fp txt -> Vector txt
env :: forall fp txt. Derivation fp txt -> Map txt txt
outputs :: Map Text (DerivationOutput StorePath Text)
inputDrvs :: Map StorePath (Set Text)
inputSrcs :: Set StorePath
platform :: Text
builder :: Text
args :: Vector Text
env :: Map Text Text
..} -> do
Serializer
(SerialT r SError) (Map Text (DerivationOutput StorePath Text))
-> Map Text (DerivationOutput StorePath Text)
-> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError Text
-> NixSerializer r SError (DerivationOutput StorePath Text)
-> Serializer
(SerialT r SError) (Map Text (DerivationOutput StorePath Text))
forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text NixSerializer r SError (DerivationOutput StorePath Text)
forall r.
HasStoreDir r =>
NixSerializer r SError (DerivationOutput StorePath Text)
derivationOutput) Map Text (DerivationOutput StorePath Text)
outputs
Serializer (SerialT r SError) (Set StorePath)
-> Set StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (Set StorePath)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) Set StorePath
inputSrcs
NixSerializer r SError Text -> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text Text
platform
NixSerializer r SError Text -> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text Text
builder
Serializer (SerialT r SError) (Vector Text)
-> Vector Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError Text
-> Serializer (SerialT r SError) (Vector Text)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Vector a)
vector NixSerializer r SError Text
forall r. NixSerializer r SError Text
text) Vector Text
args
Serializer (SerialT r SError) (Map Text Text)
-> Map Text Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError Text
-> NixSerializer r SError Text
-> Serializer (SerialT r SError) (Map Text Text)
forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r SError Text
forall r. NixSerializer r SError Text
text NixSerializer r SError Text
forall r. NixSerializer r SError Text
text) Map Text Text
env
}
derivedPathNew
:: HasStoreDir r
=> NixSerializer r SError DerivedPath
derivedPathNew :: forall r. HasStoreDir r => NixSerializer r SError DerivedPath
derivedPathNew = Serializer
{ getS :: SerialT r SError Get DerivedPath
getS = do
StoreDir
root <- (r -> StoreDir) -> SerialT r SError Get StoreDir
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> StoreDir
forall r. HasStoreDir r => r -> StoreDir
hasStoreDir
Text
p <- Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
case StoreDir -> Text -> Either ParseOutputsError DerivedPath
System.Nix.DerivedPath.parseDerivedPath StoreDir
root Text
p of
Left ParseOutputsError
err -> SError -> SerialT r SError Get DerivedPath
forall a. SError -> SerialT r SError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (SError -> SerialT r SError Get DerivedPath)
-> SError -> SerialT r SError Get DerivedPath
forall a b. (a -> b) -> a -> b
$ ParseOutputsError -> SError
SError_DerivedPath ParseOutputsError
err
Right DerivedPath
x -> DerivedPath -> SerialT r SError Get DerivedPath
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DerivedPath
x
, putS :: DerivedPath -> SerialT r SError PutM ()
putS = \DerivedPath
d -> do
StoreDir
root <- (r -> StoreDir) -> SerialT r SError PutM StoreDir
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> StoreDir
forall r. HasStoreDir r => r -> StoreDir
hasStoreDir
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text (StoreDir -> DerivedPath -> Text
System.Nix.DerivedPath.derivedPathToText StoreDir
root DerivedPath
d)
}
derivedPath
:: ( HasProtoVersion r
, HasStoreDir r
)
=> NixSerializer r SError DerivedPath
derivedPath :: forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r SError DerivedPath
derivedPath = Serializer
{ getS :: SerialT r SError Get DerivedPath
getS = do
ProtoVersion
pv <- (r -> ProtoVersion) -> SerialT r SError Get ProtoVersion
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> ProtoVersion
forall r. HasProtoVersion r => r -> ProtoVersion
hasProtoVersion
if ProtoVersion
pv ProtoVersion -> ProtoVersion -> Bool
forall a. Ord a => a -> a -> Bool
< Word16 -> Word8 -> ProtoVersion
ProtoVersion Word16
1 Word8
30
then StorePath -> DerivedPath
DerivedPath_Opaque (StorePath -> DerivedPath)
-> SerialT r SError Get StorePath
-> SerialT r SError Get DerivedPath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
else Serializer (SerialT r SError) DerivedPath
-> SerialT r SError Get DerivedPath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) DerivedPath
forall r. HasStoreDir r => NixSerializer r SError DerivedPath
derivedPathNew
, putS :: DerivedPath -> SerialT r SError PutM ()
putS = \DerivedPath
d -> do
ProtoVersion
pv <- (r -> ProtoVersion) -> SerialT r SError PutM ProtoVersion
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> ProtoVersion
forall r. HasProtoVersion r => r -> ProtoVersion
hasProtoVersion
if ProtoVersion
pv ProtoVersion -> ProtoVersion -> Bool
forall a. Ord a => a -> a -> Bool
< Word16 -> Word8 -> ProtoVersion
ProtoVersion Word16
1 Word8
30
then case DerivedPath
d of
DerivedPath_Opaque StorePath
p -> Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
p
DerivedPath
_ -> SError -> SerialT r SError PutM ()
forall a. SError -> SerialT r SError PutM a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
(SError -> SerialT r SError PutM ())
-> SError -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ String -> ForPV ProtoVersion -> SError
SError_NotYetImplemented
String
"DerivedPath_Built"
(ProtoVersion -> ForPV ProtoVersion
forall a. a -> ForPV a
ForPV_Older ProtoVersion
pv)
else Serializer (SerialT r SError) DerivedPath
-> DerivedPath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) DerivedPath
forall r. HasStoreDir r => NixSerializer r SError DerivedPath
derivedPathNew DerivedPath
d
}
buildMode :: NixSerializer r SError BuildMode
buildMode :: forall r. NixSerializer r SError BuildMode
buildMode = NixSerializer r SError BuildMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
data LoggerSError
= LoggerSError_Prim SError
| LoggerSError_InvalidOpCode Word64
| LoggerSError_TooOldForErrorInfo
| LoggerSError_TooNewForBasicError
| LoggerSError_UnknownLogFieldType Word8
deriving (LoggerSError -> LoggerSError -> Bool
(LoggerSError -> LoggerSError -> Bool)
-> (LoggerSError -> LoggerSError -> Bool) -> Eq LoggerSError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LoggerSError -> LoggerSError -> Bool
== :: LoggerSError -> LoggerSError -> Bool
$c/= :: LoggerSError -> LoggerSError -> Bool
/= :: LoggerSError -> LoggerSError -> Bool
Eq, Eq LoggerSError
Eq LoggerSError =>
(LoggerSError -> LoggerSError -> Ordering)
-> (LoggerSError -> LoggerSError -> Bool)
-> (LoggerSError -> LoggerSError -> Bool)
-> (LoggerSError -> LoggerSError -> Bool)
-> (LoggerSError -> LoggerSError -> Bool)
-> (LoggerSError -> LoggerSError -> LoggerSError)
-> (LoggerSError -> LoggerSError -> LoggerSError)
-> Ord LoggerSError
LoggerSError -> LoggerSError -> Bool
LoggerSError -> LoggerSError -> Ordering
LoggerSError -> LoggerSError -> LoggerSError
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LoggerSError -> LoggerSError -> Ordering
compare :: LoggerSError -> LoggerSError -> Ordering
$c< :: LoggerSError -> LoggerSError -> Bool
< :: LoggerSError -> LoggerSError -> Bool
$c<= :: LoggerSError -> LoggerSError -> Bool
<= :: LoggerSError -> LoggerSError -> Bool
$c> :: LoggerSError -> LoggerSError -> Bool
> :: LoggerSError -> LoggerSError -> Bool
$c>= :: LoggerSError -> LoggerSError -> Bool
>= :: LoggerSError -> LoggerSError -> Bool
$cmax :: LoggerSError -> LoggerSError -> LoggerSError
max :: LoggerSError -> LoggerSError -> LoggerSError
$cmin :: LoggerSError -> LoggerSError -> LoggerSError
min :: LoggerSError -> LoggerSError -> LoggerSError
Ord, (forall x. LoggerSError -> Rep LoggerSError x)
-> (forall x. Rep LoggerSError x -> LoggerSError)
-> Generic LoggerSError
forall x. Rep LoggerSError x -> LoggerSError
forall x. LoggerSError -> Rep LoggerSError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LoggerSError -> Rep LoggerSError x
from :: forall x. LoggerSError -> Rep LoggerSError x
$cto :: forall x. Rep LoggerSError x -> LoggerSError
to :: forall x. Rep LoggerSError x -> LoggerSError
Generic, Int -> LoggerSError -> ShowS
[LoggerSError] -> ShowS
LoggerSError -> String
(Int -> LoggerSError -> ShowS)
-> (LoggerSError -> String)
-> ([LoggerSError] -> ShowS)
-> Show LoggerSError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LoggerSError -> ShowS
showsPrec :: Int -> LoggerSError -> ShowS
$cshow :: LoggerSError -> String
show :: LoggerSError -> String
$cshowList :: [LoggerSError] -> ShowS
showList :: [LoggerSError] -> ShowS
Show)
mapPrimE
:: Functor m
=> SerialT r SError m a
-> SerialT r LoggerSError m a
mapPrimE :: forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE = (SError -> LoggerSError)
-> SerialT r SError m a -> SerialT r LoggerSError m a
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST SError -> LoggerSError
LoggerSError_Prim
maybeActivity :: NixSerializer r LoggerSError (Maybe Activity)
maybeActivity :: forall r. NixSerializer r LoggerSError (Maybe Activity)
maybeActivity = Serializer
{ getS :: SerialT r LoggerSError Get (Maybe Activity)
getS = Serializer (SerialT r LoggerSError) Int
-> SerialT r LoggerSError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Int) SerialT r LoggerSError Get Int
-> (Int -> SerialT r LoggerSError Get (Maybe Activity))
-> SerialT r LoggerSError Get (Maybe Activity)
forall a b.
SerialT r LoggerSError Get a
-> (a -> SerialT r LoggerSError Get b)
-> SerialT r LoggerSError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Int
0 -> Maybe Activity -> SerialT r LoggerSError Get (Maybe Activity)
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Activity
forall a. Maybe a
Nothing
Int
x -> SerialT r SError Get (Maybe Activity)
-> SerialT r LoggerSError Get (Maybe Activity)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get (Maybe Activity)
-> SerialT r LoggerSError Get (Maybe Activity))
-> SerialT r SError Get (Maybe Activity)
-> SerialT r LoggerSError Get (Maybe Activity)
forall a b. (a -> b) -> a -> b
$ Int -> SerialT r SError Get Activity
forall a (m :: * -> *).
(Bounded a, Enum a, MonadError SError m) =>
Int -> m a
toEnumCheckBoundsM (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
100) SerialT r SError Get Activity
-> (Activity -> SerialT r SError Get (Maybe Activity))
-> SerialT r SError Get (Maybe Activity)
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe Activity -> SerialT r SError Get (Maybe Activity)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Activity -> SerialT r SError Get (Maybe Activity))
-> (Activity -> Maybe Activity)
-> Activity
-> SerialT r SError Get (Maybe Activity)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Activity -> Maybe Activity
forall a. a -> Maybe a
Just
, putS :: Maybe Activity -> SerialT r LoggerSError PutM ()
putS = \case
Maybe Activity
Nothing -> Serializer (SerialT r LoggerSError) Int
-> Int -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (forall a r e. Integral a => NixSerializer r e a
int @Int) Int
0
Just Activity
act -> Serializer (SerialT r LoggerSError) Activity
-> Activity -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Activity
forall r. NixSerializer r LoggerSError Activity
activity Activity
act
}
activity :: NixSerializer r LoggerSError Activity
activity :: forall r. NixSerializer r LoggerSError Activity
activity = Serializer
{ getS :: SerialT r LoggerSError Get Activity
getS = SerialT r SError Get Activity
-> SerialT r LoggerSError Get Activity
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Activity
-> SerialT r LoggerSError Get Activity)
-> SerialT r SError Get Activity
-> SerialT r LoggerSError Get Activity
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Int -> SerialT r SError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int SerialT r SError Get Int
-> (Int -> SerialT r SError Get Activity)
-> SerialT r SError Get Activity
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> SerialT r SError Get Activity
forall a (m :: * -> *).
(Bounded a, Enum a, MonadError SError m) =>
Int -> m a
toEnumCheckBoundsM (Int -> SerialT r SError Get Activity)
-> (Int -> Int) -> Int -> SerialT r SError Get Activity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+(-Int
100))
, putS :: Activity -> SerialT r LoggerSError PutM ()
putS = Serializer (SerialT r LoggerSError) Int
-> Int -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int (Int -> SerialT r LoggerSError PutM ())
-> (Activity -> Int) -> Activity -> SerialT r LoggerSError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
100) (Int -> Int) -> (Activity -> Int) -> Activity -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Activity -> Int
forall a. Enum a => a -> Int
fromEnum
}
activityID :: NixSerializer r LoggerSError ActivityID
activityID :: forall r. NixSerializer r LoggerSError ActivityID
activityID = (Int -> ActivityID)
-> (ActivityID -> Int)
-> Serializer (SerialT r LoggerSError) Int
-> Serializer (SerialT r LoggerSError) ActivityID
forall (t :: (* -> *) -> * -> *) a b.
Functor (t Get) =>
(a -> b) -> (b -> a) -> Serializer t a -> Serializer t b
mapIsoSerializer Int -> ActivityID
ActivityID ActivityID -> Int
unActivityID Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int
activityResult :: NixSerializer r LoggerSError ActivityResult
activityResult :: forall r. NixSerializer r LoggerSError ActivityResult
activityResult = Serializer
{ getS :: SerialT r LoggerSError Get ActivityResult
getS = SerialT r SError Get ActivityResult
-> SerialT r LoggerSError Get ActivityResult
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get ActivityResult
-> SerialT r LoggerSError Get ActivityResult)
-> SerialT r SError Get ActivityResult
-> SerialT r LoggerSError Get ActivityResult
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Int -> SerialT r SError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int SerialT r SError Get Int
-> (Int -> SerialT r SError Get ActivityResult)
-> SerialT r SError Get ActivityResult
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> SerialT r SError Get ActivityResult
forall a (m :: * -> *).
(Bounded a, Enum a, MonadError SError m) =>
Int -> m a
toEnumCheckBoundsM (Int -> SerialT r SError Get ActivityResult)
-> (Int -> Int) -> Int -> SerialT r SError Get ActivityResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+(-Int
100))
, putS :: ActivityResult -> SerialT r LoggerSError PutM ()
putS = Serializer (SerialT r LoggerSError) Int
-> Int -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int (Int -> SerialT r LoggerSError PutM ())
-> (ActivityResult -> Int)
-> ActivityResult
-> SerialT r LoggerSError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
100) (Int -> Int) -> (ActivityResult -> Int) -> ActivityResult -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ActivityResult -> Int
forall a. Enum a => a -> Int
fromEnum
}
field :: NixSerializer r LoggerSError Field
field :: forall r. NixSerializer r LoggerSError Field
field = Serializer
{ getS :: SerialT r LoggerSError Get Field
getS = Serializer (SerialT r LoggerSError) Word8
-> SerialT r LoggerSError Get Word8
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Word8) SerialT r LoggerSError Get Word8
-> (Word8 -> SerialT r LoggerSError Get Field)
-> SerialT r LoggerSError Get Field
forall a b.
SerialT r LoggerSError Get a
-> (a -> SerialT r LoggerSError Get b)
-> SerialT r LoggerSError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Word8
0 -> Int -> Field
Field_LogInt (Int -> Field)
-> SerialT r LoggerSError Get Int
-> SerialT r LoggerSError Get Field
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r LoggerSError) Int
-> SerialT r LoggerSError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int
Word8
1 -> Text -> Field
Field_LogStr (Text -> Field)
-> SerialT r LoggerSError Get Text
-> SerialT r LoggerSError Get Field
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text)
Word8
x -> LoggerSError -> SerialT r LoggerSError Get Field
forall a. LoggerSError -> SerialT r LoggerSError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (LoggerSError -> SerialT r LoggerSError Get Field)
-> LoggerSError -> SerialT r LoggerSError Get Field
forall a b. (a -> b) -> a -> b
$ Word8 -> LoggerSError
LoggerSError_UnknownLogFieldType Word8
x
, putS :: Field -> SerialT r LoggerSError PutM ()
putS = \case
Field_LogInt Int
x -> Serializer (SerialT r LoggerSError) Word8
-> Word8 -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Word8
forall a r e. Integral a => NixSerializer r e a
int (Word8
0 :: Word8) SerialT r LoggerSError PutM ()
-> SerialT r LoggerSError PutM () -> SerialT r LoggerSError PutM ()
forall a b.
SerialT r LoggerSError PutM a
-> SerialT r LoggerSError PutM b -> SerialT r LoggerSError PutM b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Serializer (SerialT r LoggerSError) Int
-> Int -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int Int
x
Field_LogStr Text
x -> Serializer (SerialT r LoggerSError) Word8
-> Word8 -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Word8
forall a r e. Integral a => NixSerializer r e a
int (Word8
1 :: Word8) SerialT r LoggerSError PutM ()
-> SerialT r LoggerSError PutM () -> SerialT r LoggerSError PutM ()
forall a b.
SerialT r LoggerSError PutM a
-> SerialT r LoggerSError PutM b -> SerialT r LoggerSError PutM b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
x)
}
trace :: NixSerializer r LoggerSError Trace
trace :: forall r. NixSerializer r LoggerSError Trace
trace = Serializer
{ getS :: SerialT r LoggerSError Get Trace
getS = do
Maybe Int
tracePosition <- (\case Int
0 -> Maybe Int
forall a. Maybe a
Nothing; Int
x -> Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x) (Int -> Maybe Int)
-> SerialT r LoggerSError Get Int
-> SerialT r LoggerSError Get (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r LoggerSError) Int
-> SerialT r LoggerSError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Int)
Text
traceHint <- SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Text -> SerialT r LoggerSError Get Text)
-> SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
Trace -> SerialT r LoggerSError Get Trace
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Trace{Maybe Int
Text
tracePosition :: Maybe Int
traceHint :: Text
tracePosition :: Maybe Int
traceHint :: Text
..}
, putS :: Trace -> SerialT r LoggerSError PutM ()
putS = \Trace{Maybe Int
Text
tracePosition :: Trace -> Maybe Int
traceHint :: Trace -> Text
tracePosition :: Maybe Int
traceHint :: Text
..} -> do
Serializer (SerialT r LoggerSError) Int
-> Int -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int (Int -> SerialT r LoggerSError PutM ())
-> Int -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Int
0 Maybe Int
tracePosition
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
traceHint
}
basicError :: NixSerializer r LoggerSError BasicError
basicError :: forall r. NixSerializer r LoggerSError BasicError
basicError = Serializer
{ getS :: SerialT r LoggerSError Get BasicError
getS = do
Text
basicErrorMessage <- SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Text -> SerialT r LoggerSError Get Text)
-> SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
Int
basicErrorExitStatus <- Serializer (SerialT r LoggerSError) Int
-> SerialT r LoggerSError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int
BasicError -> SerialT r LoggerSError Get BasicError
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BasicError{Int
Text
basicErrorMessage :: Text
basicErrorExitStatus :: Int
basicErrorExitStatus :: Int
basicErrorMessage :: Text
..}
, putS :: BasicError -> SerialT r LoggerSError PutM ()
putS = \BasicError{Int
Text
basicErrorExitStatus :: BasicError -> Int
basicErrorMessage :: BasicError -> Text
basicErrorExitStatus :: Int
basicErrorMessage :: Text
..} -> do
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
basicErrorMessage
Serializer (SerialT r LoggerSError) Int
-> Int -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int Int
basicErrorExitStatus
}
errorInfo :: NixSerializer r LoggerSError ErrorInfo
errorInfo :: forall r. NixSerializer r LoggerSError ErrorInfo
errorInfo = Serializer
{ getS :: SerialT r LoggerSError Get ErrorInfo
getS = do
Text
etyp <- SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Text -> SerialT r LoggerSError Get Text)
-> SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
Bool
-> SerialT r LoggerSError Get () -> SerialT r LoggerSError Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.unless (Text
etyp Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Text
Data.Text.pack String
"Error")
(SerialT r LoggerSError Get () -> SerialT r LoggerSError Get ())
-> SerialT r LoggerSError Get () -> SerialT r LoggerSError Get ()
forall a b. (a -> b) -> a -> b
$ String -> SerialT r LoggerSError Get ()
forall a. String -> SerialT r LoggerSError Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail
(String -> SerialT r LoggerSError Get ())
-> String -> SerialT r LoggerSError Get ()
forall a b. (a -> b) -> a -> b
$ String
"get ErrorInfo: received unknown error type" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
etyp
Verbosity
errorInfoLevel <- Serializer (SerialT r LoggerSError) Verbosity
-> SerialT r LoggerSError Get Verbosity
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Verbosity
forall r. NixSerializer r LoggerSError Verbosity
verbosity
Text
_name <- SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Text -> SerialT r LoggerSError Get Text)
-> SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
Text
errorInfoMessage <- SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Text -> SerialT r LoggerSError Get Text)
-> SerialT r SError Get Text -> SerialT r LoggerSError Get Text
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
Maybe Int
errorInfoPosition <- (\case Int
0 -> Maybe Int
forall a. Maybe a
Nothing; Int
x -> Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x) (Int -> Maybe Int)
-> SerialT r LoggerSError Get Int
-> SerialT r LoggerSError Get (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r LoggerSError) Int
-> SerialT r LoggerSError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Int
forall a r e. Integral a => NixSerializer r e a
int
[Trace]
errorInfoTraces <- Serializer (SerialT r LoggerSError) [Trace]
-> SerialT r LoggerSError Get [Trace]
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r LoggerSError Trace
-> Serializer (SerialT r LoggerSError) [Trace]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r LoggerSError Trace
forall r. NixSerializer r LoggerSError Trace
trace)
ErrorInfo -> SerialT r LoggerSError Get ErrorInfo
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ErrorInfo{[Trace]
Maybe Int
Text
Verbosity
errorInfoLevel :: Verbosity
errorInfoMessage :: Text
errorInfoPosition :: Maybe Int
errorInfoTraces :: [Trace]
errorInfoLevel :: Verbosity
errorInfoMessage :: Text
errorInfoPosition :: Maybe Int
errorInfoTraces :: [Trace]
..}
, putS :: ErrorInfo -> SerialT r LoggerSError PutM ()
putS = \ErrorInfo{[Trace]
Maybe Int
Text
Verbosity
errorInfoLevel :: ErrorInfo -> Verbosity
errorInfoMessage :: ErrorInfo -> Text
errorInfoPosition :: ErrorInfo -> Maybe Int
errorInfoTraces :: ErrorInfo -> [Trace]
errorInfoLevel :: Verbosity
errorInfoMessage :: Text
errorInfoPosition :: Maybe Int
errorInfoTraces :: [Trace]
..} -> do
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text (Text -> SerialT r SError PutM ())
-> Text -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ String -> Text
Data.Text.pack String
"Error"
Serializer (SerialT r LoggerSError) Verbosity
-> Verbosity -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Verbosity
forall r. NixSerializer r LoggerSError Verbosity
verbosity Verbosity
errorInfoLevel
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text (Text -> SerialT r SError PutM ())
-> Text -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ String -> Text
Data.Text.pack String
"Error"
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
errorInfoMessage
Serializer (SerialT r SError) Int
-> Int -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int (Int -> SerialT r SError PutM ())
-> Int -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Int
0 Maybe Int
errorInfoPosition
Serializer (SerialT r LoggerSError) [Trace]
-> [Trace] -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r LoggerSError Trace
-> Serializer (SerialT r LoggerSError) [Trace]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r LoggerSError Trace
forall r. NixSerializer r LoggerSError Trace
trace) [Trace]
errorInfoTraces
}
loggerOpCode :: NixSerializer r LoggerSError LoggerOpCode
loggerOpCode :: forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode = Serializer
{ getS :: SerialT r LoggerSError Get LoggerOpCode
getS = do
Word64
c <- Serializer (SerialT r LoggerSError) Word64
-> SerialT r LoggerSError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Word64
forall a r e. Integral a => NixSerializer r e a
int
(String -> SerialT r LoggerSError Get LoggerOpCode)
-> (LoggerOpCode -> SerialT r LoggerSError Get LoggerOpCode)
-> Either String LoggerOpCode
-> SerialT r LoggerSError Get LoggerOpCode
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
(SerialT r LoggerSError Get LoggerOpCode
-> String -> SerialT r LoggerSError Get LoggerOpCode
forall a. a -> String -> a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SerialT r LoggerSError Get LoggerOpCode
-> String -> SerialT r LoggerSError Get LoggerOpCode)
-> SerialT r LoggerSError Get LoggerOpCode
-> String
-> SerialT r LoggerSError Get LoggerOpCode
forall a b. (a -> b) -> a -> b
$ LoggerSError -> SerialT r LoggerSError Get LoggerOpCode
forall a. LoggerSError -> SerialT r LoggerSError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Word64 -> LoggerSError
LoggerSError_InvalidOpCode Word64
c))
LoggerOpCode -> SerialT r LoggerSError Get LoggerOpCode
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(Either String LoggerOpCode
-> SerialT r LoggerSError Get LoggerOpCode)
-> Either String LoggerOpCode
-> SerialT r LoggerSError Get LoggerOpCode
forall a b. (a -> b) -> a -> b
$ Word64 -> Either String LoggerOpCode
word64ToLoggerOpCode Word64
c
, putS :: LoggerOpCode -> SerialT r LoggerSError PutM ()
putS = Serializer (SerialT r LoggerSError) Word64
-> Word64 -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Word64
forall a r e. Integral a => NixSerializer r e a
int (Word64 -> SerialT r LoggerSError PutM ())
-> (LoggerOpCode -> Word64)
-> LoggerOpCode
-> SerialT r LoggerSError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LoggerOpCode -> Word64
loggerOpCodeToWord64
}
logger
:: HasProtoVersion r
=> NixSerializer r LoggerSError Logger
logger :: forall r. HasProtoVersion r => NixSerializer r LoggerSError Logger
logger = Serializer
{ getS :: SerialT r LoggerSError Get Logger
getS = Serializer (SerialT r LoggerSError) LoggerOpCode
-> SerialT r LoggerSError Get LoggerOpCode
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode SerialT r LoggerSError Get LoggerOpCode
-> (LoggerOpCode -> SerialT r LoggerSError Get Logger)
-> SerialT r LoggerSError Get Logger
forall a b.
SerialT r LoggerSError Get a
-> (a -> SerialT r LoggerSError Get b)
-> SerialT r LoggerSError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
LoggerOpCode
LoggerOpCode_Next ->
SerialT r SError Get Logger -> SerialT r LoggerSError Get Logger
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Logger -> SerialT r LoggerSError Get Logger)
-> SerialT r SError Get Logger -> SerialT r LoggerSError Get Logger
forall a b. (a -> b) -> a -> b
$
Text -> Logger
Logger_Next (Text -> Logger)
-> SerialT r SError Get Text -> SerialT r SError Get Logger
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
LoggerOpCode
LoggerOpCode_Read ->
Word64 -> Logger
Logger_Read (Word64 -> Logger)
-> SerialT r LoggerSError Get Word64
-> SerialT r LoggerSError Get Logger
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r LoggerSError) Word64
-> SerialT r LoggerSError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Word64
forall a r e. Integral a => NixSerializer r e a
int
LoggerOpCode
LoggerOpCode_Write ->
SerialT r SError Get Logger -> SerialT r LoggerSError Get Logger
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Logger -> SerialT r LoggerSError Get Logger)
-> SerialT r SError Get Logger -> SerialT r LoggerSError Get Logger
forall a b. (a -> b) -> a -> b
$
ByteString -> Logger
Logger_Write (ByteString -> Logger)
-> SerialT r SError Get ByteString -> SerialT r SError Get Logger
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) ByteString
-> SerialT r SError Get ByteString
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString
LoggerOpCode
LoggerOpCode_Last ->
Logger -> SerialT r LoggerSError Get Logger
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Logger
Logger_Last
LoggerOpCode
LoggerOpCode_Error -> do
ProtoVersion
pv <- (r -> ProtoVersion) -> SerialT r LoggerSError Get ProtoVersion
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> ProtoVersion
forall r. HasProtoVersion r => r -> ProtoVersion
hasProtoVersion
Either BasicError ErrorInfo -> Logger
Logger_Error (Either BasicError ErrorInfo -> Logger)
-> SerialT r LoggerSError Get (Either BasicError ErrorInfo)
-> SerialT r LoggerSError Get Logger
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
if ProtoVersion -> Word8
protoVersion_minor ProtoVersion
pv Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
26
then ErrorInfo -> Either BasicError ErrorInfo
forall a b. b -> Either a b
Right (ErrorInfo -> Either BasicError ErrorInfo)
-> SerialT r LoggerSError Get ErrorInfo
-> SerialT r LoggerSError Get (Either BasicError ErrorInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r LoggerSError) ErrorInfo
-> SerialT r LoggerSError Get ErrorInfo
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) ErrorInfo
forall r. NixSerializer r LoggerSError ErrorInfo
errorInfo
else BasicError -> Either BasicError ErrorInfo
forall a b. a -> Either a b
Left (BasicError -> Either BasicError ErrorInfo)
-> SerialT r LoggerSError Get BasicError
-> SerialT r LoggerSError Get (Either BasicError ErrorInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r LoggerSError) BasicError
-> SerialT r LoggerSError Get BasicError
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) BasicError
forall r. NixSerializer r LoggerSError BasicError
basicError
LoggerOpCode
LoggerOpCode_StartActivity -> do
ActivityID
startActivityID <- Serializer (SerialT r LoggerSError) ActivityID
-> SerialT r LoggerSError Get ActivityID
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID
Verbosity
startActivityVerbosity <- Serializer (SerialT r LoggerSError) Verbosity
-> SerialT r LoggerSError Get Verbosity
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) Verbosity
forall r. NixSerializer r LoggerSError Verbosity
verbosity
Maybe Activity
startActivityType <- Serializer (SerialT r LoggerSError) (Maybe Activity)
-> SerialT r LoggerSError Get (Maybe Activity)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) (Maybe Activity)
forall r. NixSerializer r LoggerSError (Maybe Activity)
maybeActivity
ByteString
startActivityString <- SerialT r SError Get ByteString
-> SerialT r LoggerSError Get ByteString
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get ByteString
-> SerialT r LoggerSError Get ByteString)
-> SerialT r SError Get ByteString
-> SerialT r LoggerSError Get ByteString
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) ByteString
-> SerialT r SError Get ByteString
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString
[Field]
startActivityFields <- Serializer (SerialT r LoggerSError) [Field]
-> SerialT r LoggerSError Get [Field]
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r LoggerSError Field
-> Serializer (SerialT r LoggerSError) [Field]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r LoggerSError Field
forall r. NixSerializer r LoggerSError Field
field)
ActivityID
startActivityParentID <- Serializer (SerialT r LoggerSError) ActivityID
-> SerialT r LoggerSError Get ActivityID
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID
Logger -> SerialT r LoggerSError Get Logger
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Logger_StartActivity{[Field]
Maybe Activity
ByteString
ActivityID
Verbosity
startActivityID :: ActivityID
startActivityVerbosity :: Verbosity
startActivityType :: Maybe Activity
startActivityString :: ByteString
startActivityFields :: [Field]
startActivityParentID :: ActivityID
startActivityID :: ActivityID
startActivityVerbosity :: Verbosity
startActivityType :: Maybe Activity
startActivityString :: ByteString
startActivityFields :: [Field]
startActivityParentID :: ActivityID
..}
LoggerOpCode
LoggerOpCode_StopActivity -> do
ActivityID
stopActivityID <- Serializer (SerialT r LoggerSError) ActivityID
-> SerialT r LoggerSError Get ActivityID
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID
Logger -> SerialT r LoggerSError Get Logger
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Logger_StopActivity{ActivityID
stopActivityID :: ActivityID
stopActivityID :: ActivityID
..}
LoggerOpCode
LoggerOpCode_Result -> do
ActivityID
resultActivityID <- Serializer (SerialT r LoggerSError) ActivityID
-> SerialT r LoggerSError Get ActivityID
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID
ActivityResult
resultType <- Serializer (SerialT r LoggerSError) ActivityResult
-> SerialT r LoggerSError Get ActivityResult
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r LoggerSError) ActivityResult
forall r. NixSerializer r LoggerSError ActivityResult
activityResult
[Field]
resultFields <- Serializer (SerialT r LoggerSError) [Field]
-> SerialT r LoggerSError Get [Field]
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r LoggerSError Field
-> Serializer (SerialT r LoggerSError) [Field]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r LoggerSError Field
forall r. NixSerializer r LoggerSError Field
field)
Logger -> SerialT r LoggerSError Get Logger
forall a. a -> SerialT r LoggerSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Logger_Result {[Field]
ActivityResult
ActivityID
resultActivityID :: ActivityID
resultType :: ActivityResult
resultFields :: [Field]
resultActivityID :: ActivityID
resultType :: ActivityResult
resultFields :: [Field]
..}
, putS :: Logger -> SerialT r LoggerSError PutM ()
putS = \case
Logger_Next Text
s -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_Next
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
s
Logger_Read Word64
i -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_Read
Serializer (SerialT r LoggerSError) Word64
-> Word64 -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Word64
forall a r e. Integral a => NixSerializer r e a
int Word64
i
Logger_Write ByteString
s -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_Write
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) ByteString
-> ByteString -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString ByteString
s
Logger
Logger_Last ->
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_Last
Logger_Error Either BasicError ErrorInfo
basicOrInfo -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_Error
Word8
minor <- ProtoVersion -> Word8
protoVersion_minor (ProtoVersion -> Word8)
-> SerialT r LoggerSError PutM ProtoVersion
-> SerialT r LoggerSError PutM Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (r -> ProtoVersion) -> SerialT r LoggerSError PutM ProtoVersion
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> ProtoVersion
forall r. HasProtoVersion r => r -> ProtoVersion
hasProtoVersion
case Either BasicError ErrorInfo
basicOrInfo of
Left BasicError
_ | Word8
minor Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
26 -> LoggerSError -> SerialT r LoggerSError PutM ()
forall a. LoggerSError -> SerialT r LoggerSError PutM a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (LoggerSError -> SerialT r LoggerSError PutM ())
-> LoggerSError -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ LoggerSError
LoggerSError_TooNewForBasicError
Left BasicError
e | Bool
otherwise -> Serializer (SerialT r LoggerSError) BasicError
-> BasicError -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) BasicError
forall r. NixSerializer r LoggerSError BasicError
basicError BasicError
e
Right ErrorInfo
_ | Word8
minor Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
26 -> LoggerSError -> SerialT r LoggerSError PutM ()
forall a. LoggerSError -> SerialT r LoggerSError PutM a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (LoggerSError -> SerialT r LoggerSError PutM ())
-> LoggerSError -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$ LoggerSError
LoggerSError_TooOldForErrorInfo
Right ErrorInfo
e -> Serializer (SerialT r LoggerSError) ErrorInfo
-> ErrorInfo -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) ErrorInfo
forall r. NixSerializer r LoggerSError ErrorInfo
errorInfo ErrorInfo
e
Logger_StartActivity{[Field]
Maybe Activity
ByteString
ActivityID
Verbosity
startActivityID :: Logger -> ActivityID
startActivityVerbosity :: Logger -> Verbosity
startActivityType :: Logger -> Maybe Activity
startActivityString :: Logger -> ByteString
startActivityFields :: Logger -> [Field]
startActivityParentID :: Logger -> ActivityID
startActivityID :: ActivityID
startActivityVerbosity :: Verbosity
startActivityType :: Maybe Activity
startActivityString :: ByteString
startActivityFields :: [Field]
startActivityParentID :: ActivityID
..} -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_StartActivity
Serializer (SerialT r LoggerSError) ActivityID
-> ActivityID -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID ActivityID
startActivityID
Serializer (SerialT r LoggerSError) Verbosity
-> Verbosity -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) Verbosity
forall r. NixSerializer r LoggerSError Verbosity
verbosity Verbosity
startActivityVerbosity
Serializer (SerialT r LoggerSError) (Maybe Activity)
-> Maybe Activity -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) (Maybe Activity)
forall r. NixSerializer r LoggerSError (Maybe Activity)
maybeActivity Maybe Activity
startActivityType
SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall a b. (a -> b) -> a -> b
$
Serializer (SerialT r SError) ByteString
-> ByteString -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString ByteString
startActivityString
Serializer (SerialT r LoggerSError) [Field]
-> [Field] -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r LoggerSError Field
-> Serializer (SerialT r LoggerSError) [Field]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r LoggerSError Field
forall r. NixSerializer r LoggerSError Field
field) [Field]
startActivityFields
Serializer (SerialT r LoggerSError) ActivityID
-> ActivityID -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID ActivityID
startActivityParentID
Logger_StopActivity{ActivityID
stopActivityID :: Logger -> ActivityID
stopActivityID :: ActivityID
..} -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_StopActivity
Serializer (SerialT r LoggerSError) ActivityID
-> ActivityID -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID ActivityID
stopActivityID
Logger_Result{[Field]
ActivityResult
ActivityID
resultActivityID :: Logger -> ActivityID
resultType :: Logger -> ActivityResult
resultFields :: Logger -> [Field]
resultActivityID :: ActivityID
resultType :: ActivityResult
resultFields :: [Field]
..} -> do
Serializer (SerialT r LoggerSError) LoggerOpCode
-> LoggerOpCode -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) LoggerOpCode
forall r. NixSerializer r LoggerSError LoggerOpCode
loggerOpCode LoggerOpCode
LoggerOpCode_Result
Serializer (SerialT r LoggerSError) ActivityID
-> ActivityID -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) ActivityID
forall r. NixSerializer r LoggerSError ActivityID
activityID ActivityID
resultActivityID
Serializer (SerialT r LoggerSError) ActivityResult
-> ActivityResult -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r LoggerSError) ActivityResult
forall r. NixSerializer r LoggerSError ActivityResult
activityResult ActivityResult
resultType
Serializer (SerialT r LoggerSError) [Field]
-> [Field] -> SerialT r LoggerSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r LoggerSError Field
-> Serializer (SerialT r LoggerSError) [Field]
forall r e a. NixSerializer r e a -> NixSerializer r e [a]
list NixSerializer r LoggerSError Field
forall r. NixSerializer r LoggerSError Field
field) [Field]
resultFields
}
verbosity :: NixSerializer r LoggerSError Verbosity
verbosity :: forall r. NixSerializer r LoggerSError Verbosity
verbosity = Serializer
{ getS :: SerialT r LoggerSError Get Verbosity
getS = SerialT r SError Get Verbosity
-> SerialT r LoggerSError Get Verbosity
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError Get Verbosity
-> SerialT r LoggerSError Get Verbosity)
-> SerialT r SError Get Verbosity
-> SerialT r LoggerSError Get Verbosity
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Verbosity
-> SerialT r SError Get Verbosity
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Verbosity
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
, putS :: Verbosity -> SerialT r LoggerSError PutM ()
putS = SerialT r SError PutM () -> SerialT r LoggerSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r LoggerSError m a
mapPrimE (SerialT r SError PutM () -> SerialT r LoggerSError PutM ())
-> (Verbosity -> SerialT r SError PutM ())
-> Verbosity
-> SerialT r LoggerSError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Serializer (SerialT r SError) Verbosity
-> Verbosity -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Verbosity
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
}
data HandshakeSError
= HandshakeSError_InvalidWorkerMagic Word64
| HandshakeSError_InvalidTrustedFlag Word8
deriving (HandshakeSError -> HandshakeSError -> Bool
(HandshakeSError -> HandshakeSError -> Bool)
-> (HandshakeSError -> HandshakeSError -> Bool)
-> Eq HandshakeSError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HandshakeSError -> HandshakeSError -> Bool
== :: HandshakeSError -> HandshakeSError -> Bool
$c/= :: HandshakeSError -> HandshakeSError -> Bool
/= :: HandshakeSError -> HandshakeSError -> Bool
Eq, Eq HandshakeSError
Eq HandshakeSError =>
(HandshakeSError -> HandshakeSError -> Ordering)
-> (HandshakeSError -> HandshakeSError -> Bool)
-> (HandshakeSError -> HandshakeSError -> Bool)
-> (HandshakeSError -> HandshakeSError -> Bool)
-> (HandshakeSError -> HandshakeSError -> Bool)
-> (HandshakeSError -> HandshakeSError -> HandshakeSError)
-> (HandshakeSError -> HandshakeSError -> HandshakeSError)
-> Ord HandshakeSError
HandshakeSError -> HandshakeSError -> Bool
HandshakeSError -> HandshakeSError -> Ordering
HandshakeSError -> HandshakeSError -> HandshakeSError
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HandshakeSError -> HandshakeSError -> Ordering
compare :: HandshakeSError -> HandshakeSError -> Ordering
$c< :: HandshakeSError -> HandshakeSError -> Bool
< :: HandshakeSError -> HandshakeSError -> Bool
$c<= :: HandshakeSError -> HandshakeSError -> Bool
<= :: HandshakeSError -> HandshakeSError -> Bool
$c> :: HandshakeSError -> HandshakeSError -> Bool
> :: HandshakeSError -> HandshakeSError -> Bool
$c>= :: HandshakeSError -> HandshakeSError -> Bool
>= :: HandshakeSError -> HandshakeSError -> Bool
$cmax :: HandshakeSError -> HandshakeSError -> HandshakeSError
max :: HandshakeSError -> HandshakeSError -> HandshakeSError
$cmin :: HandshakeSError -> HandshakeSError -> HandshakeSError
min :: HandshakeSError -> HandshakeSError -> HandshakeSError
Ord, (forall x. HandshakeSError -> Rep HandshakeSError x)
-> (forall x. Rep HandshakeSError x -> HandshakeSError)
-> Generic HandshakeSError
forall x. Rep HandshakeSError x -> HandshakeSError
forall x. HandshakeSError -> Rep HandshakeSError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. HandshakeSError -> Rep HandshakeSError x
from :: forall x. HandshakeSError -> Rep HandshakeSError x
$cto :: forall x. Rep HandshakeSError x -> HandshakeSError
to :: forall x. Rep HandshakeSError x -> HandshakeSError
Generic, Int -> HandshakeSError -> ShowS
[HandshakeSError] -> ShowS
HandshakeSError -> String
(Int -> HandshakeSError -> ShowS)
-> (HandshakeSError -> String)
-> ([HandshakeSError] -> ShowS)
-> Show HandshakeSError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HandshakeSError -> ShowS
showsPrec :: Int -> HandshakeSError -> ShowS
$cshow :: HandshakeSError -> String
show :: HandshakeSError -> String
$cshowList :: [HandshakeSError] -> ShowS
showList :: [HandshakeSError] -> ShowS
Show)
workerMagic :: NixSerializer r HandshakeSError WorkerMagic
workerMagic :: forall r. NixSerializer r HandshakeSError WorkerMagic
workerMagic = Serializer
{ getS :: SerialT r HandshakeSError Get WorkerMagic
getS = do
Word64
c <- Serializer (SerialT r HandshakeSError) Word64
-> SerialT r HandshakeSError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r HandshakeSError) Word64
forall a r e. Integral a => NixSerializer r e a
int
(String -> SerialT r HandshakeSError Get WorkerMagic)
-> (WorkerMagic -> SerialT r HandshakeSError Get WorkerMagic)
-> Either String WorkerMagic
-> SerialT r HandshakeSError Get WorkerMagic
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
(SerialT r HandshakeSError Get WorkerMagic
-> String -> SerialT r HandshakeSError Get WorkerMagic
forall a. a -> String -> a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SerialT r HandshakeSError Get WorkerMagic
-> String -> SerialT r HandshakeSError Get WorkerMagic)
-> SerialT r HandshakeSError Get WorkerMagic
-> String
-> SerialT r HandshakeSError Get WorkerMagic
forall a b. (a -> b) -> a -> b
$ HandshakeSError -> SerialT r HandshakeSError Get WorkerMagic
forall a. HandshakeSError -> SerialT r HandshakeSError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Word64 -> HandshakeSError
HandshakeSError_InvalidWorkerMagic Word64
c))
WorkerMagic -> SerialT r HandshakeSError Get WorkerMagic
forall a. a -> SerialT r HandshakeSError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(Either String WorkerMagic
-> SerialT r HandshakeSError Get WorkerMagic)
-> Either String WorkerMagic
-> SerialT r HandshakeSError Get WorkerMagic
forall a b. (a -> b) -> a -> b
$ Word64 -> Either String WorkerMagic
word64ToWorkerMagic Word64
c
, putS :: WorkerMagic -> SerialT r HandshakeSError PutM ()
putS = Serializer (SerialT r HandshakeSError) Word64
-> Word64 -> SerialT r HandshakeSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r HandshakeSError) Word64
forall a r e. Integral a => NixSerializer r e a
int (Word64 -> SerialT r HandshakeSError PutM ())
-> (WorkerMagic -> Word64)
-> WorkerMagic
-> SerialT r HandshakeSError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WorkerMagic -> Word64
workerMagicToWord64
}
trustedFlag :: NixSerializer r HandshakeSError (Maybe TrustedFlag)
trustedFlag :: forall r. NixSerializer r HandshakeSError (Maybe TrustedFlag)
trustedFlag = Serializer
{ getS :: SerialT r HandshakeSError Get (Maybe TrustedFlag)
getS = do
Word8
n :: Word8 <- Serializer (SerialT r HandshakeSError) Word8
-> SerialT r HandshakeSError Get Word8
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r HandshakeSError) Word8
forall a r e. Integral a => NixSerializer r e a
int
case Word8
n of
Word8
0 -> Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a. a -> SerialT r HandshakeSError Get a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag))
-> Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a b. (a -> b) -> a -> b
$ Maybe TrustedFlag
forall a. Maybe a
Nothing
Word8
1 -> Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a. a -> SerialT r HandshakeSError Get a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag))
-> Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a b. (a -> b) -> a -> b
$ TrustedFlag -> Maybe TrustedFlag
forall a. a -> Maybe a
Just TrustedFlag
TrustedFlag_Trusted
Word8
2 -> Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a. a -> SerialT r HandshakeSError Get a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag))
-> Maybe TrustedFlag
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a b. (a -> b) -> a -> b
$ TrustedFlag -> Maybe TrustedFlag
forall a. a -> Maybe a
Just TrustedFlag
TrustedFlag_NotTrusted
Word8
_ -> HandshakeSError
-> SerialT r HandshakeSError Get (Maybe TrustedFlag)
forall a. HandshakeSError -> SerialT r HandshakeSError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Word8 -> HandshakeSError
HandshakeSError_InvalidTrustedFlag Word8
n)
, putS :: Maybe TrustedFlag -> SerialT r HandshakeSError PutM ()
putS = \Maybe TrustedFlag
n -> Serializer (SerialT r HandshakeSError) Word8
-> Word8 -> SerialT r HandshakeSError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r HandshakeSError) Word8
forall a r e. Integral a => NixSerializer r e a
int (Word8 -> SerialT r HandshakeSError PutM ())
-> Word8 -> SerialT r HandshakeSError PutM ()
forall a b. (a -> b) -> a -> b
$ case Maybe TrustedFlag
n of
Maybe TrustedFlag
Nothing -> Word8
0 :: Word8
Just TrustedFlag
TrustedFlag_Trusted -> Word8
1
Just TrustedFlag
TrustedFlag_NotTrusted -> Word8
2
}
storeText :: NixSerializer r SError StoreText
storeText :: forall r. NixSerializer r SError StoreText
storeText = Serializer
{ getS :: SerialT r SError Get StoreText
getS = do
StorePathName
storeTextName <- Serializer (SerialT r SError) StorePathName
-> SerialT r SError Get StorePathName
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePathName
forall r. NixSerializer r SError StorePathName
storePathName
Text
storeTextText <- Serializer (SerialT r SError) Text -> SerialT r SError Get Text
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
StoreText -> SerialT r SError Get StoreText
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StoreText{Text
StorePathName
storeTextName :: StorePathName
storeTextText :: Text
storeTextName :: StorePathName
storeTextText :: Text
..}
, putS :: StoreText -> SerialT r SError PutM ()
putS = \StoreText{Text
StorePathName
storeTextName :: StoreText -> StorePathName
storeTextText :: StoreText -> Text
storeTextName :: StorePathName
storeTextText :: Text
..} -> do
Serializer (SerialT r SError) StorePathName
-> StorePathName -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePathName
forall r. NixSerializer r SError StorePathName
storePathName StorePathName
storeTextName
Serializer (SerialT r SError) Text
-> Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text Text
storeTextText
}
workerOp :: NixSerializer r SError WorkerOp
workerOp :: forall r. NixSerializer r SError WorkerOp
workerOp = NixSerializer r SError WorkerOp
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
data RequestSError
= RequestSError_NotYetImplemented WorkerOp
| RequestSError_ReservedOp WorkerOp
| RequestSError_PrimGet SError
| RequestSError_PrimPut SError
| RequestSError_PrimWorkerOp SError
deriving (RequestSError -> RequestSError -> Bool
(RequestSError -> RequestSError -> Bool)
-> (RequestSError -> RequestSError -> Bool) -> Eq RequestSError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestSError -> RequestSError -> Bool
== :: RequestSError -> RequestSError -> Bool
$c/= :: RequestSError -> RequestSError -> Bool
/= :: RequestSError -> RequestSError -> Bool
Eq, Eq RequestSError
Eq RequestSError =>
(RequestSError -> RequestSError -> Ordering)
-> (RequestSError -> RequestSError -> Bool)
-> (RequestSError -> RequestSError -> Bool)
-> (RequestSError -> RequestSError -> Bool)
-> (RequestSError -> RequestSError -> Bool)
-> (RequestSError -> RequestSError -> RequestSError)
-> (RequestSError -> RequestSError -> RequestSError)
-> Ord RequestSError
RequestSError -> RequestSError -> Bool
RequestSError -> RequestSError -> Ordering
RequestSError -> RequestSError -> RequestSError
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RequestSError -> RequestSError -> Ordering
compare :: RequestSError -> RequestSError -> Ordering
$c< :: RequestSError -> RequestSError -> Bool
< :: RequestSError -> RequestSError -> Bool
$c<= :: RequestSError -> RequestSError -> Bool
<= :: RequestSError -> RequestSError -> Bool
$c> :: RequestSError -> RequestSError -> Bool
> :: RequestSError -> RequestSError -> Bool
$c>= :: RequestSError -> RequestSError -> Bool
>= :: RequestSError -> RequestSError -> Bool
$cmax :: RequestSError -> RequestSError -> RequestSError
max :: RequestSError -> RequestSError -> RequestSError
$cmin :: RequestSError -> RequestSError -> RequestSError
min :: RequestSError -> RequestSError -> RequestSError
Ord, (forall x. RequestSError -> Rep RequestSError x)
-> (forall x. Rep RequestSError x -> RequestSError)
-> Generic RequestSError
forall x. Rep RequestSError x -> RequestSError
forall x. RequestSError -> Rep RequestSError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RequestSError -> Rep RequestSError x
from :: forall x. RequestSError -> Rep RequestSError x
$cto :: forall x. Rep RequestSError x -> RequestSError
to :: forall x. Rep RequestSError x -> RequestSError
Generic, Int -> RequestSError -> ShowS
[RequestSError] -> ShowS
RequestSError -> String
(Int -> RequestSError -> ShowS)
-> (RequestSError -> String)
-> ([RequestSError] -> ShowS)
-> Show RequestSError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestSError -> ShowS
showsPrec :: Int -> RequestSError -> ShowS
$cshow :: RequestSError -> String
show :: RequestSError -> String
$cshowList :: [RequestSError] -> ShowS
showList :: [RequestSError] -> ShowS
Show)
storeRequest
:: ( HasProtoVersion r
, HasStoreDir r
)
=> NixSerializer r RequestSError (Some StoreRequest)
storeRequest :: forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r RequestSError (Some StoreRequest)
storeRequest = Serializer
{ getS :: SerialT r RequestSError Get (Some StoreRequest)
getS = (SError -> RequestSError)
-> SerialT r SError Get WorkerOp
-> SerialT r RequestSError Get WorkerOp
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST SError -> RequestSError
RequestSError_PrimWorkerOp (Serializer (SerialT r SError) WorkerOp
-> SerialT r SError Get WorkerOp
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp) SerialT r RequestSError Get WorkerOp
-> (WorkerOp -> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b.
SerialT r RequestSError Get a
-> (a -> SerialT r RequestSError Get b)
-> SerialT r RequestSError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
WorkerOp
WorkerOp_AddToStore -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StorePathName
pathName <- Serializer (SerialT r SError) StorePathName
-> SerialT r SError Get StorePathName
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePathName
forall r. NixSerializer r SError StorePathName
storePathName
Bool
_fixed <- Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
FileIngestionMethod
recursive <- Serializer (SerialT r SError) FileIngestionMethod
-> SerialT r SError Get FileIngestionMethod
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) FileIngestionMethod
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
Some HashAlgo
hashAlgo <- Serializer (SerialT r SError) (Some HashAlgo)
-> SerialT r SError Get (Some HashAlgo)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Some HashAlgo)
forall r. NixSerializer r SError (Some HashAlgo)
someHashAlgo
let repair :: RepairMode
repair = RepairMode
RepairMode_DontRepair
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest StorePath -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StorePathName
-> FileIngestionMethod
-> Some HashAlgo
-> RepairMode
-> StoreRequest StorePath
AddToStore StorePathName
pathName FileIngestionMethod
recursive Some HashAlgo
hashAlgo RepairMode
repair)
WorkerOp
WorkerOp_AddToStoreNar -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StorePath
storePath' <- Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
Metadata StorePath
metadata <- Serializer (SerialT r SError) (Metadata StorePath)
-> SerialT r SError Get (Metadata StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Metadata StorePath)
forall r.
HasStoreDir r =>
NixSerializer r SError (Metadata StorePath)
pathMetadata
Bool
repair <- Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
let repairMode :: RepairMode
repairMode = if Bool
repair then RepairMode
RepairMode_DoRepair else RepairMode
RepairMode_DontRepair
Bool
dontCheckSigs <- Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
let checkSigs :: CheckMode
checkSigs = if Bool
dontCheckSigs then CheckMode
CheckMode_DontCheck else CheckMode
CheckMode_DoCheck
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest NoReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StorePath
-> Metadata StorePath
-> RepairMode
-> CheckMode
-> StoreRequest NoReply
AddToStoreNar StorePath
storePath' Metadata StorePath
metadata RepairMode
repairMode CheckMode
checkSigs)
WorkerOp
WorkerOp_AddTextToStore -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreText
txt <- Serializer (SerialT r SError) StoreText
-> SerialT r SError Get StoreText
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StoreText
forall r. NixSerializer r SError StoreText
storeText
HashSet StorePath
paths <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
let repair :: RepairMode
repair = RepairMode
RepairMode_DontRepair
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest StorePath -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreText
-> HashSet StorePath -> RepairMode -> StoreRequest StorePath
AddTextToStore StoreText
txt HashSet StorePath
paths RepairMode
repair)
WorkerOp
WorkerOp_AddSignatures -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StorePath
path <- Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
Set Signature
signatures <- Serializer (SerialT r SError) (Set Signature)
-> SerialT r SError Get (Set Signature)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError Signature
-> Serializer (SerialT r SError) (Set Signature)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError Signature
forall r. NixSerializer r SError Signature
signature)
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StorePath -> Set Signature -> StoreRequest SuccessCodeReply
AddSignatures StorePath
path Set Signature
signatures)
WorkerOp
WorkerOp_AddIndirectRoot -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest SuccessCodeReply -> Some StoreRequest)
-> (StorePath -> StoreRequest SuccessCodeReply)
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest SuccessCodeReply
AddIndirectRoot (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_AddTempRoot -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest SuccessCodeReply -> Some StoreRequest)
-> (StorePath -> StoreRequest SuccessCodeReply)
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest SuccessCodeReply
AddTempRoot (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_BuildPaths -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
Set DerivedPath
derived <- Serializer (SerialT r SError) (Set DerivedPath)
-> SerialT r SError Get (Set DerivedPath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError DerivedPath
-> Serializer (SerialT r SError) (Set DerivedPath)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError DerivedPath
forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r SError DerivedPath
derivedPath)
BuildMode
buildMode' <- Serializer (SerialT r SError) BuildMode
-> SerialT r SError Get BuildMode
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) BuildMode
forall r. NixSerializer r SError BuildMode
buildMode
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (Set DerivedPath -> BuildMode -> StoreRequest SuccessCodeReply
BuildPaths Set DerivedPath
derived BuildMode
buildMode')
WorkerOp
WorkerOp_BuildDerivation -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StorePath
path <- Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
Derivation StorePath Text
drv <- Serializer (SerialT r SError) (Derivation StorePath Text)
-> SerialT r SError Get (Derivation StorePath Text)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Derivation StorePath Text)
forall r.
HasStoreDir r =>
NixSerializer r SError (Derivation StorePath Text)
derivation
BuildMode
buildMode' <- Serializer (SerialT r SError) BuildMode
-> SerialT r SError Get BuildMode
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) BuildMode
forall r. NixSerializer r SError BuildMode
buildMode
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest BuildResult -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StorePath
-> Derivation StorePath Text
-> BuildMode
-> StoreRequest BuildResult
BuildDerivation StorePath
path Derivation StorePath Text
drv BuildMode
buildMode')
WorkerOp
WorkerOp_CollectGarbage -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
GCAction
gcOptionsOperation <- Serializer (SerialT r SError) GCAction
-> SerialT r SError Get GCAction
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) GCAction
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
HashSet StorePath
gcOptionsPathsToDelete <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
Bool
gcOptionsIgnoreLiveness <- Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
Word64
gcOptionsMaxFreed <- Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int
[Word8]
-> (Word8 -> SerialT r SError Get Word8) -> SerialT r SError Get ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
Control.Monad.forM_ [Word8
0..(Word8
2 :: Word8)]
((Word8 -> SerialT r SError Get Word8) -> SerialT r SError Get ())
-> (Word8 -> SerialT r SError Get Word8) -> SerialT r SError Get ()
forall a b. (a -> b) -> a -> b
$ SerialT r SError Get Word8 -> Word8 -> SerialT r SError Get Word8
forall a. a -> Word8 -> a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SerialT r SError Get Word8 -> Word8 -> SerialT r SError Get Word8)
-> SerialT r SError Get Word8
-> Word8
-> SerialT r SError Get Word8
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Word8 -> SerialT r SError Get Word8
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Word8)
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest GCResult -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (GCOptions -> StoreRequest GCResult
CollectGarbage GCOptions{Bool
Word64
HashSet StorePath
GCAction
gcOptionsOperation :: GCAction
gcOptionsPathsToDelete :: HashSet StorePath
gcOptionsIgnoreLiveness :: Bool
gcOptionsMaxFreed :: Word64
gcOptionsOperation :: GCAction
gcOptionsIgnoreLiveness :: Bool
gcOptionsPathsToDelete :: HashSet StorePath
gcOptionsMaxFreed :: Word64
..})
WorkerOp
WorkerOp_EnsurePath -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest SuccessCodeReply -> Some StoreRequest)
-> (StorePath -> StoreRequest SuccessCodeReply)
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest SuccessCodeReply
EnsurePath (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_FindRoots -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest (Map GCRoot StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some StoreRequest (Map GCRoot StorePath)
FindRoots
WorkerOp
WorkerOp_IsValidPath -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest Bool -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest Bool -> Some StoreRequest)
-> (StorePath -> StoreRequest Bool)
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest Bool
IsValidPath (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_NarFromPath -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest NoReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest NoReply -> Some StoreRequest)
-> (StorePath -> StoreRequest NoReply)
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest NoReply
NarFromPath (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_QueryValidPaths -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
HashSet StorePath
paths <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
SubstituteMode
substituteMode <- Serializer (SerialT r SError) SubstituteMode
-> SerialT r SError Get SubstituteMode
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) SubstituteMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest (HashSet StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (HashSet StorePath
-> SubstituteMode -> StoreRequest (HashSet StorePath)
QueryValidPaths HashSet StorePath
paths SubstituteMode
substituteMode)
WorkerOp
WorkerOp_QueryAllValidPaths -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest (HashSet StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some StoreRequest (HashSet StorePath)
QueryAllValidPaths
WorkerOp
WorkerOp_QuerySubstitutablePaths -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest (HashSet StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest (HashSet StorePath) -> Some StoreRequest)
-> (HashSet StorePath -> StoreRequest (HashSet StorePath))
-> HashSet StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashSet StorePath -> StoreRequest (HashSet StorePath)
QuerySubstitutablePaths (HashSet StorePath -> Some StoreRequest)
-> SerialT r SError Get (HashSet StorePath)
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
WorkerOp
WorkerOp_QueryPathInfo -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest (Maybe (Metadata StorePath)) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest (Maybe (Metadata StorePath)) -> Some StoreRequest)
-> (StorePath -> StoreRequest (Maybe (Metadata StorePath)))
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (Maybe (Metadata StorePath))
QueryPathInfo (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_QueryReferrers -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest (HashSet StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest (HashSet StorePath) -> Some StoreRequest)
-> (StorePath -> StoreRequest (HashSet StorePath))
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePath)
QueryReferrers (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_QueryValidDerivers -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest (HashSet StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest (HashSet StorePath) -> Some StoreRequest)
-> (StorePath -> StoreRequest (HashSet StorePath))
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePath)
QueryValidDerivers (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_QueryDerivationOutputs -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest (HashSet StorePath) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest (HashSet StorePath) -> Some StoreRequest)
-> (StorePath -> StoreRequest (HashSet StorePath))
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePath)
QueryDerivationOutputs (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_QueryDerivationOutputNames -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest (HashSet StorePathName) -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest (HashSet StorePathName) -> Some StoreRequest)
-> (StorePath -> StoreRequest (HashSet StorePathName))
-> StorePath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePathName)
QueryDerivationOutputNames (StorePath -> Some StoreRequest)
-> SerialT r SError Get StorePath
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePath
-> SerialT r SError Get StorePath
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath
WorkerOp
WorkerOp_QueryPathFromHashPart -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest StorePath -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest StorePath -> Some StoreRequest)
-> (StorePathHashPart -> StoreRequest StorePath)
-> StorePathHashPart
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePathHashPart -> StoreRequest StorePath
QueryPathFromHashPart (StorePathHashPart -> Some StoreRequest)
-> SerialT r SError Get StorePathHashPart
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) StorePathHashPart
-> SerialT r SError Get StorePathHashPart
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) StorePathHashPart
forall r. NixSerializer r SError StorePathHashPart
storePathHashPart
WorkerOp
WorkerOp_QueryMissing -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
StoreRequest Missing -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (StoreRequest Missing -> Some StoreRequest)
-> (Set DerivedPath -> StoreRequest Missing)
-> Set DerivedPath
-> Some StoreRequest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set DerivedPath -> StoreRequest Missing
QueryMissing (Set DerivedPath -> Some StoreRequest)
-> SerialT r SError Get (Set DerivedPath)
-> SerialT r SError Get (Some StoreRequest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) (Set DerivedPath)
-> SerialT r SError Get (Set DerivedPath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError DerivedPath
-> Serializer (SerialT r SError) (Set DerivedPath)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError DerivedPath
forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r SError DerivedPath
derivedPath)
WorkerOp
WorkerOp_OptimiseStore -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some StoreRequest SuccessCodeReply
OptimiseStore
WorkerOp
WorkerOp_SyncWithGC -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest SuccessCodeReply -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some StoreRequest SuccessCodeReply
SyncWithGC
WorkerOp
WorkerOp_VerifyStore -> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE (SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest))
-> SerialT r SError Get (Some StoreRequest)
-> SerialT r RequestSError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ do
CheckMode
checkMode <- Serializer (SerialT r SError) CheckMode
-> SerialT r SError Get CheckMode
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) CheckMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
RepairMode
repairMode <- Serializer (SerialT r SError) RepairMode
-> SerialT r SError Get RepairMode
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) RepairMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Some StoreRequest -> SerialT r SError Get (Some StoreRequest))
-> Some StoreRequest -> SerialT r SError Get (Some StoreRequest)
forall a b. (a -> b) -> a -> b
$ StoreRequest Bool -> Some StoreRequest
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some (CheckMode -> RepairMode -> StoreRequest Bool
VerifyStore CheckMode
checkMode RepairMode
repairMode)
w :: WorkerOp
w@WorkerOp
WorkerOp_Reserved_0__ -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
reserved WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_Reserved_2__ -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
reserved WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_Reserved_15__ -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
reserved WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_Reserved_17__ -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
reserved WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_AddBuildLog -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_AddMultipleToStore -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_BuildPathsWithResults -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_ClearFailedPaths -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_ExportPath -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_HasSubstitutes -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_ImportPaths -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QueryDerivationOutputMap -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QueryDeriver -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QueryFailedPaths -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QueryPathHash -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QueryRealisation -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QuerySubstitutablePathInfo -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QuerySubstitutablePathInfos -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_QueryReferences -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_RegisterDrvOutput -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
w :: WorkerOp
w@WorkerOp
WorkerOp_SetOptions -> WorkerOp -> SerialT r RequestSError Get (Some StoreRequest)
forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet WorkerOp
w
, putS :: Some StoreRequest -> SerialT r RequestSError PutM ()
putS = \case
Some (AddToStore StorePathName
pathName FileIngestionMethod
recursive Some HashAlgo
hashAlgo RepairMode
_repair) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_AddToStore
Serializer (SerialT r SError) StorePathName
-> StorePathName -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePathName
forall r. NixSerializer r SError StorePathName
storePathName StorePathName
pathName
Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
(Bool -> SerialT r SError PutM ())
-> Bool -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not
(Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Some HashAlgo
hashAlgo Some HashAlgo -> Some HashAlgo -> Bool
forall a. Eq a => a -> a -> Bool
== HashAlgo SHA256 -> Some HashAlgo
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some HashAlgo SHA256
HashAlgo_SHA256
Bool -> Bool -> Bool
&& (FileIngestionMethod
recursive FileIngestionMethod -> FileIngestionMethod -> Bool
forall a. Eq a => a -> a -> Bool
== FileIngestionMethod
FileIngestionMethod_FileRecursive)
Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool (FileIngestionMethod
recursive FileIngestionMethod -> FileIngestionMethod -> Bool
forall a. Eq a => a -> a -> Bool
== FileIngestionMethod
FileIngestionMethod_FileRecursive)
Serializer (SerialT r SError) (Some HashAlgo)
-> Some HashAlgo -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Some HashAlgo)
forall r. NixSerializer r SError (Some HashAlgo)
someHashAlgo Some HashAlgo
hashAlgo
Some (AddToStoreNar StorePath
storePath' Metadata StorePath
metadata RepairMode
repair CheckMode
checkSigs) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_AddToStoreNar
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
storePath'
Serializer (SerialT r SError) (Metadata StorePath)
-> Metadata StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Metadata StorePath)
forall r.
HasStoreDir r =>
NixSerializer r SError (Metadata StorePath)
pathMetadata Metadata StorePath
metadata
Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool (Bool -> SerialT r SError PutM ())
-> Bool -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ RepairMode
repair RepairMode -> RepairMode -> Bool
forall a. Eq a => a -> a -> Bool
== RepairMode
RepairMode_DoRepair
Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool (Bool -> SerialT r SError PutM ())
-> Bool -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ CheckMode
checkSigs CheckMode -> CheckMode -> Bool
forall a. Eq a => a -> a -> Bool
== CheckMode
CheckMode_DontCheck
Some (AddTextToStore StoreText
txt HashSet StorePath
paths RepairMode
_repair) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_AddTextToStore
Serializer (SerialT r SError) StoreText
-> StoreText -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StoreText
forall r. NixSerializer r SError StoreText
storeText StoreText
txt
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
paths
Some (AddSignatures StorePath
path Set Signature
signatures) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_AddSignatures
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Serializer (SerialT r SError) (Set Signature)
-> Set Signature -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError Signature
-> Serializer (SerialT r SError) (Set Signature)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError Signature
forall r. NixSerializer r SError Signature
signature) Set Signature
signatures
Some (AddIndirectRoot StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_AddIndirectRoot
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (AddTempRoot StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_AddTempRoot
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (BuildPaths Set DerivedPath
derived BuildMode
buildMode') -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_BuildPaths
Serializer (SerialT r SError) (Set DerivedPath)
-> Set DerivedPath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError DerivedPath
-> Serializer (SerialT r SError) (Set DerivedPath)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError DerivedPath
forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r SError DerivedPath
derivedPath) Set DerivedPath
derived
Serializer (SerialT r SError) BuildMode
-> BuildMode -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) BuildMode
forall r. NixSerializer r SError BuildMode
buildMode BuildMode
buildMode'
Some (BuildDerivation StorePath
path Derivation StorePath Text
drv BuildMode
buildMode') -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_BuildDerivation
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Serializer (SerialT r SError) (Derivation StorePath Text)
-> Derivation StorePath Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Derivation StorePath Text)
forall r.
HasStoreDir r =>
NixSerializer r SError (Derivation StorePath Text)
derivation Derivation StorePath Text
drv
Serializer (SerialT r SError) BuildMode
-> BuildMode -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) BuildMode
forall r. NixSerializer r SError BuildMode
buildMode BuildMode
buildMode'
Some (CollectGarbage GCOptions{Bool
Word64
HashSet StorePath
GCAction
gcOptionsOperation :: GCOptions -> GCAction
gcOptionsIgnoreLiveness :: GCOptions -> Bool
gcOptionsPathsToDelete :: GCOptions -> HashSet StorePath
gcOptionsMaxFreed :: GCOptions -> Word64
gcOptionsOperation :: GCAction
gcOptionsIgnoreLiveness :: Bool
gcOptionsPathsToDelete :: HashSet StorePath
gcOptionsMaxFreed :: Word64
..}) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_CollectGarbage
Serializer (SerialT r SError) GCAction
-> GCAction -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) GCAction
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum GCAction
gcOptionsOperation
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
gcOptionsPathsToDelete
Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool Bool
gcOptionsIgnoreLiveness
Serializer (SerialT r SError) Word64
-> Word64 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int Word64
gcOptionsMaxFreed
[Word8]
-> (Word8 -> SerialT r SError PutM ()) -> SerialT r SError PutM ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
Control.Monad.forM_ [Word8
0..(Word8
2 :: Word8)]
((Word8 -> SerialT r SError PutM ()) -> SerialT r SError PutM ())
-> (Word8 -> SerialT r SError PutM ()) -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ SerialT r SError PutM () -> Word8 -> SerialT r SError PutM ()
forall a. a -> Word8 -> a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SerialT r SError PutM () -> Word8 -> SerialT r SError PutM ())
-> SerialT r SError PutM () -> Word8 -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Word8
-> Word8 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Word8
forall a r e. Integral a => NixSerializer r e a
int (Word8
0 :: Word8)
Some (EnsurePath StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_EnsurePath
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some StoreRequest a
FindRoots -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_FindRoots
Some (IsValidPath StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_IsValidPath
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (NarFromPath StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_NarFromPath
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (QueryValidPaths HashSet StorePath
paths SubstituteMode
substituteMode) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryValidPaths
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
paths
Serializer (SerialT r SError) SubstituteMode
-> SubstituteMode -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) SubstituteMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum SubstituteMode
substituteMode
Some StoreRequest a
QueryAllValidPaths -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryAllValidPaths
Some (QuerySubstitutablePaths HashSet StorePath
paths) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QuerySubstitutablePaths
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (Serializer (SerialT r SError) StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
paths
Some (QueryPathInfo StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryPathInfo
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (QueryReferrers StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryReferrers
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (QueryValidDerivers StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryValidDerivers
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (QueryDerivationOutputs StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryDerivationOutputs
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (QueryDerivationOutputNames StorePath
path) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryDerivationOutputNames
Serializer (SerialT r SError) StorePath
-> StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath StorePath
path
Some (QueryPathFromHashPart StorePathHashPart
pathHashPart) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryPathFromHashPart
Serializer (SerialT r SError) StorePathHashPart
-> StorePathHashPart -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) StorePathHashPart
forall r. NixSerializer r SError StorePathHashPart
storePathHashPart StorePathHashPart
pathHashPart
Some (QueryMissing Set DerivedPath
derived) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_QueryMissing
Serializer (SerialT r SError) (Set DerivedPath)
-> Set DerivedPath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError DerivedPath
-> Serializer (SerialT r SError) (Set DerivedPath)
forall a r e.
Ord a =>
NixSerializer r e a -> NixSerializer r e (Set a)
set NixSerializer r SError DerivedPath
forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r SError DerivedPath
derivedPath) Set DerivedPath
derived
Some StoreRequest a
OptimiseStore -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_OptimiseStore
Some StoreRequest a
SyncWithGC -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_SyncWithGC
Some (VerifyStore CheckMode
checkMode RepairMode
repairMode) -> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE (SerialT r SError PutM () -> SerialT r RequestSError PutM ())
-> SerialT r SError PutM () -> SerialT r RequestSError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) WorkerOp
-> WorkerOp -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) WorkerOp
forall r. NixSerializer r SError WorkerOp
workerOp WorkerOp
WorkerOp_VerifyStore
Serializer (SerialT r SError) CheckMode
-> CheckMode -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) CheckMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum CheckMode
checkMode
Serializer (SerialT r SError) RepairMode
-> RepairMode -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) RepairMode
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum RepairMode
repairMode
}
where
mapGetE
:: Functor m
=> SerialT r SError m a
-> SerialT r RequestSError m a
mapGetE :: forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapGetE = (SError -> RequestSError)
-> SerialT r SError m a -> SerialT r RequestSError m a
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST SError -> RequestSError
RequestSError_PrimGet
mapPutE
:: Functor m
=> SerialT r SError m a
-> SerialT r RequestSError m a
mapPutE :: forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r RequestSError m a
mapPutE = (SError -> RequestSError)
-> SerialT r SError m a -> SerialT r RequestSError m a
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST SError -> RequestSError
RequestSError_PrimPut
notYet
:: MonadError RequestSError m
=> WorkerOp
-> m a
notYet :: forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
notYet = RequestSError -> m a
forall a. RequestSError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RequestSError -> m a)
-> (WorkerOp -> RequestSError) -> WorkerOp -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WorkerOp -> RequestSError
RequestSError_NotYetImplemented
reserved
:: MonadError RequestSError m
=> WorkerOp
-> m a
reserved :: forall (m :: * -> *) a.
MonadError RequestSError m =>
WorkerOp -> m a
reserved = RequestSError -> m a
forall a. RequestSError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RequestSError -> m a)
-> (WorkerOp -> RequestSError) -> WorkerOp -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WorkerOp -> RequestSError
RequestSError_ReservedOp
data ReplySError
= ReplySError_PrimGet SError
| ReplySError_PrimPut SError
| ReplySError_DerivationOutput SError
| ReplySError_GCResult SError
| ReplySError_Metadata SError
| ReplySError_Missing SError
| ReplySError_Realisation SError
| ReplySError_RealisationWithId SError
| ReplySError_UnexpectedFalseOpSuccess
deriving (ReplySError -> ReplySError -> Bool
(ReplySError -> ReplySError -> Bool)
-> (ReplySError -> ReplySError -> Bool) -> Eq ReplySError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReplySError -> ReplySError -> Bool
== :: ReplySError -> ReplySError -> Bool
$c/= :: ReplySError -> ReplySError -> Bool
/= :: ReplySError -> ReplySError -> Bool
Eq, Eq ReplySError
Eq ReplySError =>
(ReplySError -> ReplySError -> Ordering)
-> (ReplySError -> ReplySError -> Bool)
-> (ReplySError -> ReplySError -> Bool)
-> (ReplySError -> ReplySError -> Bool)
-> (ReplySError -> ReplySError -> Bool)
-> (ReplySError -> ReplySError -> ReplySError)
-> (ReplySError -> ReplySError -> ReplySError)
-> Ord ReplySError
ReplySError -> ReplySError -> Bool
ReplySError -> ReplySError -> Ordering
ReplySError -> ReplySError -> ReplySError
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReplySError -> ReplySError -> Ordering
compare :: ReplySError -> ReplySError -> Ordering
$c< :: ReplySError -> ReplySError -> Bool
< :: ReplySError -> ReplySError -> Bool
$c<= :: ReplySError -> ReplySError -> Bool
<= :: ReplySError -> ReplySError -> Bool
$c> :: ReplySError -> ReplySError -> Bool
> :: ReplySError -> ReplySError -> Bool
$c>= :: ReplySError -> ReplySError -> Bool
>= :: ReplySError -> ReplySError -> Bool
$cmax :: ReplySError -> ReplySError -> ReplySError
max :: ReplySError -> ReplySError -> ReplySError
$cmin :: ReplySError -> ReplySError -> ReplySError
min :: ReplySError -> ReplySError -> ReplySError
Ord, (forall x. ReplySError -> Rep ReplySError x)
-> (forall x. Rep ReplySError x -> ReplySError)
-> Generic ReplySError
forall x. Rep ReplySError x -> ReplySError
forall x. ReplySError -> Rep ReplySError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ReplySError -> Rep ReplySError x
from :: forall x. ReplySError -> Rep ReplySError x
$cto :: forall x. Rep ReplySError x -> ReplySError
to :: forall x. Rep ReplySError x -> ReplySError
Generic, Int -> ReplySError -> ShowS
[ReplySError] -> ShowS
ReplySError -> String
(Int -> ReplySError -> ShowS)
-> (ReplySError -> String)
-> ([ReplySError] -> ShowS)
-> Show ReplySError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReplySError -> ShowS
showsPrec :: Int -> ReplySError -> ShowS
$cshow :: ReplySError -> String
show :: ReplySError -> String
$cshowList :: [ReplySError] -> ShowS
showList :: [ReplySError] -> ShowS
Show)
mapGetER
:: Functor m
=> SerialT r SError m a
-> SerialT r ReplySError m a
mapGetER :: forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapGetER = (SError -> ReplySError)
-> SerialT r SError m a -> SerialT r ReplySError m a
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST SError -> ReplySError
ReplySError_PrimGet
mapPutER
:: Functor m
=> SerialT r SError m a
-> SerialT r ReplySError m a
mapPutER :: forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapPutER = (SError -> ReplySError)
-> SerialT r SError m a -> SerialT r ReplySError m a
forall (m :: * -> *) e e' r a.
Functor m =>
(e -> e') -> SerialT r e m a -> SerialT r e' m a
mapErrorST SError -> ReplySError
ReplySError_PrimPut
opSuccess :: NixSerializer r ReplySError SuccessCodeReply
opSuccess :: forall r. NixSerializer r ReplySError SuccessCodeReply
opSuccess = Serializer
{ getS :: SerialT r ReplySError Get SuccessCodeReply
getS = do
Bool
retCode <- SerialT r SError Get Bool -> SerialT r ReplySError Get Bool
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapGetER (SerialT r SError Get Bool -> SerialT r ReplySError Get Bool)
-> SerialT r SError Get Bool -> SerialT r ReplySError Get Bool
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
Bool
-> SerialT r ReplySError Get () -> SerialT r ReplySError Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.unless
(Bool
retCode Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
True)
(SerialT r ReplySError Get () -> SerialT r ReplySError Get ())
-> SerialT r ReplySError Get () -> SerialT r ReplySError Get ()
forall a b. (a -> b) -> a -> b
$ ReplySError -> SerialT r ReplySError Get ()
forall a. ReplySError -> SerialT r ReplySError Get a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError ReplySError
ReplySError_UnexpectedFalseOpSuccess
SuccessCodeReply -> SerialT r ReplySError Get SuccessCodeReply
forall a. a -> SerialT r ReplySError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SuccessCodeReply
SuccessCodeReply
, putS :: SuccessCodeReply -> SerialT r ReplySError PutM ()
putS = \SuccessCodeReply
_ -> SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapPutER (SerialT r SError PutM () -> SerialT r ReplySError PutM ())
-> SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool Bool
True
}
noop :: a -> NixSerializer r ReplySError a
noop :: forall a r. a -> NixSerializer r ReplySError a
noop a
ret = Serializer
{ getS :: SerialT r ReplySError Get a
getS = a -> SerialT r ReplySError Get a
forall a. a -> SerialT r ReplySError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
ret
, putS :: a -> SerialT r ReplySError PutM ()
putS = \a
_ -> () -> SerialT r ReplySError PutM ()
forall a. a -> SerialT r ReplySError PutM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
}
derivationOutputTyped :: NixSerializer r ReplySError (System.Nix.Realisation.DerivationOutput OutputName)
derivationOutputTyped :: forall r. NixSerializer r ReplySError (DerivationOutput OutputName)
derivationOutputTyped = (SError -> ReplySError)
-> NixSerializer r SError (DerivationOutput OutputName)
-> NixSerializer r ReplySError (DerivationOutput OutputName)
forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS SError -> ReplySError
ReplySError_DerivationOutput (NixSerializer r SError (DerivationOutput OutputName)
-> NixSerializer r ReplySError (DerivationOutput OutputName))
-> NixSerializer r SError (DerivationOutput OutputName)
-> NixSerializer r ReplySError (DerivationOutput OutputName)
forall a b. (a -> b) -> a -> b
$
(Text -> Either SError (DerivationOutput OutputName))
-> (DerivationOutput OutputName -> Text)
-> Serializer (SerialT r SError) Text
-> NixSerializer r SError (DerivationOutput OutputName)
forall eGet (t :: (* -> *) -> * -> *) a b.
MonadError eGet (t Get) =>
(a -> Either eGet b)
-> (b -> a) -> Serializer t a -> Serializer t b
mapPrismSerializer
( (DerivationOutputError -> SError)
-> Either DerivationOutputError (DerivationOutput OutputName)
-> Either SError (DerivationOutput OutputName)
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
Data.Bifunctor.first DerivationOutputError -> SError
SError_DerivationOutput
(Either DerivationOutputError (DerivationOutput OutputName)
-> Either SError (DerivationOutput OutputName))
-> (Text
-> Either DerivationOutputError (DerivationOutput OutputName))
-> Text
-> Either SError (DerivationOutput OutputName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Either InvalidNameError OutputName)
-> Text
-> Either DerivationOutputError (DerivationOutput OutputName)
forall outputName.
(Text -> Either InvalidNameError outputName)
-> Text
-> Either DerivationOutputError (DerivationOutput outputName)
System.Nix.Realisation.derivationOutputParser
Text -> Either InvalidNameError OutputName
System.Nix.OutputName.mkOutputName
)
( Text -> Text
Data.Text.Lazy.toStrict
(Text -> Text)
-> (DerivationOutput OutputName -> Text)
-> DerivationOutput OutputName
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Text
Data.Text.Lazy.Builder.toLazyText
(Builder -> Text)
-> (DerivationOutput OutputName -> Builder)
-> DerivationOutput OutputName
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (OutputName -> Text) -> DerivationOutput OutputName -> Builder
forall outputName.
(outputName -> Text) -> DerivationOutput outputName -> Builder
System.Nix.Realisation.derivationOutputBuilder
OutputName -> Text
System.Nix.OutputName.unOutputName
)
Serializer (SerialT r SError) Text
forall r. NixSerializer r SError Text
text
realisation :: NixSerializer r ReplySError Realisation
realisation :: forall r. NixSerializer r ReplySError Realisation
realisation = (SError -> ReplySError)
-> NixSerializer r SError Realisation
-> NixSerializer r ReplySError Realisation
forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS SError -> ReplySError
ReplySError_Realisation NixSerializer r SError Realisation
forall a r. (FromJSON a, ToJSON a) => NixSerializer r SError a
json
realisationWithId :: NixSerializer r ReplySError RealisationWithId
realisationWithId :: forall r. NixSerializer r ReplySError RealisationWithId
realisationWithId = (SError -> ReplySError)
-> NixSerializer r SError RealisationWithId
-> NixSerializer r ReplySError RealisationWithId
forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS SError -> ReplySError
ReplySError_RealisationWithId NixSerializer r SError RealisationWithId
forall a r. (FromJSON a, ToJSON a) => NixSerializer r SError a
json
buildResult
:: ( HasProtoVersion r
, HasStoreDir r
)
=> NixSerializer r ReplySError BuildResult
buildResult :: forall r.
(HasProtoVersion r, HasStoreDir r) =>
NixSerializer r ReplySError BuildResult
buildResult = Serializer
{ getS :: SerialT r ReplySError Get BuildResult
getS = do
ProtoVersion
pv <- (r -> ProtoVersion) -> SerialT r ReplySError Get ProtoVersion
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> ProtoVersion
forall r. HasProtoVersion r => r -> ProtoVersion
hasProtoVersion
BuildStatus
buildResultStatus <- SerialT r SError Get BuildStatus
-> SerialT r ReplySError Get BuildStatus
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapGetER (SerialT r SError Get BuildStatus
-> SerialT r ReplySError Get BuildStatus)
-> SerialT r SError Get BuildStatus
-> SerialT r ReplySError Get BuildStatus
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) BuildStatus
-> SerialT r SError Get BuildStatus
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) BuildStatus
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum
Maybe Text
buildResultErrorMessage <- SerialT r SError Get (Maybe Text)
-> SerialT r ReplySError Get (Maybe Text)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapGetER (SerialT r SError Get (Maybe Text)
-> SerialT r ReplySError Get (Maybe Text))
-> SerialT r SError Get (Maybe Text)
-> SerialT r ReplySError Get (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) (Maybe Text)
-> SerialT r SError Get (Maybe Text)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Maybe Text)
forall r. NixSerializer r SError (Maybe Text)
maybeText
( Maybe Int
buildResultTimesBuilt
, Maybe Bool
buildResultIsNonDeterministic
, Maybe UTCTime
buildResultStartTime
, Maybe UTCTime
buildResultStopTime
) <-
if ProtoVersion -> Word8
protoVersion_minor ProtoVersion
pv Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
29
then SerialT
r SError Get (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r
ReplySError
Get
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapGetER (SerialT
r SError Get (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r
ReplySError
Get
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime))
-> SerialT
r SError Get (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r
ReplySError
Get
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
forall a b. (a -> b) -> a -> b
$ do
Maybe Int
tb <- (\case Int
0 -> Maybe Int
forall a. Maybe a
Nothing; Int
x -> Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x) (Int -> Maybe Int)
-> SerialT r SError Get Int -> SerialT r SError Get (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) Int -> SerialT r SError Get Int
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int
Bool
nondet <- Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
Maybe UTCTime
start <- (\case UTCTime
x | UTCTime
x UTCTime -> UTCTime -> Bool
forall a. Eq a => a -> a -> Bool
== UTCTime
t0 -> Maybe UTCTime
forall a. Maybe a
Nothing; UTCTime
x -> UTCTime -> Maybe UTCTime
forall a. a -> Maybe a
Just UTCTime
x) (UTCTime -> Maybe UTCTime)
-> SerialT r SError Get UTCTime
-> SerialT r SError Get (Maybe UTCTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) UTCTime
-> SerialT r SError Get UTCTime
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) UTCTime
forall r e. NixSerializer r e UTCTime
time
Maybe UTCTime
end <- (\case UTCTime
x | UTCTime
x UTCTime -> UTCTime -> Bool
forall a. Eq a => a -> a -> Bool
== UTCTime
t0 -> Maybe UTCTime
forall a. Maybe a
Nothing; UTCTime
x -> UTCTime -> Maybe UTCTime
forall a. a -> Maybe a
Just UTCTime
x) (UTCTime -> Maybe UTCTime)
-> SerialT r SError Get UTCTime
-> SerialT r SError Get (Maybe UTCTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) UTCTime
-> SerialT r SError Get UTCTime
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) UTCTime
forall r e. NixSerializer r e UTCTime
time
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r SError Get (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r SError Get (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime))
-> (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r SError Get (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
forall a b. (a -> b) -> a -> b
$ (Maybe Int
tb, Bool -> Maybe Bool
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
nondet, Maybe UTCTime
start, Maybe UTCTime
end)
else (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r
ReplySError
Get
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
forall a. a -> SerialT r ReplySError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r
ReplySError
Get
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime))
-> (Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
-> SerialT
r
ReplySError
Get
(Maybe Int, Maybe Bool, Maybe UTCTime, Maybe UTCTime)
forall a b. (a -> b) -> a -> b
$ (Maybe Int
forall a. Maybe a
Nothing, Maybe Bool
forall a. Maybe a
Nothing, Maybe UTCTime
forall a. Maybe a
Nothing, Maybe UTCTime
forall a. Maybe a
Nothing)
Maybe (Map (DerivationOutput OutputName) Realisation)
buildResultBuiltOutputs <-
if ProtoVersion -> Word8
protoVersion_minor ProtoVersion
pv Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
28
then
Map (DerivationOutput OutputName) Realisation
-> Maybe (Map (DerivationOutput OutputName) Realisation)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(Map (DerivationOutput OutputName) Realisation
-> Maybe (Map (DerivationOutput OutputName) Realisation))
-> (Map (DerivationOutput OutputName) RealisationWithId
-> Map (DerivationOutput OutputName) Realisation)
-> Map (DerivationOutput OutputName) RealisationWithId
-> Maybe (Map (DerivationOutput OutputName) Realisation)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(DerivationOutput OutputName, Realisation)]
-> Map (DerivationOutput OutputName) Realisation
forall k a. Ord k => [(k, a)] -> Map k a
Data.Map.Strict.fromList
([(DerivationOutput OutputName, Realisation)]
-> Map (DerivationOutput OutputName) Realisation)
-> (Map (DerivationOutput OutputName) RealisationWithId
-> [(DerivationOutput OutputName, Realisation)])
-> Map (DerivationOutput OutputName) RealisationWithId
-> Map (DerivationOutput OutputName) Realisation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((DerivationOutput OutputName, RealisationWithId)
-> (DerivationOutput OutputName, Realisation))
-> [(DerivationOutput OutputName, RealisationWithId)]
-> [(DerivationOutput OutputName, Realisation)]
forall a b. (a -> b) -> [a] -> [b]
map (\(DerivationOutput OutputName
_, RealisationWithId (DerivationOutput OutputName
a, Realisation
b)) -> (DerivationOutput OutputName
a, Realisation
b))
([(DerivationOutput OutputName, RealisationWithId)]
-> [(DerivationOutput OutputName, Realisation)])
-> (Map (DerivationOutput OutputName) RealisationWithId
-> [(DerivationOutput OutputName, RealisationWithId)])
-> Map (DerivationOutput OutputName) RealisationWithId
-> [(DerivationOutput OutputName, Realisation)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map (DerivationOutput OutputName) RealisationWithId
-> [(DerivationOutput OutputName, RealisationWithId)]
forall k a. Map k a -> [(k, a)]
Data.Map.Strict.toList
(Map (DerivationOutput OutputName) RealisationWithId
-> Maybe (Map (DerivationOutput OutputName) Realisation))
-> SerialT
r
ReplySError
Get
(Map (DerivationOutput OutputName) RealisationWithId)
-> SerialT
r
ReplySError
Get
(Maybe (Map (DerivationOutput OutputName) Realisation))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer
(SerialT r ReplySError)
(Map (DerivationOutput OutputName) RealisationWithId)
-> SerialT
r
ReplySError
Get
(Map (DerivationOutput OutputName) RealisationWithId)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r ReplySError (DerivationOutput OutputName)
-> NixSerializer r ReplySError RealisationWithId
-> Serializer
(SerialT r ReplySError)
(Map (DerivationOutput OutputName) RealisationWithId)
forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r ReplySError (DerivationOutput OutputName)
forall r. NixSerializer r ReplySError (DerivationOutput OutputName)
derivationOutputTyped NixSerializer r ReplySError RealisationWithId
forall r. NixSerializer r ReplySError RealisationWithId
realisationWithId)
else Maybe (Map (DerivationOutput OutputName) Realisation)
-> SerialT
r
ReplySError
Get
(Maybe (Map (DerivationOutput OutputName) Realisation))
forall a. a -> SerialT r ReplySError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Map (DerivationOutput OutputName) Realisation)
forall a. Maybe a
Nothing
BuildResult -> SerialT r ReplySError Get BuildResult
forall a. a -> SerialT r ReplySError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BuildResult{Maybe Bool
Maybe Int
Maybe (Map (DerivationOutput OutputName) Realisation)
Maybe Text
Maybe UTCTime
BuildStatus
buildResultStatus :: BuildStatus
buildResultErrorMessage :: Maybe Text
buildResultTimesBuilt :: Maybe Int
buildResultIsNonDeterministic :: Maybe Bool
buildResultStartTime :: Maybe UTCTime
buildResultStopTime :: Maybe UTCTime
buildResultBuiltOutputs :: Maybe (Map (DerivationOutput OutputName) Realisation)
buildResultStatus :: BuildStatus
buildResultErrorMessage :: Maybe Text
buildResultTimesBuilt :: Maybe Int
buildResultIsNonDeterministic :: Maybe Bool
buildResultStartTime :: Maybe UTCTime
buildResultStopTime :: Maybe UTCTime
buildResultBuiltOutputs :: Maybe (Map (DerivationOutput OutputName) Realisation)
..}
, putS :: BuildResult -> SerialT r ReplySError PutM ()
putS = \BuildResult{Maybe Bool
Maybe Int
Maybe (Map (DerivationOutput OutputName) Realisation)
Maybe Text
Maybe UTCTime
BuildStatus
buildResultStatus :: BuildResult -> BuildStatus
buildResultErrorMessage :: BuildResult -> Maybe Text
buildResultTimesBuilt :: BuildResult -> Maybe Int
buildResultIsNonDeterministic :: BuildResult -> Maybe Bool
buildResultStartTime :: BuildResult -> Maybe UTCTime
buildResultStopTime :: BuildResult -> Maybe UTCTime
buildResultBuiltOutputs :: BuildResult
-> Maybe (Map (DerivationOutput OutputName) Realisation)
buildResultStatus :: BuildStatus
buildResultErrorMessage :: Maybe Text
buildResultTimesBuilt :: Maybe Int
buildResultIsNonDeterministic :: Maybe Bool
buildResultStartTime :: Maybe UTCTime
buildResultStopTime :: Maybe UTCTime
buildResultBuiltOutputs :: Maybe (Map (DerivationOutput OutputName) Realisation)
..} -> do
ProtoVersion
pv <- (r -> ProtoVersion) -> SerialT r ReplySError PutM ProtoVersion
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
Control.Monad.Reader.asks r -> ProtoVersion
forall r. HasProtoVersion r => r -> ProtoVersion
hasProtoVersion
SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapPutER (SerialT r SError PutM () -> SerialT r ReplySError PutM ())
-> SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) BuildStatus
-> BuildStatus -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) BuildStatus
forall a r. (Bounded a, Enum a) => NixSerializer r SError a
enum BuildStatus
buildResultStatus
SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapPutER (SerialT r SError PutM () -> SerialT r ReplySError PutM ())
-> SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) (Maybe Text)
-> Maybe Text -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Maybe Text)
forall r. NixSerializer r SError (Maybe Text)
maybeText Maybe Text
buildResultErrorMessage
Bool
-> SerialT r ReplySError PutM () -> SerialT r ReplySError PutM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.when (ProtoVersion -> Word8
protoVersion_minor ProtoVersion
pv Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
29) (SerialT r ReplySError PutM () -> SerialT r ReplySError PutM ())
-> SerialT r ReplySError PutM () -> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapPutER (SerialT r SError PutM () -> SerialT r ReplySError PutM ())
-> SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) Int
-> Int -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Int
forall a r e. Integral a => NixSerializer r e a
int (Int -> SerialT r SError PutM ())
-> Int -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Int
0 Maybe Int
buildResultTimesBuilt
Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool (Bool -> SerialT r SError PutM ())
-> Bool -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Bool
False Maybe Bool
buildResultIsNonDeterministic
Serializer (SerialT r SError) UTCTime
-> UTCTime -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) UTCTime
forall r e. NixSerializer r e UTCTime
time (UTCTime -> SerialT r SError PutM ())
-> UTCTime -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ UTCTime -> Maybe UTCTime -> UTCTime
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe UTCTime
t0 Maybe UTCTime
buildResultStartTime
Serializer (SerialT r SError) UTCTime
-> UTCTime -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) UTCTime
forall r e. NixSerializer r e UTCTime
time (UTCTime -> SerialT r SError PutM ())
-> UTCTime -> SerialT r SError PutM ()
forall a b. (a -> b) -> a -> b
$ UTCTime -> Maybe UTCTime -> UTCTime
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe UTCTime
t0 Maybe UTCTime
buildResultStopTime
Bool
-> SerialT r ReplySError PutM () -> SerialT r ReplySError PutM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.when (ProtoVersion -> Word8
protoVersion_minor ProtoVersion
pv Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
28)
(SerialT r ReplySError PutM () -> SerialT r ReplySError PutM ())
-> SerialT r ReplySError PutM () -> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ Serializer
(SerialT r ReplySError)
(Map (DerivationOutput OutputName) RealisationWithId)
-> Map (DerivationOutput OutputName) RealisationWithId
-> SerialT r ReplySError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r ReplySError (DerivationOutput OutputName)
-> NixSerializer r ReplySError RealisationWithId
-> Serializer
(SerialT r ReplySError)
(Map (DerivationOutput OutputName) RealisationWithId)
forall k r e v.
Ord k =>
NixSerializer r e k
-> NixSerializer r e v -> NixSerializer r e (Map k v)
mapS NixSerializer r ReplySError (DerivationOutput OutputName)
forall r. NixSerializer r ReplySError (DerivationOutput OutputName)
derivationOutputTyped NixSerializer r ReplySError RealisationWithId
forall r. NixSerializer r ReplySError RealisationWithId
realisationWithId)
(Map (DerivationOutput OutputName) RealisationWithId
-> SerialT r ReplySError PutM ())
-> Map (DerivationOutput OutputName) RealisationWithId
-> SerialT r ReplySError PutM ()
forall a b. (a -> b) -> a -> b
$ [(DerivationOutput OutputName, RealisationWithId)]
-> Map (DerivationOutput OutputName) RealisationWithId
forall k a. Ord k => [(k, a)] -> Map k a
Data.Map.Strict.fromList
([(DerivationOutput OutputName, RealisationWithId)]
-> Map (DerivationOutput OutputName) RealisationWithId)
-> [(DerivationOutput OutputName, RealisationWithId)]
-> Map (DerivationOutput OutputName) RealisationWithId
forall a b. (a -> b) -> a -> b
$ ((DerivationOutput OutputName, Realisation)
-> (DerivationOutput OutputName, RealisationWithId))
-> [(DerivationOutput OutputName, Realisation)]
-> [(DerivationOutput OutputName, RealisationWithId)]
forall a b. (a -> b) -> [a] -> [b]
map (\(DerivationOutput OutputName
a, Realisation
b) -> (DerivationOutput OutputName
a, (DerivationOutput OutputName, Realisation) -> RealisationWithId
RealisationWithId (DerivationOutput OutputName
a, Realisation
b)))
([(DerivationOutput OutputName, Realisation)]
-> [(DerivationOutput OutputName, RealisationWithId)])
-> [(DerivationOutput OutputName, Realisation)]
-> [(DerivationOutput OutputName, RealisationWithId)]
forall a b. (a -> b) -> a -> b
$ Map (DerivationOutput OutputName) Realisation
-> [(DerivationOutput OutputName, Realisation)]
forall k a. Map k a -> [(k, a)]
Data.Map.Strict.toList
(Map (DerivationOutput OutputName) Realisation
-> [(DerivationOutput OutputName, Realisation)])
-> Map (DerivationOutput OutputName) Realisation
-> [(DerivationOutput OutputName, Realisation)]
forall a b. (a -> b) -> a -> b
$ Map (DerivationOutput OutputName) Realisation
-> Maybe (Map (DerivationOutput OutputName) Realisation)
-> Map (DerivationOutput OutputName) Realisation
forall a. a -> Maybe a -> a
Data.Maybe.fromMaybe Map (DerivationOutput OutputName) Realisation
forall a. Monoid a => a
mempty Maybe (Map (DerivationOutput OutputName) Realisation)
buildResultBuiltOutputs
}
where
t0 :: UTCTime
t0 :: UTCTime
t0 = NominalDiffTime -> UTCTime
Data.Time.Clock.POSIX.posixSecondsToUTCTime NominalDiffTime
0
gcResult
:: HasStoreDir r
=> NixSerializer r ReplySError GCResult
gcResult :: forall r. HasStoreDir r => NixSerializer r ReplySError GCResult
gcResult = (SError -> ReplySError)
-> NixSerializer r SError GCResult
-> NixSerializer r ReplySError GCResult
forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS SError -> ReplySError
ReplySError_GCResult (NixSerializer r SError GCResult
-> NixSerializer r ReplySError GCResult)
-> NixSerializer r SError GCResult
-> NixSerializer r ReplySError GCResult
forall a b. (a -> b) -> a -> b
$ Serializer
{ getS :: SerialT r SError Get GCResult
getS = do
HashSet StorePath
gcResultDeletedPaths <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
Word64
gcResultBytesFreed <- Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int
SerialT r SError Get Word64 -> SerialT r SError Get ()
forall (f :: * -> *) a. Functor f => f a -> f ()
Control.Monad.void (SerialT r SError Get Word64 -> SerialT r SError Get ())
-> SerialT r SError Get Word64 -> SerialT r SError Get ()
forall a b. (a -> b) -> a -> b
$ Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (forall a r e. Integral a => NixSerializer r e a
int @Word64)
GCResult -> SerialT r SError Get GCResult
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure GCResult{Word64
HashSet StorePath
gcResultDeletedPaths :: HashSet StorePath
gcResultBytesFreed :: Word64
gcResultDeletedPaths :: HashSet StorePath
gcResultBytesFreed :: Word64
..}
, putS :: GCResult -> SerialT r SError PutM ()
putS = \GCResult{Word64
HashSet StorePath
gcResultDeletedPaths :: GCResult -> HashSet StorePath
gcResultBytesFreed :: GCResult -> Word64
gcResultDeletedPaths :: HashSet StorePath
gcResultBytesFreed :: Word64
..} -> do
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
gcResultDeletedPaths
Serializer (SerialT r SError) Word64
-> Word64 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int Word64
gcResultBytesFreed
Serializer (SerialT r SError) Word64
-> Word64 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (forall a r e. Integral a => NixSerializer r e a
int @Word64) Word64
0
}
gcRoot :: NixSerializer r ReplySError GCRoot
gcRoot :: forall r. NixSerializer r ReplySError GCRoot
gcRoot = Serializer
{ getS :: SerialT r ReplySError Get GCRoot
getS = SerialT r SError Get GCRoot -> SerialT r ReplySError Get GCRoot
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapGetER (SerialT r SError Get GCRoot -> SerialT r ReplySError Get GCRoot)
-> SerialT r SError Get GCRoot -> SerialT r ReplySError Get GCRoot
forall a b. (a -> b) -> a -> b
$ do
Serializer (SerialT r SError) ByteString
-> SerialT r SError Get ByteString
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString SerialT r SError Get ByteString
-> (ByteString -> SerialT r SError Get GCRoot)
-> SerialT r SError Get GCRoot
forall a b.
SerialT r SError Get a
-> (a -> SerialT r SError Get b) -> SerialT r SError Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
ByteString
p | ByteString
p ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
censored -> GCRoot -> SerialT r SError Get GCRoot
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure GCRoot
GCRoot_Censored
ByteString
p -> GCRoot -> SerialT r SError Get GCRoot
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ByteString -> GCRoot
GCRoot_Path ByteString
p)
, putS :: GCRoot -> SerialT r ReplySError PutM ()
putS = SerialT r SError PutM () -> SerialT r ReplySError PutM ()
forall (m :: * -> *) r a.
Functor m =>
SerialT r SError m a -> SerialT r ReplySError m a
mapPutER (SerialT r SError PutM () -> SerialT r ReplySError PutM ())
-> (GCRoot -> SerialT r SError PutM ())
-> GCRoot
-> SerialT r ReplySError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Serializer (SerialT r SError) ByteString
-> ByteString -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) ByteString
forall r. NixSerializer r SError ByteString
byteString (ByteString -> SerialT r SError PutM ())
-> (GCRoot -> ByteString) -> GCRoot -> SerialT r SError PutM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
GCRoot
GCRoot_Censored -> ByteString
censored
GCRoot_Path ByteString
p -> ByteString
p
}
where censored :: ByteString
censored = String -> ByteString
Data.ByteString.Char8.pack String
"{censored}"
missing
:: HasStoreDir r
=> NixSerializer r ReplySError Missing
missing :: forall r. HasStoreDir r => NixSerializer r ReplySError Missing
missing = (SError -> ReplySError)
-> NixSerializer r SError Missing
-> NixSerializer r ReplySError Missing
forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS SError -> ReplySError
ReplySError_Missing (NixSerializer r SError Missing
-> NixSerializer r ReplySError Missing)
-> NixSerializer r SError Missing
-> NixSerializer r ReplySError Missing
forall a b. (a -> b) -> a -> b
$ Serializer
{ getS :: SerialT r SError Get Missing
getS = do
HashSet StorePath
missingWillBuild <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
HashSet StorePath
missingWillSubstitute <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
HashSet StorePath
missingUnknownPaths <- Serializer (SerialT r SError) (HashSet StorePath)
-> SerialT r SError Get (HashSet StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath)
Word64
missingDownloadSize <- Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int
Word64
missingNarSize <- Serializer (SerialT r SError) Word64 -> SerialT r SError Get Word64
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int
Missing -> SerialT r SError Get Missing
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Missing{Word64
HashSet StorePath
missingWillBuild :: HashSet StorePath
missingWillSubstitute :: HashSet StorePath
missingUnknownPaths :: HashSet StorePath
missingDownloadSize :: Word64
missingNarSize :: Word64
missingWillBuild :: HashSet StorePath
missingWillSubstitute :: HashSet StorePath
missingUnknownPaths :: HashSet StorePath
missingDownloadSize :: Word64
missingNarSize :: Word64
..}
, putS :: Missing -> SerialT r SError PutM ()
putS = \Missing{Word64
HashSet StorePath
missingWillBuild :: Missing -> HashSet StorePath
missingWillSubstitute :: Missing -> HashSet StorePath
missingUnknownPaths :: Missing -> HashSet StorePath
missingDownloadSize :: Missing -> Word64
missingNarSize :: Missing -> Word64
missingWillBuild :: HashSet StorePath
missingWillSubstitute :: HashSet StorePath
missingUnknownPaths :: HashSet StorePath
missingDownloadSize :: Word64
missingNarSize :: Word64
..} -> do
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
missingWillBuild
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
missingWillSubstitute
Serializer (SerialT r SError) (HashSet StorePath)
-> HashSet StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS (NixSerializer r SError StorePath
-> Serializer (SerialT r SError) (HashSet StorePath)
forall a r e.
(Eq a, Hashable a) =>
NixSerializer r e a -> NixSerializer r e (HashSet a)
hashSet NixSerializer r SError StorePath
forall r. HasStoreDir r => NixSerializer r SError StorePath
storePath) HashSet StorePath
missingUnknownPaths
Serializer (SerialT r SError) Word64
-> Word64 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int Word64
missingDownloadSize
Serializer (SerialT r SError) Word64
-> Word64 -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Word64
forall a r e. Integral a => NixSerializer r e a
int Word64
missingNarSize
}
maybePathMetadata
:: HasStoreDir r
=> NixSerializer r ReplySError (Maybe (Metadata StorePath))
maybePathMetadata :: forall r.
HasStoreDir r =>
NixSerializer r ReplySError (Maybe (Metadata StorePath))
maybePathMetadata = (SError -> ReplySError)
-> NixSerializer r SError (Maybe (Metadata StorePath))
-> NixSerializer r ReplySError (Maybe (Metadata StorePath))
forall e e' r a.
(e -> e') -> NixSerializer r e a -> NixSerializer r e' a
mapErrorS SError -> ReplySError
ReplySError_Metadata (NixSerializer r SError (Maybe (Metadata StorePath))
-> NixSerializer r ReplySError (Maybe (Metadata StorePath)))
-> NixSerializer r SError (Maybe (Metadata StorePath))
-> NixSerializer r ReplySError (Maybe (Metadata StorePath))
forall a b. (a -> b) -> a -> b
$ Serializer
{ getS :: SerialT r SError Get (Maybe (Metadata StorePath))
getS = do
Bool
valid <- Serializer (SerialT r SError) Bool -> SerialT r SError Get Bool
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool
if Bool
valid
then Metadata StorePath -> Maybe (Metadata StorePath)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Metadata StorePath -> Maybe (Metadata StorePath))
-> SerialT r SError Get (Metadata StorePath)
-> SerialT r SError Get (Maybe (Metadata StorePath))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Serializer (SerialT r SError) (Metadata StorePath)
-> SerialT r SError Get (Metadata StorePath)
forall (t :: (* -> *) -> * -> *) a. Serializer t a -> t Get a
getS Serializer (SerialT r SError) (Metadata StorePath)
forall r.
HasStoreDir r =>
NixSerializer r SError (Metadata StorePath)
pathMetadata
else Maybe (Metadata StorePath)
-> SerialT r SError Get (Maybe (Metadata StorePath))
forall a. a -> SerialT r SError Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Metadata StorePath)
forall a. Maybe a
Nothing
, putS :: Maybe (Metadata StorePath) -> SerialT r SError PutM ()
putS = \case
Maybe (Metadata StorePath)
Nothing -> Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool Bool
False
Just Metadata StorePath
pm -> Serializer (SerialT r SError) Bool
-> Bool -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) Bool
forall r. NixSerializer r SError Bool
bool Bool
True SerialT r SError PutM ()
-> SerialT r SError PutM () -> SerialT r SError PutM ()
forall a b.
SerialT r SError PutM a
-> SerialT r SError PutM b -> SerialT r SError PutM b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Serializer (SerialT r SError) (Metadata StorePath)
-> Metadata StorePath -> SerialT r SError PutM ()
forall (t :: (* -> *) -> * -> *) a.
Serializer t a -> a -> t PutM ()
putS Serializer (SerialT r SError) (Metadata StorePath)
forall r.
HasStoreDir r =>
NixSerializer r SError (Metadata StorePath)
pathMetadata Metadata StorePath
pm
}