-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT
{-# LANGUAGE TupleSections #-}

{- | Read private archives under the caller's credential.
Access refusals and failed reads stop fallback. Managed mirror copies require retained
completion proof, and a recorded version the private origin cannot serve falls back to public
coverage.
-}
module Ecluse.Core.Server.Pipeline.Tarball.Private (
    PrivateLeg (..),
    RecordedCopy (..),
    recordedCopy,
    streamPrivateArtifact,
    privateMetadataMiss,
    privateReadFailure,
) where

import Data.Map.Strict qualified as Map
import Network.HTTP.Client qualified as HTTP
import Network.HTTP.Types (ResponseHeaders, status404, status503, statusCode)
import Network.Wai (ResponseReceived)

import Ecluse.Core.Credential (ClientCredential)
import Ecluse.Core.Mirror.State (MirrorVersion, recordVersion, versionFiles)
import Ecluse.Core.Package (
    Artifact (artFilename, artUrl),
    PackageDetails (pkgArtifacts),
    PackageInfo (PackageInfo),
 )
import Ecluse.Core.Registry.Adapter.Capability (AdapterArtifact (artifactByFile, artifactByUrl, artifactPrivateAddressing), PrivateArtifactAddressing (..))
import Ecluse.Core.Registry.Metadata (
    MetadataClient (fetchVersionMetadata),
    MetadataError (MetadataAbsent, MetadataAuthorisationFailure),
    VersionDoc (vdDetails),
    VersionRead (vrVersion),
 )
import Ecluse.Core.Registry.Request (BaseRequest)
import Ecluse.Core.Security (
    HostPort,
    Limits (progressFloor),
    Origin (TrustedOrigin),
    artifactAuthorityHonoured,
    hostPortAddress,
    thgEcosystemHosts,
    thgPrivateHostPort,
 )
import Ecluse.Core.Server.Admission.Meter (MemoryTicket)
import Ecluse.Core.Server.Context (
    Handler,
    PackumentDeps (..),
    ServeRuntime (..),
    pdPrivateBase,
    pdTarballHostGate,
    tarballHostHonoured,
 )
import Ecluse.Core.Server.MirrorView (mirrorVersionView, mirrorViewDocuments, publicMirrorCoverage, validateMirrorProject)
import Ecluse.Core.Server.Path (unFilename)
import Ecluse.Core.Server.Pipeline.Origin (
    OriginMiss (MissAbsent, MissUnresolved),
    ReadFailure (ReadUnavailable),
    metadataReadFailure,
    mountOrigin,
    statusReadFailure,
    withPrivateMetadataClient,
 )
import Ecluse.Core.Server.Pipeline.Shared
import Ecluse.Core.Server.Pipeline.Tarball.Public (servePublicArtifactWithCoverage)
import Ecluse.Core.Server.Pipeline.Tarball.Relay (
    acceptPrivateArtifact,
    privateArtifactResponder,
    relayUnjudged,
    relayUpstreamResult,
    withMethod,
    withValidators,
 )
import Ecluse.Core.Server.Pipeline.Tarball.Types (ArtifactRequest (..), TarballReplies (..), relayResponder)
import Ecluse.Core.Server.Response (mkRefusal)
import Ecluse.Core.Server.Stream (UpstreamResult (..))
import Ecluse.Core.Telemetry.Metrics qualified as Metric
import Ecluse.Core.Version (renderVersion)
import UnliftIO (tryAny)

-- | The private leg's answer: the response it committed, or why it did not answer.
data PrivateLeg received
    = PrivateAnswered Metric.Decision received
    | PrivateMissed OriginMiss
    | PrivateHandled received

-- | What the private origin answered for a recorded version it cannot serve whole.
data RecordedCopy
    = -- | A @404@ for the name or the stored artifact: a public miss settles the version.
      RecordedCopyGone
    | -- | The name without a complete copy: the version waits for public coverage.
      RecordedCopyIncomplete
    deriving stock (RecordedCopy -> RecordedCopy -> Bool
(RecordedCopy -> RecordedCopy -> Bool)
-> (RecordedCopy -> RecordedCopy -> Bool) -> Eq RecordedCopy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecordedCopy -> RecordedCopy -> Bool
== :: RecordedCopy -> RecordedCopy -> Bool
$c/= :: RecordedCopy -> RecordedCopy -> Bool
/= :: RecordedCopy -> RecordedCopy -> Bool
Eq, Int -> RecordedCopy -> ShowS
[RecordedCopy] -> ShowS
RecordedCopy -> String
(Int -> RecordedCopy -> ShowS)
-> (RecordedCopy -> String)
-> ([RecordedCopy] -> ShowS)
-> Show RecordedCopy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecordedCopy -> ShowS
showsPrec :: Int -> RecordedCopy -> ShowS
$cshow :: RecordedCopy -> String
show :: RecordedCopy -> String
$cshowList :: [RecordedCopy] -> ShowS
showList :: [RecordedCopy] -> ShowS
Show)

-- | Only a private @404@ for the name leaves no copy of a recorded version the read could not restore.
recordedCopy :: Either SomeException (Either MetadataError VersionRead) -> RecordedCopy
recordedCopy :: Either SomeException (Either MetadataError VersionRead)
-> RecordedCopy
recordedCopy = \case
    Right (Left MetadataError
MetadataAbsent) -> RecordedCopy
RecordedCopyGone
    Either SomeException (Either MetadataError VersionRead)
_ -> RecordedCopy
RecordedCopyIncomplete

-- | Read the private origin, committing a response or reporting the miss that ends the leg.
streamPrivateArtifact ::
    ArtifactRequest response ->
    Maybe ClientCredential ->
    Handler (PrivateLeg ResponseReceived)
streamPrivateArtifact :: forall response.
ArtifactRequest response
-> Maybe ClientCredential -> Handler (PrivateLeg ResponseReceived)
streamPrivateArtifact ArtifactRequest response
ctx Maybe ClientCredential
token = do
    selected <-
        if ArtifactRequest response -> Bool
forall response. ArtifactRequest response -> Bool
privateMetadataAdmissionRequired ArtifactRequest response
ctx
            then ServeRuntime
-> (ResponseHeaders -> Handler PrivateArtifact)
-> (MemoryTicket -> Handler PrivateArtifact)
-> (PrivateArtifact -> Handler PrivateArtifact)
-> Handler PrivateArtifact
forall (m :: * -> *) received a.
MonadUnliftIO m =>
ServeRuntime
-> (ResponseHeaders -> m received)
-> (MemoryTicket -> m a)
-> (a -> m received)
-> m received
withMetadataAdmission (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx) (PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PrivateArtifact -> Handler PrivateArtifact)
-> (ResponseHeaders -> PrivateArtifact)
-> ResponseHeaders
-> Handler PrivateArtifact
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResponseHeaders -> PrivateArtifact
PrivateShed) (\MemoryTicket
ticket -> Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> Handler PrivateArtifact
forall response.
Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> Handler PrivateArtifact
privateArtifactRequest (MemoryTicket -> Maybe MemoryTicket
forall a. a -> Maybe a
Just MemoryTicket
ticket) ArtifactRequest response
ctx Maybe ClientCredential
token) PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            else Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> Handler PrivateArtifact
forall response.
Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> Handler PrivateArtifact
privateArtifactRequest Maybe MemoryTicket
forall a. Maybe a
Nothing ArtifactRequest response
ctx Maybe ClientCredential
token
    answer selected
  where
    answer :: PrivateArtifact -> Handler (PrivateLeg ResponseReceived)
