gerrit.onap Code Review - sdc.git/blob

   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.Collection;
  43 import java.util.Collections;
  44 import java.util.LinkedList;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Objects;
  48 import java.util.Optional;
  49 import java.util.stream.Collectors;
  50 import java.util.stream.Stream;
  51
  52 public class HealingManagerImpl implements HealingManager {
  53
  54   private static final String HEALERS_BY_ENTITY_TYPE_FILE = "entityHealingConfiguration.json";
  55   private static final String HEALING_USER_SUFFIX = "_healer";
  56   private static final String PUBLIC_USER = "public";
  57
  58   private HealingDao healingDao;
  59   private VersioningManager versioningManager;
  60
  61   public HealingManagerImpl(VersioningManager versioningManager, HealingDao healingDao) {
  62     this.versioningManager = versioningManager;
  63     this.healingDao = healingDao;
  64   }
  65
  66   @Override
  67   public Optional<Version> healItemVersion(final String itemId, final Version version,
  68                                            final ItemType itemType, final boolean force) {
  69     String user = getUser();
  70     if (!force && !isPrivateHealingNeededByFlags(itemId, version.getId(), user)) {
  71       return Optional.empty();
  72     }
  73
  74     Map<String, Collection<String>> healersByType = getItemHealers(itemType);
  75     List<String> failureMessages = new LinkedList<>();
  76     List<Healer> structureHealersToRun =
  77         getHealersToRun(healersByType.get(HealerType.structure.name()), itemId, version,
  78             failureMessages);
  79     List<Healer> dataHealersToRun =
  80         getHealersToRun(healersByType.get(HealerType.data.name()), itemId, version,
  81             failureMessages);
  82
  83     if (structureHealersToRun.isEmpty() && dataHealersToRun.isEmpty()) {
  84       markAsHealed(itemId, version.getId(), user);
  85       markAsHealed(itemId, version.getId(), PUBLIC_USER);
  86       return Optional.empty();
  87     }
  88
  89     Optional<Version> healVersion = getHealVersion(itemId, version);
  90     if (!healVersion.isPresent()) {
  91       // do NOT turn off flag here (in thought of saving version calculate performance next
  92       // time) because maybe next time the next version will be available (due to deletion of
  93       // the taken one)
  94       return Optional.empty();
  95     }
  96
  97     failureMessages.addAll(
  98         doHeal(itemId, healVersion.get(), version, structureHealersToRun, dataHealersToRun, user,
  99             force));
 100     handleFailures(failureMessages);
 101
 102     return healVersion;
 103   }
 104
 105   private Optional<Version> getHealVersion(String itemId, Version version) {
 106     version.setStatus(versioningManager.get(itemId, version).getStatus());
 107     return version.getStatus() == VersionStatus.Certified
 108         ? createNewVersion(itemId, version.getId())
 109         : Optional.of(version);
 110   }
 111
 112   private Optional<Version> createNewVersion(String itemId, String versionId) {
 113     Version newVersion = new Version();
 114     newVersion.setBaseId(versionId);
 115     newVersion.setDescription("Version is created by healing process");
 116     try {
 117       return Optional.of(versioningManager.create(itemId, newVersion, VersionCreationMethod.major));
 118     } catch (Exception e) {
 119       return Optional.empty();
 120     }
 121   }
 122
 123   private List<String> doHeal(String itemId, Version version, Version origVersion,
 124                               List<Healer> structureHealersToRun,
 125                               List<Healer> dataHealersToRun, String user,
 126                               boolean force) {
 127     List<String> failureMessages =
 128         force || origVersion.getStatus() == VersionStatus.Certified ||
 129             isPublicHealingNeededByFlag(itemId, origVersion.getId())
 130             ? healPublic(itemId, version, origVersion, structureHealersToRun, dataHealersToRun,
 131             user)
 132             : new LinkedList<>();
 133
 134     failureMessages.addAll(
 135         healPrivate(itemId, version, origVersion, structureHealersToRun, dataHealersToRun, user));
 136
 137     return failureMessages;
 138   }
 139
 140   private List<String> healPrivate(String itemId, Version version, Version origVersion,
 141                                    List<Healer> structureHealersToRun,
 142                                    List<Healer> dataHealersToRun, String user) {
 143     List<String> failureMessages;
 144     if (origVersion.getStatus() == VersionStatus.Certified) {
 145       failureMessages = executeHealers(itemId, version,
 146           Stream.concat(structureHealersToRun.stream(), dataHealersToRun.stream())
 147               .collect(Collectors.toList()));
 148     } else {
 149       if (structureHealersToRun.isEmpty()) {
 150         failureMessages = executeHealers(itemId, version, dataHealersToRun);
 151       } else {
 152         versioningManager.forceSync(itemId, version);
 153         failureMessages = new LinkedList<>();
 154       }
 155     }
 156     markAsHealed(itemId, origVersion.getId(), user);
 157     return failureMessages;
 158   }
 159
 160   private List<String> healPublic(String itemId, Version version, Version origVersion,
 161                                   List<Healer> structureHealersToRun,
 162                                   List<Healer> dataHealersToRun, String user) {
 163     List<String> failureMessages = origVersion.getStatus() == VersionStatus.Certified
 164         ? new LinkedList<>()
 165         : healPublic(itemId, version,
 166             Stream.concat(structureHealersToRun.stream(), dataHealersToRun.stream())
 167                 .collect(Collectors.toList()), user);
 168
 169     markAsHealed(itemId, origVersion.getId(), PUBLIC_USER);
 170     return failureMessages;
 171   }
 172
 173   private List<String> healPublic(String itemId, Version version, List<Healer> healers,
 174                                   String user) {
 175     String tenant = SessionContextProviderFactory.getInstance().createInterface().get().getTenant();
 176     SessionContextProviderFactory.getInstance().createInterface()
 177         .create(user + HEALING_USER_SUFFIX, tenant);
 178
 179     versioningManager.forceSync(itemId, version);
 180
 181     List<String> failureMessages = executeHealers(itemId, version, healers);
 182     Version publicVersion = versioningManager.get(itemId, version);
 183
 184     if (Objects.nonNull(publicVersion.getState()) && publicVersion.getState().isDirty()) {
 185       versioningManager.publish(itemId, version, "Healing vsp");
 186     }
 187
 188     SessionContextProviderFactory.getInstance().createInterface().create(user, tenant);
 189     return failureMessages;
 190   }
 191
 192   private List<String> executeHealers(String itemId, Version version, List<Healer> healers) {
 193     List<String> failureMessages = new LinkedList<>();
 194     for (Healer healer : healers) {
 195       try {
 196         healer.heal(itemId, version);
 197       } catch (Exception e) {
 198         failureMessages.add(
 199             String.format("Failure in healer %s: %s", healer.getClass().getName(), e.getMessage()));
 200       }
 201     }
 202
 203     return failureMessages;
 204   }
 205
 206   private boolean isPrivateHealingNeededByFlags(String itemId, String version, String user) {
 207     Optional<Boolean> userHealingFlag = getHealingFlag(itemId, version, user);
 208     return userHealingFlag.orElseGet(() -> isPublicHealingNeededByFlag(itemId, version));
 209   }
 210
 211   private boolean isPublicHealingNeededByFlag(String itemId, String versionId) {
 212     Optional<Boolean> publicHealingFlag = getHealingFlag(itemId, versionId, PUBLIC_USER);
 213     return publicHealingFlag.isPresent() && publicHealingFlag.get();
 214   }
 215
 216   private Optional<Boolean> getHealingFlag(String itemId, String version, String user) {
 217     return healingDao.getItemHealingFlag(user, itemId, version);
 218   }
 219
 220   private void markAsHealed(String itemId, String versionId, String user) {
 221     healingDao.setItemHealingFlag(false, user, itemId, versionId);
 222   }
 223
 224   private void handleFailures(List<String> failureMessages) {
 225     if (!failureMessages.isEmpty()) {
 226       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 227           .withCategory(ErrorCategory.APPLICATION)
 228           .withMessage(CommonMethods.listToSeparatedString(failureMessages, '\n')).build());
 229     }
 230   }
 231
 232   private List<Healer> getHealersToRun(Collection<String> healersClassNames, String itemId,
 233                                        Version version, List<String> failureMessages) {
 234     return healersClassNames == null
 235                    ? Collections.EMPTY_LIST
 236                    : healersClassNames.stream()
 237                       .map(healerClassName -> getHealerInstance(healerClassName, failureMessages))
 238                       .filter(Optional::isPresent)
 239                       .map(Optional::get)
 240                       .filter(healer -> healer.isHealingNeeded(itemId, version))
 241                       .collect(Collectors.toList());
 242   }
 243
 244   private Optional<Healer> getHealerInstance(String healerClassName, List<String> failureMessages) {
 245     try {
 246       return Optional.of((Healer) Class.forName(healerClassName).getConstructor().newInstance());
 247     } catch (Exception e) {
 248       failureMessages
 249           .add(String.format(Messages.CANT_LOAD_HEALING_CLASS.getErrorMessage(), healerClassName));
 250       return Optional.empty();
 251     }
 252   }
 253
 254   private Map<String, Collection<String>> getItemHealers(ItemType itemType) {
 255     Map healingConfig = FileUtils
 256         .readViaInputStream(HEALERS_BY_ENTITY_TYPE_FILE,
 257             stream -> JsonUtil.json2Object(stream, Map.class));
 258     return (Map<String, Collection<String>>) healingConfig.getOrDefault(itemType.name(), Collections.EMPTY_MAP);
 259   }
 260
 261   private String getUser() {
 262     return SessionContextProviderFactory.getInstance().createInterface().get().getUser()
 263         .getUserId();
 264   }
 265 }