module System.Nix.Store.Remote.Client
  ( addToStore
  , addToStoreNar
  , addTextToStore
  , addSignatures
  , addTempRoot
  , addIndirectRoot
  , buildPaths
  , buildDerivation
  , collectGarbage
  , ensurePath
  , findRoots
  , isValidPath
  , narFromPath
  , queryValidPaths
  , queryAllValidPaths
  , querySubstitutablePaths
  , queryPathInfo
  , queryReferrers
  , queryValidDerivers
  , queryDerivationOutputs
  , queryDerivationOutputNames
  , queryPathFromHashPart
  , queryMissing
  , optimiseStore
  , syncWithGC
  , verifyStore
  , module System.Nix.Store.Remote.Client.Core
  ) where

import Control.Monad (void, when)
import Control.Monad.Except (throwError)
import Data.ByteString (ByteString)
import Data.HashSet (HashSet)
import Data.Map (Map)
import Data.Set (Set)
import Data.Some (Some)
import Data.Word (Word64)

import System.Nix.Build (BuildMode, BuildResult)
import System.Nix.DerivedPath (DerivedPath)
import System.Nix.Hash (HashAlgo(..))
import System.Nix.Nar (NarSource)
import System.Nix.Signature (Signature)
import System.Nix.StorePath (StorePath, StorePathHashPart, StorePathName)
import System.Nix.StorePath.Metadata (Metadata)
import System.Nix.Store.Remote.MonadStore
import System.Nix.Store.Remote.Types.GC (GCOptions, GCResult, GCRoot)
import System.Nix.Store.Remote.Types.CheckMode (CheckMode)
import System.Nix.Store.Remote.Types.Query.Missing (Missing)
import System.Nix.Store.Remote.Types.StoreRequest (StoreRequest(..))
import System.Nix.Store.Remote.Types.StoreText (StoreText)
import System.Nix.Store.Remote.Types.SubstituteMode (SubstituteMode)
import System.Nix.Store.Remote.Client.Core
import System.Nix.Store.Types (FileIngestionMethod(..), RepairMode(..))

import qualified Control.Monad.IO.Class
import qualified Data.Attoparsec.Text
import qualified Data.Text.IO
import qualified System.Nix.Derivation
import qualified System.Nix.StorePath

-- | Add `NarSource` to the store
addToStore
  :: MonadRemoteStore m
  => StorePathName        -- ^ Name part of the newly created `StorePath`
  -> NarSource IO         -- ^ Provide nar stream
  -> FileIngestionMethod  -- ^ Add target directory recursively
  -> Some HashAlgo        -- ^
  -> RepairMode           -- ^ Only used by local store backend
  -> m StorePath
addToStore :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePathName
-> NarSource IO
-> FileIngestionMethod
-> Some HashAlgo
-> RepairMode
-> m StorePath
addToStore StorePathName
name NarSource IO
source FileIngestionMethod
method Some HashAlgo
hashAlgo RepairMode
repair = do
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.when
    (RepairMode
repair RepairMode -> RepairMode -> Bool
forall a. Eq a => a -> a -> Bool
== RepairMode
RepairMode_DoRepair)
    (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ RemoteStoreError -> m ()
forall a. RemoteStoreError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError RemoteStoreError
RemoteStoreError_RapairNotSupportedByRemoteStore

  NarSource IO -> m ()
forall (m :: * -> *). MonadRemoteStore m => NarSource IO -> m ()
setNarSource NarSource IO
source
  StoreRequest StorePath -> m StorePath
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StorePathName
-> FileIngestionMethod
-> Some HashAlgo
-> RepairMode
-> StoreRequest StorePath
AddToStore StorePathName
name FileIngestionMethod
method Some HashAlgo
hashAlgo RepairMode
repair)

addToStoreNar
  :: MonadRemoteStore m
  => StorePath
  -> Metadata StorePath
  -> RepairMode
  -> CheckMode
  -> (Word64 -> IO(Maybe ByteString))
  -> m ()