answer PrivateArtifact
prepared = case PrivateArtifact
prepared of
        -- The admission shed already counted its decision.
        PrivateShed ResponseHeaders
headers -> ResponseReceived -> PrivateLeg ResponseReceived
forall received. received -> PrivateLeg received
PrivateHandled (ResponseReceived -> PrivateLeg ResponseReceived)
-> Handler ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO ResponseReceived -> Handler ResponseReceived
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (response -> IO ResponseReceived
respond (TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
forall response.
TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
tarballError TarballReplies response
replies Status
shedStatus ResponseHeaders
headers (Maybe HelpMessage -> Text -> Refusal
mkRefusal Maybe HelpMessage
forall a. Maybe a
Nothing Text
shedMessage)))
        PrivateArtifact
PrivateUnavailable -> Decision -> ResponseReceived -> PrivateLeg ResponseReceived
forall received. Decision -> received -> PrivateLeg received
PrivateAnswered Decision
Metric.Unavailable (ResponseReceived -> PrivateLeg ResponseReceived)
-> Handler ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO ResponseReceived -> Handler ResponseReceived
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Maybe RetryAfter -> IO ResponseReceived
unavailable Maybe RetryAfter
forall a. Maybe a
Nothing)
        PrivateIncomplete RecordedCopy
copy MirrorVersion
expected -> RecordedCopy
-> MirrorVersion -> Handler (PrivateLeg ResponseReceived)
publicFallback RecordedCopy
copy MirrorVersion
expected
        PrivateRefused Int
code -> Decision -> ResponseReceived -> PrivateLeg ResponseReceived
forall received. Decision -> received -> PrivateLeg received
PrivateAnswered Decision
Metric.Deny (ResponseReceived -> PrivateLeg ResponseReceived)
-> Handler ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO ResponseReceived -> Handler ResponseReceived
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Int -> IO ResponseReceived
refuse Int
code)
        PrivateMissing OriginMiss
miss -> PrivateLeg ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateLeg ResponseReceived
forall received. OriginMiss -> PrivateLeg received
PrivateMissed OriginMiss
miss)
        PrivateRequest Maybe MirrorVersion
