Re-org folders, onboard test folder, test config

Reorganized the folder structure. Onboarded testcases. Added test config.

Issue-ID: OPTFRA-74
Change-Id: I97882a162a405a18ffd287495039e15ae9d0ad7b
Signed-off-by: Ankitkumar Patel <ankit@research.att.com>

3 files changed, 0 insertions, 261 deletions

diff --git a/adapters/policy/__init__.py b/adapters/policy/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/adapters/policy/__init__.py
+++ /dev/null
diff --git a/adapters/policy/interface.py b/adapters/policy/interface.py
deleted file mode 100644
index ee45051..0000000
--- a/adapters/policy/interface.py
+++ /dev/null
@@ -1,203 +0,0 @@
-# -------------------------------------------------------------------------
-#   Copyright (c) 2015-2017 AT&T Intellectual Property
-#
-#   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.
-#
-# -------------------------------------------------------------------------
-#
-
-import base64
-import itertools
-import json
-
-
-from requests import RequestException
-from osdf.operation.exceptions import BusinessException
-from osdf.adapters.local_data.local_policies import get_local_policies
-from osdf.adapters.policy.utils import _regex_policy_name
-from osdf.config.base import osdf_config
-from osdf.logging.osdf_logging import audit_log, MH, metrics_log, error_log, debug_log
-from osdf.utils.interfaces import RestClient
-from osdf.optimizers.placementopt.conductor.api_builder import retrieve_node
-from osdf.utils import data_mapping
-
-
-def get_by_name(rest_client, policy_name_list, wildcards=True):
-    policy_list = []
-    for policy_name in policy_name_list:
-        try:
-            query_name = policy_name
-            if wildcards:
-                query_name = _regex_policy_name(query_name)
-            policy_list.append(rest_client.request(json={"policyName": query_name}))
-        except RequestException as err:
-            audit_log.warn("Error in fetching policy: " + policy_name)
-            raise BusinessException("Cannot fetch policy {}: ".format(policy_name), err)
-    return policy_list
-
-
-def get_subscriber_name(req, pmain):
-    subs_name = retrieve_node(req, pmain['subscriber_name'])
-    if subs_name is None:
-        return "DEFAULT"
-    else:
-        subs_name_uc = subs_name.upper()
-        if subs_name_uc in ("DEFAULT", "NULL", ""):
-            subs_name = "DEFAULT"
-    return subs_name
-
-
-def get_subscriber_role(rest_client, req, pmain, service_name, scope):
-    """Make a request to policy and return subscriberRole
-    :param rest_client: rest client to make call
-    :param req: request object from MSO
-    :param pmain: main config that will have policy path information
-    :param service_name: the type of service to call: e.g. "vCPE
-    :param scope: the scope of policy to call: e.g. "OOF_HAS_vCPE".
-    :return: subscriberRole and provStatus retrieved from Subscriber policy
-    """
-    subscriber_role = "DEFAULT"
-    prov_status = []
-    subs_name = get_subscriber_name(req, pmain)
-    if subs_name == "DEFAULT":
-        return subscriber_role, prov_status
-    
-    policy_subs = pmain['policy_subscriber']
-    policy_scope = {"policyName": "{}.*".format(scope),
-                    "configAttributes": {
-                        "serviceType": "{}".format(service_name),
-                        "service": "{}".format(policy_subs)}
-                    }
-    policy_list = []
-    try:
-        policy_list.append(rest_client.request(json=policy_scope))
-    except RequestException as err:
-        audit_log.warn("Error in fetching policy for {}: ".format(policy_subs))
-        return subscriber_role, prov_status
-            
-    formatted_policies = []
-    for x in itertools.chain(*policy_list):
-        if x['config'] is None:
-            raise BusinessException("Config not found for policy with name %s" % x['policyName'])
-        else:
-            formatted_policies.append(json.loads(x['config']))
-    
-    for policy in formatted_policies:
-        property_list = policy['content']['property']
-        for prop in property_list:
-            if subs_name in prop['subscriberName']:
-                subs_role_list = prop['subscriberRole']
-                prov_status = prop['provStatus']
-                if isinstance(subs_role_list, list): # as list is returned
-                    return subs_role_list[0], prov_status
-    return subscriber_role, prov_status
-    
-
-def get_by_scope(rest_client, req, config_local, type_service):
-    policy_list = []
-    pmain = config_local['policy_info'][type_service]
-    pscope = pmain['policy_scope']
-    
-    model_name = retrieve_node(req, pscope['service_name'])
-    service_name = data_mapping.get_request_service_type(req)
-    if service_name is None:
-        service_name = data_mapping.get_service_type(model_name)
-    scope = pscope['scope_{}'.format(service_name.lower())]
-    subscriber_role, prov_status = get_subscriber_role(rest_client, req, pmain, service_name, scope)
-    policy_type_list = pmain['policy_type_{}'.format(service_name.lower())]
-    for policy_type in policy_type_list:
-        policy_scope = {"policyName": "{}.*".format(scope),
-                        "configAttributes": {
-                            "serviceType": "{}".format(service_name),
-                            "service": "{}".format(policy_type),
-                            "subscriberRole": "{}".format(subscriber_role)}
-                        }
-        policy_list.append(rest_client.request(json=policy_scope))
-    return policy_list, prov_status
-
-
-def remote_api(req_json, osdf_config, service_type="placement"):
-    """Make a request to policy and return response -- it accounts for multiple requests that be needed
-    :param req_json: policy request object (can have multiple policy names)
-    :param osdf_config: main config that will have credential information
-    :param service_type: the type of service to call: "placement", "scheduling"
-    :return: all related policies and provStatus retrieved from Subscriber policy
-    """
-#     if not req_json[service_type + "Info"]['policyId']:
-#         return []
-
-    config = osdf_config.deployment
-    uid, passwd = config['policyPlatformUsername'], config['policyPlatformPassword']
-    pcuid, pcpasswd = config['policyClientUsername'], config['policyClientPassword']
-    headers = {"ClientAuth": base64.b64encode(bytes("{}:{}".format(pcuid, pcpasswd), "ascii"))}
-    headers.update({'Environment': config['policyPlatformEnv']})
-    url = config['policyPlatformUrl']
-    rc = RestClient(userid=uid, passwd=passwd, headers=headers, url=url, log_func=debug_log.debug)
-
-    if osdf_config.core['policy_info'][service_type]['policy_fetch'] == "by_name":
-        policies = get_by_name(rc, req_json[service_type + "Info"]['policyId'], wildcards=True)
-    elif osdf_config.core['policy_info'][service_type]['policy_fetch'] == "by_name_no_wildcards":
-        policies = get_by_name(rc, req_json[service_type + "Info"]['policyId'], wildcards=False)
-    else:  # Get policy by scope
-        policies, prov_status = get_by_scope(rc, req_json, osdf_config.core, service_type)
-
-    # policies in res are list of lists, so flatten them; also only keep config part
-    formatted_policies = []
-    for x in itertools.chain(*policies):
-        if x['config'] is None:
-            raise BusinessException("Config not found for policy with name %s" % x['policyName'])
-        else:
-            formatted_policies.append(json.loads(x['config']))
-    return formatted_policies, prov_status
-
-
-def local_policies_location(req_json, osdf_config, service_type):
-    """
-    Get folder and list of policy_files if "local policies" option is enabled
-    :param service_type: placement supported for now, but can be any other service
-    :return: a tuple (folder, file_list) or None
-    """
-    lp = osdf_config.core.get('osdf_hacks', {}).get('local_policies', {})
-    if lp.get('global_disabled'):
-        return None  # short-circuit to disable all local policies
-    if lp.get('local_{}_policies_enabled'.format(service_type)):
-        if service_type == "scheduling":
-            return lp.get('{}_policy_dir'.format(service_type)), lp.get('{}_policy_files'.format(service_type))
-        else:
-            model_name = retrieve_node(req_json, osdf_config.core['policy_info'][service_type]['policy_scope']['service_name'])
-            service_name = data_mapping.get_service_type(model_name)
-            return lp.get('{}_policy_dir_{}'.format(service_type, service_name.lower())), lp.get('{}_policy_files_{}'.format(service_type, service_name.lower()))
-    return None
-
-
-def get_policies(request_json, service_type):
-    """Validate the request and get relevant policies
-    :param request_json: Request object
-    :param service_type: the type of service to call: "placement", "scheduling"
-    :return: policies associated with this request and provStatus retrieved from Subscriber policy
-    """
-    prov_status = []
-    req_info = request_json['requestInfo']
-    req_id = req_info['requestId']
-    metrics_log.info(MH.requesting("policy", req_id))
-    local_info = local_policies_location(request_json, osdf_config, service_type)
-
-    if local_info:  # tuple containing location and list of files
-        to_filter = None
-        if osdf_config.core['policy_info'][service_type]['policy_fetch'] == "by_name":
-            to_filter = request_json[service_type + "Info"]['policyId']
-        policies = get_local_policies(local_info[0], local_info[1], to_filter)
-    else:
-        policies, prov_status= remote_api(request_json, osdf_config, service_type)
-        
-    return policies, prov_status
diff --git a/adapters/policy/utils.py b/adapters/policy/utils.py
deleted file mode 100644
index a006f12..0000000
--- a/adapters/policy/utils.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# -------------------------------------------------------------------------
-#   Copyright (c) 2015-2017 AT&T Intellectual Property
-#
-#   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.
-#
-# -------------------------------------------------------------------------
-#
-
-from collections import defaultdict
-
-
-def group_policies(flat_policies):
-    """Filter policies using the following steps:
-    1. Apply prioritization among the policies that are sharing the same policy type and resource type
-    2. Remove redundant policies that may applicable across different types of resource
-    3. Filter policies based on type and return
-    :param flat_policies: list of flat policies
-    :return: Filtered policies
-    """
-    aggregated_policies = {}
-    filter_policies = defaultdict(list)
-    policy_name = []
-    for policy in flat_policies:
-        policy_type = policy['content']['type']
-        if policy_type not in aggregated_policies:
-            aggregated_policies[policy_type] = defaultdict(list)
-        for resource in policy['content']['policyScope']['resourceInstanceType']:
-            aggregated_policies[policy_type][resource].append(policy)
-    for policy_type in aggregated_policies:
-        for resource in aggregated_policies[policy_type]:
-            if len(aggregated_policies[policy_type][resource]) > 0:
-                aggregated_policies[policy_type][resource].sort(key=lambda x: x['priority'], reverse=True)
-                policy = aggregated_policies[policy_type][resource][0]
-                if policy['policyName'] not in policy_name:
-                    filter_policies[policy['content']['type']].append(policy)
-                    policy_name.append(policy['policyName'])
-    return filter_policies
-
-
-def _regex_policy_name(policy_name):
-    """Get the correct policy name as a regex
-    (e.g. OOF_HAS_vCPE.cloudAttributePolicy ends up in policy as OOF_HAS_vCPE.Config_MS_cloudAttributePolicy.1.xml
-    So, for now, we query it as OOF_HAS_vCPE..*aicAttributePolicy.*)
-    :param policy_name: Example: OOF_HAS_vCPE.aicAttributePolicy
-    :return: regexp for policy: Example: OOF_HAS_vCPE..*aicAttributePolicy.*
-    """
-    p = policy_name.partition('.')
-    return p[0] + p[1] + ".*" + p[2] + ".*"