osdf rearchitecture into apps and libs

Change-Id: I2db2f8e252bd5e60807b2ffabf5a5b193a789f7a
Signed-off-by: vrvarma <vv8305@att.com>
Issue-ID: OPTFRA-637

6 files changed, 682 insertions, 0 deletions

diff --git a/apps/placement/optimizers/__init__.py b/apps/placement/optimizers/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/apps/placement/optimizers/__init__.py
diff --git a/apps/placement/optimizers/conductor/__init__.py b/apps/placement/optimizers/conductor/__init__.py
new file mode 100644
index 0000000..4b25e5b
--- /dev/null
+++ b/apps/placement/optimizers/conductor/__init__.py
@@ -0,0 +1,17 @@
+# -------------------------------------------------------------------------
+#   Copyright (c) 2017-2018 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.
+#
+# -------------------------------------------------------------------------
+#
diff --git a/apps/placement/optimizers/conductor/api_builder.py b/apps/placement/optimizers/conductor/api_builder.py
new file mode 100644
index 0000000..7b61580
--- /dev/null
+++ b/apps/placement/optimizers/conductor/api_builder.py
@@ -0,0 +1,99 @@
+# -------------------------------------------------------------------------
+#   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 json
+
+from jinja2 import Template
+
+import apps.placement.optimizers.conductor.translation as tr
+from osdf.adapters.policy.utils import group_policies_gen
+from osdf.utils.programming_utils import list_flatten
+
+
+def _build_parameters(group_policies, request_json):
+    """
+    Function prepares parameters section for has request
+    :param group_policies: filtered policies
+    :param request_json: parameter data received from a client
+    :return:
+    """
+    initial_params = tr.get_opt_query_data(request_json, group_policies['request_param_query'])
+    params = dict()
+    params.update({"REQUIRED_MEM": initial_params.pop("requiredMemory", "")})
+    params.update({"REQUIRED_DISK": initial_params.pop("requiredDisk", "")})
+    params.update({"customer_lat": initial_params.pop("customerLatitude", 0.0)})
+    params.update({"customer_long": initial_params.pop("customerLongitude", 0.0)})
+    params.update({"service_name": request_json['serviceInfo']['serviceName']})
+    params.update({"service_id": request_json['serviceInfo']['serviceInstanceId']})
+
+    for key, val in initial_params.items():
+        if val and val != "":
+            params.update({key: val})
+
+    return params
+
+
+def conductor_api_builder(request_json, flat_policies: list, local_config,
+                          template="apps/placement/templates/conductor_interface.json"):
+    """Build an OSDF southbound API call for HAS-Conductor/Placement optimization
+    :param request_json: parameter data received from a client
+    :param flat_policies: policy data received from the policy platform (flat policies)
+    :param template: template to generate southbound API call to conductor
+    :param local_config: local configuration file with pointers for the service specific information
+    :param prov_status: provStatus retrieved from Subscriber policy
+    :return: json to be sent to Conductor/placement optimization
+    """
+    templ = Template(open(template).read())
+    gp = group_policies_gen(flat_policies, local_config)
+    demand_vnf_name_list = []
+
+    for placementDemand in request_json['placementInfo']['placementDemands']:
+        demand_vnf_name_list.append(placementDemand['resourceModuleName'].lower())
+    demand_list = tr.gen_demands(request_json, gp['vnfPolicy'])
+    attribute_policy_list = tr.gen_attribute_policy(demand_vnf_name_list, gp['attribute'])
+    distance_to_location_policy_list = tr.gen_distance_to_location_policy(
+        demand_vnf_name_list, gp['distance_to_location'])
+    inventory_policy_list = tr.gen_inventory_group_policy(demand_vnf_name_list, gp['inventory_group'])
+    resource_instance_policy_list = tr.gen_resource_instance_policy(
+        demand_vnf_name_list, gp['instance_fit'])
+    resource_region_policy_list = tr.gen_resource_region_policy(demand_vnf_name_list, gp['region_fit'])
+    zone_policy_list = tr.gen_zone_policy(demand_vnf_name_list, gp['zone'])
+    optimization_policy_list = tr.gen_optimization_policy(demand_vnf_name_list, gp['placement_optimization'])
+    reservation_policy_list = tr.gen_reservation_policy(demand_vnf_name_list, gp['instance_reservation'])
+    capacity_policy_list = tr.gen_capacity_policy(demand_vnf_name_list, gp['vim_fit'])
+    hpa_policy_list = tr.gen_hpa_policy(demand_vnf_name_list, gp['hpa'])
+    req_params_dict = _build_parameters(gp, request_json)
+    conductor_policies = [attribute_policy_list, distance_to_location_policy_list, inventory_policy_list,
+                          resource_instance_policy_list, resource_region_policy_list, zone_policy_list,
+                          reservation_policy_list, capacity_policy_list, hpa_policy_list]
+    filtered_policies = [x for x in conductor_policies if len(x) > 0]
+    policy_groups = list_flatten(filtered_policies)
+    req_info = request_json['requestInfo']
+    request_type = req_info.get('requestType', None)
+    rendered_req = templ.render(
+        requestType=request_type,
+        demand_list=demand_list,
+        policy_groups=policy_groups,
+        optimization_policies=optimization_policy_list,
+        name=req_info['requestId'],
+        timeout=req_info['timeout'],
+        limit=req_info['numSolutions'],
+        request_params=req_params_dict,
+        json=json)
+    json_payload = json.dumps(json.loads(rendered_req))  # need this because template's JSON is ugly!
+    return json_payload
diff --git a/apps/placement/optimizers/conductor/conductor.py b/apps/placement/optimizers/conductor/conductor.py
new file mode 100755
index 0000000..05d1641
--- /dev/null
+++ b/apps/placement/optimizers/conductor/conductor.py
@@ -0,0 +1,202 @@
+# -------------------------------------------------------------------------