managed Request
req ->
            IO (UpstreamResult ((), (Decision, ResponseReceived)))
-> Handler (UpstreamResult ((), (Decision, ResponseReceived)))
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status -> ResponseHeaders -> IO (Status, ResponseHeaders, ()))
-> RelayResponder (Decision, ResponseReceived)
-> IO (UpstreamResult ((), (Decision, ResponseReceived)))
forall verdict response.
ArtifactServe
-> ExchangeClient
-> ProgressFloor
-> Request
-> (Status -> Bool)
-> (Status
    -> ResponseHeaders -> IO (Status, ResponseHeaders, verdict))
-> RelayResponder response
-> IO (UpstreamResult (verdict, response))
relayUpstreamResult (ArtifactRequest response -> ArtifactServe
forall response. ArtifactRequest response -> ArtifactServe
arMode ArtifactRequest response
ctx) (ServeRuntime -> ExchangeClient
srPrivateClient (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx)) (Limits -> ProgressFloor
progressFloor (PackumentDeps -> Limits
pdLimits (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx))) (Request -> Request
shaped Request
req) Status -> Bool
acceptPrivateArtifact Status -> ResponseHeaders -> IO (Status, ResponseHeaders, ())
relayUnjudged RelayResponder (Decision, ResponseReceived)
privateResponder) Handler (UpstreamResult ((), (Decision, ResponseReceived)))
-> (UpstreamResult ((), (Decision, ResponseReceived))
    -> Handler (PrivateLeg ResponseReceived))
-> Handler (PrivateLeg ResponseReceived)
forall a b. Handler a -> (a -> Handler b) -> Handler b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                UpstreamRelayed (()
_, (Decision
decision, ResponseReceived
received)) -> PrivateLeg ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Decision -> ResponseReceived -> PrivateLeg ResponseReceived
forall received. Decision -> received -> PrivateLeg received
PrivateAnswered Decision
decision ResponseReceived
received)
                UpstreamRejected Status
status Maybe RetryAfter
retry
                    | Status
status Status -> Status -> Bool
forall a. Eq a => a -> a -> Bool
== Status
status404 -> Handler (PrivateLeg ResponseReceived)
-> (MirrorVersion -> Handler (PrivateLeg ResponseReceived))
-> Maybe MirrorVersion
-> Handler (PrivateLeg ResponseReceived)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (PrivateLeg ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateLeg ResponseReceived
forall received. OriginMiss -> PrivateLeg received
PrivateMissed OriginMiss
MissAbsent)) (RecordedCopy
-> MirrorVersion -> Handler (PrivateLeg ResponseReceived)
publicFallback RecordedCopy
RecordedCopyGone) Maybe MirrorVersion
managed
                    | Bool
otherwise -> IO (PrivateLeg ResponseReceived)
-> Handler (PrivateLeg ResponseReceived)
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Maybe MirrorVersion
-> ReadFailure -> IO (PrivateLeg ResponseReceived)
forall {a}.
Maybe a -> ReadFailure -> IO (PrivateLeg ResponseReceived)
failed Maybe MirrorVersion
managed (Int -> Maybe RetryAfter -> ReadFailure
statusReadFailure (Status -> Int
statusCode Status
status) Maybe RetryAfter
retry))
                UpstreamResult ((), (Decision, ResponseReceived))
UpstreamTransportFailure -> IO (PrivateLeg ResponseReceived)
-> Handler (PrivateLeg ResponseReceived)
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Maybe MirrorVersion
-> ReadFailure -> IO (PrivateLeg ResponseReceived)
forall {a}.
Maybe a -> ReadFailure -> IO (PrivateLeg ResponseReceived)
failed Maybe MirrorVersion
managed (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing))
                UpstreamCooling RetryAfter
retry -> IO (PrivateLeg ResponseReceived)
-> Handler (PrivateLeg ResponseReceived)
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Maybe MirrorVersion
-> ReadFailure -> IO (PrivateLeg ResponseReceived)
forall {a}.
Maybe a -> ReadFailure -> IO (PrivateLeg ResponseReceived)
failed Maybe MirrorVersion
managed (Maybe RetryAfter -> ReadFailure
ReadUnavailable (RetryAfter -> Maybe RetryAfter
forall a. a -> Maybe a
Just RetryAfter
retry)))
    replies :: TarballReplies response
replies = ArtifactRequest response -> TarballReplies response
forall response.
ArtifactRequest response -> TarballReplies response
arReplies ArtifactRequest response
ctx
    respond :: response -> IO ResponseReceived
respond = ArtifactRequest response -> response -> IO ResponseReceived
forall response.
ArtifactRequest response -> response -> IO ResponseReceived
arRespond ArtifactRequest response
ctx

    -- A managed copy keeps the mirror view's refusal while the registry is unavailable.
    failed :: Maybe a -> ReadFailure -> IO (PrivateLeg ResponseReceived)
