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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20
  21 package org.openecomp.sdc.translator.services.heattotosca.impl;
  22
  23 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  24 import org.openecomp.sdc.heat.datatypes.model.Resource;
  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.datatypes.model.NodeTemplate;
  29 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  30 import org.openecomp.sdc.tosca.services.DataModelUtil;
  31 import org.openecomp.sdc.tosca.services.ToscaConstants;
  32 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
  33 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
  35 import org.openecomp.sdc.translator.services.heattotosca.Constants;
  36 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  37 import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;
  38 import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaPropertyConverter;
  39
  40 import java.util.Arrays;
  41 import java.util.Collections;
  42 import java.util.List;
  43 import java.util.Map;
  44 import java.util.Objects;
  45 import java.util.Optional;
  46
  47
  48 public class ResourceTranslationNeutronPortImpl extends ResourceTranslationBase {
  49
  50   @Override
  51   public void translate(TranslateTo translateTo) {
  52
  53     NodeTemplate nodeTemplate = new NodeTemplate();
  54     nodeTemplate.setType(ToscaNodeType.NEUTRON_PORT.getDisplayName());
  55
  56     nodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
  57         .getToscaPropertiesSimpleConversion(translateTo.getResource().getProperties(),
  58             nodeTemplate.getProperties(), translateTo.getHeatFileName(),
  59             translateTo.getHeatOrchestrationTemplate(), translateTo.getResource().getType(),
  60             nodeTemplate, translateTo.getContext()));
  61     handleNetworkRequirement(translateTo, nodeTemplate);
  62     String resourceTranslatedId = handleSecurityRulesRequirement(translateTo);
  63     DataModelUtil
  64         .addNodeTemplate(translateTo.getServiceTemplate(), resourceTranslatedId, nodeTemplate);
  65   }
  66
  67   private String handleSecurityRulesRequirement(TranslateTo translateTo) {
  68     String resourceTranslatedId = translateTo.getTranslatedId();
  69     Map<String, Object> properties = translateTo.getResource().getProperties();
  70     Optional<Object> securityGroups =
  71         Optional.ofNullable(properties.get(Constants.SECURITY_GROUPS_PROPERTY_NAME));
  72     if (securityGroups.isPresent() && securityGroups.get() instanceof List) {
  73       List securityGroupsList = (List) securityGroups.get();
  74       securityGroupsList.forEach(resourceValue -> {
  75         Optional<AttachedResourceId> securityGroupResourceId = HeatToToscaUtil
  76             .extractAttachedResourceId(translateTo.getHeatFileName(),
  77                 translateTo.getHeatOrchestrationTemplate(), translateTo.getContext(),
  78                 resourceValue);
  79         if (securityGroupResourceId.isPresent()) {
  80           handleSecurityGroupResourceId(translateTo, resourceTranslatedId,
  81               securityGroupResourceId.get());
  82         }
  83       });
  84     }
  85     return resourceTranslatedId;
  86   }
  87
  88   private void handleSecurityGroupResourceId(TranslateTo translateTo, String resourceTranslatedId,
  89                                              AttachedResourceId securityGroupResourceId) {
  90     List<String> supportedSecurityGroupsTypes = Collections
  91         .singletonList(HeatResourcesTypes.NEUTRON_SECURITY_GROUP_RESOURCE_TYPE.getHeatResource());
  92     if (securityGroupResourceId.isGetResource()) {
  93       handleGetResource(translateTo, resourceTranslatedId, securityGroupResourceId,
  94           supportedSecurityGroupsTypes);
  95     } else if (securityGroupResourceId.isGetParam()) {
  96       handleGetParam(translateTo, resourceTranslatedId, securityGroupResourceId,
  97           supportedSecurityGroupsTypes);
  98     }
  99   }
 100
 101   private void handleGetParam(TranslateTo translateTo, String resourceTranslatedId,
 102                               AttachedResourceId securityGroupResourceId,
 103                               List<String> supportedSecurityGroupsTypes) {
 104     TranslatedHeatResource translatedSharedResourceId =
 105         translateTo.getContext().getHeatSharedResourcesByParam()
 106             .get(securityGroupResourceId.getEntityId());
 107     if (Objects.nonNull(translatedSharedResourceId)
 108         && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
 109       if (validateResourceTypeSupportedForReqCreation(translateTo, supportedSecurityGroupsTypes,
 110           translatedSharedResourceId.getHeatResource(), "security_groups")) {
 111         return;
 112       }
 113       final NodeTemplate securityGroupNodeTemplate = DataModelUtil
 114           .getNodeTemplate(translateTo.getServiceTemplate(),
 115               translatedSharedResourceId.getTranslatedId());
 116       RequirementAssignment requirement = new RequirementAssignment();
 117       requirement.setCapability(ToscaCapabilityType.ATTACHMENT.getDisplayName());
 118       requirement.setNode(resourceTranslatedId);
 119       requirement.setRelationship(ToscaRelationshipType.ATTACHES_TO.getDisplayName());
 120       DataModelUtil
 121           .addRequirementAssignment(securityGroupNodeTemplate, ToscaConstants.PORT_REQUIREMENT_ID,
 122               requirement);
 123     }
 124   }
 125
 126   private void handleGetResource(TranslateTo translateTo, String resourceTranslatedId,
 127                                  AttachedResourceId securityGroupResourceId,
 128                                  List<String> supportedSecurityGroupsTypes) {
 129     String resourceId = (String) securityGroupResourceId.getEntityId();
 130     Resource securityGroupResource = HeatToToscaUtil
 131         .getResource(translateTo.getHeatOrchestrationTemplate(), resourceId,
 132             translateTo.getHeatFileName());
 133     Optional<String> securityGroupTranslatedId =
 134         ResourceTranslationFactory.getInstance(securityGroupResource)
 135             .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(),
 136                 translateTo.getHeatOrchestrationTemplate(), securityGroupResource, resourceId,
 137                 translateTo.getContext());
 138     if (securityGroupTranslatedId.isPresent()) {
 139       if (validateResourceTypeSupportedForReqCreation(translateTo, supportedSecurityGroupsTypes,
 140           securityGroupResource, "security_groups")) {
 141         return;
 142       }
 143       final NodeTemplate securityGroupNodeTemplate = DataModelUtil
 144           .getNodeTemplate(translateTo.getServiceTemplate(), securityGroupTranslatedId.get());
 145       RequirementAssignment requirement = new RequirementAssignment();
 146       requirement.setCapability(ToscaCapabilityType.ATTACHMENT.getDisplayName());
 147       requirement.setNode(resourceTranslatedId);
 148       requirement.setRelationship(ToscaRelationshipType.ATTACHES_TO.getDisplayName());
 149       DataModelUtil
 150           .addRequirementAssignment(securityGroupNodeTemplate, ToscaConstants.PORT_REQUIREMENT_ID,
 151               requirement);
 152     }
 153   }
 154
 155   private void handleNetworkRequirement(TranslateTo translateTo, NodeTemplate nodeTemplate) {
 156     Optional<AttachedResourceId> networkResourceId =
 157         HeatToToscaUtil.extractAttachedResourceId(translateTo, "network");
 158     if (networkResourceId.isPresent()) {
 159       AttachedResourceId attachedResourceId = networkResourceId.get();
 160       addRequirementAssignmentForNetworkResource(translateTo, nodeTemplate, attachedResourceId);
 161     } else {
 162       networkResourceId = HeatToToscaUtil.extractAttachedResourceId(translateTo, "network_id");
 163       if (networkResourceId.isPresent()) {
 164         AttachedResourceId attachedResourceId = networkResourceId.get();
 165         addRequirementAssignmentForNetworkResource(translateTo, nodeTemplate, attachedResourceId);
 166       }
 167     }
 168   }
 169
 170   private void addRequirementAssignmentForNetworkResource(TranslateTo translateTo,
 171                                                           NodeTemplate nodeTemplate,
 172                                                           AttachedResourceId attachedResourceId) {
 173     String networkTranslatedId;
 174     List<String> supportedNetworkTypes =
 175         Arrays.asList(HeatResourcesTypes.NEUTRON_NET_RESOURCE_TYPE.getHeatResource(),
 176             HeatResourcesTypes.CONTRAIL_VIRTUAL_NETWORK_RESOURCE_TYPE.getHeatResource(),
 177             HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_NETWORK_RESOURCE_TYPE.getHeatResource());
 178     if (attachedResourceId.isGetResource()) {
 179       Resource networkHeatResource = translateTo.getHeatOrchestrationTemplate().getResources()
 180           .get(attachedResourceId.getEntityId());
 181       if (validateResourceTypeSupportedForReqCreation(translateTo, supportedNetworkTypes,
 182           networkHeatResource, "network'\\'network_id")) {
 183         return;
 184       }
 185       networkTranslatedId = (String) attachedResourceId.getTranslatedId();
 186       addRequirementAssignment(nodeTemplate, networkTranslatedId);
 187     } else if (attachedResourceId.isGetParam()) {
 188       TranslatedHeatResource translatedSharedResourceId =
 189           translateTo.getContext().getHeatSharedResourcesByParam()
 190               .get(attachedResourceId.getEntityId());
 191       if (Objects.nonNull(translatedSharedResourceId)
 192           && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
 193         if (validateResourceTypeSupportedForReqCreation(translateTo, supportedNetworkTypes,
 194             translatedSharedResourceId.getHeatResource(), "network'\\'network_id")) {
 195           return;
 196         }
 197         addRequirementAssignment(nodeTemplate, translatedSharedResourceId.getTranslatedId());
 198       }
 199     }
 200   }
 201
 202   private void addRequirementAssignment(NodeTemplate nodeTemplate, String translatedId) {
 203     RequirementAssignment requirement = new RequirementAssignment();
 204     requirement.setCapability(ToscaCapabilityType.NETWORK_LINKABLE.getDisplayName());
 205     requirement.setRelationship(ToscaRelationshipType.NETWORK_LINK_TO.getDisplayName());
 206     requirement.setNode(translatedId);
 207     DataModelUtil
 208         .addRequirementAssignment(nodeTemplate, ToscaConstants.LINK_REQUIREMENT_ID, requirement);
 209   }
 210
 211
 212   private boolean validateResourceTypeSupportedForReqCreation(TranslateTo translateTo,
 213                                                               List<String> supportedTypes,
 214                                                               Resource heatResource,
 215                                                               final String propertyName) {
 216     if (!isResourceTypeValidForRequirement(heatResource, supportedTypes)) {
 217       logger.warn(
 218           "'" + propertyName + "' property of port resource('" + translateTo.getResourceId()
 219               + "') is pointing to a resource of type '" + heatResource.getType() + "' "
 220               + "which is not supported for this requirement. "
 221               + "Supported types are: " + supportedTypes.toString());
 222       return true;
 223     }
 224     return false;
 225   }
 226
 227   private boolean isResourceTypeValidForRequirement(Resource networkHeatResource,
 228                                                     List<String> supportedNetworkTypes) {
 229     return Objects.nonNull(networkHeatResource)
 230         && supportedNetworkTypes.contains(networkHeatResource.getType());
 231   }
 232
 233 }