diff options
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.java | 366 |
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); } } |