gerrit.onap Code Review - sdc.git/blob

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