kenshou-remote-0.1.0.0: src/Kenshou/Remote/Perf/Publication.hs
module Kenshou.Remote.Perf.Publication (publishEvidence, verifyPublication, retrieveEvidence) where
import Control.Exception (IOException, bracket, displayException, try)
import Control.Monad (unless)
import Data.Aeson (eitherDecodeFileStrict')
import Data.List (nub)
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Manifest (Manifest (..), ManifestFile (..))
import Kenshou.Perf.Artifacts (safePath, verifyPerfManifest)
import Kenshou.Remote.Payload.Publish (digestFile)
import Kenshou.Remote.Store
import System.Directory (createDirectoryIfMissing, getTemporaryDirectory, removeFile)
import System.FilePath (takeDirectory, (</>))
import System.IO (hClose, openBinaryTempFile)
-- Manifest is published last. Every object is create-only, and even existing
-- objects are retrieved and hashed. Successful upload metadata is insufficient.
publishEvidence :: ObjectStore -> Bucket -> Text -> FilePath -> IO (Either Text Text)
publishEvidence store bucket prefix directory = protected do
validatePrefix prefix
checked <- verifyPerfManifest directory >>= require
checked `seq` pure ()
files <- publicationFiles directory
mapM_ publish files
require =<< verifyPublication store bucket prefix directory
pure ("gs://" <> bucket.unBucket <> "/" <> prefix <> "/manifest.json")
where
publish (relative, _, _, media) = do
result <- store.putFile bucket (object relative) media DoesNotExist (directory </> relative)
case result of
Written _ -> pure ()
PreconditionFailed -> pure ()
object relative = ObjectName (prefix <> "/" <> Text.pack relative)
verifyPublication :: ObjectStore -> Bucket -> Text -> FilePath -> IO (Either Text ())
verifyPublication store bucket prefix directory = protected do
validatePrefix prefix
verifyPerfManifest directory >>= require
files <- publicationFiles directory
temporaryDirectory <- getTemporaryDirectory
bracket (openBinaryTempFile temporaryDirectory "kenshou-perf-retrieval-") (removeFile . fst) \(temporary, handle) -> do
hClose handle
mapM_ (check temporary) files
where
check temporary (relative, expected, bytes, _) = do
present <- store.downloadTo bucket (ObjectName (prefix <> "/" <> Text.pack relative)) temporary
unless (present /= Nothing) (ioError (userError ("published artifact is missing: " <> relative)))
(actual, actualBytes) <- digestFile temporary
unless (actual == expected && toInteger actualBytes == bytes) (ioError (userError ("published artifact differs: " <> relative)))
-- Retrieve into a fresh caller-owned directory. Validate the complete inventory
-- before allowing any remote name to become a local output path.
retrieveEvidence :: ObjectStore -> Bucket -> Text -> Text -> FilePath -> IO (Either Text ())
retrieveEvidence store bucket prefix expectedManifest directory = protected do
validatePrefix prefix
createDirectoryIfMissing True directory
fetch "manifest.json"
(digest, _) <- digestFile (directory </> "manifest.json")
unless ("sha256:" <> digest == expectedManifest) (ioError (userError "retrieved performance manifest differs from its receipt"))
manifest <- eitherDecodeFileStrict' (directory </> "manifest.json") >>= either (ioError . userError) pure
let paths = map (.path) (manifest :: Manifest).files
unless (all safePath paths && "manifest.json" `notElem` paths && nub paths == paths && all ((>= 0) . (.bytes)) manifest.files) (ioError (userError "unsafe calibration report inventory"))
mapM_ fetch paths
verifyPerfManifest directory >>= require
where
fetch relative = do
let path = directory </> relative
createDirectoryIfMissing True (takeDirectory path)
present <- store.downloadTo bucket (ObjectName (prefix <> "/" <> Text.pack relative)) path
unless (present /= Nothing) (ioError (userError ("missing calibration report artifact: " <> relative)))
publicationFiles :: FilePath -> IO [(FilePath, Text, Integer, Text)]
publicationFiles directory = do
manifest <- eitherDecodeFileStrict' (directory </> "manifest.json") >>= either (ioError . userError) pure
(digest, bytes) <- digestFile (directory </> "manifest.json")
pure
( [(file.path, Text.drop 7 file.sha256, file.bytes, file.mediaType) | file <- (manifest :: Manifest).files]
<> [("manifest.json", digest, toInteger bytes, "application/json")]
)
validatePrefix :: Text -> IO ()
validatePrefix prefix =
unless
( not (Text.null prefix)
&& all (\part -> not (Text.null part) && part `notElem` [".", ".."]) (Text.splitOn "/" prefix)
&& not (Text.any (`elem` ['\\', '\n', '\r', '?', '#']) prefix)
)
(ioError (userError "unsafe performance publication prefix"))
require :: Either Text a -> IO a
require = either (ioError . userError . Text.unpack) pure
protected :: IO a -> IO (Either Text a)
protected action = either (Left . Text.pack . displayException) Right <$> try @IOException action