addToStoreNar :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath
-> Metadata StorePath
-> RepairMode
-> CheckMode
-> (Word64 -> IO (Maybe ByteString))
-> m ()
addToStoreNar StorePath
path Metadata StorePath
metadata RepairMode
repair CheckMode
checkSigs Word64 -> IO (Maybe ByteString)
source = do
  (Word64 -> IO (Maybe ByteString)) -> m ()
forall (m :: * -> *).
MonadRemoteStore m =>
(Word64 -> IO (Maybe ByteString)) -> m ()
setDataSource Word64 -> IO (Maybe ByteString)
source
  m NoReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m NoReply -> m ()) -> m NoReply -> m ()
forall a b. (a -> b) -> a -> b
$ StoreRequest NoReply -> m NoReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StorePath
-> Metadata StorePath
-> RepairMode
-> CheckMode
-> StoreRequest NoReply
AddToStoreNar StorePath
path Metadata StorePath
metadata RepairMode
repair CheckMode
checkSigs)
  () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

-- | Add @StoreText@ to the store
-- Reference accepts repair but only uses it
-- to throw error in case of remote talking to nix-daemon.
addTextToStore
  :: MonadRemoteStore m
  => StoreText
  -> HashSet StorePath -- ^ Set of `StorePath`s that the added text references
  -> RepairMode        -- ^ Repair mode, must be `RepairMode_DontRepair` for remote backend
                       --   (only valid for local store)
  -> m StorePath
addTextToStore :: forall (m :: * -> *).
MonadRemoteStore m =>
StoreText -> HashSet StorePath -> RepairMode -> m StorePath
addTextToStore StoreText
stext HashSet StorePath
references RepairMode
repair = do
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Control.Monad.when
    (RepairMode
repair RepairMode -> RepairMode -> Bool
forall a. Eq a => a -> a -> Bool
== RepairMode
RepairMode_DoRepair)
    (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ RemoteStoreError -> m ()
forall a. RemoteStoreError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError RemoteStoreError
RemoteStoreError_RapairNotSupportedByRemoteStore

  StoreRequest StorePath -> m StorePath
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreText
-> HashSet StorePath -> RepairMode -> StoreRequest StorePath
AddTextToStore StoreText
stext HashSet StorePath
references RepairMode
repair)

-- | Add @Signature@s to a store path
addSignatures
  :: MonadRemoteStore m
  => StorePath
  -> Set Signature
  -> m ()
addSignatures :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> Set Signature -> m ()
addSignatures StorePath
p Set Signature
signatures = (m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> StoreRequest SuccessCodeReply
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq) (StorePath -> Set Signature -> StoreRequest SuccessCodeReply
AddSignatures StorePath
p Set Signature
signatures)

-- | Add temporary garbage collector root.
--
-- This root is removed as soon as the client exits.
addTempRoot
  :: MonadRemoteStore m
  => StorePath
  -> m ()
addTempRoot :: forall (m :: * -> *). MonadRemoteStore m => StorePath -> m ()
addTempRoot = m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StorePath -> m SuccessCodeReply) -> StorePath -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> (StorePath -> StoreRequest SuccessCodeReply)
-> StorePath
-> m SuccessCodeReply
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest SuccessCodeReply
AddTempRoot

-- | Add indirect garbage collector root.
addIndirectRoot
  :: MonadRemoteStore m
  => StorePath
  -> m ()
addIndirectRoot :: forall (m :: * -> *). MonadRemoteStore m => StorePath -> m ()
addIndirectRoot = m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StorePath -> m SuccessCodeReply) -> StorePath -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> (StorePath -> StoreRequest SuccessCodeReply)
-> StorePath
-> m SuccessCodeReply
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest SuccessCodeReply
AddIndirectRoot

-- | Build a derivation available at @StorePath@
buildDerivation
  :: MonadRemoteStore m
  => StorePath
  -> BuildMode
  -> m BuildResult
buildDerivation :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> BuildMode -> m BuildResult
buildDerivation StorePath
sp BuildMode
mode = do
  StoreDir