failed Maybe a
managed = \case
        ReadUnavailable Maybe RetryAfter
retry | Maybe a -> Bool
forall a. Maybe a -> Bool
isJust Maybe a
managed -> Decision -> ResponseReceived -> PrivateLeg ResponseReceived
forall received. Decision -> received -> PrivateLeg received
PrivateAnswered Decision
Metric.Unavailable (ResponseReceived -> PrivateLeg ResponseReceived)
-> IO ResponseReceived -> IO (PrivateLeg ResponseReceived)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe RetryAfter -> IO ResponseReceived
unavailable Maybe RetryAfter
retry
        ReadFailure
failure -> PrivateLeg ResponseReceived -> IO (PrivateLeg ResponseReceived)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateLeg ResponseReceived
forall received. OriginMiss -> PrivateLeg received
PrivateMissed (ReadFailure -> OriginMiss
MissUnresolved ReadFailure
failure))

    publicFallback :: RecordedCopy
-> MirrorVersion -> Handler (PrivateLeg ResponseReceived)
publicFallback RecordedCopy
copy MirrorVersion
expected = ResponseReceived -> PrivateLeg ResponseReceived
forall received. received -> PrivateLeg received
PrivateHandled (ResponseReceived -> PrivateLeg ResponseReceived)
-> Handler ResponseReceived
-> Handler (PrivateLeg ResponseReceived)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe PackageDetails -> Bool)
-> ArtifactRequest response -> Handler ResponseReceived
forall response.
(Maybe PackageDetails -> Bool)
-> ArtifactRequest response -> Handler ResponseReceived
servePublicArtifactWithCoverage (RecordedCopy -> MirrorVersion -> Maybe PackageDetails -> Bool
covered RecordedCopy
copy MirrorVersion
expected) ArtifactRequest response
ctx
    -- A public miss covers a recorded version only once its private copy is gone.
    covered :: RecordedCopy -> MirrorVersion -> Maybe PackageDetails -> Bool
covered RecordedCopy
copy MirrorVersion
expected = \case
        Maybe PackageDetails
Nothing -> RecordedCopy
copy RecordedCopy -> RecordedCopy -> Bool
forall a. Eq a => a -> a -> Bool
== RecordedCopy
RecordedCopyGone
        Just PackageDetails
