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

-- | Relay declared distribution companions under their parent's origin and integrity authority.
module Ecluse.Core.Server.Pipeline.Sidecar (
    sidecarAction,
    sidecarUrl,
    selectSidecar,
) where

import Crypto.Hash (Digest, SHA256, hash)
import Data.ByteString qualified as BS
import Data.ByteString.Builder (byteString)
import Data.Map.Strict qualified as Map
import Network.HTTP.Client qualified as HTTP
import Network.HTTP.Types (Method, Status, hContentLength, status200, status304, status401, status403, status404, status500, statusCode)
import Network.Wai (Request, ResponseReceived, requestHeaders)
import UnliftIO (tryAny)

import Ecluse.Core.Credential (ClientCredential)
import Ecluse.Core.Fault (RetryAfter)
import Ecluse.Core.Mirror.State (MirrorVersion, recordVersion, versionFiles)
import Ecluse.Core.Package (Artifact (..), CoreMetadata (..), PackageDetails (pkgArtifacts), PackageInfo (PackageInfo), PackageName)
import Ecluse.Core.Package.Integrity (IntegrityFloor, partitionByFloor)
import Ecluse.Core.Registry (FetchFault (FetchCooldown))
import Ecluse.Core.Registry.Adapter.Capability (AdapterArtifact (artifactByUrl))
import Ecluse.Core.Registry.Exchange.Types (ExchangeClient)
import Ecluse.Core.Registry.Metadata (MetadataClient (fetchVersionMetadata), MetadataError (MetadataFetch, MetadataNameMismatch), VersionDoc (vdDetails), VersionRead (vrVersion))
import Ecluse.Core.Registry.Request (sidecarUrl)
import Ecluse.Core.Security (HostPort, Limits (progressFloor), Origin (..), hostPortAddress, thgPrivateHostPort, thgPublicHostPort)
import Ecluse.Core.Server.Admission.Meter (MemoryTicket)
import Ecluse.Core.Server.Conditional (Conditional (..), etagHeader, evaluateETag, forwardValidators, mkStrongETag)
import Ecluse.Core.Server.Context (Handler, MountBinding (bindingPackumentDeps), PackumentDeps (..), ResponseAction (RunPipeline), ServeRuntime (..), ctxMount, ctxRuntime, pdPrivateBase, pdTarballHostGate, tarballHostHonoured)
import Ecluse.Core.Server.MirrorView (mirrorVersionView, mirrorViewDocuments, publicMirrorCoverage, readMirrorCompanion, validateMirrorProject)
import Ecluse.Core.Server.Path (Filename, unFilename)
import Ecluse.Core.Server.Pipeline.Origin (OriginMiss (..), ReadFailure (ReadUnavailable), statusReadFailure, withPrivateMetadataClient, withPublicMetadata)
import Ecluse.Core.Server.Pipeline.Shared
import Ecluse.Core.Server.Pipeline.Tarball.Private (RecordedCopy (RecordedCopyGone), privateMetadataMiss, privateReadFailure, recordedCopy)
import Ecluse.Core.Server.Pipeline.Tarball.Refusal (artifactError, privateMissRefusal, privateReadRefusal, upstreamUnavailable, versionAbsent)
import Ecluse.Core.Server.Pipeline.Tarball.Relay (ArtifactServe (..), acceptPrivateArtifact, privateArtifactResponder, relayPublicResult, relayUnjudged, relayUpstreamResult, withMethod, withValidators)
import Ecluse.Core.Server.Pipeline.Tarball.Types (ArtifactRequest (..), TarballReplies (..), relayResponder)
import Ecluse.Core.Server.Response (ServeDecision, mkRefusal)
import Ecluse.Core.Server.Route (isHead)
import Ecluse.Core.Server.Stream (UpstreamResult (..))
import Ecluse.Core.Telemetry.Upstream qualified as PublicRead
import Ecluse.Core.Version (Version, renderVersion)

-- | Bind GET and HEAD to the same metadata selection and bounded relay.
sidecarAction :: TarballReplies response -> Method -> PackageName -> Version -> Filename -> ResponseAction response
sidecarAction :: forall response.
TarballReplies response
-> Method
-> PackageName
-> Version
-> Filename
-> ResponseAction response
sidecarAction TarballReplies response
replies Method
method PackageName
name Version
version Filename
file =
    response
-> (Request
    -> (response -> IO ResponseReceived) -> Handler ResponseReceived)
-> ResponseAction response
forall response.
response
-> (Request
    -> (response -> IO ResponseReceived) -> Handler ResponseReceived)
-> ResponseAction response
RunPipeline (TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
forall response.
TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
tarballError TarballReplies response
replies Status
status500 [] (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
forall a. Maybe a
Nothing Text
"internal server error")) (ArtifactServe
-> TarballReplies response
-> PackageName
-> Version
-> Filename
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
forall response.
ArtifactServe
-> TarballReplies response
-> PackageName
-> Version
-> Filename
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
serveSidecar ArtifactServe
mode TarballReplies response
replies PackageName
name Version
version Filename
file)
  where
    mode :: ArtifactServe
mode = if Method -> Bool
isHead Method
method then ArtifactServe
ServeHead else ArtifactServe
ServeFull

serveSidecar :: ArtifactServe -> TarballReplies response -> PackageName -> Version -> Filename -> Request -> (response -> IO ResponseReceived) -> Handler ResponseReceived
serveSidecar :: forall response.
ArtifactServe
-> TarballReplies response
-> PackageName
-> Version
-> Filename
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
serveSidecar ArtifactServe
mode TarballReplies response
replies PackageName
name Version
version Filename
file Request
request response -> IO ResponseReceived
respond = do
    mount <- (RequestCtx -> MountBinding) -> Handler MountBinding
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks RequestCtx -> MountBinding
ctxMount
    runtime <- asks ctxRuntime
    let deps = MountBinding -> PackumentDeps
bindingPackumentDeps MountBinding
mount
        token = MountBinding -> Request -> Maybe ClientCredential
forwardedCredential MountBinding
mount Request
request
        ctx = ArtifactServe
