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

{- | Merge authorised private metadata with admitted public versions. First-party names use only
private metadata, and a private read that fails refuses every name with the status its cause sets.
-}
module Ecluse.Core.Server.Pipeline.Packument (
    PackumentReplies (..),
    DocumentRejectionObserver (..),
    packumentAction,
    servePackument,
    headPackument,
    withObservedAdmittedDocument,
    answerMetadataBytes,
    answerDigestedMetadataBytes,
    mapPackumentReplies,

    -- * The first-party private miss (exported for its unit spec)
    firstPartyMissDecision,
    firstPartyMissReply,

    -- * The refusal when no version survives (exported for its unit spec)
    noSurvivors,

    -- * The 404 for a name no upstream lists a version of
    notFoundReply,
) where

import Crypto.Hash (Digest, SHA256, hash)
import Data.ByteString qualified as BS
import Data.ByteString.Lazy qualified as LBS
import Data.Map.Strict qualified as Map
import Data.Set qualified as Set
import Katip (Severity (DebugS), logFM, ls)
import Network.HTTP.Types (Method, ResponseHeaders, hContentLength)
import Network.Wai (Request, ResponseReceived, requestHeaders, requestMethod)
import UnliftIO (concurrently)
import UnliftIO.Exception (catchAny, evaluate, throwIO)

import Ecluse.Core.Credential (ClientCredential)
import Ecluse.Core.Cve.Types (DbEtag)
import Ecluse.Core.Mirror.Documents (MirrorDocuments)
import Ecluse.Core.Mirror.State (ProjectMirrorRecord, StateRevision)
import Ecluse.Core.Package (
    Artifact (artHashes),
    InvalidEntry (invalidKind),
    InvalidEntryKind (..),
    PackageDetails (pkgArtifacts),
    PackageInfo (infoInvalidEntries, infoVersions),
    PackageName,
    renderPackageName,
 )
import Ecluse.Core.Package.Filter (filterPlanFromDecisions, fpDecisions, fpSurvivors, restrictToSurvivors)
import Ecluse.Core.Package.Integrity (
    IntegrityFloor,
    MinTrustedIntegrity,
    VersionIntegrity (BelowFloor, MeetsFloor, NoIntegrity),
    classifyDigests,
 )
import Ecluse.Core.Package.Merge (
    MergePlan (mpDivergences, mpSurvivors),
    Provenance (GatedSource, TrustedSource),
    integrityDivergences,
    mergePackuments,
    withoutTrustedReleases,
 )
import Ecluse.Core.Registry.Adapter.Capability (AdapterMetadata (metadataChargeFactors, metadataSerialise))
import Ecluse.Core.Registry.CachedDocument (CachedDoc)
import Ecluse.Core.Registry.Metadata (
    Manifest (manifestBodyBytes, manifestDigest, manifestInfo, manifestRaw),
 )
import Ecluse.Core.Rules (newEvaluator)
import Ecluse.Core.Rules.Types (Decision (Blocked), EvalContext (ctxAdvisoryEtag), completeEvidence, mkEvalContext)
import Ecluse.Core.Security.Egress (registryUrlText)
import Ecluse.Core.Server.Admission.Budget (scaleCharge)
import Ecluse.Core.Server.Admission.Meter (ChargePart, MemoryTicket, awaitingFlight, charge, chargePart, newChargePart, servingFlight, stepDown)
import Ecluse.Core.Server.Admission.Types (ChargeFactors (cfOutputPermille))
import Ecluse.Core.Server.Cache (resolveAssembled)
import Ecluse.Core.Server.Cache.Types (assembledKey)
import Ecluse.Core.Server.Conditional (Conditional (Modified, NotModified), ETag, etagHeader, evaluateETag, mkStrongETag)
import Ecluse.Core.Server.Context (
    Handler,
    MountBinding (bindingPackumentDeps),
    PackumentDeps (..),
    ResponseAction (RunPipeline),
    ServeRuntime (..),
    ctxMount,
    ctxRuntime,
    pdPrivateBaseUrl,
    pdPublicBaseUrl,
 )
import Ecluse.Core.Server.Encoding (
    CodingChoice (NoAcceptableCoding, ServeCoding),
    ContentCoding (GzipCoding, IdentityCoding),
    MetadataCompression (GzipWhenAccepted, IdentityOnly),
    chooseCoding,
    gzipEncodingHeader,
    varyAcceptEncoding,
 )
import Ecluse.Core.Server.Fault (RenderEscape (RenderEscape))
import Ecluse.Core.Server.MetadataGzip (GzipBody (gzipLength), gzipLazyBody, gzipMetadata)
import Ecluse.Core.Server.MirrorView (mirrorProjectViews, mirrorViewDocuments, publicMirrorCoverage, validateMirrorProject)
import Ecluse.Core.Server.Pipeline.Diagnostics (logVersionlessRefusal, warnDivergences)
import Ecluse.Core.Server.Pipeline.Internal (
    VersionVerdict (..),
    admitByIntegrity,
    evalTier,
    logDenials,
    packumentServeDecision,
    recordDenials,
    recordEffectfulFailures,
    serveDecisionClass,
    statusServeDecision,
 )
import Ecluse.Core.Server.Pipeline.Origin (
    OriginMiss (MissAbsent, MissUnresolved),
    OriginResult (..),
    ReadFailure (ReadInvalid, ReadUnavailable),
    fetchPrivateOriginObserved,
    fetchPublicOriginObserved,
    originManifest,
    originMiss,
    readFailureRefusal,
 )
import Ecluse.Core.Server.Pipeline.Packument.Representation
import Ecluse.Core.Server.Pipeline.Shared
import Ecluse.Core.Server.Response (
    HelpMessage,
    PackumentStatus (PackumentBadGateway, PackumentDenied, PackumentForbidden, PackumentOk, PackumentServerError, PackumentUnavailable),
    Refusal,
    RejectReason (ByPolicy, Unavailable, UpstreamInvalid),
    Rejection (Rejection),
    RetryAfter,
    ServeDecision (Admit, Reject),
    Transience (WillResolve, WontResolve),
    mkRefusal,
    packumentStatus,
    rejectUnavailable,
    serveDecisionOf,
 )
import Ecluse.Core.Server.Response.Summary (detailedRejections)
import Ecluse.Core.Server.Route (isHead)
import Ecluse.Core.Snapshot (Snapshot (..))
import Ecluse.Core.Telemetry.Metrics qualified as Metric
import Ecluse.Core.Telemetry.Record (MetricsPort (..), timedSeconds)
import Ecluse.Core.Telemetry.Span (TracingPort, spanPackumentGate)

-- | The route-owned ways the ecosystem-neutral packument pipeline may answer.
data PackumentReplies response = PackumentReplies
    { forall response.
PackumentReplies response -> [ServeDecision] -> Text
packumentDeniedText :: [ServeDecision] -> Text
    -- ^ Render the refusals of a listing with no survivor and no outage, after status selection.
    , forall response.
PackumentReplies response
-> ResponseHeaders -> LByteString -> response
packumentOk :: ResponseHeaders -> LByteString -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> response
packumentNotModified :: ResponseHeaders -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnauthorised :: ResponseHeaders -> Refusal -> response
    , forall response.
PackumentReplies response
-> Int -> ResponseHeaders -> Refusal -> response
packumentPrivateRefused :: Int -> ResponseHeaders -> Refusal -> response
    -- ^ Preserve or collapse the private origin status according to the native protocol.
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentForbidden :: ResponseHeaders -> Refusal -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentDenied :: ResponseHeaders -> Refusal -> response
    -- ^ Answer a listing that admitted nothing because every exclusion was a policy or integrity refusal.
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotFound :: ResponseHeaders -> Refusal -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotAcceptable :: ResponseHeaders -> Refusal -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentInternal :: ResponseHeaders -> Refusal -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentBadGateway :: ResponseHeaders -> Refusal -> response
    , forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnavailable :: ResponseHeaders -> Refusal -> response
    }

-- | Observe checked version and file rejections for native coordinate resolution.
data DocumentRejectionObserver response = DocumentRejectionObserver
    { forall response.
DocumentRejectionObserver response
-> EvalContext -> PackageDetails -> Rejection -> IO ()
observeVersionRejection :: EvalContext -> PackageDetails -> Rejection -> IO ()
    -- ^ Keep the original gate context with each checked version or file exclusion.
    , forall response. DocumentRejectionObserver response -> IO response
onCheckedNoSurvivorAdmission :: IO response
    -- ^ Resolve a checked public inventory after settled private absence and no surviving contribution.
    , forall response. DocumentRejectionObserver response -> Set Text
coordinateVersions :: Set Text
    -- ^ The versions the coordinate names under this name. Mirror coverage is checked for these alone.
    }

-- | Change only response construction while retaining shared admission and refusal decisions.
mapPackumentReplies :: (a -> b) -> PackumentReplies a -> PackumentReplies b
mapPackumentReplies :: forall a b. (a -> b) -> PackumentReplies a -> PackumentReplies b
mapPackumentReplies a -> b
convert PackumentReplies a
replies =
    PackumentReplies
        { packumentDeniedText :: [ServeDecision] -> Text
packumentDeniedText = PackumentReplies a -> [ServeDecision] -> Text
forall response.
PackumentReplies response -> [ServeDecision] -> Text
packumentDeniedText PackumentReplies a
replies
        , packumentOk :: ResponseHeaders -> LByteString -> b
packumentOk = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (LByteString -> a) -> LByteString -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> LByteString -> a
forall response.
PackumentReplies response
-> ResponseHeaders -> LByteString -> response
packumentOk PackumentReplies a
replies ResponseHeaders
headers
        , packumentNotModified :: ResponseHeaders -> b
packumentNotModified = a -> b
convert (a -> b) -> (ResponseHeaders -> a) -> ResponseHeaders -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> a
forall response.
PackumentReplies response -> ResponseHeaders -> response
packumentNotModified PackumentReplies a
replies
        , packumentUnauthorised :: ResponseHeaders -> Refusal -> b
packumentUnauthorised = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnauthorised PackumentReplies a
replies ResponseHeaders
headers
        , packumentPrivateRefused :: Int -> ResponseHeaders -> Refusal -> b
packumentPrivateRefused = \Int
code ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> Int -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response
-> Int -> ResponseHeaders -> Refusal -> response
packumentPrivateRefused PackumentReplies a
replies Int
code ResponseHeaders
headers
        , packumentForbidden :: ResponseHeaders -> Refusal -> b
packumentForbidden = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentForbidden PackumentReplies a
replies ResponseHeaders
headers
        , packumentDenied :: ResponseHeaders -> Refusal -> b
packumentDenied = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentDenied PackumentReplies a
replies ResponseHeaders
headers
        , packumentNotFound :: ResponseHeaders -> Refusal -> b
packumentNotFound = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotFound PackumentReplies a
replies ResponseHeaders
headers
        , packumentNotAcceptable :: ResponseHeaders -> Refusal -> b
packumentNotAcceptable = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotAcceptable PackumentReplies a
replies ResponseHeaders
headers
        , packumentInternal :: ResponseHeaders -> Refusal -> b
packumentInternal = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentInternal PackumentReplies a
replies ResponseHeaders
headers
        , packumentBadGateway :: ResponseHeaders -> Refusal -> b
packumentBadGateway = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentBadGateway PackumentReplies a
replies ResponseHeaders
headers
        , packumentUnavailable :: ResponseHeaders -> Refusal -> b
packumentUnavailable = \ResponseHeaders
headers -> a -> b
convert (a -> b) -> (Refusal -> a) -> Refusal -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentReplies a -> ResponseHeaders -> Refusal -> a
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnavailable PackumentReplies a
replies ResponseHeaders
headers
        }

-- | GET and HEAD use the same gate and merge. HEAD withholds the body.
packumentAction :: PackumentReplies response -> Method -> PackageName -> ResponseAction response
packumentAction :: forall response.
PackumentReplies response
-> Method -> PackageName -> ResponseAction response
packumentAction PackumentReplies response
replies Method
method PackageName
name
    | Method -> Bool
isHead Method
method = response
-> (Request
    -> (response -> IO ResponseReceived) -> Handler ResponseReceived)
-> ResponseAction response
forall response.
response
-> (Request
    -> (response -> IO ResponseReceived) -> Handler ResponseReceived)
-> ResponseAction response
RunPipeline response
perimeterFallback (PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
forall response.
PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
headPackument PackumentReplies response
replies PackageName
name)
    | Bool
otherwise = response
-> (Request
    -> (response -> IO ResponseReceived) -> Handler ResponseReceived)
-> ResponseAction response
forall response.
response
-> (Request
    -> (response -> IO ResponseReceived) -> Handler ResponseReceived)
-> ResponseAction response
RunPipeline response
perimeterFallback (PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
forall response.
PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
servePackument PackumentReplies response
replies PackageName
name)
  where
    perimeterFallback :: response
perimeterFallback = PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentInternal PackumentReplies response
replies [] (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
forall a. Maybe a
Nothing Text
"internal server error")

-- | Serve merged metadata while retaining private access authority and package identity checks.
servePackument ::
    PackumentReplies response ->
    PackageName ->
    Request ->
    (response -> IO ResponseReceived) ->
    Handler ResponseReceived