details -> Map Text MirrorVersion -> PackageInfo -> Bool
publicMirrorCoverage (Text -> MirrorVersion -> Map Text MirrorVersion
forall k a. k -> a -> Map k a
Map.singleton (Version -> Text
renderVersion (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx)) MirrorVersion
expected) (PackageName
-> Map Text PackageDetails
-> Map Text Version
-> [InvalidEntry]
-> PackageInfo
PackageInfo (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (Text -> PackageDetails -> Map Text PackageDetails
forall k a. k -> a -> Map k a
Map.singleton (Version -> Text
renderVersion (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx)) PackageDetails
details) Map Text Version
forall k a. Map k a
Map.empty [])
    shaped :: Request -> Request
shaped Request
request = ResponseHeaders -> Request -> Request
withValidators (ArtifactRequest response -> ResponseHeaders
forall response. ArtifactRequest response -> ResponseHeaders
arValidators ArtifactRequest response
ctx) (ArtifactServe -> Request -> Request
withMethod (ArtifactRequest response -> ArtifactServe
forall response. ArtifactRequest response -> ArtifactServe
arMode ArtifactRequest response
ctx) Request
request)
    unavailable :: Maybe RetryAfter -> IO ResponseReceived
unavailable Maybe RetryAfter
retry = response -> IO ResponseReceived
respond (TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
forall response.
TarballReplies response
-> Status -> ResponseHeaders -> Refusal -> response
tarballError TarballReplies response
replies Status
status503 (Maybe RetryAfter -> ResponseHeaders
retryAfterHeaders Maybe RetryAfter
retry) (Maybe HelpMessage -> Text -> Refusal
mkRefusal (PackumentDeps -> Maybe HelpMessage
pdHelp (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx)) Text
"managed mirror view is unavailable"))
    refuse :: Int -> IO ResponseReceived
refuse Int
code = response -> IO ResponseReceived
respond (TarballReplies response
-> Int -> ResponseHeaders -> Refusal -> response
forall response.
TarballReplies response
-> Int -> ResponseHeaders -> Refusal -> response
tarballPrivateRefused TarballReplies response
replies Int
code [] (Maybe HelpMessage -> Refusal
privateAuthorisationRefusal (PackumentDeps -> Maybe HelpMessage
pdHelp (ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx))))
    privateResponder :: RelayResponder (Decision, ResponseReceived)
privateResponder =
        (Status -> IO (Decision, ResponseReceived))
-> (ResponseReceived -> (Decision, ResponseReceived))
-> RelayResponder ResponseReceived
-> RelayResponder (Decision, ResponseReceived)
forall result response.
(Status -> IO result)
-> (response -> result)
-> RelayResponder response
-> RelayResponder result
privateArtifactResponder (\Status
status -> (Decision
Metric.Deny,) (ResponseReceived -> (Decision, ResponseReceived))
-> IO ResponseReceived -> IO (Decision, ResponseReceived)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IO ResponseReceived
refuse (Status -> Int
statusCode Status
status)) (Decision
Metric.Admit,) (RelayResponder ResponseReceived
 -> RelayResponder (Decision, ResponseReceived))
-> RelayResponder ResponseReceived
-> RelayResponder (Decision, ResponseReceived)
forall a b. (a -> b) -> a -> b
$
            TarballReplies response
-> (response -> IO ResponseReceived)
-> RelayResponder ResponseReceived
forall response received.
TarballReplies response
-> (response -> IO received) -> RelayResponder received
relayResponder TarballReplies response
replies response -> IO ResponseReceived
respond

privateMetadataAdmissionRequired :: ArtifactRequest response -> Bool
privateMetadataAdmissionRequired :: forall response. ArtifactRequest response -> Bool
privateMetadataAdmissionRequired ArtifactRequest response
ctx =
    AdapterArtifact -> PrivateArtifactAddressing
artifactPrivateAddressing (PackumentDeps -> AdapterArtifact
pdArtifact PackumentDeps
deps) PrivateArtifactAddressing -> PrivateArtifactAddressing -> Bool
forall a. Eq a => a -> a -> Bool
== PrivateArtifactAddressing
AdmittedIndexedArtifactLocation
        Bool -> Bool -> Bool
|| (Maybe MirrorView -> Bool
forall a. Maybe a -> Bool
isJust (PackumentDeps -> Maybe MirrorView
pdMirrorState PackumentDeps
deps) Bool -> Bool -> Bool
&& Bool -> Bool
not (PackumentDeps -> PackageName -> Bool
pdFirstParty PackumentDeps
deps (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx)))
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx

data PrivateArtifact
    = PrivateRequest (Maybe MirrorVersion) HTTP.Request
    | PrivateRefused Int
    | PrivateMissing OriginMiss
    | PrivateUnavailable
    | PrivateShed ResponseHeaders
    | PrivateIncomplete RecordedCopy MirrorVersion

privateArtifactRequest :: Maybe MemoryTicket -> ArtifactRequest response -> Maybe ClientCredential -> Handler PrivateArtifact
privateArtifactRequest :: forall response.
Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> Handler PrivateArtifact
privateArtifactRequest Maybe MemoryTicket
ticket ArtifactRequest response
ctx Maybe ClientCredential
token
    | ArtifactRequest response -> Bool
forall response. ArtifactRequest response -> Bool
privateMetadataAdmissionRequired ArtifactRequest response
ctx Bool -> Bool -> Bool
&& Maybe MemoryTicket -> Bool
forall a. Maybe a -> Bool
isNothing Maybe MemoryTicket
ticket = PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PrivateArtifact
PrivateUnavailable
    | Bool
otherwise = case PackumentDeps -> Maybe BaseRequest
pdPrivateBase PackumentDeps
deps of
        Maybe BaseRequest
Nothing -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateArtifact
PrivateMissing OriginMiss
MissAbsent)
        Just BaseRequest
privateBase
            | Bool -> Bool
not (Origin -> PackumentDeps -> Maybe HostPort -> Maybe HostPort -> Bool
tarballHostHonoured Origin
TrustedOrigin PackumentDeps
deps Maybe HostPort
privateHostPort Maybe HostPort
privateHostPort) -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateArtifact
PrivateMissing OriginMiss
MissAbsent)
            | Bool
otherwise -> case AdapterArtifact -> PrivateArtifactAddressing
artifactPrivateAddressing (PackumentDeps -> AdapterArtifact
pdArtifact PackumentDeps
deps) of
                PrivateArtifactAddressing
ConventionalArtifactPath -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BaseRequest -> PrivateArtifact
byConventionalPath BaseRequest
privateBase)
                PrivateArtifactAddressing
IndexedArtifactLocation -> BaseRequest -> Handler PrivateArtifact
indexed BaseRequest
privateBase
                PrivateArtifactAddressing
AdmittedIndexedArtifactLocation -> BaseRequest -> Handler PrivateArtifact
indexed BaseRequest
privateBase
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx

    privateHostPort :: Maybe HostPort
privateHostPort = TarballHostGate -> Maybe HostPort
thgPrivateHostPort (PackumentDeps -> TarballHostGate
pdTarballHostGate PackumentDeps
deps)
    indexed :: BaseRequest -> Handler PrivateArtifact