-> TarballReplies response
-> ServeRuntime
-> PackumentDeps
-> ResponseHeaders
-> PackageName
-> Version
-> Filename
-> (response -> IO ResponseReceived)
-> ArtifactRequest response
forall response.
ArtifactServe
-> TarballReplies response
-> ServeRuntime
-> PackumentDeps
-> ResponseHeaders
-> PackageName
-> Version
-> Filename
-> (response -> IO ResponseReceived)
-> ArtifactRequest response
ArtifactRequest ArtifactServe
mode TarballReplies response
replies ServeRuntime
runtime PackumentDeps
deps (ResponseHeaders -> ResponseHeaders
forwardValidators (Request -> ResponseHeaders
requestHeaders Request
request)) PackageName
name Version
version Filename
file response -> IO ResponseReceived
respond
    if edgeTokenMatches (pdInboundToken deps) token
        then admittedRead ctx (privateSelection ctx token) (servePrivate ctx)
        else liftIO (respond (tarballError replies status401 [] (mkRefusal Nothing unauthorisedMessage)))

-- A recorded private file owns its companion absence after the complete mirror proof.
data Selection = Selected HTTP.Request | Retained ByteString | Incomplete RecordedCopy MirrorVersion | NewPublicFile | Unavailable | Cooling RetryAfter | Refused | Missing OriginMiss | CompanionAbsent

admittedRead :: ArtifactRequest response -> (MemoryTicket -> Handler Selection) -> (Selection -> Handler ResponseReceived) -> Handler ResponseReceived
admittedRead :: forall response.
ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
admittedRead ArtifactRequest response
ctx MemoryTicket -> Handler Selection
readSelection Selection -> Handler ResponseReceived
answer =
    ServeRuntime
-> (ResponseHeaders -> Handler ResponseReceived)
-> (MemoryTicket -> Handler (Either ResponseReceived Selection))
-> (Either ResponseReceived Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
forall (m :: * -> *) received a.
MonadUnliftIO m =>
ServeRuntime
-> (ResponseHeaders -> m received)
-> (MemoryTicket -> m a)
-> (a -> m received)
-> m received
withMetadataAdmission (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx) ResponseHeaders -> Handler ResponseReceived
forall {m :: * -> *}.
MonadIO m =>
ResponseHeaders -> m ResponseReceived
shed MemoryTicket -> Handler (Either ResponseReceived Selection)
retainedSelection ((ResponseReceived -> Handler ResponseReceived)
-> (Selection -> Handler ResponseReceived)
-> Either ResponseReceived Selection
-> Handler ResponseReceived
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ResponseReceived -> Handler ResponseReceived
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection -> Handler ResponseReceived
answer)
  where
    retainedSelection :: MemoryTicket -> Handler (Either ResponseReceived Selection)
retainedSelection MemoryTicket
ticket =
        MemoryTicket -> Handler Selection
readSelection MemoryTicket
ticket Handler Selection
-> (Selection -> Handler (Either ResponseReceived Selection))
-> Handler (Either ResponseReceived Selection)
forall a b. Handler a -> (a -> Handler b) -> Handler b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            Retained Method
bytes -> ResponseReceived -> Either ResponseReceived Selection
forall a b. a -> Either a b
Left (ResponseReceived -> Either ResponseReceived Selection)
-> Handler ResponseReceived
-> Handler (Either ResponseReceived Selection)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ArtifactRequest response -> Method -> Handler ResponseReceived
forall response.
ArtifactRequest response -> Method -> Handler ResponseReceived
serveRetained ArtifactRequest response
ctx Method
bytes
            Selection
selected -> Either ResponseReceived Selection
-> Handler (Either ResponseReceived Selection)
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Selection -> Either ResponseReceived Selection
forall a b. b -> Either a b
Right Selection
selected)
    shed :: ResponseHeaders -> m ResponseReceived
shed ResponseHeaders
headers = IO ResponseReceived -> m ResponseReceived
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ArtifactRequest response -> response -> IO ResponseReceived
forall response.
ArtifactRequest response -> response -> IO ResponseReceived
arRespond ArtifactRequest response
ctx (TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
forall response.
TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
tarballError (ArtifactRequest response -> TarballReplies response
forall response.
ArtifactRequest response -> TarballReplies response
arReplies ArtifactRequest response
ctx) Status
shedStatus ResponseHeaders
headers (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
forall a. Maybe a
Nothing Text
shedMessage)))

privateSelection :: ArtifactRequest response -> Maybe ClientCredential -> MemoryTicket -> Handler Selection
privateSelection :: forall response.
ArtifactRequest response
-> Maybe ClientCredential -> MemoryTicket -> Handler Selection
privateSelection ArtifactRequest response
ctx Maybe ClientCredential
token MemoryTicket
ticket = case PackumentDeps -> Maybe BaseRequest
pdPrivateBase PackumentDeps
deps of
    Maybe BaseRequest
Nothing -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> Selection
Missing OriginMiss
MissAbsent)
    Just BaseRequest
base -> do
        result <- Handler (Either MetadataError VersionRead)
-> Handler
     (Either SomeException (Either MetadataError VersionRead))
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> m (Either SomeException a)
tryAny (ServeRuntime
-> PackumentDeps
-> Maybe MemoryTicket
-> BaseRequest
-> Maybe ClientCredential
-> (MetadataClient -> IO (Either MetadataError VersionRead))
-> Handler (Either MetadataError VersionRead)
forall a.
ServeRuntime
-> PackumentDeps
-> Maybe MemoryTicket
-> BaseRequest
-> Maybe ClientCredential
-> (MetadataClient -> IO a)
-> Handler a
withPrivateMetadataClient (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx) PackumentDeps
deps (MemoryTicket -> Maybe MemoryTicket
forall a. a -> Maybe a
Just MemoryTicket
ticket) BaseRequest
base Maybe ClientCredential
token (\MetadataClient
client -> MetadataClient
-> PackageName -> Version -> IO (Either MetadataError VersionRead)
fetchVersionMetadata MetadataClient
client (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx)))
        case result of
            Right (Left MetadataError
err) | Maybe OriginMiss -> Bool
forall a. Maybe a -> Bool
isNothing (MetadataError -> Maybe OriginMiss
privateMetadataMiss MetadataError
err) -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
Refused
            Either SomeException (Either MetadataError VersionRead)
