2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation;
23 import org.apache.commons.collections4.MapUtils;
24 import org.openecomp.sdc.common.errors.CoreException;
25 import org.openecomp.sdc.common.errors.ErrorCategory;
26 import org.openecomp.sdc.common.errors.ErrorCode;
27 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
28 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
29 import org.openecomp.sdc.heat.datatypes.model.Resource;
30 import org.openecomp.sdc.logging.api.Logger;
31 import org.openecomp.sdc.logging.api.LoggerFactory;
32 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
33 import org.onap.sdc.tosca.datatypes.model.NodeType;
34 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
35 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
36 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
37 import org.openecomp.sdc.tosca.services.DataModelUtil;
38 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
39 import org.onap.sdc.tosca.services.YamlUtil;
40 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
41 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
42 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
43 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
44 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
45 import org.openecomp.sdc.translator.services.heattotosca.errors.TranslatorErrorCodes;
47 import java.util.ArrayList;
48 import java.util.List;
50 import java.util.Objects;
51 import java.util.Optional;
52 import java.util.function.Predicate;
54 abstract class BaseResourceConnection<T> {
55 protected static Logger logger = LoggerFactory.getLogger(BaseResourceConnection.class);
56 protected TranslateTo translateTo;
57 FileData nestedFileData;
58 NodeTemplate substitutionNodeTemplate;
60 ResourceTranslationBase resourceTranslationBase;
62 BaseResourceConnection(ResourceTranslationBase resourceTranslationBase, TranslateTo translateTo,
63 FileData nestedFileData, NodeTemplate substitutionNodeTemplate,
65 this.translateTo = translateTo;
66 this.nestedFileData = nestedFileData;
67 this.substitutionNodeTemplate = substitutionNodeTemplate;
68 this.nodeType = nodeType;
69 this.resourceTranslationBase = resourceTranslationBase;
72 abstract boolean isDesiredNodeTemplateType(NodeTemplate nodeTemplate);
74 abstract List<Predicate<T>> getPredicatesListForConnectionPoints();
76 abstract Optional<List<String>> getConnectorPropertyParamName(String heatResourceId,
77 Resource heatResource,
78 HeatOrchestrationTemplate
79 nestedHeatOrchestrationTemplate,
80 String nestedHeatFileName);
82 abstract String getDesiredResourceType();
84 abstract String getMappedNodeTranslatedResourceId(ServiceTemplate nestedServiceTemplate,
85 Map.Entry<String, T> connectionPointEntry);
87 abstract Map.Entry<String, T> getMappedConnectionPointEntry(ServiceTemplate nestedServiceTemplate,
89 connectionPointEntry);
91 abstract void addRequirementToConnectResources(Map.Entry<String, T> connectionPointEntry,
92 List<String> paramNames);
94 abstract List<Map<String, T>> getAllConnectionPoints();
96 abstract boolean validateResourceTypeSupportedForReqCreation(String nestedResourceId,
97 final String nestedPropertyName,
98 String connectionPointId,
99 Resource connectedResource,
100 List<String> supportedTypes);
103 ServiceTemplate nestedServiceTemplate = translateTo.getContext().getTranslatedServiceTemplates()
104 .get(translateTo.getResource().getType());
105 List<String> paramNames;
106 HeatOrchestrationTemplate nestedHeatOrchestrationTemplate = new YamlUtil()
107 .yamlToObject(translateTo.getContext().getFileContent(nestedFileData.getFile()),
108 HeatOrchestrationTemplate.class);
109 List<Map<String, T>> exposedConnectionPoints = getAllConnectionPoints();
110 for (Map<String, T> connectionPointsMap : exposedConnectionPoints) {
111 for (Map.Entry<String, T> connectionPointEntry : connectionPointsMap.entrySet()) {
113 getConnectionParameterName(nestedServiceTemplate, nestedHeatOrchestrationTemplate,
114 nestedFileData.getFile(), connectionPointEntry);
115 if (paramNames != null && !paramNames.isEmpty()) {
116 addRequirementToConnectResources(connectionPointEntry, paramNames);
122 private List<String> getConnectionParameterName(ServiceTemplate nestedServiceTemplate,
123 HeatOrchestrationTemplate
124 nestedHeatOrchestrationTemplate,
125 String nestedHeatFileName,
126 Map.Entry<String, T> connectionPointEntry) {
127 List<String> connectionParameterNameList = new ArrayList<>();
128 String mappedTranslatedResourceId =
129 getMappedNodeTranslatedResourceId(nestedServiceTemplate, connectionPointEntry);
130 NodeTemplate mappedNodeTemplate =
131 nestedServiceTemplate.getTopology_template().getNode_templates()
132 .get(mappedTranslatedResourceId);
133 if (isDesiredNodeTemplateType(mappedNodeTemplate)) {
134 return getResourcesConnectionParameterName(mappedTranslatedResourceId,
135 nestedHeatOrchestrationTemplate, nestedHeatFileName);
138 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
139 if (toscaAnalyzerService.isSubstitutableNodeTemplate(mappedNodeTemplate)) {
140 Optional<String> mappedSubstituteServiceTemplateName = toscaAnalyzerService
141 .getSubstituteServiceTemplateName(mappedTranslatedResourceId, mappedNodeTemplate);
142 if (mappedSubstituteServiceTemplateName.isPresent()) {
143 String mappedNestedHeatFileName = translateTo.getContext().getNestedHeatFileName()
144 .get(mappedSubstituteServiceTemplateName.get());
145 if (Objects.isNull(mappedNestedHeatFileName)) {
148 HeatOrchestrationTemplate mappedNestedHeatOrchestrationTemplate = new YamlUtil()
149 .yamlToObject(translateTo.getContext().getFileContent(mappedNestedHeatFileName),
150 HeatOrchestrationTemplate.class);
151 ServiceTemplate mappedNestedServiceTemplate =
152 translateTo.getContext().getTranslatedServiceTemplates().get(mappedNestedHeatFileName);
153 List<String> nestedPropertyNames = getConnectionParameterName(mappedNestedServiceTemplate,
154 mappedNestedHeatOrchestrationTemplate, mappedNestedHeatFileName,
155 getMappedConnectionPointEntry(nestedServiceTemplate, connectionPointEntry));
157 if (nestedPropertyNames != null && !nestedPropertyNames.isEmpty()) {
158 for (String propertyName : nestedPropertyNames) {
159 Object propertyValue = mappedNodeTemplate.getProperties().get(propertyName);
160 if (propertyValue instanceof Map && ((Map) propertyValue).containsKey("get_input")) {
161 Object paramName = ((Map) propertyValue).get("get_input");
162 if (paramName instanceof String) {
163 connectionParameterNameList.add((String) paramName);
168 return connectionParameterNameList;
174 private List<String> getResourcesConnectionParameterName(String translatedResourceId,
175 HeatOrchestrationTemplate
176 nestedHeatOrchestrationTemplate,
177 String nestedHeatFileName) {
178 List<String> params = new ArrayList<>();
179 Optional<List<Map.Entry<String, Resource>>> heatResources =
180 getResourceByTranslatedResourceId(translatedResourceId, nestedHeatOrchestrationTemplate);
181 if (heatResources.isPresent()) {
182 for (Map.Entry<String, Resource> resourceEntry : heatResources.get()) {
183 Resource heatResource = resourceEntry.getValue();
184 if (!MapUtils.isEmpty(heatResource.getProperties())) {
185 Optional<List<String>> connectorParamName =
186 getConnectorPropertyParamName(resourceEntry.getKey(), heatResource,
187 nestedHeatOrchestrationTemplate, nestedHeatFileName);
188 connectorParamName.ifPresent(params::addAll);
195 protected Optional<List<Map.Entry<String, Resource>>> getResourceByTranslatedResourceId(
196 String translatedResourceId, HeatOrchestrationTemplate nestedHeatOrchestrationTemplate) {
197 Optional<List<Map.Entry<String, Resource>>> resourceByTranslatedResourceId =
198 resourceTranslationBase.getResourceByTranslatedResourceId(nestedFileData.getFile(),
199 nestedHeatOrchestrationTemplate, translatedResourceId, translateTo,
200 getDesiredResourceType());
201 if (!resourceByTranslatedResourceId.isPresent()) {
202 throw new CoreException((new ErrorCode.ErrorCodeBuilder()).withMessage(
203 "Failed to get original resource from heat for translate resource id '"
204 + translatedResourceId + "'")
205 .withId(TranslatorErrorCodes.HEAT_TO_TOSCA_MAPPING_COLLISION)
206 .withCategory(ErrorCategory.APPLICATION).build());
208 return resourceByTranslatedResourceId;
211 RequirementAssignment createRequirementAssignment(Map.Entry<String, RequirementDefinition>
212 requirementEntry, String node,
213 NodeTemplate nodeTemplate) {
214 RequirementAssignment requirementAssignment = null;
215 if (Objects.nonNull(node)) {
216 requirementAssignment = new RequirementAssignment();
217 requirementAssignment.setRelationship(requirementEntry.getValue().getRelationship());
218 requirementAssignment.setCapability(requirementEntry.getValue().getCapability());
219 requirementAssignment.setNode(node);
221 .addRequirementAssignment(nodeTemplate, requirementEntry.getKey(), requirementAssignment);
223 return requirementAssignment;
227 Optional<String> getConnectionTranslatedNodeUsingGetParamFunc(
228 Map.Entry<String, T> connectionPointEntry, String paramName,
229 List<String> supportedNodeTypes) {
231 Optional<AttachedResourceId> attachedResourceId =
232 HeatToToscaUtil.extractAttachedResourceId(translateTo, paramName);
233 if (!attachedResourceId.isPresent()) {
234 return Optional.empty();
236 AttachedResourceId resourceId = attachedResourceId.get();
237 if (resourceId.isGetParam() && resourceId.getEntityId() instanceof String) {
238 TranslatedHeatResource shareResource =
239 translateTo.getContext().getHeatSharedResourcesByParam().get(resourceId.getEntityId());
240 if (Objects.nonNull(shareResource)
241 && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
242 if (validateResourceTypeSupportedForReqCreation(translateTo.getResourceId(), paramName,
243 connectionPointEntry.getKey(), shareResource.getHeatResource(), supportedNodeTypes)) {
244 return Optional.of(shareResource.getTranslatedId());
248 return Optional.empty();
251 Optional<TranslatedHeatResource> getConnectionTranslatedHeatResourceUsingGetParamFunc(
252 Map.Entry<String, T> connectionPointEntry, String paramName,
253 List<String> supportedNodeTypes) {
255 Optional<AttachedResourceId> attachedResourceId =
256 HeatToToscaUtil.extractAttachedResourceId(translateTo, paramName);
257 if (!attachedResourceId.isPresent()) {
258 return Optional.empty();
260 AttachedResourceId resourceId = attachedResourceId.get();
261 if (resourceId.isGetParam() && resourceId.getEntityId() instanceof String) {
262 TranslatedHeatResource shareResource =
263 translateTo.getContext().getHeatSharedResourcesByParam().get(resourceId.getEntityId());
264 if (Objects.nonNull(shareResource)
265 && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
266 if (validateResourceTypeSupportedForReqCreation(translateTo.getResourceId(), paramName,
267 connectionPointEntry.getKey(), shareResource.getHeatResource(), supportedNodeTypes)) {
268 return Optional.of(shareResource);
272 return Optional.empty();
276 Optional<String> getConnectionTranslatedNodeUsingGetResourceFunc(
277 Map.Entry<String, T> connectionPointEntry, String paramName, Object paramValue,
278 List<String> supportedNodeTypes) {
279 Optional<String> getResourceAttachedResourceId =
280 HeatToToscaUtil.extractContrailGetResourceAttachedHeatResourceId(paramValue);
281 if (getResourceAttachedResourceId.isPresent()) { // get resource
282 Resource resource = translateTo.getHeatOrchestrationTemplate().getResources()
283 .get(getResourceAttachedResourceId.get());
284 if (validateResourceTypeSupportedForReqCreation(translateTo.getResourceId(), paramName,
285 connectionPointEntry.getKey(), resource, supportedNodeTypes)) {
286 return ResourceTranslationBase.getResourceTranslatedId(translateTo.getHeatFileName(),
287 translateTo.getHeatOrchestrationTemplate(), getResourceAttachedResourceId.get(),
288 translateTo.getContext());
292 return Optional.empty();
295 Optional<String> getConnectionResourceUsingGetResourceFunc(
296 Map.Entry<String, T> connectionPointEntry, String paramName, Object paramValue,
297 List<String> supportedNodeTypes) {
298 Optional<String> getResourceAttachedResourceId =
299 HeatToToscaUtil.extractContrailGetResourceAttachedHeatResourceId(paramValue);
300 if (getResourceAttachedResourceId.isPresent()) { // get resource
301 Resource resource = translateTo.getHeatOrchestrationTemplate().getResources()
302 .get(getResourceAttachedResourceId.get());
303 if (validateResourceTypeSupportedForReqCreation(translateTo.getResourceId(), paramName,
304 connectionPointEntry.getKey(), resource, supportedNodeTypes)) {
305 return getResourceAttachedResourceId;
308 return Optional.empty();