| # ================================================================================ |
| # Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. |
| # ================================================================================ |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # ============LICENSE_END========================================================= |
| # |
| # ECOMP is a trademark and service mark of AT&T Intellectual Property. |
| |
| """policy-client communicates with policy-engine thru REST API""" |
| |
| import json |
| import logging |
| import re |
| |
| from .policy_consts import (POLICY_BODY, POLICY_CONFIG, POLICY_ID, POLICY_NAME, |
| POLICY_VERSION) |
| |
| class PolicyUtils(object): |
| """policy-client utils""" |
| _logger = logging.getLogger("policy_handler.policy_utils") |
| _policy_name_ext = re.compile('[.][0-9]+[.][a-zA-Z]+$') |
| |
| @staticmethod |
| def extract_policy_id(policy_name): |
| """ policy_name = policy_id + "." + <version> + "." + <extension> |
| For instance, |
| policy_name = DCAE_alex.Config_alex_policy_number_1.3.xml |
| policy_id = DCAE_alex.Config_alex_policy_number_1 |
| policy_scope = DCAE_alex |
| policy_class = Config |
| policy_version = 3 |
| type = extension = xml |
| delimiter = "." |
| policy_class_delimiter = "_" |
| policy_name in PAP = DCAE_alex.alex_policy_number_1 |
| """ |
| if not policy_name: |
| return |
| return PolicyUtils._policy_name_ext.sub('', policy_name) |
| |
| @staticmethod |
| def parse_policy_config(policy): |
| """try parsing the config in policy.""" |
| if not policy: |
| return policy |
| config = policy.get(POLICY_BODY, {}).get(POLICY_CONFIG) |
| if config: |
| policy[POLICY_BODY][POLICY_CONFIG] = Utils.safe_json_parse(config) |
| return policy |
| |
| @staticmethod |
| def convert_to_policy(policy_config): |
| """wrap policy_config received from policy-engine with policy_id.""" |
| if not policy_config: |
| return |
| policy_name = policy_config.get(POLICY_NAME) |
| policy_version = policy_config.get(POLICY_VERSION) |
| if not policy_name or not policy_version: |
| return |
| policy_id = PolicyUtils.extract_policy_id(policy_name) |
| if not policy_id: |
| return |
| return {POLICY_ID:policy_id, POLICY_BODY:policy_config} |
| |
| @staticmethod |
| def select_latest_policy(policy_configs, min_version_expected=None, ignore_policy_names=None): |
| """For some reason, the policy-engine returns all version of the policy_configs. |
| DCAE-Controller is only interested in the latest version |
| """ |
| if not policy_configs: |
| return |
| latest_policy_config = {} |
| for policy_config in policy_configs: |
| policy_name = policy_config.get(POLICY_NAME) |
| policy_version = policy_config.get(POLICY_VERSION) |
| if not policy_name or not policy_version or not policy_version.isdigit(): |
| continue |
| policy_version = int(policy_version) |
| if min_version_expected and policy_version < min_version_expected: |
| continue |
| if ignore_policy_names and policy_name in ignore_policy_names: |
| continue |
| |
| if not latest_policy_config \ |
| or int(latest_policy_config[POLICY_VERSION]) < policy_version: |
| latest_policy_config = policy_config |
| |
| return PolicyUtils.parse_policy_config(PolicyUtils.convert_to_policy(latest_policy_config)) |
| |
| @staticmethod |
| def select_latest_policies(policy_configs): |
| """For some reason, the policy-engine returns all version of the policy_configs. |
| DCAE-Controller is only interested in the latest versions |
| """ |
| if not policy_configs: |
| return {} |
| policies = {} |
| for policy_config in policy_configs: |
| policy = PolicyUtils.convert_to_policy(policy_config) |
| if not policy: |
| continue |
| policy_id = policy.get(POLICY_ID) |
| policy_version = policy.get(POLICY_BODY, {}).get(POLICY_VERSION) |
| if not policy_id or not policy_version or not policy_version.isdigit(): |
| continue |
| if policy_id not in policies \ |
| or int(policy_version) > int(policies[policy_id][POLICY_BODY][POLICY_VERSION]): |
| policies[policy_id] = policy |
| |
| for policy_id in policies: |
| policies[policy_id] = PolicyUtils.parse_policy_config(policies[policy_id]) |
| |
| return policies |
| |
| class Utils(object): |
| """general purpose utils""" |
| _logger = logging.getLogger("policy_handler.utils") |
| |
| @staticmethod |
| def safe_json_parse(json_str): |
| """try parsing json without exception - returns the json_str back if fails""" |
| if not json_str: |
| return json_str |
| try: |
| return json.loads(json_str) |
| except (ValueError, TypeError) as err: |
| Utils._logger.warning("unexpected json error(%s): len(%s) str[:100]: (%s)", |
| str(err), len(json_str), str(json_str)[:100]) |
| return json_str |
| |
| @staticmethod |
| def are_the_same(body_1, body_2): |
| """check whether both objects are the same""" |
| if (body_1 and not body_2) or (not body_1 and body_2): |
| Utils._logger.debug("only one is empty %s != %s", body_1, body_2) |
| return False |
| |
| if body_1 is None and body_2 is None: |
| return True |
| |
| if isinstance(body_1, list) and isinstance(body_2, list): |
| if len(body_1) != len(body_2): |
| Utils._logger.debug("len %s != %s", json.dumps(body_1), json.dumps(body_2)) |
| return False |
| |
| for val_1, val_2 in zip(body_1, body_2): |
| if not Utils.are_the_same(val_1, val_2): |
| return False |
| return True |
| |
| if isinstance(body_1, dict) and isinstance(body_2, dict): |
| if body_1.keys() ^ body_2.keys(): |
| Utils._logger.debug("keys %s != %s", json.dumps(body_1), json.dumps(body_2)) |
| return False |
| |
| for key, val_1 in body_1.items(): |
| if not Utils.are_the_same(val_1, body_2[key]): |
| return False |
| return True |
| |
| # ... here when primitive values or mismatched types ... |
| the_same_values = (body_1 == body_2) |
| if not the_same_values: |
| Utils._logger.debug("values %s != %s", body_1, body_2) |
| return the_same_values |