gerrit.onap Code Review - sdc.git/blob

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