module Ecluse.Core.Registry.RubyGems.Publish (
rubyPublish,
rubyPublishCodec,
uploadClaims,
classifyPublish,
) where
import Network.HTTP.Client (Request (method, requestBody, requestHeaders), RequestBody (RequestBodyBS))
import Network.HTTP.Types.Header (hContentType)
import UnliftIO.Exception (evaluate)
import Ecluse.Core.Credential (ClientCredential)
import Ecluse.Core.Deadline (inspectionDeadline)
import Ecluse.Core.Package (hashValue, renderPackageName)
import Ecluse.Core.Registry (FetchFault (FetchUrlUnformable), ParseError (..), PublishBodyFault (PublishMalformed), PublishError (PublishError), PublishFault (..), UrlFormationError (UnparseableUrl), isSuccessStatus)
import Ecluse.Core.Registry.Adapter.Capability
import Ecluse.Core.Registry.CachedDocument (rubyGemsCached)
import Ecluse.Core.Registry.Metadata (VersionDoc (vdRaw))
import Ecluse.Core.Registry.Metadata.Fetch.Preparation (presentedRead)
import Ecluse.Core.Registry.MirrorUpload
import Ecluse.Core.Registry.MirrorUpload.Internal (checkedMirrorUploadData)
import Ecluse.Core.Registry.Origin (OriginClient (ocToken), originBaseUrl)
import Ecluse.Core.Registry.Publish (PublishCodec (..), relayPublishRequest)
import Ecluse.Core.Registry.Request (CredentialMapping, ServicePresentation, StoreOperation (StoreRead, StoreWrite), apiEndpoint, attachCredential, metadataGet, parseRequestEither, presentedMapping)
import Ecluse.Core.Registry.RubyGems.Archive
import Ecluse.Core.Registry.RubyGems.CompactSpec (checkGemSpecification)
import Ecluse.Core.Registry.RubyGems.Credential
import Ecluse.Core.Registry.RubyGems.Document (GemRow (..))
import Ecluse.Core.Registry.RubyGems.Metadata (prepareGemRead)
import Ecluse.Core.Registry.RubyGems.Mirror (mirrorRow, rubyGemsMirrorDocuments, rubyGemsStateFormat, rubyMirrorCompanion)
import Ecluse.Core.Registry.RubyGems.Request (gemInfoUrl)
import Ecluse.Core.Security.Limits (Limits)
import Ecluse.Core.Server.Admission.Types (ChargeFactors (cfFullReadPermille))
rubyPublish :: ChargeFactors -> AdapterPublish
rubyPublish :: ChargeFactors -> AdapterPublish
rubyPublish ChargeFactors
factors =
AdapterPublish
{ publishRelay :: ServicePresentation
-> OriginClient
-> PackageName
-> PublishRequestBody
-> IO (Either FetchFault PublishRelayResponse)
publishRelay = \ServicePresentation
presentation OriginClient
origin PackageName
_ PublishRequestBody
body -> OriginClient
-> Either UrlFormationError Request
-> IO (Either FetchFault PublishRelayResponse)
relayPublishRequest OriginClient
origin (CredentialMapping
-> Text
-> Maybe ClientCredential
-> PublishExtras
-> Method
-> Either UrlFormationError Request
bodyRequest (ServicePresentation
-> StoreOperation -> CredentialMapping -> CredentialMapping
presentedMapping ServicePresentation
presentation StoreOperation
StoreWrite CredentialMapping
rubyPublishCredential) (OriginClient -> Text
originBaseUrl OriginClient
origin) (OriginClient -> Maybe ClientCredential
ocToken OriginClient
origin) (PublishRequestBody -> PublishExtras
publishBodyExtras PublishRequestBody
body) (PublishRequestBody -> Method
publishBodyBytes PublishRequestBody
body))
, publishCredential :: CredentialMapping
publishCredential = CredentialMapping
rubyPublishCredential
, publishRequestExtras :: RequestHeaders -> Either PublishBodyFault PublishExtras
publishRequestExtras = RequestHeaders -> Either PublishBodyFault PublishExtras
rubyPublishExtras
, publishUploadClaims :: Limits
-> (Int -> IO ())
-> Text
-> PublishRequestBody
-> IO (Either PublishBodyFault [Text])
publishUploadClaims = Limits
-> (Int -> IO ())
-> Text
-> PublishRequestBody
-> IO (Either PublishBodyFault [Text])
uploadClaims
, publishCodec :: ServicePresentation -> PublishCodec
publishCodec = ChargeFactors -> ServicePresentation -> PublishCodec
rubyPublishCodec ChargeFactors
factors
, publishMirrorRequirements :: MirrorRequirements
publishMirrorRequirements = WorkerMetadataRead
-> MirrorStateFormat
-> MirrorStateRequirement
-> MirrorRequirements
MirrorRequirements (PrepareRead -> WorkerMetadataRead
NativeChargedWorkerRead PrepareRead
prepareGemRead) MirrorStateFormat
rubyGemsStateFormat (MirrorDocuments -> MirrorStateRequirement
DurableVersionState MirrorDocuments
rubyGemsMirrorDocuments)
, publishUploadEndpoint :: UploadEndpointRequirement
publishUploadEndpoint = UploadEndpointRequirement
ReadRootUpload
, publishIdentity :: UploadIdentityRequirement
publishIdentity = UploadIdentityRequirement
TokenIdentity
}
rubyPublishCodec :: ChargeFactors -> ServicePresentation -> PublishCodec
rubyPublishCodec :: ChargeFactors -> ServicePresentation -> PublishCodec
rubyPublishCodec ChargeFactors
factors ServicePresentation
presentation =
PublishCodec
{ pcPrepareSource :: PackageName
-> Version
-> VersionDoc
-> Either PublishFault (MirrorInventory, ())
pcPrepareSource = \PackageName
name Version
version VersionDoc
doc -> do
source <- PublishFault
-> Maybe GemDocument -> Either PublishFault GemDocument
forall l r. l -> Maybe r -> Either l r
maybeToRight (Text -> PublishFault
PublishSourceUnavailable Text
"RubyGems snapshot has no paired native source") (VersionDoc -> Maybe CachedDoc
vdRaw VersionDoc
doc Maybe CachedDoc
-> (CachedDoc -> Maybe GemDocument) -> Maybe GemDocument
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (GemDocument -> CachedDoc, CachedDoc -> Maybe GemDocument)
-> CachedDoc -> Maybe GemDocument
forall a b. (a, b) -> b
snd (GemDocument -> CachedDoc, CachedDoc -> Maybe GemDocument)
rubyGemsCached)
inventory <- checkedMirrorInventory name version doc (RubyGemsMirrorRead source)
pure (inventory, ())
, pcPrepareUpload :: Deadlines
-> Limits
-> (Int -> IO ())
-> MirrorInventory
-> ()
-> ExpectedMirrorFile
-> VerifiedArtifactBytes
-> IO (Either PublishFault (MirrorUploadData GemArchive))
pcPrepareUpload = \Deadlines
deadlines Limits
limits Int -> IO ()
charge MirrorInventory
inventory () ExpectedMirrorFile
file VerifiedArtifactBytes
verified -> Deadlines
-> PublishFault
-> IO (Either PublishFault (MirrorUploadData GemArchive))
-> IO (Either PublishFault (MirrorUploadData GemArchive))
forall e a. Deadlines -> e -> IO (Either e a) -> IO (Either e a)
inspectionDeadline Deadlines
deadlines (Text -> PublishFault
PublishSourceUnavailable Text
"gem archive validation timed out") (IO (Either PublishFault (MirrorUploadData GemArchive))
-> IO (Either PublishFault (MirrorUploadData GemArchive)))
-> IO (Either PublishFault (MirrorUploadData GemArchive))
-> IO (Either PublishFault (MirrorUploadData GemArchive))
forall a b. (a -> b) -> a -> b
$ do
inspected <- Limits
-> (Int -> IO ()) -> Method -> IO (Either ParseError GemArchive)
inspectGemArchive Limits
limits Int -> IO ()
charge (VerifiedArtifactBytes -> Method
verifiedBytes VerifiedArtifactBytes
verified)
evaluate $ do
archive <- first (PublishSourceUnavailable . parseErrorMessage) (inspected >>= checkRawEnvelope)
row <- mirrorRow inventory file
checked <- first (PublishSourceUnavailable . parseErrorMessage) (checkGemArchive (grCoordinate row) (hashValue (grChecksum row)) archive)
_ <- first (PublishSourceUnavailable . parseErrorMessage) (checkGemSpecification (grCoordinate row) row (gemArchiveSpecification checked))
checkedMirrorUploadData inventory file verified checked
, pcMirrorCompanion :: Maybe MirrorCompanion
pcMirrorCompanion = MirrorCompanion -> Maybe MirrorCompanion
forall a. a -> Maybe a
Just MirrorCompanion
rubyMirrorCompanion
, pcNativeComplete :: PackageName -> Version -> PackageInfo -> Bool
pcNativeComplete = \PackageName
_ Version
_ PackageInfo
_ -> Bool
False
, pcTargetRead :: PrepareRead
pcTargetRead = CredentialMapping -> PrepareRead -> PrepareRead
presentedRead CredentialMapping
readAs PrepareRead
prepareGemRead
, pcTargetReadPermille :: Int
pcTargetReadPermille = ChargeFactors -> Int
cfFullReadPermille ChargeFactors
factors
, pcProbeRequest :: Text
-> Maybe ClientCredential
-> PackageName
-> Either UrlFormationError Request
pcProbeRequest = \Text
target Maybe ClientCredential
credential PackageName
name -> CredentialMapping
-> Maybe ClientCredential -> Method -> Request -> Request
metadataGet CredentialMapping
readAs Maybe ClientCredential
credential Method
"text/plain" (Request -> Request)
-> Either UrlFormationError Request
-> Either UrlFormationError Request
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> PackageName -> Either UrlFormationError Text
gemInfoUrl Text
target PackageName
name Either UrlFormationError Text
-> (Text -> Either UrlFormationError Request)
-> Either UrlFormationError Request
forall a b.
Either UrlFormationError a
-> (a -> Either UrlFormationError b) -> Either UrlFormationError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Either UrlFormationError Request
parseRequestEither)
, pcVersionListWalk :: Maybe (Limits -> Cursor -> Step VersionListState)
pcVersionListWalk = Maybe (Limits -> Cursor -> Step VersionListState)
forall a. Maybe a
Nothing
, pcPrepareTarget :: OriginClient
-> RegistryUrl -> IO (Either MetadataError RegistryUrl)
pcPrepareTarget = \OriginClient
_ RegistryUrl
target -> Either MetadataError RegistryUrl
-> IO (Either MetadataError RegistryUrl)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RegistryUrl -> Either MetadataError RegistryUrl
forall a b. b -> Either a b
Right RegistryUrl
target)
, pcPublishRequest :: Text
-> Maybe ClientCredential
-> PublishPlan
-> MirrorUploadData GemArchive
-> Either PublishFault Request
pcPublishRequest = \Text
target Maybe ClientCredential
credential PublishPlan
_ MirrorUploadData GemArchive
upload -> (UrlFormationError -> PublishFault)
-> Either UrlFormationError Request -> Either PublishFault Request
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (FetchFault -> PublishFault
PublishFetch (FetchFault -> PublishFault)
-> (UrlFormationError -> FetchFault)
-> UrlFormationError
-> PublishFault
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UrlFormationError -> FetchFault
FetchUrlUnformable) (CredentialMapping
-> Text
-> Maybe ClientCredential
-> PublishExtras
-> Method
-> Either UrlFormationError Request
bodyRequest (ServicePresentation
-> StoreOperation -> CredentialMapping -> CredentialMapping
presentedMapping ServicePresentation
presentation StoreOperation
StoreWrite CredentialMapping
rubyPublishCredential) Text
target Maybe ClientCredential
credential PublishExtras
NoPublishExtras (MirrorUploadData GemArchive -> Method
forall metadata. MirrorUploadData metadata -> Method
uploadBytes MirrorUploadData GemArchive
upload))
, pcPublishOutcome :: Int -> Method -> Either PublishFault ()
pcPublishOutcome = Int -> Method -> Either PublishFault ()
classifyPublish
}
where
readAs :: CredentialMapping
readAs = ServicePresentation
-> StoreOperation -> CredentialMapping -> CredentialMapping
presentedMapping ServicePresentation
presentation StoreOperation
StoreRead CredentialMapping
rubyReadCredential
uploadClaims :: Limits -> (Int -> IO ()) -> Text -> PublishRequestBody -> IO (Either PublishBodyFault [Text])
uploadClaims :: Limits
-> (Int -> IO ())
-> Text
-> PublishRequestBody
-> IO (Either PublishBodyFault [Text])
uploadClaims Limits
limits Int -> IO ()
charge Text
_ PublishRequestBody
body = do
inspected <- Limits
-> (Int -> IO ()) -> Method -> IO (Either ParseError GemArchive)
inspectGemArchive Limits
limits Int -> IO ()
charge (PublishRequestBody -> Method
publishBodyBytes PublishRequestBody
body)
case inspected >>= checkRawEnvelope of
Left ParseError
fault -> Either PublishBodyFault [Text]
-> IO (Either PublishBodyFault [Text])
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PublishBodyFault -> Either PublishBodyFault [Text]
forall a b. a -> Either a b
Left (ParseError -> PublishBodyFault
PublishMalformed ParseError
fault))
Right GemArchive
archive -> do
name <- PackageName -> IO PackageName
forall (m :: * -> *) a. MonadIO m => a -> m a
evaluate (GemArchive -> PackageName
gemArchiveName GemArchive
archive)
pure (Right [renderPackageName name])
bodyRequest :: CredentialMapping -> Text -> Maybe ClientCredential -> PublishExtras -> ByteString -> Either UrlFormationError Request
bodyRequest :: CredentialMapping
-> Text
-> Maybe ClientCredential
-> PublishExtras
-> Method
-> Either UrlFormationError Request
bodyRequest CredentialMapping
credentialMapping Text
target Maybe ClientCredential
credential PublishExtras
extras Method
bytes = do
base <- UrlFormationError
-> Text -> Text -> Either UrlFormationError Request
apiEndpoint (Text -> UrlFormationError
UnparseableUrl Text
"RubyGems publication root contains a query or fragment") Text
target Text
"api/v1/gems"
pure . attachCredential credentialMapping credential $
base
{ method = "POST"
, requestHeaders = (hContentType, "application/octet-stream") : rubyOtpHeaders extras
, requestBody = RequestBodyBS bytes
}
classifyPublish :: Int -> ByteString -> Either PublishFault ()
classifyPublish :: Int -> Method -> Either PublishFault ()
classifyPublish Int
status Method
_
| Int -> Bool
isSuccessStatus Int
status = () -> Either PublishFault ()
forall a b. b -> Either a b
Right ()
| Bool
otherwise = PublishFault -> Either PublishFault ()
forall a b. a -> Either a b
Left (PublishError -> PublishFault
PublishRejected (Text -> PublishError
PublishError (Text
"RubyGems publication failed with HTTP status " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall b a. (Show a, IsString b) => a -> b
show Int
status)))