packages feed

oglyad-0.1.6.0: src/Oglyad/Release.hs

module Oglyad.Release
  ( Base (..),
    baseName,
    baseRepoOwners,
    Distro (..),
    terra,
    terraEl,
    ultramarine,
    tuatara,
    distros,
    lookupDistro,
    remoteRepoName,
    Release (..),
    isRolling,
    tumbleweed,
    el,
    elReleasesFrom,
    releaseLabel,
    releaseDist,
    releaseBranch,
    releaseMacros,
    releaseSubrepos,
    releaseCacheTag,
    repoName,
    defaultRepoUrl,
    repoUrlFor,
    baseReposFor,
    parseReleaseArg,
    ReleaseArg (..),
    releaseArgBase,
    bodhiReleasesUrl,
    parseBodhiReleases,
    mergeFindings,
  )
where

import Data.Aeson (Value (..), eitherDecode)
import Data.Aeson.KeyMap qualified as KM
import Data.ByteString.Lazy qualified as LBS
import Data.Char (isDigit)
import Data.Containers.ListUtils (nubOrd)
import Data.List (nub, sortOn)
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Text qualified as T
import Data.Vector qualified as V
import Oglyad.Types (Finding (..))
import Text.Read (readMaybe)

data Base = Fedora | OpenSUSE | EL
  deriving stock (Eq, Show)

baseName :: Base -> Text
baseName = \case
  Fedora -> "Fedora"
  OpenSUSE -> "openSUSE"
  EL -> "EL"

-- | who ships the packages in 'baseReposFor'
baseRepoOwners :: Base -> Text
baseRepoOwners = \case
  EL -> "AlmaLinux or EPEL"
  b -> baseName b

data Distro = Distro
  { distroName :: Text,
    -- | releases default to the first one's
    distroBases :: [Base],
    distroRoot :: FilePath,
    distroMarker :: FilePath,
    -- | the monorepo's GitHub repo name, which tells distros with the same
    -- marker apart
    distroUpstream :: Text,
    distroRepo :: Text,
    distroBranch :: Text,
    distroDist :: Text,
    distroRepoUrl :: Text,
    distroSubrepos :: Bool,
    distroSkippedChecks :: [Text]
  }
  deriving stock (Eq, Show)

-- | its el10 branch is still around until Terra EL finishes moving to
-- 'terraEl'
terra :: Distro
terra =
  Distro
    { distroName = "terra",
      distroBases = [Fedora, EL],
      distroRoot = "anda",
      distroMarker = "anda",
      distroUpstream = "packages",
      distroRepo = "terra",
      distroBranch = "f",
      distroDist = ".fc",
      distroRepoUrl = defaultRepoUrl,
      distroSubrepos = True,
      distroSkippedChecks = []
    }

terraEl :: Distro
terraEl =
  Distro
    { distroName = "terra-el",
      distroBases = [EL],
      distroRoot = "anda",
      distroMarker = "anda",
      distroUpstream = "packages-el",
      distroRepo = "terra",
      distroBranch = "",
      distroDist = "",
      distroRepoUrl = defaultRepoUrl,
      distroSubrepos = False,
      distroSkippedChecks = []
    }

ultramarine :: Distro
ultramarine =
  Distro
    { distroName = "ultramarine",
      distroBases = [Fedora],
      distroRoot = "ultramarine",
      distroMarker = "ultramarine",
      distroUpstream = "packages",
      distroRepo = "um",
      distroBranch = "um",
      distroDist = ".um",
      distroRepoUrl = defaultRepoUrl,
      distroSubrepos = True,
      distroSkippedChecks = ["no-autoupdate"]
    }

tuatara :: Distro
tuatara =
  Distro
    { distroName = "tuatara",
      distroBases = [OpenSUSE],
      distroRoot = "",
      distroMarker = "tuatara",
      distroUpstream = "tuatara",
      distroRepo = "tuatara-",
      distroBranch = "",
      distroDist = "",
      distroRepoUrl = "https://repos.fyralabs.com/{repo}",
      distroSubrepos = False,
      distroSkippedChecks = []
    }

distros :: [Distro]
distros = [terra, terraEl, ultramarine, tuatara]

lookupDistro :: String -> Either String Distro
lookupDistro raw = case [d | d <- distros, distroName d == T.pack raw] of
  d : _ -> Right d
  [] -> Left ("unknown distro " <> show raw <> ", expected one of: " <> T.unpack (T.intercalate ", " (map distroName distros)))

