gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.asdctool.impl.migration.v1707.jsonmodel;
   2
   3
   4 import fj.data.Either;
   5 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
   6 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
   7 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
   8 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
   9 import org.openecomp.sdc.be.model.ArtifactDefinition;
  10 import org.openecomp.sdc.be.model.Component;
  11 import org.openecomp.sdc.be.model.ComponentInstance;
  12 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  13 import org.openecomp.sdc.be.model.GroupDefinition;
  14 import org.openecomp.sdc.be.model.GroupInstance;
  15 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
  16 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
  17 import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
  18 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaElementLifecycleOperation;
  19 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  20 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  21 import org.openecomp.sdc.common.api.Constants;
  22 import org.slf4j.Logger;
  23 import org.slf4j.LoggerFactory;
  24
  25 import javax.annotation.Resource;
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Optional;
  31 import java.util.stream.Collectors;
  32
  33
  34 public class NodeTemplateMissingDataResolver <T extends Component> {
  35
  36         private static Logger LOGGER = LoggerFactory.getLogger(NodeTemplateMissingDataResolver.class);
  37
  38         @Resource(name = "tosca-element-lifecycle-operation")
  39     private ToscaElementLifecycleOperation lifecycleOperation;
  40
  41         @Resource(name = "topology-template-operation")
  42     private TopologyTemplateOperation topologyTemplateOperation;
  43
  44         public void resolveNodeTemplateInfo(ComponentInstanceDataDefinition vfInst, Map<String, ToscaElement> origCompMap, T component) {
  45                 lifecycleOperation.resolveToscaComponentName(vfInst, origCompMap);
  46                 if(OriginTypeEnum.VF == vfInst.getOriginType()) {
  47                         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = Optional.ofNullable(component.getComponentInstancesInputs()).orElse(new HashMap<>());
  48                         collectVFInstanceInputs(componentInstancesInputs, origCompMap, vfInst);
  49                 }
  50         }
  51
  52         private void collectVFInstanceInputs(Map<String, List<ComponentInstanceInput>> instInputs, Map<String, ToscaElement> origCompMap, ComponentInstanceDataDefinition vfInst) {
  53                 String ciUid = vfInst.getUniqueId();
  54                 String origCompUid = vfInst.getComponentUid();
  55                 Either<ToscaElement, StorageOperationStatus> origComp = fetchToscaElement(origCompMap, vfInst, origCompUid);
  56         if(origComp.isRight())
  57                 return;
  58                 Map<String, PropertyDataDefinition> origVFInputs = ((TopologyTemplate)origComp.left().value()).getInputs();
  59                 if (origVFInputs != null && !origVFInputs.isEmpty()) {
  60                         Map<String, ComponentInstanceInput> collectedVFInputs = origVFInputs.values().stream()
  61                                                                                                                .collect(Collectors.toMap(PropertyDataDefinition::getName, ComponentInstanceInput::new));
  62                         List<ComponentInstanceInput> instInputList = instInputs.get(ciUid);
  63                         Map<String, ComponentInstanceInput> existingInstInputs = ToscaDataDefinition.listToMapByName(instInputList);
  64                         collectedVFInputs.putAll(existingInstInputs);
  65                         List<ComponentInstanceInput> mergedList = new ArrayList<>(collectedVFInputs.values());
  66                         instInputs.put(ciUid, mergedList);
  67                 }
  68         }
  69
  70         private Either<ToscaElement, StorageOperationStatus> fetchToscaElement(Map<String, ToscaElement> origCompMap, ComponentInstanceDataDefinition vfInst, String origCompUid) {
  71                 Either<ToscaElement, StorageOperationStatus> origCompEither;
  72                 if (!origCompMap.containsKey(origCompUid)) {
  73                         origCompEither = topologyTemplateOperation.getToscaElement(origCompUid);
  74                         if (origCompEither.isRight()) {
  75                                   LOGGER.error("failed to fetch Tosca element {} with id {}", vfInst.getComponentName(), origCompUid);
  76                                   return origCompEither;
  77                         }
  78                         origCompMap.put(origCompUid, origCompEither.left().value());
  79                 }
  80                 return Either.left(origCompMap.get(origCompUid));
  81         }
  82
  83         protected boolean isProblematicGroup(GroupDefinition gr, String resourceName, Map<String, ArtifactDefinition> deploymentArtifacts) {
  84                 List<String> artifacts = gr.getArtifacts();
  85                 List<String> artifactsUuid = gr.getArtifactsUuid();
  86
  87                 if ((artifactsUuid == null || artifactsUuid.isEmpty()) && (artifacts == null || artifacts.isEmpty())) {
  88                         LOGGER.debug("No groups in resource {} ", resourceName);
  89                         return false;
  90                 }
  91                 if (artifacts.size() < artifactsUuid.size()) {
  92                         LOGGER.debug(" artifacts.size() < artifactsUuid.size() group {} in resource {} ", gr.getName(), resourceName);
  93                         return true;
  94                 }
  95                 if (artifacts.size() > 0 && (artifactsUuid == null || artifactsUuid.isEmpty())) {
  96                         LOGGER.debug(" artifacts.size() > 0 && (artifactsUuid == null || artifactsUuid.isEmpty() group {} in resource {} ", gr.getName(), resourceName);
  97                         return true;
  98                 }
  99                 if (artifactsUuid.contains(null)) {
 100                         LOGGER.debug(" artifactsUuid.contains(null) group {} in resource {} ", gr.getName(), resourceName);
 101                         return true;
 102                 }
 103
 104                 for (String artifactId : artifacts) {
 105                         String artifactlabel = findArtifactLabelFromArtifactId(artifactId);
 106                         ArtifactDefinition artifactDefinition = deploymentArtifacts.get(artifactlabel);
 107                         if (artifactDefinition == null) {
 108                                 LOGGER.debug(" artifactDefinition == null label {} group {} in resource {} ", artifactlabel, gr.getName(), resourceName);
 109                                 return true;
 110                         }
 111                         ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactDefinition.getArtifactType());
 112                         if (artifactType != ArtifactTypeEnum.HEAT_ENV) {
 113                                 if (!artifactId.equals(artifactDefinition.getUniqueId())) {
 114                                         LOGGER.debug(" !artifactId.equals(artifactDefinition.getUniqueId() artifact {}  artId {} group {} in resource {} ", artifactlabel, artifactId, gr.getName(), resourceName);
 115                                         return true;
 116                                 }
 117                                 if (!artifactsUuid.contains(artifactDefinition.getArtifactUUID())) {
 118                                         LOGGER.debug(" artifactsUuid.contains(artifactDefinition.getArtifactUUID() label {} group {} in resource {} ", artifactlabel, gr.getName(), resourceName);
 119                                         return true;
 120                                 }
 121                         }
 122                 }
 123                 return false;
 124         }
 125
 126         protected boolean isProblematicGroupInstance(GroupInstance gi, String instName, String servicename, Map<String, ArtifactDefinition> deploymentArtifacts) {
 127                 List<String> artifacts = gi.getArtifacts();
 128                 List<String> artifactsUuid = gi.getArtifactsUuid();
 129                 List<String> instArtifactsUuid = gi.getGroupInstanceArtifactsUuid();
 130
 131                 if ((artifactsUuid == null || artifactsUuid.isEmpty()) && (artifacts == null || artifacts.isEmpty())) {
 132                         LOGGER.debug("No instance groups for instance {} in service {} ", instName, servicename);
 133                         return false;
 134                 }
 135                 if (artifacts.size() < artifactsUuid.size()) {
 136                         LOGGER.debug(" artifacts.size() < artifactsUuid.size() inst {} in service {} ", instName, servicename);
 137                         return true;
 138                 }
 139                 if (artifacts.size() > 0 && (artifactsUuid == null || artifactsUuid.isEmpty())) {
 140                         LOGGER.debug(" artifacts.size() > 0 && (artifactsUuid == null || artifactsUuid.isEmpty() inst {} in service {} ", instName, servicename);
 141                         return true;
 142                 }
 143                 if (artifactsUuid.contains(null)) {
 144                         LOGGER.debug(" artifactsUuid.contains(null) inst {} in service {} ", instName, servicename);
 145                         return true;
 146                 }
 147
 148                 for (String artifactId : artifacts) {
 149                         String artifactlabel = findArtifactLabelFromArtifactId(artifactId);
 150                         ArtifactDefinition artifactDefinition = deploymentArtifacts.get(artifactlabel);
 151                         if (artifactDefinition == null) {
 152                                 LOGGER.debug(" artifactDefinition == null label {} inst {} in service {} ", artifactlabel, instName, servicename);
 153                                 return true;
 154                         }
 155                         ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifactDefinition.getArtifactType());
 156                         if (artifactType != ArtifactTypeEnum.HEAT_ENV) {
 157                                 if (!artifactId.equals(artifactDefinition.getUniqueId())) {
 158                                         LOGGER.debug(" !artifactId.equals(artifactDefinition.getUniqueId() artifact {}  artId {} inst {} in service {} ", artifactlabel, artifactId, instName, servicename);
 159                                         return true;
 160                                 }
 161                                 if (!artifactsUuid.contains(artifactDefinition.getArtifactUUID())) {
 162                                         LOGGER.debug(" artifactsUuid.contains(artifactDefinition.getArtifactUUID() label {} inst {} in service {} ", artifactlabel, instName, servicename);
 163                                         return true;
 164                                 }
 165                         } else {
 166                                 if (!instArtifactsUuid.contains(artifactDefinition.getArtifactUUID())) {
 167                                         LOGGER.debug(" instArtifactsUuid.contains(artifactDefinition.getArtifactUUID() label {} inst {} in service {} ", artifactlabel, instName, servicename);
 168                                         return true;
 169                                 }
 170                         }
 171                 }
 172                 return false;
 173         }
 174
 175         private String findArtifactLabelFromArtifactId(String artifactId) {
 176                 String artifactLabel = "";
 177
 178                 int index = artifactId.lastIndexOf(".");
 179                 if (index > 0 && index + 1 < artifactId.length())
 180                         artifactLabel = artifactId.substring(index + 1);
 181                 return artifactLabel;
 182         }
 183
 184         protected boolean fixVFGroups(Component component){
 185                 boolean res = true;
 186
 187                 Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
 188                 List<GroupDefinition> groups = component.getGroups();
 189                 if (groups == null || groups.isEmpty()) {
 190                         LOGGER.debug("No  groups  in component {} id {} ",  component.getName(), component.getUniqueId());
 191                         return res;
 192                 }
 193
 194                 for (GroupDefinition group : groups) {
 195                         if (group.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE) && deploymentArtifacts != null) {
 196                                 if (isProblematicGroup(group, component.getName(), deploymentArtifacts)) {
 197                                         List<String> groupArtifacts = new ArrayList<String>(group.getArtifacts());
 198                                         group.getArtifacts().clear();
 199                                         group.getArtifactsUuid().clear();
 200                                         for (String artifactId : groupArtifacts) {
 201                                                 String artifactlabel = findArtifactLabelFromArtifactId(artifactId);
 202                                                 LOGGER.debug("fix group:  group name {} artifactId for fix {} artifactlabel {} ", group.getName(), artifactId, artifactlabel);
 203                                                 if (!artifactlabel.isEmpty() && deploymentArtifacts.containsKey(artifactlabel)) {
 204                                                         ArtifactDefinition artifact = deploymentArtifacts.get(artifactlabel);
 205                                                         String correctArtifactId = artifact.getUniqueId();
 206                                                         String correctArtifactUUID = artifact.getArtifactUUID();
 207                                                         LOGGER.debug(" fix group:  group name {} correct artifactId {} artifactUUID {} ", group.getName(), correctArtifactId, correctArtifactUUID);
 208                                                         group.getArtifacts().add(correctArtifactId);
 209                                                         if (correctArtifactUUID != null && !correctArtifactUUID.isEmpty()) {
 210                                                                 group.getArtifactsUuid().add(correctArtifactUUID);
 211                                                         }
 212
 213                                                 }
 214                                         }
 215                                 }
 216                         }
 217
 218                 }
 219
 220                 return res;
 221         }
 222
 223         protected boolean fixVFGroupInstances(Component component, ComponentInstance instance){
 224                 boolean res = true;
 225
 226                 Map<String, ArtifactDefinition> deploymentArtifacts = instance.getDeploymentArtifacts();
 227                 List<GroupInstance> groupInstances = instance.getGroupInstances();
 228                 if (groupInstances == null || groupInstances.isEmpty()) {
 229                         LOGGER.debug("No instance groups for instance {} in service {} id {} ", instance.getName(), component.getName(), component.getUniqueId());
 230                         return res;
 231                 }
 232                 for (GroupInstance group : groupInstances) {
 233                         if (group.getType().equals(Constants.DEFAULT_GROUP_VF_MODULE)) {
 234                                 if (isProblematicGroupInstance(group, instance.getName(), component.getName(), deploymentArtifacts)) {
 235
 236                                         LOGGER.debug("Migration1707ArtifactUuidFix  fix group:  resource id {}, group name {} ", component.getUniqueId(), group.getName());
 237                                         List<String> groupArtifacts = Optional.ofNullable(group.getArtifacts()).orElse(new ArrayList<>());
 238
 239                                         group.setArtifacts(new ArrayList<>());
 240                                         group.setArtifactsUuid(new ArrayList<>());
 241                                         group.setGroupInstanceArtifacts(new ArrayList<>());
 242                                         group.setGroupInstanceArtifactsUuid(new ArrayList<>());
 243
 244                                         for (String artifactId : groupArtifacts) {
 245                                                 String artifactlabel = findArtifactLabelFromArtifactId(artifactId);
 246                                                 LOGGER.debug("Migration1707ArtifactUuidFix  fix group:  group name {} artifactId for fix {} artifactlabel {} ", group.getName(), artifactId, artifactlabel);
 247                                                 if (!artifactlabel.isEmpty() && deploymentArtifacts.containsKey(artifactlabel)) {
 248                                                         ArtifactDefinition artifact = deploymentArtifacts.get(artifactlabel);
 249                                                         ArtifactTypeEnum artifactType = ArtifactTypeEnum.findType(artifact.getArtifactType());
 250                                                         String correctArtifactId = artifact.getUniqueId();
 251                                                         String correctArtifactUUID = artifact.getArtifactUUID();
 252                                                         if (artifactType != ArtifactTypeEnum.HEAT_ENV) {
 253
 254                                                                 LOGGER.debug("Migration1707ArtifactUuidFix  fix group:  group name {} correct artifactId {} artifactUUID {} ", group.getName(), correctArtifactId, correctArtifactUUID);
 255                                                                 group.getArtifacts().add(correctArtifactId);
 256                                                                 if (correctArtifactUUID != null && !correctArtifactUUID.isEmpty()) {
 257                                                                         group.getArtifactsUuid().add(correctArtifactUUID);
 258                                                                 }
 259                                                         } else {
 260                                                                 LOGGER.debug("Migration1707ArtifactUuidFix  fix group:  group name {} correct artifactId {} artifactUUID {} ", group.getName(), correctArtifactId, correctArtifactUUID);
 261                                                                 group.getGroupInstanceArtifacts().add(correctArtifactId);
 262                                                                 if (correctArtifactUUID != null && !correctArtifactUUID.isEmpty()) {
 263                                                                         group.getGroupInstanceArtifactsUuid().add(correctArtifactUUID);
 264                                                                 }
 265                                                         }
 266                                                 }
 267                                         }
 268
 269                                 }
 270                         }
 271                 }
 272
 273                 return res;
 274         }
 275
 276 }