_ | Just ReadFailure
failure <- Either SomeException (Either MetadataError VersionRead)
-> Maybe ReadFailure
privateReadFailure Either SomeException (Either MetadataError VersionRead)
result -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> Selection
Missing (ReadFailure -> OriginMiss
MissUnresolved ReadFailure
failure))
            Either SomeException (Either MetadataError VersionRead)
_ -> case PackumentDeps -> Maybe MirrorView
pdMirrorState PackumentDeps
deps of
                Just MirrorView
mirror
                    | Bool -> Bool
not (PackumentDeps -> PackageName -> Bool
pdFirstParty PackumentDeps
deps (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx)) ->
                        IO
  (Either
     MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
-> Handler
     (Either
        MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MirrorView
-> MemoryTicket
-> PackageName
-> IO
     (Either
        MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
validateMirrorProject MirrorView
mirror MemoryTicket
ticket (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx)) Handler
  (Either
     MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
-> (Either
      MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord))
    -> Handler Selection)
-> Handler Selection
forall a b. Handler a -> (a -> Handler b) -> Handler b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                            Left MirrorStateFault
_ -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
Unavailable
                            Right Maybe (StateRevision, ProjectMirrorRecord)
Nothing -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either SomeException (Either MetadataError VersionRead)
-> Selection
forall {a}.
Either a (Either MetadataError VersionRead) -> Selection
ordinary Either SomeException (Either MetadataError VersionRead)
result)
                            Right (Just (StateRevision
_, ProjectMirrorRecord
record)) -> case Version -> ProjectMirrorRecord -> Maybe MirrorVersion
recordVersion (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) ProjectMirrorRecord
record of
                                Maybe MirrorVersion
Nothing -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either SomeException (Either MetadataError VersionRead)
-> Selection
forall {a}.
Either a (Either MetadataError VersionRead) -> Selection
ordinary Either SomeException (Either MetadataError VersionRead)
result)
                                Just MirrorVersion
expected -> case MirrorDocuments
-> Version
-> ProjectMirrorRecord
-> Maybe VersionDoc
-> Either MirrorStateFault (Maybe VersionDoc)
mirrorVersionView (MirrorView -> MirrorDocuments
mirrorViewDocuments MirrorView
mirror) (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) ProjectMirrorRecord
record ((SomeException -> Maybe VersionDoc)
-> (Either MetadataError VersionRead -> Maybe VersionDoc)
-> Either SomeException (Either MetadataError VersionRead)
-> Maybe VersionDoc
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe VersionDoc -> SomeException -> Maybe VersionDoc
forall a b. a -> b -> a
const Maybe VersionDoc
forall a. Maybe a
Nothing) ((MetadataError -> Maybe VersionDoc)
-> (VersionRead -> Maybe VersionDoc)
-> Either MetadataError VersionRead
-> Maybe VersionDoc
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe VersionDoc -> MetadataError -> Maybe VersionDoc
forall a b. a -> b -> a
const Maybe VersionDoc
forall a. Maybe a
Nothing) VersionRead -> Maybe VersionDoc
vrVersion) Either SomeException (Either MetadataError VersionRead)
result) of
                                    Left MirrorStateFault
_ -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RecordedCopy -> MirrorVersion -> Selection
Incomplete (Either SomeException (Either MetadataError VersionRead)
-> RecordedCopy
recordedCopy Either SomeException (Either MetadataError VersionRead)
result) MirrorVersion
expected)
                                    Right Maybe VersionDoc
_ | Text -> Map Text ExpectedMirrorFile -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.notMember (Filename -> Text
unFilename (ArtifactRequest response -> Filename
forall response. ArtifactRequest response -> Filename
arFile ArtifactRequest response
ctx)) (MirrorVersion -> Map Text ExpectedMirrorFile
versionFiles MirrorVersion
expected) -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
NewPublicFile
                                    Right Maybe VersionDoc
restored -> case Maybe VersionDoc
restored Maybe VersionDoc
-> (VersionDoc -> Maybe Artifact) -> Maybe Artifact
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MinTrustedIntegrity
-> (Artifact -> Bool) -> Text -> PackageDetails -> Maybe Artifact
forall floor.
IntegrityFloor floor =>
floor
-> (Artifact -> Bool) -> Text -> PackageDetails -> Maybe Artifact
selectSidecar (PackumentDeps -> MinTrustedIntegrity
pdMinTrustedIntegrity PackumentDeps
deps) (Origin -> PackumentDeps -> Maybe HostPort -> Maybe HostPort -> Bool
tarballHostHonoured Origin
TrustedOrigin PackumentDeps
deps Maybe HostPort
privateHost (Maybe HostPort -> Bool)
-> (Artifact -> Maybe HostPort) -> Artifact -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe HostPort
hostPortAddress (Text -> Maybe HostPort)
-> (Artifact -> Text) -> Artifact -> Maybe HostPort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Artifact -> Text
artUrl) (Filename -> Text
unFilename (ArtifactRequest response -> Filename
forall response. ArtifactRequest response -> Filename
arFile ArtifactRequest response
ctx)) (PackageDetails -> Maybe Artifact)
-> (VersionDoc -> PackageDetails) -> VersionDoc -> Maybe Artifact
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionDoc -> PackageDetails
vdDetails of
                                        Maybe Artifact
Nothing -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
CompanionAbsent
                                        Just Artifact
_ -> (MirrorStateFault -> Selection)
-> (Method -> Selection)
-> Either MirrorStateFault Method
-> Selection
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Selection -> MirrorStateFault -> Selection
forall a b. a -> b -> a
const Selection
Unavailable) Method -> Selection
Retained (Either MirrorStateFault Method -> Selection)
-> Handler (Either MirrorStateFault Method) -> Handler Selection
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Either MirrorStateFault Method)
-> Handler (Either MirrorStateFault Method)
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MirrorView
-> MemoryTicket
-> ProjectMirrorRecord
-> Version
-> Text
-> IO (Either MirrorStateFault Method)
readMirrorCompanion MirrorView
mirror MemoryTicket
ticket ProjectMirrorRecord
record (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) (Filename -> Text
unFilename (ArtifactRequest response -> Filename
forall response. ArtifactRequest response -> Filename
arFile ArtifactRequest response
ctx)))
                Maybe MirrorView
