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 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 import org.openecomp.core.utilities.CommonMethods;
  24 import org.openecomp.core.utilities.file.FileUtils;
  25 import org.openecomp.core.utilities.json.JsonUtil;
  26 import org.openecomp.sdc.common.errors.Messages;
  27 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  28 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  29 import org.openecomp.sdc.datatypes.model.ItemType;
  30 import org.openecomp.sdc.healing.api.HealingManager;
  31 import org.openecomp.sdc.healing.dao.HealingDao;
  32 import org.openecomp.sdc.healing.interfaces.Healer;
  33 import org.openecomp.sdc.healing.types.HealCode;
  34 import org.openecomp.sdc.healing.types.HealerType;
  35 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  36 import org.openecomp.sdc.logging.types.LoggerConstants;
  37 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  38 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  39 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  40 import org.openecomp.sdc.versioning.VersioningManager;
  41 import org.openecomp.sdc.versioning.dao.types.Version;
  42 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  43 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  44
  45 import java.lang.reflect.InvocationTargetException;
  46 import java.util.ArrayList;
  47 import java.util.Collection;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.Objects;
  51 import java.util.Optional;
  52 import java.util.stream.Collectors;
  53
  54 /**
  55  * Created by Talio on 11/29/2016.
  56  */
  57 public class HealingManagerImpl implements HealingManager {
  58
  59   private static final String HEALERS_BY_ENTITY_TYPE_FILE = "entityHealingConfiguration.json";
  60   private static final String HEALING_USER_SUFFIX = "_healer";
  61   private static final String PUBLIC_USER = "public";
  62
  63   private HealingDao healingDao;
  64   private VersioningManager versioningManager;
  65
  66   public HealingManagerImpl(VersioningManager versioningManager, HealingDao healingDao) {
  67     this.versioningManager = versioningManager;
  68     this.healingDao = healingDao;
  69   }
  70
  71   @Override
  72   public Optional<Version> healItemVersion(String itemId, Version version, ItemType itemType,
  73                                            boolean force) {
  74     String user = getUser();
  75     if (force || isPrivateHealingNeededByFlag(itemId, version.getId(), user)) {
  76       version = versioningManager.get(itemId, version);
  77       Version origVersion = version;
  78       if (version.getStatus() == VersionStatus.Certified) {
  79         Optional<Version> newVersion = createNewVersion(itemId, version);
  80         if (!newVersion.isPresent()) {
  81           // do NOT turn off flag here (in thought of saving version calculate performance next
  82           // time) because maybe next time the next version will be available (due to deletion of
  83           // the taken one)
  84           return Optional.empty();
  85         }
  86         version = newVersion.get();
  87       }
  88
  89       doHeal(itemId, version, origVersion, itemType, user, force);
  90       return Optional.of(version);
  91     }
  92     return Optional.empty();
  93   }
  94
  95   private void doHeal(String itemId, Version version, Version origVersion,
  96                       ItemType itemType, String user, boolean force) {
  97     Optional<String> privateFailureMessages =
  98         healPrivate(itemId, version, origVersion, getItemHealers(itemType), user);
  99
 100     Optional<String> publicFailureMessages =
 101         force || origVersion.getStatus() == VersionStatus.Certified ||
 102             isPublicHealingNeededByFlag(itemId, origVersion.getId())
 103             ? healPublic(itemId, version, origVersion, getItemHealers(itemType), user)
 104             : Optional.empty();
 105
 106     if (privateFailureMessages.isPresent() || publicFailureMessages.isPresent()) {
 107       throw new RuntimeException(
 108           publicFailureMessages.orElse("") + " " + privateFailureMessages.orElse(""));
 109     }
 110   }
 111
 112   private Optional<String> healPrivate(String itemId, Version version, Version origVersion,
 113                                        Map<String, Map<String, String>> itemHealers, String user) {
 114     if (origVersion.getStatus() != VersionStatus.Certified) {
 115       itemHealers.remove(HealerType.structure.name());
 116     }
 117
 118     Optional<String> privateHealingFailureMessages = executeHealers(itemId, version, itemHealers);
 119     markAsHealed(itemId, origVersion.getId(), user);
 120     return privateHealingFailureMessages;
 121   }
 122
 123   private Optional<String> healPublic(String itemId, Version version, Version origVersion,
 124                                       Map<String, Map<String, String>> itemHealers, String user) {
 125     Optional<String> healingFailureMessages = origVersion.getStatus() == VersionStatus.Certified
 126         ? Optional.empty()
 127         : healPublic(itemId, version, itemHealers, user);
 128
 129     markAsHealed(itemId, origVersion.getId(), PUBLIC_USER);
 130     return healingFailureMessages;
 131   }
 132
 133   private Optional<String> healPublic(String itemId, Version version,
 134                                       Map<String, Map<String, String>> itemHealers, String user) {
 135     SessionContextProviderFactory.getInstance().createInterface()
 136         .create(user + HEALING_USER_SUFFIX);
 137
 138     versioningManager.sync(itemId, version);
 139
 140     Optional<String> healingFailureMessages = executeHealers(itemId, version, itemHealers);
 141     Version publicVersion = versioningManager.get(itemId, version);
 142
 143     if (Objects.nonNull(publicVersion.getState()) && publicVersion.getState().isDirty()) {
 144       versioningManager.publish(itemId, version, "Healing vsp");
 145     }
 146
 147     SessionContextProviderFactory.getInstance().createInterface().create(user);
 148     return healingFailureMessages;
 149   }
 150
 151   private Optional<Version> createNewVersion(String itemId, Version version) {
 152     Version newVersion = new Version();
 153     newVersion.setBaseId(version.getId());
 154     try {
 155       return Optional.of(versioningManager.create(itemId, newVersion, VersionCreationMethod.major));
 156     } catch (Exception e) {
 157       return Optional.empty();
 158     }
 159   }
 160
 161   @Override
 162   public Object heal(String itemId, Version version, HealerType healerType, HealCode code,
 163                      ItemType itemType) {
 164     String healerClassName = getItemHealers(itemType).get(healerType.name()).get(code.name());
 165     ArrayList<String> healingFailureMessages = new ArrayList<>();
 166
 167     Object result = executeHealer(itemId, version, healerClassName, healingFailureMessages);
 168
 169     if (!healingFailureMessages.isEmpty()) {
 170       throw new RuntimeException(CommonMethods.listToSeparatedString(healingFailureMessages, '\n'));
 171     }
 172     return result;
 173   }
 174
 175   private Optional<String> executeHealers(String itemId, Version version,
 176                                           Map<String, Map<String, String>> itemHealers) {
 177     List<String> healers = itemHealers.values().stream()
 178         .map(Map::values)
 179         .flatMap(Collection::stream)
 180         .collect(Collectors.toList());
 181
 182     List<String> healingFailureMessages = new ArrayList<>();
 183     for (String implClassName : healers) {
 184       executeHealer(itemId, version, implClassName, healingFailureMessages);
 185     }
 186
 187     return healingFailureMessages.isEmpty()
 188         ? Optional.empty()
 189         : Optional.of(CommonMethods.listToSeparatedString(healingFailureMessages, '\n'));
 190   }
 191
 192
 193   private Object executeHealer(String itemId, Version version, String healerClassName,
 194                                List<String> healingFailureMessages) {
 195     Healer healer;
 196     try {
 197       healer = getHealerImplInstance(healerClassName);
 198     } catch (Exception e) {
 199       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 200           LoggerTragetServiceName.SELF_HEALING, ErrorLevel.ERROR.name(), LoggerErrorCode
 201               .DATA_ERROR.getErrorCode(), LoggerErrorDescription.CANT_HEAL);
 202       healingFailureMessages
 203           .add(String.format(Messages.CANT_LOAD_HEALING_CLASS.getErrorMessage(),
 204               healerClassName));
 205       return null;
 206     }
 207
 208     try {
 209       return healer.heal(itemId, version);
 210     } catch (Exception e) {
 211       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
 212           LoggerTragetServiceName.SELF_HEALING, ErrorLevel.ERROR.name(), LoggerErrorCode
 213               .DATA_ERROR.getErrorCode(), LoggerErrorDescription.CANT_HEAL);
 214       healingFailureMessages.add(e.getMessage() + " ,healer name :" + healerClassName);
 215     }
 216     return null;
 217   }
 218
 219   private boolean isPrivateHealingNeededByFlag(String itemId, String version, String user) {
 220     Optional<Boolean> userHealingFlag = getHealingFlag(itemId, version, user);
 221     return userHealingFlag.isPresent()
 222         ? userHealingFlag.get()
 223         : isPublicHealingNeededByFlag(itemId, version);
 224   }
 225
 226   private boolean isPublicHealingNeededByFlag(String itemId, String versionId) {
 227     Optional<Boolean> publicHealingFlag = getHealingFlag(itemId, versionId, PUBLIC_USER);
 228     return publicHealingFlag.isPresent() && publicHealingFlag.get();
 229   }
 230
 231   private Optional<Boolean> getHealingFlag(String itemId, String version, String user) {
 232     return healingDao.getItemHealingFlag(user, itemId, version);
 233   }
 234
 235   private void markAsHealed(String itemId, String versionId, String user) {
 236     healingDao.setItemHealingFlag(false, user, itemId, versionId);
 237   }
 238
 239   private Map<String, Map<String, String>> getItemHealers(ItemType itemType) {
 240     // TODO: 11/29/2017 create objects to hold this configuration +
 241     // load once from the json file and use the relevant healers (by itemType, healerType) as needed.
 242     Map healingConfig = FileUtils
 243         .readViaInputStream(HEALERS_BY_ENTITY_TYPE_FILE,
 244             stream -> JsonUtil.json2Object(stream, Map.class));
 245     return (Map<String, Map<String, String>>) healingConfig.get(itemType.name());
 246   }
 247
 248   private Healer getHealerImplInstance(String implClassName)
 249       throws InstantiationException, IllegalAccessException, InvocationTargetException,
 250       NoSuchMethodException, ClassNotFoundException {
 251     return (Healer) Class.forName(implClassName).getConstructor().newInstance();
 252   }
 253
 254   private String getUser() {
 255     return SessionContextProviderFactory.getInstance().createInterface().get().getUser()
 256         .getUserId();
 257   }
 258 }