{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-|
Description : NixSerializer
Copyright   : (c) John Ericson, 2023
                  Sorki, 2023
|-}

module System.Nix.Store.Remote.Serializer
  (
  -- * NixSerializer
    NixSerializer
  , mapReaderS
  , mapErrorS
  -- * Errors
  , SError(..)
  -- ** Runners
  , runSerialT
  , runG
  , runP
  -- * Primitives
  , int
  , bool
  , byteString
  , enum
  , text
  , maybeText
  -- * UTCTime
  , time
  -- * Combinators
  , list
  , set
  , hashSet
  , mapS
  , vector
  , json
  -- * ProtoVersion
  , protoVersion
  -- * StorePath
  , storePath
  , maybePath
  , storePathHashPart
  , storePathName
  -- * Metadata
  , pathMetadata
  -- * OutputName
  , outputName
  -- * Signatures
  , signature
  , narSignature
  -- * Some HashAlgo
  , someHashAlgo
  -- * Digest
  , digest
  -- * DSum HashAlgo Digest
  , namedDigest
  -- * Derivation
  , derivation
  -- * Derivation
  , derivedPath
  -- * Build
  , buildMode
  -- * Logger
  , LoggerSError(..)
  , activityID
  , maybeActivity
  , activity
  , activityResult
  , field
  , trace
  , basicError
  , errorInfo
  , loggerOpCode
  , logger
  , verbosity
  -- * Handshake
  , HandshakeSError(..)
  , workerMagic
  , trustedFlag
  -- * Worker protocol
  , storeText
  , workerOp
  -- ** Request
  , RequestSError(..)
  , storeRequest
  -- ** Reply
  , ReplySError(..)
  , opSuccess
  , noop
  -- *** Realisation
  , derivationOutputTyped
  , realisation
  , realisationWithId
  -- *** BuildResult
  , buildResult
  -- *** GCResult
  , gcResult
  -- *** GCResult
  , gcRoot
  -- *** Missing
  , missing
  -- *** Maybe (Metadata StorePath)
  , 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

-- | Transformer for @Serializer@
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

-- | Runner for @SerialT@
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
  }

-- * NixSerializer

type NixSerializer r e = Serializer (SerialT r e)

-- * Errors

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)

-- ** Runners

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)

-- * Primitives

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)

-- | Utility toEnum version checking bounds using Bounded class
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

-- TODO Parser Builder
_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

-- * UTCTime

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
    -- fancy (*10^12), from Int to Uni to Pico(seconds)
    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)

    -- fancy (`div`10^12), from Pico to Uni to Int
    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

-- * Combinators

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

-- protoVersion_major & 0xFF00
-- protoVersion_minor & 0x00FF
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

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

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

-- * Signatures

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

-- * Some HashAlgo

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

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

-- * DSum HashAlgo Digest

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
      -- bit hacky since mkNamedDigest does the check
      -- that the expected matches but we don't know
      -- what we expect here (i.e. handle each HashAlgo)
      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
  -- TODO: we also lack a builder for SRI hashes
  -- , putS = putS textBuilder . System.Nix.Hash.algoDigestBuilder
  , 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

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)
      -- Our type is Derivation, but in Nix
      -- the type sent over the wire is BasicDerivation
      -- which omits inputDrvs
      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
  }

-- * DerivedPath

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
  }

-- * Build

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

-- * Logger

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 -- removed error name
      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" -- removed error name
        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
  }

-- * Handshake

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
  }

-- * Worker protocol

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

-- * Request

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 -- obsolete
        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

        -- not supported by ProtoVersion < 1.25
        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
        -- obsolete fields
        [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
        -- obsolete fixed
        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
        -- obsolete fields
        [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

-- ** Reply

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

-- | Parse a bool returned at the end of simple operations.
-- This is always 1 (@True@) so we assert that it really is so.
-- Errors for these operations are indicated via @Logger_Error@.
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 ()
  }

-- *** Realisation

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

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

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) -- obsolete
      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 -- obsolete
  }

-- *** GCRoot

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

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
  }

-- *** Maybe (Metadata StorePath)

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
  }