sd <- m StoreDir
forall (m :: * -> *). MonadRemoteStore m => m StoreDir
getStoreDir
  Text
drvContents <-
    IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
Control.Monad.IO.Class.liftIO
    (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ FilePath -> IO Text
Data.Text.IO.readFile
    (FilePath -> IO Text) -> FilePath -> IO Text
forall a b. (a -> b) -> a -> b
$ StoreDir -> StorePath -> FilePath
System.Nix.StorePath.storePathToFilePath StoreDir
sd StorePath
sp
  case Parser (Derivation StorePath Text)
-> Text -> Either FilePath (Derivation StorePath Text)
forall a. Parser a -> Text -> Either FilePath a
Data.Attoparsec.Text.parseOnly
    (StoreDir -> Parser (Derivation StorePath Text)
System.Nix.Derivation.parseDerivation StoreDir
sd) Text
drvContents of
      Left FilePath
e -> RemoteStoreError -> m BuildResult
forall a. RemoteStoreError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (RemoteStoreError -> m BuildResult)
-> RemoteStoreError -> m BuildResult
forall a b. (a -> b) -> a -> b
$ FilePath -> RemoteStoreError
RemoteStoreError_DerivationParse FilePath
e
      Right Derivation StorePath Text
drv -> StoreRequest BuildResult -> m BuildResult
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StorePath
-> Derivation StorePath Text
-> BuildMode
-> StoreRequest BuildResult
BuildDerivation StorePath
sp Derivation StorePath Text
drv BuildMode
mode)

-- | Build paths if they are an actual derivations.
--
-- If derivation output paths are already valid, do nothing.
buildPaths
  :: MonadRemoteStore m
  => Set DerivedPath
  -> BuildMode
  -> m ()
buildPaths :: forall (m :: * -> *).
MonadRemoteStore m =>
Set DerivedPath -> BuildMode -> m ()
buildPaths Set DerivedPath
a BuildMode
b = (m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> StoreRequest SuccessCodeReply
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq) (Set DerivedPath -> BuildMode -> StoreRequest SuccessCodeReply
BuildPaths Set DerivedPath
a BuildMode
b)

collectGarbage
  :: MonadRemoteStore m
  => GCOptions
  -> m GCResult
collectGarbage :: forall (m :: * -> *). MonadRemoteStore m => GCOptions -> m GCResult
collectGarbage = StoreRequest GCResult -> m GCResult
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest GCResult -> m GCResult)
-> (GCOptions -> StoreRequest GCResult) -> GCOptions -> m GCResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GCOptions -> StoreRequest GCResult
CollectGarbage

ensurePath
  :: MonadRemoteStore m
  => StorePath
  -> m ()
ensurePath :: forall (m :: * -> *). MonadRemoteStore m => StorePath -> m ()
ensurePath = m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StorePath -> m SuccessCodeReply) -> StorePath -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> (StorePath -> StoreRequest SuccessCodeReply)
-> StorePath
-> m SuccessCodeReply
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest SuccessCodeReply
EnsurePath

-- | Find garbage collector roots.
findRoots
  :: MonadRemoteStore m
  => m (Map GCRoot StorePath)
findRoots :: forall (m :: * -> *).
MonadRemoteStore m =>
m (Map GCRoot StorePath)
findRoots = StoreRequest (Map GCRoot StorePath) -> m (Map GCRoot StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq StoreRequest (Map GCRoot StorePath)
FindRoots

isValidPath
  :: MonadRemoteStore m
  => StorePath
  -> m Bool
isValidPath :: forall (m :: * -> *). MonadRemoteStore m => StorePath -> m Bool
isValidPath = StoreRequest Bool -> m Bool
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest Bool -> m Bool)
-> (StorePath -> StoreRequest Bool) -> StorePath -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest Bool
IsValidPath

