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

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(),
     }

reconcile/jira_watcher.py

@@ -1,4 +1,6 @@
 import logging
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any
 
 from reconcile import queries
 from reconcile.slack_base import slackapi_from_slack_workspace
@@ -6,6 +8,7 @@ from reconcile.utils.defer import defer
 from reconcile.utils.jira_client import JiraClient
 from reconcile.utils.secret_reader import SecretReader
 from reconcile.utils.sharding import is_in_shard_round_robin
+from reconcile.utils.slack_api import SlackApi
 from reconcile.utils.state import (
     State,
     init_state,
@@ -14,7 +17,9 @@ from reconcile.utils.state import (
 QONTRACT_INTEGRATION = "jira-watcher"
 
 
-def fetch_current_state(jira_board, settings):
+def fetch_current_state(
+    jira_board: Mapping, settings: Mapping
+) -> tuple[JiraClient, dict[str, dict[str, str]]]:
     jira = JiraClient(jira_board, settings=settings)
     issues = jira.get_issues(fields=["key", "status", "summary"])
     return jira, {
@@ -23,11 +28,18 @@ def fetch_current_state(jira_board, settings):
     }
 
 
-def fetch_previous_state(state, project):
+def fetch_previous_state(state: State, project: str) -> dict:
     return state.get(project, {})
 
 
-def format_message(server, key, data, event, previous_state=None, current_state=None):
+def format_message(
+    server: str,
+    key: str,
+    data: Mapping,
+    event: str,
+    previous_state: Mapping | None = None,
+    current_state: Mapping | None = None,
+) -> str:
     summary = data["summary"]
     info = (
         ": {} -> {}".format(previous_state["status"], current_state["status"])
@@ -38,7 +50,9 @@ def format_message(server, key, data, event, previous_state=None, current_state=
     return f"{url} ({summary}) {event}{info}"
 
 
-def calculate_diff(server, current_state, previous_state):
+def calculate_diff(
+    server: str, current_state: Mapping, previous_state: Mapping
+) -> list[str]:
     messages = []
     new_issues = [
         format_message(server, key, data, "created")
@@ -64,7 +78,7 @@ def calculate_diff(server, current_state, previous_state):
     return messages
 
 
-def init_slack(jira_board):
+def init_slack(jira_board: Mapping[str, Any]) -> SlackApi:
     secret_reader = SecretReader(queries.get_secret_reader_settings())
     slack_info = jira_board["slack"]
 
@@ -77,7 +91,7 @@ def init_slack(jira_board):
     )
 
 
-def act(dry_run, jira_board, diffs):
+def act(dry_run: bool, jira_board: Mapping[str, str], diffs: Sequence[str]) -> None:
     if not dry_run and diffs:
         slack = init_slack(jira_board)
 
@@ -87,16 +101,17 @@ def act(dry_run, jira_board, diffs):
             slack.chat_post_message(diff)
 
 
-def write_state(state: State, project, state_to_write):
+def write_state(state: State, project: str, state_to_write: Mapping) -> None:
     state.add(project, value=state_to_write, force=True)
 
 
 @defer
-def run(dry_run, defer):
+def run(dry_run: bool, defer: Callable | None = None) -> None:
     jira_boards = [j for j in queries.get_jira_boards() if j.get("slack")]
     settings = queries.get_app_interface_settings()
     state = init_state(integration=QONTRACT_INTEGRATION)
-    defer(state.cleanup)
+    if defer:
+        defer(state.cleanup)
     for index, jira_board in enumerate(jira_boards):
         if not is_in_shard_round_robin(jira_board["name"], index):
             continue
@@ -109,6 +124,7 @@ def run(dry_run, defer):
             continue
         previous_state = fetch_previous_state(state, jira.project)
         if previous_state:
+            assert jira.server
             diffs = calculate_diff(jira.server, current_state, previous_state)
             act(dry_run, jira_board, diffs)
         if not dry_run:

reconcile/utils/jira_client.py

@@ -176,7 +176,7 @@ class JiraClient:
             server=server_url,
         )
 
-    def get_issues(self, fields: Mapping | None = None) -> list[Issue]:
+    def get_issues(self, fields: Iterable | None = None) -> list[Issue]:
         block_size = 100
         block_num = 0