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