-- | Download a NAR file.
narFromPath
  :: MonadRemoteStore m
  => StorePath -- ^ Path to generate a NAR for
  -> Word64 -- ^ Byte length of NAR
  -> (ByteString -> IO()) -- ^ Data sink where NAR bytes will be written
  -> m ()
narFromPath :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> Word64 -> (ByteString -> IO ()) -> m ()
narFromPath StorePath
path Word64
narSize ByteString -> IO ()
sink = do
  (ByteString -> IO ()) -> m ()
forall (m :: * -> *).
MonadRemoteStore m =>
(ByteString -> IO ()) -> m ()
setDataSink ByteString -> IO ()
sink
  Word64 -> m ()
forall (m :: * -> *). MonadRemoteStore m => Word64 -> m ()
setDataSinkSize Word64
narSize
  m NoReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m NoReply -> m ()) -> m NoReply -> m ()
forall a b. (a -> b) -> a -> b
$ StoreRequest NoReply -> m NoReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StorePath -> StoreRequest NoReply
NarFromPath StorePath
path)

-- | Query valid paths from a set,
-- optionally try to use substitutes
queryValidPaths
  :: MonadRemoteStore m
  => HashSet StorePath
  -- ^ Set of @StorePath@s to query
  -> SubstituteMode
  -- ^ Try substituting missing paths when @SubstituteMode_DoSubstitute@
  -> m (HashSet StorePath)
queryValidPaths :: forall (m :: * -> *).
MonadRemoteStore m =>
HashSet StorePath -> SubstituteMode -> m (HashSet StorePath)
queryValidPaths HashSet StorePath
a SubstituteMode
b = StoreRequest (HashSet StorePath) -> m (HashSet StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (HashSet StorePath
-> SubstituteMode -> StoreRequest (HashSet StorePath)
QueryValidPaths HashSet StorePath
a SubstituteMode
b)

-- | Query all valid paths
queryAllValidPaths
  :: MonadRemoteStore m
  => m (HashSet StorePath)
queryAllValidPaths :: forall (m :: * -> *). MonadRemoteStore m => m (HashSet StorePath)
queryAllValidPaths = StoreRequest (HashSet StorePath) -> m (HashSet StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq StoreRequest (HashSet StorePath)
QueryAllValidPaths

-- | Query a set of paths substituable from caches
querySubstitutablePaths
  :: MonadRemoteStore m
  => HashSet StorePath
  -> m (HashSet StorePath)
querySubstitutablePaths :: forall (m :: * -> *).
MonadRemoteStore m =>
HashSet StorePath -> m (HashSet StorePath)
querySubstitutablePaths = StoreRequest (HashSet StorePath) -> m (HashSet StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest (HashSet StorePath) -> m (HashSet StorePath))
-> (HashSet StorePath -> StoreRequest (HashSet StorePath))
-> HashSet StorePath
-> m (HashSet StorePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashSet StorePath -> StoreRequest (HashSet StorePath)
QuerySubstitutablePaths

-- | Query path metadata
queryPathInfo
  :: MonadRemoteStore m
  => StorePath
  -> m (Maybe (Metadata StorePath))
queryPathInfo :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> m (Maybe (Metadata StorePath))
queryPathInfo = StoreRequest (Maybe (Metadata StorePath))
-> m (Maybe (Metadata StorePath))
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest (Maybe (Metadata StorePath))
 -> m (Maybe (Metadata StorePath)))
-> (StorePath -> StoreRequest (Maybe (Metadata StorePath)))
-> StorePath
-> m (Maybe (Metadata StorePath))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (Maybe (Metadata StorePath))
QueryPathInfo

queryReferrers
  :: MonadRemoteStore m
  => StorePath
  -> m (HashSet StorePath)
queryReferrers :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> m (HashSet StorePath)
queryReferrers = StoreRequest (HashSet StorePath) -> m (HashSet StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest (HashSet StorePath) -> m (HashSet StorePath))
-> (StorePath -> StoreRequest (HashSet StorePath))
-> StorePath
-> m (HashSet StorePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePath)
QueryReferrers

queryValidDerivers
  :: MonadRemoteStore m
  => StorePath
  -> m (HashSet StorePath)
queryValidDerivers :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> m (HashSet StorePath)
queryValidDerivers = StoreRequest (HashSet StorePath) -> m (HashSet StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest (HashSet StorePath) -> m (HashSet StorePath))
-> (StorePath -> StoreRequest (HashSet StorePath))
-> StorePath
-> m (HashSet StorePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePath)
QueryValidDerivers

queryDerivationOutputs
  :: MonadRemoteStore m
  => StorePath
  -> m (HashSet StorePath)
queryDerivationOutputs :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> m (HashSet StorePath)
queryDerivationOutputs = StoreRequest (HashSet StorePath) -> m (HashSet StorePath)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest (HashSet StorePath) -> m (HashSet StorePath))
-> (StorePath -> StoreRequest (HashSet StorePath))
-> StorePath
-> m (HashSet StorePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePath)
QueryDerivationOutputs

queryDerivationOutputNames
  :: MonadRemoteStore m
  => StorePath
  -> m (HashSet StorePathName)
queryDerivationOutputNames :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePath -> m (HashSet StorePathName)
queryDerivationOutputNames = StoreRequest (HashSet StorePathName) -> m (HashSet StorePathName)
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest (HashSet StorePathName) -> m (HashSet StorePathName))
-> (StorePath -> StoreRequest (HashSet StorePathName))
-> StorePath
-> m (HashSet StorePathName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePath -> StoreRequest (HashSet StorePathName)
QueryDerivationOutputNames

queryPathFromHashPart
  :: MonadRemoteStore m
  => StorePathHashPart
  -> m StorePath
queryPathFromHashPart :: forall (m :: * -> *).
MonadRemoteStore m =>
StorePathHashPart -> m StorePath
queryPathFromHashPart = StoreRequest StorePath -> m StorePath
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest StorePath -> m StorePath)
-> (StorePathHashPart -> StoreRequest StorePath)
-> StorePathHashPart
-> m StorePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StorePathHashPart -> StoreRequest StorePath
QueryPathFromHashPart