indexed BaseRequest
privateBase = Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> BaseRequest
-> Maybe HostPort
-> Handler PrivateArtifact
forall response.
Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> BaseRequest
-> Maybe HostPort
-> Handler PrivateArtifact
byIndexedLocation Maybe MemoryTicket
ticket ArtifactRequest response
ctx Maybe ClientCredential
token BaseRequest
privateBase Maybe HostPort
privateHostPort

    byConventionalPath :: BaseRequest -> PrivateArtifact
byConventionalPath BaseRequest
privateBase =
        (UrlFormationError -> PrivateArtifact)
-> (Request -> PrivateArtifact)
-> Either UrlFormationError Request
-> PrivateArtifact
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (PrivateArtifact -> UrlFormationError -> PrivateArtifact
forall a b. a -> b -> a
const (OriginMiss -> PrivateArtifact
PrivateMissing OriginMiss
MissAbsent)) (Maybe MirrorVersion -> Request -> PrivateArtifact
PrivateRequest Maybe MirrorVersion
forall a. Maybe a
Nothing) (Either UrlFormationError Request -> PrivateArtifact)
-> Either UrlFormationError Request -> PrivateArtifact
forall a b. (a -> b) -> a -> b
$
            AdapterArtifact
-> OriginClient
-> PackageName
-> Text
-> Either UrlFormationError Request
artifactByFile (PackumentDeps -> AdapterArtifact
pdArtifact PackumentDeps
deps) (PackumentDeps
-> ExchangeClient
-> BaseRequest
-> Maybe ClientCredential
-> OriginClient
mountOrigin PackumentDeps
deps (ServeRuntime -> ExchangeClient
srPrivateClient (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx)) BaseRequest
privateBase Maybe ClientCredential
token) (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (Filename -> Text
unFilename (ArtifactRequest response -> Filename
forall response. ArtifactRequest response -> Filename
arFile ArtifactRequest response
ctx))

byIndexedLocation :: Maybe MemoryTicket -> ArtifactRequest response -> Maybe ClientCredential -> BaseRequest -> Maybe HostPort -> Handler PrivateArtifact
byIndexedLocation :: forall response.
Maybe MemoryTicket
-> ArtifactRequest response
-> Maybe ClientCredential
-> BaseRequest
-> Maybe HostPort
-> Handler PrivateArtifact
byIndexedLocation Maybe MemoryTicket
ticket ArtifactRequest response
ctx Maybe ClientCredential
token BaseRequest
privateBase Maybe HostPort
privateHostPort = do
    resolved <- Handler (Either MetadataError VersionRead)
-> Handler
     (Either SomeException (Either MetadataError VersionRead))
forall (m :: * -> *) a.
MonadUnliftIO m =>
m a -> m (Either SomeException a)
tryAny (ServeRuntime
-> PackumentDeps
-> Maybe MemoryTicket
-> BaseRequest
-> Maybe ClientCredential
-> (MetadataClient -> IO (Either MetadataError VersionRead))
-> Handler (Either MetadataError VersionRead)
forall a.
ServeRuntime
-> PackumentDeps
-> Maybe MemoryTicket
-> BaseRequest
-> Maybe ClientCredential
-> (MetadataClient -> IO a)
-> Handler a
withPrivateMetadataClient (ArtifactRequest response -> ServeRuntime
forall response. ArtifactRequest response -> ServeRuntime
arRuntime ArtifactRequest response
ctx) PackumentDeps
deps Maybe MemoryTicket
ticket BaseRequest
privateBase Maybe ClientCredential
token (\MetadataClient
client -> MetadataClient
-> PackageName -> Version -> IO (Either MetadataError VersionRead)
fetchVersionMetadata MetadataClient
client (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx) (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx)))
    case resolved of
        Right (Left (MetadataAuthorisationFailure Int
code)) -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> PrivateArtifact
PrivateRefused Int
code)
        Either SomeException (Either MetadataError VersionRead)
_ | Just ReadFailure
failure <- Either SomeException (Either MetadataError VersionRead)
-> Maybe ReadFailure
privateReadFailure Either SomeException (Either MetadataError VersionRead)
resolved -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateArtifact
PrivateMissing (ReadFailure -> OriginMiss
MissUnresolved ReadFailure
failure))
        Either SomeException (Either MetadataError VersionRead)
_ -> case (PackumentDeps -> Maybe MirrorView
pdMirrorState PackumentDeps
deps, Maybe MemoryTicket
ticket) of
            (Just MirrorView
mirror, Just MemoryTicket
admitted)
                | Bool -> Bool
not (PackumentDeps -> PackageName -> Bool
pdFirstParty PackumentDeps
deps (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx)) ->
                    IO
  (Either
     MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
-> Handler
     (Either
        MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
forall a. IO a -> Handler a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MirrorView
-> MemoryTicket
-> PackageName
-> IO
     (Either
        MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
validateMirrorProject MirrorView
mirror MemoryTicket
admitted (ArtifactRequest response -> PackageName
forall response. ArtifactRequest response -> PackageName
arPackage ArtifactRequest response
ctx)) Handler
  (Either
     MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord)))
