From 7bb53c64da2dcf88894bfd31503accdd81498f3d Mon Sep 17 00:00:00 2001
From: Thomas Duval <thomas.duval@orange.com>
Date: Wed, 3 Jun 2020 10:06:52 +0200
Subject: Update to new version 5.4

Signed-off-by: Thomas Duval <thomas.duval@orange.com>
Change-Id: Idcd868133d75928a1ffd74d749ce98503e0555ea
---
 .../moon_utilities/invalided_functions.py          | 440 +++++++++++++++++++++
 1 file changed, 440 insertions(+)
 create mode 100644 moon_utilities/moon_utilities/invalided_functions.py

(limited to 'moon_utilities/moon_utilities/invalided_functions.py')

diff --git a/moon_utilities/moon_utilities/invalided_functions.py b/moon_utilities/moon_utilities/invalided_functions.py
new file mode 100644
index 00000000..1c24d3f4
--- /dev/null
+++ b/moon_utilities/moon_utilities/invalided_functions.py
@@ -0,0 +1,440 @@
+# Software Name: MOON
+
+# Version: 5.4
+
+# SPDX-FileCopyrightText: Copyright (c) 2018-2020 Orange and its contributors
+# SPDX-License-Identifier: Apache-2.0
+
+# This software is distributed under the 'Apache License 2.0',
+# the text of which is available at 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+# or see the "LICENSE" file for more details.
+
+
+import logging
+import requests
+
+logger = logging.getLogger("moon.utilities." + __name__)
+
+
+def invalidate_assignment_in_slaves(slaves, policy_id, perimeter_id, category_id, data_id, type):
+    """
+    Send a request to one or more slaves to invalidate specific assignments
+    :param slaves: list of slaves
+    :param policy_id: the ID of the concerned policy
+    :param perimeter_id: the ID of the concerned perimeter
+    :param category_id: the ID of the concerned category
+    :param data_id: the ID of the concerned data
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/assignment"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            if policy_id and perimeter_id and category_id and data_id:
+                update = requests.delete("http://{}:{}/{}/{}/{}/{}/{}/{}".format(
+                    hostname, port, uri, policy_id, type, perimeter_id, category_id, data_id),
+                    timeout=1
+                )
+            elif policy_id and perimeter_id and category_id:
+                update = requests.delete("http://{}:{}/{}/{}/{}/{}/{}".format(
+                    hostname, port, uri, policy_id, type, perimeter_id, category_id),
+                    timeout=1
+                )
+            elif policy_id and perimeter_id:
+                update = requests.delete("http://{}:{}/{}/{}/{}/{}".format(
+                    hostname, port, uri, policy_id, type, perimeter_id),
+                    timeout=1
+                )
+            elif policy_id:
+                update = requests.delete("http://{}:{}/{}/{}/{}".format(
+                    hostname, port, uri, policy_id, type),
+                    timeout=1
+                )
+
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_data_in_slaves(slaves, policy_id, category_id, data_id, type):
+    """
+    Send a request to one or more slaves to invalidate specific data
+    :param slaves: list of slaves
+    :param policy_id: the ID of the concerned policy
+    :param category_id: the ID of the concerned category
+    :param data_id: the ID of the concerned data
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/data"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            update = requests.delete("http://{}:{}/{}/{}/{}".format(
+                hostname, port, uri, data_id, type),
+                timeout=1
+            )
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_perimeter_in_slaves(slaves, policy_id, perimeter_id, type, data=None,
+                                   is_delete=True):
+    """
+    Send a request to one or more slaves to invalidate specific perimeter
+    :param slaves: list of slaves
+    :param policy_id: the ID of the concerned policy
+    :param perimeter_id: the ID of the concerned perimeter
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/perimeter"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            if is_delete:
+                update = requests.delete("http://{}:{}/{}/{}/{}/{}".format(
+                    hostname, port, uri, perimeter_id, policy_id, type),
+                    timeout=1
+                )
+            else:
+                update = requests.put("http://{}:{}/{}/{}/{}/{}".format(
+                    hostname, port, uri, perimeter_id, policy_id, type),
+                    data=data,
+                    timeout=1
+                )
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_pdp_in_slaves(slaves, pdp_id, is_delete=True, data=None):
+    """
+    Send a request to one or more slaves to invalidate specific PDPs
+    :param slaves: list of slaves
+    :param pdp_id: the ID of the concerned PDP
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/pdp"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            if is_delete:
+                update = requests.delete("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, pdp_id),
+                    timeout=1
+                )
+            else:
+                update = requests.put("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, pdp_id),
+                    data=data,
+                    timeout=1
+                )
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_policy_in_slaves(slaves, policy_id, is_delete=True, data=None):
+    """
+    Send a request to one or more slaves to invalidate specific policies
+    :param slaves: list of slaves
+    :param policy_id: the ID of the concerned policy
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/policy"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            if is_delete:
+                update = requests.delete("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, policy_id),
+                    timeout=1
+                )
+            else:
+                update = requests.put("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, policy_id),
+                    data=data,
+                    timeout=1
+                )
+
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_rules_in_slaves(slaves, policy_id, rule_id):
+    """
+    Send a request to one or more slaves to invalidate specific rules
+    :param slaves: list of slaves
+    :param policy_id: the ID of the concerned policy
+    :param rule_id: the ID of the concerned rule
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/rule"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            update = requests.delete("http://{}:{}/{}/{}/{}".format(
+                hostname, port, uri, policy_id, rule_id),
+                timeout=1
+            )
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_model_in_slaves(slaves, model_id, is_delete=True, data=None):
+    """
+    Send a request to one or more slaves to invalidate specific models
+    :param slaves: list of slaves
+    :param model_id: the ID of the concerned model
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/model"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            if is_delete:
+                update = requests.delete("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, model_id),
+                    timeout=1
+                )
+            else:
+                update = requests.put("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, model_id),
+                    data=data,
+                    timeout=1
+                )
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_meta_data_in_slaves(slaves, category_id, type):
+    """
+    Send a request to one or more slaves to invalidate specific meta data
+    :param slaves: list of slaves
+    :param category_id: the ID of the concerned category
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/meta_data"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            update = requests.delete("http://{}:{}/{}/{}/{}".format(
+                hostname, port, uri, category_id, type),
+                data={
+                    "category_id": category_id
+                },
+                timeout=1
+            )
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
+def invalidate_meta_rule_in_slaves(slaves, meta_rule_id, is_delete=True, data=None):
+    """
+    Send a request to one or more slaves to invalidate specific meta rules
+    :param slaves: list of slaves
+    :param meta_rule_id: the ID of the concerned policy
+    :return: None
+    """
+
+    hostname, port = "", ""
+    uri = "update/meta_rule"
+    result = []
+    for key, value in slaves.get('slaves', {}).items():
+        if value.get("extra", {}).get("status") != "up":
+            continue
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            if is_delete:
+                update = requests.delete("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, meta_rule_id),
+                    timeout=1
+                )
+            else:
+                update = requests.put("http://{}:{}/{}/{}".format(
+                    hostname, port, uri, meta_rule_id),
+                    data=data,
+                    timeout=1
+                )
+
+            logger.debug("result {} {}:{} = {}".format(
+                update.status_code,
+                hostname,
+                port,
+                update.text))
+            result.append(value.get("name"))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+
+
+def invalidate_attributes_in_slaves(slaves, name, value=None):
+    """
+    Send a request to one or more slaves to invalidate specific data
+    :param slaves: list of slaves
+    :param name: the name of the attribute to invalidate
+    :param value: the value that has changed
+    :return: a list of updated slaves
+    """
+
+    hostname, port = "", ""
+    uri = "update/attributes"
+    result = []
+    for key, value in slaves.items():
+        try:
+            hostname = value.get("extra", {}).get("server_ip")
+            port = value.get("extra", {}).get("port")
+            update = requests.delete("http://{}:{}/{}/{}".format(
+                hostname, port, uri, name),
+                headers={"x-api-key": value.get("extra", {}).get("api_key")},
+                timeout=1
+            )
+            if update.status_code in (200, 202, 206, 208):
+                result.append(value.get("name"))
+            else:
+                logger.warning("Error when updating {} ({})".format(key, update.status_code))
+        except requests.exceptions.ConnectionError:
+            logger.warning(
+                "Cannot reach {}:{}".format(hostname, port))
+        except requests.models.InvalidURL:
+            logger.warning(
+                "Invalid URL {}:{}".format(hostname, port))
+    return result
+
+
-- 
cgit 1.2.3-korg