+#   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.

+#

+# -------------------------------------------------------------------------

+#

+

+"""

+This application generates conductor API calls using the information received from SO and Policy platform.

+"""

+

+import json

+import time

+

+from jinja2 import Template

+from requests import RequestException

+

+from apps.placement.optimizers.conductor.api_builder import conductor_api_builder

+from osdf.logging.osdf_logging import debug_log

+from osdf.utils.interfaces import RestClient

+from osdf.operation.exceptions import BusinessException

+

+

+def request(req_object, osdf_config, flat_policies):

+    """

+    Process a placement request from a Client (build Conductor API call, make the call, return result)

+    :param req_object: Request parameters from the client

+    :param osdf_config: Configuration specific to SNIRO application (core + deployment)

+    :param flat_policies: policies related to placement (fetched based on request)

+    :param prov_status: provStatus retrieved from Subscriber policy

+    :return: response from Conductor (accounting for redirects from Conductor service

+    """

+    config = osdf_config.deployment

+    local_config = osdf_config.core

+    uid, passwd = config['conductorUsername'], config['conductorPassword']

+    conductor_url = config['conductorUrl']

+    req_id = req_object['requestInfo']['requestId']

+    transaction_id = req_object['requestInfo']['transactionId']

+    headers = dict(transaction_id=transaction_id)

+    placement_ver_enabled = config.get('placementVersioningEnabled', False)

+    

+    if placement_ver_enabled:

+        cond_minor_version = config.get('conductorMinorVersion', None) 

+        if cond_minor_version is not None:

+            x_minor_version = str(cond_minor_version)

+            headers.update({'X-MinorVersion': x_minor_version})

+        debug_log.debug("Versions set in HTTP header to conductor: X-MinorVersion: {} ".format(x_minor_version))

+

+    max_retries = config.get('conductorMaxRetries', 30)

+    ping_wait_time = config.get('conductorPingWaitTime', 60)

