# # ------------------------------------------------------------------------- # Copyright (c) 2015-2017 AT&T Intellectual Property # Copyright (C) 2020 Wipro Limited. # # 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 datetime import json import os import uuid import six import yaml from conductor import __file__ as conductor_root from conductor import messaging from conductor import service from conductor.common import threshold from conductor.common.music import messaging as music_messaging from conductor.data.plugins.triage_translator.triage_translator_data import TraigeTranslatorData from conductor.data.plugins.triage_translator.triage_translator import TraigeTranslator from oslo_config import cfg from oslo_log import log LOG = log.getLogger(__name__) CONF = cfg.CONF VERSIONS = ["2016-11-01", "2017-10-10", "2018-02-01"] LOCATION_KEYS = ['latitude', 'longitude', 'host_name', 'clli_code'] INVENTORY_PROVIDERS = ['aai'] INVENTORY_TYPES = ['cloud', 'service', 'transport', 'vfmodule', 'nssi'] DEFAULT_INVENTORY_PROVIDER = INVENTORY_PROVIDERS[0] CANDIDATE_KEYS = ['candidate_id', 'cost', 'inventory_type', 'location_id', 'location_type'] DEMAND_KEYS = ['filtering_attributes', 'passthrough_attributes', 'candidates', 'complex', 'conflict_identifier', 'customer_id', 'default_cost', 'excluded_candidates', 'existing_placement', 'flavor', 'inventory_provider', 'inventory_type', 'port_key', 'region', 'required_candidates', 'service_id', 'service_resource_id', 'service_subscription', 'service_type', 'subdivision', 'unique', 'vlan_key'] CONSTRAINT_KEYS = ['type', 'demands', 'properties'] CONSTRAINTS = { # constraint_type: { # split: split into individual constraints, one per demand # required: list of required property names, # optional: list of optional property names, # thresholds: dict of property/base-unit pairs for threshold parsing # allowed: dict of keys and allowed values (if controlled vocab); # only use this for Conductor-controlled values! # } 'attribute': { 'split': True, 'required': ['evaluate'], }, 'threshold': { 'split': True, 'required': ['attribute', 'threshold', 'operator'], 'optional': ['unit'] }, 'distance_between_demands': { 'required': ['distance'], 'thresholds': { 'distance': 'distance' }, }, 'distance_to_location': { 'split': True, 'required': ['distance', 'location'], 'thresholds': { 'distance': 'distance' }, }, 'instance_fit': { 'split': True, 'required': ['controller'], 'optional': ['request'], }, 'inventory_group': {}, 'region_fit': { 'split': True, 'required': ['controller'], 'optional': ['request'], }, 'zone': { 'required': ['qualifier', 'category'], 'optional': ['location'], 'allowed': {'qualifier': ['same', 'different'], 'category': ['disaster', 'region', 'complex', 'country', 'time', 'maintenance']}, }, 'vim_fit': { 'split': True, 'required': ['controller'], 'optional': ['request'], }, 'hpa': { 'split': True, 'required': ['evaluate'], }, } HPA_FEATURES = ['architecture', 'hpa-feature', 'hpa-feature-attributes', 'hpa-version', 'mandatory', 'directives'] HPA_OPTIONAL = ['score'] HPA_ATTRIBUTES = ['hpa-attribute-key', 'hpa-attribute-value', 'operator'] HPA_ATTRIBUTES_OPTIONAL = ['unit'] class TranslatorException(Exception): pass class Translator(object): """Template translator. Takes an input template and translates it into something the solver can use. Calls the data service as needed, giving it the inventory provider as context. Presently the only inventory provider is A&AI. Others may be added in the future. """ def __init__(self, conf, plan_name, plan_id, template): self.conf = conf self._template = copy.deepcopy(template) self._plan_name = plan_name self._plan_id = plan_id self._translation = None self._valid = False self._ok = False self.triageTranslatorData= TraigeTranslatorData() self.triageTranslator = TraigeTranslator() # Set up the RPC service(s) we want to talk to. self.data_service = self.setup_rpc(self.conf, "data") def setup_rpc(self, conf, topic): """Set up the RPC Client""" # TODO(jdandrea): Put this pattern inside music_messaging? transport = messaging.get_transport(conf=conf) target = music_messaging.Target(topic=topic) client = music_messaging.RPCClient(conf=conf, transport=transport, target=target) return client def create_components(self): # TODO(jdandrea): Make deep copies so the template is untouched self._version = self._template.get("homing_template_version") self._parameters = self._template.get("parameters", {}) self._locations = self._template.get("locations", {}) self._demands = self._template.get("demands", {}) self._constraints = self._template.get("constraints", {}) self._optmization = self._template.get("optimization", {}) self._reservations = self._template.get("reservation", {}) if isinstance(self._version, datetime.date): self._version = str(self._version) def validate_components(self): """Cursory validation of template components. More detailed validation happens while parsing each component. """ self._valid = False # Check version if self._version not in VERSIONS: raise TranslatorException( "conductor_template_version must be one " "of: {}".format(', '.join(VERSIONS))) # Check top level structure components = { "parameters": { "name": "Parameter", "content": self._parameters, }, "locations": { "name": "Location", "keys": LOCATION_KEYS, "content": self._locations, }, "demands": { "name": "Demand", "content": self._demands, }, "constraints": { "name": "Constraint", "keys": CONSTRAINT_KEYS, "content": self._constraints, }, "optimization": { "name": "Optimization", "content": self._optmization, }, "reservations": { "name": "Reservation", "content": self._reservations, } } for name, component in components.items(): name = component.get('name') keys = component.get('keys', None) content = component.get('content') if type(content) is not dict: raise TranslatorException( "{} section must be a dictionary".format(name)) for content_name, content_def in content.items(): if not keys: continue for key in content_def: if key not in keys: raise TranslatorException( "{} {} has an invalid key {}".format( name, content_name, key)) demand_keys = list(self._demands.keys()) # Python 3 Conversion -- dict object to list object location_keys = list(self._locations.keys()) # Python 3 Conversion -- dict object to list object for constraint_name, constraint in self._constraints.items(): # Require a single demand (string), or a list of one or more. demands = constraint.get('demands') if isinstance(demands, six.string_types): demands = [demands] if not isinstance(demands, list) or len(demands) < 1: raise TranslatorException( "Demand list for Constraint {} must be " "a list of names or a string with one name".format( constraint_name)) if not set(demands).issubset(demand_keys + location_keys): raise TranslatorException( "Undefined Demand(s) {} in Constraint '{}'".format( list(set(demands).difference(demand_keys)), constraint_name)) properties = constraint.get('properties', None) if properties: location = properties.get('location', None) if location: if location not in location_keys: raise TranslatorException( "Location {} in Constraint {} is undefined".format( location, constraint_name)) self._valid = True def _parse_parameters(self, obj, path=[]): """Recursively parse all {get_param: X} occurrences This modifies obj in-place. If you want to keep the original, pass in a deep copy. """ # Ok to start with a string ... if isinstance(path, six.string_types): # ... but the breadcrumb trail goes in an array. path = [path] # Traverse a list if type(obj) is list: for idx, val in enumerate(obj, start=0): # Add path to the breadcrumb trail new_path = list(path) new_path[-1] += "[{}]".format(idx) # Look at each element. obj[idx] = self._parse_parameters(val, new_path) # Traverse a dict elif type(obj) is dict: # Did we find a "{get_param: ...}" intrinsic? if list(obj.keys()) == ['get_param']: param_name = obj['get_param'] # The parameter name must be a string. if not isinstance(param_name, six.string_types): path_str = ' > '.join(path) raise TranslatorException( "Parameter name '{}' not a string in path {}".format( param_name, path_str)) # Parameter name must be defined. if param_name not in self._parameters: path_str = ' > '.join(path) raise TranslatorException( "Parameter '{}' undefined in path {}".format( param_name, path_str)) # Return the value in place of the call. return self._parameters.get(param_name) # Not an intrinsic. Traverse as usual. for key in list(obj.keys()): # Add path to the breadcrumb trail. new_path = list(path) new_path.append(key) # Look at each key/value pair. obj[key] = self._parse_parameters(obj[key], new_path) # Return whatever we have after unwinding. return obj def parse_parameters(self): """Resolve all parameters references.""" locations = copy.deepcopy(self._locations) self._locations = self._parse_parameters(locations, 'locations') demands = copy.deepcopy(self._demands) self._demands = self._parse_parameters(demands, 'demands') constraints = copy.deepcopy(self._constraints) self._constraints = self._parse_parameters(constraints, 'constraints') reservations = copy.deepcopy(self._reservations) self._reservations = self._parse_parameters(reservations, 'reservations') def parse_locations(self, locations): """Prepare the locations for use by the solver.""" parsed = {} for location, args in locations.items(): ctxt = { 'plan_id': self._plan_id, 'keyspace': self.conf.keyspace } latitude = args.get("latitude") longitude = args.get("longitude") if latitude and longitude: resolved_location = {"latitude": latitude, "longitude": longitude} else: # ctxt = {} response = self.data_service.call( ctxt=ctxt, method="resolve_location", args=args) resolved_location = \ response and response.get('resolved_location') if not resolved_location: raise TranslatorException( "Unable to resolve location {}".format(location) ) parsed[location] = resolved_location return parsed def parse_demands(self, demands): """Validate/prepare demands for use by the solver.""" if type(demands) is not dict: raise TranslatorException("Demands must be provided in " "dictionary form") # Look at each demand demands_copy = copy.deepcopy(demands) parsed = {} for name, requirements in demands_copy.items(): inventory_candidates = [] for requirement in requirements: for key in requirement: if key not in DEMAND_KEYS: raise TranslatorException( "Demand {} has an invalid key {}".format( requirement, key)) if 'candidates' in requirement: # Candidates *must* specify an inventory provider provider = requirement.get("inventory_provider") if provider and provider not in INVENTORY_PROVIDERS: raise TranslatorException( "Unsupported inventory provider {} " "in demand {}".format(provider, name)) else: provider = DEFAULT_INVENTORY_PROVIDER # Check each candidate for candidate in requirement.get('candidates'): # Must be a dictionary if type(candidate) is not dict: raise TranslatorException( "Candidate found in demand {} that is " "not a dictionary".format(name)) # Must have only supported keys for key in list(candidate.keys()): if key not in CANDIDATE_KEYS: raise TranslatorException( "Candidate with invalid key {} found " "in demand {}".format(key, name) ) # TODO(jdandrea): Check required/optional keys # Set the inventory provider if not already candidate['inventory_provider'] = \ candidate.get('inventory_provider', provider) # Set cost if not already (default cost is 0?) candidate['cost'] = candidate.get('cost', 0) # Add to our list of parsed candidates inventory_candidates.append(candidate) # candidates are specified through inventory providers # Do the basic sanity checks for inputs else: # inventory provider MUST be specified provider = requirement.get("inventory_provider") if not provider: raise TranslatorException( "Inventory provider not specified " "in demand {}".format(name) ) elif provider and provider not in INVENTORY_PROVIDERS: raise TranslatorException( "Unsupported inventory provider {} " "in demand {}".format(provider, name) ) else: provider = DEFAULT_INVENTORY_PROVIDER requirement['provider'] = provider # inventory type MUST be specified inventory_type = requirement.get('inventory_type') if not inventory_type or inventory_type == '': raise TranslatorException( "Inventory type not specified for " "demand {}".format(name) ) if inventory_type and \ inventory_type not in INVENTORY_TYPES: raise TranslatorException( "Unknown inventory type {} specified for " "demand {}".format(inventory_type, name) ) # For service and vfmodule inventories, customer_id and # service_type MUST be specified if inventory_type == 'service' or inventory_type == 'vfmodule': filtering_attributes = requirement.get('filtering_attributes') if filtering_attributes: customer_id = filtering_attributes.get('customer-id') global_customer_id = filtering_attributes.get('global-customer-id') if global_customer_id: customer_id = global_customer_id else: # for backward compatibility customer_id = requirement.get('customer_id') service_type = requirement.get('service_type') if not customer_id: raise TranslatorException( "Customer ID not specified for " "demand {}".format(name) ) if not filtering_attributes and not service_type: raise TranslatorException( "Service Type not specified for " "demand {}".format(name) ) # TODO(jdandrea): Check required/optional keys for requirement # elif 'inventory_type' in requirement: # # For now this is just a stand-in candidate # candidate = { # 'inventory_provider': # requirement.get('inventory_provider', # DEFAULT_INVENTORY_PROVIDER), # 'inventory_type': # requirement.get('inventory_type', ''), # 'candidate_id': '', # 'location_id': '', # 'location_type': '', # 'cost': 0, # } # # # Add to our list of parsed candidates # inventory_candidates.append(candidate) # Ask conductor-data for one or more candidates. ctxt = { "plan_id": self._plan_id, "plan_name": self._plan_name, "keyspace": self.conf.keyspace, } args = { "demands": { name: requirements, }, "plan_info":{ "plan_id": self._plan_id, "plan_name": self._plan_name }, "triage_translator_data": self.triageTranslatorData.__dict__ } # Check if required_candidate and excluded candidate # are mutually exclusive. for requirement in requirements: required_candidates = requirement.get("required_candidates") excluded_candidates = requirement.get("excluded_candidates") if (required_candidates and excluded_candidates and set(map(lambda entry: entry['candidate_id'], required_candidates)) & set(map(lambda entry: entry['candidate_id'], excluded_candidates))): raise TranslatorException( "Required candidate list and excluded candidate" " list are not mutually exclusive for demand" " {}".format(name) ) response = self.data_service.call( ctxt=ctxt, method="resolve_demands", args=args) resolved_demands = \ response and response.get('resolved_demands') triage_data_trans = \ response and response.get('trans') required_candidates = resolved_demands \ .get('required_candidates') if not resolved_demands: self.triageTranslator.thefinalCallTrans(triage_data_trans) raise TranslatorException( "Unable to resolve inventory " "candidates for demand {}" .format(name) ) resolved_candidates = resolved_demands.get(name) for candidate in resolved_candidates: inventory_candidates.append(candidate) if len(inventory_candidates) < 1: if not required_candidates: self.triageTranslator.thefinalCallTrans(triage_data_trans) raise TranslatorException( "Unable to find any candidate for " "demand {}".format(name) ) else: self.triageTranslator.thefinalCallTrans(triage_data_trans) raise TranslatorException( "Unable to find any required " "candidate for demand {}" .format(name) ) parsed[name] = { "candidates": inventory_candidates, } self.triageTranslator.thefinalCallTrans(triage_data_trans) return parsed def validate_hpa_constraints(self, req_prop, value): for para in value.get(req_prop): # Make sure there is at least one # set of id, type, directives and flavorProperties if not para.get('id') \ or not para.get('type') \ or not para.get('directives') \ or not para.get('flavorProperties') \ or para.get('id') == '' \ or para.get('type') == '' \ or not isinstance(para.get('directives'), list) \ or para.get('flavorProperties') == '': raise TranslatorException( "HPA requirements need at least " "one set of id, type, directives and flavorProperties" ) for feature in para.get('flavorProperties'): if type(feature) is not dict: raise TranslatorException("HPA feature must be a dict") # process mandatory parameter hpa_mandatory = set(HPA_FEATURES).difference(feature.keys()) if bool(hpa_mandatory): raise TranslatorException( "Lack of compulsory elements inside HPA feature") # process optional parameter hpa_optional = set(feature.keys()).difference(HPA_FEATURES) if hpa_optional and not hpa_optional.issubset(HPA_OPTIONAL): raise TranslatorException( "Got unrecognized elements inside HPA feature") if feature.get('mandatory') == 'False' and not feature.get( 'score'): raise TranslatorException( "Score needs to be present if mandatory is False") for attr in feature.get('hpa-feature-attributes'): if type(attr) is not dict: raise TranslatorException( "HPA feature attributes must be a dict") # process mandatory hpa attribute parameter hpa_attr_mandatory = set(HPA_ATTRIBUTES).difference( attr.keys()) if bool(hpa_attr_mandatory): raise TranslatorException( "Lack of compulsory elements inside HPA " "feature attributes") # process optional hpa attribute parameter hpa_attr_optional = set(attr.keys()).difference( HPA_ATTRIBUTES) if hpa_attr_optional and not hpa_attr_optional.issubset( HPA_ATTRIBUTES_OPTIONAL): raise TranslatorException( "Invalid attributes '{}' found inside HPA " "feature attributes".format(hpa_attr_optional)) def parse_constraints(self, constraints): """Validate/prepare constraints for use by the solver.""" if not isinstance(constraints, dict): raise TranslatorException("Constraints must be provided in " "dictionary form") # Look at each constraint. Properties must exist, even if empty. constraints_copy = copy.deepcopy(constraints) parsed = {} for name, constraint in constraints_copy.items(): if not constraint.get('properties'): constraint['properties'] = {} constraint_type = constraint.get('type') constraint_def = CONSTRAINTS.get(constraint_type) # Is it a supported type? if constraint_type not in CONSTRAINTS: raise TranslatorException( "Unsupported type '{}' found in constraint " "named '{}'".format(constraint_type, name)) # Now walk through the constraint's content for key, value in constraint.items(): # Must be a supported key if key not in CONSTRAINT_KEYS: raise TranslatorException( "Invalid key '{}' found in constraint " "named '{}'".format(key, name)) # For properties ... if key == 'properties': # Make sure all required properties are present required = constraint_def.get('required', []) for req_prop in required: if req_prop not in list(value.keys()): raise TranslatorException( "Required property '{}' not found in " "constraint named '{}'".format( req_prop, name)) if not value.get(req_prop) \ or value.get(req_prop) == '': raise TranslatorException( "No value specified for property '{}' in " "constraint named '{}'".format( req_prop, name)) # For HPA constraints if constraint_type == 'hpa': self.validate_hpa_constraints(req_prop, value) # Make sure there are no unknown properties optional = constraint_def.get('optional', []) for prop_name in list(value.keys()): if prop_name not in required + optional: raise TranslatorException( "Unknown property '{}' in " "constraint named '{}'".format( prop_name, name)) # If a property has a controlled vocabulary, make # sure its value is one of the allowed ones. allowed = constraint_def.get('allowed', {}) for prop_name, allowed_values in allowed.items(): if prop_name in list(value.keys()): prop_value = value.get(prop_name, '') if prop_value not in allowed_values: raise TranslatorException( "Property '{}' value '{}' unsupported in " "constraint named '{}' (must be one of " "{})".format(prop_name, prop_value, name, allowed_values)) # Break all threshold-formatted values into parts thresholds = constraint_def.get('thresholds', {}) for thr_prop, base_units in thresholds.items(): if thr_prop in list(value.keys()): expression = value.get(thr_prop) thr = threshold.Threshold(expression, base_units) value[thr_prop] = thr.parts # We already know we have one or more demands due to # validate_components(). We still need to coerce the demands # into a list in case only one demand was provided. constraint_demands = constraint.get('demands') if isinstance(constraint_demands, six.string_types): constraint['demands'] = [constraint_demands] # Either split the constraint into parts, one per demand, # or use it as-is if constraint_def.get('split'): for demand in constraint.get('demands', []): constraint_demand = name + '_' + demand parsed[constraint_demand] = copy.deepcopy(constraint) parsed[constraint_demand]['name'] = name parsed[constraint_demand]['demands'] = demand else: parsed[name] = copy.deepcopy(constraint) parsed[name]['name'] = name return parsed def parse_optimization(self, optimization): """Validate/prepare optimization for use by the solver.""" # WARNING: The template format for optimization is generalized, # however the solver is very particular about the expected # goal, functions, and operands. Therefore, for the time being, # we are choosing to be highly conservative in what we accept # at the template level. Once the solver can handle the more # general form, we can make the translation pass in this # essentially pre-parsed formula unchanged, or we may allow # optimizations to be written in algebraic form and pre-parsed # with antlr4-python2-runtime. (jdandrea 1 Dec 2016) if not optimization: LOG.debug("No objective function or " "optimzation provided in the template") return optimization_copy = copy.deepcopy(optimization) parsed = { "goal": "min", "operation": "sum", "operands": [], } if type(optimization_copy) is not dict: raise TranslatorException("Optimization must be a dictionary.") goals = list(optimization_copy.keys()) if goals != ['minimize']: raise TranslatorException( "Optimization must contain a single goal of 'minimize'.") funcs = list(optimization_copy['minimize'].keys()) if funcs != ['sum']: raise TranslatorException( "Optimization goal 'minimize' must " "contain a single function of 'sum'.") operands = optimization_copy['minimize']['sum'] if type(operands) is not list: # or len(operands) != 2: raise TranslatorException( "Optimization goal 'minimize', function 'sum' " "must be a list of exactly two operands.") def get_latency_between_args(operand): args = operand.get('latency_between') if type(args) is not list and len(args) != 2: raise TranslatorException( "Optimization 'latency_between' arguments must " "be a list of length two.") got_demand = False got_location = False for arg in args: if not got_demand and arg in list(self._demands.keys()): got_demand = True if not got_location and arg in list(self._locations.keys()): got_location = True if not got_demand or not got_location: raise TranslatorException( "Optimization 'latency_between' arguments {} must " "include one valid demand name and one valid " "location name.".format(args)) return args def get_distance_between_args(operand): args = operand.get('distance_between') if type(args) is not list and len(args) != 2: raise TranslatorException( "Optimization 'distance_between' arguments must " "be a list of length two.") got_demand = False got_location = False for arg in args: if not got_demand and arg in list(self._demands.keys()): got_demand = True if not got_location and arg in list(self._locations.keys()): got_location = True if not got_demand or not got_location: raise TranslatorException( "Optimization 'distance_between' arguments {} must " "include one valid demand name and one valid " "location name.".format(args)) return args for operand in operands: weight = 1.0 args = None nested = False if list(operand.keys()) == ['distance_between']: # Value must be a list of length 2 with one # location and one demand function = 'distance_between' args = get_distance_between_args(operand) elif list(operand.keys()) == ['product']: for product_op in operand['product']: if threshold.is_number(product_op): weight = product_op elif isinstance(product_op, dict): if list(product_op.keys()) == ['latency_between']: function = 'latency_between' args = get_latency_between_args(product_op) elif list(product_op.keys()) == ['distance_between']: function = 'distance_between' args = get_distance_between_args(product_op) elif list(product_op.keys()) == ['aic_version']: function = 'aic_version' args = product_op.get('aic_version') elif list(product_op.keys()) == ['hpa_score']: function = 'hpa_score' args = product_op.get('hpa_score') if not self.is_hpa_policy_exists(args): raise TranslatorException( "HPA Score Optimization must include a " "HPA Policy constraint ") elif list(product_op.keys()) == ['sum']: nested = True nested_operands = product_op.get('sum') for nested_operand in nested_operands: if list(nested_operand.keys()) == ['product']: nested_weight = weight for nested_product_op in nested_operand['product']: if threshold.is_number(nested_product_op): nested_weight = nested_weight * int(nested_product_op) elif isinstance(nested_product_op, dict): if list(nested_product_op.keys()) == ['latency_between']: function = 'latency_between' args = get_latency_between_args(nested_product_op) elif list(nested_product_op.keys()) == ['distance_between']: function = 'distance_between' args = get_distance_between_args(nested_product_op) parsed['operands'].append( { "operation": "product", "weight": nested_weight, "function": function, "function_param": args, } ) if not args: raise TranslatorException( "Optimization products must include at least " "one 'distance_between' function call and " "one optional number to be used as a weight.") # We now have our weight/function_param. if not nested: parsed['operands'].append( { "operation": "product", "weight": weight, "function": function, "function_param": args, } ) return parsed def is_hpa_policy_exists(self, demand_list): # Check if a HPA constraint exist for the demands in the demand list. constraints_copy = copy.deepcopy(self._constraints) for demand in demand_list: for name, constraint in constraints_copy.items(): constraint_type = constraint.get('type') if constraint_type == 'hpa': hpa_demands = constraint.get('demands') if demand in hpa_demands: return True return False def parse_reservations(self, reservations): demands = self._demands if not isinstance(reservations, dict): raise TranslatorException("Reservations must be provided in " "dictionary form") parsed = {} if reservations: parsed['counter'] = 0 parsed['demands'] = {} for key, value in reservations.items(): if key == "service_model": parsed['service_model'] = value elif key == "service_candidates": for name, reservation_details in value.items(): if not reservation_details.get('properties'): reservation_details['properties'] = {} for demand in reservation_details.get('demands', []): if demand in list(demands.keys()): reservation_demand = name + '_' + demand parsed['demands'][reservation_demand] = copy.deepcopy(reservation_details) parsed['demands'][reservation_demand]['name'] = name parsed['demands'][reservation_demand]['demands'] = demand else: raise TranslatorException("Demand {} must be provided in demands section".format(demand)) return parsed def do_translation(self): """Perform the translation.""" if not self.valid: raise TranslatorException("Can't translate an invalid template.") request_type = self._parameters.get("request_type") \ or self._parameters.get("REQUEST_TYPE") \ or "" self._translation = { "conductor_solver": { "version": self._version, "plan_id": self._plan_id, "request_type": request_type, "locations": self.parse_locations(self._locations), "demands": self.parse_demands(self._demands), "objective": self.parse_optimization(self._optmization), "constraints": self.parse_constraints(self._constraints), "objective": self.parse_optimization(self._optmization), "reservations": self.parse_reservations(self._reservations), } } def translate(self): """Translate the template for the solver.""" self._ok = False try: self.create_components() self.validate_components() self.parse_parameters() self.do_translation() self._ok = True except Exception as exc: self._error_message = exc.args @property def valid(self): """Returns True if the template has been validated.""" return self._valid @property def ok(self): """Returns True if the translation was successful.""" return self._ok @property def translation(self): """Returns the translation if it was successful.""" return self._translation @property def error_message(self): """Returns the last known error message.""" return self._error_message def main(): template_name = 'some_template' path = os.path.abspath(conductor_root) dir_path = os.path.dirname(path) # Prepare service-wide components (e.g., config) conf = service.prepare_service( [], config_files=[dir_path + '/../etc/conductor/conductor.conf']) # conf.set_override('mock', True, 'music_api') t1 = threshold.Threshold("< 500 ms", "time") t2 = threshold.Threshold("= 120 mi", "distance") t3 = threshold.Threshold("160", "currency") t4 = threshold.Threshold("60-80 Gbps", "throughput") print('t1: {}\nt2: {}\nt3: {}\nt4: {}\n'.format(t1, t2, t3, t4)) template_file = dir_path + '/tests/data/' + template_name + '.yaml' fd = open(template_file, "r") template = yaml.load(fd) trns = Translator(conf, template_name, str(uuid.uuid4()), template) trns.translate() if trns.ok: print(json.dumps(trns.translation, indent=2)) else: print("TESTING - Translator Error: {}".format(trns.error_message)) if __name__ == '__main__': main()