openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceConnectionUsingRequirementHelper.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
  21 import java.util.ArrayList;
  22 import java.util.HashMap;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Optional;
  26 import java.util.function.Predicate;
  27
  28 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  29 import org.onap.sdc.tosca.datatypes.model.NodeType;
  30 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
  31 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  32 //import org.openecomp.core.model.types.ServiceTemplate;
  33 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  34 import org.openecomp.sdc.tosca.services.DataModelUtil;
  35 import org.openecomp.sdc.tosca.services.ToscaConstants;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  37
  38 abstract class ResourceConnectionUsingRequirementHelper extends BaseResourceConnection<RequirementDefinition> {
  39     ResourceConnectionUsingRequirementHelper(ResourceTranslationBase resourceTranslationBase,
  40                                              TranslateTo translateTo, FileData nestedFileData,
  41                                              NodeTemplate substitutionNodeTemplate,
  42                                              NodeType nodeType) {
  43         super(resourceTranslationBase, translateTo, nestedFileData, substitutionNodeTemplate, nodeType);
  44     }
  45
  46     @Override
  47     String getMappedNodeTranslatedResourceId(ServiceTemplate nestedServiceTemplate,
  48                                              Map.Entry<String,
  49                                                      RequirementDefinition> connectionPointEntry) {
  50         List<String> substitutionMapping =
  51                 nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getRequirements()
  52                         .get(connectionPointEntry.getKey());
  53         return substitutionMapping.get(0);
  54     }
  55
  56     @Override
  57     Map.Entry<String, RequirementDefinition> getMappedConnectionPointEntry(
  58             ServiceTemplate nestedServiceTemplate,
  59             Map.Entry<String, RequirementDefinition> connectionPointEntry) {
  60         List<String> substitutionMapping =
  61                 nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getRequirements()
  62                         .get(connectionPointEntry.getKey());
  63         String mappedNodeTranslatedId = substitutionMapping.get(0);
  64         String mappedReqId = substitutionMapping.get(1);
  65         NodeTemplate mappedNodeTemplate =
  66                 nestedServiceTemplate.getTopology_template().getNode_templates()
  67                         .get(mappedNodeTranslatedId);
  68         NodeType substituteNodeType =
  69                 translateTo.getContext().getGlobalSubstitutionServiceTemplate().getNode_types()
  70                         .get(mappedNodeTemplate.getType());
  71         Optional<RequirementDefinition> requirementDefinition =
  72                 DataModelUtil.getRequirementDefinition(substituteNodeType, mappedReqId);
  73         return new Map.Entry<String, RequirementDefinition>() {
  74             @Override
  75             public String getKey() {
  76                 return mappedReqId;
  77             }
  78
  79             @Override
  80             public RequirementDefinition getValue() {
  81                 return requirementDefinition.orElse(null);
  82             }
  83
  84             @Override
  85             public RequirementDefinition setValue(RequirementDefinition value) {
  86                 return null;
  87             }
  88         };
  89     }
  90
  91     @Override
  92     List<Map<String, RequirementDefinition>> getAllConnectionPoints() {
  93         List<Map<String, RequirementDefinition>> exposedRequirementsList = new ArrayList<>();
  94         List<Predicate<RequirementDefinition>> predicates = getPredicatesListForConnectionPoints();
  95         List<Map<String, RequirementDefinition>> requirements = this.nodeType.getRequirements();
  96         if (requirements == null) {
  97             return exposedRequirementsList;
  98         }
  99         requirements.stream()
 100                 .map(Map::entrySet)
 101                 .forEach(x -> x.stream()
 102                         .filter(entry -> predicates
 103                                 .stream()
 104                                 .anyMatch(p -> p.test(entry.getValue())))
 105                         .forEach(entry -> {
 106                             Map<String, RequirementDefinition> exposedRequirementsMap = new HashMap<>();
 107                             exposedRequirementsMap.put(entry.getKey(), entry.getValue());
 108                             exposedRequirementsList.add(exposedRequirementsMap);
 109                         }));
 110         return exposedRequirementsList;
 111     }
 112
 113     void addRequirementToConnectResource(
 114             Map.Entry<String, RequirementDefinition> requirementDefinitionEntry, String paramName,
 115             Object paramValue, List<String> supportedNetworkTypes) {
 116         if (paramValue == null) {
 117             logger.warn(LOG_NESTED_RESOURCE_PROPERTY_NOT_DEFINED, paramName, translateTo.getResourceId(),
 118                     requirementDefinitionEntry.getKey(), ToscaConstants.REQUIREMENT);
 119             return;
 120         }
 121         Optional<String> targetTranslatedNodeId =
 122                 getConnectionTranslatedNodeUsingGetResourceFunc(requirementDefinitionEntry, paramName,
 123                         paramValue, supportedNetworkTypes);
 124         if (targetTranslatedNodeId.isPresent()) {
 125             createRequirementAssignment(requirementDefinitionEntry, targetTranslatedNodeId.get(),
 126                     substitutionNodeTemplate);
 127         } else {
 128             targetTranslatedNodeId =
 129                     getConnectionTranslatedNodeUsingGetParamFunc(requirementDefinitionEntry, paramName,
 130                             supportedNetworkTypes);
 131             targetTranslatedNodeId
 132                     .ifPresent(targetTranslatedId -> createRequirementAssignment(requirementDefinitionEntry,
 133                             targetTranslatedId, substitutionNodeTemplate));
 134         }
 135     }
 136 }