+

+    rc = RestClient(userid=uid, passwd=passwd, method="GET", log_func=debug_log.debug, headers=headers)

+    conductor_req_json_str = conductor_api_builder(req_object, flat_policies, local_config)

+    conductor_req_json = json.loads(conductor_req_json_str)

+

+    debug_log.debug("Sending first Conductor request for request_id {}".format(req_id))

+    resp, raw_resp = initial_request_to_conductor(rc, conductor_url, conductor_req_json)

+    # Very crude way of keeping track of time.

+    # We are not counting initial request time, first call back, or time for HTTP request

+    total_time, ctr = 0, 2

+    client_timeout = req_object['requestInfo']['timeout']

+    configured_timeout = max_retries * ping_wait_time

+    max_timeout = min(client_timeout, configured_timeout)

+

+    while True:  # keep requesting conductor till we get a result or we run out of time

+        if resp is not None:

+            if resp["plans"][0].get("status") in ["error"]:

+                raise RequestException(response=raw_resp, request=raw_resp.request)

+

+            if resp["plans"][0].get("status") in ["done", "not found"]:

+                if resp["plans"][0].get("recommendations"):

+                    return conductor_response_processor(resp, raw_resp, req_id)

+                else:  # "solved" but no solutions found

+                    return conductor_no_solution_processor(resp, raw_resp, req_id)

+            new_url = resp['plans'][0]['links'][0][0]['href']  # TODO: check why a list of lists

+

+        if total_time >= max_timeout:

+            raise BusinessException("Conductor could not provide a solution within {} seconds,"

+                                    "this transaction is timing out".format(max_timeout))

+        time.sleep(ping_wait_time)

+        ctr += 1

+        debug_log.debug("Attempt number {} url {}; prior status={}".format(ctr, new_url, resp['plans'][0]['status']))

+        total_time += ping_wait_time

+

+        try:

+            raw_resp = rc.request(new_url, raw_response=True)

+            resp = raw_resp.json()

+        except RequestException as e:

+            debug_log.debug("Conductor attempt {} for request_id {} has failed because {}".format(ctr, req_id, str(e)))

+

+

+def initial_request_to_conductor(rc, conductor_url, conductor_req_json):

+    """First steps in the request-redirect chain in making a call to Conductor

+    :param rc: REST client object for calling conductor

+    :param conductor_url: conductor's base URL to submit a placement request

+    :param conductor_req_json: request json object to send to Conductor

+    :return: URL to check for follow up (similar to redirects); we keep checking these till we get a result/error

+    """

+    debug_log.debug("Payload to Conductor: {}".format(json.dumps(conductor_req_json)))

+    raw_resp = rc.request(url=conductor_url, raw_response=True, method="POST", json=conductor_req_json)

+    resp = raw_resp.json()

+    if resp["status"] != "template":

+        raise RequestException(response=raw_resp, request=raw_resp.request)

+    time.sleep(10)  # 10 seconds wait time to avoid being too quick!

+    plan_url = resp["links"][0][0]["href"]

+    debug_log.debug("Attempting to read the plan from the conductor provided url {}".format(plan_url))

+    raw_resp = rc.request(raw_response=True, url=plan_url)  # TODO: check why a list of lists for links

+    resp = raw_resp.json()

+

+    if resp["plans"][0]["status"] in ["error"]:

+        raise RequestException(response=raw_resp, request=raw_resp.request)

+    return resp, raw_resp  # now the caller of this will handle further follow-ups

+

+

+def conductor_response_processor(conductor_response, raw_response, req_id):

+    """Build a response object to be sent to client's callback URL from Conductor's response

+    This includes Conductor's placement optimization response, and required ASDC license artifacts

+

+    :param conductor_response: JSON response from Conductor

+    :param raw_response: Raw HTTP response corresponding to above

+    :param req_id: Id of a request

+    :return: JSON object that can be sent to the client's callback URL

+    """