servePackument :: forall response.
PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
servePackument = PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
forall response.
PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
packumentWith PackumentServe
PackumentFull

-- | Serve the packument's GET status and headers without its body.
headPackument ::
    PackumentReplies response ->
    PackageName ->
    Request ->
    (response -> IO ResponseReceived) ->
    Handler ResponseReceived
headPackument :: forall response.
PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
headPackument = PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
forall response.
PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
packumentWith PackumentServe
PackumentHead

data PackumentServe
    = -- A @GET@: serve the merged packument body.
      PackumentFull
    | -- HEAD shares GET admission and representation headers.

      PackumentHead

data PackumentServing response = PackumentServing
    { forall response. PackumentServing response -> PackumentServe
psvMode :: PackumentServe
    , forall response.
PackumentServing response -> PackumentReplies response
psvReplies :: PackumentReplies response
    , forall response. PackumentServing response -> PackumentDeps
psvDeps :: PackumentDeps
    , forall response. PackumentServing response -> PackageName
psvName :: PackageName
    , forall response. PackumentServing response -> Request
psvRequest :: Request
    , forall response. PackumentServing response -> ServeRuntime
psvRuntime :: ServeRuntime
    , forall response. PackumentServing response -> MemoryTicket
psvTicket :: MemoryTicket
    -- ^ The request's account with the memory meter, which its reads and its output pay into.
    , forall response. PackumentServing response -> ChargePart
psvPrivateRead :: ChargePart
    -- ^ What the private read paid. It steps down to what the read keeps, and goes once the body exists.
    , forall response. PackumentServing response -> Int -> IO ()
psvInputBytes :: Int -> IO ()
    , forall response.
PackumentServing response -> Int -> IO (Either response ())
psvDocumentBytes :: Int -> IO (Either response ())
    , forall response.
PackumentServing response
-> Maybe (DocumentRejectionObserver response)
psvRejectionObserver :: Maybe (DocumentRejectionObserver response)
    , forall response. PackumentServing response -> Maybe response
psvAbsent :: Maybe response
    , forall response.
PackumentServing response
-> PackumentServing response
-> [Contribution]
-> MergePlan
-> Handler response
psvResolved :: PackumentServing response -> [Contribution] -> MergePlan -> Handler response
    , forall response. PackumentServing response -> ChargePart
psvPublicRead :: ChargePart
    -- ^ The same for the public read, which pays only when this request leads the shared fetch.
    }

servingMetrics :: PackumentServing response -> MetricsPort
servingMetrics :: forall response. PackumentServing response -> MetricsPort
servingMetrics = ServeRuntime -> MetricsPort
srMetrics (ServeRuntime -> MetricsPort)
-> (PackumentServing response -> ServeRuntime)
-> PackumentServing response
-> MetricsPort
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackumentServing response -> ServeRuntime
forall response. PackumentServing response -> ServeRuntime
psvRuntime

-- Authenticate before egress. Write after the CPU slot releases, under the memory ticket.
packumentWith ::
    PackumentServe ->
    PackumentReplies response ->
    PackageName ->
    Request ->
    (response -> IO ResponseReceived) ->
    Handler ResponseReceived
packumentWith :: forall response.
PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> (response -> IO ResponseReceived)
-> Handler ResponseReceived
packumentWith PackumentServe
mode PackumentReplies response
replies PackageName
name Request
request response -> IO ResponseReceived
respond = do
    ctx <- Handler RequestCtx
forall r (m :: * -> *). MonadReader r m => m r
ask
    let mount = RequestCtx -> MountBinding
ctxMount RequestCtx
ctx
        deps = MountBinding -> PackumentDeps
bindingPackumentDeps MountBinding
mount
        clientToken = MountBinding -> Request -> Maybe ClientCredential
forwardedCredential MountBinding
mount Request
request
        serving MemoryTicket
ticket = PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> MemoryTicket
-> (PackumentServing response
    -> [Contribution] -> MergePlan -> Handler response)
-> Handler (PackumentServing response)
forall response.
PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> MemoryTicket
-> (PackumentServing response
    -> [Contribution] -> MergePlan -> Handler response)
-> Handler (PackumentServing response)
newServing PackumentServe
mode PackumentReplies response
replies PackageName
name Request
request MemoryTicket
ticket PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
forall response.
PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
answerPackumentConditional
    if edgeTokenMatches (pdInboundToken deps) clientToken
        then withListingAdmission (ctxRuntime ctx) (\ResponseHeaders
headers -> (PackumentReplies response
 -> ResponseHeaders -> Refusal -> response)
-> ResponseHeaders -> Text -> Handler ResponseReceived
forall {m :: * -> *} {t}.
MonadIO m =>
(PackumentReplies response -> t -> Refusal -> response)
-> t -> Text -> m ResponseReceived
refuse PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnavailable ResponseHeaders
headers Text
shedMessage) (serving >=> (`serveAdmittedPackument` clientToken) >=> evaluate) (liftIO . respond)
        else refuse packumentUnauthorised [] unauthorisedMessage
  where
    refuse :: (PackumentReplies response -> t -> Refusal -> response)
-> t -> Text -> m ResponseReceived
refuse PackumentReplies response -> t -> Refusal -> response
reply t
headers Text
message = IO ResponseReceived -> m ResponseReceived
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (response -> IO ResponseReceived
respond (PackumentReplies response -> t -> Refusal -> response
reply PackumentReplies response
replies t
headers (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
forall a. Maybe a
Nothing Text
message)))

{- | Observe source sizes and checked rejections, including admission with no surviving contribution.
A caller that supplies an absent answer receives it for a name both origins answered @404@ for.
-}
withObservedAdmittedDocument ::
    PackumentReplies response ->
    MemoryTicket ->
    (Int -> IO ()) ->
    (Int -> IO (Either response ())) ->
    Maybe (DocumentRejectionObserver response) ->
    PackageName ->
    Request ->
    Maybe response ->
    (CachedDoc -> Int -> Map Text Provenance -> Handler response) ->
    Handler response
withObservedAdmittedDocument :: forall response.
PackumentReplies response
-> MemoryTicket
-> (Int -> IO ())
-> (Int -> IO (Either response ()))
-> Maybe (DocumentRejectionObserver response)
-> PackageName
-> Request
-> Maybe response
-> (CachedDoc -> Int -> Map Text Provenance -> Handler response)
-> Handler response
withObservedAdmittedDocument PackumentReplies response
replies MemoryTicket
ticket Int -> IO ()
observe Int -> IO (Either response ())
checkDocument Maybe (DocumentRejectionObserver response)
rejected PackageName
name Request
request Maybe response
absent CachedDoc -> Int -> Map Text Provenance -> Handler response
consume = do
    mount <- (RequestCtx -> MountBinding) -> Handler MountBinding
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks RequestCtx -> MountBinding
ctxMount
    let deps = MountBinding -> PackumentDeps
bindingPackumentDeps MountBinding
mount
        clientToken = MountBinding -> Request -> Maybe ClientCredential
forwardedCredential MountBinding
mount Request
request
        refuse PackumentReplies response -> [a] -> Refusal -> a
reply Text
message = a -> f a
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response -> [a] -> Refusal -> a
reply PackumentReplies response
replies [] (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
forall a. Maybe a
Nothing Text
message))
    if edgeTokenMatches (pdInboundToken deps) clientToken
        then do
            serving <- newServing PackumentFull replies name request ticket admitted
            serveAdmittedPackument serving{psvAbsent = absent, psvInputBytes = observe, psvDocumentBytes = checkDocument, psvRejectionObserver = rejected} clientToken
        else refuse packumentUnauthorised unauthorisedMessage
  where
    admitted :: PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
admitted PackumentServing response
serving [Contribution]
sources MergePlan
plan = do
        let basis :: Int
basis = MergePlan -> [Contribution] -> Int
outputBasisBytes MergePlan
plan [Contribution]
sources
            factor :: Int
