openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNeutronPortImpl.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation;
  18
  19 import com.google.common.collect.ImmutableList;
  20 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  21 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  22 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  23 import org.openecomp.sdc.heat.datatypes.model.Resource;
  24 import org.openecomp.sdc.heat.services.HeatConstants;
  25 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  26 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  27 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  28 import org.openecomp.sdc.tosca.services.DataModelUtil;
  29 import org.openecomp.sdc.tosca.services.ToscaConstants;
  30 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
  31 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  32 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
  33 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
  34 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationEntityType;
  35 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  36 import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;
  37 import org.openecomp.sdc.translator.services.heattotosca.helper.ResourceTranslationNeutronPortHelper;
  38 import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaPropertyConverter;
  39
  40 import java.util.*;
  41
  42 import static org.openecomp.sdc.translator.services.heattotosca.Constants.SECURITY_GROUPS_PROPERTY_NAME;
  43 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_UNSUPPORTED_RESOURCE_REQUIREMENT_CONNECTION;
  44
  45
  46 public class ResourceTranslationNeutronPortImpl extends ResourceTranslationBase {
  47
  48     @Override
  49     public void translate(TranslateTo translateTo) {
  50         NodeTemplate nodeTemplate = new NodeTemplate();
  51         nodeTemplate.setType(ToscaNodeType.NEUTRON_PORT);
  52         nodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
  53                 .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(),
  54                         translateTo.getResourceId(), translateTo.getResource().getProperties(),
  55                         nodeTemplate.getProperties(), translateTo.getHeatFileName(),
  56                         translateTo.getHeatOrchestrationTemplate(), translateTo.getResource().getType(),
  57                         nodeTemplate, translateTo.getContext()));
  58         new ResourceTranslationNeutronPortHelper().setAdditionalProperties(nodeTemplate
  59                 .getProperties());
  60         handleNetworkRequirement(translateTo, nodeTemplate);
  61         String resourceTranslatedId = handleSecurityRulesRequirement(translateTo);
  62         DataModelUtil
  63                 .addNodeTemplate(translateTo.getServiceTemplate(), resourceTranslatedId, nodeTemplate);
  64     }
  65
  66     private String handleSecurityRulesRequirement(TranslateTo translateTo) {
  67         String resourceTranslatedId = translateTo.getTranslatedId();
  68         Map<String, Object> properties = translateTo.getResource().getProperties();
  69         Optional<Object> securityGroups = Optional.ofNullable(properties.get(SECURITY_GROUPS_PROPERTY_NAME));
  70         if (securityGroups.isPresent() && securityGroups.get() instanceof List) {
  71             List securityGroupsList = (List) securityGroups.get();
  72             securityGroupsList.forEach(resourceValue -> {
  73                 Optional<AttachedResourceId> securityGroupResourceId = HeatToToscaUtil
  74                         .extractAttachedResourceId(translateTo.getHeatFileName(),
  75                                 translateTo.getHeatOrchestrationTemplate(), translateTo.getContext(), resourceValue);
  76                 securityGroupResourceId.ifPresent(attachedResourceId -> handleSecurityGroupResourceId(translateTo,
  77                         resourceTranslatedId, attachedResourceId));
  78             });
  79         }
  80         return resourceTranslatedId;
  81     }
  82
  83     private void handleSecurityGroupResourceId(TranslateTo translateTo, String resourceTranslatedId,
  84                                                AttachedResourceId securityGroupResourceId) {
  85         List<String> supportedSecurityGroupsTypes = Collections
  86                 .singletonList(HeatResourcesTypes.NEUTRON_SECURITY_GROUP_RESOURCE_TYPE.getHeatResource());
  87         if (securityGroupResourceId.isGetResource()) {
  88             handleGetResource(translateTo, resourceTranslatedId, securityGroupResourceId, supportedSecurityGroupsTypes);
  89         } else if (securityGroupResourceId.isGetParam()) {
  90             handleGetParam(translateTo, resourceTranslatedId, securityGroupResourceId, supportedSecurityGroupsTypes);
  91         }
  92     }
  93
  94     private void handleGetParam(TranslateTo translateTo, String resourceTranslatedId,
  95                                 AttachedResourceId securityGroupResourceId,
  96                                 List<String> supportedSecurityGroupsTypes) {
  97         if (!(securityGroupResourceId.getEntityId() instanceof String)) {
  98             return;
  99         }
 100         TranslatedHeatResource translatedSharedResourceId =
 101                 translateTo.getContext().getHeatSharedResourcesByParam().get(securityGroupResourceId.getEntityId());
 102         if (Objects.nonNull(translatedSharedResourceId)
 103                 && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
 104             if (validateResourceTypeSupportedForReqCreation(translateTo, supportedSecurityGroupsTypes,
 105                     translatedSharedResourceId.getHeatResource(), SECURITY_GROUPS_PROPERTY_NAME)) {
 106                 return;
 107             }
 108             final NodeTemplate securityGroupNodeTemplate = DataModelUtil
 109                     .getNodeTemplate(translateTo.getServiceTemplate(),
 110                             translatedSharedResourceId.getTranslatedId());
 111             RequirementAssignment requirement = new RequirementAssignment();
 112             requirement.setCapability(ToscaCapabilityType.NATIVE_ATTACHMENT);
 113             requirement.setNode(resourceTranslatedId);
 114             requirement.setRelationship(ToscaRelationshipType.ATTACHES_TO);
 115             DataModelUtil.addRequirementAssignment(securityGroupNodeTemplate, ToscaConstants.PORT_REQUIREMENT_ID,
 116                             requirement);
 117
 118             ConsolidationDataUtil.updateNodesConnectedIn(translateTo, translatedSharedResourceId.getTranslatedId(),
 119                             ConsolidationEntityType.PORT, translateTo.getResourceId(),
 120                             ToscaConstants.PORT_REQUIREMENT_ID, requirement);
 121         }
 122     }
 123
 124     private void handleGetResource(TranslateTo translateTo, String resourceTranslatedId,
 125                                    AttachedResourceId securityGroupResourceId,
 126                                    List<String> supportedSecurityGroupsTypes) {
 127         String resourceId = (String) securityGroupResourceId.getEntityId();
 128         Resource securityGroupResource = HeatToToscaUtil.getResource(translateTo.getHeatOrchestrationTemplate(),
 129                 resourceId, translateTo.getHeatFileName());
 130         Optional<String> securityGroupTranslatedId = ResourceTranslationFactory.getInstance(securityGroupResource)
 131                         .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(),
 132                             translateTo.getHeatOrchestrationTemplate(), securityGroupResource, resourceId,
 133                             translateTo.getContext());
 134         if (!securityGroupTranslatedId.isPresent()) {
 135             return;
 136         }
 137         if (validateResourceTypeSupportedForReqCreation(translateTo, supportedSecurityGroupsTypes,
 138                 securityGroupResource, SECURITY_GROUPS_PROPERTY_NAME)) {
 139             return;
 140         }
 141         final NodeTemplate securityGroupNodeTemplate = DataModelUtil
 142                 .getNodeTemplate(translateTo.getServiceTemplate(), securityGroupTranslatedId.get());
 143         RequirementAssignment requirement = new RequirementAssignment();
 144         requirement.setCapability(ToscaCapabilityType.NATIVE_ATTACHMENT);
 145         requirement.setNode(resourceTranslatedId);
 146         requirement.setRelationship(ToscaRelationshipType.ATTACHES_TO);
 147         DataModelUtil
 148                 .addRequirementAssignment(securityGroupNodeTemplate, ToscaConstants.PORT_REQUIREMENT_ID,
 149                         requirement);
 150
 151         ConsolidationDataUtil.updateNodesConnectedIn(translateTo, securityGroupTranslatedId.get(),
 152                 ConsolidationEntityType.PORT, translateTo.getResourceId(),
 153                 ToscaConstants.PORT_REQUIREMENT_ID, requirement);
 154     }
 155
 156     private void handleNetworkRequirement(TranslateTo translateTo, NodeTemplate nodeTemplate) {
 157         Optional<AttachedResourceId> networkResourceId =
 158                 HeatToToscaUtil.extractAttachedResourceId(translateTo, HeatConstants.NETWORK_PROPERTY_NAME);
 159         if (networkResourceId.isPresent()) {
 160             AttachedResourceId attachedResourceId = networkResourceId.get();
 161             addRequirementAssignmentForNetworkResource(translateTo, nodeTemplate, attachedResourceId);
 162         } else {
 163             networkResourceId = HeatToToscaUtil.extractAttachedResourceId(translateTo, HeatConstants
 164                     .NETWORK_ID_PROPERTY_NAME);
 165             if (networkResourceId.isPresent()) {
 166                 AttachedResourceId attachedResourceId = networkResourceId.get();
 167                 addRequirementAssignmentForNetworkResource(translateTo, nodeTemplate, attachedResourceId);
 168             }
 169         }
 170     }
 171
 172     private void addRequirementAssignmentForNetworkResource(TranslateTo translateTo,
 173                                                             NodeTemplate nodeTemplate,
 174                                                             AttachedResourceId attachedResourceId) {
 175         if (attachedResourceId.isGetResource()) {
 176             addLinkRequirementForGetResource(translateTo, nodeTemplate, attachedResourceId);
 177         } else if (attachedResourceId.isGetParam() && attachedResourceId.getEntityId() instanceof String) {
 178             addLinkRequirementForGetParam(translateTo, nodeTemplate, attachedResourceId);
 179         }
 180     }
 181
 182     private void addLinkRequirementForGetParam(TranslateTo translateTo, NodeTemplate nodeTemplate,
 183                                                AttachedResourceId attachedResourceId) {
 184         TranslatedHeatResource translatedSharedResourceId =
 185                 translateTo.getContext().getHeatSharedResourcesByParam().get(attachedResourceId.getEntityId());
 186         if (Objects.nonNull(translatedSharedResourceId)
 187                 && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
 188             if (validateResourceTypeSupportedForReqCreation(translateTo, getSupportedNetworkResourceTypes(),
 189                     translatedSharedResourceId.getHeatResource(), "network'\\'network_id")) {
 190                 return;
 191             }
 192             RequirementAssignment requirementAssignment = HeatToToscaUtil.addLinkReqFromPortToNetwork(
 193                     nodeTemplate, translatedSharedResourceId.getTranslatedId());
 194
 195             ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 196                     translatedSharedResourceId.getTranslatedId(), ConsolidationEntityType.PORT,
 197                     ToscaConstants.LINK_REQUIREMENT_ID, requirementAssignment);
 198         }
 199     }
 200
 201     private void addLinkRequirementForGetResource(TranslateTo translateTo, NodeTemplate nodeTemplate,
 202                                                   AttachedResourceId attachedResourceId) {
 203         String networkTranslatedId;
 204         Resource networkHeatResource = translateTo.getHeatOrchestrationTemplate()
 205                 .getResources().get(attachedResourceId.getEntityId());
 206         if (validateResourceTypeSupportedForReqCreation(translateTo, getSupportedNetworkResourceTypes(),
 207                 networkHeatResource, "network'\\'network_id")) {
 208             return;
 209         }
 210         networkTranslatedId = (String) attachedResourceId.getTranslatedId();
 211         RequirementAssignment requirementAssignment = HeatToToscaUtil.addLinkReqFromPortToNetwork(
 212                 nodeTemplate, networkTranslatedId);
 213
 214         ConsolidationDataUtil.updateNodesConnectedOut(translateTo, networkTranslatedId,
 215                 ConsolidationEntityType.PORT, ToscaConstants.LINK_REQUIREMENT_ID, requirementAssignment);
 216     }
 217
 218
 219     private boolean validateResourceTypeSupportedForReqCreation(TranslateTo translateTo,
 220                                                                 List<String> supportedTypes,
 221                                                                 Resource heatResource,
 222                                                                 final String propertyName) {
 223         if (isUnsupportedResourceType(heatResource, supportedTypes)) {
 224             String supportedResourceTypes = supportedTypes.toString();
 225             logger.warn(LOG_UNSUPPORTED_RESOURCE_REQUIREMENT_CONNECTION, propertyName, translateTo
 226                     .getResourceId(), heatResource.getType(), supportedResourceTypes);
 227             return true;
 228         }
 229         return false;
 230     }
 231
 232
 233     private List<String> getSupportedNetworkResourceTypes() {
 234         return ImmutableList.of(HeatResourcesTypes.NEUTRON_NET_RESOURCE_TYPE.getHeatResource(),
 235                 HeatResourcesTypes.CONTRAIL_VIRTUAL_NETWORK_RESOURCE_TYPE.getHeatResource(),
 236                 HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_NETWORK_RESOURCE_TYPE.getHeatResource());
 237     }
 238 }