_ -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either SomeException (Either MetadataError VersionRead)
-> Selection
forall {a}.
Either a (Either MetadataError VersionRead) -> Selection
ordinary Either SomeException (Either MetadataError VersionRead)
result)
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx
    privateHost :: Maybe HostPort
privateHost = TarballHostGate -> Maybe HostPort
thgPrivateHostPort (PackumentDeps -> TarballHostGate
pdTarballHostGate PackumentDeps
deps)

    ordinary :: Either a (Either MetadataError VersionRead) -> Selection
ordinary = \case
        Left a
_ -> OriginMiss -> Selection
Missing (ReadFailure -> OriginMiss
MissUnresolved (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing))
        Right (Left MetadataError
err) -> Selection
-> (OriginMiss -> Selection) -> Maybe OriginMiss -> Selection
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Selection
Refused OriginMiss -> Selection
Missing (MetadataError -> Maybe OriginMiss
privateMetadataMiss MetadataError
err)
        Right (Right VersionRead
readVersion) -> case VersionRead -> Maybe VersionDoc
vrVersion VersionRead
readVersion of
            Maybe VersionDoc
Nothing -> OriginMiss -> Selection
Missing OriginMiss
MissAbsent
            Just VersionDoc
doc -> case MinTrustedIntegrity
-> (Artifact -> [Hash])
-> NonEmpty Artifact
-> Either VersionIntegrity (NonEmpty Artifact)
forall floor file.
IntegrityFloor floor =>
floor
-> (file -> [Hash])
-> NonEmpty file
-> Either VersionIntegrity (NonEmpty file)
partitionByFloor (PackumentDeps -> MinTrustedIntegrity
pdMinTrustedIntegrity PackumentDeps
deps) Artifact -> [Hash]
artHashes (PackageDetails -> NonEmpty Artifact
pkgArtifacts (VersionDoc -> PackageDetails
vdDetails VersionDoc
doc)) of
                Left VersionIntegrity
_ -> OriginMiss -> Selection
Missing OriginMiss
MissAbsent
                Right NonEmpty Artifact
_ -> case ArtifactRequest response
-> Origin
-> MinTrustedIntegrity
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
forall floor response.
IntegrityFloor floor =>
ArtifactRequest response
-> Origin
-> floor
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
selectRequest ArtifactRequest response
ctx Origin
TrustedOrigin (PackumentDeps -> MinTrustedIntegrity
pdMinTrustedIntegrity PackumentDeps
deps) Maybe HostPort
privateHost Maybe ClientCredential
token VersionRead
readVersion of
                    Missing OriginMiss
_ -> Selection
CompanionAbsent
                    Selection
selected -> Selection
selected

publicSelection :: ArtifactRequest response -> MemoryTicket -> Handler Selection
publicSelection :: forall response.
ArtifactRequest response -> MemoryTicket -> Handler Selection
publicSelection ArtifactRequest response
ctx MemoryTicket
ticket = do
    result <- Handler (Either MetadataError VersionRead)
-> Handler
     (Either SomeException (Either MetadataError VersionRead))
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> m (Either SomeException a)
tryAny (ServeRuntime
-> PackumentDeps
-> MemoryTicket
-> PackageName
-> Version
-> (IO (Either MetadataError VersionRead)
    -> Handler (Either MetadataError VersionRead))
-> Handler (Either MetadataError VersionRead)
forall a.
ServeRuntime
-> PackumentDeps
-> MemoryTicket
-> PackageName
-> Version
-> (IO (Either MetadataError VersionRead) -> Handler a)
-> Handler a
withPublicMetadata (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx) PackumentDeps
deps MemoryTicket
ticket (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) IO (Either MetadataError VersionRead)
-> Handler (Either MetadataError VersionRead)
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO)
    pure $ case result of
        Left SomeException
_ -> OriginMiss -> Selection
Missing (ReadFailure -> OriginMiss
MissUnresolved (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing))
        Right (Left (MetadataFetch (FetchCooldown RetryAfter
retry))) -> RetryAfter -> Selection
Cooling RetryAfter
retry
        Right (Left MetadataError
err) -> OriginMiss -> Selection
Missing (MetadataError -> OriginMiss
publicMetadataMiss MetadataError
err)
        Right (Right VersionRead
readVersion) -> ArtifactRequest response
-> Origin
-> MinIntegrity
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
forall floor response.
IntegrityFloor floor =>
ArtifactRequest response
-> Origin
-> floor
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
selectRequest ArtifactRequest response
ctx Origin
UntrustedOrigin (PackumentDeps -> MinIntegrity
pdMinIntegrity PackumentDeps
deps) Maybe HostPort
publicHost Maybe ClientCredential
forall a. Maybe a
Nothing VersionRead
readVersion
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx
    publicHost :: Maybe HostPort
publicHost = TarballHostGate -> Maybe HostPort
thgPublicHostPort (PackumentDeps -> TarballHostGate
pdTarballHostGate PackumentDeps
deps)

-- A public origin that names another package drops out, so its mismatch reads as an absence.
publicMetadataMiss :: MetadataError -> OriginMiss
publicMetadataMiss :: MetadataError -> OriginMiss
publicMetadataMiss = \case
    MetadataNameMismatch Text
_ -> OriginMiss
MissAbsent
    MetadataError
err -> OriginMiss -> Maybe OriginMiss -> OriginMiss
forall a. a -> Maybe a -> a
fromMaybe (ReadFailure -> OriginMiss
MissUnresolved (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing)) (MetadataError -> Maybe OriginMiss
privateMetadataMiss MetadataError
err)

selectRequest :: (IntegrityFloor floor) => ArtifactRequest response -> Origin -> floor -> Maybe HostPort -> Maybe ClientCredential -> VersionRead -> Selection
selectRequest :: forall floor response.
IntegrityFloor floor =>
ArtifactRequest response
-> Origin
-> floor
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
selectRequest ArtifactRequest response
ctx Origin
origin floor
floorSpec Maybe HostPort
authority Maybe ClientCredential
token VersionRead
readVersion =
    Selection -> Maybe Selection -> Selection
