distro-tools/apollo/server/routes/api_updateinfo.py

import datetime
from typing import Optional
from xml.etree import ElementTree as ET

from fastapi import APIRouter, Response
from slugify import slugify

from apollo.db import AdvisoryAffectedProduct
from apollo.server.settings import COMPANY_NAME, MANAGING_EDITOR, UI_URL, get_setting

from apollo.rpmworker.repomd import NEVRA_RE, NVRA_RE, EPOCH_RE

from common.fastapi import RenderErrorTemplateException

router = APIRouter(tags=["updateinfo"])


@router.get("/{product_name}/{repo}/updateinfo.xml")
async def get_updateinfo(
    product_name: str,
    repo: str,
    req_arch: Optional[str] = None,
):
    filters = {
        "name": product_name,
        "advisory__packages__repo_name": repo,
    }
    if req_arch:
        filters["arch"] = req_arch

    affected_products = await AdvisoryAffectedProduct.filter(
        **filters
    ).prefetch_related(
        "advisory",
        "advisory__cves",
        "advisory__fixes",
        "advisory__packages",
        "supported_product",
    ).all()
    if not affected_products:
        raise RenderErrorTemplateException("No advisories found", 404)

    ui_url = await get_setting(UI_URL)
    managing_editor = await get_setting(MANAGING_EDITOR)
    company_name = await get_setting(COMPANY_NAME)

    advisories = {}
    for affected_product in affected_products:
        advisory = affected_product.advisory
        if advisory.name not in advisories:
            advisories[advisory.name] = {
                "advisory":
                    advisory,
                "arch":
                    affected_product.arch,
                "major_version":
                    affected_product.major_version,
                "minor_version":
                    affected_product.minor_version,
                "supported_product_name":
                    affected_product.supported_product.name,
            }

    tree = ET.Element("updates")
    for _, adv in advisories.items():
        advisory = adv["advisory"]
        product_arch = adv["arch"]
        major_version = adv["major_version"]
        minor_version = adv["minor_version"]
        supported_product_name = adv["supported_product_name"]

        update = ET.SubElement(tree, "update")

        # Set update attributes
        update.set("from", managing_editor)
        update.set("status", "final")

        if advisory.kind == "Security":
            update.set("type", "security")
        elif advisory.kind == "Bug Fix":
            update.set("type", "bugfix")
        elif advisory.kind == "Enhancement":
            update.set("type", "enhancement")

        update.set("version", "2")

        # Add id
        ET.SubElement(update, "id").text = advisory.name

        # Add title
        ET.SubElement(update, "title").text = advisory.synopsis

        # Add description
        ET.SubElement(update, "description").text = advisory.description

        # Add time
        time_format = "%Y-%m-%d %H:%M:%S"
        issued = ET.SubElement(update, "issued")
        issued.set("date", advisory.published_at.strftime(time_format))
        updated = ET.SubElement(update, "updated")
        updated.set("date", advisory.updated_at.strftime(time_format))

        # Add rights
        now = datetime.datetime.utcnow()
        ET.SubElement(
            update, "rights"
        ).text = f"Copyright {now.year} {company_name}"

        # Add release name
        release_name = f"{supported_product_name} {major_version}"
        if minor_version:
            release_name += f".{minor_version}"
        ET.SubElement(update, "release").text = release_name

        # Add pushcount
        ET.SubElement(update, "pushcount").text = "1"

        # Add severity
        ET.SubElement(update, "severity").text = advisory.severity

        # Add summary
        ET.SubElement(update, "summary").text = advisory.topic

        # Add description
        ET.SubElement(update, "description").text = advisory.description

        # Add solution
        ET.SubElement(update, "solution").text = ""

        # Add references
        references = ET.SubElement(update, "references")
        for cve in advisory.cves:
            reference = ET.SubElement(references, "reference")
            reference.set(
                "href",
                f"https://cve.mitre.org/cgi-bin/cvename.cgi?name={cve.cve}",
            )
            reference.set("id", cve.cve)
            reference.set("type", "cve")
            reference.set("title", cve.cve)

        for fix in advisory.fixes:
            reference = ET.SubElement(references, "reference")
            reference.set("href", fix.source)
            reference.set("id", fix.ticket_id)
            reference.set("type", "bugzilla")
            reference.set("title", fix.description)

        # Add UI self reference
        reference = ET.SubElement(references, "reference")
        reference.set("href", f"{ui_url}/{advisory.name}")
        reference.set("id", advisory.name)
        reference.set("type", "self")
        reference.set("title", advisory.name)

        # Add packages
        packages = ET.SubElement(update, "pkglist")

        suffixes_to_skip = [
            "-debuginfo",
            "-debugsource",
            "-debuginfo-common",
            "-debugsource-common",
        ]

        pkg_name_map = {}
        for pkg in advisory.packages:
            name = pkg.package_name
            if pkg.module_name:
                name = f"{pkg.module_name}:{pkg.package_name}:{pkg.module_stream}"
            if name not in pkg_name_map:
                pkg_name_map[name] = []

            pkg_name_map[name].append(pkg)

        pkg_src_rpm = {}
        for top_pkg in advisory.packages:
            name = top_pkg.package_name
            if top_pkg.module_name:
                name = f"{top_pkg.module_name}:{top_pkg.package_name}:{top_pkg.module_stream}"
            if name not in pkg_src_rpm:
                for pkg in pkg_name_map[name]:
                    nvra_no_epoch = EPOCH_RE.sub("", pkg.nevra)
                    nvra = NVRA_RE.search(nvra_no_epoch)
                    if nvra:
                        nvr_name = nvra.group(1)
                        nvr_arch = nvra.group(4)
                        if pkg.package_name == nvr_name and nvr_arch == "src":
                            src_rpm = nvra_no_epoch
                            if not src_rpm.endswith(".rpm"):
                                src_rpm += ".rpm"
                            pkg_src_rpm[name] = src_rpm

        # Collection list, may be more than one if module RPMs are involved
        collections = {}
        no_default_collection = False
        default_collection_short = slugify(f"{product_name}-{repo}-rpms")

        # Check if this is an actual module advisory, if so we need to split the
        # collections, and module RPMs need to go into their own collection based on
        # module name, while non-module RPMs go into the main collection (if any)
        for pkg in advisory.packages:
            if pkg.product_name != product_name:
                continue
            if pkg.repo_name != repo:
                continue
            if pkg.module_name:
                collection_short = f"{default_collection_short}__{pkg.module_name}"
                if collection_short not in collections:
                    collections[collection_short] = {
                        "packages": [],
                        "module_context": pkg.module_context,
                        "module_name": pkg.module_name,
                        "module_stream": pkg.module_stream,
                        "module_version": pkg.module_version,
                    }
                    no_default_collection = True
                collections[collection_short]["packages"].append(pkg)
            else:
                if no_default_collection:
                    continue
                if default_collection_short not in collections:
                    collections[default_collection_short] = {
                        "packages": [],
                    }
                collections[default_collection_short]["packages"].append(pkg)

        if no_default_collection and default_collection_short in collections:
            del collections[default_collection_short]

        collections_added = 0

        for collection_short, info in collections.items():
            # Create collection
            collection = ET.Element("collection")
            collection.set("short", collection_short)

            # Set short to name as well
            ET.SubElement(collection, "name").text = collection_short

            if "module_name" in info:
                module_element = ET.SubElement(collection, "module")
                module_element.set("name", info["module_name"])
                module_element.set("stream", info["module_stream"])
                module_element.set("version", info["module_version"])
                module_element.set("context", info["module_context"])
                module_element.set("arch", product_arch)

            added_pkg_count = 0
            for pkg in info["packages"]:
                if pkg.nevra.endswith(".src.rpm"):
                    continue

                name = pkg.package_name
                epoch = "0"
                if NEVRA_RE.match(pkg.nevra):
                    nevra = NEVRA_RE.search(pkg.nevra)
                    name = nevra.group(1)
                    epoch = nevra.group(2)
                    version = nevra.group(3)
                    release = nevra.group(4)
                    arch = nevra.group(5)
                elif NVRA_RE.match(pkg.nevra):
                    nvra = NVRA_RE.search(pkg.nevra)
                    name = nvra.group(1)
                    version = nvra.group(2)
                    release = nvra.group(3)
                    arch = nvra.group(4)
                else:
                    continue

                p_name = pkg.package_name
                if pkg.module_name:
                    p_name = f"{pkg.module_name}:{pkg.package_name}:{pkg.module_stream}"

                if p_name not in pkg_src_rpm:
                    continue
                if arch != product_arch and arch != "noarch":
                    if arch != "x86_64":
                        continue
                    if arch == "x86_64" and product_arch != "i686":
                        continue

                skip = False
                for suffix in suffixes_to_skip:
                    if name.endswith(suffix):
                        skip = True
                        break
                if skip:
                    continue

                package = ET.SubElement(collection, "package")
                package.set("name", name)
                package.set("arch", arch)
                package.set("epoch", epoch)
                package.set("version", version)
                package.set("release", release)
                package.set("src", pkg_src_rpm[p_name])

                # Add filename element
                ET.SubElement(package,
                              "filename").text = EPOCH_RE.sub("", pkg.nevra)

                # Add checksum
                ET.SubElement(
                    package, "sum", type=pkg.checksum_type
                ).text = pkg.checksum

                added_pkg_count += 1

            if added_pkg_count > 0:
                packages.append(collection)
                collections_added += 1

        if collections_added == 0:
            tree.remove(update)

    ET.indent(tree)
    xml_str = ET.tostring(
        tree,
        encoding="unicode",
        method="xml",
        short_empty_elements=True,
    )

    return Response(content=xml_str, media_type="application/xml")