qontract-reconcile 0.10.2.dev216__py3-none-any.whl → 0.10.2.dev217__py3-none-any.whl

reconcile/gitlab_housekeeping.py

@@ -243,7 +243,7 @@ def close_item(
     enable_closing: bool,
     item_type: str,
     item: ProjectIssue | ProjectMergeRequest,
-):
+) -> None:
     if enable_closing:
         logging.info([
             "close_item",
@@ -263,32 +263,31 @@ def close_item(
 
 
 def handle_stale_items(
-    dry_run,
-    gl,
-    days_interval,
-    enable_closing,
-    items,
-    item_type,
-):
+    dry_run: bool,
+    gl: GitLabApi,
+    days_interval: int,
+    enable_closing: bool,
+    items: Iterable[ProjectIssue | ProjectMergeRequest],
+    item_type: str,
+) -> None:
     LABEL = "stale"
 
     now = datetime.utcnow()
     for item in items:
-        item_iid = item.attributes.get("iid")
         if AUTO_MERGE in item.labels:
             if item.merge_status == MRStatus.UNCHECKED:
                 # this call triggers a status recheck
-                item = gl.get_merge_request(item_iid)
+                item = gl.get_merge_request(item.iid)
             if item.merge_status == MRStatus.CANNOT_BE_MERGED:
                 close_item(dry_run, gl, enable_closing, item_type, item)
-        update_date = datetime.strptime(item.attributes.get("updated_at"), DATE_FORMAT)
+        update_date = datetime.strptime(item.updated_at, DATE_FORMAT)
 
         # if item is over days_interval
         current_interval = now.date() - update_date.date()
         if current_interval > timedelta(days=days_interval):
             # if item does not have 'stale' label - add it
             if LABEL not in item.labels:
-                logging.info(["add_label", gl.project.name, item_type, item_iid, LABEL])
+                logging.info(["add_label", gl.project.name, item_type, item.iid, LABEL])
                 if not dry_run:
                     gl.add_label_with_note(item, LABEL)
             # if item has 'stale' label - close it
@@ -310,8 +309,7 @@ def handle_stale_items(
                 continue
 
             cancel_notes_dates = [
-                datetime.strptime(note.attributes.get("updated_at"), DATE_FORMAT)
-                for note in cancel_notes
+                datetime.strptime(item.updated_at, DATE_FORMAT) for note in cancel_notes
             ]
             latest_cancel_note_date = max(d for d in cancel_notes_dates)
             # if the latest cancel note is under
@@ -322,20 +320,20 @@ def handle_stale_items(
                     "remove_label",
                     gl.project.name,
                     item_type,
-                    item_iid,
+                    item.iid,
                     LABEL,
                 ])
                 if not dry_run:
                     gl.remove_label(item, LABEL)
 
 
-def is_good_to_merge(labels):
+def is_good_to_merge(labels: Iterable[str]) -> bool:
     return any(m in MERGE_LABELS_PRIORITY for m in labels) and not any(
         b in HOLD_LABELS for b in labels
     )
 
 
-def is_rebased(mr, gl: GitLabApi) -> bool:
+def is_rebased(mr: ProjectMergeRequest, gl: GitLabApi) -> bool:
     target_branch = mr.target_branch
     head = cast(
         list[ProjectCommit],
@@ -471,14 +469,14 @@ def preprocess_merge_requests(
 
 
 def rebase_merge_requests(
-    dry_run,
-    gl,
-    rebase_limit,
-    pipeline_timeout=None,
-    wait_for_pipeline=False,
-    users_allowed_to_label=None,
-    state=None,
-):
+    dry_run: bool,
+    gl: GitLabApi,
+    rebase_limit: int,
+    state: State,
+    pipeline_timeout: int | None = None,
+    wait_for_pipeline: bool = False,
+    users_allowed_to_label: Iterable[str] | None = None,
+) -> None:
     rebases = 0
     merge_requests = [
         item["mr"]
@@ -542,20 +540,20 @@ def rebase_merge_requests(
 
 @retry(max_attempts=10, hook=_log_exception)
 def merge_merge_requests(
-    dry_run,
+    dry_run: bool,
     gl: GitLabApi,
     project_merge_requests: list[ProjectMergeRequest],
     reload_toggle: ReloadToggle,
-    merge_limit,
-    rebase,
+    merge_limit: int,
+    rebase: bool,
     app_sre_usernames: Set[str],
-    pipeline_timeout=None,
-    insist=False,
-    wait_for_pipeline=False,
-    users_allowed_to_label=None,
-    must_pass=None,
-    state=None,
-):
+    state: State,
+    pipeline_timeout: int | None = None,
+    insist: bool = False,
+    wait_for_pipeline: bool = False,
+    users_allowed_to_label: Iterable[str] | None = None,
+    must_pass: Iterable[str] | None = None,
+) -> None:
     merges = 0
     if reload_toggle.reload:
         project_merge_requests = gl.get_merge_requests(state=MRState.OPENED)
@@ -654,7 +652,7 @@ def publish_access_token_expiration_metrics(gl: GitLabApi) -> None:
                 gitlab_token_expiration.remove(pat.name)
 
 
-def run(dry_run, wait_for_pipeline):
+def run(dry_run: bool, wait_for_pipeline: bool) -> None:
     default_days_interval = 15
     default_limit = 8
     default_enable_closing = False
@@ -711,45 +709,46 @@ def run(dry_run, wait_for_pipeline):
             must_pass = hk.get("must_pass")
             try:
                 merge_merge_requests(
-                    dry_run,
-                    gl,
-                    project_merge_requests,
-                    reload_toggle,
-                    limit,
-                    rebase,
-                    app_sre_usernames,
-                    pipeline_timeout,
+                    dry_run=dry_run,
+                    gl=gl,
+                    project_merge_requests=project_merge_requests,
+                    reload_toggle=reload_toggle,
+                    merge_limit=limit,
+                    rebase=rebase,
+                    app_sre_usernames=app_sre_usernames,
+                    state=state,
+                    pipeline_timeout=pipeline_timeout,
                     insist=True,
                     wait_for_pipeline=wait_for_pipeline,
                     users_allowed_to_label=users_allowed_to_label,
                     must_pass=must_pass,
-                    state=state,
                 )
             except Exception:
                 logging.error(
                     "All retries failed, trying to rerun merge_merge_requests() again."
                 )
                 merge_merge_requests(
-                    dry_run,
-                    gl,
-                    project_merge_requests,
-                    reload_toggle,
-                    limit,
-                    rebase,
-                    app_sre_usernames,
-                    pipeline_timeout,
+                    dry_run=dry_run,
+                    gl=gl,
+                    project_merge_requests=project_merge_requests,
+                    reload_toggle=reload_toggle,
+                    merge_limit=limit,
+                    rebase=rebase,
+                    app_sre_usernames=app_sre_usernames,
+                    state=state,
+                    pipeline_timeout=pipeline_timeout,
+                    insist=False,
                     wait_for_pipeline=wait_for_pipeline,
                     users_allowed_to_label=users_allowed_to_label,
                     must_pass=must_pass,
-                    state=state,
                 )
             if rebase:
                 rebase_merge_requests(
-                    dry_run,
-                    gl,
-                    limit,
+                    dry_run=dry_run,
+                    gl=gl,
+                    rebase_limit=limit,
+                    state=state,
                     pipeline_timeout=pipeline_timeout,
                     wait_for_pipeline=wait_for_pipeline,
                     users_allowed_to_label=users_allowed_to_label,
-                    state=state,
                 )

reconcile/gitlab_permissions.py

@@ -1,10 +1,12 @@
 import itertools
 import logging
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from typing import Any, cast
 
 from gitlab.exceptions import GitlabGetError
 from gitlab.v4.objects import (
+    GroupMember,
     Project,
     SharedProject,
 )
@@ -159,7 +161,9 @@ class GroupPermissionHandler:
             raise ExceptionGroup("Reconcile errors occurred", errors)
 
 
-def get_members_to_add(repo, gl, app_sre):
+def get_members_to_add(
+    repo: str, gl: GitLabApi, app_sre: list[GroupMember]
+) -> list[dict[str, Any]]:
     maintainers = get_all_app_sre_maintainers(repo, gl, app_sre)
     if maintainers is None:
         return []
@@ -172,7 +176,9 @@ def get_members_to_add(repo, gl, app_sre):
     return members_to_add
 
 
-def get_all_app_sre_maintainers(repo, gl, app_sre):
+def get_all_app_sre_maintainers(
+    repo: str, gl: GitLabApi, app_sre: list[GroupMember]
+) -> list[str]:
     app_sre_user_ids = [user.id for user in app_sre]
     chunks = batches.batched(app_sre_user_ids, PAGE_SIZE)
     app_sre_maintainers = (
@@ -182,12 +188,14 @@ def get_all_app_sre_maintainers(repo, gl, app_sre):
     return list(itertools.chain.from_iterable(app_sre_maintainers))
 
 
-def create_user_ids_query(ids):
+def create_user_ids_query(ids: Iterable[str]) -> dict[str, str]:
     return {"user_ids": ",".join(str(id) for id in ids)}
 
 
 @defer
-def run(dry_run, thread_pool_size=10, defer=None):
+def run(
+    dry_run: bool, thread_pool_size: int = 10, defer: Callable | None = None
+) -> None:
     instance = queries.get_gitlab_instance()
     settings = queries.get_app_interface_settings()
     gl = GitLabApi(instance, settings=settings)
@@ -221,7 +229,7 @@ def share_project_with_group_members(
             gl.add_project_member(m["repo"], m["user"])
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     instance = queries.get_gitlab_instance()
     return {
         "instance": instance,

reconcile/gitlab_projects.py

@@ -1,5 +1,6 @@
 import logging
 import sys
+from collections.abc import Callable
 from typing import Any
 
 from reconcile import queries
@@ -10,14 +11,15 @@ QONTRACT_INTEGRATION = "gitlab-projects"
 
 
 @defer
-def run(dry_run, defer=None):
+def run(dry_run: bool, defer: Callable | None = None) -> None:
     instance = queries.get_gitlab_instance()
     settings = queries.get_app_interface_settings()
     code_components = queries.get_code_components()
     app_int_repos = [c["url"] for c in code_components]
     saas_bundle_repos = [c["url"] for c in code_components if c["resource"] == "bundle"]
     gl = GitLabApi(instance, settings=settings)
-    defer(gl.cleanup)
+    if defer:
+        defer(gl.cleanup)
 
     project_requests = instance["projectRequests"] or []
     error = False
@@ -45,7 +47,7 @@ def run(dry_run, defer=None):
     sys.exit(error)
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     instance = queries.get_gitlab_instance()
     return {
         "instance": instance,

reconcile/integrations_manager.py

@@ -2,6 +2,7 @@ import logging
 import os
 import sys
 from collections.abc import (
+    Callable,
     Iterable,
     Mapping,
     Sequence,
@@ -119,7 +120,7 @@ def _build_helm_integration_spec(
     integration_name: str,
     managed: IntegrationManagedV1,
     shard_manager: IntegrationShardManager,
-):
+) -> HelmIntegrationSpec:
     integration_spec = managed.spec.dict(by_alias=True)
     shard_specs = shard_manager.build_integration_shards(integration_name, managed)
     his = HelmIntegrationSpec(
@@ -151,7 +152,7 @@ class IntegrationsEnvironment(BaseModel):
 
 def collect_integrations_environment(
     integrations: Iterable[IntegrationV1],
-    environment_name: str,
+    environment_name: str | None,
     shard_manager: IntegrationShardManager,
 ) -> list[IntegrationsEnvironment]:
     int_envs: dict[str, IntegrationsEnvironment] = {}
@@ -210,7 +211,7 @@ def fetch_desired_state(
     upstream: str,
     image: str,
     image_tag_from_ref: Mapping[str, str] | None,
-):
+) -> None:
     for ie in integrations_environments:
         oc_resources = construct_oc_resources(ie, upstream, image, image_tag_from_ref)
         for r in oc_resources:
@@ -230,17 +231,17 @@ def filter_integrations(
 
 @defer
 def run(
-    dry_run,
-    environment_name,
+    dry_run: bool,
+    environment_name: str | None,
     integration_runtime_meta: dict[str, IntegrationMeta],
-    thread_pool_size=10,
-    internal=None,
-    use_jump_host=True,
-    image_tag_from_ref=None,
-    upstream=None,
-    image=None,
-    defer=None,
-):
+    thread_pool_size: int = 10,
+    internal: bool = False,
+    use_jump_host: bool = True,
+    image_tag_from_ref: dict[str, str] | None = None,
+    upstream: str | None = None,
+    image: str | None = None,
+    defer: Callable | None = None,
+) -> None:
     # Beware, environment_name can be empty! It's optional to set it!
     # If not set, all environments should be considered.
 
@@ -269,41 +270,31 @@ def run(
         logging.debug("Nothing to do, exiting.")
         sys.exit(ExitCodes.SUCCESS)
 
-    fetch_args = {
-        "namespaces": [
+    ri, oc_map = ob.fetch_current_state(
+        namespaces=[
             ie.namespace.dict(by_alias=True) for ie in integration_environments
         ],
-        "thread_pool_size": thread_pool_size,
-        "integration": QONTRACT_INTEGRATION,
-        "integration_version": QONTRACT_INTEGRATION_VERSION,
-        "override_managed_types": ["Deployment", "StatefulSet", "CronJob", "Service"],
-        "internal": internal,
-        "use_jump_host": use_jump_host,
-    }
-
-    if not image:
-        image = IMAGE_DEFAULT
-
-    if upstream:
-        use_upstream = True
-        fetch_args["caller"] = upstream
-    else:
-        # Not set to fetch_args on purpose, fallback for cases where caller is not yet set
-        use_upstream = False
-        upstream = UPSTREAM_DEFAULT
-
-    ri, oc_map = ob.fetch_current_state(**fetch_args)
-    defer(oc_map.cleanup)
+        thread_pool_size=thread_pool_size,
+        integration=QONTRACT_INTEGRATION,
+        integration_version=QONTRACT_INTEGRATION_VERSION,
+        override_managed_types=["Deployment", "StatefulSet", "CronJob", "Service"],
+        internal=internal,
+        use_jump_host=use_jump_host,
+        caller=upstream,
+    )
+    if defer:
+        defer(oc_map.cleanup)
 
     fetch_desired_state(
-        integration_environments, ri, upstream, image, image_tag_from_ref
+        integration_environments,
+        ri,
+        upstream or UPSTREAM_DEFAULT,
+        image or IMAGE_DEFAULT,
+        image_tag_from_ref,
     )
 
     ob.publish_metrics(ri, QONTRACT_INTEGRATION)
-    if use_upstream:
-        ob.realize_data(dry_run, oc_map, ri, thread_pool_size, caller=upstream)
-    else:
-        ob.realize_data(dry_run, oc_map, ri, thread_pool_size)
+    ob.realize_data(dry_run, oc_map, ri, thread_pool_size, caller=upstream)
 
     if ri.has_error_registered():
         sys.exit(ExitCodes.ERROR)

reconcile/jenkins_job_builder.py

@@ -46,7 +46,7 @@ def init_jjb(
     return JJB(configs, secret_reader=secret_reader, print_only=print_only)
 
 
-def validate_repos_and_admins(jjb: JJB):
+def validate_repos_and_admins(jjb: JJB) -> None:
     jjb_repos = jjb.get_repos()
     app_int_repos = queries.get_repos()
     missing_repos = [r for r in jjb_repos if r not in app_int_repos]

reconcile/jenkins_job_builds_cleaner.py

@@ -2,6 +2,7 @@ import logging
 import operator
 import re
 import time
+from typing import Any
 
 from reconcile import queries
 from reconcile.utils.jenkins_api import JenkinsApi
@@ -10,11 +11,13 @@ from reconcile.utils.secret_reader import SecretReader
 QONTRACT_INTEGRATION = "jenkins-job-builds-cleaner"
 
 
-def hours_to_ms(hours):
+def hours_to_ms(hours: int) -> int:
     return hours * 60 * 60 * 1000
 
 
-def delete_builds(jenkins, builds_todel, dry_run=True):
+def delete_builds(
+    jenkins: JenkinsApi, builds_todel: list[dict[str, Any]], dry_run: bool = True
+) -> None:
     delete_builds_count = len(builds_todel)
     for idx, build in enumerate(builds_todel, start=1):
         job_name = build["job_name"]
@@ -35,7 +38,7 @@ def delete_builds(jenkins, builds_todel, dry_run=True):
                 logging.exception(msg)
 
 
-def get_last_build_ids(builds):
+def get_last_build_ids(builds: list[dict[str, Any]]) -> list[str]:
     builds_to_keep = []
     sorted_builds = sorted(builds, key=operator.itemgetter("timestamp"), reverse=True)
     if sorted_builds:
@@ -49,7 +52,9 @@ def get_last_build_ids(builds):
     return builds_to_keep
 
 
-def find_builds(jenkins, job_names, rules):
+def find_builds(
+    jenkins: JenkinsApi, job_names: list[str], rules: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
     # Current time in ms
     time_ms = time.time() * 1000
 
@@ -78,7 +83,7 @@ def find_builds(jenkins, job_names, rules):
     return builds_found
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     jenkins_instances = queries.get_jenkins_instances()
     secret_reader = SecretReader(queries.get_secret_reader_settings())
 

reconcile/jenkins_job_cleaner.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Iterable
 
 from reconcile import queries
 from reconcile.jenkins_job_builder import init_jjb
@@ -8,7 +9,9 @@ from reconcile.utils.secret_reader import SecretReader
 QONTRACT_INTEGRATION = "jenkins-job-cleaner"
 
 
-def get_managed_job_names(job_names, managed_projects):
+def get_managed_job_names(
+    job_names: Iterable[str], managed_projects: Iterable[str]
+) -> list[str]:
     managed_jobs = set()
     for job_name in job_names:
         for managed_project in managed_projects:
@@ -18,13 +21,13 @@ def get_managed_job_names(job_names, managed_projects):
     return list(managed_jobs)
 
 
-def get_desired_job_names(instance_name: str, secret_reader: SecretReader):
+def get_desired_job_names(instance_name: str, secret_reader: SecretReader) -> list[str]:
     jjb = init_jjb(secret_reader)
     desired_jobs = jjb.get_all_jobs(instance_name=instance_name)[instance_name]
     return [j["name"] for j in desired_jobs]
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     jenkins_instances = queries.get_jenkins_instances()
     secret_reader = SecretReader(queries.get_secret_reader_settings())
 

reconcile/jenkins_roles.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Iterable, Mapping
 
 from reconcile import queries
 from reconcile.utils import (
@@ -76,8 +77,8 @@ def get_jenkins_map() -> dict[str, JenkinsApi]:
     return jenkins_map
 
 
-def get_current_state(jenkins_map):
-    current_state = []
+def get_current_state(jenkins_map: Mapping[str, JenkinsApi]) -> list[dict[str, str]]:
+    current_state: list[dict[str, str]] = []
 
     for instance, jenkins in jenkins_map.items():
         roles = jenkins.get_all_roles()
@@ -97,11 +98,11 @@ def get_current_state(jenkins_map):
     return current_state
 
 
-def get_desired_state():
+def get_desired_state() -> list[dict[str, str]]:
     gqlapi = gql.get_api()
     roles: list[dict] = expiration.filter(gqlapi.query(ROLES_QUERY)["roles"])
 
-    desired_state = []
+    desired_state: list[dict[str, str]] = []
     for r in roles:
         for p in r["permissions"]:
             if p["service"] != "jenkins-role":
@@ -128,7 +129,9 @@ def get_desired_state():
     return desired_state
 
 
-def calculate_diff(current_state, desired_state):
+def calculate_diff(
+    current_state: Iterable[dict[str, str]], desired_state: Iterable[dict[str, str]]
+) -> list[dict[str, str]]:
     diff = []
     users_to_assign = subtract_states(
         desired_state, current_state, "assign_role_to_user"
@@ -142,7 +145,11 @@ def calculate_diff(current_state, desired_state):
     return diff
 
 
-def subtract_states(from_state, subtract_state, action):
+def subtract_states(
+    from_state: Iterable[dict[str, str]],
+    subtract_state: Iterable[dict[str, str]],
+    action: str,
+) -> list[dict[str, str]]:
     result = []
 
     for f_user in from_state:
@@ -163,7 +170,7 @@ def subtract_states(from_state, subtract_state, action):
     return result
 
 
-def act(diff, jenkins_map):
+def act(diff: dict[str, str], jenkins_map: Mapping[str, JenkinsApi]) -> None:
     instance = diff["instance"]
     role = diff["role"]
     user = diff["user"]
@@ -177,7 +184,7 @@ def act(diff, jenkins_map):
         raise Exception(f"invalid action: {action}")
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     jenkins_map = get_jenkins_map()
     current_state = get_current_state(jenkins_map)
     desired_state = get_desired_state()

reconcile/jenkins_webhooks.py

@@ -1,5 +1,6 @@
 import copy
 import logging
+from collections.abc import Callable, MutableMapping
 from typing import Any
 
 from reconcile import queries
@@ -17,7 +18,9 @@ def get_gitlab_api(secret_reader: SecretReader) -> GitLabApi:
     return GitLabApi(instance, secret_reader=secret_reader)
 
 
-def get_hooks_to_add(desired_state, gl):
+def get_hooks_to_add(
+    desired_state: MutableMapping, gl: GitLabApi
+) -> MutableMapping[str, list[dict[str, Any]]]:
     diff = copy.deepcopy(desired_state)
     for project_url, desired_hooks in diff.items():
         try:
@@ -45,7 +48,7 @@ def get_hooks_to_add(desired_state, gl):
 
 
 @defer
-def run(dry_run, defer=None):
+def run(dry_run: bool, defer: Callable | None = None) -> None:
     secret_reader = SecretReader(queries.get_secret_reader_settings())
     jjb: JJB = init_jjb(secret_reader)
     gl = get_gitlab_api(secret_reader)
@@ -63,7 +66,7 @@ def run(dry_run, defer=None):
                 gl.create_project_hook(project_url, h)
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     return {
         "jenkins_configs": queries.get_jenkins_configs(),
     }

reconcile/jenkins_webhooks_cleaner.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Callable
 from typing import Any
 
 from reconcile import queries
@@ -9,7 +10,7 @@ QONTRACT_INTEGRATION = "jenkins-webhooks-cleaner"
 
 
 @defer
-def run(dry_run, defer=None):
+def run(dry_run: bool, defer: Callable | None = None) -> None:
     instance = queries.get_gitlab_instance()
     settings = queries.get_app_interface_settings()
     gl = GitLabApi(instance, settings=settings)
@@ -40,7 +41,7 @@ def run(dry_run, defer=None):
             logging.warning("no access to project: " + repo)
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     return {
         "previous_urls": queries.get_jenkins_instances_previous_urls(),
     }