forall a. a -> Maybe a -> a
fromMaybe (OriginMiss -> Selection
Missing OriginMiss
MissAbsent) (Maybe Selection -> Selection) -> Maybe Selection -> Selection
forall a b. (a -> b) -> a -> b
$ do
        details <- VersionDoc -> PackageDetails
vdDetails (VersionDoc -> PackageDetails)
-> Maybe VersionDoc -> Maybe PackageDetails
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VersionRead -> Maybe VersionDoc
vrVersion VersionRead
readVersion
        artifact <- selectSidecar floorSpec (tarballHostHonoured origin deps authority . hostPortAddress . artUrl) (unFilename (arFile ctx)) details
        let url = Text -> Text
sidecarUrl (Artifact -> Text
artUrl Artifact
artifact)
            target = Text -> Maybe HostPort
hostPortAddress Text
url
            credential = if Origin
origin Origin -> Origin -> Bool
forall a. Eq a => a -> a -> Bool
== Origin
TrustedOrigin Bool -> Bool -> Bool
&& Maybe HostPort
target Maybe HostPort -> Maybe HostPort -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe HostPort
authority then Maybe ClientCredential
token else Maybe ClientCredential
forall a. Maybe a
Nothing
        guard (tarballHostHonoured origin deps authority target)
        Selected <$> rightToMaybe (artifactByUrl (pdArtifact deps) credential url)
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx

-- | Select the first eligible source entry before checking its companion declaration.
selectSidecar :: (IntegrityFloor floor) => floor -> (Artifact -> Bool) -> Text -> PackageDetails -> Maybe Artifact
selectSidecar :: forall floor.
IntegrityFloor floor =>
floor
-> (Artifact -> Bool) -> Text -> PackageDetails -> Maybe Artifact
selectSidecar floor
floorSpec Artifact -> Bool
allowed Text
filename PackageDetails
details = do
    survivors <- Either VersionIntegrity (NonEmpty Artifact)
-> Maybe (NonEmpty Artifact)
forall l r. Either l r -> Maybe r
rightToMaybe (floor
-> (Artifact -> [Hash])
-> NonEmpty Artifact
-> Either VersionIntegrity (NonEmpty Artifact)
forall floor file.
IntegrityFloor floor =>
floor
-> (file -> [Hash])
-> NonEmpty file
-> Either VersionIntegrity (NonEmpty file)
partitionByFloor floor
floorSpec Artifact -> [Hash]
artHashes (PackageDetails -> NonEmpty Artifact
pkgArtifacts PackageDetails
details))
    artifact <- find (\Artifact
candidate -> Artifact -> Text
artFilename Artifact
candidate Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
filename Bool -> Bool -> Bool
&& Artifact -> Bool
allowed Artifact
candidate) survivors
    guard $ case artCoreMetadata artifact of
        Just (MetadataAvailable Bool
available) -> Bool
available
        Just (MetadataDigests Map Text Text
digests) -> Bool -> Bool
not (Map Text Text -> Bool
forall a. Map Text a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Map Text Text
digests)
        Maybe CoreMetadata
Nothing -> Bool
False
    pure artifact

servePrivate :: ArtifactRequest response -> Selection -> Handler ResponseReceived
servePrivate :: forall response.
ArtifactRequest response -> Selection -> Handler ResponseReceived
servePrivate ArtifactRequest response
ctx = \case
    Retained Method
bytes -> ArtifactRequest response -> Method -> Handler ResponseReceived
forall response.
ArtifactRequest response -> Method -> Handler ResponseReceived
serveRetained ArtifactRequest response
ctx Method
bytes
    Selection
Unavailable -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Cooling RetryAfter
retry -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx (RetryAfter -> ServeDecision
upstreamCooling RetryAfter
retry)
    Incomplete RecordedCopy
copy MirrorVersion
expected -> ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
forall response.
ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
admittedRead ArtifactRequest response
ctx (ArtifactRequest response
-> Maybe (RecordedCopy, MirrorVersion)
-> MemoryTicket
-> Handler Selection
forall response.
ArtifactRequest response
-> Maybe (RecordedCopy, MirrorVersion)
-> MemoryTicket
-> Handler Selection
publicSelectionCovered ArtifactRequest response
ctx ((RecordedCopy, MirrorVersion)
-> Maybe (RecordedCopy, MirrorVersion)
forall a. a -> Maybe a
Just (RecordedCopy
copy, MirrorVersion
expected))) (ArtifactRequest response -> Selection -> Handler ResponseReceived
forall response.
ArtifactRequest response -> Selection -> Handler ResponseReceived
servePublic ArtifactRequest response
ctx)
    Selection
NewPublicFile -> ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
forall response.
ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
admittedRead ArtifactRequest response
ctx (ArtifactRequest response
-> Maybe (RecordedCopy, MirrorVersion)
-> MemoryTicket
-> Handler Selection
forall response.
ArtifactRequest response
-> Maybe (RecordedCopy, MirrorVersion)
-> MemoryTicket
-> Handler Selection
publicSelectionCovered ArtifactRequest response
ctx Maybe (RecordedCopy, MirrorVersion)
forall a. Maybe a
Nothing) (ArtifactRequest response -> Selection -> Handler ResponseReceived
forall response.
ArtifactRequest response -> Selection -> Handler ResponseReceived
servePublic ArtifactRequest response
ctx)
    Selection
CompanionAbsent -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
versionAbsent
    Selection
Refused -> ArtifactRequest response -> Handler ResponseReceived
forall response.
ArtifactRequest response -> Handler ResponseReceived
refusePrivate ArtifactRequest response
ctx
    Missing OriginMiss
miss -> ArtifactRequest response -> OriginMiss -> Handler ResponseReceived
forall response.
ArtifactRequest response -> OriginMiss -> Handler ResponseReceived
fallback ArtifactRequest response
ctx OriginMiss
miss
    Selected Request
request -> do
        result <- ArtifactRequest response
