openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceConnectionUsingCapabilityHelper.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 static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_NESTED_RESOURCE_PROPERTY_NOT_DEFINED;
  20 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_UNSUPPORTED_CAPABILITY_CONNECTION;
  21
  22 import java.util.ArrayList;
  23 import java.util.HashMap;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Optional;
  27 import java.util.function.Predicate;
  28
  29 import org.onap.sdc.tosca.datatypes.model.*;
  30 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  31 import org.openecomp.sdc.heat.datatypes.model.Resource;
  32 import org.openecomp.sdc.tosca.services.DataModelUtil;
  33 import org.openecomp.sdc.tosca.services.ToscaConstants;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
  36 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
  37 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  38 import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;
  39
  40 public abstract class ResourceConnectionUsingCapabilityHelper extends BaseResourceConnection<CapabilityDefinition> {
  41
  42     ResourceConnectionUsingCapabilityHelper(ResourceTranslationBase resourceTranslationBase,
  43                                             TranslateTo translateTo, FileData nestedFileData,
  44                                             NodeTemplate substitutionNodeTemplate,
  45                                             NodeType nodeType) {
  46         super(resourceTranslationBase, translateTo, nestedFileData, substitutionNodeTemplate, nodeType);
  47     }
  48
  49     abstract Map.Entry<String, RequirementDefinition> createRequirementDefinition(
  50             String capabilityKey);
  51
  52     @Override
  53     String getMappedNodeTranslatedResourceId(ServiceTemplate nestedServiceTemplate,
  54                                              Map.Entry<String,
  55                                                      CapabilityDefinition> connectionPointEntry) {
  56         List<String> substitutionMapping =
  57                 nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities()
  58                         .get(connectionPointEntry.getKey());
  59         return substitutionMapping.get(0);
  60     }
  61
  62     @Override
  63     Map.Entry<String, CapabilityDefinition> getMappedConnectionPointEntry(
  64             ServiceTemplate nestedServiceTemplate,
  65             Map.Entry<String, CapabilityDefinition> connectionPointEntry) {
  66         List<String> substitutionMapping =
  67                 nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities()
  68                         .get(connectionPointEntry.getKey());
  69         String mappedNodeTranslatedId = substitutionMapping.get(0);
  70         String mappedCapabilityId = substitutionMapping.get(1);
  71         NodeTemplate mappedNodeTemplate =
  72                 nestedServiceTemplate.getTopology_template().getNode_templates()
  73                         .get(mappedNodeTranslatedId);
  74         NodeType substituteNodeType =
  75                 translateTo.getContext().getGlobalSubstitutionServiceTemplate().getNode_types()
  76                         .get(mappedNodeTemplate.getType());
  77         Optional<CapabilityDefinition> capabilityDefinition =
  78                 DataModelUtil.getCapabilityDefinition(substituteNodeType, mappedCapabilityId);
  79         return new Map.Entry<String, CapabilityDefinition>() {
  80             @Override
  81             public String getKey() {
  82                 return mappedCapabilityId;
  83             }
  84
  85             @Override
  86             public CapabilityDefinition getValue() {
  87                 return capabilityDefinition.orElse(null);
  88             }
  89
  90             @Override
  91             public CapabilityDefinition setValue(CapabilityDefinition value) {
  92                 return null;
  93             }
  94         };
  95     }
  96
  97     @Override
  98     protected List<Map<String, CapabilityDefinition>> getAllConnectionPoints() {
  99         List<Map<String, CapabilityDefinition>> exposedRequirementsList = new ArrayList<>();
 100         List<Predicate<CapabilityDefinition>> predicates = getPredicatesListForConnectionPoints();
 101         Map<String, CapabilityDefinition> capabilities = this.nodeType.getCapabilities();
 102         if (capabilities == null) {
 103             return exposedRequirementsList;
 104         }
 105         capabilities.entrySet()
 106                 .stream()
 107                 .filter(entry -> predicates
 108                         .stream()
 109                         .anyMatch(p -> p.test(entry.getValue())))
 110                 .forEach(entry -> {
 111                     Map<String, CapabilityDefinition> exposedRequirementsMap = new HashMap<>();
 112                     exposedRequirementsMap.put(entry.getKey(), entry.getValue());
 113                     exposedRequirementsList.add(exposedRequirementsMap);
 114                 });
 115         return exposedRequirementsList;
 116     }
 117
 118     void addRequirementToConnectResource(Map.Entry<String, CapabilityDefinition> connectionPointEntry,
 119                                          List<String> supportedSourceNodeTypes, String paramName) {
 120         Object paramValue = translateTo.getResource().getProperties().get(paramName);
 121         if (paramValue == null) {
 122             logger.warn(LOG_NESTED_RESOURCE_PROPERTY_NOT_DEFINED, paramName,
 123                     translateTo.getResourceId(), connectionPointEntry.getKey(), ToscaConstants.CAPABILITY);
 124             return;
 125         }
 126
 127         Map.Entry<String, RequirementDefinition> requirementDefinition =
 128                 createRequirementDefinition(connectionPointEntry.getKey());
 129
 130         Optional<String> sourceResourceId =
 131                 getConnectionResourceUsingGetResourceFunc(connectionPointEntry, paramName, paramValue,
 132                         supportedSourceNodeTypes);
 133         if (sourceResourceId.isPresent()) {
 134             Resource sourceResource = HeatToToscaUtil
 135                     .getResource(translateTo.getHeatOrchestrationTemplate(), sourceResourceId.get(),
 136                             translateTo.getHeatFileName());
 137             Optional<String> translatedSourceNodeId =
 138                     ResourceTranslationFactory.getInstance(sourceResource)
 139                             .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(),
 140                                     translateTo.getHeatOrchestrationTemplate(), sourceResource,
 141                                     sourceResourceId.get(), translateTo.getContext());
 142             if (translatedSourceNodeId.isPresent()) {
 143                 NodeTemplate sourceNodeTemplate = DataModelUtil
 144                         .getNodeTemplate(translateTo.getServiceTemplate(), translatedSourceNodeId.get());
 145                 RequirementAssignment requirementAssignment = createRequirementAssignment(
 146                         requirementDefinition, translateTo.getTranslatedId(), sourceNodeTemplate);
 147                 ConsolidationDataUtil.updateNodesConnectedData(translateTo, translateTo.getResourceId(),
 148                         translateTo.getResource(), sourceResource, translatedSourceNodeId.get(),
 149                         requirementDefinition.getKey(), requirementAssignment);
 150             } else {
 151                 logger.warn(LOG_UNSUPPORTED_CAPABILITY_CONNECTION, sourceResource.getType(),
 152                         connectionPointEntry.getKey(),
 153                         connectionPointEntry.getValue().getType());
 154             }
 155         } else {
 156             Optional<TranslatedHeatResource> sharedSourceTranslatedHeatResource =
 157                     getConnectionTranslatedHeatResourceUsingGetParamFunc(connectionPointEntry, paramName,
 158                             supportedSourceNodeTypes);
 159             if (sharedSourceTranslatedHeatResource.isPresent()) {
 160                 NodeTemplate sharedSourceNodeTemplate = DataModelUtil
 161                         .getNodeTemplate(translateTo.getServiceTemplate(),
 162                                 sharedSourceTranslatedHeatResource.get().getTranslatedId());
 163                 RequirementAssignment requirementAssignment = createRequirementAssignment(
 164                         requirementDefinition, translateTo.getTranslatedId(), sharedSourceNodeTemplate);
 165
 166                 ConsolidationDataUtil.updateNodesConnectedData(translateTo, translateTo.getResourceId(),
 167                         translateTo.getResource(), sharedSourceTranslatedHeatResource.get().getHeatResource(),
 168                         sharedSourceTranslatedHeatResource.get().getTranslatedId(),
 169                         requirementDefinition.getKey(),
 170                         requirementAssignment);
 171             }
 172         }
 173     }
 174
 175 }