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