-> Bool
-> ExchangeClient
-> (Status -> Bool)
-> Request
-> Handler (UpstreamResult ((), ResponseReceived))
forall response.
ArtifactRequest response
-> Bool
-> ExchangeClient
-> (Status -> Bool)
-> Request
-> Handler (UpstreamResult ((), ResponseReceived))
relay ArtifactRequest response
ctx Bool
True (ServeRuntime -> ExchangeClient
srPrivateClient (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx)) Status -> Bool
acceptPrivateArtifact Request
request
        case result of
            UpstreamRelayed (()
_, ResponseReceived
received) -> ResponseReceived -> Handler ResponseReceived
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ResponseReceived
received
            UpstreamRejected Status
status Maybe RetryAfter
retry
                | Status
status Status -> Status -> Bool
forall a. Eq a => a -> a -> Bool
== Status
status404 -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
versionAbsent
                | Bool
otherwise -> ReadFailure -> Handler ResponseReceived
readFailed (Int -> Maybe RetryAfter -> ReadFailure
statusReadFailure (Status -> Int
statusCode Status
status) Maybe RetryAfter
retry)
            UpstreamResult ((), ResponseReceived)
UpstreamTransportFailure -> ReadFailure -> Handler ResponseReceived
readFailed (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing)
            UpstreamCooling RetryAfter
retry -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx (RetryAfter -> ServeDecision
upstreamCooling RetryAfter
retry)
  where
    readFailed :: ReadFailure -> Handler ResponseReceived
readFailed = ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx (ServeDecision -> Handler ResponseReceived)
-> (ReadFailure -> ServeDecision)
-> ReadFailure
-> Handler ResponseReceived
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentDeps -> PackageName -> ReadFailure -> ServeDecision
privateReadRefusal (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx) (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx)

fallback :: ArtifactRequest response -> OriginMiss -> Handler ResponseReceived
fallback :: forall response.
ArtifactRequest response -> OriginMiss -> Handler ResponseReceived
fallback ArtifactRequest response
ctx OriginMiss
miss =
    Handler ResponseReceived
-> (ServeDecision -> Handler ResponseReceived)
-> Maybe ServeDecision
-> Handler ResponseReceived
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
forall response.
ArtifactRequest response
-> (MemoryTicket -> Handler Selection)
-> (Selection -> Handler ResponseReceived)
-> Handler ResponseReceived
admittedRead ArtifactRequest response
ctx (ArtifactRequest response -> MemoryTicket -> Handler Selection
forall response.
ArtifactRequest response -> MemoryTicket -> Handler Selection
publicSelection ArtifactRequest response
ctx) (ArtifactRequest response -> Selection -> Handler ResponseReceived
forall response.
ArtifactRequest response -> Selection -> Handler ResponseReceived
servePublic ArtifactRequest response
ctx)) (ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx) (PackumentDeps -> PackageName -> OriginMiss -> Maybe ServeDecision
privateMissRefusal (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx) (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) OriginMiss
miss)

servePublic :: ArtifactRequest response -> Selection -> Handler ResponseReceived
servePublic :: forall response.
ArtifactRequest response -> Selection -> Handler ResponseReceived
servePublic ArtifactRequest response
ctx = \case
    Retained Method
_ -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Selection
Unavailable -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Cooling RetryAfter
retry -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx (RetryAfter -> ServeDecision
upstreamCooling RetryAfter
retry)
    Incomplete RecordedCopy
_ MirrorVersion
_ -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Selection
NewPublicFile -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Selection
CompanionAbsent -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
versionAbsent
    Selection
Refused -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Missing OriginMiss
MissAbsent -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
versionAbsent
    Missing (MissUnresolved ReadFailure
_) -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable
    Selected Request
request ->
        ArtifactRequest response
-> Bool
-> ExchangeClient
-> (Status -> Bool)
-> Request
-> Handler (UpstreamResult ((), ResponseReceived))
forall response.
ArtifactRequest response
-> Bool
-> ExchangeClient
-> (Status -> Bool)
-> Request
-> Handler (UpstreamResult ((), ResponseReceived))
relay ArtifactRequest response
ctx Bool
False (ServeRuntime -> ExchangeClient
srPublicClient (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx)) (Bool -> Status -> Bool
forall a b. a -> b -> a
const Bool
True) Request
request Handler (UpstreamResult ((), ResponseReceived))
-> (UpstreamResult ((), ResponseReceived)
    -> Handler ResponseReceived)
-> Handler ResponseReceived
forall a b. Handler a -> (a -> Handler b) -> Handler b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            UpstreamRelayed (()
_, ResponseReceived
received) -> ResponseReceived -> Handler ResponseReceived
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ResponseReceived
received
            UpstreamCooling RetryAfter
retry -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx (RetryAfter -> ServeDecision
upstreamCooling RetryAfter
retry)
            UpstreamResult ((), ResponseReceived)
_ -> ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
upstreamUnavailable

relay :: ArtifactRequest response -> Bool -> ExchangeClient -> (Status -> Bool) -> HTTP.Request -> Handler (UpstreamResult ((), ResponseReceived))
relay :: forall response.
ArtifactRequest response
-> Bool
-> ExchangeClient
-> (Status -> Bool)
-> Request
-> Handler (UpstreamResult ((), ResponseReceived))
relay ArtifactRequest response
ctx Bool
private ExchangeClient
client Status -> Bool
accepts Request
request =
    IO (UpstreamResult ((), ResponseReceived))
-> Handler (UpstreamResult ((), ResponseReceived))
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (UpstreamResult ((), ResponseReceived))
 -> Handler (UpstreamResult ((), ResponseReceived)))
-> IO (UpstreamResult ((), ResponseReceived))
-> Handler (UpstreamResult ((), ResponseReceived))
forall a b. (a -> b) -> a -> b
$
        ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status -> ResponseHeaders -> IO (Status, ResponseHeaders, ()))
-> RelayResponder ResponseReceived
-> IO (UpstreamResult ((), ResponseReceived))
forall {verdict} {response}.
ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
relayRead (ArtifactRequest response -> ArtifactServe
forall response. ArtifactRequest response -> ArtifactServe
arMode ArtifactRequest response
ctx) ExchangeClient
client (Limits -> ProgressFloor
progressFloor (PackumentDeps -> Limits
pdLimits (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx))) Request
shaped Status -> Bool
accepts Status -> ResponseHeaders -> IO (Status, ResponseHeaders, ())
relayUnjudged RelayResponder ResponseReceived
responder
  where
    relayRead :: ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
