summaryrefslogtreecommitdiffstats
path: root/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java')
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java366
1 files changed, 137 insertions, 229 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java
index 00a2f6827f..e347df916e 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/utils/MergeInstanceUtils.java
@@ -7,9 +7,9 @@
* 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.
@@ -17,10 +17,22 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-
package org.openecomp.sdc.be.components.merge.utils;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonList;
+import static org.openecomp.sdc.be.dao.utils.MapUtil.toMap;
+
import fj.data.Either;
+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.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.openecomp.sdc.be.components.impl.utils.ExceptionUtils;
@@ -39,29 +51,15 @@ import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.common.log.wrappers.Logger;
-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.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import static java.util.Collections.emptyMap;
-import static java.util.Collections.singletonList;
-import static org.openecomp.sdc.be.dao.utils.MapUtil.toMap;
-
/**
* This class is Utils class but it should be bean
- * @author dr2032
*
+ * @author dr2032
*/
@org.springframework.stereotype.Component
public class MergeInstanceUtils {
+
private static final Logger log = Logger.getLogger(MergeInstanceUtils.class);
-
private final ToscaOperationFacade toscaOperationFacade;
private final ExceptionUtils exceptionUtils;
@@ -70,27 +68,31 @@ public class MergeInstanceUtils {
this.exceptionUtils = exceptionUtils;
}
+ private static boolean isCVFC(Component component) {
+ ComponentTypeEnum componentType = component.getComponentType();
+ if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
+ return false;
+ }
+ Resource resource = (Resource) component;
+ ResourceTypeEnum resourceType = resource.getResourceType();
+ return resourceType == ResourceTypeEnum.CVFC;
+ }
+
/**
- * @param container containing new component instance
- * @param origInstanceNode old component (in case of PROXY it should be actual service)
- * @param newInstanceId - ID of new instance of the component
+ * @param container containing new component instance
+ * @param origInstanceNode old component (in case of PROXY it should be actual service)
+ * @param newInstanceId - ID of new instance of the component
* @param oldCapabilitiesOwnerIds the old capabilities owner ids
* @return a map of capability owner IDs of old component instance to capability owner IDs of the new component instance
*/
- public Map<String, String> mapOldToNewCapabilitiesOwnerIds(Component container,
- Component origInstanceNode,
- String newInstanceId,
+ public Map<String, String> mapOldToNewCapabilitiesOwnerIds(Component container, Component origInstanceNode, String newInstanceId,
List<String> oldCapabilitiesOwnerIds) {
-
Map<String, String> resultMap;
-
if (ModelConverter.isAtomicComponent(origInstanceNode) || isCVFC(origInstanceNode)) {
resultMap = prepareMapForAtomicComponent(newInstanceId, oldCapabilitiesOwnerIds);
- }
- else {
+ } else {
resultMap = prepareMapForNonAtomicComponent(container, origInstanceNode, newInstanceId, oldCapabilitiesOwnerIds);
}
-
return resultMap;
}
@@ -100,8 +102,8 @@ public class MergeInstanceUtils {
* @return a map between capability owner IDs of old component instance to capability owner IDs of the new component instance
*/
public Map<String, String> mapOldToNewCapabilitiesOwnerIds(ComponentInstance oldInstance, ComponentInstance newInstance) {
- List<CapabilityOwner> prevCapabilityOwners = getInstanceAtomicBuildingBlocks(oldInstance).getCapabilitiesOwners();
- List<CapabilityOwner> newCapOwners = getInstanceAtomicBuildingBlocks(newInstance).getCapabilitiesOwners();
+ List<CapabilityOwner> prevCapabilityOwners = getInstanceAtomicBuildingBlocks(oldInstance).getCapabilitiesOwners();
+ List<CapabilityOwner> newCapOwners = getInstanceAtomicBuildingBlocks(newInstance).getCapabilitiesOwners();
return getCapabilitiesOwnerMapping(prevCapabilityOwners, newCapOwners);
}
@@ -113,15 +115,11 @@ public class MergeInstanceUtils {
public List<RequirementCapabilityRelDef> getUpdatedUiRelations(Component oldResource, Component newResource) {
Map<String, ComponentInstance> mapOldComponentInstances = buildComponentInstanceMap(oldResource, ComponentInstance::getUniqueId);
Map<String, ComponentInstance> mapNewComponentInstances = buildComponentInstanceMap(newResource, ComponentInstance::getName);
-
- return getUpdatedCapReqDefs(oldResource, newResource,
- mapOldComponentInstances,
- mapNewComponentInstances,
- RequirementCapabilityRelDef::isOriginUI);
+ return getUpdatedCapReqDefs(oldResource, newResource, mapOldComponentInstances, mapNewComponentInstances,
+ RequirementCapabilityRelDef::isOriginUI);
}
/**
- *
* @param componentInstance the instance which its building blocks are to be returned
* @return the atomic building (groups and instances) blocks which the given component instance is a composition of
*/
@@ -135,9 +133,8 @@ public class MergeInstanceUtils {
}
/**
- *
* @param componentInstance the instance which its building blocks are to be returned
- * @param component the type thar the given component instance was created from
+ * @param component the type thar the given component instance was created from
* @return the atomic building blocks (groups and instances) which the given component instance is a composition of
*/
public ComponentInstanceBuildingBlocks getInstanceAtomicBuildingBlocks(ComponentInstance componentInstance, Component component) {
@@ -149,20 +146,19 @@ public class MergeInstanceUtils {
if (componentInstance.getIsProxy()) {
// Component is proxy and it doesn't contain required data
instanceBuildingBlocks = getInstanceAtomicBuildingBlocks(componentInstance);
- }
- else {
+ } else {
instanceBuildingBlocks = ComponentInstanceBuildingBlocks.of(new ArrayList<>(), singletonList(componentInstance));
}
return instanceBuildingBlocks;
- }
- else {
+ } else {
instanceBuildingBlocks = recursiveScanForAtomicBuildingBlocks(component);
- if(org.apache.commons.collections.MapUtils.isNotEmpty(component.getCapabilities()) || org.apache.commons.collections.MapUtils.isNotEmpty(component.getRequirements())) {
- ComponentInstanceBuildingBlocks nonAtomicBlocks = ComponentInstanceBuildingBlocks.of(new ArrayList<>(), singletonList(componentInstance));
+ if (org.apache.commons.collections.MapUtils.isNotEmpty(component.getCapabilities()) || org.apache.commons.collections.MapUtils
+ .isNotEmpty(component.getRequirements())) {
+ ComponentInstanceBuildingBlocks nonAtomicBlocks = ComponentInstanceBuildingBlocks
+ .of(new ArrayList<>(), singletonList(componentInstance));
return ComponentInstanceBuildingBlocks.merge(instanceBuildingBlocks, nonAtomicBlocks);
}
return instanceBuildingBlocks;
-
}
}
@@ -176,13 +172,9 @@ public class MergeInstanceUtils {
return createRequirementRelationMergeInfo(vfcInstances, ownerId, relDef);
}
-
- public RequirementCapabilityRelDef restoreCapabilityRelation(RelationMergeInfo oldCapInfo,
- String newInstanceId,
- Map<String, CapabilityOwner> capOwnerByName,
- Component updatedContainerComponent) {
+ public RequirementCapabilityRelDef restoreCapabilityRelation(RelationMergeInfo oldCapInfo, String newInstanceId,
+ Map<String, CapabilityOwner> capOwnerByName, Component updatedContainerComponent) {
String oldCapOwnerName = oldCapInfo.getCapOwnerName();
-
CapabilityOwner newCapOwner = capOwnerByName.get(oldCapOwnerName);
if (newCapOwner != null) {
// Append relation to updated container
@@ -203,41 +195,30 @@ public class MergeInstanceUtils {
}
}
-
-
- public RequirementCapabilityRelDef restoreRequirementRelation(RelationMergeInfo oldReqInfo,
- String newInstanceId,
- Map<String, ComponentInstance> vfciMap,
- Component updatedContainerComponent) {
+ public RequirementCapabilityRelDef restoreRequirementRelation(RelationMergeInfo oldReqInfo, String newInstanceId,
+ Map<String, ComponentInstance> vfciMap, Component updatedContainerComponent) {
String oldVfcInstanceName = oldReqInfo.getCapOwnerName();
-
ComponentInstance newVfcInstance = vfciMap.get(oldReqInfo.getCapOwnerName());
if (newVfcInstance != null) {
// Append relation to updated container
RequirementCapabilityRelDef oldRelDef = oldReqInfo.getRelDef();
oldRelDef.setFromNode(newInstanceId);
-
RelationshipInfo oldRelationshipInfo = oldRelDef.resolveSingleRelationship().getRelation();
oldRelationshipInfo.setRequirementOwnerId(newVfcInstance.getUniqueId());
oldRelationshipInfo.getRelationship().setType(oldReqInfo.getCapReqType());
-
String vfcUid = newVfcInstance.getComponentUid();
Either<Component, StorageOperationStatus> eitherComponent = toscaOperationFacade.getToscaElement(vfcUid);
-
- if(eitherComponent.isLeft()) {
- String requirementUid = retrieveRequirementUid(oldReqInfo.getCapReqName() , eitherComponent.left().value());
+ if (eitherComponent.isLeft()) {
+ String requirementUid = retrieveRequirementUid(oldReqInfo.getCapReqName(), eitherComponent.left().value());
oldRelationshipInfo.setRequirementUid(requirementUid);
- }
- else {
+ } else {
log.debug("#restoreRequirementCapabilityRelDef - Unexpected error: resource was not loaded for VF ID: {}", vfcUid);
}
-
if (updatedContainerComponent != null) {
updatedContainerComponent.getComponentInstancesRelations().add(oldRelDef);
}
return oldRelDef;
- }
- else {
+ } else {
log.debug("#restoreRequirementCapabilityRelDef - Skip relation since it was not found VFC Instance with name {}", oldVfcInstanceName);
return null;
}
@@ -249,254 +230,204 @@ public class MergeInstanceUtils {
private Map<String, String> getCapabilitiesOwnerMapping(List<CapabilityOwner> oldCapOwners, List<CapabilityOwner> newCapOwners) {
Map<String, CapabilityOwner> newCapOwnerNameMap = toMap(newCapOwners, CapabilityOwner::getName, (p1, p2) -> p1);
- return oldCapOwners.stream()
- .filter(oldCapOwner -> newCapOwnerNameMap.containsKey(oldCapOwner.getName()))
- .collect(Collectors.toMap(CapabilityOwner::getUniqueId, oldCapOwner -> newCapOwnerNameMap.get(oldCapOwner.getName()).getUniqueId(), (p1, p2) -> p1));
- }
-
- private static boolean isCVFC(Component component) {
- ComponentTypeEnum componentType = component.getComponentType();
- if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
- return false;
- }
- Resource resource = (Resource) component;
- ResourceTypeEnum resourceType = resource.getResourceType();
- return resourceType == ResourceTypeEnum.CVFC;
+ return oldCapOwners.stream().filter(oldCapOwner -> newCapOwnerNameMap.containsKey(oldCapOwner.getName())).collect(Collectors
+ .toMap(CapabilityOwner::getUniqueId, oldCapOwner -> newCapOwnerNameMap.get(oldCapOwner.getName()).getUniqueId(), (p1, p2) -> p1));
}
-
private RequirementCapabilityRelDef mergeCapRelDefs(RequirementCapabilityRelDef capRelDefFrom, RequirementCapabilityRelDef capRelDefTo) {
if (capRelDefFrom == capRelDefTo) {
return capRelDefFrom;
- }
- else if (capRelDefFrom == null) {
+ } else if (capRelDefFrom == null) {
return capRelDefTo;
- }
- else if (capRelDefTo == null) {
+ } else if (capRelDefTo == null) {
return capRelDefFrom;
}
-
RelationshipInfo relationshipInfoFrom = capRelDefFrom.resolveSingleRelationship().getRelation();
RelationshipInfo relationshipInfoTo = capRelDefTo.resolveSingleRelationship().getRelation();
-
relationshipInfoFrom.setCapabilityOwnerId(relationshipInfoTo.getCapabilityOwnerId());
relationshipInfoFrom.setCapabilityUid(relationshipInfoTo.getCapabilityUid());
-
return capRelDefFrom;
}
-
-
private Map<String, ComponentInstance> buildComponentInstanceMap(Component oldRresource, Function<ComponentInstance, String> getKeyFunc) {
- return oldRresource.getComponentInstances().stream()
- .collect(Collectors.toMap(getKeyFunc, Function.identity(), (p1, p2) -> p1));
+ return oldRresource.getComponentInstances().stream().collect(Collectors.toMap(getKeyFunc, Function.identity(), (p1, p2) -> p1));
}
private List<RequirementCapabilityRelDef> getUpdatedCapReqDefs(Component oldResource, Component newComponent,
Map<String, ComponentInstance> mapOldComponentInstances,
Map<String, ComponentInstance> mapNewComponentInstances,
Predicate<? super RequirementCapabilityRelDef> filter) {
- return oldResource.getComponentInstancesRelations().stream()
- .filter(filter)
- .map(rel -> createRelationMergeInfoPair(rel, mapOldComponentInstances))
- .map(infoPair -> restoreRequirementCapabilityRelDef(infoPair, mapNewComponentInstances))
- .filter(Objects::nonNull)
- .filter(r-> capReqMatchExist(r, newComponent))
- .collect(Collectors.toList());
+ return oldResource.getComponentInstancesRelations().stream().filter(filter)
+ .map(rel -> createRelationMergeInfoPair(rel, mapOldComponentInstances))
+ .map(infoPair -> restoreRequirementCapabilityRelDef(infoPair, mapNewComponentInstances)).filter(Objects::nonNull)
+ .filter(r -> capReqMatchExist(r, newComponent)).collect(Collectors.toList());
}
-
private boolean capReqMatchExist(RequirementCapabilityRelDef rel, Component currentComponent) {
- return currentComponent.getComponentInstances().stream()
- .anyMatch(i->isFromInstance(i, rel)) &&
- currentComponent.getComponentInstances().stream()
- .anyMatch(i->isToInstance(i, rel));
+ return currentComponent.getComponentInstances().stream().anyMatch(i -> isFromInstance(i, rel)) && currentComponent.getComponentInstances()
+ .stream().anyMatch(i -> isToInstance(i, rel));
}
private boolean isToInstance(ComponentInstance inst, RequirementCapabilityRelDef rel) {
- return inst.getUniqueId().equals(rel.getToNode()) &&
- inst.getCapabilities().values()
- .stream()
- .flatMap(Collection::stream)
- .anyMatch(cap->cap.getName().equals(rel.resolveSingleRelationship().getRelation().getCapability())
- && cap.getOwnerId().equals(rel.resolveSingleRelationship().getRelation().getCapabilityOwnerId()));
+ return inst.getUniqueId().equals(rel.getToNode()) && inst.getCapabilities().values().stream().flatMap(Collection::stream).anyMatch(
+ cap -> cap.getName().equals(rel.resolveSingleRelationship().getRelation().getCapability()) && cap.getOwnerId()
+ .equals(rel.resolveSingleRelationship().getRelation().getCapabilityOwnerId()));
}
private boolean isFromInstance(ComponentInstance inst, RequirementCapabilityRelDef rel) {
- return inst.getUniqueId().equals(rel.getFromNode()) &&
- inst.getRequirements().values()
- .stream()
- .flatMap(Collection::stream)
- .anyMatch(req->req.getName().equals(rel.resolveSingleRelationship().getRelation().getRequirement())
- && req.getOwnerId().equals(rel.resolveSingleRelationship().getRelation().getRequirementOwnerId()));
+ return inst.getUniqueId().equals(rel.getFromNode()) && inst.getRequirements().values().stream().flatMap(Collection::stream).anyMatch(
+ req -> req.getName().equals(rel.resolveSingleRelationship().getRelation().getRequirement()) && req.getOwnerId()
+ .equals(rel.resolveSingleRelationship().getRelation().getRequirementOwnerId()));
}
private ImmutablePair<RelationMergeInfo, RelationMergeInfo> createRelationMergeInfoPair(RequirementCapabilityRelDef reqCapDef,
Map<String, ComponentInstance> mapOldComponentInstances) {
-
ComponentInstance oldComponentInstanceFrom = mapOldComponentInstances.get(reqCapDef.getFromNode());
RelationMergeInfo fromRelationMergeInfo = createRequirmentRelationMergeInfo(oldComponentInstanceFrom, reqCapDef);
-
ComponentInstance oldComponentInstanceTo = mapOldComponentInstances.get(reqCapDef.getToNode());
RelationMergeInfo toRelationMergeInfo = createCapabilityRelationMergeInfo(oldComponentInstanceTo, reqCapDef);
return new ImmutablePair<>(fromRelationMergeInfo, toRelationMergeInfo);
}
- private RelationMergeInfo createRequirmentRelationMergeInfo(ComponentInstance componentInstance, RequirementCapabilityRelDef reqCapDef ) {
-
+ private RelationMergeInfo createRequirmentRelationMergeInfo(ComponentInstance componentInstance, RequirementCapabilityRelDef reqCapDef) {
List<ComponentInstance> vfcInstances = getVfcInstances(componentInstance);
- if (vfcInstances != null) {
+ if (vfcInstances != null) {
return mapRelationRequirement(reqCapDef, vfcInstances);
- }
- else {
+ } else {
log.debug("#createRelationMergeInfo - It's unexpected that vfc instnaces were not found for {}", componentInstance);
return null;
}
}
- private RelationMergeInfo createCapabilityRelationMergeInfo(ComponentInstance componentInstance,
- RequirementCapabilityRelDef reqCapDef) {
+ private RelationMergeInfo createCapabilityRelationMergeInfo(ComponentInstance componentInstance, RequirementCapabilityRelDef reqCapDef) {
List<CapabilityOwner> capabilityOwners = getInstanceAtomicBuildingBlocks(componentInstance).getCapabilitiesOwners();
return mapRelationCapability(reqCapDef, capabilityOwners);
}
-
- private RequirementCapabilityRelDef restoreRequirementCapabilityRelDef(ImmutablePair<RelationMergeInfo, RelationMergeInfo> mergeInfoPair, Map<String, ComponentInstance> mapNewComponentInstances) {
+ private RequirementCapabilityRelDef restoreRequirementCapabilityRelDef(ImmutablePair<RelationMergeInfo, RelationMergeInfo> mergeInfoPair,
+ Map<String, ComponentInstance> mapNewComponentInstances) {
RequirementCapabilityRelDef capRelDefFrom = restoreRequirementRelDef(mergeInfoPair, mapNewComponentInstances);
RequirementCapabilityRelDef capRelDefTo = restoreCapabilityRelDef(mergeInfoPair, mapNewComponentInstances);
-
return mergeCapRelDefs(capRelDefFrom, capRelDefTo);
}
- private RequirementCapabilityRelDef restoreRequirementRelDef(ImmutablePair<RelationMergeInfo, RelationMergeInfo> mergeInfoPair, Map<String, ComponentInstance> mapNewComponentInstances) {
+ private RequirementCapabilityRelDef restoreRequirementRelDef(ImmutablePair<RelationMergeInfo, RelationMergeInfo> mergeInfoPair,
+ Map<String, ComponentInstance> mapNewComponentInstances) {
RequirementCapabilityRelDef capRelDefFrom = null;
RelationMergeInfo mergeInfoFrom = mergeInfoPair.getLeft();
if (mergeInfoFrom != null) {
ComponentInstance newComponentInstanceFrom = mapNewComponentInstances.get(mergeInfoFrom.getCapOwnerName());
- if(newComponentInstanceFrom != null){
- capRelDefFrom = restoreRequirementRelDef(newComponentInstanceFrom, mergeInfoFrom, newComponentInstanceFrom.getUniqueId());
+ if (newComponentInstanceFrom != null) {
+ capRelDefFrom = restoreRequirementRelDef(newComponentInstanceFrom, mergeInfoFrom, newComponentInstanceFrom.getUniqueId());
}
- }
- else {
+ } else {
capRelDefFrom = null;
}
return capRelDefFrom;
}
- private RequirementCapabilityRelDef restoreCapabilityRelDef(ImmutablePair<RelationMergeInfo, RelationMergeInfo> mergeInfoPair, Map<String, ComponentInstance> mapNewComponentInstances) {
+ private RequirementCapabilityRelDef restoreCapabilityRelDef(ImmutablePair<RelationMergeInfo, RelationMergeInfo> mergeInfoPair,
+ Map<String, ComponentInstance> mapNewComponentInstances) {
RequirementCapabilityRelDef capRelDefTo;
RelationMergeInfo mergeInfoTo = mergeInfoPair.getRight();
if (mergeInfoTo != null) {
ComponentInstance newComponentInstanceTo = mapNewComponentInstances.get(mergeInfoTo.getCapOwnerName());
capRelDefTo = restoreCapabilityRelDef(newComponentInstanceTo, mergeInfoTo, newComponentInstanceTo.getUniqueId());
- }
- else {
+ } else {
capRelDefTo = null;
}
return capRelDefTo;
}
- private RequirementCapabilityRelDef restoreRequirementRelDef(ComponentInstance newComponentInstance, RelationMergeInfo mergeInfoFrom, String newComponentInstanceFromId) {
+ private RequirementCapabilityRelDef restoreRequirementRelDef(ComponentInstance newComponentInstance, RelationMergeInfo mergeInfoFrom,
+ String newComponentInstanceFromId) {
if (newComponentInstance != null) {
List<ComponentInstance> vfcInstances = getVfcInstances(newComponentInstance);
- if(vfcInstances != null) {
+ if (vfcInstances != null) {
Map<String, ComponentInstance> vfciMap = toMap(vfcInstances, ComponentInstance::getName, (p1, p2) -> p1);
return restoreRequirementRelation(mergeInfoFrom, newComponentInstanceFromId, vfciMap, null);
- }
- else {
+ } else {
log.debug("#restoreRequirementCapabilityRelDef - It was not found VFC instances for component instance {}", newComponentInstance);
}
}
return null;
}
- private RequirementCapabilityRelDef restoreCapabilityRelDef(ComponentInstance newComponentInstance, RelationMergeInfo mergeInfoTo, String newComponentInstanceToId) {
+ private RequirementCapabilityRelDef restoreCapabilityRelDef(ComponentInstance newComponentInstance, RelationMergeInfo mergeInfoTo,
+ String newComponentInstanceToId) {
if (newComponentInstance != null) {
List<CapabilityOwner> capsOwners = getInstanceAtomicBuildingBlocks(newComponentInstance).getCapabilitiesOwners();
- if(capsOwners != null) {
+ if (capsOwners != null) {
Map<String, CapabilityOwner> vfciMap = toMap(capsOwners, CapabilityOwner::getName, (p1, p2) -> p1);
return restoreCapabilityRelation(mergeInfoTo, newComponentInstanceToId, vfciMap, null);
- }
- else {
+ } else {
log.debug("#restoreRequirementCapabilityRelDef - It was not found VFC instances for component instance {}", newComponentInstance);
}
}
return null;
}
-
private ComponentInstanceBuildingBlocks recursiveScanForAtomicBuildingBlocks(Component component) {
ComponentInstanceBuildingBlocks capsOwners = ComponentInstanceBuildingBlocks.of(component.getGroups(), null);
List<ComponentInstance> componentInstances = component.safeGetComponentInstances();
// Go recursively to collect atomic components only
- ComponentInstanceBuildingBlocks propsOwnersRec = componentInstances.stream()
- .map(this::getInstanceAtomicBuildingBlocks)
- .reduce(ComponentInstanceBuildingBlocks::merge)
- .orElse(ComponentInstanceBuildingBlocks.empty());
+ ComponentInstanceBuildingBlocks propsOwnersRec = componentInstances.stream().map(this::getInstanceAtomicBuildingBlocks)
+ .reduce(ComponentInstanceBuildingBlocks::merge).orElse(ComponentInstanceBuildingBlocks.empty());
return ComponentInstanceBuildingBlocks.merge(capsOwners, propsOwnersRec);
}
-
private Map<String, String> prepareMapForAtomicComponent(String newInstanceId, List<String> oldCapabilitiesOwnerIds) {
Map<String, String> resultMap;
-
int oldCapabilityOwnerIdsSize = oldCapabilitiesOwnerIds.size();
if (oldCapabilityOwnerIdsSize == 1) {
resultMap = new HashMap<>();
resultMap.put(oldCapabilitiesOwnerIds.get(0), newInstanceId);
- }
- else {
- log.debug("#prepareMapForAtomicComponent - For atomic component the list of old capabilities owner Ids should contains one element while actual size is {},", oldCapabilityOwnerIdsSize);
+ } else {
+ log.debug(
+ "#prepareMapForAtomicComponent - For atomic component the list of old capabilities owner Ids should contains one element while actual size is {},",
+ oldCapabilityOwnerIdsSize);
resultMap = emptyMap();
}
-
return resultMap;
}
- private Map<String, String> prepareMapForNonAtomicComponent(Component container, Component origInstanceNode,
- String newInstanceId, List<String> oldCapabilitiesOwnerIds) {
+ private Map<String, String> prepareMapForNonAtomicComponent(Component container, Component origInstanceNode, String newInstanceId,
+ List<String> oldCapabilitiesOwnerIds) {
ComponentInstance newInstance = container.getComponentInstanceById(newInstanceId).orElse(null);
if (newInstance == null) {
log.debug("#prepareMapForNonAtomicComponent - Failed to get component instance by newInstanceId: {}.", newInstanceId);
return emptyMap();
}
List<CapabilityOwner> prevCapOwners = recursiveScanForAtomicBuildingBlocks(origInstanceNode).getCapabilitiesOwners();
- Component origNewCmpt = toscaOperationFacade.getToscaElement(newInstance.getActualComponentUid()).left().on(err -> exceptionUtils.rollBackAndThrow(err, newInstance.getActualComponentUid()));
+ Component origNewCmpt = toscaOperationFacade.getToscaElement(newInstance.getActualComponentUid()).left()
+ .on(err -> exceptionUtils.rollBackAndThrow(err, newInstance.getActualComponentUid()));
return mapOldOwnerIdsToNewOnes(oldCapabilitiesOwnerIds, prevCapOwners, newInstance, origNewCmpt);
}
- private Map<String, String> mapOldOwnerIdsToNewOnes(List<String> oldCapabilitiesOwnerIds,
- List<CapabilityOwner> prevCapOwners, ComponentInstance newInstance, Component origNewInstanceType) {
+ private Map<String, String> mapOldOwnerIdsToNewOnes(List<String> oldCapabilitiesOwnerIds, List<CapabilityOwner> prevCapOwners,
+ ComponentInstance newInstance, Component origNewInstanceType) {
List<CapabilityOwner> newCapOwners = getInstanceAtomicBuildingBlocks(newInstance, origNewInstanceType).getCapabilitiesOwners();
return getCapabilitiesOwnerMapping(oldCapabilitiesOwnerIds, prevCapOwners, newCapOwners);
}
- private Map<String, String> getCapabilitiesOwnerMapping(List<String> oldCapabilitiesOwnerIds, List<CapabilityOwner> prevCapOwners, List<CapabilityOwner> newCapOwners) {
+ private Map<String, String> getCapabilitiesOwnerMapping(List<String> oldCapabilitiesOwnerIds, List<CapabilityOwner> prevCapOwners,
+ List<CapabilityOwner> newCapOwners) {
Map<String, CapabilityOwner> capOwnersByName = toMap(newCapOwners, CapabilityOwner::getName, (p1, p2) -> p1);
- return prevCapOwners
- .stream()
- .filter(oldCapOwner -> oldCapabilitiesOwnerIds.contains(oldCapOwner.getUniqueId()))
- .filter(oldCapOwner -> capOwnersByName.containsKey(oldCapOwner.getName()))
- .collect(Collectors.toMap(CapabilityOwner::getUniqueId, oldCapOwner -> capOwnersByName.get(oldCapOwner.getName()).getUniqueId(), (p1, p2) -> p1));
+ return prevCapOwners.stream().filter(oldCapOwner -> oldCapabilitiesOwnerIds.contains(oldCapOwner.getUniqueId()))
+ .filter(oldCapOwner -> capOwnersByName.containsKey(oldCapOwner.getName())).collect(Collectors
+ .toMap(CapabilityOwner::getUniqueId, oldCapOwner -> capOwnersByName.get(oldCapOwner.getName()).getUniqueId(), (p1, p2) -> p1));
}
-
- private RelationMergeInfo createCapabilityRelationMergeInfo(List<CapabilityOwner> vfcInstances, String ownerId, RequirementCapabilityRelDef relation) {
- return vfcInstances.stream()
- .filter(inst -> StringUtils.equals(inst.getUniqueId(), ownerId))
- .map(capabilityOwner -> getCapabilityMergeInfo(capabilityOwner, relation))
- .findAny()
- .orElse(null);
+ private RelationMergeInfo createCapabilityRelationMergeInfo(List<CapabilityOwner> vfcInstances, String ownerId,
+ RequirementCapabilityRelDef relation) {
+ return vfcInstances.stream().filter(inst -> StringUtils.equals(inst.getUniqueId(), ownerId))
+ .map(capabilityOwner -> getCapabilityMergeInfo(capabilityOwner, relation)).findAny().orElse(null);
}
-
- private RelationMergeInfo createRequirementRelationMergeInfo(List<ComponentInstance> vfcInstances, String ownerId, RequirementCapabilityRelDef relation) {
- return vfcInstances.stream()
- .filter(inst -> StringUtils.equals(inst.getUniqueId(), ownerId))
- .map(currVfcInst -> mapVfcInstanceRequirement(currVfcInst, relation))
- .filter(Objects::nonNull)
- .findAny()
- .orElse(null);
+ private RelationMergeInfo createRequirementRelationMergeInfo(List<ComponentInstance> vfcInstances, String ownerId,
+ RequirementCapabilityRelDef relation) {
+ return vfcInstances.stream().filter(inst -> StringUtils.equals(inst.getUniqueId(), ownerId))
+ .map(currVfcInst -> mapVfcInstanceRequirement(currVfcInst, relation)).filter(Objects::nonNull).findAny().orElse(null);
}
private RelationMergeInfo getCapabilityMergeInfo(CapabilityOwner capabilityOwner, RequirementCapabilityRelDef relDef) {
@@ -509,80 +440,57 @@ public class MergeInstanceUtils {
capabilityType = capabilityDef.getType();
capabilityName = capabilityDef.getName();
} else {
- log.debug("#getCapabilityMergeInfo - Failed to retrieve capability type for relation with name: {} and uniqueId {}", relDef.resolveSingleRelationship().getRelation().getCapability(), capabilityUniqueId);
+ log.debug("#getCapabilityMergeInfo - Failed to retrieve capability type for relation with name: {} and uniqueId {}",
+ relDef.resolveSingleRelationship().getRelation().getCapability(), capabilityUniqueId);
capabilityType = null;
capabilityName = null;
}
return new RelationMergeInfo(capabilityType, capabilityName, capOwnerName, relDef);
}
-
+
private RelationMergeInfo mapVfcInstanceRequirement(ComponentInstance vfcInstance, RequirementCapabilityRelDef relDef) {
String requirementUniqueId = relDef.resolveSingleRelationship().getRelation().getRequirementUid();
-
String vfcInstanceName = vfcInstance.getName();
String vfcUid = vfcInstance.getComponentUid();
-
Either<Resource, StorageOperationStatus> vfcResource = toscaOperationFacade.getToscaElement(vfcUid);
- if(vfcResource.isLeft()) {
+ if (vfcResource.isLeft()) {
Resource vfc = vfcResource.left().value();
-
RequirementDefinition requirementDef = retrieveRequirementDefinition(requirementUniqueId, vfc);
String requirementType;
String requirementName;
if (requirementDef != null) {
requirementType = requirementDef.getCapability();
requirementName = requirementDef.getName();
- }
- else {
- log.debug("#mapVfcInstanceRequirement - Failed to retrieve requirement type for relation with name: {} and uniqueId {}", relDef.resolveSingleRelationship().getRelation().getRequirement(), requirementUniqueId);
+ } else {
+ log.debug("#mapVfcInstanceRequirement - Failed to retrieve requirement type for relation with name: {} and uniqueId {}",
+ relDef.resolveSingleRelationship().getRelation().getRequirement(), requirementUniqueId);
requirementType = null;
- requirementName = null;
+ requirementName = null;
}
-
return new RelationMergeInfo(requirementType, requirementName, vfcInstanceName, relDef);
- }
- else {
- log.debug("#mapVfcInstanceRequirement - Failed to load VFC by uid {}", vfcUid);
+ } else {
+ log.debug("#mapVfcInstanceRequirement - Failed to load VFC by uid {}", vfcUid);
return null;
}
}
private CapabilityDefinition retrieveCapabilityDefinition(String uniqueId, CapabilityOwner capabilityOwner) {
- return capabilityOwner.getCapabilities().values().stream()
- .flatMap(List::stream)
- .filter(Objects::nonNull)
- .filter(def -> uniqueId.equals(def.getUniqueId()))
- .findFirst()
- .orElse(null);
- }
-
+ return capabilityOwner.getCapabilities().values().stream().flatMap(List::stream).filter(Objects::nonNull)
+ .filter(def -> uniqueId.equals(def.getUniqueId())).findFirst().orElse(null);
+ }
+
private RequirementDefinition retrieveRequirementDefinition(String uniqueId, Resource vfc) {
- return vfc.getRequirements().values().stream()
- .flatMap(List::stream)
- .filter(Objects::nonNull)
- .filter(def -> uniqueId.equals(def.getUniqueId()))
- .findFirst()
- .orElse(null);
- }
-
+ return vfc.getRequirements().values().stream().flatMap(List::stream).filter(Objects::nonNull)
+ .filter(def -> uniqueId.equals(def.getUniqueId())).findFirst().orElse(null);
+ }
+
private String retrieveCapabilityUid(String name, CapabilityOwner capabilityOwner) {
- return capabilityOwner.getCapabilities().values()
- .stream()
- .flatMap(List::stream)
- .filter(Objects::nonNull)
- .filter(def -> name.equals(def.getName()))
- .findFirst()
- .map(CapabilityDefinition::getUniqueId)
- .orElse(null);
+ return capabilityOwner.getCapabilities().values().stream().flatMap(List::stream).filter(Objects::nonNull)
+ .filter(def -> name.equals(def.getName())).findFirst().map(CapabilityDefinition::getUniqueId).orElse(null);
}
private String retrieveRequirementUid(String name, Component vfc) {
- return vfc.getRequirements().values().stream()
- .flatMap(List::stream)
- .filter(Objects::nonNull)
- .filter(def -> name.equals(def.getName()))
- .findFirst()
- .map(RequirementDefinition::getUniqueId)
- .orElse(null);
+ return vfc.getRequirements().values().stream().flatMap(List::stream).filter(Objects::nonNull).filter(def -> name.equals(def.getName()))
+ .findFirst().map(RequirementDefinition::getUniqueId).orElse(null);
}
}