diff options
Diffstat (limited to 'openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java')
24 files changed, 2044 insertions, 967 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/TranslationContext.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/TranslationContext.java index 6f77f22625..8175072bbc 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/TranslationContext.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/TranslationContext.java @@ -1,5 +1,5 @@ /* - * Copyright © 2016-2017 European Support Limited + * Copyright © 2016-2018 European Support Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,6 +16,8 @@ package org.openecomp.sdc.translator.datatypes.heattotosca; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; import org.apache.commons.collections.MapUtils; import org.openecomp.config.api.Configuration; import org.openecomp.config.api.ConfigurationManager; @@ -92,6 +94,9 @@ public class TranslationContext { private Set<String> nodeTemplateIdsPointingToStWithoutNodeTemplates = new HashSet<>(); + //Key - service template name, value - Map of key: node template id, value: proerties with %index% + private Map<String, ListMultimap<String, String>> indexVarProperties = new HashMap<>(); + static { Configuration config = ConfigurationManager.lookup(); translationMapping = @@ -171,6 +176,25 @@ public class TranslationContext { .addCleanedNodeTemplate(nodeTemplateId, unifiedCompositionEntity, nodeTemplate); } + public Optional<List<String>> getIndexVarProperties(String serviceTemplateName, + String nodeTemplateId) { + ListMultimap<String, String> serviceTemplateIndexVarProperties = this.indexVarProperties + .get(serviceTemplateName); + if (Objects.nonNull(serviceTemplateIndexVarProperties)) { + return Optional.of(this.indexVarProperties.get(serviceTemplateName).get(nodeTemplateId)); + } + return Optional.empty(); + } + + public void addIndexVarProperties(String serviceTemplateName, + String nodeTemplateId, + List<String> indexVarProperties) { + this.indexVarProperties.putIfAbsent(serviceTemplateName, ArrayListMultimap.create()); + this.indexVarProperties + .get(serviceTemplateName) + .putAll(nodeTemplateId, indexVarProperties); + } + public NodeTemplate getCleanedNodeTemplate(String serviceTemplateName, String nodeTemplateId) { return this.unifiedSubstitutionData.get(serviceTemplateName) diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionData.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionData.java index a3635391ba..08db3be2a9 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionData.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionData.java @@ -1,8 +1,25 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; import java.util.ArrayList; import java.util.List; @@ -20,6 +37,7 @@ public class UnifiedCompositionData { */ private List<PortTemplateConsolidationData> portTemplateConsolidationDataList; + private List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList; private NestedTemplateConsolidationData nestedTemplateConsolidationData; @@ -75,6 +93,26 @@ public class UnifiedCompositionData { } /** + * Gets sub interface template consolidation data list. + * + * @return the sub interface template consolidation data list + */ + public List<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationDataList() { + return subInterfaceTemplateConsolidationDataList; + } + + /** + * Sets sub interface template consolidation data list. + * + * @param subInterfaceTemplateConsolidationDataList the sub interface template consolidation data + * list + */ + public void setSubInterfaceTemplateConsolidationDataList( + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList) { + this.subInterfaceTemplateConsolidationDataList = subInterfaceTemplateConsolidationDataList; + } + + /** * Gets nested template consolidation data. * * @return the nested template consolidation data diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionEntity.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionEntity.java index d0bb826904..58a9092616 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionEntity.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedCompositionEntity.java @@ -1,8 +1,35 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition; public enum UnifiedCompositionEntity { - Compute, - Port, - Nested, - Other; + COMPUTE("Compute"), + PORT("Port"), + NESTED("Nested"), + SUB_INTERFACE("SubInterface"), + OTHER("Other"); + + private String displayName; + + UnifiedCompositionEntity(String displayName) { + this.displayName = displayName; + } + + public String getDisplayName() { + return displayName; + } } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/CommandImplNames.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/CommandImplNames.java new file mode 100644 index 0000000000..8fa2c74b1b --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/CommandImplNames.java @@ -0,0 +1,30 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands; + +public class CommandImplNames { + + private static final String COMMANDS_IMPL_BASE_PACKAGE = + "org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.impl"; + + public static final String COMPUTE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL = + COMMANDS_IMPL_BASE_PACKAGE + ".ComputeNewNodeTemplateIdGenerator"; + public static final String PORT_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL = + COMMANDS_IMPL_BASE_PACKAGE + ".PortNewNodeTemplateIdGenerator"; + public static final String SUB_INTERFACE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL = + COMMANDS_IMPL_BASE_PACKAGE + ".SubInterfaceNewNodeTemplateIdGenerator"; +} diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/UnifiedSubstitutionNodeTemplateIdGenerator.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/UnifiedSubstitutionNodeTemplateIdGenerator.java new file mode 100644 index 0000000000..a932859807 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/UnifiedSubstitutionNodeTemplateIdGenerator.java @@ -0,0 +1,25 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands; + +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo; + +import java.util.Optional; + +public interface UnifiedSubstitutionNodeTemplateIdGenerator { + public Optional<String> generate(UnifiedCompositionTo unifiedCompositionTo, String originalNodeTemplateId); +} diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/ComputeNewNodeTemplateIdGenerator.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/ComputeNewNodeTemplateIdGenerator.java new file mode 100644 index 0000000000..c39a26c545 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/ComputeNewNodeTemplateIdGenerator.java @@ -0,0 +1,32 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.impl; + +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.UnifiedSubstitutionNodeTemplateIdGenerator; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo; +import org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil; + +import java.util.Optional; + +public class ComputeNewNodeTemplateIdGenerator implements UnifiedSubstitutionNodeTemplateIdGenerator { + + @Override + public Optional<String> generate(UnifiedCompositionTo unifiedCompositionTo, String originalNodeTemplateId) { + return Optional.ofNullable(UnifiedCompositionUtil.getNewComputeNodeTemplateId( + unifiedCompositionTo.getServiceTemplate(), originalNodeTemplateId)); + } +} diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/PortNewNodeTemplateIdGenerator.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/PortNewNodeTemplateIdGenerator.java new file mode 100644 index 0000000000..e70ac165e2 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/PortNewNodeTemplateIdGenerator.java @@ -0,0 +1,46 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.impl; + +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getConnectedComputeConsolidationData; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewPortNodeTemplateId; + +import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; +import org.openecomp.sdc.tosca.services.DataModelUtil; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.UnifiedSubstitutionNodeTemplateIdGenerator; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData; + +import java.util.Objects; +import java.util.Optional; + +public class PortNewNodeTemplateIdGenerator implements UnifiedSubstitutionNodeTemplateIdGenerator { + + @Override + public Optional<String> generate(UnifiedCompositionTo unifiedCompositionTo, String originalNodeTemplateId) { + ComputeTemplateConsolidationData connectedComputeConsolidationData = + getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(), + originalNodeTemplateId); + if (Objects.nonNull(connectedComputeConsolidationData)) { + NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo + .getServiceTemplate(), connectedComputeConsolidationData.getNodeTemplateId()); + return Optional.of(getNewPortNodeTemplateId(originalNodeTemplateId, connectedComputeNodeTemplate.getType(), + connectedComputeConsolidationData)); + } + return Optional.empty(); + } +} diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/SubInterfaceNewNodeTemplateIdGenerator.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/SubInterfaceNewNodeTemplateIdGenerator.java new file mode 100644 index 0000000000..5aafa1aac5 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/commands/impl/SubInterfaceNewNodeTemplateIdGenerator.java @@ -0,0 +1,69 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.impl; + +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getConnectedComputeConsolidationData; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewSubInterfaceNodeTemplateId; + +import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; +import org.openecomp.sdc.tosca.services.DataModelUtil; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.UnifiedSubstitutionNodeTemplateIdGenerator; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; +import org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil; + +import java.util.Collection; +import java.util.List; +import java.util.Objects; +import java.util.Optional; + +public class SubInterfaceNewNodeTemplateIdGenerator implements UnifiedSubstitutionNodeTemplateIdGenerator { + + @Override + public Optional<String> generate(UnifiedCompositionTo unifiedCompositionTo, String originalNodeTemplateId) { + SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData = + getSubInterfaceTemplateConsolidationDataById(unifiedCompositionTo.getUnifiedCompositionDataList(), + originalNodeTemplateId); + if (Objects.nonNull(subInterfaceTemplateConsolidationData)) { + String parentPortNodeTemplateId = subInterfaceTemplateConsolidationData.getParentPortNodeTemplateId(); + ComputeTemplateConsolidationData connectedComputeConsolidationData = + getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(), + parentPortNodeTemplateId); + if (Objects.nonNull(connectedComputeConsolidationData)) { + NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo + .getServiceTemplate(), connectedComputeConsolidationData.getNodeTemplateId()); + return Optional.of(getNewSubInterfaceNodeTemplateId(unifiedCompositionTo.getServiceTemplate(), + connectedComputeNodeTemplate.getType(), connectedComputeConsolidationData, + subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext())); + } + } + return Optional.empty(); + } + + private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationDataById( + List<UnifiedCompositionData> unifiedCompositionDataList, + String subInterfaceNodeTemplateId) { + return unifiedCompositionDataList.stream() + .map(UnifiedCompositionUtil::getSubInterfaceTemplateConsolidationDataList) + .flatMap(Collection::stream) + .filter(subInterfaceTemplateConsolidationData -> subInterfaceNodeTemplateId + .equals(subInterfaceTemplateConsolidationData.getNodeTemplateId())) + .findFirst().orElse(null); + } +} diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/to/UnifiedCompositionTo.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/to/UnifiedCompositionTo.java new file mode 100644 index 0000000000..56c647129f --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/to/UnifiedCompositionTo.java @@ -0,0 +1,73 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to; + +import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; +import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData; + +import java.util.List; + +public class UnifiedCompositionTo { + private ServiceTemplate serviceTemplate; + private ServiceTemplate substitutionServiceTemplate; + private List<UnifiedCompositionData> unifiedCompositionDataList; + private TranslationContext context; + + public UnifiedCompositionTo(ServiceTemplate serviceTemplate, + ServiceTemplate substitutionServiceTemplate, + List<UnifiedCompositionData> unifiedCompositionDataList, + TranslationContext context) { + this.serviceTemplate = serviceTemplate; + this.substitutionServiceTemplate = substitutionServiceTemplate; + this.unifiedCompositionDataList = unifiedCompositionDataList; + this.context = context; + } + + public ServiceTemplate getServiceTemplate() { + return serviceTemplate; + } + + public void setServiceTemplate(ServiceTemplate serviceTemplate) { + this.serviceTemplate = serviceTemplate; + } + + public ServiceTemplate getSubstitutionServiceTemplate() { + return substitutionServiceTemplate; + } + + public void setSubstitutionServiceTemplate(ServiceTemplate substitutionServiceTemplate) { + this.substitutionServiceTemplate = substitutionServiceTemplate; + } + + public List<UnifiedCompositionData> getUnifiedCompositionDataList() { + return unifiedCompositionDataList; + } + + public void setUnifiedCompositionDataList( + List<UnifiedCompositionData> unifiedCompositionDataList) { + this.unifiedCompositionDataList = unifiedCompositionDataList; + } + + public TranslationContext getContext() { + return context; + } + + public void setContext(TranslationContext context) { + this.context = context; + } +} diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java index 0eacd4de3c..5d372370e3 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java @@ -19,7 +19,9 @@ package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolid import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ListMultimap; import com.google.common.collect.Multimaps; + import java.util.List; +import java.util.Set; /** @@ -27,10 +29,29 @@ import java.util.List; */ public class PortTemplateConsolidationData extends EntityConsolidationData { - // key - subport type - for ResourceGroup it is the nested file name - // value - List of subports of that type in the port - private final ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData = - Multimaps.synchronizedListMultimap(ArrayListMultimap.create()); + // key - sub-interface type - for ResourceGroup it is the nested file name + // value - List of sub-interfaces of that type in the port + private final ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData = + Multimaps.synchronizedListMultimap(ArrayListMultimap.create()); + + private String networkRole; + + public String getNetworkRole() { + return networkRole; + } + + public void setNetworkRole(String networkRole) { + this.networkRole = networkRole; + } + + public List<SubInterfaceTemplateConsolidationData> getSubInterfaceConsolidationData( + String subInterfaceType) { + return this.subInterfaceConsolidationData.get(subInterfaceType); + } + + public Set<String> getAllSubInterfaceNodeTypes() { + return this.subInterfaceConsolidationData.keySet(); + } public void addSubInterfaceConsolidationData(String subPortType, SubInterfaceTemplateConsolidationData @@ -43,29 +64,26 @@ public class PortTemplateConsolidationData extends EntityConsolidationData { other.subInterfaceConsolidationData.keySet()); } - public void copyMappedInto(ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceTypeToEntity) { + public void copyMappedInto(ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceTypeToEntity) { subInterfaceTypeToEntity.putAll(this.subInterfaceConsolidationData); } - public void copyFlatInto(List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList) { - subInterfaceTemplateConsolidationDataList.addAll(subInterfaceConsolidationData.values()); - } + public void copyFlatInto(List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList) { + subInterfaceTemplateConsolidationDataList.addAll(subInterfaceConsolidationData.values()); + } public boolean isNumberOfSubInterfacesPerTypeSimilar(PortTemplateConsolidationData other) { + return this.subInterfaceConsolidationData.isEmpty() && other.subInterfaceConsolidationData.isEmpty() + || !this.subInterfaceConsolidationData.isEmpty() && !other.subInterfaceConsolidationData.isEmpty() + && this.subInterfaceConsolidationData.keySet().stream().allMatch( + subInterfaceType -> calculateSize(other.subInterfaceConsolidationData.get(subInterfaceType)) + == calculateSize(this.subInterfaceConsolidationData.get(subInterfaceType))); - if (this.subInterfaceConsolidationData.isEmpty() && - other.subInterfaceConsolidationData.isEmpty()) { - return true; - } - - return !this.subInterfaceConsolidationData.isEmpty() - && !other.subInterfaceConsolidationData.isEmpty() - && this.subInterfaceConsolidationData.keySet().stream().allMatch(subInterfaceType -> - calculateSize(other.subInterfaceConsolidationData.get(subInterfaceType)) == - calculateSize(this.subInterfaceConsolidationData.get(subInterfaceType))); } private int calculateSize(List<SubInterfaceTemplateConsolidationData> subInterfaces) { return subInterfaces == null ? 0 : subInterfaces.size(); } + + }
\ No newline at end of file diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java index 0a94d2a3d9..f5eac507f1 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java @@ -1,5 +1,22 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.openecomp.sdc.translator.services.heattotosca; +import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.MapUtils; import org.apache.commons.lang3.StringUtils; import org.openecomp.core.utilities.file.FileUtils; @@ -8,6 +25,7 @@ import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration; import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate; import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes; import org.openecomp.sdc.heat.datatypes.model.Resource; +import org.openecomp.sdc.tosca.datatypes.ToscaNodeType; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; @@ -28,6 +46,7 @@ import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolida import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData; import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder; @@ -37,6 +56,7 @@ import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Optional; /** @@ -47,6 +67,9 @@ public class ConsolidationDataUtil { private static final String UNDERSCORE = "_"; private static final String DIGIT_REGEX = "\\d+"; + private ConsolidationDataUtil() { + } + /** * Gets compute template consolidation data. * @@ -106,10 +129,11 @@ public class ConsolidationDataUtil { * @param portNodeTemplateId the port node template id * @return the port template consolidation data */ - public static PortTemplateConsolidationData getPortTemplateConsolidationData( - TranslationContext context, - ServiceTemplate serviceTemplate, - String portNodeTemplateId) { + public static PortTemplateConsolidationData getPortTemplateConsolidationData(TranslationContext context, + ServiceTemplate serviceTemplate, + String portResourceId, + String portResourceType, + String portNodeTemplateId) { ConsolidationData consolidationData = context.getConsolidationData(); String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); @@ -128,15 +152,98 @@ public class ConsolidationDataUtil { PortTemplateConsolidationData portTemplateConsolidationData = filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId); if (portTemplateConsolidationData == null) { + portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId, + portResourceId, portResourceType); + filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData); + } + + return portTemplateConsolidationData; + } + + private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId, + String portResourceId, + String portResourceType) { + PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData(); + portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId); + Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId, + portResourceType); + portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole); + return portTemplateConsolidationData; + } + + public static Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData( + TranslateTo subInterfaceTo, + String subInterfaceNodeTemplateId) { + Optional<String> parentPortNodeTemplateId = + HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo); + if (parentPortNodeTemplateId.isPresent()) { + return Optional.ofNullable(getSubInterfaceTemplateConsolidationData(subInterfaceTo, + parentPortNodeTemplateId.get(), subInterfaceNodeTemplateId)); + } + return Optional.empty(); + } + + private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData( + TranslateTo subInterfaceTo, + String parentPortNodeTemplateId, + String subInterfaceNodeTemplateId) { + + ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData(); + String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate()); + + PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData(); + + FilePortConsolidationData filePortConsolidationData = portConsolidationData + .getFilePortConsolidationData(serviceTemplateFileName); + + if (filePortConsolidationData == null) { + filePortConsolidationData = new FilePortConsolidationData(); + portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName, + filePortConsolidationData); + } + + PortTemplateConsolidationData portTemplateConsolidationData = + filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId); + if (portTemplateConsolidationData == null) { portTemplateConsolidationData = new PortTemplateConsolidationData(); - portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId); - filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, + portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId); + filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId, portTemplateConsolidationData); } - return portTemplateConsolidationData; + return getSubInterfaceResourceTemplateConsolidationData(subInterfaceTo.getResource(), portTemplateConsolidationData, + subInterfaceNodeTemplateId, parentPortNodeTemplateId); } + private static SubInterfaceTemplateConsolidationData getSubInterfaceResourceTemplateConsolidationData( + Resource resource, + PortTemplateConsolidationData portTemplateConsolidationData, + String subInterfaceNodeTemplateId, + String parentPortNodeTemplateId) { + String subInterfaceType = ToscaNodeType.VLAN_SUB_INTERFACE_RESOURCE_TYPE_PREFIX + + FileUtils.getFileWithoutExtention(HeatToToscaUtil.getSubInterfaceResourceType(resource)); + SubInterfaceTemplateConsolidationData data = new SubInterfaceTemplateConsolidationData(); + data.setNodeTemplateId(subInterfaceNodeTemplateId); + data.setParentPortNodeTemplateId(parentPortNodeTemplateId); + if (CollectionUtils.isNotEmpty(portTemplateConsolidationData.getSubInterfaceConsolidationData(subInterfaceType))) { + boolean isNewSubInterface = true; + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + portTemplateConsolidationData.getSubInterfaceConsolidationData(subInterfaceType); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + if (subInterfaceNodeTemplateId.equals(subInterfaceTemplateConsolidationData.getNodeTemplateId())) { + data = subInterfaceTemplateConsolidationData; + isNewSubInterface = false; + } + } + if (isNewSubInterface) { + portTemplateConsolidationData.addSubInterfaceConsolidationData(subInterfaceType, data); + } + } else { + portTemplateConsolidationData.addSubInterfaceConsolidationData(subInterfaceType, data); + } + return data; + } /** * Gets nested template consolidation data. @@ -250,10 +357,13 @@ public class ConsolidationDataUtil { * * @param translateTo the translate to * @param computeNodeType the compute node type + * @param portResourceId the port resource id * @param portNodeTemplateId the port node template id */ public static void updatePortInConsolidationData(TranslateTo translateTo, String computeNodeType, + String portResourceId, + String portResourceType, String portNodeTemplateId) { TranslationContext translationContext = translateTo.getContext(); ServiceTemplate serviceTemplate = translateTo.getServiceTemplate(); @@ -262,7 +372,8 @@ public class ConsolidationDataUtil { translateTo.getTranslatedId()); computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId); // create port in consolidation data - getPortTemplateConsolidationData(translationContext, serviceTemplate, portNodeTemplateId); + getPortTemplateConsolidationData(translationContext, serviceTemplate, portResourceId, + portResourceType, portNodeTemplateId); } /** @@ -278,12 +389,7 @@ public class ConsolidationDataUtil { String nodeTemplateId, String requirementId, RequirementAssignment requirementAssignment) { ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER; - HeatOrchestrationTemplate heatOrchestrationTemplate = translateTo - .getHeatOrchestrationTemplate(); - TranslationContext translationContext = translateTo.getContext(); - - consolidationEntityType.setEntityType(heatOrchestrationTemplate, sourceResource, - targetResource, translateTo.getContext()); + consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext()); // Add resource dependency information in nodesConnectedIn if the target node // is a consolidation entity if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) { @@ -304,10 +410,7 @@ public class ConsolidationDataUtil { private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) { - return (consolidationEntityType == ConsolidationEntityType.COMPUTE - || consolidationEntityType == ConsolidationEntityType.PORT - || consolidationEntityType == ConsolidationEntityType.NESTED - || consolidationEntityType == ConsolidationEntityType.VFC_NESTED); + return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType); } /** @@ -340,8 +443,17 @@ public class ConsolidationDataUtil { entityConsolidationData = getComputeTemplateConsolidationData(translationContext, serviceTemplate, nodeType, translateTo.getTranslatedId()); } else if (consolidationEntityType == ConsolidationEntityType.PORT) { - entityConsolidationData = getPortTemplateConsolidationData(translationContext, - serviceTemplate, translateTo.getTranslatedId()); + entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate, + translateTo.getResourceId(), translateTo.getResource().getType(), translateTo + .getTranslatedId()); + } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE + && Objects.nonNull(serviceTemplate.getTopology_template().getNode_templates() + .get(translateTo.getTranslatedId()))) { + Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData = + getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId()); + if (subInterfaceTemplateConsolidationData.isPresent()) { + entityConsolidationData = subInterfaceTemplateConsolidationData.get(); + } } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED || consolidationEntityType == ConsolidationEntityType.NESTED) { entityConsolidationData = @@ -350,17 +462,15 @@ public class ConsolidationDataUtil { translateTo.getTranslatedId()); } - if (Objects.isNull(entityConsolidationData)) { - return; - } + if (Objects.nonNull(entityConsolidationData)) { + if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) { + entityConsolidationData.setNodesConnectedOut(new HashMap<>()); + } - if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) { - entityConsolidationData.setNodesConnectedOut(new HashMap<>()); + entityConsolidationData.getNodesConnectedOut() + .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>()) + .add(requirementAssignmentData); } - - entityConsolidationData.getNodesConnectedOut() - .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>()) - .add(requirementAssignmentData); } /** @@ -386,7 +496,7 @@ public class ConsolidationDataUtil { if (consolidationEntityType == ConsolidationEntityType.COMPUTE) { NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, dependentNodeTemplateId); - String nodeType = null; + String nodeType; if (Objects.isNull(computeNodeTemplate)) { Resource targetResource = translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId); @@ -403,8 +513,18 @@ public class ConsolidationDataUtil { entityConsolidationData = getComputeTemplateConsolidationData(translationContext, serviceTemplate, nodeType, dependentNodeTemplateId); } else if (consolidationEntityType == ConsolidationEntityType.PORT) { - entityConsolidationData = getPortTemplateConsolidationData(translationContext, - serviceTemplate, dependentNodeTemplateId); + entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate, + translateTo.getResourceId(), translateTo.getResource().getType(), dependentNodeTemplateId); + } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE) { + Resource targetResource = + translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId); + TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate, translateTo + .getHeatOrchestrationTemplate(), targetResource, targetResourceId, null, translationContext); + Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData = + getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId); + if (subInterfaceTemplateConsolidationData.isPresent()) { + entityConsolidationData = subInterfaceTemplateConsolidationData.get(); + } } else if (consolidationEntityType == ConsolidationEntityType.NESTED || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) { entityConsolidationData = getNestedTemplateConsolidationData(translationContext, @@ -501,9 +621,9 @@ public class ConsolidationDataUtil { public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate, String resourceId) { String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType(); - return (resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()) + return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()) || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE - .getHeatResource())); + .getHeatResource()); } /** @@ -514,9 +634,9 @@ public class ConsolidationDataUtil { */ public static boolean isVolumeResource(Resource resource) { String resourceType = resource.getType(); - return (resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()) + return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()) || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE - .getHeatResource())); + .getHeatResource()); } /** @@ -579,10 +699,9 @@ public class ConsolidationDataUtil { } if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate, contrailSharedResourceId)) { - NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, - sharedTranslatedResourceId); - EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, - serviceTemplate, sharedTranslatedResourceId); + Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId); + EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, serviceTemplate, + contrailSharedResourceId, resource.getType(), sharedTranslatedResourceId); List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData .getOutputParametersGetAttrIn(); removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList); diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationEntityType.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationEntityType.java index 8e6e9024fb..dd7825b9a5 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationEntityType.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationEntityType.java @@ -1,13 +1,34 @@ -package org.openecomp.sdc.translator.services.heattotosca; +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ -import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate; -import org.openecomp.sdc.heat.datatypes.model.Resource; -import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; +package org.openecomp.sdc.translator.services.heattotosca; import static org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil.isComputeResource; import static org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil.isPortResource; import static org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil.isVolumeResource; +import org.openecomp.sdc.heat.datatypes.model.Resource; +import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; + +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; +import java.util.stream.Collectors; + /** * The enum Entity type. */ @@ -19,7 +40,7 @@ public enum ConsolidationEntityType { //Simple nested VFC (nested file with one compute) or a complex VFC (nested ST with more than //one compute) VFC_NESTED, - SUB_PORT, + SUB_INTERFACE, OTHER; private ConsolidationEntityType sourceEntityType; @@ -33,39 +54,54 @@ public enum ConsolidationEntityType { return targetEntityType; } + /** * Sets entity type. * - * @param heatOrchestrationTemplate the heat orchestration template * @param sourceResource the source resource * @param targetResource the target resource */ - public void setEntityType(HeatOrchestrationTemplate heatOrchestrationTemplate, - Resource sourceResource, + public void setEntityType(Resource sourceResource, Resource targetResource, TranslationContext context) { targetEntityType = - getEntityType(heatOrchestrationTemplate, targetResource, context); + getEntityType(targetResource, context); sourceEntityType = - getEntityType(heatOrchestrationTemplate, sourceResource, context); + getEntityType(sourceResource, context); + } + + private static final Set<ConsolidationEntityType> consolidationEntityTypes = initConsolidationEntities(); + + private static Set<ConsolidationEntityType> initConsolidationEntities() { + Set<ConsolidationEntityType> consolidationEntityTypes = new HashSet<>(Arrays.asList(ConsolidationEntityType + .values())); + return Collections.unmodifiableSet(consolidationEntityTypes.stream() + .filter(entity -> entity != ConsolidationEntityType.OTHER + && entity != ConsolidationEntityType.VOLUME) + .collect(Collectors.toSet())); + } + + public static Set<ConsolidationEntityType> getSupportedConsolidationEntities() { + return consolidationEntityTypes; } - private ConsolidationEntityType getEntityType(HeatOrchestrationTemplate heatOrchestrationTemplate, - Resource resource, TranslationContext context) { + private ConsolidationEntityType getEntityType(Resource resource, TranslationContext context) { + ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER; if (isComputeResource(resource)) { - return ConsolidationEntityType.COMPUTE; + consolidationEntityType = ConsolidationEntityType.COMPUTE; } else if (isPortResource(resource)) { - return ConsolidationEntityType.PORT; + consolidationEntityType = ConsolidationEntityType.PORT; + } else if (HeatToToscaUtil.isSubInterfaceResource(resource, context)) { + consolidationEntityType = ConsolidationEntityType.SUB_INTERFACE; } else if (isVolumeResource(resource)) { - return ConsolidationEntityType.VOLUME; + consolidationEntityType = ConsolidationEntityType.VOLUME; } else if (HeatToToscaUtil.isNestedResource(resource)) { if (HeatToToscaUtil.isNestedVfcResource(resource, context)) { - return ConsolidationEntityType.VFC_NESTED; + consolidationEntityType = ConsolidationEntityType.VFC_NESTED; } else { - return ConsolidationEntityType.NESTED; + consolidationEntityType = ConsolidationEntityType.NESTED; } - } else { - return ConsolidationEntityType.OTHER; } + return consolidationEntityType; } }
\ No newline at end of file diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java index bc5a3c7e3a..c4762037a6 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java @@ -920,6 +920,8 @@ public class ConsolidationService { } } } + unifiedCompositionData.setSubInterfaceTemplateConsolidationDataList( + subInterfaceTemplateConsolidationDataList); unifiedCompositionDataList.add(unifiedCompositionData); } @@ -1034,13 +1036,13 @@ public class ConsolidationService { List<String> getPropertiesWithIdenticalVal(UnifiedCompositionEntity entity) { switch (entity) { - case Compute: + case COMPUTE: return getComputePropertiesWithIdenticalVal(); - case Other: + case OTHER: return getComputePropertiesWithIdenticalVal(); - case Port: + case PORT: return getPortPropertiesWithIdenticalVal(); default: diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java index 63990862ba..98e650719e 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java @@ -1,61 +1,29 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca; public class Constants { //Service Template - Template Names - public static final String COMMON_GLOBAL_TEMPLATE_NAME = "CommonGlobalTypes"; - public static final String CINDER_VOLUME_TEMPLATE_NAME = "CinderVolumeGlobalTypes"; - public static final String CONTRAIL_VIRTUAL_NETWORK_TEMPLATE_NAME = - "ContrailVirtualNetworkGlobalType"; - public static final String CONTRAIL_NETWORK_RULE_TEMPLATE_NAME = "ContrailNetworkRuleGlobalType"; - public static final String CONTRAILV2_VIRTUAL_NETWORK_TEMPLATE_NAME = - "ContrailV2VirtualNetworkGlobalType"; - public static final String CONTRAILV2_NETWORK_RULE_TEMPLATE_NAME = - "ContrailV2NetworkRuleGlobalType"; - public static final String CONTRAILV2_VIRTUAL_MACHINE_INTERFACE_TEMPLATE_NAME = - "ContrailV2VirtualMachineInterfaceGlobalType"; - public static final String NEUTRON_NET_TEMPLATE_NAME = "NeutronNetGlobalTypes"; - public static final String NEUTRON_PORT_TEMPLATE_NAME = "NeutronPortGlobalTypes"; - public static final String NEUTRON_SECURITY_RULES_TEMPLATE_NAME = - "NeutronSecurityRulesGlobalTypes"; - public static final String NOVA_SERVER_TEMPLATE_NAME = "NovaServerGlobalTypes"; - public static final String ABSTRACT_SUBSTITUTE_TEMPLATE_NAME = "AbstractSubstituteGlobalTypes"; public static final String GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME = "GlobalSubstitutionTypes"; - public static final String CONTRAIL_COMPUTE_TEMPLATE_NAME = "ContrailComputeGlobalTypes"; - public static final String CONTRAIL_PORT_TEMPLATE_NAME = "ContrailPortGlobalTypes"; - public static final String CONTRAIL_ABSTRACT_SUBSTITUTE_TEMPLATE_NAME = - "ContrailAbstractSubstituteGlobalTypes"; public static final String MAIN_TEMPLATE_NAME = "Main"; - public static final String PORT_TEMPLATE_NAME = "PortGlobalTypes"; - public static final String COMPUTE_TEMPLATE_NAME = "ComputeGlobalTypes"; - public static final String NETWORK_TEMPLATE_NAME = "NetworkGlobalTypes"; - public static final String SUB_INTERFACE_TEMPLATE_NAME = "SubInterfaceGlobalTypes"; - public static final String CONTRAILV2_VLAN_SUB_INTERFACE_TEMPLATE_NAME = - "ContrailV2VLANSubInterfaceGlobalType"; //properties public static final String MAX_INSTANCES_PROPERTY_NAME = "max_instances"; public static final String DESCRIPTION_PROPERTY_NAME = "description"; public static final String NAME_PROPERTY_NAME = "name"; - public static final String RULES_PROPERTY_NAME = "rules"; public static final String SECURITY_GROUPS_PROPERTY_NAME = "security_groups"; public static final String PORT_PROPERTY_NAME = "port"; //General @@ -64,9 +32,10 @@ public class Constants { public static final String SERVICE_INSTANCE_PORT_PREFIX = "port_"; public static final String SERVICE_INSTANCE_LINK_PREFIX = "link_"; //Unified model - public static final String COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX = "vm_"; - public static final String COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX = "_name"; - public static final String PORT_IDENTICAL_VALUE_PROPERTY_PREFIX = "port_"; + static final String COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX = "vm_"; + static final String COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX = "_name"; + static final String PORT_IDENTICAL_VALUE_PROPERTY_PREFIX = "port_"; + static final String SUB_INTERFACE_PROPERTY_VALUE_PREFIX = "subinterface_"; public static final String ABSTRACT_NODE_TEMPLATE_ID_PREFIX = "abstract_"; private Constants() { diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/HeatToToscaUtil.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/HeatToToscaUtil.java index dafd8e6207..370f48915a 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/HeatToToscaUtil.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/HeatToToscaUtil.java @@ -1,5 +1,5 @@ /* - * Copyright © 2016-2017 European Support Limited + * Copyright © 2016-2018 European Support Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -36,6 +36,7 @@ import org.openecomp.sdc.heat.datatypes.manifest.FileData; import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate; import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes; import org.openecomp.sdc.heat.datatypes.model.Resource; +import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions; import org.openecomp.sdc.heat.datatypes.structure.HeatStructureTree; import org.openecomp.sdc.heat.datatypes.structure.ValidationStructureList; import org.openecomp.sdc.heat.services.HeatConstants; @@ -45,6 +46,7 @@ import org.openecomp.sdc.logging.api.Logger; import org.openecomp.sdc.logging.api.LoggerFactory; import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType; import org.openecomp.sdc.tosca.datatypes.ToscaElementTypes; +import org.openecomp.sdc.tosca.datatypes.ToscaFunctions; import org.openecomp.sdc.tosca.datatypes.ToscaNodeType; import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType; import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel; @@ -76,12 +78,15 @@ import org.openecomp.sdc.translator.datatypes.heattotosca.to.FileDataCollection; import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo; import org.openecomp.sdc.translator.services.heattotosca.errors.ResourceNotFoundInHeatFileErrorBuilder; import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator; +import org.openecomp.sdc.translator.services.heattotosca.helper.ContrailV2VirtualMachineInterfaceHelper; import org.openecomp.sdc.translator.services.heattotosca.helper.FunctionTranslationHelper; +import org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation.ResourceTranslationBase; import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaPropertyConverter; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; @@ -100,9 +105,11 @@ public class HeatToToscaUtil { private static final Logger LOGGER = LoggerFactory.getLogger(HeatToToscaUtil.class); public static final String FQ_NAME = "fq_name"; public static final String GET_PARAM = "get_param"; - private static final String FORWARDER = "forwarder"; private static final String GET_ATTR = "get_attr"; private static final String GET_RESOURCE = "get_resource"; + private static final String VMI = "vmi"; + private static final String NEUTRON_PORT_IDENTIFIER = "port"; + private static final String UNDERSCORE = "_"; /** * Load and translate template data translator output. @@ -285,7 +292,7 @@ public class HeatToToscaUtil { List<String> filenames, Set<String> referenced) { Object resourceDef = resource.getProperties().get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME); - Object innerTypeDef = ((Map) resourceDef).get("type"); + Object innerTypeDef = ((Map) resourceDef).get(HeatConstants.RESOURCE_DEF_TYPE_PROPERTY_NAME); if (innerTypeDef instanceof String) { String internalResourceType = (String) innerTypeDef; if (filenames.contains(internalResourceType)) { @@ -519,12 +526,14 @@ public class HeatToToscaUtil { if (resourceType.equals(HeatResourcesTypes.RESOURCE_GROUP_RESOURCE_TYPE.getHeatResource())) { Object resourceDef = resource.getProperties().get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME); - if (!(((Map) resourceDef).get("type") instanceof String)) { + if (!(((Map) resourceDef).get(HeatConstants.RESOURCE_DEF_TYPE_PROPERTY_NAME) instanceof + String)) { //currently only resource group which is poinitng to nested heat file is supported //dynamic type is currently not supported return false; } - String internalResourceType = (String) ((Map) resourceDef).get("type"); + String internalResourceType = (String) ((Map) resourceDef).get(HeatConstants + .RESOURCE_DEF_TYPE_PROPERTY_NAME); if (isYamlFile(internalResourceType)) { return true; } @@ -535,6 +544,108 @@ public class HeatToToscaUtil { } /** + * Checks if the current HEAT resource if of type sub interface. + * + * @param resource the resource + * @return true if the resource is of sub interface type and false otherwise + */ + public static boolean isSubInterfaceResource(Resource resource, TranslationContext context) { + if (!ToggleableFeature.VLAN_TAGGING.isActive()) { + //Remove this once feature is stable and moved to production + return false; + } + //Check if resource group is a nested resource + if (!isNestedResource(resource)) { + return false; + } + Optional<String> nestedHeatFileName = HeatToToscaUtil.getNestedHeatFileName(resource); + return nestedHeatFileName.filter(fileName -> + isNestedVlanResource(fileName, context)).isPresent(); + } + + private static boolean isNestedVlanResource(String nestedHeatFileName, + TranslationContext translationContext) { + HeatOrchestrationTemplate nestedHeatOrchestrationTemplate = new YamlUtil() + .yamlToObject(translationContext.getFileContent(nestedHeatFileName), + HeatOrchestrationTemplate.class); + return Objects.nonNull(nestedHeatOrchestrationTemplate.getResources()) + && nestedHeatOrchestrationTemplate.getResources().values().stream() + .anyMatch(new ContrailV2VirtualMachineInterfaceHelper()::isVlanSubInterfaceResource); + } + + public static Optional<String> getSubInterfaceParentPortNodeTemplateId(TranslateTo subInterfaceTo) { + String subInterfaceResourceType = getSubInterfaceResourceType(subInterfaceTo.getResource()); + HeatOrchestrationTemplate nestedHeatOrchestrationTemplate = new YamlUtil() + .yamlToObject(subInterfaceTo.getContext().getFileContent(subInterfaceResourceType), + HeatOrchestrationTemplate.class); + if (Objects.isNull(nestedHeatOrchestrationTemplate.getResources())) { + return Optional.empty(); + } + for (Map.Entry<String, Resource> resourceEntry : nestedHeatOrchestrationTemplate + .getResources().entrySet()) { + Resource resource = resourceEntry.getValue(); + if (isVmiRefsPropertyExists(resource)) { + Object toscaPropertyValue = + TranslatorHeatToToscaPropertyConverter.getToscaPropertyValue(subInterfaceTo.getServiceTemplate(), + resourceEntry.getKey(), HeatConstants.VMI_REFS_PROPERTY_NAME, + resource.getProperties().get(HeatConstants.VMI_REFS_PROPERTY_NAME), + resource.getType(), subInterfaceResourceType, nestedHeatOrchestrationTemplate, + null, subInterfaceTo.getContext()); + return getParentNodeTemplateIdFromPropertyValue(toscaPropertyValue, subInterfaceTo); + } + } + return Optional.empty(); + } + + private static boolean isVmiRefsPropertyExists(Resource resource) { + return HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE + .getHeatResource().equals(resource.getType()) + && MapUtils.isNotEmpty(resource.getProperties()) + && resource.getProperties().containsKey(HeatConstants.VMI_REFS_PROPERTY_NAME); + } + + public static String getSubInterfaceResourceType(Resource resource) { + if (!HeatToToscaUtil.isYamlFile(resource.getType())) { + return ((Map) resource.getProperties() + .get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME)) + .get(HeatConstants.RESOURCE_DEF_TYPE_PROPERTY_NAME) + .toString(); + } + return resource.getType(); + } + + private static Optional<String> getParentNodeTemplateIdFromPropertyValue(Object toscaPropertyValue, + TranslateTo subInterfaceTo) { + if (toscaPropertyValue instanceof List + && ((List) toscaPropertyValue).get(0) instanceof Map) { + Resource subInterfaceResource = subInterfaceTo.getResource(); + Map<String, String> toscaPropertyValueMap = (Map) ((List) toscaPropertyValue).get(0); + String parentPortPropertyInput = toscaPropertyValueMap.get(ToscaFunctions.GET_INPUT + .getDisplayName()); + Map<String, Object> resourceDefPropertiesMap; + if (!isYamlFile(subInterfaceResource.getType())) { + resourceDefPropertiesMap = (Map)((Map) subInterfaceResource + .getProperties().get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME)) + .get(HeatConstants.RESOURCE_DEF_PROPERTIES); + } else { + resourceDefPropertiesMap = subInterfaceResource.getProperties(); + } + Object parentPortObj = resourceDefPropertiesMap.get(parentPortPropertyInput); + if (parentPortObj instanceof Map) { + Map<String, String> parentPortPropertyValue = (Map) parentPortObj; + if (parentPortPropertyValue.keySet().contains(ResourceReferenceFunctions + .GET_RESOURCE.getFunction())) { + return ResourceTranslationBase.getResourceTranslatedId(subInterfaceTo.getHeatFileName(), + subInterfaceTo.getHeatOrchestrationTemplate(), + parentPortPropertyValue.get(ResourceReferenceFunctions.GET_RESOURCE.getFunction()), + subInterfaceTo.getContext()); + } + } + } + return Optional.empty(); + } + + /** * Checks if the nested resource represents a VFC or a complex VFC (Heat file should contain at * least one or more compute nodes). * @@ -573,7 +684,8 @@ public class HeatToToscaUtil { if (resourceType.equals(HeatResourcesTypes.RESOURCE_GROUP_RESOURCE_TYPE.getHeatResource())) { Object resourceDef = resource.getProperties().get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME); - String internalResourceType = (String) ((Map) resourceDef).get("type"); + String internalResourceType = (String) ((Map) resourceDef).get(HeatConstants + .RESOURCE_DEF_TYPE_PROPERTY_NAME); return Optional.of(internalResourceType); } return Optional.of(resourceType); @@ -592,14 +704,15 @@ public class HeatToToscaUtil { String resourceType = resource.getType(); if (resourceType.equals(HeatResourcesTypes.RESOURCE_GROUP_RESOURCE_TYPE.getHeatResource())) { Object resourceDef = resource.getProperties().get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME); - String internalResourceType = (String) ((Map) resourceDef).get("type"); + String internalResourceType = (String) ((Map) resourceDef).get(HeatConstants + .RESOURCE_DEF_TYPE_PROPERTY_NAME); return Optional.of(internalResourceType); } else { return Optional.of(resourceType); } } - private static boolean isYamlFile(String fileName) { + public static boolean isYamlFile(String fileName) { return fileName.endsWith(".yaml") || fileName.endsWith(".yml"); } @@ -800,7 +913,10 @@ public class HeatToToscaUtil { return Optional.empty(); } Optional<AttachedPropertyVal> extractedProperty = extractProperty(property); - return extractedProperty.flatMap(HeatToToscaUtil::getParameterName); + if (extractedProperty.isPresent()) { + return getParameterName(extractedProperty.get()); + } + return Optional.empty(); } private static Optional<String> getParameterName(AttachedPropertyVal extractedProperty) { @@ -1063,25 +1179,22 @@ public class HeatToToscaUtil { * Checks if the source and target resource is a valid candidate for adding tosca dependency * relationship. * - * @param heatOrchestrationTemplate the heat orchestration template * @param sourceResource the source resource * @param targetResource the target resource * @param dependencyEntity the dependency entity * @return true if the candidate resources are a valid combination for the dependency relationship - * and false otherwise + * and false otherwise */ - public static boolean isValidDependsOnCandidate(HeatOrchestrationTemplate - heatOrchestrationTemplate, - Resource sourceResource, + public static boolean isValidDependsOnCandidate(Resource sourceResource, Resource targetResource, ConsolidationEntityType dependencyEntity, TranslationContext context) { - dependencyEntity - .setEntityType(heatOrchestrationTemplate, sourceResource, targetResource, context); + dependencyEntity.setEntityType(sourceResource, targetResource, context); ConsolidationEntityType sourceEntityType = dependencyEntity.getSourceEntityType(); ConsolidationEntityType targetEntityType = dependencyEntity.getTargetEntityType(); - return ConsolidationTypesConnectivity.isDependsOnRelationshipValid(sourceEntityType, targetEntityType); + return ConsolidationTypesConnectivity + .isDependsOnRelationshipValid(sourceEntityType, targetEntityType); } private static Map<String, Object> managerSubstitutionNodeTemplateProperties( @@ -1183,17 +1296,12 @@ public class HeatToToscaUtil { flatNodeType.getCapabilities() .entrySet() .stream() - .filter(capabilityNodeEntry -> shouldCapabilityNeedsToBeAdded(capabilityNodeEntry.getKey())) .forEach(capabilityNodeEntry -> addCapabilityToSubMapping( templateName, capabilityNodeEntry, nodeTypeCapabilitiesDefinition, capabilitySubstitutionMapping)); } } - private static boolean shouldCapabilityNeedsToBeAdded(String capabilityKey) { - return !capabilityKey.contains(FORWARDER) || ToggleableFeature.FORWARDER_CAPABILITY.isActive(); - } - public static boolean shouldAnnotationsToBeAdded() { return ToggleableFeature.ANNOTATIONS.isActive(); } @@ -1204,7 +1312,7 @@ public class HeatToToscaUtil { Map<String, List<String>> capabilitySubstitutionMapping) { String capabilityKey; List<String> capabilityMapping; - capabilityKey = capabilityNodeEntry.getKey() + "_" + templateName; + capabilityKey = capabilityNodeEntry.getKey() + UNDERSCORE + templateName; nodeTypeCapabilitiesDefinition.put(capabilityKey, capabilityNodeEntry.getValue().clone()); capabilityMapping = new ArrayList<>(); capabilityMapping.add(templateName); @@ -1243,7 +1351,7 @@ public class HeatToToscaUtil { requirementMapping.add(templateName); requirementMapping.add(requirementNodeEntry.getKey()); requirementSubstitutionMapping - .put(requirementNodeEntry.getKey() + "_" + templateName, requirementMapping); + .put(requirementNodeEntry.getKey() + UNDERSCORE + templateName, requirementMapping); if (Objects.isNull(requirementNodeEntryValue.getNode())) { requirementNodeEntryValue.setOccurrences(new Object[]{1, 1}); } @@ -1354,4 +1462,66 @@ public class HeatToToscaUtil { return serviceTemplatesMap; } + public static String getNestedResourceTypePrefix(TranslateTo translateTo) { + String nestedFileName = translateTo.getResource().getType(); + if (isSubInterfaceResource(translateTo.getResource(), translateTo.getContext()) + && isSubInterfaceBoundToPort(translateTo)) { + return ToscaNodeType.VLAN_SUB_INTERFACE_RESOURCE_TYPE_PREFIX; + } + return ToscaNodeType.NESTED_HEAT_RESOURCE_TYPE_PREFIX; + } + + private static boolean isSubInterfaceBoundToPort(TranslateTo translateTo) { + return HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(translateTo).isPresent(); + } + + //Method evaluate the network role from sub interface node template id, designed considering + // only single sub interface present in nested file else it will return null + public static Optional<String> getNetworkRoleFromResource(Resource resource, + TranslationContext translationContext) { + Optional<String> networkRole = Optional.empty(); + Optional<String> nestedHeatFileName = HeatToToscaUtil.getNestedHeatFileName(resource); + + if (!nestedHeatFileName.isPresent()) { + return networkRole; + } + + HeatOrchestrationTemplate nestedHeatOrchestrationTemplate = new YamlUtil() + .yamlToObject(translationContext.getFileContent(nestedHeatFileName.get()), + HeatOrchestrationTemplate.class); + + if (MapUtils.isNotEmpty(nestedHeatOrchestrationTemplate.getResources())) { + ContrailV2VirtualMachineInterfaceHelper contrailV2VirtualMachineInterfaceHelper = + new ContrailV2VirtualMachineInterfaceHelper(); + Optional<Map.Entry<String, Resource>> vlanSubinterfaceResource = nestedHeatOrchestrationTemplate + .getResources().entrySet().stream() + .filter(resourceEntry -> contrailV2VirtualMachineInterfaceHelper + .isVlanSubInterfaceResource(resourceEntry.getValue())) + .findFirst(); + if (vlanSubinterfaceResource.isPresent()) { + Map.Entry<String, Resource> vlanSubinterfaceResourceEntry = vlanSubinterfaceResource.get(); + networkRole = evaluateNetworkRoleFromResourceId(vlanSubinterfaceResourceEntry.getKey(), + vlanSubinterfaceResourceEntry.getValue().getType()); + } + } + return networkRole; + } + + public static Optional<String> evaluateNetworkRoleFromResourceId(String resourceId, String resourceType) { + String[] splitStr = resourceId.toLowerCase().split(UNDERSCORE); + List<String> splitList = Arrays.asList(splitStr); + + if (resourceType.equals(HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE.getHeatResource())) { + if (splitList.contains(VMI)) { + return Optional.of(splitList.get(splitList.indexOf(VMI) - 1)); + } + } + + if (resourceType.equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource())) { + if (splitList.contains(NEUTRON_PORT_IDENTIFIER)) { + return Optional.of(splitList.get(splitList.indexOf(NEUTRON_PORT_IDENTIFIER) - 1)); + } + } + return Optional.empty(); + } } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java index cfab3fc022..84a9dcf442 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java @@ -1,25 +1,40 @@ /* - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca; +import static org.openecomp.sdc.tosca.services.DataModelUtil.getClonedObject; +import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.COMPUTE; +import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.PORT; +import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.SUB_INTERFACE; +import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX; +import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX; +import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX; +import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX; +import static org.openecomp.sdc.translator.services.heattotosca.Constants.SUB_INTERFACE_PROPERTY_VALUE_PREFIX; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getComputeTypeSuffix; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getConnectedComputeConsolidationData; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewComputeNodeTemplateId; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewPortNodeTemplateId; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewSubInterfaceNodeTemplateId; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfacePortTemplateConsolidationData; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfaceTemplateConsolidationDataList; +import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfaceTypeSuffix; + +import com.google.common.collect.ListMultimap; import org.apache.commons.collections.map.HashedMap; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.MapUtils; @@ -31,8 +46,6 @@ import org.openecomp.config.api.ConfigurationManager; import org.openecomp.core.utilities.CommonMethods; import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration; import org.openecomp.sdc.heat.services.HeatConstants; -import org.openecomp.sdc.logging.api.Logger; -import org.openecomp.sdc.logging.api.LoggerFactory; import org.openecomp.sdc.tosca.datatypes.ToscaFunctions; import org.openecomp.sdc.tosca.datatypes.ToscaGroupType; import org.openecomp.sdc.tosca.datatypes.ToscaNodeType; @@ -49,9 +62,9 @@ import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition; import org.openecomp.sdc.tosca.datatypes.model.PropertyType; import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate; import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; -import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition; import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping; +import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt; import org.openecomp.sdc.tosca.datatypes.model.heatextend.PropertyTypeExt; import org.openecomp.sdc.tosca.services.DataModelUtil; import org.openecomp.sdc.tosca.services.ToscaAnalyzerService; @@ -63,6 +76,9 @@ import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.compositi import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionMode; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.CommandImplNames; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.UnifiedSubstitutionNodeTemplateIdGenerator; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData; @@ -72,11 +88,12 @@ import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolida import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; +import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashMap; @@ -86,42 +103,41 @@ import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.regex.Pattern; - -import static org.openecomp.sdc.tosca.services.DataModelUtil.getClonedObject; -import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX; -import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX; -import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX; -import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX; +import java.util.stream.Collectors; public class UnifiedCompositionService { - protected static Logger logger = - (Logger) LoggerFactory.getLogger(UnifiedCompositionService.class); - private static Map<String, ImplementationConfiguration> unifiedCompositionImplMap; + private static final Map<String, ImplementationConfiguration> unifiedCompositionImplMap; + + private static final EnumMap<UnifiedCompositionEntity, String> unifiedSubstitutionNodeTemplateIdGeneratorImplMap; static { Configuration config = ConfigurationManager.lookup(); unifiedCompositionImplMap = config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE, ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class); + unifiedSubstitutionNodeTemplateIdGeneratorImplMap = new EnumMap<>(UnifiedCompositionEntity.class); + initNodeTemplateIdGeneratorImplMap(); + } + private static void initNodeTemplateIdGeneratorImplMap() { + unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(COMPUTE, CommandImplNames + .COMPUTE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL); + unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(PORT, CommandImplNames + .PORT_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL); + unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(SUB_INTERFACE, CommandImplNames + .SUB_INTERFACE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL); } - private ConsolidationService consolidationService = new ConsolidationService(); + private final ConsolidationService consolidationService = new ConsolidationService(); private static List<EntityConsolidationData> getPortConsolidationDataList( List<String> portIds, List<UnifiedCompositionData> unifiedCompositionDataList) { - List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>(); - for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) { - for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData - .getPortTemplateConsolidationDataList()) { - if (portIds.contains(portTemplateConsolidationData.getNodeTemplateId())) { - portConsolidationDataList.add(portTemplateConsolidationData); - } - } - } - return portConsolidationDataList; + return unifiedCompositionDataList.stream() + .flatMap(unifiedCompositionData -> unifiedCompositionData.getPortTemplateConsolidationDataList().stream()) + .filter(portTemplateConsolidationData -> portIds.contains(portTemplateConsolidationData.getNodeTemplateId())) + .collect(Collectors.toList()); } /** @@ -170,9 +186,7 @@ public class UnifiedCompositionService { if (CollectionUtils.isEmpty(unifiedCompositionDataList)) { return Optional.empty(); } - UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0); - String templateName = - getTemplateName(serviceTemplate, unifiedCompositionData, substitutionNodeTypeId, index); + String templateName = getTemplateName(substitutionNodeTypeId, index); ServiceTemplate substitutionServiceTemplate = HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName); @@ -183,11 +197,14 @@ public class UnifiedCompositionService { context); handlePorts(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, computeNodeType, context); - createOutputParameters(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, - computeNodeType, context); + + UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate, + substitutionServiceTemplate, unifiedCompositionDataList, context); + handleSubInterfaces(unifiedCompositionTo); + createOutputParameters(unifiedCompositionTo, computeNodeType); NodeType substitutionGlobalNodeType = handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate, - context, unifiedCompositionData, substitutionNodeTypeId, index); + context, substitutionNodeTypeId); HeatToToscaUtil.handleSubstitutionMapping(context, substitutionNodeTypeId, @@ -224,9 +241,13 @@ public class UnifiedCompositionService { directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE); substitutionNodeTemplate.setDirectives(directiveList); substitutionNodeTemplate.setType(substituteNodeTypeId); - Optional<Map<String, Object>> abstractSubstitutionProperties = - createAbstractSubstitutionProperties(serviceTemplate, - substitutionServiceTemplate, unifiedCompositionDataList, context); + Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil + .getInputParameters(substitutionServiceTemplate); + Optional<Map<String, Object>> abstractSubstitutionProperties = Optional.empty(); + if (Objects.nonNull(substitutionTemplateInputs)) { + abstractSubstitutionProperties = createAbstractSubstitutionProperties(serviceTemplate, + substitutionTemplateInputs, unifiedCompositionDataList, context); + } abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties); //Add substitution filtering property @@ -237,9 +258,7 @@ public class UnifiedCompositionService { substitutionNodeTemplate, count); //Add index_value property addIndexValueProperty(substitutionNodeTemplate); - String substituteNodeTemplateId = - getSubstituteNodeTemplateId(serviceTemplate, unifiedCompositionDataList.get(0), - substituteNodeTypeId, index); + String substituteNodeTemplateId = getSubstituteNodeTemplateId(substituteNodeTypeId, index); //Add node template id and related abstract node template id in context addUnifiedSubstitionData(context, serviceTemplate, unifiedCompositionDataList, substituteNodeTemplateId); @@ -287,18 +306,27 @@ public class UnifiedCompositionService { List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) { + //Clean compute node template data from top level service template ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData.getComputeTemplateConsolidationData(); cleanServiceTemplate(serviceTemplate, computeTemplateConsolidationData, context); + //Clean port node template data from top level service template List<PortTemplateConsolidationData> portTemplateConsolidationDataList = getPortTemplateConsolidationDataList(unifiedCompositionData); for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) { cleanServiceTemplate(serviceTemplate, portTemplateConsolidationData, context); } - } + //Clean sub-interface node template data from top level service template + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + cleanServiceTemplate(serviceTemplate, subInterfaceTemplateConsolidationData, context); + } + } } /** @@ -322,10 +350,10 @@ public class UnifiedCompositionService { } public void updateSubstitutionNodeTypePrefix(ServiceTemplate substitutionServiceTemplate) { - Map<String, NodeTemplate> node_templates = + Map<String, NodeTemplate> nodeTemplates = substitutionServiceTemplate.getTopology_template().getNode_templates(); - for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : node_templates.entrySet()) { + for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet()) { String nodeTypeId = nodeTemplateEntry.getValue().getType(); NodeType origNodeType = substitutionServiceTemplate.getNode_types().get(nodeTypeId); if (Objects.nonNull(origNodeType) @@ -409,8 +437,7 @@ public class UnifiedCompositionService { nestedServiceTemplate.getTopology_template().getSubstitution_mappings(); String nodeTypeId = substitutionMappings.getNode_type(); - Optional<String> newNestedNodeTypeId = - getNewNestedNodeTypeId(mainServiceTemplate, nestedServiceTemplate, context); + Optional<String> newNestedNodeTypeId = getNewNestedNodeTypeId(nestedServiceTemplate, context); ServiceTemplate globalSubstitutionServiceTemplate = context.getGlobalSubstitutionServiceTemplate(); @@ -480,7 +507,7 @@ public class UnifiedCompositionService { .getPortTemplateConsolidationData(portNodeTemplateId)); handleNodeTypeProperties(nestedServiceTemplate, - portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.Port, + portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.PORT, null, context); } } @@ -499,8 +526,6 @@ public class UnifiedCompositionService { updateNodeTypeProperties(nestedServiceTemplate, globalSubstitutionServiceTemplate, indexedNewNestedNodeTypeId); - //addComputeNodeTypeToGlobalST(); - } private void updateNodeTypeProperties(ServiceTemplate nestedServiceTemplate, @@ -555,7 +580,7 @@ public class UnifiedCompositionService { ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), newNestedNodeTypeId); return globalNodeTypeIndex > 0 ? newNestedNodeTypeId + "_" - + String.valueOf(globalNodeTypeIndex) : newNestedNodeTypeId; + + globalNodeTypeIndex : newNestedNodeTypeId; } private void updateUnifiedNestedTemplates(ServiceTemplate mainServiceTemplate, @@ -615,21 +640,19 @@ public class UnifiedCompositionService { } public void handleComplexVfcType(ServiceTemplate serviceTemplate, TranslationContext context) { - SubstitutionMapping substitution_mappings = + SubstitutionMapping substitutionMapping = serviceTemplate.getTopology_template().getSubstitution_mappings(); - if (Objects.isNull(substitution_mappings)) { + if (Objects.isNull(substitutionMapping)) { return; } ServiceTemplate globalSubstitutionServiceTemplate = context.getGlobalSubstitutionServiceTemplate(); - String substitutionNT = substitution_mappings.getNode_type(); + String substitutionNT = substitutionMapping.getNode_type(); if (globalSubstitutionServiceTemplate.getNode_types().containsKey(substitutionNT)) { - //todo - remove comment after integration with AT&T -// globalSubstitutionServiceTemplate.getNode_types().get(substitutionNT).setDerived_from -// (ToscaNodeType.COMPLEX_VFC_NODE_TYPE); + //This needs to be done when catalog is ready for complex VFC } } @@ -666,6 +689,30 @@ public class UnifiedCompositionService { newPortNodeTemplateId, portNodesConnectedOut, context); } } + //For sub-interface + //Add requirements in the abstract node template for nodes connected out for ports + updateSubInterfaceNodesConnectedOut(serviceTemplate, unifiedCompositionData, + computeTemplateConsolidationData, computeType, context); + } + } + + private void updateSubInterfaceNodesConnectedOut(ServiceTemplate serviceTemplate, + UnifiedCompositionData unifiedCompositionData, + ComputeTemplateConsolidationData computeTemplateConsolidationData, + String computeType, + TranslationContext context) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType, + computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context); + Map<String, List<RequirementAssignmentData>> subInterfaceNodesConnectedOut = + subInterfaceTemplateConsolidationData.getNodesConnectedOut(); + if (subInterfaceNodesConnectedOut != null) { + updateRequirementInAbstractNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData, + newSubInterfaceNodeTemplateId, subInterfaceNodesConnectedOut, context); + } } } @@ -694,13 +741,13 @@ public class UnifiedCompositionService { } String singleComputeId = computeType.getAllComputeNodeTemplateIds().iterator().next(); - if (Objects.nonNull(singleComputeId)) { + if (Objects.nonNull(singleComputeId) && (Objects.nonNull(nestedTemplateConsolidationData))) { updateRequirementInNestedNodeTemplate(serviceTemplate, nestedTemplateConsolidationData, singleComputeId, nodesConnectedOut); } } - protected void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate, + private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { @@ -725,6 +772,10 @@ public class UnifiedCompositionService { updNodesConnectedInConnectivity(serviceTemplate, portTemplateConsolidationData, newPortNodeTemplateId, context, false); } + + //Update requirements in the node template which pointing to the sub-interface + updateSubInterfaceNodesConnectedIn(serviceTemplate, unifiedCompositionData, + computeTemplateConsolidationData, computeType, context); } } @@ -754,7 +805,7 @@ public class UnifiedCompositionService { //Update the requirement assignment object in the original node template if (isNested) { updateRequirementForNestedCompositionNodesConnectedIn(serviceTemplate, - requirementAssignmentData, entityConsolidationData, newNodeTemplateId, context); + requirementAssignmentData, newNodeTemplateId); } else { updateRequirementForNodesConnectedIn(serviceTemplate, requirementAssignmentData, entityConsolidationData, entry.getKey(), newNodeTemplateId, context); @@ -764,6 +815,22 @@ public class UnifiedCompositionService { } } + private void updateSubInterfaceNodesConnectedIn(ServiceTemplate serviceTemplate, + UnifiedCompositionData unifiedCompositionData, + ComputeTemplateConsolidationData computeTemplateConsolidationData, + String computeType, + TranslationContext context) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType, + computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context); + updNodesConnectedInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, + newSubInterfaceNodeTemplateId, context, false); + } + } + protected void updNestedCompositionNodesConnectedInConnectivity( ServiceTemplate serviceTemplate, UnifiedCompositionData unifiedCompositionData, @@ -781,24 +848,7 @@ public class UnifiedCompositionService { } -// protected void updNestedCompositionNodesConnectedOutConnectivity( -// ServiceTemplate serviceTemplate, -// UnifiedCompositionData unifiedCompositionData, -// TranslationContext context) { -// NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData -// .getNestedTemplateConsolidationData(); -// //Update requirements in the node template which pointing to the nested nodes -// String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); -// Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId( -// serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId()); -// newNestedNodeTemplateId.ifPresent( -// newNestedNodeTemplateIdVal -> updNodesConnectedOutConnectivity(serviceTemplate, -// nestedTemplateConsolidationData, -// newNestedNodeTemplateIdVal, context, true)); -// -// } - - protected void updVolumeConnectivity(ServiceTemplate serviceTemplate, + private void updVolumeConnectivity(ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { @@ -817,7 +867,7 @@ public class UnifiedCompositionService { } } - protected void updGroupsConnectivity(ServiceTemplate serviceTemplate, + private void updGroupsConnectivity(ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { @@ -825,21 +875,23 @@ public class UnifiedCompositionService { ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData .getComputeTemplateConsolidationData(); //Add requirements in the abstract node template for nodes connected in for computes - String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate, - computeTemplateConsolidationData.getNodeTemplateId()); updGroupsConnectivity(serviceTemplate, computeTemplateConsolidationData, context); - String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData - .getNodeTemplateId()); //Add requirements in the abstract node template for nodes connected in for ports List<PortTemplateConsolidationData> portTemplateConsolidationDataList = getPortTemplateConsolidationDataList(unifiedCompositionData); for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) { - String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData - .getNodeTemplateId(), computeType, computeTemplateConsolidationData); updGroupsConnectivity(serviceTemplate, portTemplateConsolidationData, context); } + + //Add requirements in the abstract node template for nodes connected in for subInterface + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + updGroupsConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, context); + } } } @@ -853,25 +905,27 @@ public class UnifiedCompositionService { String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId( serviceTemplate, entityConsolidationData.getNodeTemplateId()); Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups(); - if (groups != null) { - for (String groupId : groupIds) { - GroupDefinition groupDefinition = groups.get(groupId); - if (groupDefinition != null) { - List<String> groupMembers = groupDefinition.getMembers(); - if (groupMembers.contains(oldNodeTemplateId)) { - //Replace the old node template id - groupMembers.remove(oldNodeTemplateId); - if (!groupMembers.contains(abstractNodeTemplateId)) { - //Add the abstract node template id if not already present - groupMembers.add(abstractNodeTemplateId); - } - } + if (groups == null) { + return; + } + for (String groupId : groupIds) { + GroupDefinition groupDefinition = groups.get(groupId); + if (groupDefinition == null) { + continue; + } + List<String> groupMembers = groupDefinition.getMembers(); + if (groupMembers.contains(oldNodeTemplateId)) { + //Replace the old node template id + groupMembers.remove(oldNodeTemplateId); + if (!groupMembers.contains(abstractNodeTemplateId)) { + //Add the abstract node template id if not already present + groupMembers.add(abstractNodeTemplateId); } } } } - protected void updOutputParamGetAttrInConnectivity( + private void updOutputParamGetAttrInConnectivity( ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList, TranslationContext context) { for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) { @@ -899,10 +953,30 @@ public class UnifiedCompositionService { portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context, false); } + + updateSubInterfaceOutputParamGetAttrIn(serviceTemplate, unifiedCompositionData, + computeTemplateConsolidationData, computeType, context); + } + } + + private void updateSubInterfaceOutputParamGetAttrIn(ServiceTemplate serviceTemplate, + UnifiedCompositionData unifiedCompositionData, + ComputeTemplateConsolidationData computeTemplateConsolidationData, + String computeType, + TranslationContext context) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType, + computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context); + updOutputParamGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, + subInterfaceTemplateConsolidationData.getNodeTemplateId(), newSubInterfaceNodeTemplateId, context, + false); } } - protected void updNodesGetAttrInConnectivity( + private void updNodesGetAttrInConnectivity( ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList, TranslationContext context) { @@ -934,6 +1008,28 @@ public class UnifiedCompositionService { portTemplateConsolidationData.getNodeTemplateId(), newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false); } + + updateSubInterfaceNodesGetAttrIn(serviceTemplate, unifiedCompositionData, + computeTemplateConsolidationData, computeType, consolidationNodeTemplateIdAndType, context); + } + } + + private void updateSubInterfaceNodesGetAttrIn(ServiceTemplate serviceTemplate, + UnifiedCompositionData unifiedCompositionData, + ComputeTemplateConsolidationData computeTemplateConsolidationData, + String computeType, + Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType, + TranslationContext context) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType, + computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context); + updNodeGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, + subInterfaceTemplateConsolidationData.getNodeTemplateId(), + newSubInterfaceNodeTemplateId, context, + consolidationNodeTemplateIdAndType, false); } } @@ -1018,9 +1114,7 @@ public class UnifiedCompositionService { private void updateRequirementForNestedCompositionNodesConnectedIn( ServiceTemplate serviceTemplate, RequirementAssignmentData requirementAssignmentData, - EntityConsolidationData entityConsolidationData, - String newNodeTemplateId, - TranslationContext context) { + String newNodeTemplateId) { ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl(); String newAbstractUnifiedNodeTemplateId = newNodeTemplateId; RequirementAssignment requirementAssignment = requirementAssignmentData @@ -1064,11 +1158,10 @@ public class UnifiedCompositionService { String capabilityId = entry.getKey(); CapabilityDefinition capabilityDefinition = entry.getValue(); String capabilityType = capabilityDefinition.getType(); - if (capabilityType.equals(requirementAssignment.getCapability())) { + if (capabilityType.equals(requirementAssignment.getCapability()) + && capabilityId.endsWith(newNodeTemplateId)) { //Matching capability type found..Check if the id ends with new node template id - if (capabilityId.endsWith(newNodeTemplateId)) { - return Optional.ofNullable(capabilityId); - } + return Optional.ofNullable(capabilityId); } } return Optional.empty(); @@ -1154,38 +1247,6 @@ public class UnifiedCompositionService { } } - private NodeTemplate getAbstractNodeTemplate( - ServiceTemplate serviceTemplate, - UnifiedCompositionEntity unifiedCompositionEntity, - ComputeTemplateConsolidationData computeTemplateConsolidationData, - PortTemplateConsolidationData portTemplateConsolidationData, - TranslationContext context) { - String abstractNodeTemplateId = - getAbstractNodeTemplateId(serviceTemplate, unifiedCompositionEntity, - computeTemplateConsolidationData, portTemplateConsolidationData, context); - - return DataModelUtil.getNodeTemplate(serviceTemplate, - abstractNodeTemplateId); - } - - private String getAbstractNodeTemplateId( - ServiceTemplate serviceTemplate, - UnifiedCompositionEntity unifiedCompositionEntity, - ComputeTemplateConsolidationData computeTemplateConsolidationData, - PortTemplateConsolidationData portTemplateConsolidationData, - TranslationContext context) { - switch (unifiedCompositionEntity) { - case Compute: - return context.getUnifiedAbstractNodeTemplateId(serviceTemplate, - computeTemplateConsolidationData.getNodeTemplateId()); - case Port: - return context.getUnifiedAbstractNodeTemplateId(serviceTemplate, - portTemplateConsolidationData.getNodeTemplateId()); - default: - return null; - } - } - private void updNodeGetAttrInConnectivity( ServiceTemplate serviceTemplate, EntityConsolidationData entityConsolidationData, @@ -1198,13 +1259,14 @@ public class UnifiedCompositionService { return; } - for (String sourceNodeTemplateId : nodesGetAttrIn.keySet()) { + for (Map.Entry<String, List<GetAttrFuncData>> nodesGetAttrInEntry : nodesGetAttrIn.entrySet()) { + String sourceNodeTemplateId = nodesGetAttrInEntry.getKey(); NodeTemplate sourceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId); if (!isNested && consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) { continue; } - List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrIn.get(sourceNodeTemplateId); + List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrInEntry.getValue(); for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) { Object propertyValue = DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName()); @@ -1237,12 +1299,8 @@ public class UnifiedCompositionService { } } - private String getTemplateName(ServiceTemplate serviceTemplate, - UnifiedCompositionData unifiedCompositionData, - String nodeTypeId, + private String getTemplateName(String nodeTypeId, Integer index) { - ComputeTemplateConsolidationData computeTemplateConsolidationData = - unifiedCompositionData.getComputeTemplateConsolidationData(); String computeType = getComputeTypeSuffix(nodeTypeId); String templateName = "Nested_" + computeType; if (Objects.nonNull(index)) { @@ -1251,23 +1309,6 @@ public class UnifiedCompositionService { return templateName; } - private String getComputeTypeSuffix(ServiceTemplate serviceTemplate, - String computeNodeTemplateId) { - NodeTemplate computeNodeTemplate = - DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId); - return getComputeTypeSuffix(computeNodeTemplate.getType()); - } - - /** - * Gets compute type. - * - * @param computeType the compute node type abc.def.vFSB - * @return the compute type e.g.:vFSB - */ - private String getComputeTypeSuffix(String computeType) { - return DataModelUtil.getNamespaceSuffix(computeType); - } - private void updOutputParamGetAttrInConnectivity(ServiceTemplate serviceTemplate, EntityConsolidationData entityConsolidationData, String oldNodeTemplateId, @@ -1334,13 +1375,9 @@ public class UnifiedCompositionService { return true; } } -// Map.Entry<String, Object> functionMapEntry = -// (Map.Entry<String, Object>) ((Map) valueObject).entrySet().iterator().next(); -// return isIncludeToscaFunc(functionMapEntry.getValue(), toscaFunction); - } else if (valueObject instanceof List) { for (Object valueEntity : (List) valueObject) { - if (isIncludeToscaFunc(valueEntity, toscaFunction) == true) { + if (isIncludeToscaFunc(valueEntity, toscaFunction)) { return true; } } @@ -1348,19 +1385,18 @@ public class UnifiedCompositionService { return false; } - private void createOutputParameters(ServiceTemplate serviceTemplate, - ServiceTemplate substitutionServiceTemplate, - List<UnifiedCompositionData> unifiedCompositionDataList, - String computeNodeType, TranslationContext context) { + private void createOutputParameters(UnifiedCompositionTo unifiedCompositionTo, + String computeNodeType) { - createOutputParametersForCompute(serviceTemplate, substitutionServiceTemplate, - unifiedCompositionDataList, context); - createOutputParameterForPorts(serviceTemplate, substitutionServiceTemplate, - unifiedCompositionDataList, computeNodeType, context); + createOutputParametersForCompute(unifiedCompositionTo.getServiceTemplate(), + unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(), + unifiedCompositionTo.getContext()); + createOutputParameterForPorts(unifiedCompositionTo.getSubstitutionServiceTemplate(), + unifiedCompositionTo.getUnifiedCompositionDataList(), computeNodeType, unifiedCompositionTo.getContext()); + createOutputParameterForSubInterfaces(unifiedCompositionTo, computeNodeType); } private void createOutputParameterForPorts( - ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String connectedComputeNodeType, @@ -1379,28 +1415,31 @@ public class UnifiedCompositionService { connectedComputeNodeType, unifiedCompositionData.getComputeTemplateConsolidationData()); addOutputParameters(portTemplateConsolidationData, newPortNodeTemplateId, - serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, context); + substitutionServiceTemplate, unifiedCompositionDataList, context); } } } - //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId> - private String getNewPortNodeTemplateId( - String portNodeTemplateId, - String connectedComputeNodeType, - ComputeTemplateConsolidationData computeTemplateConsolidationData) { + private void createOutputParameterForSubInterfaces(UnifiedCompositionTo unifiedCompositionTo, + String connectedComputeNodeType) { + for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionTo.getUnifiedCompositionDataList()) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + if (CollectionUtils.isEmpty(subInterfaceTemplateConsolidationDataList)) { + return; + } - StringBuilder newPortNodeTemplateId = new StringBuilder(); - String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId); - newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType)); - if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) { - //single port - newPortNodeTemplateId.append("_").append(portNodeTemplateId); - } else { - //consolidation port - newPortNodeTemplateId.append("_").append(portType); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo + .getServiceTemplate(), connectedComputeNodeType, unifiedCompositionData + .getComputeTemplateConsolidationData(), subInterfaceTemplateConsolidationData, + unifiedCompositionTo.getContext()); + addOutputParameters(subInterfaceTemplateConsolidationData, newSubInterfaceNodeTemplateId, + unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(), + unifiedCompositionTo.getContext()); + } } - return newPortNodeTemplateId.toString(); } private void createOutputParametersForCompute( @@ -1417,33 +1456,31 @@ public class UnifiedCompositionService { getNewComputeNodeTemplateId(serviceTemplate, computeTemplateConsolidationData.getNodeTemplateId()); addOutputParameters(computeTemplateConsolidationData, newComputeNodeTemplateId, - serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, context); + substitutionServiceTemplate, unifiedCompositionDataList, context); } } private void addOutputParameters(EntityConsolidationData entityConsolidationData, String newNodeTemplateId, - ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { - handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, serviceTemplate, - substitutionServiceTemplate, unifiedCompositionDataList, context); + handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate, + unifiedCompositionDataList, context); - handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId, serviceTemplate, + handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate, context); } private void handleOutputParamGetAttrIn(EntityConsolidationData entityConsolidationData, String newNodeTemplateId, - ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, TranslationContext context) { List<GetAttrFuncData> outputParametersGetAttrIn = entityConsolidationData.getOutputParametersGetAttrIn(); if (!CollectionUtils.isEmpty(outputParametersGetAttrIn)) { for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) { - createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId, + createAndAddOutputParameter(newNodeTemplateId, substitutionServiceTemplate, getAttrFuncData, context); } } @@ -1451,29 +1488,28 @@ public class UnifiedCompositionService { private void handleNodesGetAttrIn(EntityConsolidationData entityConsolidationData, String newNodeTemplateId, - ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { Map<String, List<GetAttrFuncData>> getAttrIn = entityConsolidationData.getNodesGetAttrIn(); - - if (!MapUtils.isEmpty(getAttrIn)) { - Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = - getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList); - for (String sourceNodeTemplateId : getAttrIn.keySet()) { - if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) { - List<GetAttrFuncData> getAttrFuncDataList = getAttrIn.get(sourceNodeTemplateId); - for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) { - createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId, - substitutionServiceTemplate, getAttrFuncData, context); - } + if (MapUtils.isEmpty(getAttrIn)) { + return; + } + Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = + getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList); + for (Map.Entry<String, List<GetAttrFuncData>> getAttrInEntry : getAttrIn.entrySet()) { + String sourceNodeTemplateId = getAttrInEntry.getKey(); + if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) { + List<GetAttrFuncData> getAttrFuncDataList = getAttrInEntry.getValue(); + for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) { + createAndAddOutputParameter(newNodeTemplateId, + substitutionServiceTemplate, getAttrFuncData, context); } } } } - private void createAndAddOutputParameter(EntityConsolidationData entityConsolidationData, - String newNodeTemplateId, + private void createAndAddOutputParameter(String newNodeTemplateId, ServiceTemplate substitutionServiceTemplate, GetAttrFuncData getAttrFuncData, TranslationContext context) { @@ -1499,8 +1535,8 @@ public class UnifiedCompositionService { NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(substitutionServiceTemplate, newNodeTemplateId); //Get the type and entry schema of the output parameter from the node type flat hierarchy - String outputParameterType = null; - EntrySchema outputParameterEntrySchema = null; + String outputParameterType; + EntrySchema outputParameterEntrySchema; NodeType nodeTypeWithFlatHierarchy = HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), substitutionServiceTemplate, context); @@ -1524,18 +1560,6 @@ public class UnifiedCompositionService { outputParameter.setEntry_schema(outputParameterEntrySchema); } - private String getNewInputParameterType(NodeTemplate nodeTemplate, - ServiceTemplate serviceTemplate, - String inputParameterName, - TranslationContext context) { - NodeType nodeTypeWithFlatHierarchy = - HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), - serviceTemplate, context); - String parameterType = nodeTypeWithFlatHierarchy.getProperties() - .get(inputParameterName).getType(); - return getUnifiedInputParameterType(parameterType); - } - private AttributeDefinition getOutputParameterDefinitionFromAttributes(NodeType nodeTypeWithFlatHierarchy, String outputParameterName) { @@ -1548,29 +1572,6 @@ public class UnifiedCompositionService { return outputParameterDefinition; } - private String getUnifiedInputParameterType(String parameterType) { - String unifiedInputParameterType = null; - if (Objects.nonNull(parameterType)) { - if (parameterType.equalsIgnoreCase(PropertyType.STRING.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.TIMESTAMP.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.NULL.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.SCALAR_UNIT_SIZE.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.SCALAR_UNIT_FREQUENCY.getDisplayName())) { - unifiedInputParameterType = parameterType.toLowerCase(); - } else if (parameterType.equalsIgnoreCase(PropertyType.MAP.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) - || parameterType.equalsIgnoreCase(PropertyTypeExt.JSON.getDisplayName())) { - unifiedInputParameterType = PropertyTypeExt.JSON.getDisplayName(); - } else { - unifiedInputParameterType = parameterType; - } - } - return unifiedInputParameterType; - } - private String getNewSubstitutionOutputParameterId(String newNodeTemplateId, String attributeName) { return newNodeTemplateId + "_" + attributeName; @@ -1599,6 +1600,16 @@ public class UnifiedCompositionService { substituteNodeTemplateId); } } + //Add Sub-interface template mapping information + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + if (CollectionUtils.isNotEmpty(subInterfaceTemplateConsolidationDataList)) { + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + context.addUnifiedSubstitutionData(serviceTemplateFileName, + subInterfaceTemplateConsolidationData.getNodeTemplateId(), substituteNodeTemplateId); + } + } } } @@ -1617,14 +1628,8 @@ public class UnifiedCompositionService { nodeTemplate.setProperties(properties); } - private String getSubstituteNodeTemplateId(ServiceTemplate serviceTemplate, - UnifiedCompositionData unifiedCompositionData, - String nodeTypeId, + private String getSubstituteNodeTemplateId(String nodeTypeId, Integer index) { - String computeNodeTemplateId = - unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId(); - NodeTemplate computeNodeTemplate = - DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId); String nodeTemplateId = ABSTRACT_NODE_TEMPLATE_ID_PREFIX + DataModelUtil .getNamespaceSuffix(nodeTypeId); if (Objects.nonNull(index)) { @@ -1664,18 +1669,10 @@ public class UnifiedCompositionService { return nodeTypeId; } - private String getNewComputeNodeTemplateId( - ServiceTemplate serviceTemplate, - String computeNodeTemplateId) { - return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId); - } - private NodeType handleSubstitutionGlobalNodeType(ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, TranslationContext context, - UnifiedCompositionData unifiedCompositionData, - String substitutionNodeTypeId, - Integer index) { + String substitutionNodeTypeId) { NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl() .createInitSubstitutionNodeType(substitutionServiceTemplate, ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE); @@ -1735,9 +1732,9 @@ public class UnifiedCompositionService { Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList); - for (String portType : portIdsPerPortType.keySet()) { + for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) { List<EntityConsolidationData> portTemplateConsolidationDataList = - getPortConsolidationDataList(portIdsPerPortType.get(portType), + getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(), unifiedCompositionDataList); if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) { continue; @@ -1765,7 +1762,7 @@ public class UnifiedCompositionService { removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate); handleProperties(serviceTemplate, newPortNodeTemplate, - substitutionServiceTemplate, UnifiedCompositionEntity.Port, + substitutionServiceTemplate, UnifiedCompositionEntity.PORT, portTemplateConsolidationDataList, computeTemplateConsolidationData, unifiedCompositionDataList, context); @@ -1790,6 +1787,156 @@ public class UnifiedCompositionService { } + private void handleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) { + if (unifiedCompositionTo.getUnifiedCompositionDataList().size() > 1) { + handleConsolidationSubInterfaces(unifiedCompositionTo); + } else { + handleSingleSubInterfaces(unifiedCompositionTo); + } + } + + private void handleSingleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) { + UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0); + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + List<SubInterfaceTemplateConsolidationData> subInterfaceDataList = new ArrayList<>(); + subInterfaceDataList.add(subInterfaceTemplateConsolidationData); + createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceDataList); + } + } + + private void handleConsolidationSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) { + Collection<ComputeTemplateConsolidationData> computeConsolidationDataList = + (Collection) getComputeConsolidationDataList(unifiedCompositionTo.getUnifiedCompositionDataList()); + + Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil + .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList); + + for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) { + List<EntityConsolidationData> portEntityConsolidationDataList = + getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(), + unifiedCompositionTo.getUnifiedCompositionDataList()); + if (CollectionUtils.isEmpty(portEntityConsolidationDataList)) { + continue; + } + + List<PortTemplateConsolidationData> portTemplateConsolidationDataList = + portEntityConsolidationDataList.stream() + .map(data -> (PortTemplateConsolidationData) data) + .collect(Collectors.toList()); + + ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfacesByType = UnifiedCompositionUtil + .collectAllSubInterfacesOfEachTypesFromPorts(portTemplateConsolidationDataList); + Set<String> subInterfaceTypes = subInterfacesByType.keySet(); + for (String subInterfaceType: subInterfaceTypes) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + subInterfacesByType.get(subInterfaceType); + createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceTemplateConsolidationDataList); + } + } + } + + private void createSubInterfaceSubstitutionNodeTemplate(UnifiedCompositionTo unifiedCompositionTo, + List<SubInterfaceTemplateConsolidationData> + subInterfaceTemplateConsolidationDataList) { + SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData = + subInterfaceTemplateConsolidationDataList.get(0); + PortTemplateConsolidationData portTemplateConsolidationData = + getSubInterfacePortTemplateConsolidationData(unifiedCompositionTo.getServiceTemplate(), + subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext()); + + if (Objects.isNull(portTemplateConsolidationData)) { + return; + } + + String originalSubInterfaceNodeTemplateId = subInterfaceTemplateConsolidationDataList.get(0) + .getNodeTemplateId(); + NodeTemplate originalSubInterfaceNodeTemplate = + DataModelUtil.getNodeTemplate(unifiedCompositionTo.getServiceTemplate(), originalSubInterfaceNodeTemplateId); + if (Objects.isNull(originalSubInterfaceNodeTemplate)) { + return; + } + NodeTemplate newSubInterfaceNodeTemplate = originalSubInterfaceNodeTemplate.clone(); + ComputeTemplateConsolidationData connectedComputeConsolidationData = + getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(), + portTemplateConsolidationData.getNodeTemplateId()); + if (Objects.nonNull(connectedComputeConsolidationData)) { + NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo + .getServiceTemplate(), connectedComputeConsolidationData.getNodeTemplateId()); + String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo + .getServiceTemplate(), connectedComputeNodeTemplate.getType(), connectedComputeConsolidationData, + subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext()); + DataModelUtil.addNodeTemplate(unifiedCompositionTo.getSubstitutionServiceTemplate(), + newSubInterfaceNodeTemplateId, newSubInterfaceNodeTemplate); + List<EntityConsolidationData> entityConsolidationDataList = + new ArrayList<>(subInterfaceTemplateConsolidationDataList); + //Remove all the existing properties as we are going to create new based on the + // naming convention for the substitution + handleSubInterfaceProperties(unifiedCompositionTo, newSubInterfaceNodeTemplate, entityConsolidationDataList, + portTemplateConsolidationData); + //Update requirements for relationships between the consolidation entities + handleConsolidationEntitiesRequirementConnectivity(newSubInterfaceNodeTemplate, unifiedCompositionTo + .getServiceTemplate(), unifiedCompositionTo.getContext()); + removeConnectivityOut(subInterfaceTemplateConsolidationData,newSubInterfaceNodeTemplate); + } + } + + private void handleSubInterfaceProperties(UnifiedCompositionTo unifiedCompositionTo, + NodeTemplate newSubInterfaceNodeTemplate, + List<EntityConsolidationData> + entityConsolidationDataList, + PortTemplateConsolidationData + portTemplateConsolidationData) { + UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0); + ServiceTemplate serviceTemplate = unifiedCompositionTo.getServiceTemplate(); + TranslationContext context = unifiedCompositionTo.getContext(); + newSubInterfaceNodeTemplate.setProperties(new HashMap<>()); + for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) { + String nodeTemplateId = entityConsolidationData.getNodeTemplateId(); + Optional<List<String>> indexVarProperties = + context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate), + nodeTemplateId); + Map<String, Object> properties = + DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId); + if (MapUtils.isEmpty(properties)) { + continue; + } + + for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) { + NodeType nodeTypeWithFlatHierarchy = + HeatToToscaUtil.getNodeTypeWithFlatHierarchy(newSubInterfaceNodeTemplate.getType(), + serviceTemplate, context); + PropertyDefinition propertyDefinition = + nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey()); + String propertyType = propertyDefinition.getType(); + //Handle service_template_filter property for subinterface as we should not create inputs + // for this property + if (propertyEntry.getKey().equals(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME)) { + handleSubInterfaceServiceTemplateFilterProperty(newSubInterfaceNodeTemplate, + propertyEntry.getKey(), propertyEntry.getValue(), serviceTemplate, + unifiedCompositionTo.getSubstitutionServiceTemplate()); + } else if (indexVarProperties.isPresent() + && indexVarProperties.get().contains(propertyEntry.getKey())) { + //Handle index property + handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(), + newSubInterfaceNodeTemplate); + } else { + Optional<String> parameterId = + updateProperty(serviceTemplate, nodeTemplateId, newSubInterfaceNodeTemplate, + propertyEntry, UnifiedCompositionEntity.SUB_INTERFACE, unifiedCompositionData + .getComputeTemplateConsolidationData(), portTemplateConsolidationData, + unifiedCompositionTo.getUnifiedCompositionDataList(), context); + parameterId.ifPresent( + parameterIdValue -> addPropertyInputParameter(propertyType, + unifiedCompositionTo.getSubstitutionServiceTemplate(), + propertyDefinition.getEntry_schema(), parameterIdValue)); + } + } + } + } + private NodeTemplate getNodeTemplate(String nodeTemplateId, ServiceTemplate serviceTemplate, TranslationContext context) { @@ -1813,8 +1960,6 @@ public class UnifiedCompositionService { unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(); handleComputeNodeTemplate(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, context); - ServiceTemplate globalSubstitutionServiceTemplate = - HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context); return handleComputeNodeType(serviceTemplate, substitutionServiceTemplate, computeTemplateConsolidationData); } @@ -1834,11 +1979,6 @@ public class UnifiedCompositionService { return computeNodeTypeId; } - private String getComputeNodeType(String nodeType) { - String computeTypeSuffix = getComputeTypeSuffix(nodeType); - return ToscaNodeType.COMPUTE_TYPE_PREFIX + "." + computeTypeSuffix; - } - private void handleComputeNodeTemplate(ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, @@ -1851,12 +1991,12 @@ public class UnifiedCompositionService { removeConnectivityOut(computeTemplateConsolidationData, newComputeNodeTemplate); removeVolumeConnectivity(computeTemplateConsolidationData, newComputeNodeTemplate); - List<EntityConsolidationData> computeConsoliadtionDataList = + List<EntityConsolidationData> computeConsolidationDataList = getComputeConsolidationDataList(unifiedCompositionDataList); handleProperties(serviceTemplate, newComputeNodeTemplate, - substitutionServiceTemplate, UnifiedCompositionEntity.Compute, - computeConsoliadtionDataList, computeTemplateConsolidationData, unifiedCompositionDataList, + substitutionServiceTemplate, COMPUTE, + computeConsolidationDataList, computeTemplateConsolidationData, unifiedCompositionDataList, context); String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate, @@ -1869,7 +2009,7 @@ public class UnifiedCompositionService { .addNodeTemplate(substitutionServiceTemplate, newComputeNodeTemplateId, newComputeNodeTemplate); //Add the node template mapping in the context for handling requirement updation - for (EntityConsolidationData data : computeConsoliadtionDataList) { + for (EntityConsolidationData data : computeConsolidationDataList) { String newComputeTemplateId = getNewComputeNodeTemplateId(serviceTemplate, computeTemplateConsolidationData.getNodeTemplateId()); context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil @@ -1878,25 +2018,11 @@ public class UnifiedCompositionService { } } - private void updateComputeNodeType(ServiceTemplate serviceTemplate, - String nodeTemplateId, - NodeTemplate newComputeNodeTemplate) { - String computeNodeType = getComputeNodeType(newComputeNodeTemplate.getType()); - NodeType origNodeType = serviceTemplate.getNode_types().get(newComputeNodeTemplate.getType()); - DataModelUtil.removeNodeType(serviceTemplate, newComputeNodeTemplate.getType()); - DataModelUtil.addNodeType(serviceTemplate, computeNodeType, origNodeType); - newComputeNodeTemplate.setType(computeNodeType); - DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateId, newComputeNodeTemplate); - } - private List<EntityConsolidationData> getComputeConsolidationDataList( List<UnifiedCompositionData> unifiedCompositionDataList) { - List<EntityConsolidationData> computeConsolidationDataList = new ArrayList<>(); - for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) { - computeConsolidationDataList - .add(unifiedCompositionData.getComputeTemplateConsolidationData()); - } - return computeConsolidationDataList; + return unifiedCompositionDataList.stream() + .map(UnifiedCompositionData::getComputeTemplateConsolidationData) + .collect(Collectors.toList()); } @@ -1908,8 +2034,6 @@ public class UnifiedCompositionService { ComputeTemplateConsolidationData computeTemplateConsolidationData, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { - List<String> propertiesWithIdenticalVal = - consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity); nodeTemplate.setProperties(new HashedMap()); handleNodeTemplateProperties(serviceTemplate, nodeTemplate, substitutionServiceTemplate, unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData, @@ -1936,6 +2060,9 @@ public class UnifiedCompositionService { for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) { String nodeTemplateId = entityConsolidationData.getNodeTemplateId(); + Optional<List<String>> indexVarProperties = + context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate), + nodeTemplateId); Map<String, Object> properties = DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId); if (MapUtils.isEmpty(properties)) { @@ -1960,17 +2087,67 @@ public class UnifiedCompositionService { propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition .getEntry_schema() : null, substitutionServiceTemplate); + } else if (indexVarProperties.isPresent() + && indexVarProperties.get().contains(propertyEntry.getKey())) { + //Handle index property + handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(), nodeTemplate); } else { Optional<String> parameterId = updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry, - unifiedCompositionEntity, computeTemplateConsolidationData, + unifiedCompositionEntity, computeTemplateConsolidationData, null, unifiedCompositionDataList, context); - //todo - define list of type which will match the node property type (instead of string) parameterId.ifPresent( parameterIdValue -> addPropertyInputParameter(propertyType, substitutionServiceTemplate, - propertyDefinition.getEntry_schema(), parameterIdValue, context)); + propertyDefinition.getEntry_schema(), parameterIdValue)); + } + } + } + } + + private void handleIndexVarProperty(String propertyKey, Object propertyValue, + NodeTemplate nodeTemplate) { + //Retain properties translated from %index% value in heat + nodeTemplate.getProperties().put(propertyKey, propertyValue); + } + + private void handleSubInterfaceServiceTemplateFilterProperty(NodeTemplate nodeTemplate, + String propertyKey, + Object propertyValue, + ServiceTemplate serviceTemplate, + ServiceTemplate substitutionServiceTemplate) { + //Retain service_template_filter (Can be present in a sub-interface resource-def) + nodeTemplate.getProperties().put(propertyKey, propertyValue); + Object serviceTemplateFilterProperty = + nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME); + if (!(serviceTemplateFilterProperty instanceof Map)) { + return; + } + Map<String, Object> serviceTemplatePropertyMap = (Map<String, Object>) + serviceTemplateFilterProperty; + Object countPropertyVal = serviceTemplatePropertyMap.get(ToscaConstants.COUNT_PROPERTY_NAME); + //Check if the value of the count property is a tosca function + if (!isPropertyContainsToscaFunction(countPropertyVal)) { + return; + } + Map<String, Object> countPropertyValMap = (Map<String, Object>) countPropertyVal; + //If the value is in the form of get_input add an input parameter in current service + // template + if (countPropertyValMap.keySet().contains(ToscaFunctions.GET_INPUT.getDisplayName())) { + String countPropertyInputName = countPropertyValMap.get(ToscaFunctions.GET_INPUT + .getDisplayName()).toString(); + //Get the input parameter definition from top level where the resource group was present + ParameterDefinitionExt parameterDefinition = (ParameterDefinitionExt) + DataModelUtil.getInputParameters(serviceTemplate).get(countPropertyInputName); + if (Objects.nonNull(parameterDefinition)) { + //Remove annotations if any for the nested service template + parameterDefinition.setAnnotations(null); + DataModelUtil.getInputParameters(substitutionServiceTemplate) + .put(countPropertyInputName, parameterDefinition); + if (Objects.nonNull(countPropertyInputName)) { + //Remove the input from top level + DataModelUtil.getInputParameters(serviceTemplate).remove(countPropertyInputName); } } } @@ -1987,11 +2164,11 @@ public class UnifiedCompositionService { Optional<NodeType> enrichNodeType; List<String> enrichProperties; - if (compositionEntity.equals(UnifiedCompositionEntity.Port)) { + if (compositionEntity.equals(UnifiedCompositionEntity.PORT)) { enrichNodeType = toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT, context.getGlobalServiceTemplates().values()); - enrichProperties = context.getEnrichPortResourceProperties(); + enrichProperties = TranslationContext.getEnrichPortResourceProperties(); if (!enrichNodeType.isPresent() || Objects.isNull(enrichProperties)) { return; } @@ -2028,7 +2205,7 @@ public class UnifiedCompositionService { String inputParamId = getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName, - compositionEntity, computeTemplateConsolidationData); + compositionEntity, computeTemplateConsolidationData, null); Map<String, String> propertyValMap = new HashMap<>(); context @@ -2047,7 +2224,7 @@ public class UnifiedCompositionService { addPropertyInputParameter(propertyType, substitutionServiceTemplate, enrichNodeType .getProperties().get(enrichPropertyName).getEntry_schema(), - inputParamId, context); + inputParamId); } } @@ -2078,9 +2255,11 @@ public class UnifiedCompositionService { private void addPropertyInputParameter(String propertyType, ServiceTemplate substitutionServiceTemplate, - EntrySchema entrySchema, String parameterId, - TranslationContext context) { - if (isParameterBelongsToEnrichedPortProperties(parameterId, context)) { + EntrySchema entrySchema, String parameterId) { + if (Objects.isNull(propertyType)) { + return; + } + if (isParameterBelongsToEnrichedPortProperties(parameterId)) { addInputParameter(parameterId, propertyType, propertyType.equals(PropertyType.LIST.getDisplayName()) ? entrySchema : null, @@ -2102,9 +2281,8 @@ public class UnifiedCompositionService { } } - private boolean isParameterBelongsToEnrichedPortProperties(String parameterId, - TranslationContext context) { - List enrichPortResourceProperties = context.getEnrichPortResourceProperties(); + private boolean isParameterBelongsToEnrichedPortProperties(String parameterId) { + List enrichPortResourceProperties = TranslationContext.getEnrichPortResourceProperties(); for (int i = 0; i < enrichPortResourceProperties.size(); i++) { if (parameterId.contains((CharSequence) enrichPortResourceProperties.get(i))) { @@ -2116,11 +2294,8 @@ public class UnifiedCompositionService { } private boolean isPropertySimpleType(String propertyType) { - return !Objects.isNull(propertyType) && - (propertyType.equalsIgnoreCase(PropertyType.STRING.getDisplayName()) - || propertyType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName()) - || propertyType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName()) - || propertyType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName())); + return !Objects.isNull(propertyType) + && (PropertyType.getSimplePropertyTypes().contains(propertyType.toLowerCase())); } private String analyzeParameterType(String propertyType) { @@ -2129,7 +2304,7 @@ public class UnifiedCompositionService { } private String analyzeEntrySchemaType(String propertyType, EntrySchema entrySchema) { - return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) ? + return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) && entrySchema != null ? entrySchema.getType() : null; } @@ -2198,34 +2373,28 @@ public class UnifiedCompositionService { UnifiedCompositionEntity unifiedCompositionEntity, List<UnifiedCompositionData> unifiedCompositionDataList) { - String inputParamId; + String inputParamId = null; Map<String, Object> propertyVal = new HashMap<>(); switch (unifiedCompositionEntity) { - case Compute: + case COMPUTE: inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX; - propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId); nodeTemplate.getProperties().put(propertyId, propertyVal); - - return inputParamId; - - case Port: + break; + case PORT: String portType = ConsolidationDataUtil.getPortType(nodeTemplateId); ComputeTemplateConsolidationData computeTemplateConsolidationData = getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId); - inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType, - computeTemplateConsolidationData); - + inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType, computeTemplateConsolidationData); propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId); nodeTemplate.getProperties().put(propertyId, propertyVal); - - return inputParamId; - + break; default: - return null; + break; } + return inputParamId; } private String getInputParamIdForPort(String nodeTemplateId, String propertyId, String portType, @@ -2234,12 +2403,12 @@ public class UnifiedCompositionService { if (Objects.isNull(computeTemplateConsolidationData) || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) { inputParamId = - UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_" + + UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + nodeTemplateId + "_" + propertyId; } else { inputParamId = - UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_" + UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_" + propertyId; } return inputParamId; @@ -2267,6 +2436,7 @@ public class UnifiedCompositionService { Map.Entry<String, Object> propertyEntry, UnifiedCompositionEntity compositionEntity, ComputeTemplateConsolidationData computeTemplateConsolidationData, + PortTemplateConsolidationData portTemplateConsolidationData, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { @@ -2278,16 +2448,13 @@ public class UnifiedCompositionService { String inputParamId = getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity, - computeTemplateConsolidationData); - Map<String, List<String>> propertyVal = getPropertyValueInputParam(nodeTemplateId, - nodeTemplate, inputParamId); + computeTemplateConsolidationData, portTemplateConsolidationData); + Map<String, List<String>> propertyVal = getPropertyValueInputParam(inputParamId); nodeTemplate.getProperties().put(propertyEntry.getKey(), propertyVal); return Optional.of(inputParamId); } - private Map<String, List<String>> getPropertyValueInputParam(String nodeTemplateId, - NodeTemplate nodeTemplate, - String inputParamId) { + private Map<String, List<String>> getPropertyValueInputParam(String inputParamId) { Map<String, List<String>> propertyVal = new HashMap<>(); List<String> getInputFuncParams = new ArrayList<>(); getInputFuncParams.add(inputParamId); @@ -2335,8 +2502,8 @@ public class UnifiedCompositionService { for (List<Object> getAttrFunc : clonedGetAttrFuncList) { String targetNodeTemplateId = (String) getAttrFunc.get(0); if (consolidationNodeTemplateIds.contains(targetNodeTemplateId)) { - updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList, context, - consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc); + updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList, + consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc, context); } } nodeTemplate.getProperties().put(propertyEntry.getKey(), clonedPropertyValue); @@ -2345,19 +2512,6 @@ public class UnifiedCompositionService { return false; } - private boolean isGetAttrFromConsolidationNodesIsFromSameType(String sourceNodeTemplateId, - Set<String> nodeTemplateIdsFromConsolidation, - Map<String, String> - nodeTemplateIdToType) { - for (String idFromConsolidation : nodeTemplateIdsFromConsolidation) { - if (isGetAttrNodeTemplateFromSameType(sourceNodeTemplateId, idFromConsolidation, - nodeTemplateIdToType)) { - return true; - } - } - return false; - } - private boolean isGetAttrNodeTemplateFromSameType(String sourceNodeTemplateId, String targetNodeTemplateId, Map<String, String> nodeTemplateIdToType) { @@ -2374,37 +2528,33 @@ public class UnifiedCompositionService { private void updatePropertyGetAttrFunc( ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, - TranslationContext context, Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType, String targetNodeTemplateId, - List<Object> getAttrFunc) { + List<Object> getAttrFunc, TranslationContext context) { UnifiedCompositionEntity targetCompositionEntity = consolidationNodeTemplateIdAndType.get(targetNodeTemplateId); String targetNewNodeTemplateId = getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId, - targetCompositionEntity); + targetCompositionEntity, context); getAttrFunc.set(0, targetNewNodeTemplateId); } private String getNewNodeTemplateId(ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String nodeTemplateId, - UnifiedCompositionEntity compositionEntity) { - switch (compositionEntity) { - case Compute: - return getNewComputeNodeTemplateId(serviceTemplate, nodeTemplateId); - case Port: - ComputeTemplateConsolidationData connectedComputeConsolidationData = - getConnectedComputeConsolidationData( - unifiedCompositionDataList, nodeTemplateId); - NodeTemplate connectedComputeNodeTemplate = - DataModelUtil.getNodeTemplate(serviceTemplate, - connectedComputeConsolidationData.getNodeTemplateId()); - return getNewPortNodeTemplateId(nodeTemplateId, connectedComputeNodeTemplate.getType(), - connectedComputeConsolidationData); - default: - return null; + UnifiedCompositionEntity compositionEntity, + TranslationContext context) { + String newNodeTemplateId = nodeTemplateId; + String nodeTemplateIdGeneratorImpl = unifiedSubstitutionNodeTemplateIdGeneratorImplMap.get(compositionEntity); + UnifiedSubstitutionNodeTemplateIdGenerator nodeTemplateIdGenerator = + CommonMethods.newInstance(nodeTemplateIdGeneratorImpl, UnifiedSubstitutionNodeTemplateIdGenerator.class); + UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate, null, + unifiedCompositionDataList, context); + Optional<String> generatedNodeTemplateId = nodeTemplateIdGenerator.generate(unifiedCompositionTo, nodeTemplateId); + if (generatedNodeTemplateId.isPresent()) { + newNodeTemplateId = generatedNodeTemplateId.get(); } + return newNodeTemplateId; } private String getNewNodeTemplateId(String origNodeTemplateId, @@ -2413,11 +2563,11 @@ public class UnifiedCompositionService { TranslationContext context) { ConsolidationData consolidationData = context.getConsolidationData(); - if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Port, + if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.PORT, serviceTemplateFileName, context)) { return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData); - } else if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Compute, + } else if (isIdIsOfExpectedType(origNodeTemplateId, COMPUTE, serviceTemplateFileName, context)) { NodeTemplate nodeTemplate = getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context); @@ -2427,21 +2577,6 @@ public class UnifiedCompositionService { return null; } - private ComputeTemplateConsolidationData getConnectedComputeConsolidationData( - List<UnifiedCompositionData> unifiedCompositionDataList, - String portNodeTemplateId) { - for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) { - Collection<List<String>> portsCollection = - unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values(); - for (List<String> portIdList : portsCollection) { - if (portIdList.contains(portNodeTemplateId)) { - return unifiedCompositionData.getComputeTemplateConsolidationData(); - } - } - } - return null; - } - private Object getClonedPropertyValue(Map.Entry<String, Object> propertyEntry) { if (propertyEntry.getValue() instanceof Map) { return getClonedObject(propertyEntry.getValue(), Map.class); @@ -2454,23 +2589,49 @@ public class UnifiedCompositionService { private String getParameterId(String nodeTemplateId, NodeTemplate nodeTemplate, String propertyId, UnifiedCompositionEntity unifiedCompositionEntity, - ComputeTemplateConsolidationData computeTemplateConsolidationData) { + ComputeTemplateConsolidationData + computeTemplateConsolidationData, + PortTemplateConsolidationData portTemplateConsolidationData) { + String paramterId = propertyId; switch (unifiedCompositionEntity) { - case Compute: - return UnifiedCompositionEntity.Compute.name().toLowerCase() + "_" + case COMPUTE: + paramterId = COMPUTE.getDisplayName().toLowerCase() + "_" + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId; - case Port: + break; + case PORT: String portType = ConsolidationDataUtil.getPortType(nodeTemplateId); if (Objects.isNull(computeTemplateConsolidationData) || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) { - return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_" + paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + + nodeTemplateId + "_" + propertyId; + } else { + paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_" + propertyId; } - return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_" - + propertyId; + break; + case SUB_INTERFACE: + String subInterfaceType = getSubInterfaceTypeSuffix(nodeTemplate.getType()); + if (Objects.isNull(portTemplateConsolidationData) + || isSubInterfaceNodeTemplateIdParameter(portTemplateConsolidationData, nodeTemplate)) { + paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_" + + nodeTemplateId + "_" + propertyId; + } else { + paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_" + + subInterfaceType + "_" + propertyId; + } + break; default: - return propertyId; + break; } + return paramterId; + } + + private boolean isSubInterfaceNodeTemplateIdParameter(PortTemplateConsolidationData portTemplateConsolidationData, + NodeTemplate nodeTemplate) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + portTemplateConsolidationData.getSubInterfaceConsolidationData(nodeTemplate.getType()); + return (Objects.nonNull(subInterfaceTemplateConsolidationDataList) + && subInterfaceTemplateConsolidationDataList.size() > 1) ; } private void removeConnectivityOut(EntityConsolidationData entityConsolidationData, @@ -2541,15 +2702,10 @@ public class UnifiedCompositionService { private Optional<Map<String, Object>> createAbstractSubstitutionProperties( ServiceTemplate serviceTemplate, - ServiceTemplate substitutionServiceTemplate, + Map<String, ParameterDefinition> substitutionTemplateInputs, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>(); - Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil - .getInputParameters(substitutionServiceTemplate); - if (substitutionTemplateInputs == null) { - return Optional.empty(); - } //Since all the computes have the same type fetching the type from the first entry NodeTemplate firstComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, unifiedCompositionDataList.get(0) @@ -2564,14 +2720,14 @@ public class UnifiedCompositionService { if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) { if (isIdenticalValueProperty( - substitutionTemplateInputName, inputUnifiedCompositionEntity, context)) { + substitutionTemplateInputName, inputUnifiedCompositionEntity)) { //Handle identical value properties Optional<String> identicalValuePropertyName = getIdenticalValuePropertyName(substitutionTemplateInputName, - inputUnifiedCompositionEntity, context); + inputUnifiedCompositionEntity); identicalValuePropertyName.ifPresent(propertyName -> updateIdenticalPropertyValue(propertyName, - substitutionTemplateInputName, computeType, inputUnifiedCompositionEntity, + substitutionTemplateInputName, inputUnifiedCompositionEntity, unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties, context)); } @@ -2580,59 +2736,110 @@ public class UnifiedCompositionService { //Check if the input is of type compute or port List<Object> abstractPropertyValue = new ArrayList<>(); - Object propertyValue = null; switch (inputUnifiedCompositionEntity) { - case Compute: - for (UnifiedCompositionData compositionData : unifiedCompositionDataList) { - ComputeTemplateConsolidationData computeTemplateConsolidationData = - compositionData.getComputeTemplateConsolidationData(); - propertyValue = getComputePropertyValue(substitutionTemplateInputName, - serviceTemplate, computeTemplateConsolidationData); - if (!(propertyValue instanceof Optional)) { - abstractPropertyValue.add(propertyValue); - } - } + case COMPUTE: + createAbstractComputeProperties(unifiedCompositionDataList, + substitutionTemplateInputName, serviceTemplate, abstractPropertyValue); break; - case Port: - for (UnifiedCompositionData compositionData : unifiedCompositionDataList) { - List<PortTemplateConsolidationData> portTemplateConsolidationDataList = - getPortTemplateConsolidationDataList(compositionData); - //Get the input type for this input whether it is of type - // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name> - PortInputType portInputType = getPortInputType(substitutionTemplateInputName, - compositionData); - for (PortTemplateConsolidationData portTemplateConsolidationData : - portTemplateConsolidationDataList) { - //Get the port property value - String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId(); - propertyValue = getPortPropertyValue(substitutionTemplateInputName, - computeType, portInputType, serviceTemplate, - portNodeTemplateId); - //If the value object is Optional.empty it implies that the property name was not - // found in the input name - if (!(propertyValue instanceof Optional)) { - if (!abstractPropertyValue.contains(propertyValue)) { - abstractPropertyValue.add(propertyValue); - } - } - } - } + case PORT: + createAbstractPortProperties(unifiedCompositionDataList, substitutionTemplateInputName, + computeType, serviceTemplate, abstractPropertyValue); + break; + case SUB_INTERFACE: + createAbstractSubInterfaceProperties(unifiedCompositionDataList, + substitutionTemplateInputName, serviceTemplate, abstractPropertyValue); break; default: break; } //Add the property only if it has at least one non-null value - for (Object val : abstractPropertyValue) { - if (Objects.nonNull(val)) { - updateAbstractPropertyValue(substitutionTemplateInputName, inputParameterDefinition, - abstractPropertyValue, abstractSubstituteProperties); - break; - } + if (abstractPropertyValue.stream().anyMatch(Objects::nonNull)) { + updateAbstractPropertyValue(substitutionTemplateInputName, inputParameterDefinition, + abstractPropertyValue, abstractSubstituteProperties); } } return Optional.ofNullable(abstractSubstituteProperties); } + private void createAbstractComputeProperties(List<UnifiedCompositionData> + unifiedCompositionDataList, + String substitutionTemplateInputName, + ServiceTemplate serviceTemplate, + List<Object> abstractPropertyValue) { + for (UnifiedCompositionData compositionData : unifiedCompositionDataList) { + ComputeTemplateConsolidationData computeTemplateConsolidationData = + compositionData.getComputeTemplateConsolidationData(); + Object propertyValue = getComputePropertyValue(substitutionTemplateInputName, + serviceTemplate, computeTemplateConsolidationData); + if (!(propertyValue instanceof Optional)) { + abstractPropertyValue.add(propertyValue); + } + } + } + + private void createAbstractPortProperties(List<UnifiedCompositionData> + unifiedCompositionDataList, + String substitutionTemplateInputName, + String computeType, + ServiceTemplate serviceTemplate, + List<Object> abstractPropertyValue) { + for (UnifiedCompositionData compositionData : unifiedCompositionDataList) { + List<PortTemplateConsolidationData> portTemplateConsolidationDataList = + getPortTemplateConsolidationDataList(compositionData); + //Get the input type for this input whether it is of type + // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name> + PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName, + compositionData); + for (PortTemplateConsolidationData portTemplateConsolidationData : + portTemplateConsolidationDataList) { + //Get the port property value + String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId(); + Object propertyValue = getPortPropertyValue(substitutionTemplateInputName, + computeType, portInputType, serviceTemplate, + portNodeTemplateId); + //If the value object is Optional.empty it implies that the property name was not + // found in the input name + if (!(propertyValue instanceof Optional)) { + abstractPropertyValue.add(propertyValue); + } + } + } + } + + private void createAbstractSubInterfaceProperties(List<UnifiedCompositionData> + unifiedCompositionDataList, + String substitutionTemplateInputName, + ServiceTemplate serviceTemplate, + List<Object> abstractPropertyValue) { + for (UnifiedCompositionData compositionData : unifiedCompositionDataList) { + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(compositionData); + //Get the input type for this input whether it is of type + // subInterface_<subinterface_node_template_id>_<property_name> or + // subInterface_<subinterface_type>_<property_name> + PropertyInputType subInterfaceInputType = + getSubInterfaceInputType(substitutionTemplateInputName, compositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + //Get the subInterface property value + String subInterfaceNodeTemplateId = subInterfaceTemplateConsolidationData + .getNodeTemplateId(); + NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, + subInterfaceNodeTemplateId); + String subInterfaceType = getSubInterfaceTypeSuffix(subInterfaceNodeTemplate + .getType()); + Object propertyValue = getSubInterfacePropertyValue(substitutionTemplateInputName, + subInterfaceType, subInterfaceInputType, serviceTemplate, + subInterfaceNodeTemplateId); + //If the value object is Optional.empty it implies that the property name was not + // found in the input name + if (!(propertyValue instanceof Optional)) { + abstractPropertyValue.add(propertyValue); + } + } + } + } + private void updateAbstractPropertyValue(String substitutionTemplateInputName, ParameterDefinition parameterDefinition, List<Object> abstractPropertyValue, @@ -2642,10 +2849,7 @@ public class UnifiedCompositionService { } else { Object propertyValue = abstractPropertyValue.get(0); String entrySchemaType = parameterDefinition.getEntry_schema().getType(); - if (entrySchemaType.equalsIgnoreCase(PropertyType.STRING.getDisplayName()) - || entrySchemaType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName()) - || entrySchemaType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName()) - || entrySchemaType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName()) + if (PropertyType.getSimplePropertyTypes().contains(entrySchemaType.toLowerCase()) || entrySchemaType.equals(PropertyTypeExt.JSON.getDisplayName())) { abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue); } else { @@ -2656,7 +2860,6 @@ public class UnifiedCompositionService { private void updateIdenticalPropertyValue(String identicalValuePropertyName, String substitutionTemplateInputName, - String computeType, UnifiedCompositionEntity entity, UnifiedCompositionData unifiedCompositionData, ServiceTemplate serviceTemplate, @@ -2678,73 +2881,95 @@ public class UnifiedCompositionService { private Optional<Object> getIdenticalPropertyValueByType(String identicalValuePropertyName, String substitutionTemplateInputName, UnifiedCompositionEntity entity, - UnifiedCompositionData unifiedCompositionData, + UnifiedCompositionData + unifiedCompositionData, ServiceTemplate serviceTemplate, TranslationContext context) { ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData.getComputeTemplateConsolidationData(); - Optional<Object> computeIdenticalPropertyValue; + Optional<Object> identicalPropertyValue = Optional.empty(); switch (entity) { - case Compute: - computeIdenticalPropertyValue = + case COMPUTE: + identicalPropertyValue = getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate, - entity, computeTemplateConsolidationData, context); - return computeIdenticalPropertyValue.isPresent() ? Optional.of( - computeIdenticalPropertyValue.get()) : Optional.empty(); - - case Other: - computeIdenticalPropertyValue = + computeTemplateConsolidationData, context); + break; + case OTHER: + identicalPropertyValue = getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate, - entity, computeTemplateConsolidationData, context); - return computeIdenticalPropertyValue.isPresent() ? Optional.of( - computeIdenticalPropertyValue.get()) : Optional.empty(); - - case Port: + computeTemplateConsolidationData, context); + break; + case PORT: List<PortTemplateConsolidationData> portTemplateConsolidationDataList = unifiedCompositionData.getPortTemplateConsolidationDataList(); for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) { String portType = ConsolidationDataUtil.getPortType(portTemplateConsolidationData.getNodeTemplateId()); if (substitutionTemplateInputName.contains(portType)) { - return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate, - entity, portTemplateConsolidationData, context); + return getIdenticalPropertyValue(identicalValuePropertyName, + serviceTemplate, portTemplateConsolidationData, context); } } + break; + default: + break; } - - return Optional.empty(); - + return identicalPropertyValue; } - private PortInputType getPortInputType(String inputName, - UnifiedCompositionData unifiedCompositionData) { - String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_"; + private PropertyInputType getPortInputType(String inputName, + UnifiedCompositionData unifiedCompositionData) { + String portInputPrefix = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_"; ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData .getComputeTemplateConsolidationData(); List<PortTemplateConsolidationData> portTemplateConsolidationDataList = getPortTemplateConsolidationDataList(unifiedCompositionData); //Scan the available port node template ids to check if the input is of the form // "port_<port_node_template_id>_<property_name>" - for (PortTemplateConsolidationData portTemplateConsolidationData : - portTemplateConsolidationDataList) { - String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId(); - String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId; - if (inputName.startsWith(portNodeTemplateIdPrefix)) { - return PortInputType.NodeTemplateId; - } + if (portTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId) + .map(portNodeTemplateId -> portInputPrefix + portNodeTemplateId).anyMatch(inputName::startsWith)) { + return PropertyInputType.NODE_TEMPLATE_ID; } //Check whether the input is of the form "port_<port_type>_<property_name>" Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet(); - for (String portType : portTypes) { - String expectedPortTypeSusbtring = portInputPrefix + portType + "_"; - if (inputName.startsWith(expectedPortTypeSusbtring)) { - return PortInputType.PortType; - } + if (portTypes.stream().map(portType -> portInputPrefix + portType + "_").anyMatch(inputName::startsWith)) { + return PropertyInputType.TYPE; + } + return PropertyInputType.OTHER; + } + + private PropertyInputType getSubInterfaceInputType(String inputName, + UnifiedCompositionData unifiedCompositionData) { + String subInterfaceInputPrefix = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + + "_"; + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + //Scan the available port node template ids to check if the input is of the form + // "subinterface_<subinterface_node_template_id>_<property_name>" + if (subInterfaceTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId) + .map(subInterfaceNodeTemplateId -> subInterfaceInputPrefix + + subInterfaceNodeTemplateId) + .anyMatch(inputName::startsWith)) { + return PropertyInputType.NODE_TEMPLATE_ID; + } + //Check whether the input is of the form "subinterface_<subinterface_type>_<property_name>" + Set<String> subInterfaceTypes = new HashSet<>(); + List<PortTemplateConsolidationData> portTemplateConsolidationDataList = + getPortTemplateConsolidationDataList(unifiedCompositionData); + for (PortTemplateConsolidationData portTemplateConsolidationData : + portTemplateConsolidationDataList) { + subInterfaceTypes.addAll(portTemplateConsolidationData.getAllSubInterfaceNodeTypes()); } - return PortInputType.Other; + + if (subInterfaceTypes.stream().map(UnifiedCompositionUtil::getSubInterfaceTypeSuffix) + .map(subInterfaceTypeSuffix -> subInterfaceInputPrefix + subInterfaceTypeSuffix + "_") + .anyMatch(inputName::startsWith)) { + return PropertyInputType.TYPE; + } + return PropertyInputType.OTHER; } private void cleanServiceTemplate(ServiceTemplate serviceTemplate, @@ -2768,8 +2993,8 @@ public class UnifiedCompositionService { context.addCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate), nodeTemplateIdToRemove, entity.getClass() == ComputeTemplateConsolidationData.class - ? UnifiedCompositionEntity.Compute - : UnifiedCompositionEntity.Port, + ? COMPUTE + : UnifiedCompositionEntity.PORT, nodeTemplateToRemove); } @@ -2795,7 +3020,6 @@ public class UnifiedCompositionService { Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template() .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups(); - String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); String nodeRelatedAbstractNodeId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId()); @@ -2822,25 +3046,6 @@ public class UnifiedCompositionService { groupEntry.getValue().setMembers(members); } - private void updateSubstitutableNodeTemplateRequirements(ServiceTemplate serviceTemplate, - ServiceTemplate substitutionServiceTemplate) { - if (Objects.isNull(substitutionServiceTemplate.getTopology_template())) { - return; - } - - SubstitutionMapping substitution_mappings = - substitutionServiceTemplate.getTopology_template().getSubstitution_mappings(); - - if (Objects.isNull(substitution_mappings)) { - return; - } - - String node_type = substitution_mappings.getNode_type(); - Map<String, List<String>> requirements = substitution_mappings.getRequirements(); - - - } - private void updateSubstitutionMapping(ServiceTemplate serviceTemplate, TranslationContext context) { SubstitutionMapping substitutionMappings = @@ -2938,118 +3143,6 @@ public class UnifiedCompositionService { .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate( unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate, mainServiceTemplate, context)); - - //updateNestedNodeTemplateRequirement(nestedNodeTemplateId, mainServiceTemplate, - //nestedServiceTemplate, context); - - //updateNodeTemplateRequirements(nestedNodeTemplateId, mainServiceTemplate, - //nestedServiceTemplate, context); - - //updateNodeDependencyRequirement(mainServiceTemplate, context, nestedNodeTemplate); - } - - private void updateNestedNodeTemplateRequirement(String nestedNodeTemplateId, - ServiceTemplate mainServiceTemplate, - ServiceTemplate nestedServiceTemplate, - TranslationContext context) { - NestedTemplateConsolidationData nestedTemplateConsolidationData = - ConsolidationDataUtil - .getNestedTemplateConsolidationData(context, mainServiceTemplate, null, - nestedNodeTemplateId); - - FileComputeConsolidationData fileComputeConsolidationData = - context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData - (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate)); - - - TypeComputeConsolidationData compute = - fileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next(); - - if (Objects.isNull(nestedTemplateConsolidationData)) { - return; - } - - Map<String, List<RequirementAssignmentData>> nodesConnectedOut = - nestedTemplateConsolidationData.getNodesConnectedOut(); - - if (MapUtils.isEmpty(nodesConnectedOut)) { - return; - } - - updateRequirements(nestedNodeTemplateId, mainServiceTemplate, nestedServiceTemplate, compute, - nodesConnectedOut); - } - - private void updateRequirements(String nestedNodeTemplateId, ServiceTemplate mainServiceTemplate, - ServiceTemplate nestedServiceTemplate, - TypeComputeConsolidationData compute, - Map<String, List<RequirementAssignmentData>> nodesConnectedOut) { - NodeTemplate nodeTemplate = - DataModelUtil.getNodeTemplate(mainServiceTemplate, nestedNodeTemplateId); - - for (List<RequirementAssignmentData> requirementAssignmentDataList : nodesConnectedOut - .values()) { - for (RequirementAssignmentData data : requirementAssignmentDataList) { - if (!data.getRequirementId().equals("dependency")) { - DataModelUtil.addRequirementAssignment(nodeTemplate, data.getRequirementId(), - cloneRequirementAssignment(data.getRequirementAssignment())); - updateRequirementInSubMapping(nestedServiceTemplate, compute, data); - - } - } - } - - removeUneccessaryRequirements(nodeTemplate); - } - - private void updateRequirementInSubMapping(ServiceTemplate nestedServiceTemplate, - TypeComputeConsolidationData compute, - RequirementAssignmentData data) { - List<String> subMappingRequirement = - Arrays.asList(compute.getAllComputeNodeTemplateIds().iterator().next(), "dependency"); - DataModelUtil.addSubstitutionMappingReq(nestedServiceTemplate, data.getRequirementId(), - subMappingRequirement); - } - - - private RequirementAssignment cloneRequirementAssignment(RequirementAssignment reqToClone) { - RequirementAssignment requirementAssignment = new RequirementAssignment(); - - requirementAssignment.setRelationship(reqToClone.getRelationship()); - requirementAssignment.setNode(reqToClone.getNode()); - requirementAssignment.setCapability(reqToClone.getCapability()); - - return requirementAssignment; - } - - private void removeUneccessaryRequirements(NodeTemplate nodeTemplate) { - List<Map<String, RequirementAssignment>> reqsToRemove = new ArrayList<>(); - for (Map<String, RequirementAssignment> requirementDefinitionMap : nodeTemplate - .getRequirements()) { - if (requirementDefinitionMap.containsKey("dependency")) { - reqsToRemove.add(requirementDefinitionMap); - } - } - - nodeTemplate.getRequirements().removeAll(reqsToRemove); - } - - private RequirementAssignment getRequirementAssignmentFromDefinition( - Map.Entry<String, RequirementDefinition> requirementDefinitionEntry) { - - RequirementAssignment requirementAssignment = new RequirementAssignment(); - if (requirementDefinitionEntry.getValue() instanceof RequirementDefinition) { - requirementAssignment.setCapability(requirementDefinitionEntry.getValue().getCapability()); - requirementAssignment.setNode(requirementDefinitionEntry.getValue().getNode()); - requirementAssignment - .setRelationship(requirementDefinitionEntry.getValue().getRelationship()); - } else if (requirementDefinitionEntry.getValue() instanceof Map) { - Map<String, Object> reqAsMap = (Map<String, Object>) requirementDefinitionEntry.getValue(); - requirementAssignment.setCapability((String) reqAsMap.get("capability")); - requirementAssignment.setNode((String) reqAsMap.get("node")); - requirementAssignment.setRelationship((String) reqAsMap.get("relationship")); - } - return requirementAssignment; } private void updateNestedNodeTemplateProperties(ServiceTemplate nestedServiceTemplate, @@ -3148,8 +3241,7 @@ public class UnifiedCompositionService { } } - private Optional<String> getNewNestedNodeTypeId(ServiceTemplate mainServiceTemplate, - ServiceTemplate nestedServiceTemplate, + private Optional<String> getNewNestedNodeTypeId(ServiceTemplate nestedServiceTemplate, TranslationContext context) { FileComputeConsolidationData fileComputeConsolidationData = context.getConsolidationData().getComputeConsolidationData() @@ -3168,7 +3260,7 @@ public class UnifiedCompositionService { FileComputeConsolidationData fileComputeConsolidationData) { List<TypeComputeConsolidationData> typeComputeConsolidationDatas = new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData()); - if (typeComputeConsolidationDatas.size() == 0) { + if (typeComputeConsolidationDatas.isEmpty()) { return null; } else { String computeNodeType = fileComputeConsolidationData.getAllComputeTypes().iterator().next(); @@ -3300,15 +3392,16 @@ public class UnifiedCompositionService { private Object getPortPropertyValue(String inputName, String computeType, - PortInputType portInputType, + PropertyInputType portInputType, ServiceTemplate serviceTemplate, String portNodeTemplateId) { //Get the input prefix to extract the property name from the input name - String portInputPrefix = getPortInputPrefix( - portNodeTemplateId, portInputType); + String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId); + String portInputPrefix = getPropertyInputPrefix( + portNodeTemplateId, portType, portInputType, UnifiedCompositionEntity.PORT); //Get the property name from the input Optional<String> propertyName = getPropertyNameFromInput(inputName, - UnifiedCompositionEntity.Port, computeType, portInputPrefix); + UnifiedCompositionEntity.PORT, computeType, portInputPrefix); //Get the property value from the node template if (propertyName.isPresent()) { NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, @@ -3320,27 +3413,6 @@ public class UnifiedCompositionService { return Optional.empty(); } - private Optional<String> getPortTypeFromInput( - String inputName, - String portNodeTemplateId, - ComputeTemplateConsolidationData computeTemplateConsolidationData) { - String portTypeFromInput = null; - String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_"; - String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId; - if (inputName.startsWith(portNodeTemplateIdPrefix)) { - return Optional.empty(); - } - Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet(); - for (String portType : portTypes) { - String expectedPortTypeSusbtring = "_" + portType + "_"; - if (inputName.contains(expectedPortTypeSusbtring)) { - portTypeFromInput = portType; - break; - } - } - return Optional.ofNullable(portTypeFromInput); - } - private Object getComputePropertyValue( String inputName, ServiceTemplate serviceTemplate, @@ -3349,16 +3421,37 @@ public class UnifiedCompositionService { computeTemplateConsolidationData.getNodeTemplateId()); String nodeType = getComputeTypeSuffix(nodeTemplate.getType()); Optional<String> propertyName = - getPropertyNameFromInput(inputName, UnifiedCompositionEntity.Compute, nodeType, null); + getPropertyNameFromInput(inputName, COMPUTE, nodeType, null); if (propertyName.isPresent()) { return getPropertyValueFromNodeTemplate(propertyName.get(), nodeTemplate); } return Optional.empty(); } + private Object getSubInterfacePropertyValue(String inputName, + String subInterfaceTypeSuffix, + PropertyInputType propertyInputType, + ServiceTemplate serviceTemplate, + String subInterfaceNodeTemplateId) { + //Get the input prefix to extract the property name from the input name + String propertyInputPrefix = getPropertyInputPrefix(subInterfaceNodeTemplateId, + subInterfaceTypeSuffix, propertyInputType, UnifiedCompositionEntity.SUB_INTERFACE); + //Get the property name from the input + Optional<String> propertyName = getPropertyNameFromInput(inputName, + UnifiedCompositionEntity.SUB_INTERFACE, null, propertyInputPrefix); + //Get the property value from the node template + if (propertyName.isPresent()) { + NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, + subInterfaceNodeTemplateId); + if (Objects.nonNull(subInterfaceNodeTemplate)) { + return getPropertyValueFromNodeTemplate(propertyName.get(), subInterfaceNodeTemplate); + } + } + return Optional.empty(); + } + private Optional<Object> getIdenticalPropertyValue(String identicalValuePropertyName, ServiceTemplate serviceTemplate, - UnifiedCompositionEntity unifiedCompositionEntity, EntityConsolidationData entity, TranslationContext context) { NodeTemplate nodeTemplate = @@ -3372,12 +3465,17 @@ public class UnifiedCompositionService { } private UnifiedCompositionEntity getInputCompositionEntity(String inputName) { - UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.Other; - String inputType = inputName.substring(0, inputName.indexOf('_')); - if (inputType.equals(UnifiedCompositionEntity.Compute.name().toLowerCase())) { - inputCompositionEntity = UnifiedCompositionEntity.Compute; - } else if (inputType.equals(UnifiedCompositionEntity.Port.name().toLowerCase())) { - inputCompositionEntity = UnifiedCompositionEntity.Port; + UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.OTHER; + if (inputName.indexOf('_') != -1) { + String inputType = inputName.substring(0, inputName.indexOf('_')); + if (inputType.equalsIgnoreCase(COMPUTE.getDisplayName())) { + inputCompositionEntity = COMPUTE; + } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.PORT.getDisplayName())) { + inputCompositionEntity = UnifiedCompositionEntity.PORT; + } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.SUB_INTERFACE + .getDisplayName())) { + inputCompositionEntity = UnifiedCompositionEntity.SUB_INTERFACE; + } } return inputCompositionEntity; } @@ -3385,16 +3483,17 @@ public class UnifiedCompositionService { private Optional<String> getPropertyNameFromInput( String inputName, UnifiedCompositionEntity compositionEntity, - String computeType, String portInputPrefix) { + String entityType, String propertyInputPrefix) { String propertyName = null; switch (compositionEntity) { - case Compute: - propertyName = inputName.substring(inputName.lastIndexOf(computeType) - + computeType.length() + 1); + case COMPUTE: + propertyName = inputName.substring(inputName.lastIndexOf(entityType) + + entityType.length() + 1); break; - case Port: - if (inputName.startsWith(portInputPrefix)) { - propertyName = inputName.split(portInputPrefix)[1]; + case PORT: + case SUB_INTERFACE: + if (inputName.startsWith(propertyInputPrefix)) { + propertyName = inputName.split(propertyInputPrefix)[1]; } break; default: @@ -3403,47 +3502,49 @@ public class UnifiedCompositionService { return Optional.ofNullable(propertyName); } - private String getPortInputPrefix( - String portNodeTemplateId, - PortInputType portInputType) { - String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_"; - String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId); - if (portInputType == PortInputType.NodeTemplateId) { - portInputPrefix += portNodeTemplateId + "_"; - } else if (portInputType == PortInputType.PortType) { - portInputPrefix += portType + "_"; + private String getPropertyInputPrefix(String nodeTemplateId, + String propertyEntityType, + PropertyInputType propertyInputType, + UnifiedCompositionEntity unifiedCompositionEntity) { + String propertyInputPrefix = unifiedCompositionEntity.getDisplayName().toLowerCase() + "_"; + if (propertyInputType == PropertyInputType.NODE_TEMPLATE_ID) { + propertyInputPrefix += nodeTemplateId + "_"; + } else if (propertyInputType == PropertyInputType.TYPE) { + propertyInputPrefix += propertyEntityType + "_"; } - return portInputPrefix; + return propertyInputPrefix; } private boolean isIdenticalValueProperty(String inputName, - UnifiedCompositionEntity unifiedCompositionEntity, - TranslationContext context) { + UnifiedCompositionEntity unifiedCompositionEntity) { List<String> identicalValuePropertyList = consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity); StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity); + if (Objects.isNull(builder)) { + return false; + } boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName); - return (isMatchingProperty + return isMatchingProperty && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity, - identicalValuePropertyList)); + identicalValuePropertyList); } private boolean isPropertyFromIdenticalValuesList(String inputName, UnifiedCompositionEntity unifiedCompositionEntity, List<String> identicalValuePropertyList) { switch (unifiedCompositionEntity) { - case Compute: + case COMPUTE: return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName, - unifiedCompositionEntity, null).get()); + unifiedCompositionEntity).get()); - case Other: + case OTHER: return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName, - unifiedCompositionEntity, null).get()); + unifiedCompositionEntity).get()); - case Port: + case PORT: return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent(); default: @@ -3465,15 +3566,18 @@ public class UnifiedCompositionService { UnifiedCompositionEntity unifiedCompositionEntity) { switch (unifiedCompositionEntity) { - case Compute: + case COMPUTE: return getComputePropertyValueStringBuilder(); - case Other: + case OTHER: return getComputePropertyValueStringBuilder(); - case Port: + case PORT: return getPortPropertyValueStringBuilder(); + case SUB_INTERFACE: + return getSubInterfacePropertyValueStringBuilder(); + default: return null; } @@ -3494,17 +3598,24 @@ public class UnifiedCompositionService { return builder; } + private StringBuilder getSubInterfacePropertyValueStringBuilder() { + StringBuilder builder; + builder = new StringBuilder(SUB_INTERFACE_PROPERTY_VALUE_PREFIX); + builder.append(".+"); + return builder; + } + private Optional<String> getIdenticalValuePropertyName(String input, - UnifiedCompositionEntity unifiedCompositionEntity, - TranslationContext context) { + UnifiedCompositionEntity + unifiedCompositionEntity) { switch (unifiedCompositionEntity) { - case Compute: + case COMPUTE: return Optional.of(input.split("_")[1]); - case Other: + case OTHER: return Optional.of(input.split("_")[1]); - case Port: + case PORT: return getPortPropertyNameFromInput(input, consolidationService .getPropertiesWithIdenticalVal(unifiedCompositionEntity)); @@ -3533,21 +3644,28 @@ public class UnifiedCompositionService { if (Objects.nonNull(computeTemplateConsolidationData)) { consolidationNodeTemplateIdAndType .put(computeTemplateConsolidationData.getNodeTemplateId(), - UnifiedCompositionEntity.Compute); + COMPUTE); + } + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData); + for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData : + subInterfaceTemplateConsolidationDataList) { + consolidationNodeTemplateIdAndType.put(subInterfaceTemplateConsolidationData.getNodeTemplateId(), + UnifiedCompositionEntity.SUB_INTERFACE); } List<PortTemplateConsolidationData> portTemplateConsolidationDataList = getPortTemplateConsolidationDataList(unifiedCompositionData); for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) { consolidationNodeTemplateIdAndType.put(portTemplateConsolidationData.getNodeTemplateId(), - UnifiedCompositionEntity.Port); + UnifiedCompositionEntity.PORT); } NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData.getNestedTemplateConsolidationData(); if (Objects.nonNull(nestedTemplateConsolidationData)) { consolidationNodeTemplateIdAndType .put(nestedTemplateConsolidationData.getNodeTemplateId(), - UnifiedCompositionEntity.Nested); + UnifiedCompositionEntity.NESTED); } } return consolidationNodeTemplateIdAndType; @@ -3559,9 +3677,9 @@ public class UnifiedCompositionService { ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList(); } - private enum PortInputType { - NodeTemplateId, - PortType, - Other; + private enum PropertyInputType { + NODE_TEMPLATE_ID, + TYPE, + OTHER } } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionUtil.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionUtil.java index 7f3025408f..4d9a269c2e 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionUtil.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionUtil.java @@ -1,15 +1,46 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.openecomp.sdc.translator.services.heattotosca; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; +import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.MapUtils; import org.openecomp.sdc.logging.api.Logger; import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; +import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; +import org.openecomp.sdc.tosca.services.DataModelUtil; +import org.openecomp.sdc.tosca.services.ToscaUtil; +import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.stream.Collectors; /** * Utility class for consolidation data collection helper methods. @@ -18,6 +49,10 @@ public class UnifiedCompositionUtil { protected static Logger logger = LoggerFactory.getLogger(UnifiedCompositionUtil.class); + private UnifiedCompositionUtil() { + //Hiding the implicit public constructor + } + /** * Gets all ports per port type, which are connected to the computes from the input * computeTemplateConsolidationDataCollection. @@ -40,6 +75,37 @@ public class UnifiedCompositionUtil { return portTypeToIds; } + static ListMultimap<String, SubInterfaceTemplateConsolidationData> + collectAllSubInterfacesOfEachTypesFromPorts(Collection<PortTemplateConsolidationData> + portTemplateConsolidationDataCollection) { + ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceDataByType = ArrayListMultimap.create(); + for (PortTemplateConsolidationData port : portTemplateConsolidationDataCollection) { + Set<String> allSubInterfaceNodeTypes = port.getAllSubInterfaceNodeTypes(); + if (CollectionUtils.isEmpty(allSubInterfaceNodeTypes)) { + continue; + } + for (String subInterfaceNodeType : allSubInterfaceNodeTypes) { + subInterfaceDataByType.putAll(subInterfaceNodeType, + port.getSubInterfaceConsolidationData(subInterfaceNodeType)); + } + } + return subInterfaceDataByType; + } + + static List<String> getSubInterfaceNodeTemplateIdsByType(PortTemplateConsolidationData + portTemplateConsolidationData, + String subInterfaceType) { + List<String> subInterfaceNodeTemplateIds = new ArrayList<>(); + List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = + portTemplateConsolidationData.getSubInterfaceConsolidationData(subInterfaceType); + if (CollectionUtils.isNotEmpty(subInterfaceTemplateConsolidationDataList)) { + subInterfaceNodeTemplateIds = subInterfaceTemplateConsolidationDataList.stream() + .map(SubInterfaceTemplateConsolidationData::getNodeTemplateId) + .collect(Collectors.toList()); + } + return subInterfaceNodeTemplateIds; + } + private static void addPortsToMap(Map<String, List<String>> portTypeToIds, Map<String, List<String>> ports) { for (Map.Entry<String, List<String>> portTypeToIdEntry : ports.entrySet()) { @@ -48,5 +114,116 @@ public class UnifiedCompositionUtil { } } + static String getComputeTypeSuffix(ServiceTemplate serviceTemplate, + String computeNodeTemplateId) { + NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId); + if (Objects.nonNull(computeNodeTemplate)) { + return getComputeTypeSuffix(computeNodeTemplate.getType()); + } + return null; + } + + public static String getNewComputeNodeTemplateId(ServiceTemplate serviceTemplate, String computeNodeTemplateId) { + return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId); + } + + static String getComputeTypeSuffix(String computeType) { + return DataModelUtil.getNamespaceSuffix(computeType); + } + + public static ComputeTemplateConsolidationData getConnectedComputeConsolidationData( + List<UnifiedCompositionData> unifiedCompositionDataList, + String portNodeTemplateId) { + for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) { + if (Objects.isNull(unifiedCompositionData.getComputeTemplateConsolidationData().getPorts())) { + continue; + } + Collection<List<String>> portsCollection = + unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values(); + for (List<String> portIdList : portsCollection) { + if (portIdList.contains(portNodeTemplateId)) { + return unifiedCompositionData.getComputeTemplateConsolidationData(); + } + } + } + return null; + } + + //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId> + public static String getNewPortNodeTemplateId( + String portNodeTemplateId, + String connectedComputeNodeType, + ComputeTemplateConsolidationData computeTemplateConsolidationData) { + + StringBuilder newPortNodeTemplateId = new StringBuilder(); + String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId); + newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType)); + if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) { + //single port + newPortNodeTemplateId.append("_").append(portNodeTemplateId); + } else { + //consolidation port + newPortNodeTemplateId.append("_").append(portType); + } + return newPortNodeTemplateId.toString(); + } + + public static String getNewSubInterfaceNodeTemplateId(ServiceTemplate serviceTemplate, + String connectedComputeNodeType, + ComputeTemplateConsolidationData computeTemplateConsolidationData, + SubInterfaceTemplateConsolidationData + subInterfaceTemplateConsolidationData, + TranslationContext context) { + //The ID should be <vm_type>_<portType/NodetemplateId>_<subInterface_type> + // or <vm_type>_<portType/NodetemplateId>_<subInterfaceNodeTemplateId> + StringBuilder newSubInterfaceNodeTemplateId = new StringBuilder(); + newSubInterfaceNodeTemplateId.append(getNewPortNodeTemplateId(subInterfaceTemplateConsolidationData + .getParentPortNodeTemplateId(), connectedComputeNodeType, computeTemplateConsolidationData)); + PortTemplateConsolidationData portTemplateConsolidationData = + getSubInterfacePortTemplateConsolidationData(serviceTemplate, subInterfaceTemplateConsolidationData, context); + NodeTemplate subInterfaceNodeTemplate = + DataModelUtil.getNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData.getNodeTemplateId()); + if (Objects.nonNull(portTemplateConsolidationData)) { + List<String> subInterfaceNodeTemplateIdsByType = + UnifiedCompositionUtil.getSubInterfaceNodeTemplateIdsByType(portTemplateConsolidationData, + subInterfaceNodeTemplate.getType()); + if (CollectionUtils.isNotEmpty(subInterfaceNodeTemplateIdsByType)) { + //If there are more than one subinterfaces with same type use node template id + if (subInterfaceNodeTemplateIdsByType.size() > 1) { + newSubInterfaceNodeTemplateId.append("_").append(subInterfaceTemplateConsolidationData.getNodeTemplateId()); + } else { + //Add sub interface type since we have only one subinterface per type + String subInterfaceTypeSuffix = getSubInterfaceTypeSuffix(subInterfaceNodeTemplate.getType()); + newSubInterfaceNodeTemplateId.append("_").append(subInterfaceTypeSuffix); + } + return newSubInterfaceNodeTemplateId.toString(); + } + } + return subInterfaceTemplateConsolidationData.getNodeTemplateId(); + } + + static PortTemplateConsolidationData getSubInterfacePortTemplateConsolidationData(ServiceTemplate serviceTemplate, + SubInterfaceTemplateConsolidationData + subInterfaceTemplateConsolidationData, + TranslationContext context) { + FilePortConsolidationData filePortConsolidationData = context.getConsolidationData().getPortConsolidationData() + .getFilePortConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate)); + PortTemplateConsolidationData portTemplateConsolidationData = null; + if (filePortConsolidationData != null) { + portTemplateConsolidationData = filePortConsolidationData + .getPortTemplateConsolidationData(subInterfaceTemplateConsolidationData.getParentPortNodeTemplateId()); + } + return portTemplateConsolidationData; + } + + static String getSubInterfaceTypeSuffix(String nodeType) { + return DataModelUtil.getNamespaceSuffix(nodeType); + } + + public static List<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationDataList( + UnifiedCompositionData unifiedCompositionData) { + return unifiedCompositionData.getSubInterfaceTemplateConsolidationDataList() == null ? new + ArrayList<>() : unifiedCompositionData.getSubInterfaceTemplateConsolidationDataList(); + } } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/helper/ContrailV2VirtualMachineInterfaceHelper.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/helper/ContrailV2VirtualMachineInterfaceHelper.java index 0933174296..622f3c1be3 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/helper/ContrailV2VirtualMachineInterfaceHelper.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/helper/ContrailV2VirtualMachineInterfaceHelper.java @@ -1,27 +1,27 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ + package org.openecomp.sdc.translator.services.heattotosca.helper; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes; import org.openecomp.sdc.heat.datatypes.model.Resource; +import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions; import org.openecomp.sdc.heat.services.HeatConstants; import org.openecomp.sdc.logging.api.Logger; import org.openecomp.sdc.logging.api.LoggerFactory; @@ -30,6 +30,7 @@ import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; import org.openecomp.sdc.tosca.services.ToscaConstants; import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId; +import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo; import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource; import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil; @@ -37,11 +38,14 @@ import org.openecomp.sdc.translator.services.heattotosca.ConsolidationEntityType import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil; import org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation.ResourceTranslationBase; +import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; +import java.util.Set; public class ContrailV2VirtualMachineInterfaceHelper { static Logger logger = @@ -138,7 +142,7 @@ public class ContrailV2VirtualMachineInterfaceHelper { } /** - * Check if the input heat resource is Vlan sub interface resource + * Check if the input heat resource is Vlan sub interface resource. * * @param resource heat resource to be checked * @return true - if input resource is valn sub interface resource flase - otherwise. @@ -154,6 +158,32 @@ public class ContrailV2VirtualMachineInterfaceHelper { return false; } + public boolean isVlanSubInterfaceConnectedToPortIndirectly(TranslateTo translateTo) { + Resource resource = translateTo.getResource(); + TranslationContext context = translateTo.getContext(); + Set<String> nestedHeatsFiles = context.getNestedHeatsFiles(); + Map<String, Object> properties = resource.getProperties(); + + if (MapUtils.isNotEmpty(properties) + && properties.containsKey(HeatConstants.VMI_REFS_PROPERTY_NAME)) { + Map<String, Object> portReference = getPortReference(properties); + + return CollectionUtils.isNotEmpty(nestedHeatsFiles) + && nestedHeatsFiles.contains(translateTo.getHeatFileName()) + && portReference.containsKey(ResourceReferenceFunctions.GET_PARAM.getFunction()); + } + + return false; + } + + private Map<String, Object> getPortReference(Map<String, Object> properties) { + Object portReferenceObj = properties.get(HeatConstants.VMI_REFS_PROPERTY_NAME); + List<Object> portReference = + portReferenceObj instanceof List ? (List<Object>) portReferenceObj : new ArrayList<>(); + return CollectionUtils.isEmpty(portReference) ? new HashMap<>() + : (Map<String, Object>) portReference.get(0); + } + private Optional<Object> getVlanTagPropertyValue(Resource resource) { Object vmiProperties = resource.getProperties() .get(HeatConstants.VMI_PROPERTIES_PROPERTY_NAME); diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/functiontranslation/FunctionTranslationGetAttrImpl.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/functiontranslation/FunctionTranslationGetAttrImpl.java index 1d35795e4c..686a9c89a9 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/functiontranslation/FunctionTranslationGetAttrImpl.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/functiontranslation/FunctionTranslationGetAttrImpl.java @@ -1,9 +1,6 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -15,11 +12,12 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation; +import static org.openecomp.sdc.translator.services.heattotosca.ConfigConstants.TRANS_MAPPING_DELIMITER_CHAR; + import org.apache.commons.lang3.StringUtils; import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate; import org.openecomp.sdc.heat.datatypes.model.Resource; @@ -30,8 +28,9 @@ import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; import org.openecomp.sdc.tosca.datatypes.model.Template; import org.openecomp.sdc.tosca.services.YamlUtil; import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; +import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData; -import org.openecomp.sdc.translator.services.heattotosca.ConfigConstants; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil; import org.openecomp.sdc.translator.services.heattotosca.Constants; import org.openecomp.sdc.translator.services.heattotosca.FunctionTranslation; @@ -243,10 +242,16 @@ public class FunctionTranslationGetAttrImpl implements FunctionTranslation { String attName) { Resource resource = heatOrchestrationTemplate.getResources().get(resourceId); boolean isNestedResource = HeatToToscaUtil.isNestedResource(resource); + String heatPropertyName = propertyName; String toscaPropertyName = propertyName; + //For handling get_attr in inner levels for complex properties + if (propertyName.contains(TRANS_MAPPING_DELIMITER_CHAR)) { + heatPropertyName = propertyName.substring(0, + propertyName.indexOf(TRANS_MAPPING_DELIMITER_CHAR)); + } if (!isNestedResource) { toscaPropertyName = HeatToToscaUtil.getToscaPropertyName(context, resource - .getType(), propertyName); + .getType(), heatPropertyName); } ConsolidationDataUtil .updateNodeGetAttributeIn(entityConsolidationData, @@ -271,13 +276,22 @@ public class FunctionTranslationGetAttrImpl implements FunctionTranslation { return Optional.of( ConsolidationDataUtil.getComputeTemplateConsolidationData(context, serviceTemplate, - computeType, resourceId)); + computeType, resourceTranslatedId)); } else if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate, resourceId)) { return Optional.of(ConsolidationDataUtil - .getPortTemplateConsolidationData(context, serviceTemplate, resourceId)); + .getPortTemplateConsolidationData(context, serviceTemplate, resourceId, resource.getType(), + resourceTranslatedId)); + } else if (HeatToToscaUtil.isSubInterfaceResource(resource, context)) { + TranslateTo subInterfaceTo = new TranslateTo(heatFileName, serviceTemplate, heatOrchestrationTemplate, + resource, resourceId, resourceTranslatedId, context); + Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData = + ConsolidationDataUtil.getSubInterfaceTemplateConsolidationData(subInterfaceTo, resourceTranslatedId); + if (subInterfaceTemplateConsolidationData.isPresent()) { + return Optional.of(subInterfaceTemplateConsolidationData.get()); + } } else if (HeatToToscaUtil.isNestedResource(resource)) { return Optional.ofNullable(ConsolidationDataUtil - .getNestedTemplateConsolidationData(context, serviceTemplate, heatFileName, resourceId)); + .getNestedTemplateConsolidationData(context, serviceTemplate, heatFileName, resourceTranslatedId)); } return Optional.empty(); } @@ -330,7 +344,7 @@ public class FunctionTranslationGetAttrImpl implements FunctionTranslation { if (isInteger(attributeParamList.get(j))) { continue; } - attributeFullPath.append(ConfigConstants.TRANS_MAPPING_DELIMITER_CHAR); + attributeFullPath.append(TRANS_MAPPING_DELIMITER_CHAR); attributeFullPath.append(attributeParamList.get(j)); } return attributeFullPath.toString(); @@ -341,13 +355,7 @@ public class FunctionTranslationGetAttrImpl implements FunctionTranslation { return false; } - /*try { - Integer.parseInt(String.valueOf(inputNumber)); - return true; - } catch (NumberFormatException exception) { - return false; - }*/ - if(StringUtils.isNumeric(String.valueOf(inputNumber))){ + if (StringUtils.isNumeric(String.valueOf(inputNumber))){ return true; } else { return false; @@ -377,15 +385,7 @@ public class FunctionTranslationGetAttrImpl implements FunctionTranslation { return getResourceTranslatedAttributesList(resource, context); } - if(!(attributeParamList.get(1) instanceof String)){ - //todo - once dynamic attr name will be supported the commented line will be support it in - // the first translation phase. -// Object toscaAttributeValue = getToscaAttributeValue(serviceTemplate, resourceId, propertyName, -// attributeParamList.get(1), resource -// .getType(), heatFileName, heatOrchestrationTemplate, null, context); -// List<Object> dynamicAttrValue = new ArrayList<>(); -// dynamicAttrValue.add(toscaAttributeValue); -// return Optional.of(dynamicAttrValue); + if (!(attributeParamList.get(1) instanceof String)) { return Optional.empty(); } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationBase.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationBase.java index 8cccbb8894..6809ce39cf 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationBase.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationBase.java @@ -1,21 +1,17 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation; @@ -77,7 +73,7 @@ public abstract class ResourceTranslationBase { getResourceTranslatedId(heatFileName, heatOrchestrationTemplate, resourceId, context); context.getTranslatedResources().putIfAbsent(heatFileName, new HashSet<>()); - if(isResourceWithSameIdAppearsInOtherFiles(heatFileName, resourceId, context)){ + if (isResourceWithSameIdAppearsInOtherFiles(heatFileName, resourceId, context)) { throw new CoreException( new DuplicateResourceIdsInDifferentFilesErrorBuilder(resourceId).build()); } @@ -106,7 +102,7 @@ public abstract class ResourceTranslationBase { private boolean isResourceWithSameIdAppearsInOtherFiles(String heatFileName, String resourceId, - TranslationContext context){ + TranslationContext context) { Set<String> translatedResourceIdsFromOtherFiles = context.getTranslatedResourceIdsFromOtherFiles(heatFileName); @@ -281,7 +277,7 @@ public abstract class ResourceTranslationBase { .getResource(heatOrchestrationTemplate, dependsOnResourceId, translateTo.getHeatFileName()); if (HeatToToscaUtil - .isValidDependsOnCandidate(heatOrchestrationTemplate, sourceResource, targetResource, + .isValidDependsOnCandidate(sourceResource, targetResource, ConsolidationEntityType.OTHER, translateTo.getContext())) { requirementAssignment.setNode(resourceTranslatedId.get()); requirementAssignment.setCapability(ToscaCapabilityType.NATIVE_NODE); diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationContrailV2VmInterfaceImpl.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationContrailV2VmInterfaceImpl.java index 7d96bd0b40..310cb2b4e3 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationContrailV2VmInterfaceImpl.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationContrailV2VmInterfaceImpl.java @@ -1,5 +1,5 @@ /* - * Copyright © 2016-2017 European Support Limited + * Copyright © 2016-2018 European Support Limited * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,6 +18,8 @@ package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslati import org.openecomp.sdc.common.togglz.ToggleableFeature; import org.openecomp.sdc.heat.services.HeatConstants; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; import org.openecomp.sdc.tosca.datatypes.ToscaNodeType; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.services.DataModelUtil; @@ -31,21 +33,24 @@ import java.util.Map; public class ResourceTranslationContrailV2VmInterfaceImpl extends ResourceTranslationBase { + protected static final Logger LOGGER = LoggerFactory.getLogger(ResourceTranslationContrailV2VmInterfaceImpl.class); + final ContrailV2VirtualMachineInterfaceHelper contrailV2VirtualMachineInterfaceHelper = + new ContrailV2VirtualMachineInterfaceHelper(); @Override - protected String generateTranslatedId(TranslateTo translateTo) { - if (!(new ContrailV2VirtualMachineInterfaceHelper().isVlanSubInterfaceResource(translateTo - .getResource())) || ToggleableFeature.VLAN_TAGGING.isActive()) { - return super.generateTranslatedId(translateTo); + protected boolean isEssentialRequirementsValid(TranslateTo translateTo) { + if(contrailV2VirtualMachineInterfaceHelper + .isVlanSubInterfaceResource(translateTo.getResource())) { + return ToggleableFeature.VLAN_TAGGING.isActive() && contrailV2VirtualMachineInterfaceHelper + .isVlanSubInterfaceConnectedToPortIndirectly(translateTo); } - - return null; + return true; } @Override protected void translate(TranslateTo translateTo) { - if (new ContrailV2VirtualMachineInterfaceHelper().isVlanSubInterfaceResource(translateTo - .getResource())) { + if (contrailV2VirtualMachineInterfaceHelper + .isVlanSubInterfaceResource(translateTo.getResource())) { translateVlanSubInterfaceResource(translateTo); } else { translateVirtualMachineInterfaceResource(translateTo); @@ -57,8 +62,8 @@ public class ResourceTranslationContrailV2VmInterfaceImpl extends ResourceTransl NodeTemplate nodeTemplate = new NodeTemplate(); nodeTemplate.setType(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE); nodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter - .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(),translateTo. - getResourceId(),translateTo.getResource().getProperties(), + .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(), translateTo. + getResourceId(), translateTo.getResource().getProperties(), nodeTemplate.getProperties(), translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(), translateTo.getResource().getType(), nodeTemplate, translateTo.getContext())); @@ -70,7 +75,7 @@ public class ResourceTranslationContrailV2VmInterfaceImpl extends ResourceTransl handleVmiMacAddressesInProperties(translateTo, nodeTemplate); - new ContrailV2VirtualMachineInterfaceHelper() + contrailV2VirtualMachineInterfaceHelper .connectVmiToNetwork(this, translateTo, nodeTemplate); DataModelUtil.addNodeTemplate(translateTo.getServiceTemplate(), translateTo.getTranslatedId(), nodeTemplate); @@ -81,12 +86,13 @@ public class ResourceTranslationContrailV2VmInterfaceImpl extends ResourceTransl String toscaVmiMacAddressesName = HeatToToscaUtil.getToscaPropertyName(translateTo, HeatConstants.VMI_MAC_ADDRESSES); String toscaVmiMacAddressesMacAddressesName = - HeatToToscaUtil.getToscaPropertyName(translateTo, HeatConstants.VMI_MAC_ADDRESSES_MAC_ADDRESSES); + HeatToToscaUtil + .getToscaPropertyName(translateTo, HeatConstants.VMI_MAC_ADDRESSES_MAC_ADDRESSES); - if(nodeTemplate.getProperties().containsKey(toscaVmiMacAddressesName)){ + if (nodeTemplate.getProperties().containsKey(toscaVmiMacAddressesName)) { Object macAddressesValue = nodeTemplate.getProperties().get(toscaVmiMacAddressesName); - if(macAddressesValue instanceof Map && ((Map<String, Object>)macAddressesValue).containsKey - (toscaVmiMacAddressesMacAddressesName)){ + if (macAddressesValue instanceof Map && ((Map<String, Object>) macAddressesValue).containsKey + (toscaVmiMacAddressesMacAddressesName)) { updateMacAddressesMacAddressesInProperties(nodeTemplate, toscaVmiMacAddressesName, toscaVmiMacAddressesMacAddressesName, (Map<String, Object>) macAddressesValue); @@ -100,9 +106,9 @@ public class ResourceTranslationContrailV2VmInterfaceImpl extends ResourceTransl Map<String, Object> macAddressesValue) { Object macAddressesMacAddressesValue = macAddressesValue.get(toscaVmiMacAddressesMacAddressesName); - if(macAddressesMacAddressesValue instanceof List){ + if (macAddressesMacAddressesValue instanceof List) { nodeTemplate.getProperties().put(toscaVmiMacAddressesName, macAddressesMacAddressesValue); - }else{ + } else { nodeTemplate.getProperties().remove(toscaVmiMacAddressesName); } } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNestedImpl.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNestedImpl.java index b85fb02795..a3b8009868 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNestedImpl.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNestedImpl.java @@ -1,47 +1,55 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.StringUtils; import org.openecomp.core.utilities.file.FileUtils; import org.openecomp.sdc.heat.datatypes.manifest.FileData; +import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes; +import org.openecomp.sdc.heat.datatypes.model.Resource; +import org.openecomp.sdc.heat.services.HeatConstants; import org.openecomp.sdc.logging.api.Logger; import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType; import org.openecomp.sdc.tosca.datatypes.ToscaNodeType; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.datatypes.model.NodeType; +import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; import org.openecomp.sdc.tosca.services.DataModelUtil; import org.openecomp.sdc.tosca.services.ToscaUtil; import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl; import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData; import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil; import org.openecomp.sdc.translator.services.heattotosca.Constants; import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil; import org.openecomp.sdc.translator.services.heattotosca.TranslationService; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + public class ResourceTranslationNestedImpl extends ResourceTranslationBase { - protected static Logger logger = - (Logger) LoggerFactory.getLogger(ResourceTranslationNestedImpl.class); + private static final String SUB_INTERFACE_COUNT = "count"; + protected static Logger log = LoggerFactory.getLogger(ResourceTranslationNestedImpl.class); @Override public void translate(TranslateTo translateTo) { @@ -49,13 +57,13 @@ public class ResourceTranslationNestedImpl extends ResourceTranslationBase { FileData nestedFileData = HeatToToscaUtil.getFileData(translateTo.getResource().getType(), context); if (nestedFileData == null) { - logger.warn("Nested File '" + translateTo.getResource().getType() + log.warn("Nested File '" + translateTo.getResource().getType() + "' is not exist, therefore, the nested resource with the ID '" + translateTo.getResourceId() + "' will be ignored in TOSCA translation"); return; } String templateName = FileUtils.getFileWithoutExtention(translateTo.getResource().getType()); - String substitutionNodeTypeKey = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat." + String substitutionNodeTypeKey = HeatToToscaUtil.getNestedResourceTypePrefix(translateTo) + templateName; if (!context.getTranslatedServiceTemplates() @@ -66,7 +74,7 @@ public class ResourceTranslationNestedImpl extends ResourceTranslationBase { createSubstitutionServiceTemplate(translateTo, nestedFileData, templateName); //global substitution service template - ServiceTemplate globalSubstitutionServiceTemplate = new HeatToToscaUtil() + ServiceTemplate globalSubstitutionServiceTemplate = HeatToToscaUtil .fetchGlobalSubstitutionServiceTemplate(translateTo.getServiceTemplate(), context); @@ -89,7 +97,7 @@ public class ResourceTranslationNestedImpl extends ResourceTranslationBase { ServiceTemplate substitutionServiceTemplate = context.getTranslatedServiceTemplates() .get(translateTo.getResource().getType()); - if(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(substitutionServiceTemplate)){ + if (DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(substitutionServiceTemplate)) { handleSubstitutionServiceTemplateWithoutNodeTemplates( templateName, translateTo); return; @@ -104,6 +112,57 @@ public class ResourceTranslationNestedImpl extends ResourceTranslationBase { //Add nested node template id to consolidation data ConsolidationDataUtil.updateNestedNodeTemplateId(translateTo); + + //Gather consolidation data if the resource group represents a sub interface + if (StringUtils.isNotBlank(substitutionNodeTypeKey) + && substitutionNodeTypeKey.contains(ToscaNodeType + .VLAN_SUB_INTERFACE_RESOURCE_TYPE_PREFIX)) { + populateSubInterfaceTemplateConsolidationData(translateTo, substitutionNodeTemplate); + } + } + + private void populateSubInterfaceTemplateConsolidationData(TranslateTo translateTo, + NodeTemplate nodeTemplate) { + + Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData = + ConsolidationDataUtil.getSubInterfaceTemplateConsolidationData(translateTo, translateTo + .getTranslatedId()); + if (!subInterfaceTemplateConsolidationData.isPresent()) { + return; + } + Optional<String> subInterfaceNetworkRole = + HeatToToscaUtil.getNetworkRoleFromResource(translateTo.getResource(), translateTo.getContext()); + subInterfaceNetworkRole.ifPresent(subInterfaceTemplateConsolidationData.get()::setNetworkRole); + Object count = getSubInterfaceCountFromResourceProperties(translateTo); + subInterfaceTemplateConsolidationData.get().setResourceGroupCount(count); + + if (CollectionUtils.isNotEmpty(nodeTemplate.getRequirements())) { + //Add connectivity to network in consolidation data based on resource group link requirements + nodeTemplate.getRequirements().forEach((Map<String, RequirementAssignment> requirementMap) -> + requirementMap.entrySet().stream() + .filter(requirementAssignmentEntry -> ToscaCapabilityType.NATIVE_NETWORK_LINKABLE + .equals(requirementAssignmentEntry.getValue().getCapability())) + .forEach(requirementAssignmentEntry -> subInterfaceTemplateConsolidationData.get() + .addNodesConnectedOut(requirementAssignmentEntry.getValue().getNode(), + requirementAssignmentEntry.getKey(), + requirementAssignmentEntry.getValue()) + ) + ); + } + } + + private Object getSubInterfaceCountFromResourceProperties(TranslateTo translateTo) { + if (Objects.nonNull(translateTo.getHeatOrchestrationTemplate().getResources().get(translateTo + .getResourceId()))) { + Resource resource = translateTo.getHeatOrchestrationTemplate().getResources().get(translateTo + .getResourceId()); + if(HeatResourcesTypes.RESOURCE_GROUP_RESOURCE_TYPE.getHeatResource().equals(resource.getType())) { + return resource.getProperties().get(SUB_INTERFACE_COUNT); + } else if (HeatToToscaUtil.isYamlFile(resource.getType())) { + return HeatConstants.DEFAULT_NESTED_HEAT_RESOURCE_COUNT; + } + } + return null; } private void handleSubstitutionServiceTemplateWithoutNodeTemplates(String templateName, diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNovaServerImpl.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNovaServerImpl.java index 06ba26c97a..2eb1040795 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNovaServerImpl.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNovaServerImpl.java @@ -1,21 +1,17 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation; @@ -415,8 +411,8 @@ public class ResourceTranslationNovaServerImpl extends ResourceTranslationBase { DataModelUtil.addBindingReqFromPortToCompute(novaServerResourceId, portNodeTemplate); // Add ports - ConsolidationDataUtil.updatePortInConsolidationData(translateTo, novaNodeTemplate.getType(), - translatedPortId.get()); + ConsolidationDataUtil.updatePortInConsolidationData(translateTo, novaNodeTemplate.getType(), resourceId, + portResource.getType(), translatedPortId.get()); } else { logger.warn("NovaServer connect to port resource with id : " + resourceId + " and type : " + portResource.getType() diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationResourceGroupImpl.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationResourceGroupImpl.java index 6afaf79cb9..68e3062a64 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationResourceGroupImpl.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationResourceGroupImpl.java @@ -1,25 +1,24 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. - * ================================================================================ +/* + * Copyright © 2016-2018 European Support Limited + * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * ============LICENSE_END========================================================= */ package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation; +import static org.openecomp.sdc.heat.services.HeatConstants.RESOURCE_DEF_TYPE_PROPERTY_NAME; +import static org.openecomp.sdc.heat.services.HeatConstants.RESOURCE_GROUP_INDEX_VAR_DEFAULT_VALUE; + import org.openecomp.sdc.common.errors.CoreException; import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes; import org.openecomp.sdc.heat.datatypes.model.Resource; @@ -28,6 +27,7 @@ import org.openecomp.sdc.tosca.datatypes.ToscaFunctions; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.services.DataModelUtil; import org.openecomp.sdc.tosca.services.ToscaConstants; +import org.openecomp.sdc.tosca.services.ToscaUtil; import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo; import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil; import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory; @@ -49,7 +49,7 @@ public class ResourceTranslationResourceGroupImpl extends ResourceTranslationBas Object resourceDef = translateTo.getResource().getProperties().get(HeatConstants.RESOURCE_DEF_PROPERTY_NAME); Resource nestedResource = new Resource(); - Object typeDefinition = ((Map) resourceDef).get("type"); + Object typeDefinition = ((Map) resourceDef).get(RESOURCE_DEF_TYPE_PROPERTY_NAME); if (!(typeDefinition instanceof String)) { logger.warn("Resource '" + translateTo.getResourceId() + "' of type'" + HeatResourcesTypes.RESOURCE_GROUP_RESOURCE_TYPE.getHeatResource() @@ -75,10 +75,12 @@ public class ResourceTranslationResourceGroupImpl extends ResourceTranslationBas .translateResource(heatFileName, translateTo.getServiceTemplate(), translateTo.getHeatOrchestrationTemplate(), nestedResource, translateTo.getResourceId(), translateTo.getContext()); + if (substitutionNodeTemplateId.isPresent()) { NodeTemplate substitutionNodeTemplate = - DataModelUtil.getNodeTemplate(translateTo.getServiceTemplate(), substitutionNodeTemplateId.get()); - if(!Objects.isNull(substitutionNodeTemplate)) { + DataModelUtil.getNodeTemplate(translateTo.getServiceTemplate(), + substitutionNodeTemplateId.get()); + if (!Objects.isNull(substitutionNodeTemplate)) { Map serviceTemplateFilter = (Map<String, Object>) substitutionNodeTemplate.getProperties() .get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME); @@ -93,8 +95,13 @@ public class ResourceTranslationResourceGroupImpl extends ResourceTranslationBas } private void handlingIndexVar(TranslateTo translateTo, NodeTemplate substitutionNodeTemplate) { + List<String> indexVarProperties = new ArrayList<>(); String indexVarValue = getIndexVarValue(translateTo); - replacePropertiesIndexVarValue(indexVarValue, substitutionNodeTemplate.getProperties()); + replacePropertiesIndexVarValue(indexVarValue, substitutionNodeTemplate.getProperties(), + indexVarProperties, translateTo); + //Add index var properties to context for unified model later + translateTo.getContext().addIndexVarProperties(ToscaUtil.getServiceTemplateFileName(translateTo + .getServiceTemplate()), translateTo.getTranslatedId(), indexVarProperties); } private Map<String, List> getNewIndexVarValue() { @@ -108,21 +115,29 @@ public class ResourceTranslationResourceGroupImpl extends ResourceTranslationBas } private void replacePropertiesIndexVarValue(String indexVarValue, - Map<String, Object> properties) { + Map<String, Object> properties, + List<String> indexVarProperties, + TranslateTo translateTo) { if (properties == null || properties.isEmpty()) { return; } for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) { Object propertyValue = propertyEntry.getValue(); - Object newPropertyValue = getUpdatedPropertyValueWithIndex(indexVarValue, propertyValue); + if (propertyValue != null && propertyValue.equals(RESOURCE_GROUP_INDEX_VAR_DEFAULT_VALUE)) { + indexVarProperties.add(propertyEntry.getKey()); + } + Object newPropertyValue = getUpdatedPropertyValueWithIndex(indexVarValue, propertyValue, + indexVarProperties, translateTo); if (newPropertyValue != null) { properties.put(propertyEntry.getKey(), newPropertyValue); } } } - private Object getUpdatedPropertyValueWithIndex(String indexVarValue, Object propertyValue) { + private Object getUpdatedPropertyValueWithIndex(String indexVarValue, Object propertyValue, + List<String> indexVarProperties, + TranslateTo translateTo) { if (propertyValue != null && propertyValue instanceof String) { if (propertyValue.equals(indexVarValue)) { return getNewIndexVarValue(); @@ -151,12 +166,14 @@ public class ResourceTranslationResourceGroupImpl extends ResourceTranslationBas } return propertyValue; //no update is needed } else if (propertyValue instanceof Map && !((Map) propertyValue).isEmpty()) { - replacePropertiesIndexVarValue(indexVarValue, (Map<String, Object>) propertyValue); + replacePropertiesIndexVarValue(indexVarValue, (Map<String, Object>) propertyValue, + indexVarProperties, translateTo); return propertyValue; } else if (propertyValue instanceof List && !((List) propertyValue).isEmpty()) { List newPropertyValueList = new ArrayList<>(); - for (Object entry : ((List) propertyValue)) { - newPropertyValueList.add(getUpdatedPropertyValueWithIndex(indexVarValue, entry)); + for (Object entry : (List) propertyValue) { + newPropertyValueList.add(getUpdatedPropertyValueWithIndex(indexVarValue, entry, + indexVarProperties, translateTo)); } return newPropertyValueList; } @@ -183,7 +200,7 @@ public class ResourceTranslationResourceGroupImpl extends ResourceTranslationBas Map serviceTemplateFilter) { boolean mandatory = false; Object countValue = TranslatorHeatToToscaPropertyConverter - .getToscaPropertyValue(translateTo.getServiceTemplate(),translateTo.getResourceId(), + .getToscaPropertyValue(translateTo.getServiceTemplate(), translateTo.getResourceId(), ToscaConstants.COUNT_PROPERTY_NAME, translateTo.getResource().getProperties().get (ToscaConstants.COUNT_PROPERTY_NAME), null, translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(), |