+    composite_solutions = []

+    name_map = {"physical-location-id": "cloudClli", "host_id": "vnfHostName",

+                "cloud_version": "cloudVersion", "cloud_owner": "cloudOwner",

+                "cloud": "cloudRegionId", "service": "serviceInstanceId", "is_rehome": "isRehome",

+                "location_id": "locationId", "location_type": "locationType", "directives": "oof_directives"}

+    for reco in conductor_response['plans'][0]['recommendations']:

+        for resource in reco.keys():

+            c = reco[resource]['candidate']

+            solution = {

+                'resourceModuleName': resource,

+                'serviceResourceId': reco[resource].get('service_resource_id', ""),

+                'solution': {"identifierType": name_map.get(c['inventory_type'], c['inventory_type']),

+                             'identifiers': [c['candidate_id']],

+                             'cloudOwner': c.get('cloud_owner', "")},

+                'assignmentInfo': []

+            }

+            for key, value in c.items():

+                if key in ["location_id", "location_type", "is_rehome", "host_id"]:

+                    try:

+                        solution['assignmentInfo'].append({"key": name_map.get(key, key), "value": value})

+                    except KeyError:

+                        debug_log.debug("The key[{}] is not mapped and will not be returned in assignment info".format(key))

+

+            for key, value in reco[resource]['attributes'].items():

+                try:

+                    solution['assignmentInfo'].append({"key": name_map.get(key, key), "value": value})

+                except KeyError:

+                    debug_log.debug("The key[{}] is not mapped and will not be returned in assignment info".format(key))

+            composite_solutions.append(solution)

+

+    request_status = "completed" if conductor_response['plans'][0]['status'] == "done" \

+        else conductor_response['plans'][0]['status']

+    transaction_id = raw_response.headers.get('transaction_id', "")

+    status_message = conductor_response.get('plans')[0].get('message', "")

+

+    solution_info = {}

+    if composite_solutions:

+        solution_info.setdefault('placementSolutions', [])

+        solution_info['placementSolutions'].append(composite_solutions)

+

+    resp = {

+        "transactionId": transaction_id,

+        "requestId": req_id,

+        "requestStatus": request_status,

+        "statusMessage": status_message,

+        "solutions": solution_info

+    }

+    return resp

+

+

+def conductor_no_solution_processor(conductor_response, raw_response, request_id,

+                                    template_placement_response="templates/plc_opt_response.jsont"):

+    """Build a response object to be sent to client's callback URL from Conductor's response

+    This is for case where no solution is found

+

+    :param conductor_response: JSON response from Conductor

+    :param raw_response: Raw HTTP response corresponding to above

+    :param request_id: request Id associated with the client request (same as conductor response's "name")

+    :param template_placement_response: the template for generating response to client (plc_opt_response.jsont)

+    :return: JSON object that can be sent to the client's callback URL

+    """

+    status_message = conductor_response["plans"][0].get("message")

+    templ = Template(open(template_placement_response).read())

+    return json.loads(templ.render(composite_solutions=[], requestId=request_id, license_solutions=[],

+                                   transactionId=raw_response.headers.get('transaction_id', ""),

+                                   requestStatus="completed", statusMessage=status_message, json=json))

+

+

