catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.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.be.components.utils;
  18
  19 import java.util.ArrayList;
  20 import java.util.Arrays;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Objects;
  25 import java.util.Optional;
  26 import java.util.stream.Collectors;
  27 import org.apache.commons.collections.CollectionUtils;
  28 import org.apache.commons.collections4.MapUtils;
  29 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
  30 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  31 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  32 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  33 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
  34 import org.openecomp.sdc.be.model.Component;
  35 import org.openecomp.sdc.be.model.InputDefinition;
  36 import org.openecomp.sdc.be.model.InterfaceDefinition;
  37 import org.openecomp.sdc.be.model.Operation;
  38 import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
  39 import org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil;
  40
  41 public class InterfaceOperationUtils {
  42
  43     private InterfaceOperationUtils() {
  44     }
  45
  46     public static Optional<InterfaceDefinition> getInterfaceDefinitionFromComponentByInterfaceType(Component component,
  47             String interfaceType) {
  48         if (MapUtils.isEmpty(component.getInterfaces())) {
  49             return Optional.empty();
  50         }
  51         return component.getInterfaces().values().stream()
  52                        .filter(interfaceDefinition -> interfaceDefinition.getType() != null && interfaceDefinition
  53                                                                                                        .getType()
  54                                                                                                        .equals(interfaceType))
  55                        .findAny();
  56     }
  57
  58     public static Optional<InterfaceDefinition> getInterfaceDefinitionFromComponentByInterfaceId(Component component,
  59             String interfaceId) {
  60         if (MapUtils.isEmpty(component.getInterfaces())) {
  61             return Optional.empty();
  62         }
  63         return component.getInterfaces().values().stream()
  64                        .filter(interfaceDefinition -> interfaceDefinition.getUniqueId() != null && interfaceDefinition
  65                                                                                                            .getUniqueId()
  66                                                                                                            .equals(interfaceId))
  67                        .findAny();
  68     }
  69
  70     public static Optional<Map.Entry<String, Operation>> getOperationFromInterfaceDefinition(
  71             InterfaceDefinition interfaceDefinition, String operationId) {
  72         if (MapUtils.isEmpty(interfaceDefinition.getOperationsMap())) {
  73             return Optional.empty();
  74         }
  75         return interfaceDefinition.getOperationsMap().entrySet().stream()
  76                        .filter(entry -> entry.getValue().getUniqueId().equals(operationId)).findAny();
  77     }
  78
  79     public static Optional<InterfaceDefinition> getInterfaceDefinitionFromOperationId(List<InterfaceDefinition> interfaces,
  80             String operationId) {
  81         if (CollectionUtils.isEmpty(interfaces)) {
  82             return Optional.empty();
  83         }
  84         return interfaces.stream()
  85                        .filter(interfaceDefinition -> interfaceDefinition.getOperationsMap().containsKey(operationId))
  86                        .findAny();
  87     }
  88
  89     public static boolean isOperationInputMappedToComponentInput(OperationInputDefinition input,
  90                                                                  List<InputDefinition> inputs) {
  91         if (CollectionUtils.isEmpty(inputs)) {
  92             return false;
  93         }
  94         return inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(input.getInputId()))
  95                 || (input.getInputId().contains(".")
  96                 && inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(
  97                 input.getInputId().substring(0, input.getInputId().lastIndexOf('.'))))) ;
  98     }
  99
 100     public static boolean isOperationInputMappedToOtherOperationOutput(String outputName,
 101                                                                        List<OperationOutputDefinition>
 102                                                                                otherOperationOutputs) {
 103         if (CollectionUtils.isEmpty(otherOperationOutputs)) {
 104             return false;
 105         }
 106         return otherOperationOutputs.stream()
 107                 .anyMatch(output -> output.getName().equals(outputName));
 108
 109     }
 110
 111     public static Map<String, List<String>> createMappedInputPropertyDefaultValue(String propertyName) {
 112         Map<String, List<String>> getPropertyMap = new HashMap<>();
 113         List<String> values = new ArrayList<>();
 114         values.add(InterfacesOperationsToscaUtil.SELF);
 115         if (Objects.nonNull(propertyName) && !propertyName.isEmpty()) {
 116             values.addAll(Arrays.asList(propertyName.split("\\.")));
 117         }
 118         getPropertyMap.put(ToscaFunctions.GET_PROPERTY.getFunctionName(), values);
 119         return getPropertyMap;
 120     }
 121
 122     /**
 123      * Get the list of outputs of other operations of all the interfaces in the component.
 124      * @param currentOperationIdentifier Fully qualified operation name e.g. org.test.interfaces.node.lifecycle.Abc.stop
 125      * @param componentInterfaces VF or service interfaces
 126      */
 127
 128     public static ListDataDefinition<OperationOutputDefinition> getOtherOperationOutputsOfComponent(
 129             String currentOperationIdentifier, Map<String, ? extends InterfaceDataDefinition> componentInterfaces) {
 130         ListDataDefinition<OperationOutputDefinition> componentOutputs = new ListDataDefinition<>();
 131         if (MapUtils.isEmpty(componentInterfaces)) {
 132             return componentOutputs;
 133         }
 134         for (Map.Entry<String, ? extends InterfaceDataDefinition> interfaceDefinitionEntry :
 135                 componentInterfaces.entrySet()) {
 136             String interfaceName = interfaceDefinitionEntry.getKey();
 137             final Map<String, OperationDataDefinition> operations = interfaceDefinitionEntry.getValue().getOperations();
 138             if (MapUtils.isEmpty(operations)) {
 139                 continue;
 140             }
 141             for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
 142                 ListDataDefinition<OperationOutputDefinition> outputs = operationEntry.getValue().getOutputs();
 143                 String expectedOperationIdentifier = interfaceName + "." + operationEntry.getKey();
 144                 if (!currentOperationIdentifier.equals(expectedOperationIdentifier) && !outputs.isEmpty()) {
 145                     outputs.getListToscaDataDefinition().forEach(componentOutputs::add);
 146                 }
 147             }
 148         }
 149         return componentOutputs;
 150     }
 151
 152     /**
 153      * Create the value for operation input mapped to an operation output.
 154      * @param propertyName the mapped other operation output full name
 155      * @return input map for tosca
 156      */
 157     public static Map<String, List<String>> createMappedOutputDefaultValue(String componentName, String propertyName) {
 158         Map<String, List<String>> getOperationOutputMap = new HashMap<>();
 159         //For operation input mapped to other operation output parameter, the mapped property value
 160         // should be of the format <interface name>.<operation name>.<output parameter name>
 161         // Operation name and output param name should not contain "."
 162         List<String> defaultMappedOperationOutputValue = new ArrayList<>();
 163         String[] tokens = propertyName.split("\\.");
 164         if (tokens.length > 2) {
 165             defaultMappedOperationOutputValue.add(componentName);
 166             String outputPropertyName = tokens[tokens.length - 1];
 167             String operationName = tokens[tokens.length - 2];
 168             String mappedPropertyInterfaceType =
 169                     propertyName.substring(0, propertyName.indexOf(operationName + '.' + outputPropertyName) - 1);
 170             defaultMappedOperationOutputValue.addAll(Arrays.asList(mappedPropertyInterfaceType, operationName,
 171                     outputPropertyName));
 172             getOperationOutputMap.put(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName(),
 173                     defaultMappedOperationOutputValue);
 174         }
 175         return getOperationOutputMap;
 176     }
 177
 178     public static String getOperationOutputName(String fullOutputIdentifier) {
 179         return fullOutputIdentifier.contains(".")
 180                 ? fullOutputIdentifier.substring(fullOutputIdentifier.lastIndexOf('.') + 1)
 181                 : fullOutputIdentifier;
 182     }
 183
 184     public static boolean isArtifactInUse(Component component, String operationId, String artifactUniqueId) {
 185         return MapUtils.emptyIfNull(component.getInterfaces()).values().stream()
 186                        .filter(o -> MapUtils.isNotEmpty(o.getOperations()) && !o.getOperations().containsKey(operationId))
 187                        .flatMap(o -> o.getOperations().values().stream()).collect(Collectors.toList()).stream()
 188                        .anyMatch(op -> op.getImplementation().getUniqueId().equals(artifactUniqueId));
 189     }
 190 }