-> (Either
      MirrorStateFault (Maybe (StateRevision, ProjectMirrorRecord))
    -> Handler PrivateArtifact)
-> Handler PrivateArtifact
forall a b. Handler a -> (a -> Handler b) -> Handler b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                        Left MirrorStateFault
_ -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PrivateArtifact
PrivateUnavailable
                        Right Maybe (StateRevision, ProjectMirrorRecord)
Nothing -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either SomeException (Either MetadataError VersionRead)
-> PrivateArtifact
forall {a}.
Either a (Either MetadataError VersionRead) -> PrivateArtifact
ordinary Either SomeException (Either MetadataError VersionRead)
resolved)
                        Right (Just (StateRevision
_, ProjectMirrorRecord
record)) -> case Version -> ProjectMirrorRecord -> Maybe MirrorVersion
recordVersion (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) ProjectMirrorRecord
record of
                            Maybe MirrorVersion
Nothing -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either SomeException (Either MetadataError VersionRead)
-> PrivateArtifact
forall {a}.
Either a (Either MetadataError VersionRead) -> PrivateArtifact
ordinary Either SomeException (Either MetadataError VersionRead)
resolved)
                            Just MirrorVersion
expected -> case MirrorDocuments
-> Version
-> ProjectMirrorRecord
-> Maybe VersionDoc
-> Either MirrorStateFault (Maybe VersionDoc)
mirrorVersionView (MirrorView -> MirrorDocuments
mirrorViewDocuments MirrorView
mirror) (ArtifactRequest response -> Version
forall response. ArtifactRequest response -> Version
arVersion ArtifactRequest response
ctx) ProjectMirrorRecord
record ((SomeException -> Maybe VersionDoc)
-> (Either MetadataError VersionRead -> Maybe VersionDoc)
-> Either SomeException (Either MetadataError VersionRead)
-> Maybe VersionDoc
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe VersionDoc -> SomeException -> Maybe VersionDoc
forall a b. a -> b -> a
const Maybe VersionDoc
forall a. Maybe a
Nothing) ((MetadataError -> Maybe VersionDoc)
-> (VersionRead -> Maybe VersionDoc)
-> Either MetadataError VersionRead
-> Maybe VersionDoc
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe VersionDoc -> MetadataError -> Maybe VersionDoc
forall a b. a -> b -> a
const Maybe VersionDoc
forall a. Maybe a
Nothing) VersionRead -> Maybe VersionDoc
vrVersion) Either SomeException (Either MetadataError VersionRead)
resolved) of
                                Left MirrorStateFault
_ -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RecordedCopy -> MirrorVersion -> PrivateArtifact
PrivateIncomplete (Either SomeException (Either MetadataError VersionRead)
-> RecordedCopy
recordedCopy Either SomeException (Either MetadataError VersionRead)
resolved) MirrorVersion
expected)
                                Right Maybe VersionDoc
_ | Text -> Map Text ExpectedMirrorFile -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.notMember (Filename -> Text
unFilename (ArtifactRequest response -> Filename
forall response. ArtifactRequest response -> Filename
arFile ArtifactRequest response
ctx)) (MirrorVersion -> Map Text ExpectedMirrorFile
versionFiles MirrorVersion
expected) -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OriginMiss -> PrivateArtifact
PrivateMissing OriginMiss
MissAbsent)
                                Right Maybe VersionDoc
restored -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PrivateArtifact
-> (Request -> PrivateArtifact) -> Maybe Request -> PrivateArtifact
forall b a. b -> (a -> b) -> Maybe a -> b
maybe PrivateArtifact
PrivateUnavailable (Maybe MirrorVersion -> Request -> PrivateArtifact
PrivateRequest (MirrorVersion -> Maybe MirrorVersion
forall a. a -> Maybe a
Just MirrorVersion
expected)) (Maybe VersionDoc
restored Maybe VersionDoc -> (VersionDoc -> Maybe Request) -> Maybe Request
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= PackageDetails -> Maybe Request
requestForDetails (PackageDetails -> Maybe Request)
-> (VersionDoc -> PackageDetails) -> VersionDoc -> Maybe Request
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionDoc -> PackageDetails
vdDetails))
            (Maybe MirrorView, Maybe MemoryTicket)
_ -> PrivateArtifact -> Handler PrivateArtifact
forall a. a -> Handler a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either SomeException (Either MetadataError VersionRead)
-> PrivateArtifact
forall {a}.
Either a (Either MetadataError VersionRead) -> PrivateArtifact
ordinary Either SomeException (Either MetadataError VersionRead)
resolved)
  where
    deps :: PackumentDeps