relayRead = if Bool
private then ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
forall {verdict} {response}.
ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
relayUpstreamResult else PublicControl
-> PublicReadKind
-> ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
forall verdict response.
PublicControl
-> PublicReadKind
-> ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
relayPublicResult (ServeRuntime -> PublicControl
srPublicControl (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx)) PublicReadKind
PublicRead.Companion
    shaped :: Request
shaped = ResponseHeaders -> Request -> Request
withValidators (ArtifactRequest response -> ResponseHeaders
forall response. ArtifactRequest response -> ResponseHeaders
arValidators ArtifactRequest response
ctx) (ArtifactServe -> Request -> Request
withMethod (ArtifactRequest response -> ArtifactServe
forall response. ArtifactRequest response -> ArtifactServe
arMode ArtifactRequest response
ctx) Request
request)
    replies :: TarballReplies response
replies = ArtifactRequest response -> TarballReplies response
forall response.
ArtifactRequest response -> TarballReplies response
arReplies ArtifactRequest response
ctx
    respond :: response -> IO ResponseReceived
respond = ArtifactRequest response -> response -> IO ResponseReceived
forall response.
ArtifactRequest response -> response -> IO ResponseReceived
arRespond ArtifactRequest response
ctx
    responder :: RelayResponder ResponseReceived
responder =
        if Bool
private
            then (Status -> IO ResponseReceived)
-> (ResponseReceived -> ResponseReceived)
-> RelayResponder ResponseReceived
-> RelayResponder ResponseReceived
forall result response.
(Status -> IO result)
-> (response -> result)
-> RelayResponder response
-> RelayResponder result
privateArtifactResponder (IO ResponseReceived -> Status -> IO ResponseReceived
forall a b. a -> b -> a
const (response -> IO ResponseReceived
respond (ArtifactRequest response -> response
forall response. ArtifactRequest response -> response
privateRefusal ArtifactRequest response
ctx))) ResponseReceived -> ResponseReceived
forall a. a -> a
id RelayResponder ResponseReceived
upstreamResponder
            else RelayResponder ResponseReceived
upstreamResponder
    upstreamResponder :: RelayResponder ResponseReceived
upstreamResponder = TarballReplies response
-> (response -> IO ResponseReceived)
-> RelayResponder ResponseReceived
forall response received.
TarballReplies response
-> (response -> IO received) -> RelayResponder received
relayResponder TarballReplies response
replies response -> IO ResponseReceived
respond

privateRefusal :: ArtifactRequest response -> response
privateRefusal :: forall response. ArtifactRequest response -> response
privateRefusal ArtifactRequest response
ctx = TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
forall response.
TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
tarballError (ArtifactRequest response -> TarballReplies response
forall response.
ArtifactRequest response -> TarballReplies response
arReplies ArtifactRequest response
ctx) Status
status403 [] (Maybe HelpMessage -> Refusal
privateAuthorisationRefusal (PackumentDeps -> Maybe HelpMessage
pdHelp (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx)))

refusePrivate :: ArtifactRequest response -> Handler ResponseReceived
refusePrivate :: forall response.
ArtifactRequest response -> Handler ResponseReceived
refusePrivate ArtifactRequest response
ctx = IO ResponseReceived -> Handler ResponseReceived
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ArtifactRequest response -> response -> IO ResponseReceived
forall response.
ArtifactRequest response -> response -> IO ResponseReceived
arRespond ArtifactRequest response
ctx (ArtifactRequest response -> response
forall response. ArtifactRequest response -> response
privateRefusal ArtifactRequest response
ctx))

answerError :: ArtifactRequest response -> ServeDecision -> Handler ResponseReceived
answerError :: forall response.
ArtifactRequest response
-> ServeDecision -> Handler ResponseReceived
answerError ArtifactRequest response
ctx ServeDecision
decision = IO ResponseReceived -> Handler ResponseReceived
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ArtifactRequest response -> response -> IO ResponseReceived
forall response.
ArtifactRequest response -> response -> IO ResponseReceived
arRespond ArtifactRequest response
ctx (TarballReplies response
-> PackumentDeps -> ServeDecision -> response
forall response.
TarballReplies response
-> PackumentDeps -> ServeDecision -> response
artifactError (ArtifactRequest response -> TarballReplies response
forall response.
ArtifactRequest response -> TarballReplies response
arReplies ArtifactRequest response
ctx) (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx) ServeDecision
decision))

serveRetained :: ArtifactRequest response -> ByteString -> Handler ResponseReceived
serveRetained :: forall response.
ArtifactRequest response -> Method -> Handler ResponseReceived
serveRetained ArtifactRequest response
ctx Method
bytes = IO ResponseReceived -> Handler ResponseReceived
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ResponseReceived -> Handler ResponseReceived)
-> IO ResponseReceived -> Handler ResponseReceived
forall a b. (a -> b) -> a -> b
$ ArtifactRequest response -> response -> IO ResponseReceived
forall response.
ArtifactRequest response -> response -> IO ResponseReceived
arRespond ArtifactRequest response
ctx (response -> IO ResponseReceived)
-> response -> IO ResponseReceived
forall a b. (a -> b) -> a -> b
$ case ResponseHeaders -> ETag -> Conditional
evaluateETag (ArtifactRequest response -> ResponseHeaders
forall response. ArtifactRequest response -> ResponseHeaders
arValidators ArtifactRequest response
ctx) ETag
etag of
    NotModified ETag
matched -> TarballReplies response -> Status -> ResponseHeaders -> response
forall response.
TarballReplies response -> Status -> ResponseHeaders -> response
tarballEmpty TarballReplies response
replies Status
status304 [ETag -> Header
etagHeader ETag
matched]
    Modified ETag
fresh -> case ArtifactRequest response -> ArtifactServe
forall response. ArtifactRequest response -> ArtifactServe
arMode ArtifactRequest response
ctx of
        ArtifactServe
ServeHead -> TarballReplies response -> Status -> ResponseHeaders -> response
forall response.
TarballReplies response -> Status -> ResponseHeaders -> response
tarballEmpty TarballReplies response
replies Status
status200 (ETag -> ResponseHeaders
headers ETag
fresh)
        ArtifactServe