diff --git a/apps/placement/optimizers/conductor/remote_opt_processor.py b/apps/placement/optimizers/conductor/remote_opt_processor.py
new file mode 100644
index 0000000..a08f3a4
--- /dev/null
+++ b/apps/placement/optimizers/conductor/remote_opt_processor.py
@@ -0,0 +1,81 @@
+# -------------------------------------------------------------------------
+#   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 requests import RequestException
+
+import traceback
+from osdf.operation.error_handling import build_json_error_body
+from osdf.logging.osdf_logging import metrics_log, MH, error_log
+from apps.placement.optimizers.conductor import conductor
+from apps.license.optimizers.simple_license_allocation import license_optim
+from osdf.utils.interfaces import get_rest_client
+from osdf.utils.mdc_utils import mdc_from_json
+
+
+def process_placement_opt(request_json, policies, osdf_config):
+    """Perform the work for placement optimization (e.g. call SDC artifact and make conductor request)
+    NOTE: there is scope to make the requests to policy asynchronous to speed up overall performance
+    :param request_json: json content from original request
+    :param policies: flattened policies corresponding to this request
+    :param osdf_config: configuration specific to OSDF app
+    :param prov_status: provStatus retrieved from Subscriber policy
+    :return: None, but make a POST to callback URL
+    """
+    
+    try:
+        mdc_from_json(request_json)
+        rc = get_rest_client(request_json, service="so")
+        req_id = request_json["requestInfo"]["requestId"]
+        transaction_id = request_json['requestInfo']['transactionId']
+
+        metrics_log.info(MH.inside_worker_thread(req_id))
+        license_info = None
+        if request_json.get('licenseInfo', {}).get('licenseDemands'):
+            license_info = license_optim(request_json)
+
+        # Conductor only handles placement, only call Conductor if placementDemands exist
+        if request_json.get('placementInfo', {}).get('placementDemands'):
+            metrics_log.info(MH.requesting("placement/conductor", req_id))
+            placement_response = conductor.request(request_json, osdf_config, policies)
+            if license_info:  # Attach license solution if it exists
+                placement_response['solutionInfo']['licenseInfo'] = license_info
+        else:  # License selection only scenario
+            placement_response = {
+                "transactionId": transaction_id,
+                "requestId": req_id,
+                "requestStatus": "completed",
+                "statusMessage": "License selection completed successfully",
+                "solutionInfo": {"licenseInfo": license_info}
+            }
+    except Exception as err:
+        error_log.error("Error for {} {}".format(req_id, traceback.format_exc()))
+
+        try:
+            body = build_json_error_body(err)
+            metrics_log.info(MH.sending_response(req_id, "ERROR"))
+            rc.request(json=body, noresponse=True)
+        except RequestException:
+            error_log.error("Error sending asynchronous notification for {} {}".format(req_id, traceback.format_exc()))
+        return
+
+    try:
+        metrics_log.info(MH.calling_back_with_body(req_id, rc.url,placement_response))
+        rc.request(json=placement_response, noresponse=True)
+    except RequestException :  # can't do much here but log it and move on
+        error_log.error("Error sending asynchronous notification for {} {}".format(req_id, traceback.format_exc()))
+
diff --git a/apps/placement/optimizers/conductor/translation.py b/apps/placement/optimizers/conductor/translation.py
new file mode 100644
index 0000000..d361755
--- /dev/null
+++ b/apps/placement/optimizers/conductor/translation.py
@@ -0,0 +1,283 @@
+# -------------------------------------------------------------------------
+#   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 copy
+import json
+import yaml
+import re
+
+from osdf.utils.data_conversion import text_to_symbol
+from osdf.utils.programming_utils import dot_notation
+
+policy_config_mapping = yaml.safe_load(open('config/has_config.yaml')).get('policy_config_mapping')
+
+
+def get_opt_query_data(req_json, policies):
+    """
+    Fetch service and order specific details from the requestParameters field of a request.
+    :param req_json: a request file
+    :param policies: A set of policies
+    :return: A dictionary with service and order-specific attributes.
+    """
+    req_param_dict = {}
+    if 'requestParameters' in req_json["placementInfo"]:
+        req_params = req_json["placementInfo"]["requestParameters"]
+        for policy in policies:
+            for queryProp in policy['content']['queryProperties']:
+                attr_val = queryProp['value'] if 'value' in queryProp and queryProp['value'] != "" \
+                    else dot_notation(req_params, queryProp['attribute_location'])
+                if attr_val is not None:
+                    req_param_dict.update({queryProp['attribute']: attr_val})
+    return req_param_dict
+
+
+def gen_optimization_policy(vnf_list, optimization_policy):
+    """Generate optimization policy details to pass to Conductor
+    :param vnf_list: List of vnf's to used in placement request
+    :param optimization_policy: optimization objective policy information provided in the incoming request
+    :return: List of optimization objective policies in a format required by Conductor
+    """
+    optimization_policy_list = []
+    for policy in optimization_policy:
+        content = policy['content']
+        parameter_list = []
+        parameters = ["cloud_version", "hpa_score"]
+
+        for attr in content['objectiveParameter']['parameterAttributes']:
+            parameter = attr['parameter'] if attr['parameter'] in parameters else attr['parameter']+"_between"
+            vnfs = get_matching_vnfs(attr['resources'], vnf_list)
+            for vnf in vnfs:
+                value = [vnf] if attr['parameter'] in parameters else [attr['customerLocationInfo'], vnf]
+                parameter_list.append({
+                    attr['operator']: [attr['weight'], {parameter: value}]
+                })
+
+        optimization_policy_list.append({
+                content['objective']: {content['objectiveParameter']['operator']: parameter_list }
+        })
+    return optimization_policy_list
+
+
+def get_matching_vnfs(resources, vnf_list, match_type="intersection"):
+    """Get a list of matching VNFs from the list of resources
+    :param resources:
+    :param vnf_list: List of vnfs to used in placement request
+    :param match_type: "intersection" or "all" or "any" (any => send all_vnfs if there is any intersection)
+    :return: List of matching VNFs
+    """
+    resources_lcase = [x.lower() for x in resources]
+    if match_type == "all":  # don't bother with any comparisons
+        return resources if set(resources_lcase) <= set(vnf_list) else None
+    common_vnfs = set(vnf_list) & set(resources_lcase)
+    common_resources = [x for x in resources if x.lower() in common_vnfs]
+    if match_type == "intersection":  # specifically requested intersection
+        return list(common_resources)
+    return resources if common_vnfs else None  # "any" match => all resources to be returned
+
+
+def gen_policy_instance(vnf_list, resource_policy, match_type="intersection", rtype=None):
+    """Generate a list of policies
+    :param vnf_list: List of vnf's to used in placement request
+    :param resource_policy: policy for this specific resource
+    :param match_type: How to match the vnf_names with the vnf_list (intersection or "any")
+             intersection => return intersection; "any" implies return all vnf_names if intersection is not null
+    :param rtype: resource type (e.g. resourceRegionProperty or resourceInstanceProperty)
+             None => no controller information added to the policy specification to Conductor
+    :return: resource policy list in a format required by Conductor
+    """
+    resource_policy_list = []
+    related_policies = []
+    for policy in resource_policy:
+        pc = policy['content']
+        demands = get_matching_vnfs(pc['resources'], vnf_list, match_type=match_type)
+        resource = {pc['identity']: {'type': pc['policyType'], 'demands': demands}}
+
+        if rtype:
+            resource[pc['identity']]['properties'] = {'controller': pc[rtype]['controller'],
+                                                      'request': json.loads(pc[rtype]['request'])}
+        if demands and len(demands) != 0:
+            resource_policy_list.append(resource)
+            related_policies.append(policy)
+    return resource_policy_list, related_policies
+
+
+def gen_resource_instance_policy(vnf_list, resource_instance_policy):
+    """Get policies governing resource instances in order to populate the Conductor API call"""
+    cur_policies, _ = gen_policy_instance(vnf_list, resource_instance_policy, rtype='resourceInstanceProperty')
+    return cur_policies
+
+
+def gen_resource_region_policy(vnf_list, resource_region_policy):
+    """Get policies governing resource region in order to populate the Conductor API call"""
+    cur_policies, _ = gen_policy_instance(vnf_list, resource_region_policy, rtype='resourceRegionProperty')
+    return cur_policies
+
+
+def gen_inventory_group_policy(vnf_list, inventory_group_policy):
+    """Get policies governing inventory group in order to populate the Conductor API call"""
+    cur_policies, _ = gen_policy_instance(vnf_list, inventory_group_policy, rtype=None)
+    return cur_policies
+
+
+def gen_reservation_policy(vnf_list, reservation_policy):
+    """Get policies governing resource instances in order to populate the Conductor API call"""
+    cur_policies, _ = gen_policy_instance(vnf_list, reservation_policy, rtype='instanceReservationProperty')
+    return cur_policies
+
+
+def gen_distance_to_location_policy(vnf_list, distance_to_location_policy):
+    """Get policies governing distance-to-location for VNFs in order to populate the Conductor API call"""
+    cur_policies, related_policies = gen_policy_instance(vnf_list, distance_to_location_policy, rtype=None)
+    for p_new, p_main in zip(cur_policies, related_policies):  # add additional fields to each policy
+        properties = p_main['content']['distanceProperties']
+        pcp_d = properties['distance']
+        p_new[p_main['content']['identity']]['properties'] = {
+            'distance': pcp_d['operator'] + " " + pcp_d['value'].lower() + " " + pcp_d['unit'].lower(),
+            'location': properties['locationInfo']
+        }
+    return cur_policies
+
+
+def gen_attribute_policy(vnf_list, attribute_policy):
+    """Get policies governing attributes of VNFs in order to populate the Conductor API call"""
+    cur_policies, related_policies = gen_policy_instance(vnf_list, attribute_policy, rtype=None)
+    for p_new, p_main in zip(cur_policies, related_policies):  # add additional fields to each policy
+        properties = p_main['content']['cloudAttributeProperty']
+        attribute_mapping = policy_config_mapping['attributes']  # wanted attributes and mapping
+        p_new[p_main['content']['identity']]['properties'] = {
+            'evaluate': dict((k, properties.get(attribute_mapping.get(k))) for k in attribute_mapping.keys())
+        }
+    return cur_policies  # cur_policies gets updated in place...
+
+
+def gen_zone_policy(vnf_list, zone_policy):
+    """Get zone policies in order to populate the Conductor API call"""
+    cur_policies, related_policies = gen_policy_instance(vnf_list, zone_policy, match_type="all", rtype=None)
+    for p_new, p_main in zip(cur_policies, related_policies):  # add additional fields to each policy
+        pmz = p_main['content']['affinityProperty']
+        p_new[p_main['content']['identity']]['properties'] = {'category': pmz['category'], 'qualifier': pmz['qualifier']}
+    return cur_policies
+
+
+def gen_capacity_policy(vnf_list, capacity_policy):
+    """Get zone policies in order to populate the Conductor API call"""
+    cur_policies, related_policies = gen_policy_instance(vnf_list, capacity_policy, rtype=None)
+    for p_new, p_main in zip(cur_policies, related_policies):  # add additional fields to each policy
+        pmz = p_main['content']['capacityProperty']
+        p_new[p_main['content']['identity']]['properties'] = \
+            {"controller": pmz['controller'], 'request': json.loads(pmz['request'])}
+    return cur_policies
+
+
+def gen_hpa_policy(vnf_list, hpa_policy):
+    """Get zone policies in order to populate the Conductor API call"""
+    cur_policies, related_policies = gen_policy_instance(vnf_list, hpa_policy, rtype=None)
+    for p_new, p_main in zip(cur_policies, related_policies):  # add additional fields to each policy
+        p_new[p_main['content']['identity']]['properties'] = {'evaluate': p_main['content']['flavorFeatures']}
+    return cur_policies
+
+
+def get_augmented_policy_attributes(policy_property, demand):
+    """Get policy attributes and augment them using policy_config_mapping and demand information"""
+    attributes = copy.copy(policy_property['attributes'])
+    remapping = policy_config_mapping['remapping']
+    extra = dict((x, demand['resourceModelInfo'][remapping[x]]) for x in attributes if x in remapping)
+    attributes.update(extra)
+    return attributes
+
+
+def get_candidates_demands(demand):
+    """Get demands related to candidates; e.g. excluded/required"""
+    res = {}
+    for k, v in policy_config_mapping['candidates'].items():
+        if k not in demand:
+            continue
+        res[v] = [{'inventory_type': x['identifierType'], 'candidate_id': x['identifiers']} for x in demand[k]]
+    return res
+
+
+def get_policy_properties(demand, policies):
+    """Get policy_properties for cases where there is a match with the demand"""
+    for policy in policies:
+        policy_demands = set([x.lower() for x in policy['content'].get('resources', [])])
+        if demand['resourceModuleName'].lower() not in policy_demands:
+            continue  # no match for this policy
+        for policy_property in policy['content']['vnfProperties']:
+            yield policy_property
+
+
+def get_demand_properties(demand, policies):
+    """Get list demand properties objects (named tuples) from policy"""
+    demand_properties = []
+    for policy_property in get_policy_properties(demand, policies):
+        prop = dict(inventory_provider=policy_property['inventoryProvider'],
+                    inventory_type=policy_property['inventoryType'],
+                    service_type=demand['serviceResourceId'],
+                    service_resource_id=demand['serviceResourceId'])
+
+        prop.update({'unique': policy_property['unique']} if 'unique' in policy_property and
+                                                             policy_property['unique'] else {})
+        prop['attributes'] = dict()
+        prop['attributes'].update({'global-customer-id': policy_property['customerId']}
+                                  if policy_property['customerId'] else {})
+        prop['attributes'].update({'model-invariant-id': demand['resourceModelInfo']['modelInvariantId']}
+                                  if demand['resourceModelInfo']['modelInvariantId'] else {})
+        prop['attributes'].update({'model-version-id': demand['resourceModelInfo']['modelVersionId']}
+                                  if demand['resourceModelInfo']['modelVersionId'] else {})
+        prop['attributes'].update({'equipment-role': policy_property['equipmentRole']}
+                                  if policy_property['equipmentRole'] else {})
+
+        if policy_property.get('attributes'):
+            for attr_key, attr_val in policy_property['attributes'].items():
+                update_converted_attribute(attr_key, attr_val, prop)
+
+        prop.update(get_candidates_demands(demand))
+        demand_properties.append(prop)
+    return demand_properties
+
+
+def update_converted_attribute(attr_key, attr_val, properties):
+    """
+    Updates dictonary of attributes with one specified in the arguments.
+    Automatically translates key namr from camelCase to hyphens
+    :param attr_key: key of the attribute
+    :param attr_val: value of the attribute
+    :param properties: dictionary with attributes to update
+    :return:
+    """
+    if attr_val:
+        remapping = policy_config_mapping['attributes']
+        if remapping.get(attr_key):
+            key_value = remapping.get(attr_key)
+        else:
+            key_value = re.sub('(.)([A-Z][a-z]+)', r'\1-\2', attr_key)
+            key_value = re.sub('([a-z0-9])([A-Z])', r'\1-\2', key_value).lower()
+        properties['attributes'].update({key_value: attr_val})
+
+
+def gen_demands(req_json, vnf_policies):
+    """Generate list of demands based on request and VNF policies
+    :param req_json: Request object from the client (e.g. MSO)
+    :param vnf_policies: Policies associated with demand resources (e.g. from grouped_policies['vnfPolicy'])
+    :return: list of demand parameters to populate the Conductor API call
+    """
+    demand_dictionary = {}
+    for demand in req_json['placementInfo']['placementDemands']:
+        prop = get_demand_properties(demand, vnf_policies)
+        if len(prop) > 0:
+            demand_dictionary.update({demand['resourceModuleName']: prop})
+    return demand_dictionary