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