deps = ArtifactRequest response -> PackumentDeps
forall response. ArtifactRequest response -> PackumentDeps
arDeps ArtifactRequest response
ctx

    ordinary :: Either a (Either MetadataError VersionRead) -> PrivateArtifact
ordinary = \case
        Left a
_ -> OriginMiss -> PrivateArtifact
PrivateMissing (ReadFailure -> OriginMiss
MissUnresolved (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing))
        Right (Left MetadataError
err) -> MetadataError -> PrivateArtifact
privateMetadataFailure MetadataError
err
        Right (Right VersionRead
versionRead) -> PrivateArtifact
-> (Request -> PrivateArtifact) -> Maybe Request -> PrivateArtifact
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (OriginMiss -> PrivateArtifact
PrivateMissing OriginMiss
MissAbsent) (Maybe MirrorVersion -> Request -> PrivateArtifact
PrivateRequest Maybe MirrorVersion
forall a. Maybe a
Nothing) (VersionRead -> Maybe VersionDoc
vrVersion VersionRead
versionRead Maybe VersionDoc -> (VersionDoc -> Maybe Request) -> Maybe Request
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= PackageDetails -> Maybe Request
requestForDetails (PackageDetails -> Maybe Request)
-> (VersionDoc -> PackageDetails) -> VersionDoc -> Maybe Request
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VersionDoc -> PackageDetails
vdDetails)

    requestForDetails :: PackageDetails -> Maybe Request
requestForDetails PackageDetails
details = do
        artifact <- (Artifact -> Bool) -> NonEmpty Artifact -> Maybe Artifact
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Filename -> Text
unFilename (ArtifactRequest response -> Filename
forall response. ArtifactRequest response -> Filename
arFile ArtifactRequest response
ctx)) (Text -> Bool) -> (Artifact -> Text) -> Artifact -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Artifact -> Text
artFilename) (PackageDetails -> NonEmpty Artifact
pkgArtifacts PackageDetails
details)
        let target = Text -> Maybe HostPort
hostPortAddress (Artifact -> Text
artUrl Artifact
artifact)
        guard (artifactAuthorityHonoured (thgEcosystemHosts (pdTarballHostGate deps)) privateHostPort target)
        let carried = if Maybe HostPort
target Maybe HostPort -> Maybe HostPort -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe HostPort
privateHostPort then Maybe ClientCredential
token else Maybe ClientCredential
forall a. Maybe a
Nothing
        rightToMaybe (artifactByUrl (pdArtifact deps) carried (artUrl artifact))

privateMetadataFailure :: MetadataError -> PrivateArtifact
privateMetadataFailure :: MetadataError -> PrivateArtifact
privateMetadataFailure = \case
    MetadataAuthorisationFailure Int
code -> Int -> PrivateArtifact
PrivateRefused Int
code
    MetadataError
err -> OriginMiss -> PrivateArtifact
PrivateMissing (OriginMiss
-> (ReadFailure -> OriginMiss) -> Maybe ReadFailure -> OriginMiss
forall b a. b -> (a -> b) -> Maybe a -> b
maybe OriginMiss
MissAbsent ReadFailure -> OriginMiss
MissUnresolved (MetadataError -> Maybe ReadFailure
metadataReadFailure MetadataError
err))

-- | Classify a private metadata failure: 'Nothing' for an access refusal, else absence or a failure by cause.
privateMetadataMiss :: MetadataError -> Maybe OriginMiss
privateMetadataMiss :: MetadataError -> Maybe OriginMiss
privateMetadataMiss = \case
    MetadataAuthorisationFailure{} -> Maybe OriginMiss
forall a. Maybe a
Nothing
    MetadataError
err -> OriginMiss -> Maybe OriginMiss
forall a. a -> Maybe a
Just (OriginMiss
-> (ReadFailure -> OriginMiss) -> Maybe ReadFailure -> OriginMiss
forall b a. b -> (a -> b) -> Maybe a -> b
maybe OriginMiss
MissAbsent ReadFailure -> OriginMiss
MissUnresolved (MetadataError -> Maybe ReadFailure
metadataReadFailure MetadataError
err))

-- | Why a private version read failed, or 'Nothing' when it resolved, settled absence or refused access.
privateReadFailure :: Either SomeException (Either MetadataError VersionRead) -> Maybe ReadFailure
privateReadFailure :: Either SomeException (Either MetadataError VersionRead)
-> Maybe ReadFailure
privateReadFailure = \case
    Left SomeException
_ -> ReadFailure -> Maybe ReadFailure
forall a. a -> Maybe a
Just (Maybe RetryAfter -> ReadFailure
ReadUnavailable Maybe RetryAfter
forall a. Maybe a
Nothing)
    Right (Left MetadataError
err) -> MetadataError -> Maybe ReadFailure
metadataReadFailure MetadataError
err
    Right (Right VersionRead
_) -> Maybe ReadFailure
forall a. Maybe a
Nothing