factor = ChargeFactors -> Int
cfOutputPermille (AdapterMetadata -> ChargeFactors
metadataChargeFactors (PackumentDeps -> AdapterMetadata
pdMetadata (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving)))
        output <- IO ChargePart -> Handler ChargePart
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MemoryTicket -> IO ChargePart
newChargePart MemoryTicket
ticket)
        liftIO (chargePart output (scaleCharge factor basis))
        document <- evaluate (renderServedBody (psvDeps serving) sources plan)
        let origins = (Int -> Maybe Provenance) -> Map Text Int -> Map Text Provenance
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe (Int -> Map Int Provenance -> Maybe Provenance
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` [(Int, Provenance)] -> Map Int Provenance
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([Int] -> [Provenance] -> [(Int, Provenance)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 ..] ((Contribution -> Provenance) -> [Contribution] -> [Provenance]
forall a b. (a -> b) -> [a] -> [b]
map Contribution -> Provenance
srcProvenance [Contribution]
sources))) (MergePlan -> Map Text Int
mpSurvivors MergePlan
plan)
        result <- consume document (sum (map srcBodyBytes sources)) origins
        liftIO (releaseReads serving >> stepDown output 0)
        pure result

newServing ::
    PackumentServe ->
    PackumentReplies response ->
    PackageName ->
    Request ->
    MemoryTicket ->
    (PackumentServing response -> [Contribution] -> MergePlan -> Handler response) ->
    Handler (PackumentServing response)
newServing :: forall response.
PackumentServe
-> PackumentReplies response
-> PackageName
-> Request
-> MemoryTicket
-> (PackumentServing response
    -> [Contribution] -> MergePlan -> Handler response)
-> Handler (PackumentServing response)
newServing PackumentServe
mode PackumentReplies response
replies PackageName
name Request
request MemoryTicket
ticket PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
resolved = do
    ctx <- Handler RequestCtx
forall r (m :: * -> *). MonadReader r m => m r
ask
    privateRead <- liftIO (newChargePart ticket)
    publicRead <- liftIO (newChargePart ticket)
    pure
        PackumentServing
            { psvMode = mode
            , psvReplies = replies
            , psvDeps = bindingPackumentDeps (ctxMount ctx)
            , psvName = name
            , psvRequest = request
            , psvRuntime = ctxRuntime ctx
            , psvTicket = ticket
            , psvPrivateRead = privateRead
            , psvPublicRead = publicRead
            , psvInputBytes = const pass
            , psvDocumentBytes = const (pure (Right ()))
            , psvRejectionObserver = Nothing
            , psvAbsent = Nothing
            , psvResolved = resolved
            }

serveAdmittedPackument :: PackumentServing response -> Maybe ClientCredential -> Handler response
serveAdmittedPackument :: forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler response
serveAdmittedPackument PackumentServing response
serving Maybe ClientCredential
clientToken = do
    Severity -> LogStr -> Handler ()
forall (m :: * -> *).
(Applicative m, KatipContext m) =>
Severity -> LogStr -> m ()
logFM Severity
DebugS (Text -> LogStr
forall a. StringConv a Text => a -> LogStr
ls (Text
"serving packument request for " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> PackageName -> Text
renderPackageName (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving)))
    evalCtx <- IO EvalContext -> Handler EvalContext
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UTCTime -> IO (Maybe DbEtag) -> IO EvalContext
mkEvalContext (PackumentDeps -> IO UTCTime
pdNow PackumentDeps
deps) (PackumentDeps -> IO (Maybe DbEtag)
pdAdvisoryEtag PackumentDeps
deps))
    case pdMirrorState deps of
        Just MirrorView
mirror | Bool -> Bool
not (PackumentDeps -> PackageName -> Bool
pdFirstParty PackumentDeps
deps (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving)) -> do
            ((private, checked), public) <-
                Handler
  (OriginResult,
   Either
     MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
-> Handler OriginResult
-> Handler
     ((OriginResult,
       Either
         MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord))),
      OriginResult)
forall (m :: * -> *) a b. MonadUnliftIO m => m a -> m b -> m (a, b)
concurrently
                    ( do
                        private <- PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
readPrivate PackumentServing response
serving Maybe ClientCredential
clientToken
                        checked <-
                            if refusesBeforeMirror private
                                then pure (Right Nothing)
                                else liftIO (validateMirrorProject mirror (psvTicket serving) (psvName serving))
                        pure (private, checked)
                    )
                    (PackumentServing response -> Handler OriginResult
forall response. PackumentServing response -> Handler OriginResult
readPublic PackumentServing response
serving)
            case private of
                OriginAuthorisationFailure Int
code -> PackumentServing response -> Int -> Handler response
forall response.
PackumentServing response -> Int -> Handler response
privateAccessRefused PackumentServing response
serving Int
code
                OriginResult
_ -> case Either
  MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord))
checked of
                    Left MirrorStateFault
_ -> PackumentServing response -> Handler response
forall response. PackumentServing response -> Handler response
mirrorUnavailable PackumentServing response
serving
                    Right Maybe (StateRevision, ProjectMirrorRecord)
record -> PackumentServing response
-> EvalContext
-> Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
-> OriginResult
-> OriginResult
-> Handler response
forall response.
PackumentServing response
-> EvalContext
-> Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
-> OriginResult
-> OriginResult
-> Handler response
serveMergedPackument PackumentServing response
serving EvalContext
evalCtx ((MirrorView -> MirrorDocuments
mirrorViewDocuments MirrorView
mirror,) ((StateRevision, ProjectMirrorRecord)
 -> (MirrorDocuments, (StateRevision, ProjectMirrorRecord)))
-> Maybe (StateRevision, ProjectMirrorRecord)
-> Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (StateRevision, ProjectMirrorRecord)
record) OriginResult
private OriginResult
public
        Maybe MirrorView
_ -> do
            (private, public) <- PackumentServing response
-> Maybe ClientCredential -> Handler (OriginResult, OriginResult)
forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler (OriginResult, OriginResult)
resolveOrigins PackumentServing response
serving Maybe ClientCredential
clientToken
            case private of
                OriginAuthorisationFailure Int
code -> PackumentServing response -> Int -> Handler response
forall response.
PackumentServing response -> Int -> Handler response
privateAccessRefused PackumentServing response
serving Int
code
                OriginResult
_ -> PackumentServing response
-> EvalContext
-> Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
-> OriginResult
-> OriginResult
-> Handler response
forall response.
PackumentServing response
-> EvalContext
-> Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
-> OriginResult
-> OriginResult
-> Handler response
serveMergedPackument PackumentServing response
serving EvalContext
evalCtx Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
forall a. Maybe a
Nothing OriginResult
private OriginResult
public
  where
    deps :: PackumentDeps
deps = PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving

-- An access refusal or a failed private read decides the request before mirror state can.
refusesBeforeMirror :: OriginResult -> Bool
refusesBeforeMirror :: OriginResult -> Bool
refusesBeforeMirror = \case
    OriginAuthorisationFailure Int
_ -> Bool
True
    OriginResult
result -> case OriginResult -> Maybe OriginMiss
originMiss OriginResult
result of
        Just (MissUnresolved ReadFailure
_) -> Bool
True
        Maybe OriginMiss
_ -> Bool
False

resolveOrigins :: PackumentServing response -> Maybe ClientCredential -> Handler (OriginResult, OriginResult)
resolveOrigins :: forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler (OriginResult, OriginResult)
resolveOrigins PackumentServing response
serving Maybe ClientCredential
clientToken
    | PackumentDeps -> PackageName -> Bool
pdFirstParty (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving) (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving) = (,OriginResult
OriginAbsent) (OriginResult -> (OriginResult, OriginResult))
-> Handler OriginResult -> Handler (OriginResult, OriginResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
readPrivate PackumentServing response
serving Maybe ClientCredential
clientToken
    | Bool
otherwise = Handler OriginResult
-> Handler OriginResult -> Handler (OriginResult, OriginResult)
forall (m :: * -> *) a b. MonadUnliftIO m => m a -> m b -> m (a, b)
concurrently (PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
readPrivate PackumentServing response
serving Maybe ClientCredential
clientToken) (PackumentServing response -> Handler OriginResult
forall response. PackumentServing response -> Handler OriginResult
readPublic PackumentServing response
serving)

readPrivate :: PackumentServing response -> Maybe ClientCredential -> Handler OriginResult
readPrivate :: forall response.
PackumentServing response
-> Maybe ClientCredential -> Handler OriginResult
readPrivate PackumentServing response
serving Maybe ClientCredential
clientToken = (Int -> IO ())
-> PackumentDeps
-> ServeRuntime
-> ChargePart
-> Maybe ClientCredential
-> PackageName
-> Handler OriginResult
fetchPrivateOriginObserved (PackumentServing response -> Int -> IO ()
forall response. PackumentServing response -> Int -> IO ()
psvInputBytes PackumentServing response
serving) (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving) (PackumentServing response -> ServeRuntime
forall response. PackumentServing response -> ServeRuntime
psvRuntime PackumentServing response
serving) (PackumentServing response -> ChargePart
forall response. PackumentServing response -> ChargePart
psvPrivateRead PackumentServing response
serving) Maybe ClientCredential
clientToken (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving)

readPublic :: PackumentServing response -> Handler OriginResult
readPublic :: forall response. PackumentServing response -> Handler OriginResult
readPublic PackumentServing response
serving = (Int -> IO ())
-> PackumentDeps
-> ServeRuntime
-> MemoryTicket
-> ChargePart
-> PackageName
-> Handler OriginResult
fetchPublicOriginObserved (PackumentServing response -> Int -> IO ()
forall response. PackumentServing response -> Int -> IO ()
psvInputBytes PackumentServing response
serving) (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving) (PackumentServing response -> ServeRuntime
forall response. PackumentServing response -> ServeRuntime
psvRuntime PackumentServing response
serving) (PackumentServing response -> MemoryTicket
forall response. PackumentServing response -> MemoryTicket
psvTicket PackumentServing response
serving) (PackumentServing response -> ChargePart
forall response. PackumentServing response -> ChargePart
psvPublicRead PackumentServing response
serving) (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving)

privateAccessRefused :: PackumentServing response -> Int -> Handler response
privateAccessRefused :: forall response.
PackumentServing response -> Int -> Handler response
privateAccessRefused PackumentServing response
serving Int
code = do
    IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> Decision -> IO ()
mpServeDecision (PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving) Decision
Metric.Deny)
    response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response
-> Int -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response
-> Int -> ResponseHeaders -> Refusal -> response
packumentPrivateRefused (PackumentServing response -> PackumentReplies response
forall response.
PackumentServing response -> PackumentReplies response
psvReplies PackumentServing response
serving) Int
code [] (Maybe HelpMessage -> Refusal
privateAuthorisationRefusal (PackumentDeps -> Maybe HelpMessage
pdHelp (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving))))

serveMergedPackument ::
    PackumentServing response ->
    EvalContext ->
    Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord)) ->
    OriginResult ->
    OriginResult ->
    Handler response
serveMergedPackument :: forall response.
PackumentServing response
-> EvalContext
-> Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
-> OriginResult
-> OriginResult
-> Handler response
serveMergedPackument PackumentServing response
serving EvalContext
evalCtx Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
record OriginResult
privResult OriginResult
pubResult
    | OriginBudgetExceeded LimitError
fault <- OriginResult
privResult = LimitError -> Handler response
forall {a}. Show a => a -> Handler response
budgetRefused LimitError
fault
    | Just (MissUnresolved ReadFailure
failure) <- OriginResult -> Maybe OriginMiss
originMiss OriginResult
privResult = PackumentServing response
-> EvalContext -> OriginResult -> ReadFailure -> Handler response
forall response.
PackumentServing response
-> EvalContext -> OriginResult -> ReadFailure -> Handler response
privateUnresolved PackumentServing response
serving EvalContext
evalCtx OriginResult
privResult ReadFailure
failure
    | OriginBudgetExceeded LimitError
fault <- OriginResult
pubResult = LimitError -> Handler response
forall {a}. Show a => a -> Handler response
budgetRefused LimitError
fault
    | Bool -> Bool
not (PackumentDeps -> PackageName -> Bool
pdFirstParty PackumentDeps
deps PackageName
name)
    , OriginResult -> Bool
settledAbsence OriginResult
privResult
    , OriginResult -> Bool
settledAbsence OriginResult
pubResult
    , Just Handler response
answer <- Maybe (Handler response)
unheldAnswer =
        Handler response
answer
    | Bool
otherwise = PackumentServing response
-> [Manifest] -> Handler response -> Handler response
forall response.
PackumentServing response
-> [Manifest] -> Handler response -> Handler response
withCheckedSourceDocuments PackumentServing response
serving ([Maybe Manifest] -> [Manifest]
forall a. [Maybe a] -> [a]
catMaybes [OriginResult -> Maybe Manifest
originManifest OriginResult
privResult, OriginResult -> Maybe Manifest
originManifest OriginResult
pubResult]) (Handler response -> Handler response)
-> Handler response -> Handler response
forall a b. (a -> b) -> a -> b
$ case Either
  MirrorStateFault
  (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
views of
        Left MirrorStateFault
_ -> PackumentServing response -> Handler response
forall response. PackumentServing response -> Handler response
mirrorUnavailable PackumentServing response
serving
        Right (Maybe Manifest
unmanagedManifest, Maybe Manifest
managedManifest, Map Text MirrorVersion
pending) -> do
            let (Maybe Contribution
unmanaged, [VersionVerdict]
privateExclusions) = MinTrustedIntegrity
-> Maybe Manifest -> (Maybe Contribution, [VersionVerdict])
admitTrusted (PackumentDeps -> MinTrustedIntegrity
pdMinTrustedIntegrity PackumentDeps
deps) Maybe Manifest
unmanagedManifest
                (Maybe Contribution
managed, [VersionVerdict]
managedExclusions) = MinTrustedIntegrity
-> Maybe Manifest -> (Maybe Contribution, [VersionVerdict])
admitTrusted (PackumentDeps -> MinTrustedIntegrity
pdMinTrustedIntegrity PackumentDeps
deps) Maybe Manifest
managedManifest
                privateSources :: [Contribution]
privateSources = [Maybe Contribution] -> [Contribution]
forall a. [Maybe a] -> [a]
catMaybes [Maybe Contribution
unmanaged, Maybe Contribution
managed]
                trustedVersions :: Map Text PackageDetails
trustedVersions = [Map Text PackageDetails] -> Map Text PackageDetails
forall (f :: * -> *) k a.
(Foldable f, Ord k) =>
f (Map k a) -> Map k a
Map.unions ((Contribution -> Map Text PackageDetails)
-> [Contribution] -> [Map Text PackageDetails]
forall a b. (a -> b) -> [a] -> [b]
map (PackageInfo -> Map Text PackageDetails
infoVersions (PackageInfo -> Map Text PackageDetails)
-> (Contribution -> PackageInfo)
-> Contribution
-> Map Text PackageDetails
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Contribution -> PackageInfo
srcInfo) [Contribution]
privateSources)
                -- A public version that a private one claims under another spelling of its release is not offered.
                publicManifest :: Maybe Manifest
publicManifest = (\Manifest
manifest -> Manifest
manifest{manifestInfo = withoutTrustedReleases trustedVersions (manifestInfo manifest)}) (Manifest -> Manifest) -> Maybe Manifest -> Maybe Manifest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OriginResult -> Maybe Manifest
originManifest OriginResult
pubResult
            public <- IO PublicAdmission -> Handler PublicAdmission
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Maybe (EvalContext -> PackageDetails -> Rejection -> IO ())
-> TracingPort
-> MetricsPort
-> PackumentDeps
-> PackageName
-> EvalContext
-> Map Text PackageDetails
-> Set Text
-> Maybe Manifest
-> IO PublicAdmission
gatePublic (DocumentRejectionObserver response
-> EvalContext -> PackageDetails -> Rejection -> IO ()
forall response.
DocumentRejectionObserver response
-> EvalContext -> PackageDetails -> Rejection -> IO ()
observeVersionRejection (DocumentRejectionObserver response
 -> EvalContext -> PackageDetails -> Rejection -> IO ())
-> Maybe (DocumentRejectionObserver response)
-> Maybe (EvalContext -> PackageDetails -> Rejection -> IO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackumentServing response
-> Maybe (DocumentRejectionObserver response)
forall response.
PackumentServing response
-> Maybe (DocumentRejectionObserver response)
psvRejectionObserver PackumentServing response
serving) (ServeRuntime -> TracingPort
srTracing ServeRuntime
rt) (PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving) PackumentDeps
deps PackageName
name EvalContext
evalCtx Map Text PackageDetails
trustedVersions (Map Text MirrorVersion -> Set Text
forall k a. Map k a -> Set k
Map.keysSet Map Text MirrorVersion
pending) Maybe Manifest
publicManifest)
            let sources = [Contribution]
privateSources [Contribution] -> [Contribution] -> [Contribution]
forall a. Semigroup a => a -> a -> a
<> Maybe Contribution -> [Contribution]
forall a. Maybe a -> [a]
maybeToList (PublicAdmission -> Maybe Contribution
paContribution PublicAdmission
public)
                -- A coordinate lookup checks mirror coverage for the versions it names alone, as Cargo and PyPI do.
                named = DocumentRejectionObserver response -> Set Text
forall response. DocumentRejectionObserver response -> Set Text
coordinateVersions (DocumentRejectionObserver response -> Set Text)
-> Maybe (DocumentRejectionObserver response) -> Maybe (Set Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackumentServing response
-> Maybe (DocumentRejectionObserver response)
forall response.
PackumentServing response
-> Maybe (DocumentRejectionObserver response)
psvRejectionObserver PackumentServing response
serving
                requested = Map Text MirrorVersion
-> (Set Text -> Map Text MirrorVersion)
-> Maybe (Set Text)
-> Map Text MirrorVersion
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Map Text MirrorVersion
pending (Map Text MirrorVersion -> Set Text -> Map Text MirrorVersion
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.restrictKeys Map Text MirrorVersion
pending) Maybe (Set Text)
named
                gone = Map Text MirrorVersion -> Set Text
forall {a}. Map Text a -> Set Text
goneFromBoth Map Text MirrorVersion
requested
                required = Map Text MirrorVersion -> Set Text -> Map Text MirrorVersion
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys Map Text MirrorVersion
requested (PublicAdmission -> Set Text
paBlockedPending PublicAdmission
public Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
gone)
                covered = Map Text MirrorVersion -> Bool
forall k a. Map k a -> Bool
Map.null Map Text MirrorVersion
required Bool -> Bool -> Bool
|| Bool -> (Contribution -> Bool) -> Maybe Contribution -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Map Text MirrorVersion -> PackageInfo -> Bool
publicMirrorCoverage Map Text MirrorVersion
required (PackageInfo -> Bool)
-> (Contribution -> PackageInfo) -> Contribution -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Contribution -> PackageInfo
srcInfo) (PublicAdmission -> Maybe Contribution
paContribution PublicAdmission
public)
            if not covered || fmap (infoVersions . manifestInfo) managedManifest /= fmap (infoVersions . srcInfo) managed
                then mirrorUnavailableWithRetry serving (case pubResult of OriginCooling RetryAfter
retry -> RetryAfter -> Maybe RetryAfter
forall a. a -> Maybe a
Just RetryAfter
retry; OriginResult
_ -> Maybe RetryAfter
forall a. Maybe a
Nothing)
                else case originMiss privResult of
                    Just OriginMiss
MissAbsent | PackumentDeps -> PackageName -> Bool
pdFirstParty PackumentDeps
deps PackageName
name -> PackumentServing response -> OriginMiss -> Handler response
forall response.
PackumentServing response -> OriginMiss -> Handler response
firstPartyMissed PackumentServing response
serving OriginMiss
MissAbsent
                    -- Every version the coordinate names is recorded and gone from both upstreams, whatever else the public lists.
                    Maybe OriginMiss
_ | Just Set Text
versions <- Maybe (Set Text)
named, Bool -> Bool
not (Set Text -> Bool
forall a. Set a -> Bool
Set.null Set Text
versions), Set Text
versions Set Text -> Set Text -> Bool
forall a. Ord a => Set a -> Set a -> Bool
`Set.isSubsetOf` Set Text
gone -> Text -> Handler response
forall {m :: * -> *}. MonadIO m => Text -> m response
notFound Text
"no upstream lists the requested version"
                    Maybe OriginMiss
_ -> case [Contribution]
-> Map Text PackageDetails
-> Map Text PackageDetails
-> Maybe MergePlan
packumentPlan [Contribution]
sources Map Text PackageDetails
trustedVersions (PublicAdmission -> Map Text PackageDetails
paDeniedEvidence PublicAdmission
public) of
                        Just MergePlan
plan -> do
                            IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> Handler ()) -> IO () -> Handler ()
forall a b. (a -> b) -> a -> b
$ do
                                PublicAdmission -> IO ()
paReportRejections PublicAdmission
public
                                Maybe (DocumentRejectionObserver response)
-> (DocumentRejectionObserver response -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (PackumentServing response
-> Maybe (DocumentRejectionObserver response)
forall response.
PackumentServing response
-> Maybe (DocumentRejectionObserver response)
psvRejectionObserver PackumentServing response
serving) ((DocumentRejectionObserver response -> IO ()) -> IO ())
-> (DocumentRejectionObserver response -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DocumentRejectionObserver response
observer ->
                                    [Manifest] -> (Manifest -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ ([Maybe Manifest] -> [Manifest]
forall a. [Maybe a] -> [a]
catMaybes [Maybe Manifest
unmanagedManifest, Maybe Manifest
managedManifest]) ((Manifest -> IO ()) -> IO ()) -> (Manifest -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Manifest
manifest ->
                                        (EvalContext -> PackageDetails -> Rejection -> IO ())
-> EvalContext
-> MinTrustedIntegrity
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> IO ()
forall floor.
IntegrityFloor floor =>
(EvalContext -> PackageDetails -> Rejection -> IO ())
-> EvalContext
-> floor
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> IO ()
reportIntegrityRejections (DocumentRejectionObserver response
-> EvalContext -> PackageDetails -> Rejection -> IO ()
forall response.
DocumentRejectionObserver response
-> EvalContext -> PackageDetails -> Rejection -> IO ()
observeVersionRejection DocumentRejectionObserver response
observer) EvalContext
evalCtx (PackumentDeps -> MinTrustedIntegrity
pdMinTrustedIntegrity PackumentDeps
deps) ServeDecision
trustedIntegrityBelowFloor ServeDecision
trustedIntegrityMissing (Manifest -> PackageInfo
manifestInfo Manifest
manifest)
                            PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
forall response.
PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
serveResolved PackumentServing response
serving [Contribution]
sources MergePlan
plan
                        Maybe MergePlan
Nothing
                            | Just DocumentRejectionObserver response
observer <- PackumentServing response
-> Maybe (DocumentRejectionObserver response)
forall response.
PackumentServing response
-> Maybe (DocumentRejectionObserver response)
psvRejectionObserver PackumentServing response
serving
                            , OriginResult -> Bool
settledAbsence OriginResult
privResult
                            , Just Manifest
manifest <- OriginResult -> Maybe Manifest
originManifest OriginResult
pubResult
                            , [InvalidEntry] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (PackageInfo -> [InvalidEntry]
infoInvalidEntries (Manifest -> PackageInfo
manifestInfo Manifest
manifest)) ->
                                IO response -> Handler response
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (PublicAdmission -> IO ()
paReportRejections PublicAdmission
public IO () -> IO response -> IO response
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DocumentRejectionObserver response -> IO response
forall response. DocumentRejectionObserver response -> IO response
onCheckedNoSurvivorAdmission DocumentRejectionObserver response
observer)
                            | Bool
otherwise ->
                                let refused :: [VersionVerdict]
refused = [VersionVerdict]
privateExclusions [VersionVerdict] -> [VersionVerdict] -> [VersionVerdict]
forall a. Semigroup a => a -> a -> a
<> [VersionVerdict]
managedExclusions [VersionVerdict] -> [VersionVerdict] -> [VersionVerdict]
forall a. Semigroup a => a -> a -> a
<> PublicAdmission -> [VersionVerdict]
paVerdicts PublicAdmission
public
                                 in case OriginResult -> OriginResult -> [ServeDecision] -> [ServeDecision]
collectDecisions OriginResult
privResult OriginResult
pubResult ((VersionVerdict -> ServeDecision)
-> [VersionVerdict] -> [ServeDecision]
forall a b. (a -> b) -> [a] -> [b]
map VersionVerdict -> ServeDecision
vvDecision [VersionVerdict]
refused) of
                                        [] -> [VersionVerdict] -> Handler response
unlisted [VersionVerdict]
refused
                                        [ServeDecision]
decisions -> PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
forall response.
PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
noServeableVersions PackumentServing response
serving (EvalContext -> Maybe DbEtag
ctxAdvisoryEtag EvalContext
evalCtx) [VersionVerdict]
refused [ServeDecision]
decisions
  where
    budgetRefused :: a -> Handler response
budgetRefused a
fault =
        PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
forall response.
PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
noServeableVersions PackumentServing response
serving (EvalContext -> Maybe DbEtag
ctxAdvisoryEtag EvalContext
evalCtx) [] [Rejection -> ServeDecision
Reject (RejectReason -> Text -> Rejection
Rejection RejectReason
UpstreamInvalid (Text
"the cumulative metadata input exceeded its bound: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> a -> Text
forall b a. (Show a, IsString b) => a -> b
show a
fault))]
    settledAbsence :: OriginResult -> Bool
settledAbsence OriginResult
OriginAbsent = Bool
True
    settledAbsence OriginResult
OriginNotFound = Bool
True
    settledAbsence OriginResult
_ = Bool
False
    -- A listing answers 404 with this cause, and a coordinate lookup takes its own answer.
    notFound :: Text -> m response
notFound Text
message = m response
-> (response -> m response) -> Maybe response -> m response
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (IO response -> m response
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort
-> PackumentReplies response
-> Maybe HelpMessage
-> Text
-> IO response
forall response.
MetricsPort
-> PackumentReplies response
-> Maybe HelpMessage
-> Text
-> IO response
notFoundReply (PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving) (PackumentServing response -> PackumentReplies response
forall response.
PackumentServing response -> PackumentReplies response
psvReplies PackumentServing response
serving) (PackumentDeps -> Maybe HelpMessage
pdHelp PackumentDeps
deps) Text
message)) response -> m response
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentServing response -> Maybe response
forall response. PackumentServing response -> Maybe response
psvAbsent PackumentServing response
serving)
    unheldAnswer :: Maybe (Handler response)
unheldAnswer
        | Bool
noRecordedCopy = Handler response -> Maybe (Handler response)
forall a. a -> Maybe a
Just (Text -> Handler response
forall {m :: * -> *}. MonadIO m => Text -> m response
notFound (PackumentDeps -> Text
unheldMessage PackumentDeps
deps))
        | Bool
otherwise = Maybe (Handler response)
forall a. Maybe a
Nothing
    -- With no other cause, documents that dropped every version entry refuse the request, each named in one line beside
    -- its read's log of the entries. Documents that list no version leave a 404.
    unlisted :: [VersionVerdict] -> Handler response
unlisted [VersionVerdict]
refused = case [(Text
upstream, Text
url, Manifest
manifest) | (Text
upstream, Text
url, OriginResult
result) <- [(Text, Text, OriginResult)]
origins, Just Manifest
manifest <- [OriginResult -> Maybe Manifest
originManifest OriginResult
result], Manifest -> Bool
droppedEveryEntry Manifest
manifest] of
        [] -> Text -> Handler response
forall {m :: * -> *}. MonadIO m => Text -> m response
notFound Text
"no upstream lists a version of the requested package"
        [(Text, Text, Manifest)]
dropped -> do
            [(Text, Text, Manifest)]
-> ((Text, Text, Manifest) -> Handler ()) -> Handler ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [(Text, Text, Manifest)]
dropped (((Text, Text, Manifest) -> Handler ()) -> Handler ())
-> ((Text, Text, Manifest) -> Handler ()) -> Handler ()
forall a b. (a -> b) -> a -> b
$ \(Text
upstream, Text
url, Manifest
manifest) -> PackageName -> Text -> Text -> Int -> Handler ()
forall (m :: * -> *).
KatipContext m =>
PackageName -> Text -> Text -> Int -> m ()
logVersionlessRefusal PackageName
name Text
upstream Text
url ([InvalidEntry] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (PackageInfo -> [InvalidEntry]
infoInvalidEntries (Manifest -> PackageInfo
manifestInfo Manifest
manifest)))
            PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
forall response.
PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
noServeableVersions PackumentServing response
serving (EvalContext -> Maybe DbEtag
ctxAdvisoryEtag EvalContext
evalCtx) [VersionVerdict]
refused [[Text] -> ServeDecision
malformedEntries [Text
upstream | (Text
upstream, Text
_, Manifest
_) <- [(Text, Text, Manifest)]
dropped]]
    origins :: [(Text, Text, OriginResult)]
origins = [(Text
"the private upstream", Text -> (RegistryUrl -> Text) -> Maybe RegistryUrl -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" RegistryUrl -> Text
registryUrlText (PackumentDeps -> Maybe RegistryUrl
pdPrivateBaseUrl PackumentDeps
deps), OriginResult
privResult), (Text
"the public upstream", RegistryUrl -> Text
registryUrlText (PackumentDeps -> RegistryUrl
pdPublicBaseUrl PackumentDeps
deps), OriginResult
pubResult)]
    -- Beside a private 404, a coordinate lookup releases the recorded versions the public document lacks too, so
    -- their artifacts answer 404 as on Cargo and PyPI. A listing keeps them.
    goneFromBoth :: Map Text a -> Set Text
goneFromBoth Map Text a
pending = case OriginResult -> Maybe Manifest
originManifest OriginResult
pubResult of
        Just Manifest
manifest | Maybe response -> Bool
forall a. Maybe a -> Bool
isJust (PackumentServing response -> Maybe response
forall response. PackumentServing response -> Maybe response
psvAbsent PackumentServing response
serving), OriginResult -> Bool
settledAbsence OriginResult
privResult -> Map Text a -> Set Text
forall k a. Map k a -> Set k
Map.keysSet (Map Text a -> Set Text -> Map Text a
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys Map Text a
pending (Map Text PackageDetails -> Set Text
forall k a. Map k a -> Set k
Map.keysSet (PackageInfo -> Map Text PackageDetails
infoVersions (Manifest -> PackageInfo
manifestInfo Manifest
manifest))))
        Maybe Manifest
_ -> Set Text
forall a. Set a
Set.empty
    noRecordedCopy :: Bool
noRecordedCopy = (MirrorStateFault -> Bool)
-> ((Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
    -> Bool)
-> Either
     MirrorStateFault
     (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
-> Bool
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Bool -> MirrorStateFault -> Bool
forall a b. a -> b -> a
const Bool
False) (\(Maybe Manifest
_, Maybe Manifest
managed, Map Text MirrorVersion
_) -> Maybe Manifest -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Manifest
managed) Either
  MirrorStateFault
  (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
views
    deps :: PackumentDeps
deps = PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving
    name :: PackageName
name = PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving
    rt :: ServeRuntime
rt = PackumentServing response -> ServeRuntime
forall response. PackumentServing response -> ServeRuntime
psvRuntime PackumentServing response
serving
    views :: Either
  MirrorStateFault
  (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
views = case Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
record of
        Maybe (MirrorDocuments, (StateRevision, ProjectMirrorRecord))
Nothing -> (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
-> Either
     MirrorStateFault
     (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
forall a b. b -> Either a b
Right (OriginResult -> Maybe Manifest
originManifest OriginResult
privResult, Maybe Manifest
forall a. Maybe a
Nothing, Map Text MirrorVersion
forall k a. Map k a
Map.empty)
        Just (MirrorDocuments
documents, (StateRevision
revision, ProjectMirrorRecord
current)) -> MirrorDocuments
-> StateRevision
-> ProjectMirrorRecord
-> Maybe Manifest
-> Either
     MirrorStateFault
     (Maybe Manifest, Maybe Manifest, Map Text MirrorVersion)
mirrorProjectViews MirrorDocuments
documents StateRevision
revision ProjectMirrorRecord
current (OriginResult -> Maybe Manifest
originManifest OriginResult
privResult)

withCheckedSourceDocuments :: PackumentServing response -> [Manifest] -> Handler response -> Handler response
withCheckedSourceDocuments :: forall response.
PackumentServing response
-> [Manifest] -> Handler response -> Handler response
withCheckedSourceDocuments PackumentServing response
serving [Manifest]
manifests Handler response
action = [Manifest] -> Handler response
go [Manifest]
manifests
  where
    go :: [Manifest] -> Handler response
go [] = Handler response
action
    go (Manifest
manifest : [Manifest]
rest) = do
        checked <- IO (Either response ()) -> Handler (Either response ())
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (PackumentServing response -> Int -> IO (Either response ())
forall response.
PackumentServing response -> Int -> IO (Either response ())
psvDocumentBytes PackumentServing response
serving (Manifest -> Int
manifestBodyBytes Manifest
manifest))
        case checked of
            Left response
refusal -> response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure response
refusal
            Right () -> [Manifest] -> Handler response
go [Manifest]
rest

mirrorUnavailable :: PackumentServing response -> Handler response
mirrorUnavailable :: forall response. PackumentServing response -> Handler response
mirrorUnavailable PackumentServing response
serving = PackumentServing response -> Maybe RetryAfter -> Handler response
forall response.
PackumentServing response -> Maybe RetryAfter -> Handler response
mirrorUnavailableWithRetry PackumentServing response
serving Maybe RetryAfter
forall a. Maybe a
Nothing

mirrorUnavailableWithRetry :: PackumentServing response -> Maybe RetryAfter -> Handler response
mirrorUnavailableWithRetry :: forall response.
PackumentServing response -> Maybe RetryAfter -> Handler response
mirrorUnavailableWithRetry PackumentServing response
serving Maybe RetryAfter
retry = do
    IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> Decision -> IO ()
mpServeDecision (PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving) Decision
Metric.Unavailable)
    response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnavailable (PackumentServing response -> PackumentReplies response
forall response.
PackumentServing response -> PackumentReplies response
psvReplies PackumentServing response
serving) (Maybe RetryAfter -> ResponseHeaders
retryAfterHeaders Maybe RetryAfter
retry) (Maybe HelpMessage -> Text -> Refusal
mkRefusal (PackumentDeps -> Maybe HelpMessage
pdHelp (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving)) Text
"managed mirror view is unavailable"))

admitTrusted :: MinTrustedIntegrity -> Maybe Manifest -> (Maybe Contribution, [VersionVerdict])
admitTrusted :: MinTrustedIntegrity
-> Maybe Manifest -> (Maybe Contribution, [VersionVerdict])
admitTrusted MinTrustedIntegrity
minTrusted = \case
    Maybe Manifest
Nothing -> (Maybe Contribution
forall a. Maybe a
Nothing, [])
    Just Manifest
manifest ->
        let (PackageInfo
admissible, [VersionVerdict]
integrityRefusals) =
                MinTrustedIntegrity
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> (PackageInfo, [VersionVerdict])
forall floor.
IntegrityFloor floor =>
floor
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> (PackageInfo, [VersionVerdict])
admitByIntegrity MinTrustedIntegrity
minTrusted ServeDecision
trustedIntegrityBelowFloor ServeDecision
trustedIntegrityMissing (Manifest -> PackageInfo
manifestInfo Manifest
manifest)
         in if Map Text PackageDetails -> Bool
forall k a. Map k a -> Bool
Map.null (PackageInfo -> Map Text PackageDetails
infoVersions PackageInfo
admissible)
                then (Maybe Contribution
forall a. Maybe a
Nothing, [VersionVerdict]
integrityRefusals)
                else (Contribution -> Maybe Contribution
forall a. a -> Maybe a
Just (Provenance
-> PackageInfo -> CachedDoc -> ContentDigest -> Int -> Contribution
Contribution Provenance
TrustedSource PackageInfo
admissible (Manifest -> CachedDoc
manifestRaw Manifest
manifest) (Manifest -> ContentDigest
manifestDigest Manifest
manifest) (Manifest -> Int
manifestBodyBytes Manifest
manifest)), [VersionVerdict]
integrityRefusals)

data PublicAdmission = PublicAdmission
    { PublicAdmission -> Maybe Contribution
paContribution :: Maybe Contribution
    , -- Every integrity refusal, and the rule verdicts when no version survives.
      PublicAdmission -> [VersionVerdict]
paVerdicts :: [VersionVerdict]
    , PublicAdmission -> Set Text
paBlockedPending :: Set Text
    , -- Only named denials release a missing recorded version from coverage.
      PublicAdmission -> Map Text PackageDetails
paDeniedEvidence :: Map Text PackageDetails
    , -- Integrity-admitted but rule-denied versions contribute alarms, never served entries.
      PublicAdmission -> IO ()
paReportRejections :: IO ()
    }

gatePublic :: Maybe (EvalContext -> PackageDetails -> Rejection -> IO ()) -> TracingPort -> MetricsPort -> PackumentDeps -> PackageName -> EvalContext -> Map Text PackageDetails -> Set Text -> Maybe Manifest -> IO PublicAdmission
gatePublic :: Maybe (EvalContext -> PackageDetails -> Rejection -> IO ())
-> TracingPort
-> MetricsPort
-> PackumentDeps
-> PackageName
-> EvalContext
-> Map Text PackageDetails
-> Set Text
-> Maybe Manifest
-> IO PublicAdmission
gatePublic Maybe (EvalContext -> PackageDetails -> Rejection -> IO ())
rejected TracingPort
tracing MetricsPort
metrics PackumentDeps
deps PackageName
name EvalContext
ctx Map Text PackageDetails
trustedVersions Set Text
pendingVersions = \case
    Maybe Manifest
Nothing -> PublicAdmission -> IO PublicAdmission
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Contribution
-> [VersionVerdict]
-> Set Text
-> Map Text PackageDetails
-> IO ()
-> PublicAdmission
PublicAdmission Maybe Contribution
forall a. Maybe a
Nothing [] Set Text
forall a. Set a
Set.empty Map Text PackageDetails
forall k a. Map k a
Map.empty IO ()
forall (f :: * -> *). Applicative f => f ()
pass)
    Just Manifest
manifest -> TracingPort -> forall a. PackageName -> IO a -> IO a
spanPackumentGate TracingPort
tracing PackageName
name (IO PublicAdmission -> IO PublicAdmission)
-> IO PublicAdmission -> IO PublicAdmission
forall a b. (a -> b) -> a -> b
$ do
        let (PackageInfo
admissible, [VersionVerdict]
integrityRefusals) = MinIntegrity
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> (PackageInfo, [VersionVerdict])
forall floor.
IntegrityFloor floor =>
floor
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> (PackageInfo, [VersionVerdict])
admitByIntegrity (PackumentDeps -> MinIntegrity
pdMinIntegrity PackumentDeps
deps) ServeDecision
integrityBelowFloor ServeDecision
integrityMissing (Manifest -> PackageInfo
manifestInfo Manifest
manifest)
        (decisions, seconds) <- IO (Map Text Decision) -> IO (Map Text Decision, Double)
forall (m :: * -> *) a. MonadIO m => m a -> m (a, Double)
timedSeconds (PackumentDeps
-> EvalContext -> PackageInfo -> IO (Map Text Decision)
decideVersions PackumentDeps
deps EvalContext
ctx PackageInfo
admissible)
        mpRuleEvalDuration metrics (evalTier (pdRules deps)) seconds
        recordEffectfulFailures metrics (Map.elems decisions)
        let plan = Map Text Decision -> FilterPlan
filterPlanFromDecisions Map Text Decision
decisions
            blockedPending = [Text] -> Set Text
forall a. Ord a => [a] -> Set a
Set.fromList [Text
version | (Text
version, Blocked{}) <- Map Text Decision -> [(Text, Decision)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map Text Decision -> Set Text -> Map Text Decision
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.restrictKeys Map Text Decision
decisions Set Text
pendingVersions)]
            deniedEvidence = Map Text PackageDetails -> Set Text -> Map Text PackageDetails
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys (Map Text PackageDetails
-> Map Text PackageDetails -> Map Text PackageDetails
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection (PackageInfo -> Map Text PackageDetails
infoVersions PackageInfo
admissible) Map Text PackageDetails
trustedVersions) (FilterPlan -> Set Text
fpSurvivors FilterPlan
plan)
            reportRejections = Maybe (EvalContext -> PackageDetails -> Rejection -> IO ())
-> ((EvalContext -> PackageDetails -> Rejection -> IO ()) -> IO ())
-> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ Maybe (EvalContext -> PackageDetails -> Rejection -> IO ())
rejected (((EvalContext -> PackageDetails -> Rejection -> IO ()) -> IO ())
 -> IO ())
-> ((EvalContext -> PackageDetails -> Rejection -> IO ()) -> IO ())
-> IO ()
forall a b. (a -> b) -> a -> b
$ \EvalContext -> PackageDetails -> Rejection -> IO ()
report -> do
                (EvalContext -> PackageDetails -> Rejection -> IO ())
-> EvalContext
-> MinIntegrity
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> IO ()
forall floor.
IntegrityFloor floor =>
(EvalContext -> PackageDetails -> Rejection -> IO ())
-> EvalContext
-> floor
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> IO ()
reportIntegrityRejections EvalContext -> PackageDetails -> Rejection -> IO ()
report EvalContext
ctx (PackumentDeps -> MinIntegrity
pdMinIntegrity PackumentDeps
deps) ServeDecision
integrityBelowFloor ServeDecision
integrityMissing (Manifest -> PackageInfo
manifestInfo Manifest
manifest)
                [(Text, PackageDetails)]
-> ((Text, PackageDetails) -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Map Text PackageDetails -> [(Text, PackageDetails)]
forall k a. Map k a -> [(k, a)]
Map.toList (PackageInfo -> Map Text PackageDetails
infoVersions PackageInfo
admissible)) (((Text, PackageDetails) -> IO ()) -> IO ())
-> ((Text, PackageDetails) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \(Text
version, PackageDetails
details) ->
                    Maybe Decision -> (Decision -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Text -> Map Text Decision -> Maybe Decision
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
version Map Text Decision
decisions) ((Decision -> IO ()) -> IO ()) -> (Decision -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Decision
decision -> case RuleEvidence -> Decision -> ServeDecision
serveDecisionOf (PackageDetails -> RuleEvidence
completeEvidence PackageDetails
details) Decision
decision of
                        ServeDecision
Admit -> IO ()
forall (f :: * -> *). Applicative f => f ()
pass
                        Reject Rejection
rejection -> EvalContext -> PackageDetails -> Rejection -> IO ()
report EvalContext
ctx PackageDetails
details Rejection
rejection
        pure $
            if Set.null (fpSurvivors plan)
                then PublicAdmission Nothing (projectDecisions admissible (fpDecisions plan) <> integrityRefusals) blockedPending deniedEvidence reportRejections
                else
                    PublicAdmission
                        (Just (Contribution GatedSource (restrictToSurvivors (fpSurvivors plan) admissible) (manifestRaw manifest) (manifestDigest manifest) (manifestBodyBytes manifest)))
                        integrityRefusals
                        blockedPending
                        deniedEvidence
                        reportRejections

reportIntegrityRejections :: (IntegrityFloor floor) => (EvalContext -> PackageDetails -> Rejection -> IO ()) -> EvalContext -> floor -> ServeDecision -> ServeDecision -> PackageInfo -> IO ()
reportIntegrityRejections :: forall floor.
IntegrityFloor floor =>
(EvalContext -> PackageDetails -> Rejection -> IO ())
-> EvalContext
-> floor
-> ServeDecision
-> ServeDecision
-> PackageInfo
-> IO ()
reportIntegrityRejections EvalContext -> PackageDetails -> Rejection -> IO ()
report EvalContext
ctx floor
floorSpec ServeDecision
below ServeDecision
missing PackageInfo
info =
    [PackageDetails] -> (PackageDetails -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Map Text PackageDetails -> [PackageDetails]
forall k a. Map k a -> [a]
Map.elems (PackageInfo -> Map Text PackageDetails
infoVersions PackageInfo
info)) ((PackageDetails -> IO ()) -> IO ())
-> (PackageDetails -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \PackageDetails
details ->
        NonEmpty Artifact -> (Artifact -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (PackageDetails -> NonEmpty Artifact
pkgArtifacts PackageDetails
details) ((Artifact -> IO ()) -> IO ()) -> (Artifact -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Artifact
artifact ->
            case floor -> [Hash] -> VersionIntegrity
forall floor.
IntegrityFloor floor =>
floor -> [Hash] -> VersionIntegrity
classifyDigests floor
floorSpec (Artifact -> [Hash]
artHashes Artifact
artifact) of
                VersionIntegrity
MeetsFloor -> IO ()
forall (f :: * -> *). Applicative f => f ()
pass
                VersionIntegrity
BelowFloor -> PackageDetails -> Artifact -> ServeDecision -> IO ()
rejected PackageDetails
details Artifact
artifact ServeDecision
below
                VersionIntegrity
NoIntegrity -> PackageDetails -> Artifact -> ServeDecision -> IO ()
rejected PackageDetails
details Artifact
artifact ServeDecision
missing
  where
    rejected :: PackageDetails -> Artifact -> ServeDecision -> IO ()
rejected PackageDetails
details Artifact
artifact = \case
        ServeDecision
Admit -> IO ()
forall (f :: * -> *). Applicative f => f ()
pass
        Reject Rejection
rejection -> EvalContext -> PackageDetails -> Rejection -> IO ()
report EvalContext
ctx PackageDetails
details{pkgArtifacts = artifact :| []} Rejection
rejection

decideVersions :: PackumentDeps -> EvalContext -> PackageInfo -> IO (Map Text Decision)
decideVersions :: PackumentDeps
-> EvalContext -> PackageInfo -> IO (Map Text Decision)
decideVersions PackumentDeps
deps EvalContext
ctx PackageInfo
info = do
    decide <- EvalContext -> [PreparedRule] -> IO (RuleEvidence -> IO Decision)
newEvaluator EvalContext
ctx (PackumentDeps -> [PreparedRule]
pdRules PackumentDeps
deps)
    traverse (decide . completeEvidence) (infoVersions info)

projectDecisions :: PackageInfo -> [Decision] -> [VersionVerdict]
projectDecisions :: PackageInfo -> [Decision] -> [VersionVerdict]
projectDecisions PackageInfo
info =
    ((Text, PackageDetails) -> Decision -> VersionVerdict)
-> [(Text, PackageDetails)] -> [Decision] -> [VersionVerdict]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (Text, PackageDetails) -> Decision -> VersionVerdict
versionVerdict (Map Text PackageDetails -> [(Text, PackageDetails)]
forall k a. Map k a -> [(k, a)]
Map.toList (PackageInfo -> Map Text PackageDetails
infoVersions PackageInfo
info))
  where
    versionVerdict :: (Text, PackageDetails) -> Decision -> VersionVerdict
versionVerdict (Text
ver, PackageDetails
details) Decision
d = Text -> ServeDecision -> VersionVerdict
VersionVerdict Text
ver (RuleEvidence -> Decision -> ServeDecision
serveDecisionOf (PackageDetails -> RuleEvidence
completeEvidence PackageDetails
details) Decision
d)

packumentPlan :: [Contribution] -> Map Text PackageDetails -> Map Text PackageDetails -> Maybe MergePlan
packumentPlan :: [Contribution]
-> Map Text PackageDetails
-> Map Text PackageDetails
-> Maybe MergePlan
packumentPlan [Contribution]
sources Map Text PackageDetails
trustedVersions Map Text PackageDetails
deniedEvidence = do
    plan <- [(Provenance, Snapshot PackageInfo)] -> Maybe MergePlan
mergePackuments [(Contribution -> Provenance
srcProvenance Contribution
s, ContentDigest -> PackageInfo -> Snapshot PackageInfo
forall a. ContentDigest -> a -> Snapshot a
Snapshot (Contribution -> ContentDigest
srcDigest Contribution
s) (Contribution -> PackageInfo
srcInfo Contribution
s)) | Contribution
s <- [Contribution]
sources]
    guard (not (Map.null (mpSurvivors plan)))
    pure plan{mpDivergences = mpDivergences plan <> integrityDivergences trustedVersions deniedEvidence}

serveResolved :: PackumentServing response -> [Contribution] -> MergePlan -> Handler response
serveResolved :: forall response.
PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
serveResolved PackumentServing response
serving [Contribution]
sources MergePlan
plan = do
    MetricsPort -> PackageName -> MergePlan -> Handler ()
forall (m :: * -> *).
KatipContext m =>
MetricsPort -> PackageName -> MergePlan -> m ()
warnDivergences (PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving) (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving) MergePlan
plan
    -- A coordinate lookup records its decision once it serves or misses its coordinate.
    Bool -> Handler () -> Handler ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe response -> Bool
forall a. Maybe a -> Bool
isNothing (PackumentServing response -> Maybe response
forall response. PackumentServing response -> Maybe response
psvAbsent PackumentServing response
serving)) (Handler () -> Handler ()) -> Handler () -> Handler ()
forall a b. (a -> b) -> a -> b
$ IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> Decision -> IO ()
mpServeDecision (PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving) Decision
Metric.Admit)
    PackumentServing response
-> PackumentServing response
-> [Contribution]
-> MergePlan
-> Handler response
forall response.
PackumentServing response
-> PackumentServing response
-> [Contribution]
-> MergePlan
-> Handler response
psvResolved PackumentServing response
serving PackumentServing response
serving [Contribution]
sources MergePlan
plan

answerPackumentConditional :: PackumentServing response -> [Contribution] -> MergePlan -> Handler response
answerPackumentConditional :: forall response.
PackumentServing response
-> [Contribution] -> MergePlan -> Handler response
answerPackumentConditional PackumentServing response
serving [Contribution]
sources MergePlan
plan =
    PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> PackumentServe
-> ETag
-> IO Method
-> Handler response
forall response.
PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> PackumentServe
-> ETag
-> IO Method
-> Handler response
answerMetadataConditional (PackumentServing response -> PackumentReplies response
forall response.
PackumentServing response -> PackumentReplies response
psvReplies PackumentServing response
serving) PackumentDeps
deps (PackumentServing response -> MemoryTicket
forall response. PackumentServing response -> MemoryTicket
psvTicket PackumentServing response
serving) (PackumentServing response -> Request
forall response. PackumentServing response -> Request
psvRequest PackumentServing response
serving) (PackumentServing response -> PackumentServe
forall response. PackumentServing response -> PackumentServe
psvMode PackumentServing response
serving) ETag
identityTag (IO Method -> Handler response) -> IO Method -> Handler response
forall a b. (a -> b) -> a -> b
$ do
        bytes <- PackumentServing response
-> [Contribution] -> MergePlan -> ETag -> IO Method
forall response.
PackumentServing response
-> [Contribution] -> MergePlan -> ETag -> IO Method
servedBytes PackumentServing response
serving [Contribution]
sources MergePlan
plan ETag
identityTag
        releaseReads serving
        pure bytes
  where
    deps :: PackumentDeps
deps = PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving
    origins :: [Text]
origins = (RegistryUrl -> Text) -> [RegistryUrl] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map RegistryUrl -> Text
registryUrlText (Maybe RegistryUrl -> [RegistryUrl]
forall a. Maybe a -> [a]
maybeToList (PackumentDeps -> Maybe RegistryUrl
pdPrivateBaseUrl PackumentDeps
deps) [RegistryUrl] -> [RegistryUrl] -> [RegistryUrl]
forall a. Semigroup a => a -> a -> a
<> [PackumentDeps -> RegistryUrl
pdPublicBaseUrl PackumentDeps
deps])
    identityTag :: ETag
identityTag = Text
-> [Text]
-> PackageName
-> [(Provenance, ContentDigest, [(Text, [EntryKey])])]
-> ETag
packumentETag (PackumentDeps -> Text
pdMountBaseUrl PackumentDeps
deps) [Text]
origins (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving) ((Contribution -> (Provenance, ContentDigest, [(Text, [EntryKey])]))
-> [Contribution]
-> [(Provenance, ContentDigest, [(Text, [EntryKey])])]
forall a b. (a -> b) -> [a] -> [b]
map Contribution -> (Provenance, ContentDigest, [(Text, [EntryKey])])
fingerprintPiece [Contribution]
sources)

-- | Finalise bounded native bytes only after current authorisation, admission and validation.
answerMetadataBytes :: PackumentReplies response -> PackumentDeps -> MemoryTicket -> Request -> ByteString -> Handler response
answerMetadataBytes :: forall response.
PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> Method
-> Handler response
answerMetadataBytes PackumentReplies response
replies PackumentDeps
deps MemoryTicket
ticket Request
request Method
bytes = PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> Digest SHA256
-> Method
-> Handler response
forall response.
PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> Digest SHA256
-> Method
-> Handler response
answerDigestedMetadataBytes PackumentReplies response
replies PackumentDeps
deps MemoryTicket
ticket Request
request (Method -> Digest SHA256
forall ba a.
(ByteArrayAccess ba, HashAlgorithm a) =>
ba -> Digest a
hash Method
bytes) Method
bytes

-- | 'answerMetadataBytes' with the caller's SHA-256 of the same bytes, so a caller that also sends it hashes once.
answerDigestedMetadataBytes :: PackumentReplies response -> PackumentDeps -> MemoryTicket -> Request -> Digest SHA256 -> ByteString -> Handler response
answerDigestedMetadataBytes :: forall response.
PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> Digest SHA256
-> Method
-> Handler response
answerDigestedMetadataBytes PackumentReplies response
replies PackumentDeps
deps MemoryTicket
ticket Request
request Digest SHA256
digest Method
bytes =
    PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> PackumentServe
-> ETag
-> IO Method
-> Handler response
forall response.
PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> PackumentServe
-> ETag
-> IO Method
-> Handler response
answerMetadataConditional PackumentReplies response
replies PackumentDeps
deps MemoryTicket
ticket Request
request PackumentServe
mode (Digest SHA256 -> ETag
mkStrongETag Digest SHA256
digest) (Method -> IO Method
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Method
bytes)
  where
    mode :: PackumentServe
mode = if Method -> Bool
isHead (Request -> Method
requestMethod Request
request) then PackumentServe
PackumentHead else PackumentServe
PackumentFull

-- Choose coding before its validator. An input-derived tag can skip assembly and compression on 304.
answerMetadataConditional :: PackumentReplies response -> PackumentDeps -> MemoryTicket -> Request -> PackumentServe -> ETag -> IO ByteString -> Handler response
answerMetadataConditional :: forall response.
PackumentReplies response
-> PackumentDeps
-> MemoryTicket
-> Request
-> PackumentServe
-> ETag
-> IO Method
-> Handler response
answerMetadataConditional PackumentReplies response
replies PackumentDeps
deps MemoryTicket
ticket Request
request PackumentServe
mode ETag
identityTag IO Method
render =
    case MetadataCompression -> ResponseHeaders -> CodingChoice
chooseCoding (PackumentDeps -> MetadataCompression
pdMetadataCompression PackumentDeps
deps) ResponseHeaders
headers of
        CodingChoice
NoAcceptableCoding ->
            response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotAcceptable PackumentReplies response
replies (ResponseHeaders -> ResponseHeaders
represented []) (Maybe HelpMessage -> Text -> Refusal
mkRefusal (PackumentDeps -> Maybe HelpMessage
pdHelp PackumentDeps
deps) Text
"the request's Accept-Encoding excludes both gzip and identity"))
        ServeCoding ContentCoding
coding -> case ResponseHeaders -> ETag -> Conditional
evaluateETag ResponseHeaders
headers (ContentCoding -> ETag -> ETag
codedETag ContentCoding
coding ETag
identityTag) of
            NotModified ETag
matched -> response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response -> ResponseHeaders -> response
forall response.
PackumentReplies response -> ResponseHeaders -> response
packumentNotModified PackumentReplies response
replies (ResponseHeaders -> ResponseHeaders
represented [ETag -> Header
etagHeader ETag
matched]))
            Modified ETag
fresh -> do
                bytes <- IO Method -> Handler Method
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO Method
render
                listing <- liftIO (codedListing ticket coding bytes)
                pure (packumentResponse replies mode (represented [etagHeader fresh]) listing)
  where
    headers :: ResponseHeaders
headers = Request -> ResponseHeaders
requestHeaders Request
request
    represented :: ResponseHeaders -> ResponseHeaders
represented = case PackumentDeps -> MetadataCompression
pdMetadataCompression PackumentDeps
deps of
        MetadataCompression
GzipWhenAccepted -> ResponseHeaders -> ResponseHeaders
varyAcceptEncoding
        MetadataCompression
IdentityOnly -> ResponseHeaders -> ResponseHeaders
forall a. a -> a
id

-- Once the body exists nothing reaches the reads' documents, so only the output charge stays while it is sent.
releaseReads :: PackumentServing response -> IO ()
releaseReads :: forall response. PackumentServing response -> IO ()
releaseReads PackumentServing response
serving = (ChargePart -> IO ()) -> [ChargePart] -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (ChargePart -> Int -> IO ()
`stepDown` Int
0) [PackumentServing response -> ChargePart
forall response. PackumentServing response -> ChargePart
psvPrivateRead PackumentServing response
serving, PackumentServing response -> ChargePart
forall response. PackumentServing response -> ChargePart
psvPublicRead PackumentServing response
serving]

data CodedListing
    = IdentityListing ByteString
    | GzipListing GzipBody

-- The request's ticket pays for the deflater and its output, on a cache hit as on a miss.
codedListing :: MemoryTicket -> ContentCoding -> ByteString -> IO CodedListing
codedListing :: MemoryTicket -> ContentCoding -> Method -> IO CodedListing
codedListing MemoryTicket
ticket = \case
    ContentCoding
IdentityCoding -> CodedListing -> IO CodedListing
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CodedListing -> IO CodedListing)
-> (Method -> CodedListing) -> Method -> IO CodedListing
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Method -> CodedListing
IdentityListing
    ContentCoding
GzipCoding -> (GzipBody -> CodedListing) -> IO GzipBody -> IO CodedListing
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GzipBody -> CodedListing
GzipListing (IO GzipBody -> IO CodedListing)
-> (Method -> IO GzipBody) -> Method -> IO CodedListing
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> IO ()) -> Method -> IO GzipBody
gzipMetadata (MemoryTicket -> Int -> IO ()
charge MemoryTicket
ticket)

-- Distinct private views produce distinct cache keys. A cache miss pays for the merged document and
-- its encoding before either exists, and wraps a render escape, which breaks the totality contract.
servedBytes :: PackumentServing response -> [Contribution] -> MergePlan -> ETag -> IO ByteString
servedBytes :: forall response.
PackumentServing response
-> [Contribution] -> MergePlan -> ETag -> IO Method
servedBytes PackumentServing response
serving [Contribution]
sources MergePlan
plan ETag
etag =
    MemoryTicket -> FlightKey -> IO Method -> IO Method
forall (m :: * -> *) a.
MonadUnliftIO m =>
MemoryTicket -> FlightKey -> m a -> m a
awaitingFlight (PackumentServing response -> MemoryTicket
forall response. PackumentServing response -> MemoryTicket
psvTicket PackumentServing response
serving) FlightKey
flight (IO Method -> IO Method)
-> (IO Method -> IO Method) -> IO Method -> IO Method
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MetricsPort -> MetadataCache -> CacheKey -> IO Method -> IO Method
resolveAssembled (ServeRuntime -> MetricsPort
srMetrics ServeRuntime
rt) (ServeRuntime -> MetadataCache
srMetadataCache ServeRuntime
rt) CacheKey
key (IO Method -> IO Method) -> IO Method -> IO Method
forall a b. (a -> b) -> a -> b
$ do
        MemoryTicket -> Int -> IO ()
charge (FlightKey -> MemoryTicket -> MemoryTicket
servingFlight FlightKey
flight (PackumentServing response -> MemoryTicket
forall response. PackumentServing response -> MemoryTicket
psvTicket PackumentServing response
serving)) Int
outputCharge
        IO Method -> IO Method
markRenderEscape (IO Method -> IO Method) -> IO Method -> IO Method
forall a b. (a -> b) -> a -> b
$
            (RenderRefused -> IO Method)
-> (LByteString -> IO Method)
-> Either RenderRefused LByteString
-> IO Method
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either RenderRefused -> IO Method
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (\LByteString
body -> Method -> IO Method
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Method -> IO Method) -> Method -> IO Method
forall a b. (a -> b) -> a -> b
$! LByteString -> Method
LBS.toStrict LByteString
body) (AdapterMetadata -> CachedDoc -> Either RenderRefused LByteString
metadataSerialise (PackumentDeps -> AdapterMetadata
pdMetadata PackumentDeps
deps) (PackumentDeps -> [Contribution] -> MergePlan -> CachedDoc
renderServedBody PackumentDeps
deps [Contribution]
sources MergePlan
plan))
  where
    rt :: ServeRuntime
rt = PackumentServing response -> ServeRuntime
forall response. PackumentServing response -> ServeRuntime
psvRuntime PackumentServing response
serving
    deps :: PackumentDeps
deps = PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving
    key :: CacheKey
key = ETag -> CacheKey
assembledKey ETag
etag
    flight :: FlightKey
flight = CacheKey -> FlightKey
flightOf CacheKey
key
    outputCharge :: Int
outputCharge = Int -> Int -> Int
scaleCharge (ChargeFactors -> Int
cfOutputPermille (AdapterMetadata -> ChargeFactors
metadataChargeFactors (PackumentDeps -> AdapterMetadata
pdMetadata PackumentDeps
deps))) (MergePlan -> [Contribution] -> Int
outputBasisBytes MergePlan
plan [Contribution]
sources)
    markRenderEscape :: IO ByteString -> IO ByteString
    markRenderEscape :: IO Method -> IO Method
markRenderEscape IO Method
render = IO Method
render IO Method -> (SomeException -> IO Method) -> IO Method
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> (SomeException -> m a) -> m a
`catchAny` (RenderEscape -> IO Method
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO (RenderEscape -> IO Method)
-> (SomeException -> RenderEscape) -> SomeException -> IO Method
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeException -> RenderEscape
RenderEscape)

renderServedBody :: PackumentDeps -> [Contribution] -> MergePlan -> CachedDoc
renderServedBody :: PackumentDeps -> [Contribution] -> MergePlan -> CachedDoc
renderServedBody PackumentDeps
deps = AdapterMetadata -> Text -> [Contribution] -> MergePlan -> CachedDoc
assembleServedBody (PackumentDeps -> AdapterMetadata
pdMetadata PackumentDeps
deps) (PackumentDeps -> Text
pdMountBaseUrl PackumentDeps
deps)

-- A HEAD states the GET's exact length. A gzip GET states it too, because its length is known before it is sent.
packumentResponse :: PackumentReplies response -> PackumentServe -> ResponseHeaders -> CodedListing -> response
packumentResponse :: forall response.
PackumentReplies response
-> PackumentServe -> ResponseHeaders -> CodedListing -> response
packumentResponse PackumentReplies response
replies PackumentServe
mode ResponseHeaders
headers = \case
    IdentityListing Method
bytes -> case PackumentServe
mode of
        PackumentServe
PackumentFull -> PackumentReplies response
-> ResponseHeaders -> LByteString -> response
forall response.
PackumentReplies response
-> ResponseHeaders -> LByteString -> response
packumentOk PackumentReplies response
replies ResponseHeaders
headers (Method -> LByteString
LBS.fromStrict Method
bytes)
        PackumentServe
PackumentHead -> PackumentReplies response
-> ResponseHeaders -> LByteString -> response
forall response.
PackumentReplies response
-> ResponseHeaders -> LByteString -> response
packumentOk PackumentReplies response
replies (ResponseHeaders
headers ResponseHeaders -> ResponseHeaders -> ResponseHeaders
forall a. Semigroup a => a -> a -> a
<> [Int -> Header
forall {a} {b}. (Show a, IsString b) => a -> (HeaderName, b)
contentLength (Method -> Int
BS.length Method
bytes)]) (Method -> LByteString
LBS.fromStrict Method
bytes)
    GzipListing GzipBody
body -> PackumentReplies response
-> ResponseHeaders -> LByteString -> response
forall response.
PackumentReplies response
-> ResponseHeaders -> LByteString -> response
packumentOk PackumentReplies response
replies (ResponseHeaders
headers ResponseHeaders -> ResponseHeaders -> ResponseHeaders
forall a. Semigroup a => a -> a -> a
<> [Header
gzipEncodingHeader, Int -> Header
forall {a} {b}. (Show a, IsString b) => a -> (HeaderName, b)
contentLength (GzipBody -> Int
gzipLength GzipBody
body)]) (GzipBody -> LByteString
gzipLazyBody GzipBody
body)
  where
    contentLength :: a -> (HeaderName, b)
contentLength a
size = (HeaderName
hContentLength, a -> b
forall b a. (Show a, IsString b) => a -> b
show a
size)

noServeableVersions ::
    PackumentServing response ->
    Maybe DbEtag ->
    [VersionVerdict] ->
    [ServeDecision] ->
    Handler response
noServeableVersions :: forall response.
PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
noServeableVersions PackumentServing response
serving Maybe DbEtag
etag [VersionVerdict]
verdicts [ServeDecision]
decisions = do
    IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> Decision -> IO ()
mpServeDecision MetricsPort
metrics (PackumentStatus -> Decision
statusServeDecision PackumentStatus
status))
    IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> [ServeDecision] -> IO ()
recordDenials MetricsPort
metrics [ServeDecision]
decisions)
    PackageName -> Maybe DbEtag -> [VersionVerdict] -> Handler ()
forall (m :: * -> *).
KatipContext m =>
PackageName -> Maybe DbEtag -> [VersionVerdict] -> m ()
logDenials (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving) Maybe DbEtag
etag [VersionVerdict]
verdicts
    response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response
-> Maybe HelpMessage
-> PackumentStatus
-> [ServeDecision]
-> response
forall response.
PackumentReplies response
-> Maybe HelpMessage
-> PackumentStatus
-> [ServeDecision]
-> response
noSurvivors (PackumentServing response -> PackumentReplies response
forall response.
PackumentServing response -> PackumentReplies response
psvReplies PackumentServing response
serving) (PackumentDeps -> Maybe HelpMessage
pdHelp (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving)) PackumentStatus
status [ServeDecision]
decisions)
  where
    metrics :: MetricsPort
metrics = PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving
    status :: PackumentStatus
status = [ServeDecision] -> PackumentStatus
packumentStatus [ServeDecision]
decisions

-- | Answer an empty listing, finishing the selected refusal text before writing the reply.
noSurvivors :: PackumentReplies response -> Maybe HelpMessage -> PackumentStatus -> [ServeDecision] -> response
noSurvivors :: forall response.
PackumentReplies response
-> Maybe HelpMessage
-> PackumentStatus
-> [ServeDecision]
-> response
noSurvivors PackumentReplies response
replies Maybe HelpMessage
help PackumentStatus
status [ServeDecision]
decisions = case PackumentStatus
status of
    PackumentStatus
PackumentOk -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentInternal PackumentReplies response
replies [] Refusal
body
    PackumentStatus
PackumentDenied -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentDenied PackumentReplies response
replies [] Refusal
body
    PackumentStatus
PackumentForbidden -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentForbidden PackumentReplies response
replies [] Refusal
body
    PackumentUnavailable Maybe RetryAfter
retry -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnavailable PackumentReplies response
replies (Maybe RetryAfter -> ResponseHeaders
retryAfterHeaders Maybe RetryAfter
retry) Refusal
body
    PackumentStatus
PackumentBadGateway -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentBadGateway PackumentReplies response
replies [] Refusal
body
    PackumentStatus
PackumentServerError -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentInternal PackumentReplies response
replies [] Refusal
body
  where
    message :: Text
message = case PackumentStatus
status of
        PackumentStatus
PackumentDenied -> PackumentReplies response -> [ServeDecision] -> Text
forall response.
PackumentReplies response -> [ServeDecision] -> Text
packumentDeniedText PackumentReplies response
replies [ServeDecision]
decisions
        PackumentStatus
PackumentForbidden -> PackumentReplies response -> [ServeDecision] -> Text
forall response.
PackumentReplies response -> [ServeDecision] -> Text
packumentDeniedText PackumentReplies response
replies [ServeDecision]
decisions
        PackumentStatus
_ -> [ServeDecision] -> Text
detailedRejections [ServeDecision]
decisions

    !body :: Refusal
body = Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
help Text
message

collectDecisions :: OriginResult -> OriginResult -> [ServeDecision] -> [ServeDecision]
collectDecisions :: OriginResult -> OriginResult -> [ServeDecision] -> [ServeDecision]
collectDecisions OriginResult
privResult OriginResult
pubResult [ServeDecision]
exclusions =
    [ServeDecision]
privateLeg [ServeDecision] -> [ServeDecision] -> [ServeDecision]
forall a. Semigroup a => a -> a -> a
<> OriginResult -> [ServeDecision]
publicDecision OriginResult
pubResult [ServeDecision] -> [ServeDecision] -> [ServeDecision]
forall a. Semigroup a => a -> a -> a
<> [ServeDecision]
exclusions
  where
    -- A private 404 leaves the listing to the public origin. A public document the gate refused in full or
    -- that lists no version settles it, and a failed public read refuses it by its own cause.
    privateLeg :: [ServeDecision]
privateLeg = case (OriginResult
privResult, OriginResult
pubResult) of
        (OriginResult
OriginNotFound, OriginResolved Manifest
_) | [ServeDecision] -> PackumentStatus
packumentStatus [ServeDecision]
exclusions PackumentStatus -> PackumentStatus -> Bool
forall a. Eq a => a -> a -> Bool
== PackumentStatus
PackumentDenied -> []
        (OriginResult
OriginNotFound, OriginResolved Manifest
manifest) | Map Text PackageDetails -> Bool
forall k a. Map k a -> Bool
Map.null (PackageInfo -> Map Text PackageDetails
infoVersions (Manifest -> PackageInfo
manifestInfo Manifest
manifest)) -> []
        (OriginResult
OriginNotFound, OriginResult
_) | OriginResult -> Bool
publicReadFailed OriginResult
pubResult -> []
        (OriginResult, OriginResult)
_ -> OriginResult -> [ServeDecision]
privateDecision OriginResult
privResult

-- The refusal of a listing whose documents dropped every version entry they listed, naming the upstreams that sent them.
malformedEntries :: [Text] -> ServeDecision
malformedEntries :: [Text] -> ServeDecision
malformedEntries [Text]
upstreams =
    Rejection -> ServeDecision
Reject (RejectReason -> Text -> Rejection
Rejection RejectReason
UpstreamInvalid (Text
"every version entry from " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat (Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
intersperse Text
" and " [Text]
upstreams) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" was malformed or unusable"))

-- Whether a document listed version entries and dropped every one. A dropped tag, time or listing entry is no version.
droppedEveryEntry :: Manifest -> Bool
droppedEveryEntry :: Manifest -> Bool
droppedEveryEntry Manifest
manifest = Map Text PackageDetails -> Bool
forall k a. Map k a -> Bool
Map.null (PackageInfo -> Map Text PackageDetails
infoVersions PackageInfo
info) Bool -> Bool -> Bool
&& (InvalidEntry -> Bool) -> [InvalidEntry] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (InvalidEntryKind -> Bool
dropsVersion (InvalidEntryKind -> Bool)
-> (InvalidEntry -> InvalidEntryKind) -> InvalidEntry -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InvalidEntry -> InvalidEntryKind
invalidKind) (PackageInfo -> [InvalidEntry]
infoInvalidEntries PackageInfo
info)
  where
    info :: PackageInfo
info = Manifest -> PackageInfo
manifestInfo Manifest
manifest
    dropsVersion :: InvalidEntryKind -> Bool
dropsVersion = \case
        InvalidEntryKind
InvalidVersionManifest -> Bool
True
        InvalidEntryKind
InvalidIndexFile -> Bool
True
        InvalidEntryKind
InvalidDistTag -> Bool
False
        InvalidEntryKind
InvalidPublishTime -> Bool
False
        InvalidEntryKind
InvalidVersionListing -> Bool
False

privateDecision :: OriginResult -> [ServeDecision]
privateDecision :: OriginResult -> [ServeDecision]
privateDecision = \case
    OriginBudgetExceeded LimitError
_ -> [ServeDecision
upstreamInvalidDecision]
    OriginAuthorisationFailure Int
_ -> []
    OriginResolved Manifest
_ -> []
    -- Unless the public origin settled the name or failed with its own cause, a private 404 with no
    -- public survivor keeps the outage refusal.
    OriginResult
OriginNotFound -> [Maybe RetryAfter -> ServeDecision
neededUpstreamUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing]
    OriginUnresolved ReadFailure
failure -> [Text -> Text -> ReadFailure -> ServeDecision
readFailureRefusal Text
"the private upstream" Text
neededUpstreamUnavailableMessage ReadFailure
failure]
    OriginCooling RetryAfter
retry -> [RetryAfter -> ServeDecision
upstreamCooling RetryAfter
retry]
    OriginResult
OriginNameMismatch -> [ServeDecision
upstreamInvalidDecision]
    -- An unconfigured private leg (a serve-only pure gate) is not an outage:
    -- nothing was needed, so nothing is unavailable.
    OriginResult
OriginAbsent -> []

-- A public read that failed never reached the gate, so whatever the private side held, its cause
-- refuses the listing as a failed private read would.
publicDecision :: OriginResult -> [ServeDecision]
publicDecision :: OriginResult -> [ServeDecision]
publicDecision = \case
    OriginBudgetExceeded LimitError
_ -> [ServeDecision
upstreamInvalidDecision]
    -- The public read is anonymous, so its 401 or 403 is a reply Écluse cannot use, as a 400 is.
    OriginAuthorisationFailure Int
_ -> [ReadFailure -> ServeDecision
publicReadRefusal ReadFailure
ReadInvalid]
    OriginResult
OriginNameMismatch -> [ServeDecision
upstreamInvalidDecision]
    OriginResolved Manifest
_ -> []
    OriginResult
OriginNotFound -> []
    OriginUnresolved ReadFailure
failure -> [ReadFailure -> ServeDecision
publicReadRefusal ReadFailure
failure]
    OriginCooling RetryAfter
retry -> [RetryAfter -> ServeDecision
upstreamCooling RetryAfter
retry]
    OriginResult
OriginAbsent -> []
  where
    publicReadRefusal :: ReadFailure -> ServeDecision
publicReadRefusal = Text -> Text -> ReadFailure -> ServeDecision
readFailureRefusal Text
"the public upstream" Text
neededUpstreamUnavailableMessage

-- Whether the public read failed, so that its cause, not a private 404, decides a listing with nothing admitted.
publicReadFailed :: OriginResult -> Bool
publicReadFailed :: OriginResult -> Bool
publicReadFailed = \case
    OriginUnresolved ReadFailure
_ -> Bool
True
    OriginAuthorisationFailure Int
_ -> Bool
True
    OriginResult
OriginNameMismatch -> Bool
True
    OriginResult
_ -> Bool
False

neededUpstreamUnavailable :: Maybe RetryAfter -> ServeDecision
neededUpstreamUnavailable :: Maybe RetryAfter -> ServeDecision
neededUpstreamUnavailable Maybe RetryAfter
retry = Transience -> Text -> ServeDecision
rejectUnavailable (Maybe RetryAfter -> Transience
WillResolve Maybe RetryAfter
retry) Text
neededUpstreamUnavailableMessage

neededUpstreamUnavailableMessage :: Text
neededUpstreamUnavailableMessage :: Text
neededUpstreamUnavailableMessage = Text
"a needed upstream was unavailable"

upstreamInvalidDecision :: ServeDecision
upstreamInvalidDecision :: ServeDecision
upstreamInvalidDecision = Rejection -> ServeDecision
Reject (RejectReason -> Text -> Rejection
Rejection RejectReason
UpstreamInvalid Text
"an upstream returned a packument for a different package")

-- | Answer 404 with this cause, recorded as the artifact path records a missing version.
notFoundReply :: MetricsPort -> PackumentReplies response -> Maybe HelpMessage -> Text -> IO response
notFoundReply :: forall response.
MetricsPort
-> PackumentReplies response
-> Maybe HelpMessage
-> Text
-> IO response
notFoundReply MetricsPort
metrics PackumentReplies response
replies Maybe HelpMessage
help Text
message = do
    MetricsPort -> Decision -> IO ()
mpServeDecision MetricsPort
metrics (ServeDecision -> Decision
serveDecisionClass ServeDecision
decision)
    MetricsPort -> [ServeDecision] -> IO ()
recordDenials MetricsPort
metrics [ServeDecision
decision]
    response -> IO response
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotFound PackumentReplies response
replies [] (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
help Text
message))
  where
    decision :: ServeDecision
decision = Transience -> Text -> ServeDecision
rejectUnavailable Transience
WontResolve Text
message

-- Why a name no configured origin holds is absent, naming only the configured origins.
unheldMessage :: PackumentDeps -> Text
unheldMessage :: PackumentDeps -> Text
unheldMessage PackumentDeps
deps
    | Maybe RegistryUrl -> Bool
forall a. Maybe a -> Bool
isJust (PackumentDeps -> Maybe RegistryUrl
pdPrivateBaseUrl PackumentDeps
deps) = Text
"neither the private nor the public upstream has the requested package"
    | Bool
otherwise = Text
"the public upstream does not have the requested package"

-- A private origin that was not read refuses every name, so no public namesake stands in for a
-- private package. Its cause alone sets the status, whatever the public leg did.
privateUnresolved :: PackumentServing response -> EvalContext -> OriginResult -> ReadFailure -> Handler response
privateUnresolved :: forall response.
PackumentServing response
-> EvalContext -> OriginResult -> ReadFailure -> Handler response
privateUnresolved PackumentServing response
serving EvalContext
evalCtx OriginResult
privResult ReadFailure
failure
    | PackumentDeps -> PackageName -> Bool
pdFirstParty (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving) (PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving) = PackumentServing response -> OriginMiss -> Handler response
forall response.
PackumentServing response -> OriginMiss -> Handler response
firstPartyMissed PackumentServing response
serving (ReadFailure -> OriginMiss
MissUnresolved ReadFailure
failure)
    | Bool
otherwise = PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
forall response.
PackumentServing response
-> Maybe DbEtag
-> [VersionVerdict]
-> [ServeDecision]
-> Handler response
noServeableVersions PackumentServing response
serving (EvalContext -> Maybe DbEtag
ctxAdvisoryEtag EvalContext
evalCtx) [] (OriginResult -> [ServeDecision]
privateDecision OriginResult
privResult)

firstPartyMissed :: PackumentServing response -> OriginMiss -> Handler response
firstPartyMissed :: forall response.
PackumentServing response -> OriginMiss -> Handler response
firstPartyMissed PackumentServing response
serving OriginMiss
miss = do
    IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> Decision -> IO ()
mpServeDecision MetricsPort
metrics ([ServeDecision] -> Decision
packumentServeDecision [ServeDecision
decision]))
    IO () -> Handler ()
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MetricsPort -> [ServeDecision] -> IO ()
recordDenials MetricsPort
metrics [ServeDecision
decision])
    response -> Handler response
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PackumentReplies response
-> Maybe HelpMessage -> PackageName -> OriginMiss -> response
forall response.
PackumentReplies response
-> Maybe HelpMessage -> PackageName -> OriginMiss -> response
firstPartyMissReply (PackumentServing response -> PackumentReplies response
forall response.
PackumentServing response -> PackumentReplies response
psvReplies PackumentServing response
serving) (PackumentDeps -> Maybe HelpMessage
pdHelp (PackumentServing response -> PackumentDeps
forall response. PackumentServing response -> PackumentDeps
psvDeps PackumentServing response
serving)) PackageName
name OriginMiss
miss)
  where
    metrics :: MetricsPort
metrics = PackumentServing response -> MetricsPort
forall response. PackumentServing response -> MetricsPort
servingMetrics PackumentServing response
serving
    name :: PackageName
name = PackumentServing response -> PackageName
forall response. PackumentServing response -> PackageName
psvName PackumentServing response
serving
    decision :: ServeDecision
decision = PackageName -> OriginMiss -> ServeDecision
firstPartyMissDecision PackageName
name OriginMiss
miss

-- Why a first-party name did not resolve, in the words the client reads.
firstPartyMissMessage :: PackageName -> OriginMiss -> Text
firstPartyMissMessage :: PackageName -> OriginMiss -> Text
firstPartyMissMessage PackageName
name = \case
    OriginMiss
MissAbsent ->
        Text
"'"
            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
rendered
            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"' did not resolve from the private upstream, and its namespace is first-party to this deployment, so it is never fetched from the public registry"
    MissUnresolved (ReadUnavailable Maybe RetryAfter
_) ->
        Text
"the private upstream did not answer for '"
            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
rendered
            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"', and its namespace is first-party to this deployment, so no public document may stand in for it"
    MissUnresolved ReadFailure
ReadInvalid ->
        Text
"the private upstream returned an invalid or unusable reply for '"
            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
rendered
            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"', and its namespace is first-party to this deployment, so no public document may stand in for it"
  where
    rendered :: Text
rendered = PackageName -> Text
renderPackageName PackageName
name

-- | Classify a first-party absence as a policy refusal, and an unread origin by its cause.
firstPartyMissDecision :: PackageName -> OriginMiss -> ServeDecision
firstPartyMissDecision :: PackageName -> OriginMiss -> ServeDecision
firstPartyMissDecision PackageName
name OriginMiss
miss = Rejection -> ServeDecision
Reject (RejectReason -> Text -> Rejection
Rejection RejectReason
reason (PackageName -> OriginMiss -> Text
firstPartyMissMessage PackageName
name OriginMiss
miss))
  where
    reason :: RejectReason
reason = case OriginMiss
miss of
        OriginMiss
MissAbsent -> RuleName -> [Reason] -> RejectReason
ByPolicy RuleName
firstPartyRule []
        MissUnresolved (ReadUnavailable Maybe RetryAfter
retry) -> Transience -> RejectReason
Unavailable (Maybe RetryAfter -> Transience
WillResolve Maybe RetryAfter
retry)
        MissUnresolved ReadFailure
ReadInvalid -> RejectReason
UpstreamInvalid

-- | Render a settled absence as @404@, an unavailable origin as @503@ with its delay, and an invalid reply as @502@.
firstPartyMissReply :: PackumentReplies response -> Maybe HelpMessage -> PackageName -> OriginMiss -> response
firstPartyMissReply :: forall response.
PackumentReplies response
-> Maybe HelpMessage -> PackageName -> OriginMiss -> response
firstPartyMissReply PackumentReplies response
replies Maybe HelpMessage
help PackageName
name OriginMiss
miss = case OriginMiss
miss of
    OriginMiss
MissAbsent -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentNotFound PackumentReplies response
replies [] Refusal
body
    MissUnresolved (ReadUnavailable Maybe RetryAfter
retry) -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentUnavailable PackumentReplies response
replies (Maybe RetryAfter -> ResponseHeaders
retryAfterHeaders Maybe RetryAfter
retry) Refusal
body
    MissUnresolved ReadFailure
ReadInvalid -> PackumentReplies response -> ResponseHeaders -> Refusal -> response
forall response.
PackumentReplies response -> ResponseHeaders -> Refusal -> response
packumentBadGateway PackumentReplies response
replies [] Refusal
body
  where
    body :: Refusal
body = Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
help (PackageName -> OriginMiss -> Text
firstPartyMissMessage PackageName
name OriginMiss
miss)