ServeFull -> TarballReplies response
-> Status -> ResponseHeaders -> StreamingBody -> response
forall response.
TarballReplies response
-> Status -> ResponseHeaders -> StreamingBody -> response
tarballStream TarballReplies response
replies Status
status200 (ETag -> ResponseHeaders
headers ETag
fresh) (\Builder -> IO ()
send IO ()
flush -> Builder -> IO ()
send (Method -> Builder
byteString Method
bytes) IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO ()
flush)
  where
    replies :: TarballReplies response
replies = ArtifactRequest response -> TarballReplies response
forall response.
ArtifactRequest response -> TarballReplies response
arReplies ArtifactRequest response
ctx
    etag :: ETag
etag = Digest SHA256 -> ETag
mkStrongETag (Method -> Digest SHA256
forall ba a.
(ByteArrayAccess ba, HashAlgorithm a) =>
ba -> Digest a
hash Method
bytes :: Digest SHA256)
    headers :: ETag -> ResponseHeaders
headers ETag
fresh = [ETag -> Header
etagHeader ETag
fresh, (HeaderName
hContentLength, Int -> Method
forall b a. (Show a, IsString b) => a -> b
show (Method -> Int
BS.length Method
bytes))]

publicSelectionCovered :: ArtifactRequest response -> Maybe (RecordedCopy, MirrorVersion) -> MemoryTicket -> Handler Selection
publicSelectionCovered :: forall response.
ArtifactRequest response
-> Maybe (RecordedCopy, MirrorVersion)
-> MemoryTicket
-> Handler Selection
publicSelectionCovered ArtifactRequest response
ctx Maybe (RecordedCopy, MirrorVersion)
expected MemoryTicket
ticket = do
    result <- Handler (Either MetadataError VersionRead)
-> Handler
     (Either SomeException (Either MetadataError VersionRead))
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> m (Either SomeException a)
tryAny (ServeRuntime
-> PackumentDeps
-> MemoryTicket
-> PackageName
-> Version
-> (IO (Either MetadataError VersionRead)
    -> Handler (Either MetadataError VersionRead))
-> Handler (Either MetadataError VersionRead)
forall a.
ServeRuntime
-> PackumentDeps
-> MemoryTicket
-> PackageName
-> Version
-> (IO (Either MetadataError VersionRead) -> Handler a)
-> Handler a
withPublicMetadata (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx) PackumentDeps
deps MemoryTicket
ticket (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) IO (Either MetadataError VersionRead)
-> Handler (Either MetadataError VersionRead)
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO)
    case result of
        Right (Right VersionRead
readVersion) | Just VersionDoc
doc <- VersionRead -> Maybe VersionDoc
vrVersion VersionRead
readVersion -> do
            let info :: PackageInfo
info = PackageName
-> Map Text PackageDetails
-> Map Text Version
-> [InvalidEntry]
-> PackageInfo
PackageInfo (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (Text -> PackageDetails -> Map Text PackageDetails
forall k a. k -> a -> Map k a
Map.singleton (Version -> Text
renderVersion (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx)) (VersionDoc -> PackageDetails
vdDetails VersionDoc
doc)) Map Text Version
forall k a. Map k a
Map.empty []
            if Bool
-> ((RecordedCopy, MirrorVersion) -> Bool)
-> Maybe (RecordedCopy, MirrorVersion)
-> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (\(RecordedCopy
_, MirrorVersion
mirror) -> Map Text MirrorVersion -> PackageInfo -> Bool
publicMirrorCoverage (Text -> MirrorVersion -> Map Text MirrorVersion
forall k a. k -> a -> Map k a
Map.singleton (Version -> Text
renderVersion (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx)) MirrorVersion
mirror) PackageInfo
info) Maybe (RecordedCopy, MirrorVersion)
expected
                then Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArtifactRequest response
-> Origin
-> MinIntegrity
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
forall floor response.
IntegrityFloor floor =>
ArtifactRequest response
-> Origin
-> floor
-> Maybe HostPort
-> Maybe ClientCredential
-> VersionRead
-> Selection
selectRequest ArtifactRequest response
ctx Origin
UntrustedOrigin (PackumentDeps -> MinIntegrity
pdMinIntegrity PackumentDeps
deps) Maybe HostPort
publicHost Maybe ClientCredential
forall a. Maybe a
Nothing VersionRead
readVersion)
                else Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
Unavailable
        Right (Left (MetadataFetch (FetchCooldown RetryAfter
retry))) -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RetryAfter -> Selection
Cooling RetryAfter
retry)
        -- A public index for another project is an unusable reply, never the absence of a recorded version.
        Right (Left (MetadataNameMismatch Text
_)) | Maybe (RecordedCopy, MirrorVersion) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (RecordedCopy, MirrorVersion)
expected -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
Unavailable
        Right (Right VersionRead
_) | Bool
missSettles -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> Selection
Missing OriginMiss
MissAbsent)
        Right (Left MetadataError
err) | Bool
missSettles -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> Selection
Missing (MetadataError -> OriginMiss
publicMetadataMiss MetadataError
err))
        Either SomeException (Either MetadataError VersionRead)
_ -> Selection -> Handler Selection
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Selection
Unavailable
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx
    -- A public miss settles a new file, or a recorded version whose private copy is gone.
    missSettles :: Bool
missSettles = Bool
-> ((RecordedCopy, MirrorVersion) -> Bool)
-> Maybe (RecordedCopy, MirrorVersion)
-> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True ((RecordedCopy -> RecordedCopy -> Bool
forall a. Eq a => a -> a -> Bool
== RecordedCopy
RecordedCopyGone) (RecordedCopy -> Bool)
-> ((RecordedCopy, MirrorVersion) -> RecordedCopy)
-> (RecordedCopy, MirrorVersion)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RecordedCopy, MirrorVersion) -> RecordedCopy
forall a b. (a, b) -> a
fst) Maybe (RecordedCopy, MirrorVersion)
expected
    publicHost :: Maybe HostPort
publicHost = TarballHostGate -> Maybe HostPort
thgPublicHostPort (PackumentDeps -> TarballHostGate
pdTarballHostGate PackumentDeps
deps)