openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/java/org/openecomp/sdc/healing/impl/HealingManagerImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.healing.impl;
  22
  23
  24 import org.openecomp.core.utilities.CommonMethods;
  25 import org.openecomp.core.utilities.file.FileUtils;
  26 import org.openecomp.core.utilities.json.JsonUtil;
  27 import org.openecomp.sdc.common.errors.CoreException;
  28 import org.openecomp.sdc.common.errors.ErrorCategory;
  29 import org.openecomp.sdc.common.errors.ErrorCode;
  30 import org.openecomp.sdc.common.errors.Messages;
  31 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  32 import org.openecomp.sdc.datatypes.model.ItemType;
  33 import org.openecomp.sdc.healing.api.HealingManager;
  34 import org.openecomp.sdc.healing.dao.HealingDao;
  35 import org.openecomp.sdc.healing.interfaces.Healer;
  36 import org.openecomp.sdc.healing.types.HealerType;
  37 import org.openecomp.sdc.versioning.VersioningManager;
  38 import org.openecomp.sdc.versioning.dao.types.Version;
  39 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  40 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  41
  42 import java.util.*;
  43 import java.util.stream.Collectors;
  44 import java.util.stream.Stream;
  45
  46 public class HealingManagerImpl implements HealingManager {
  47
  48   private static final String HEALERS_BY_ENTITY_TYPE_FILE = "entityHealingConfiguration.json";
  49   private static final String HEALING_USER_SUFFIX = "_healer";
  50   private static final String PUBLIC_USER = "public";
  51
  52   private HealingDao healingDao;
  53   private VersioningManager versioningManager;
  54
  55   public HealingManagerImpl(VersioningManager versioningManager, HealingDao healingDao) {
  56     this.versioningManager = versioningManager;
  57     this.healingDao = healingDao;
  58   }
  59
  60   @Override
  61   public Optional<Version> healItemVersion(final String itemId, final Version version,
  62                                            final ItemType itemType, final boolean force) {
  63     String user = getUser();
  64     populateVersionInfo(itemId, version);
  65
  66     if (!isHealingNeeded(itemId, version, force, user)) {
  67       return Optional.empty();
  68     }
  69
  70     Map<String, Collection<String>> healersByType = getItemHealers(itemType);
  71     List<String> failureMessages = new LinkedList<>();
  72     List<Healer> structureHealersToRun =
  73         getHealersToRun(healersByType.get(HealerType.structure.name()), itemId, version,
  74             failureMessages);
  75     List<Healer> dataHealersToRun =
  76         getHealersToRun(healersByType.get(HealerType.data.name()), itemId, version,
  77             failureMessages);
  78
  79     if (structureHealersToRun.isEmpty() && dataHealersToRun.isEmpty()) {
  80       markAsHealed(itemId, version.getId(), user);
  81       markAsHealed(itemId, version.getId(), PUBLIC_USER);
  82       return Optional.empty();
  83     }
  84
  85     Optional<Version> healVersion = getHealVersion(itemId, version);
  86     if (!healVersion.isPresent()) {
  87       // do NOT turn off flag here (in thought of saving version calculate performance next
  88       // time) because maybe next time the next version will be available (due to deletion of
  89       // the taken one)
  90       return Optional.empty();
  91     }
  92
  93     failureMessages.addAll(
  94         doHeal(itemId, healVersion.get(), version, structureHealersToRun, dataHealersToRun, user,
  95             force));
  96     handleFailures(failureMessages);
  97
  98     return healVersion;
  99   }
 100
 101   private void populateVersionInfo(String itemId, Version version) {
 102     if (version.getStatus() != null) {
 103       return;
 104     }
 105
 106     Version retrievedVersion = versioningManager.get(itemId, version);
 107     version.setStatus(retrievedVersion.getStatus());
 108     version.setBaseId(retrievedVersion.getBaseId());
 109   }
 110
 111   private boolean isHealingNeeded(String itemId, Version version, boolean force, String user) {
 112     return force || isHealingFlagOn(itemId, version.getId(), user)
 113         .orElse(isHealingFlagOn(itemId, version.getId(), PUBLIC_USER)
 114             .orElse(version.getStatus() == VersionStatus.Draft && version.getBaseId() != null &&
 115                 isHealingFlagOn(itemId, version.getBaseId(), user)
 116                     .orElse(isHealingFlagOn(itemId, version.getBaseId(), PUBLIC_USER)
 117                         .orElse(false))));
 118   }
 119
 120   private Optional<Version> getHealVersion(String itemId, Version version) {
 121     return version.getStatus() == VersionStatus.Certified
 122         ? createNewVersion(itemId, version.getId())
 123         : Optional.of(version);
 124   }
 125
 126   private Optional<Version> createNewVersion(String itemId, String versionId) {
 127     Version newVersion = new Version();
 128     newVersion.setBaseId(versionId);
 129     newVersion.setDescription("Version is created by healing process");
 130     try {
 131       return Optional.of(versioningManager.create(itemId, newVersion, VersionCreationMethod.major));
 132     } catch (Exception e) {
 133       return Optional.empty();
 134     }
 135   }
 136
 137   private List<String> doHeal(String itemId, Version version, Version origVersion,
 138                               List<Healer> structureHealersToRun,
 139                               List<Healer> dataHealersToRun, String user,
 140                               boolean force) {
 141     boolean publicFlagOn = isHealingFlagOn(itemId, origVersion.getId(), PUBLIC_USER)
 142         .orElse(origVersion.getBaseId() != null &&
 143             isHealingFlagOn(itemId, origVersion.getBaseId(), PUBLIC_USER).orElse(false));
 144
 145     List<String> failureMessages =
 146         force || origVersion.getStatus() == VersionStatus.Certified || publicFlagOn
 147             ? healPublic(itemId, version, origVersion, structureHealersToRun, dataHealersToRun,
 148             user)
 149             : new LinkedList<>();
 150
 151     failureMessages.addAll(
 152         healPrivate(itemId, version, origVersion, structureHealersToRun, dataHealersToRun, user));
 153
 154     return failureMessages;
 155   }
 156
 157   private List<String> healPrivate(String itemId, Version version, Version origVersion,
 158                                    List<Healer> structureHealersToRun,
 159                                    List<Healer> dataHealersToRun, String user) {
 160     List<String> failureMessages;
 161     if (origVersion.getStatus() == VersionStatus.Certified) {
 162       failureMessages = executeHealers(itemId, version,
 163           Stream.concat(structureHealersToRun.stream(), dataHealersToRun.stream())
 164               .collect(Collectors.toList()));
 165     } else {
 166       if (structureHealersToRun.isEmpty()) {
 167         failureMessages = executeHealers(itemId, version, dataHealersToRun);
 168       } else {
 169         versioningManager.forceSync(itemId, version);
 170         failureMessages = new LinkedList<>();
 171       }
 172     }
 173     markAsHealed(itemId, origVersion.getId(), user);
 174     return failureMessages;
 175   }
 176
 177   private List<String> healPublic(String itemId, Version version, Version origVersion,
 178                                   List<Healer> structureHealersToRun,
 179                                   List<Healer> dataHealersToRun, String user) {
 180     List<String> failureMessages = origVersion.getStatus() == VersionStatus.Certified
 181         ? new LinkedList<>()
 182         : healPublic(itemId, version,
 183             Stream.concat(structureHealersToRun.stream(), dataHealersToRun.stream())
 184                 .collect(Collectors.toList()), user);
 185
 186     markAsHealed(itemId, origVersion.getId(), PUBLIC_USER);
 187     return failureMessages;
 188   }
 189
 190   private List<String> healPublic(String itemId, Version version, List<Healer> healers,
 191                                   String user) {
 192     String tenant = SessionContextProviderFactory.getInstance().createInterface().get().getTenant();
 193     SessionContextProviderFactory.getInstance().createInterface()
 194         .create(user + HEALING_USER_SUFFIX, tenant);
 195
 196     versioningManager.forceSync(itemId, version);
 197
 198     List<String> failureMessages = executeHealers(itemId, version, healers);
 199     Version publicVersion = versioningManager.get(itemId, version);
 200
 201     if (Objects.nonNull(publicVersion.getState()) && publicVersion.getState().isDirty()) {
 202       versioningManager.publish(itemId, version, "Healing vsp");
 203     }
 204
 205     SessionContextProviderFactory.getInstance().createInterface().create(user, tenant);
 206     return failureMessages;
 207   }
 208
 209   private List<String> executeHealers(String itemId, Version version, List<Healer> healers) {
 210     List<String> failureMessages = new LinkedList<>();
 211     for (Healer healer : healers) {
 212       try {
 213         healer.heal(itemId, version);
 214       } catch (Exception e) {
 215         failureMessages.add(
 216             String.format("Failure in healer %s: %s", healer.getClass().getName(), e.getMessage()));
 217       }
 218     }
 219
 220     return failureMessages;
 221   }
 222
 223   private Optional<Boolean> isHealingFlagOn(String itemId, String version, String user) {
 224     return healingDao.getItemHealingFlag(user, itemId, version);
 225   }
 226
 227   private void markAsHealed(String itemId, String versionId, String user) {
 228     healingDao.setItemHealingFlag(false, user, itemId, versionId);
 229   }
 230
 231   private void handleFailures(List<String> failureMessages) {
 232     if (!failureMessages.isEmpty()) {
 233       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 234           .withCategory(ErrorCategory.APPLICATION)
 235           .withMessage(CommonMethods.listToSeparatedString(failureMessages, '\n')).build());
 236     }
 237   }
 238
 239   private List<Healer> getHealersToRun(Collection<String> healersClassNames, String itemId,
 240                                        Version version, List<String> failureMessages) {
 241     return healersClassNames == null
 242         ? Collections.emptyList()
 243         : healersClassNames.stream()
 244             .map(healerClassName -> getHealerInstance(healerClassName, failureMessages))
 245             .filter(Optional::isPresent)
 246             .map(Optional::get)
 247             .filter(healer -> healer.isHealingNeeded(itemId, version))
 248             .collect(Collectors.toList());
 249   }
 250
 251   private Optional<Healer> getHealerInstance(String healerClassName, List<String> failureMessages) {
 252     try {
 253       return Optional.of((Healer) Class.forName(healerClassName).getConstructor().newInstance());
 254     } catch (Exception e) {
 255       failureMessages
 256           .add(String.format(Messages.CANT_LOAD_HEALING_CLASS.getErrorMessage(), healerClassName));
 257       return Optional.empty();
 258     }
 259   }
 260
 261   private Map<String, Collection<String>> getItemHealers(ItemType itemType) {
 262     Map healingConfig = FileUtils
 263         .readViaInputStream(HEALERS_BY_ENTITY_TYPE_FILE,
 264             stream -> JsonUtil.json2Object(stream, Map.class));
 265     return (Map<String, Collection<String>>) healingConfig
 266         .getOrDefault(itemType.name(), Collections.emptyMap());
 267   }
 268
 269   private String getUser() {
 270     return SessionContextProviderFactory.getInstance().createInterface().get().getUser()
 271         .getUserId();
 272   }
 273 }