remoteRepoName :: Text -> Maybe Text
remoteRepoName url = case T.split (`elem` ['/', ':']) (T.dropWhileEnd (== '/') (T.strip url)) of
  parts@(_ : _ : _) | name <- dropGit (last parts), not (T.null name) -> Just name
  _ -> Nothing
  where
    dropGit n = maybe n id (T.stripSuffix ".git" n)

-- | a base distro release a monorepo builds for. rawhide keeps its number
-- too, since %fedora still needs one when evaluating specs
data Release = Release
  { relBase :: Base,
    relName :: Text,
    -- | what %fedora, %suse_version or %rhel expands to
    relVersion :: Int
  }
  deriving stock (Eq, Show)

isRolling :: Release -> Bool
isRolling r = relName r `elem` ["rawhide", "tumbleweed"]

tumbleweed :: Release
tumbleweed = Release OpenSUSE "tumbleweed" 1699

el :: Int -> Release
el n = Release EL ("el" <> T.pack (show n)) n

elReleasesFrom :: [Text] -> [Release]
elReleasesFrom branches =
  sortOn
    relVersion
    [ el n
    | b <- nub branches,
      Just digits <- [T.stripPrefix "el" b],
      not (T.null digits),
      T.all isDigit digits,
      Just n <- [readMaybe (T.unpack digits)]
    ]

releaseLabel :: Release -> Text
releaseLabel r
  | relBase r == Fedora && not (isRolling r) = "f" <> relName r
  | otherwise = relName r

-- | rawhide builds use .fcrawhide, not .fc46. terrapkg/packages' bootstrap
-- workflow rewrites macros.dist to do it, and Ultramarine does the same
releaseDist :: Distro -> Release -> Text
releaseDist d r = case relBase r of
  Fedora -> distroDist d <> relName r
  OpenSUSE -> ""
  EL -> "." <> relName r

-- | %fedora comes from the host otherwise, so -r 43 on an F44 box would
-- take the wrong side of every %if 0%{?fedora} >= 44
releaseMacros :: Distro -> Release -> [(Text, Maybe Text)]
releaseMacros d r = case relBase r of
  Fedora -> [("dist", Just (releaseDist d r)), ("fedora", Just version)]
  OpenSUSE ->
    [ ("dist", Nothing),
      ("fedora", Nothing),
      ("suse_version", Just version),
      ("is_opensuse", Just "1")
    ]
  EL ->
    [ ("dist", Just (releaseDist d r)),
      ("fedora", Nothing),
      ("rhel", Just version),
      (relName r, Just "1"),
      ("epel", Just version)
    ]
  where
    version = T.pack (show (relVersion r))

releaseCacheTag :: Distro -> Release -> Text
releaseCacheTag d r = "-" <> distroName d <> "-" <> relName r

releaseBranch :: Distro -> Release -> Text
releaseBranch d r = case relBase r of
  Fedora -> distroBranch d <> relName r
  _ -> relName r

-- | Terra's EL builds only ever upload to terrael10, whatever subrepo label
-- a package has
releaseSubrepos :: Distro -> Release -> Bool
releaseSubrepos d r = distroSubrepos d && relBase r == Fedora

repoName :: Distro -> Release -> Text
repoName d r = distroRepo d <> relName r

-- | the same metalink dnf uses
defaultRepoUrl :: Text
defaultRepoUrl = "https://tetsudou.fyralabs.com/metalink?repo={repo}&arch=x86_64"

-- | {repo} is left for 'Oglyad.Types.repoUrl' to fill in
repoUrlFor :: Text -> Release -> Text
repoUrlFor url r = T.replace "{release}" (relName r) url

