Merge branch 'build/checkmk-24-support' of github.com:Checkmk/ansible-collection-checkmk.general into build/checkmk-24-support

Author: robin-checkmk

plugins/module_utils/api.py

@@ -26,8 +26,9 @@
 class CheckmkAPI:
     """Base class to contact a Checkmk server"""
 
-    def __init__(self, module):
+    def __init__(self, module, logger=None):
         self.module = module
+        self.logger = logger
         self.params = self.module.params
         server = self.params.get("server_url")
         site = self.params.get("site")
@@ -47,6 +48,18 @@ def __init__(self, module):
     def _fetch(
         self, code_mapping="", endpoint="", data=None, method="GET", logger=None
     ):
+        if not logger:
+            logger = self.logger
+
+        if logger:
+            logger.debug(
+                "_fetch(): endpoint: %s, data: %s, method: %s"
+                % (
+                    endpoint,
+                    str(data),
+                    method,
+                )
+            )
         http_mapping = GENERIC_HTTP_CODES.copy()
         http_mapping.update(code_mapping)
 
@@ -100,6 +113,8 @@ def _fetch(
                 logger=logger,
             )
             # self.module.fail_json(**result_as_dict(result))
+        if logger:
+            logger.debug("_fetch(): result: %s" % str(result))
         return result
 
     def getversion(self):

plugins/module_utils/discovery.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8; py-indent-offset: 4 -*-
+
+# Copyright: (c) 2022, Michael Sekania &
+#                      Robin Gierse <[email protected]>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+from ansible_collections.checkmk.general.plugins.module_utils.version import (
+    CheckmkVersion,
+)
+
+# from .version import CheckmkVersion
+
+HTTP_CODES = {
+    # http_code: (changed, failed, "Message")
+    200: (True, False, "Discovery successful."),
+    302: (
+        True,
+        False,
+        (
+            "The service discovery background job has been initialized. "
+            "Redirecting to the 'Wait for service discovery completion' endpoint."
+        ),
+    ),
+    404: (False, True, "Not Found: Host could not be found."),
+    409: (False, False, "Conflict: A discovery background job is already running"),
+}
+
+HTTP_CODES_SC = {
+    # http_code: (changed, failed, "Message")
+    200: (True, False, "The service discovery has been completed."),
+    302: (
+        True,
+        False,
+        (
+            "The service discovery is still running. "
+            "Redirecting to the 'Wait for completion' endpoint."
+        ),
+    ),
+    404: (False, False, "Not Found: There is no running service discovery"),
+}
+
+HTTP_CODES_BULK = {
+    # http_code: (changed, failed, "Message")
+    200: (True, False, "Discovery successful."),
+    409: (False, False, "Conflict: A bulk discovery job is already active"),
+}
+
+HTTP_CODES_BULK_SC = {
+    # http_code: (changed, failed, "Message")
+    200: (True, False, "The service discovery has been completed."),
+    404: (False, False, "Not Found: There is no running bulk_discovery job"),
+}
+
+SUPPORTED_VERSIONS = {
+    "min": "2.1.0",
+    "max": "2.5.0",
+}
+
+
+class Discovery:
+    def __init__(self, module, logger):
+        self.module = module
+        self.logger = logger
+        self.timeout = module.params.get("wait_timeout", -1)
+        self.wait_for_previous = module.params.get("wait_for_previous", True)
+        self.wait_for_completion = module.params.get("wait_for_completion", True)
+        self.single_mode = self._single_mode()
+        self.bulk_mode = not self.single_mode
+        self.supported_versions = SUPPORTED_VERSIONS
+
+    def _single_mode(self):
+        return not (
+            "hosts" in self.module.params
+            and self.module.params.get("hosts")
+            and len(self.module.params.get("hosts", [])) > 0
+        )
+
+    def _min_version(self):
+        return CheckmkVersion(self.supported_versions["min"])
+
+    def _max_version(self):
+        return CheckmkVersion(self.supported_versions["max"])
+
+    def compatible(self, version):
+        return self._min_version() <= version <= self._max_version()
+
+    def start_discovery(self):
+        raise NotImplementedError