queryMissing
  :: MonadRemoteStore m
  => Set DerivedPath
  -> m Missing
queryMissing :: forall (m :: * -> *).
MonadRemoteStore m =>
Set DerivedPath -> m Missing
queryMissing = StoreRequest Missing -> m Missing
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (StoreRequest Missing -> m Missing)
-> (Set DerivedPath -> StoreRequest Missing)
-> Set DerivedPath
-> m Missing
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set DerivedPath -> StoreRequest Missing
QueryMissing

optimiseStore
  :: MonadRemoteStore m
  => m ()
optimiseStore :: forall (m :: * -> *). MonadRemoteStore m => m ()
optimiseStore = (m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> StoreRequest SuccessCodeReply
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq) StoreRequest SuccessCodeReply
OptimiseStore

syncWithGC
  :: MonadRemoteStore m
  => m ()
syncWithGC :: forall (m :: * -> *). MonadRemoteStore m => m ()
syncWithGC = (m SuccessCodeReply -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m SuccessCodeReply -> m ())
-> (StoreRequest SuccessCodeReply -> m SuccessCodeReply)
-> StoreRequest SuccessCodeReply
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreRequest SuccessCodeReply -> m SuccessCodeReply
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq) StoreRequest SuccessCodeReply
SyncWithGC

verifyStore
  :: MonadRemoteStore m
  => CheckMode
  -> RepairMode
  -> m Bool
verifyStore :: forall (m :: * -> *).
MonadRemoteStore m =>
CheckMode -> RepairMode -> m Bool
verifyStore CheckMode
check RepairMode
repair = StoreRequest Bool -> m Bool
forall (m :: * -> *) a.
(MonadIO m, MonadRemoteStore m, StoreReply a, Show a) =>
StoreRequest a -> m a
doReq (CheckMode -> RepairMode -> StoreRequest Bool
VerifyStore CheckMode
check RepairMode
repair)