10404516601

Committed 15 Aug 2024 01:24PM UTC coverage: 92.152% (+4.8%) from 87.316%

Build # 10404516601

Build Type

Pull #283

github

Committed by

web-flow

Commit Message

Merge d8aa904a5 into 2e5fa942c

Pull Request Pull Request #283: Fix warnings mentioned by SonarQube

Run Details

729 of 852 branches covered (85.56%)

Branch coverage included in aggregate %.

133 of 137 new or added lines in 15 files covered. (97.08%)

1 existing line in 1 file now uncovered.

3956 of 4232 relevant lines covered (93.48%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.62

/greenwave/product_versions.py

# SPDX-License-Identifier: GPL-2.0+
"""
Product version guessing for subject identifiers
"""

import logging
import re

from defusedxml.xmlrpc import xmlrpc_client
from werkzeug.exceptions import BadGateway, NotFound

from greenwave.resources import (
    retrieve_koji_build_target,
    retrieve_koji_build_task_id,
)

log = logging.getLogger(__name__)


def _product_version_number_or_none(toparse) -> int | None:
    # seperate the prefix from the number
    result = list(filter(None, "-".join(re.split(r"(\d+)", toparse)).split("-")))
    if len(result) >= 2:
        try:
            return int(result[1])
        except ValueError:
            pass

    return None


def _guess_product_versions(toparse, koji_build=False) -> list[str]:
    if toparse == "rawhide" or toparse.startswith("Fedora-Rawhide"):
        return ["fedora-rawhide"]

    product_version = None
    if toparse.startswith("f") and koji_build:
        product_version = "fedora-"
    elif toparse.startswith("epel"):
        product_version = "epel-"
    elif toparse.startswith("el") and len(toparse) > 2 and toparse[2].isdigit():
        product_version = "rhel-"
    elif toparse.startswith("rhel-") and len(toparse) > 5 and toparse[5].isdigit():
        product_version = "rhel-"
    elif toparse.startswith("fc") or toparse.startswith("Fedora"):
        product_version = "fedora-"

    if not product_version:
        log.warning("Failed to guess the product version for %s", toparse)
        return []

    number = _product_version_number_or_none(toparse)
    if number:
        return [f"{product_version}{number}"]

    log.warning("Failed to get the product version number for %s", toparse)
    return []


def _guess_koji_build_product_versions(
    subject, koji_base_url, koji_task_id=None
) -> list[str]:
    try:
        if not koji_task_id:
            try:
                koji_task_id = retrieve_koji_build_task_id(
                    subject.identifier, koji_base_url
                )
            except NotFound:
                koji_task_id = None

            if not koji_task_id:
                return []

        target = retrieve_koji_build_target(koji_task_id, koji_base_url)
        if target:
            pvs = subject.product_versions_from_koji_build_target(target)
            if pvs:
                return pvs
            return _guess_product_versions(target, koji_build=True)

        return []
    except (xmlrpc_client.ProtocolError, OSError) as err:
        raise ConnectionError(f"Could not reach Koji: {err}")
    except BadGateway:
        log.warning("Failed to get product version from Koji")
        return []


def subject_product_versions(
    subject, koji_base_url=None, koji_task_id=None
) -> list[str]:
    if subject.product_versions:
        return subject.product_versions

    if koji_base_url and subject.is_koji_build:
        pvs = _guess_koji_build_product_versions(subject, koji_base_url, koji_task_id)
        if pvs:
            return pvs

    if subject.short_product_version:
        return _guess_product_versions(
            subject.short_product_version, koji_build=subject.is_koji_build
        )

    return []

1	# SPDX-License-Identifier: GPL-2.0+
2	"""	1✔
3	Product version guessing for subject identifiers
4	"""
5
6	import logging	1✔
7	import re	1✔
8
9	from defusedxml.xmlrpc import xmlrpc_client	1✔
10	from werkzeug.exceptions import BadGateway, NotFound	1✔
11
12	from greenwave.resources import (	1✔
13	retrieve_koji_build_target,
14	retrieve_koji_build_task_id,
15	)
16
17	log = logging.getLogger(__name__)	1✔
18
19
20	def _product_version_number_or_none(toparse) -> int \| None:	1✔
21	# seperate the prefix from the number
22	result = list(filter(None, "-".join(re.split(r"(\d+)", toparse)).split("-")))	1✔
23	if len(result) >= 2:	1!
24	try:	1✔
25	return int(result[1])	1✔
NEW 26	except ValueError:	×
NEW 27	pass	×
28
NEW 29	return None	×
30
31
32	def _guess_product_versions(toparse, koji_build=False) -> list[str]:	1✔
33	if toparse == "rawhide" or toparse.startswith("Fedora-Rawhide"):	1✔
34	return ["fedora-rawhide"]	1✔
35
36	product_version = None	1✔
37	if toparse.startswith("f") and koji_build:	1✔
38	product_version = "fedora-"	1✔
39	elif toparse.startswith("epel"):	1✔
40	product_version = "epel-"	1✔
41	elif toparse.startswith("el") and len(toparse) > 2 and toparse[2].isdigit():	1✔
42	product_version = "rhel-"	1✔
43	elif toparse.startswith("rhel-") and len(toparse) > 5 and toparse[5].isdigit():	1!
44	product_version = "rhel-"	×
45	elif toparse.startswith("fc") or toparse.startswith("Fedora"):	1!
46	product_version = "fedora-"	×
47
48	if not product_version:	1✔
49	log.warning("Failed to guess the product version for %s", toparse)	1✔
50	return []	1✔
51
52	number = _product_version_number_or_none(toparse)	1✔
53	if number:	1!
54	return [f"{product_version}{number}"]	1✔
55
NEW 56	log.warning("Failed to get the product version number for %s", toparse)	×
UNCOV 57	return []	×
58
59
60	def _guess_koji_build_product_versions(	1✔
61	subject, koji_base_url, koji_task_id=None
62	) -> list[str]:
63	try:	1✔
64	if not koji_task_id:	1✔
65	try:	1✔
66	koji_task_id = retrieve_koji_build_task_id(	1✔
67	subject.identifier, koji_base_url
68	)
69	except NotFound:	1✔
70	koji_task_id = None	×
71
72	if not koji_task_id:	1✔
73	return []	1✔
74
75	target = retrieve_koji_build_target(koji_task_id, koji_base_url)	1✔
76	if target:	1✔
77	pvs = subject.product_versions_from_koji_build_target(target)	1✔
78	if pvs:	1✔
79	return pvs	1✔
80	return _guess_product_versions(target, koji_build=True)	1✔
81
82	return []	1✔
83	except (xmlrpc_client.ProtocolError, OSError) as err:	1!
84	raise ConnectionError(f"Could not reach Koji: {err}")	1✔
85	except BadGateway:	×
86	log.warning("Failed to get product version from Koji")	×
87	return []	×
88
89
90	def subject_product_versions(	1✔
91	subject, koji_base_url=None, koji_task_id=None
92	) -> list[str]:
93	if subject.product_versions:	1✔
94	return subject.product_versions	1✔
95
96	if koji_base_url and subject.is_koji_build:	1✔
97	pvs = _guess_koji_build_product_versions(subject, koji_base_url, koji_task_id)	1✔
98	if pvs:	1✔
99	return pvs	1✔
100
101	if subject.short_product_version:	1✔
102	return _guess_product_versions(	1✔
103	subject.short_product_version, koji_build=subject.is_koji_build
104	)
105
106	return []	1✔

release-engineering / greenwave / 10404516601

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous