openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationCinderVolumeAttachmentImpl.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 org.apache.commons.lang3.StringUtils;
  20 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  21 import org.onap.sdc.tosca.datatypes.model.RelationshipTemplate;
  22 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  23 import org.openecomp.sdc.common.errors.CoreException;
  24 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  25 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  26 import org.openecomp.sdc.heat.datatypes.model.Resource;
  27 import org.openecomp.sdc.heat.services.HeatConstants;
  28 import org.openecomp.sdc.logging.api.Logger;
  29 import org.openecomp.sdc.logging.api.LoggerFactory;
  30 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  31 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  32 import org.openecomp.sdc.tosca.datatypes.ToscaTopologyTemplateElements;
  33 import org.openecomp.sdc.tosca.services.DataModelUtil;
  34 import org.openecomp.sdc.tosca.services.ToscaConstants;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.to.ResourceFileDataAndIDs;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  38 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
  39 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  40 import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;
  41 import org.openecomp.sdc.translator.services.heattotosca.errors.MissingMandatoryPropertyErrorBuilder;
  42 import org.openecomp.sdc.translator.services.heattotosca.helper.VolumeTranslationHelper;
  43 import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaPropertyConverter;
  44
  45 import java.util.List;
  46 import java.util.Optional;
  47
  48 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_INVALID_INSTANCE_UUID;
  49 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_UNSUPPORTED_VOLUME_ATTACHMENT_MSG;
  50 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil.getResource;
  51
  52 public class ResourceTranslationCinderVolumeAttachmentImpl extends ResourceTranslationBase {
  53
  54     protected static Logger logger = LoggerFactory.getLogger(ResourceTranslationCinderVolumeAttachmentImpl.class);
  55
  56     @Override
  57     protected void translate(TranslateTo translateTo) {
  58         RelationshipTemplate relationTemplate = new RelationshipTemplate();
  59         relationTemplate.setType(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO);
  60         String heatFileName = translateTo.getHeatFileName();
  61         relationTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
  62                 .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(),
  63                         translateTo.getResourceId(), translateTo.getResource().getProperties(),
  64                         relationTemplate.getProperties(), heatFileName,
  65                         translateTo.getHeatOrchestrationTemplate(), translateTo.getResource().getType(),
  66                         relationTemplate, translateTo.getContext()));
  67
  68         String volumeIdPropertyName = HeatConstants.VOL_ID_PROPERTY_NAME;
  69         AttachedResourceId attachedVolumeId = getAttachedResourceId(translateTo, volumeIdPropertyName);
  70         String instanceUuid = HeatConstants.INSTANCE_UUID_PROPERTY_NAME;
  71         AttachedResourceId attachedNovaServerId = getAttachedResourceId(translateTo, instanceUuid);
  72         if (attachedNovaServerId.isGetResource()) {
  73             handleNovaGetResource(translateTo, relationTemplate, attachedVolumeId,
  74                     (String) attachedNovaServerId.getEntityId());
  75         } else {
  76             logger.warn(LOG_INVALID_INSTANCE_UUID, translateTo.getResourceId(), translateTo.getResource().getType());
  77         }
  78     }
  79
  80     @Override
  81     protected Optional<ToscaTopologyTemplateElements> getTranslatedToscaTopologyElement(TranslateTo translateTo) {
  82         if (isEssentialRequirementsValid(translateTo)) {
  83             return Optional.of(ToscaTopologyTemplateElements.RELATIONSHIP_TEMPLATE);
  84         } else {
  85             return Optional.empty();
  86         }
  87     }
  88
  89     private AttachedResourceId getAttachedResourceId(TranslateTo translateTo, String propertyName) {
  90         Optional<AttachedResourceId> attachedResourceId = HeatToToscaUtil.extractAttachedResourceId(translateTo,
  91                 propertyName);
  92         if (!attachedResourceId.isPresent()) {
  93             throw new CoreException(new MissingMandatoryPropertyErrorBuilder(propertyName).build());
  94         }
  95         return attachedResourceId.get();
  96     }
  97
  98     private void handleNovaGetResource(TranslateTo translateTo, RelationshipTemplate relationTemplate,
  99                                        AttachedResourceId volResourceId, String novaResourceId) {
 100         RequirementAssignment requirement = new RequirementAssignment();
 101         String toscaCapabilityAttachment = ToscaCapabilityType.NATIVE_ATTACHMENT;
 102         requirement.setCapability(toscaCapabilityAttachment);
 103         if (volResourceId.isGetResource()) {
 104             createVolumeNovaRelationshipForVolGetResource(translateTo, relationTemplate, volResourceId, requirement);
 105         } else if (volResourceId.isGetParam() && volResourceId.getEntityId() instanceof String) {
 106             createVolumeNovaRelationshipForVolGetParam(translateTo, relationTemplate, volResourceId, requirement);
 107         }
 108         translateNovaServerResource(translateTo, novaResourceId, requirement);
 109     }
 110
 111     private void translateNovaServerResource(TranslateTo translateTo, String novaResourceId,
 112                                              RequirementAssignment requirement) {
 113         Resource novaServerResource =
 114                 getResource(translateTo.getHeatOrchestrationTemplate(), novaResourceId, translateTo.getHeatFileName());
 115         if (!StringUtils.equals(HeatResourcesTypes.NOVA_SERVER_RESOURCE_TYPE.getHeatResource(),
 116                 novaServerResource.getType())) {
 117             logger.warn(LOG_UNSUPPORTED_VOLUME_ATTACHMENT_MSG, translateTo.getResourceId(),
 118                     novaServerResource.getType(), HeatResourcesTypes.NOVA_SERVER_RESOURCE_TYPE.getHeatResource());
 119             return;
 120         }
 121         Optional<String> translatedNovaServerId = ResourceTranslationFactory.getInstance(novaServerResource)
 122                 .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(),
 123                         translateTo.getHeatOrchestrationTemplate(), novaServerResource, novaResourceId,
 124                         translateTo.getContext());
 125
 126         if (translatedNovaServerId.isPresent() && StringUtils.isNotEmpty(requirement.getNode())) {
 127             NodeTemplate novaServerNodeTemplate = DataModelUtil
 128                     .getNodeTemplate(translateTo.getServiceTemplate(), translatedNovaServerId.get());
 129             DataModelUtil.addRequirementAssignment(novaServerNodeTemplate, ToscaConstants
 130                     .LOCAL_STORAGE_REQUIREMENT_ID, requirement);
 131             //Add volume information to consolidation data
 132             ConsolidationDataUtil.updateComputeConsolidationDataVolumes(translateTo,
 133                     novaServerNodeTemplate.getType(), translatedNovaServerId.get(), ToscaConstants
 134                             .LOCAL_STORAGE_REQUIREMENT_ID, requirement);
 135         }
 136     }
 137
 138     private void createVolumeNovaRelationshipForVolGetParam(TranslateTo translateTo,
 139                                                                RelationshipTemplate relationTemplate,
 140                                                                AttachedResourceId volResourceId,
 141                                                                RequirementAssignment requirement) {
 142         String volumeResourceIdParamName = (String) volResourceId.getEntityId();
 143         if (translateTo.getContext().getHeatSharedResourcesByParam().containsKey(volumeResourceIdParamName)
 144                 && !isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
 145             handleSharedVolume(translateTo, relationTemplate, requirement, volumeResourceIdParamName);
 146         } else {
 147             handleUnsharedVolume(translateTo, relationTemplate, requirement, volumeResourceIdParamName);
 148         }
 149     }
 150
 151     private void handleSharedVolume(TranslateTo translateTo, RelationshipTemplate relationTemplate,
 152                                        RequirementAssignment requirement, String volumeResourceIdParamName) {
 153         Resource volServerResource = translateTo.getContext().getHeatSharedResourcesByParam()
 154                 .get(volumeResourceIdParamName).getHeatResource();
 155         if (!StringUtils.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource(),
 156                 volServerResource.getType())) {
 157             logger.warn(LOG_UNSUPPORTED_VOLUME_ATTACHMENT_MSG, translateTo.getResourceId(),
 158                     volServerResource.getType(),
 159                     HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource());
 160             return;
 161         }
 162         requirement.setNode(translateTo.getContext().getHeatSharedResourcesByParam().get(volumeResourceIdParamName)
 163                         .getTranslatedId());
 164         requirement.setRelationship(translateTo.getTranslatedId());
 165         DataModelUtil.addRelationshipTemplate(translateTo.getServiceTemplate(), translateTo.getTranslatedId(),
 166                         relationTemplate);
 167     }
 168
 169     private void createVolumeNovaRelationshipForVolGetResource(TranslateTo translateTo,
 170                                                                   RelationshipTemplate relationTemplate,
 171                                                                   AttachedResourceId volResourceId,
 172                                                                   RequirementAssignment requirement) {
 173         Resource volServerResource = getResource(translateTo.getHeatOrchestrationTemplate(),
 174                 (String) volResourceId.getTranslatedId(), translateTo.getHeatFileName());
 175         if (!StringUtils.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource(),
 176                 volServerResource.getType())) {
 177             logger.warn(LOG_UNSUPPORTED_VOLUME_ATTACHMENT_MSG, translateTo.getResourceId(), volServerResource.getType(),
 178                     HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource());
 179             return;
 180         }
 181         requirement.setNode((String) volResourceId.getTranslatedId());
 182         requirement.setRelationship(translateTo.getTranslatedId());
 183         DataModelUtil.addRelationshipTemplate(translateTo.getServiceTemplate(), translateTo.getTranslatedId(),
 184                 relationTemplate);
 185     }
 186
 187     private void handleUnsharedVolume(TranslateTo translateTo, RelationshipTemplate relationTemplate,
 188                                       RequirementAssignment requirement, String volumeResourceId) {
 189         List<FileData> allFilesData = translateTo.getContext().getManifest().getContent().getData();
 190         Optional<FileData> fileData = HeatToToscaUtil.getFileData(translateTo.getHeatFileName(), allFilesData);
 191         if (fileData.isPresent()) {
 192             Optional<ResourceFileDataAndIDs> fileDataContainingResource =
 193                     new VolumeTranslationHelper(logger)
 194                             .getFileDataContainingVolume(fileData.get().getData(), volumeResourceId, translateTo,
 195                                     FileData.Type.HEAT_VOL);
 196             fileDataContainingResource.ifPresent(resourceFileDataAndIDs -> addRelationshipToServiceTemplate(
 197                     translateTo, relationTemplate, requirement, resourceFileDataAndIDs));
 198         }
 199     }
 200
 201     private boolean isHeatFileNested(TranslateTo translateTo, String heatFileName) {
 202         return translateTo.getContext().getNestedHeatsFiles().contains(heatFileName);
 203     }
 204
 205     private void addRelationshipToServiceTemplate(TranslateTo translateTo,
 206                                                   RelationshipTemplate relationTemplate,
 207                                                   RequirementAssignment requirement,
 208                                                   ResourceFileDataAndIDs resourceFileDataAndIDs) {
 209         String translatedId = resourceFileDataAndIDs.getTranslatedResourceId();
 210         String toscaVolIdPropName =
 211                 HeatToToscaUtil.getToscaPropertyName(translateTo, HeatConstants.VOL_ID_PROPERTY_NAME);
 212         relationTemplate.getProperties().put(toscaVolIdPropName, translatedId);
 213         requirement.setNode(translatedId);
 214         requirement.setRelationship(translateTo.getTranslatedId());
 215         DataModelUtil.addRelationshipTemplate(translateTo.getServiceTemplate(), translateTo.getTranslatedId(),
 216                 relationTemplate);
 217     }
 218 }