catalog-be/src/main/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceForwardingPathMerge.java

   1 package org.openecomp.sdc.be.components.merge.instance;
   2
   3 import fj.data.Either;
   4 import org.javatuples.Pair;
   5 import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
   6 import org.openecomp.sdc.be.dao.api.ActionStatus;
   7 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
   8 import org.openecomp.sdc.be.impl.ComponentsUtils;
   9 import org.openecomp.sdc.be.impl.ForwardingPathUtils;
  10 import org.openecomp.sdc.be.model.CapabilityDefinition;
  11 import org.openecomp.sdc.be.model.Component;
  12 import org.openecomp.sdc.be.model.ComponentInstance;
  13 import org.openecomp.sdc.be.model.Service;
  14 import org.openecomp.sdc.be.model.User;
  15 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  16 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  17 import org.openecomp.sdc.exception.ResponseFormat;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20 import org.springframework.beans.factory.annotation.Autowired;
  21
  22 import java.util.Collection;
  23 import java.util.HashSet;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Set;
  27 import java.util.stream.Collectors;
  28
  29 @org.springframework.stereotype.Component
  30 public class ComponentInstanceForwardingPathMerge implements ComponentInstanceMergeInterface {
  31
  32     private static Logger log = LoggerFactory.getLogger(ComponentInstanceForwardingPathMerge.class);
  33
  34     @Autowired
  35     private ServiceBusinessLogic serviceBusinessLogic;
  36
  37     @Autowired
  38     private ToscaOperationFacade toscaOperationFacade;
  39
  40     @Autowired
  41     private ComponentsUtils componentsUtils;
  42
  43     @Override
  44     public void saveDataBeforeMerge(DataForMergeHolder dataHolder, Component containerComponent,
  45         ComponentInstance currentResourceInstance, Component originComponent) {
  46         dataHolder.setOrigInstanceCapabilities(getAllInstanceCapabilities(currentResourceInstance));
  47         dataHolder.setOrigInstanceNode(originComponent);
  48         dataHolder.setOrigComponentInstId(currentResourceInstance.getUniqueId());
  49     }
  50
  51     @Override
  52     public Either<Component, ResponseFormat> mergeDataAfterCreate(User user, DataForMergeHolder dataHolder,
  53         Component updatedContainerComponent, String newInstanceId) {
  54         if (!(updatedContainerComponent instanceof Service)) {
  55             // no need to handle forwarding paths
  56             return Either.left(updatedContainerComponent);
  57         }
  58         Service service = (Service) updatedContainerComponent;
  59         ComponentInstance ci = service.getComponentInstanceById(newInstanceId).orElse(null);
  60         if (ci == null){
  61             ResponseFormat responseFormat = componentsUtils
  62                 .getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND_ON_CONTAINER, newInstanceId);
  63             return Either.right(responseFormat);
  64         }
  65         Either<Component, StorageOperationStatus> resourceEither = toscaOperationFacade.getToscaFullElement(ci.getComponentUid());
  66         if (resourceEither.isRight() ) {
  67             log.debug("Failed to fetch resource with id {} for instance {}",ci.getComponentUid() ,ci.getUniqueId());
  68             ResponseFormat responseFormat = componentsUtils
  69                 .getResponseFormat(componentsUtils.convertFromStorageResponse(resourceEither.right().value()));
  70             return Either.right(responseFormat);
  71         }
  72
  73         Component fetchedComponent = resourceEither.left().value();
  74
  75         Pair<Map<String, ForwardingPathDataDefinition>, Map<String, ForwardingPathDataDefinition>> pair = new ForwardingPathUtils()
  76             .updateForwardingPathOnVersionChange(service, dataHolder, fetchedComponent, newInstanceId);
  77         Map<String, ForwardingPathDataDefinition> updated = pair.getValue0();
  78         Map<String, ForwardingPathDataDefinition> deleted = pair.getValue1();
  79         if (deleted != null && !deleted.isEmpty()) {
  80             Either<Set<String>, ResponseFormat> deleteEither = serviceBusinessLogic
  81                 .deleteForwardingPaths(service.getUniqueId(), new HashSet<>(deleted.keySet()), user, false);
  82             if (deleteEither.isRight()) {
  83                 if (log.isDebugEnabled()) {
  84                     log.debug("Failed to delete forwarding paths : {}", deleted.values().stream()
  85                         .map(ForwardingPathDataDefinition::getName).collect(Collectors.joining(", ", "( ", " )")));
  86                 }
  87                 return Either.right(deleteEither.right().value());
  88             }
  89             deleted.keySet().forEach(key -> service.getForwardingPaths().remove(key));
  90         }
  91         if (updated != null && !updated.isEmpty()) {
  92             Service updateFPService = new Service();
  93             updateFPService.setForwardingPaths(updated);
  94             Either<Service, ResponseFormat> updateFPEither = serviceBusinessLogic
  95                 .updateForwardingPath(service.getUniqueId(), updateFPService, user, false);
  96             if (updateFPEither.isRight()) {
  97                 if (log.isDebugEnabled()) {
  98                     log.debug("Failed to update forwarding paths : {}", updated.values().stream()
  99                         .map(ForwardingPathDataDefinition::getName).collect(Collectors.joining(", ", "( ", " )")));
 100                 }
 101                 return Either.right(updateFPEither.right().value());
 102             }
 103             updated.forEach((key, forwardingPathDataDefinition) -> service.getForwardingPaths().put(key,forwardingPathDataDefinition));
 104         }
 105         return Either.left(updatedContainerComponent);
 106     }
 107
 108
 109     private List<CapabilityDefinition> getAllInstanceCapabilities(ComponentInstance currentResourceInstance) {
 110         return currentResourceInstance.getCapabilities().values().stream().flatMap(Collection::stream)
 111             .collect(Collectors.toList());
 112     }
 113 }