-- | EL builds run on AlmaLinux with EPEL enabled, so both count
baseReposFor :: Release -> [Text]
baseReposFor r = case relBase r of
  OpenSUSE ->
    [ "https://download.opensuse.org/tumbleweed/repo/oss",
      "https://download.opensuse.org/update/tumbleweed"
    ]
  EL ->
    [ "https://repo.almalinux.org/almalinux/" <> major <> "/" <> repo <> "/x86_64/os"
    | repo <- ["BaseOS", "AppStream", "CRB", "extras"]
    ]
      <> ["https://dl.fedoraproject.org/pub/epel/" <> major <> "/Everything/x86_64"]
  Fedora -> fedoraRepos
  where
    major = T.pack (show (relVersion r))
    fedoraRepos
      | isRolling r = ["https://dl.fedoraproject.org/pub/fedora/linux/development/rawhide/Everything/x86_64/os"]
      | otherwise =
          [ "https://dl.fedoraproject.org/pub/fedora/linux/releases/" <> relName r <> "/Everything/x86_64/os",
            "https://dl.fedoraproject.org/pub/fedora/linux/updates/" <> relName r <> "/Everything/x86_64"
          ]

-- | --release, before we know the distro or rawhide's number
data ReleaseArg = NumberedArg Int | RawhideArg | TumbleweedArg | ElArg Int
  deriving stock (Eq, Show)

releaseArgBase :: ReleaseArg -> Base
releaseArgBase = \case
  NumberedArg _ -> Fedora
  RawhideArg -> Fedora
  TumbleweedArg -> OpenSUSE
  ElArg _ -> EL

parseReleaseArg :: String -> Either String ReleaseArg
parseReleaseArg raw = case raw of
  "tumbleweed" -> Right TumbleweedArg
  "tw" -> Right TumbleweedArg
  'e' : 'l' : n | Just v <- number n -> Right (ElArg v)
  _ -> case dropF raw of
    "rawhide" -> Right RawhideArg
    n | Just v <- number n -> Right (NumberedArg v)
    _ -> Left ("unknown release " <> show raw <> ", expected a number like 43, f43, rawhide, tumbleweed, or el10")
  where
    dropF ('f' : rest) = rest
    dropF s = s
    number n
      | not (null n), all isDigit n = readMaybe n
      | otherwise = Nothing

-- | unarchived releases are the current ones, a branched one before its
-- release, and rawhide
bodhiReleasesUrl :: Text
bodhiReleasesUrl = "https://bodhi.fedoraproject.org/releases/?exclude_archived=true&rows_per_page=100"

parseBodhiReleases :: LBS.ByteString -> Either Text [Release]
parseBodhiReleases body = do
  v <- either (Left . ("bad json from Bodhi: " <>) . T.pack) Right (eitherDecode body)
  rels <- case v of
    Object o | Just (Array rs) <- KM.lookup "releases" o -> Right (V.toList rs)
    _ -> Left "no releases in Bodhi's answer"
  let found =
        [ Release Fedora (if branch == "rawhide" then "rawhide" else ver) n
        | Object r <- rels,
          Just (String name) <- [KM.lookup "name" r],
          isFedoraRelease name,
          Just (String ver) <- [KM.lookup "version" r],
          Just n <- [readMaybe (T.unpack ver)],
          Just (String branch) <- [KM.lookup "branch" r]
        ]
  case found of
    [] -> Left "Bodhi listed no Fedora releases"
    _ -> Right (sortOn (\r -> (isRolling r, relVersion r)) found)
  where
    isFedoraRelease name = case T.uncons name of
      Just ('F', digits) -> not (T.null digits) && T.all isDigit digits
      _ -> False

-- | a finding that comes up the same way in several releases is shown once,
-- with fReleases naming them. "the same way" ignores the dist tag, so
-- build-lag's "spec is at 1.2-1.fc43" and "spec is at 1.2-1.fc44" merge into
-- "spec is at 1.2-1%{dist}"
mergeFindings :: Distro -> [(Release, [Finding])] -> [Finding]
mergeFindings distro perRelease =
  [ merged k f (r : map snd rest)
  | k <- nubOrd (map fst tagged),
    Just ((f, r) : rest) <- [Map.lookup k grouped]
  ]
  where
    tagged = [(keyOf r f, (f, relName r)) | (r, fs) <- perRelease, f <- fs]
    keyOf r f = (fCheck f, fPackage f, fPath f, fSeverity f, distless r (fMessage f))
    distless r msg = case releaseDist distro r of
      "" -> msg
      dist -> T.replace dist "%{dist}" msg
    -- members stay in the order the releases were given
    grouped = Map.fromListWith (flip (<>)) [(k, [x]) | (k, x) <- tagged]
    merged (_, _, _, _, generic) f rels = case nub rels of
      [single] -> f {fReleases = [single]}
      many -> f {fReleases = many, fMessage = generic}