plugins/module_utils/discovery_210.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8; py-indent-offset: 4 -*-
+
+# Copyright: (c) 2022 - 2025,
+#   Michael Sekania &
+#   Robin Gierse <[email protected]> &
+#   Max Sickora <[email protected]> &
+#   Lars Getwan <[email protected]>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+import json
+import time
+
+from ansible_collections.checkmk.general.plugins.module_utils.api import CheckmkAPI
+from ansible_collections.checkmk.general.plugins.module_utils.discovery import (
+    HTTP_CODES,
+    HTTP_CODES_BULK,
+    HTTP_CODES_BULK_SC,
+    HTTP_CODES_SC,
+    Discovery,
+)
+from ansible_collections.checkmk.general.plugins.module_utils.types import (
+    generate_result,
+)
+
+COMPATIBLE_MODES = [
+    "new",
+    "remove",
+    "fix_all",
+    "refresh",
+    "only_host_labels",
+]
+
+SUPPORTED_VERSIONS = {
+    "min": "2.1.0",
+    "max": "2.1.0p99",
+}
+
+
+class ServiceDiscoveryAPI(CheckmkAPI):
+    def post(self):
+        mode = self.params.get("state")
+        if mode not in COMPATIBLE_MODES:
+            return generate_result(
+                msg="State %s is not supported with this Checkmk version." % mode
+            )
+
+        data = {
+            "host_name": self.params.get("host_name"),
+            "mode": mode,
+        }
+
+        return self._fetch(
+            code_mapping=HTTP_CODES,
+            endpoint="domain-types/service_discovery_run/actions/start/invoke",
+            data=data,
+            method="POST",
+            logger=self.logger,
+        )
+
+
+class ServiceBulkDiscoveryAPI(CheckmkAPI):
+    def post(self):
+        mode = self.params.get("state")
+        if mode not in COMPATIBLE_MODES:
+            return generate_result(
+                msg="State %s is not supported with this Checkmk version." % mode
+            )
+
+        data = {
+            "hostnames": self.params.get("hosts", []),
+            "mode": self.params.get("state"),
+            "do_full_scan": self.params.get("do_full_scan", True),
+            "bulk_size": self.params.get("bulk_size", 1),
+            "ignore_errors": self.params.get("ignore_errors", True),
+        }
+
+        return self._fetch(
+            code_mapping=HTTP_CODES_BULK,
+            endpoint="domain-types/discovery_run/actions/bulk-discovery-start/invoke",
+            data=data,
+            method="POST",
+        )
+
+
+class ServiceCompletionAPI(CheckmkAPI):
+    def get(self):
+        data = {}
+
+        return self._fetch(
+            code_mapping=HTTP_CODES_SC,
+            endpoint=("objects/service_discovery_run/" + self.params.get("host_name")),
+            data=data,
+            method="GET",
+        )
+
+
+class ServiceCompletionBulkAPI(CheckmkAPI):
+    def get(self):
+        data = {}
+
+        return self._fetch(
+            code_mapping=HTTP_CODES_BULK_SC,
+            endpoint=("objects/discovery_run/bulk_discovery"),
+            data=data,
+            method="GET",
+        )
+
+
+class Discovery210(Discovery):
+    def __init__(self, module, logger):
+        super().__init__(module, logger)
+
+        self.discovery_single = ServiceDiscoveryAPI(self.module, self.logger)
+        self.discovery_bulk = ServiceBulkDiscoveryAPI(self.module, self.logger)
+        self.completion_single = ServiceCompletionAPI(self.module, self.logger)
+        self.completion_bulk = ServiceCompletionBulkAPI(self.module, self.logger)
+
+        self.discovery_api = self._discovery_api()
+        self.service_completion_api = self._service_completion_api()
+
+        self.supported_versions = SUPPORTED_VERSIONS
+
+    def _discovery_api(self):
+        if self.single_mode:
+            return self.discovery_single
+
+        return self.discovery_bulk
+
+    def _service_completion_api(self):
+        if self.single_mode:
+            return self.completion_single
+
+        return self.completion_bulk
+
+    def _wait_for_completion(self, what):
+        now = time.time()
+        if self.timeout > 0:
+            deadline = now + self.timeout
+        else:
+            deadline = 0  # In case of infinite timeout
+
+        while True:
+            now = time.time()
+            if self.timeout > 0 and now > deadline:
+                return generate_result(
+                    msg="Timeout reached while waiting for %s discovery" % what
+                )
+
+            result = self.service_completion_api.get()
+
+            # The completion api shows the state of the job
+            if not json.loads(result.content).get("extensions").get("active"):
+                break
+
+            time.sleep(3)
+
+        return result
+
+    def start_discovery(self):
+        if self.wait_for_previous:
+            result = self._wait_for_completion("previous")
+            if result.failed:
+                return result
+
+        result = self.discovery_api.post()
+        if result.failed:
+            return result
+
+        if self.wait_for_completion:
+            result = self._wait_for_completion("current")
+
+        return result