gerrit.onap Code Review - sdc.git/blob

   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.CoreException;
  27 import org.openecomp.sdc.common.errors.ErrorCategory;
  28 import org.openecomp.sdc.common.errors.ErrorCode;
  29 import org.openecomp.sdc.common.errors.Messages;
  30 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  31 import org.openecomp.sdc.datatypes.model.ItemType;
  32 import org.openecomp.sdc.healing.api.HealingManager;
  33 import org.openecomp.sdc.healing.dao.HealingDao;
  34 import org.openecomp.sdc.healing.interfaces.Healer;
  35 import org.openecomp.sdc.healing.types.HealerType;
  36 import org.openecomp.sdc.versioning.VersioningManager;
  37 import org.openecomp.sdc.versioning.dao.types.Version;
  38 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  39 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  40
  41 import java.util.Collection;
  42 import java.util.LinkedList;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Objects;
  46 import java.util.Optional;
  47 import java.util.stream.Collectors;
  48 import java.util.stream.Stream;
  49
  50 public class HealingManagerImpl implements HealingManager {
  51
  52   private static final String HEALERS_BY_ENTITY_TYPE_FILE = "entityHealingConfiguration.json";
  53   private static final String HEALING_USER_SUFFIX = "_healer";
  54   private static final String PUBLIC_USER = "public";
  55
  56   private HealingDao healingDao;
  57   private VersioningManager versioningManager;
  58
  59   public HealingManagerImpl(VersioningManager versioningManager, HealingDao healingDao) {
  60     this.versioningManager = versioningManager;
  61     this.healingDao = healingDao;
  62   }
  63
  64   @Override
  65   public Optional<Version> healItemVersion(final String itemId, final Version version,
  66                                            final ItemType itemType, final boolean force) {
  67     String user = getUser();
  68     if (force || isPrivateHealingNeededByFlag(itemId, version.getId(), user)) {
  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
  97       handleFailures(failureMessages);
  98       return healVersion;
  99     }
 100     return Optional.empty();
 101   }
 102
 103   private Optional<Version> getHealVersion(String itemId, Version version) {
 104     version.setStatus(versioningManager.get(itemId, version).getStatus());
 105     return version.getStatus() == VersionStatus.Certified
 106         ? createNewVersion(itemId, version.getId())
 107         : Optional.of(version);
 108   }
 109
 110   private Optional<Version> createNewVersion(String itemId, String versionId) {
 111     Version newVersion = new Version();
 112     newVersion.setBaseId(versionId);
 113     try {
 114       return Optional.of(versioningManager.create(itemId, newVersion, VersionCreationMethod.major));
 115     } catch (Exception e) {
 116       return Optional.empty();
 117     }
 118   }
 119
 120   private List<String> doHeal(String itemId, Version version, Version origVersion,
 121                               List<Healer> structureHealersToRun,
 122                               List<Healer> dataHealersToRun, String user,
 123                               boolean force) {
 124     List<String> failureMessages =
 125         force || origVersion.getStatus() == VersionStatus.Certified ||
 126             isPublicHealingNeededByFlag(itemId, origVersion.getId())
 127             ? healPublic(itemId, version, origVersion, structureHealersToRun, dataHealersToRun,
 128             user)
 129             : new LinkedList<>();
 130
 131     failureMessages.addAll(
 132         healPrivate(itemId, version, origVersion, structureHealersToRun, dataHealersToRun, user));
 133
 134     return failureMessages;
 135   }
 136
 137   private List<String> healPrivate(String itemId, Version version, Version origVersion,
 138                                    List<Healer> structureHealersToRun,
 139                                    List<Healer> dataHealersToRun, String user) {
 140     List<String> failureMessages;
 141     if (origVersion.getStatus() == VersionStatus.Certified) {
 142       failureMessages = executeHealers(itemId, version,
 143           Stream.concat(structureHealersToRun.stream(), dataHealersToRun.stream())
 144               .collect(Collectors.toList()));
 145     } else {
 146       if (structureHealersToRun.isEmpty()) {
 147         failureMessages = executeHealers(itemId, version, dataHealersToRun);
 148       } else {
 149         versioningManager.forceSync(itemId, version);
 150         failureMessages = new LinkedList<>();
 151       }
 152     }
 153     markAsHealed(itemId, origVersion.getId(), user);
 154     return failureMessages;
 155   }
 156
 157   private List<String> healPublic(String itemId, Version version, Version origVersion,
 158                                   List<Healer> structureHealersToRun,
 159                                   List<Healer> dataHealersToRun, String user) {
 160     List<String> failureMessages = origVersion.getStatus() == VersionStatus.Certified
 161         ? new LinkedList<>()
 162         : healPublic(itemId, version,
 163             Stream.concat(structureHealersToRun.stream(), dataHealersToRun.stream())
 164                 .collect(Collectors.toList()), user);
 165
 166     markAsHealed(itemId, origVersion.getId(), PUBLIC_USER);
 167     return failureMessages;
 168   }
 169
 170   private List<String> healPublic(String itemId, Version version, List<Healer> healers,
 171                                   String user) {
 172     String tenant = SessionContextProviderFactory.getInstance().createInterface().get().getTenant();
 173     SessionContextProviderFactory.getInstance().createInterface()
 174         .create(user + HEALING_USER_SUFFIX, tenant);
 175
 176     versioningManager.forceSync(itemId, version);
 177
 178     List<String> failureMessages = executeHealers(itemId, version, healers);
 179     Version publicVersion = versioningManager.get(itemId, version);
 180
 181     if (Objects.nonNull(publicVersion.getState()) && publicVersion.getState().isDirty()) {
 182       versioningManager.publish(itemId, version, "Healing vsp");
 183     }
 184
 185     SessionContextProviderFactory.getInstance().createInterface().create(user, tenant);
 186     return failureMessages;
 187   }
 188
 189   private List<String> executeHealers(String itemId, Version version, List<Healer> healers) {
 190     List<String> failureMessages = new LinkedList<>();
 191     for (Healer healer : healers) {
 192       try {
 193         healer.heal(itemId, version);
 194       } catch (Exception e) {
 195         failureMessages.add(
 196             String.format("Failure in healer %s: %s", healer.getClass().getName(), e.getMessage()));
 197       }
 198     }
 199
 200     return failureMessages;
 201   }
 202
 203   private boolean isPrivateHealingNeededByFlag(String itemId, String version, String user) {
 204     Optional<Boolean> userHealingFlag = getHealingFlag(itemId, version, user);
 205     return userHealingFlag.orElseGet(() -> isPublicHealingNeededByFlag(itemId, version));
 206   }
 207
 208   private boolean isPublicHealingNeededByFlag(String itemId, String versionId) {
 209     Optional<Boolean> publicHealingFlag = getHealingFlag(itemId, versionId, PUBLIC_USER);
 210     return publicHealingFlag.isPresent() && publicHealingFlag.get();
 211   }
 212
 213   private Optional<Boolean> getHealingFlag(String itemId, String version, String user) {
 214     return healingDao.getItemHealingFlag(user, itemId, version);
 215   }
 216
 217   private void markAsHealed(String itemId, String versionId, String user) {
 218     healingDao.setItemHealingFlag(false, user, itemId, versionId);
 219   }
 220
 221   private void handleFailures(List<String> failureMessages) {
 222     if (!failureMessages.isEmpty()) {
 223       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 224           .withCategory(ErrorCategory.APPLICATION)
 225           .withMessage(CommonMethods.listToSeparatedString(failureMessages, '\n')).build());
 226     }
 227   }
 228
 229   private List<Healer> getHealersToRun(Collection<String> healersClassNames, String itemId,
 230                                        Version version, List<String> failureMessages) {
 231     return healersClassNames.stream()
 232         .map(healerClassName -> getHealerInstance(healerClassName, failureMessages))
 233         .filter(Optional::isPresent)
 234         .map(Optional::get)
 235         .filter(healer -> healer.isHealingNeeded(itemId, version))
 236         .collect(Collectors.toList());
 237   }
 238
 239   private Optional<Healer> getHealerInstance(String healerClassName, List<String> failureMessages) {
 240     try {
 241       return Optional.of((Healer) Class.forName(healerClassName).getConstructor().newInstance());
 242     } catch (Exception e) {
 243       failureMessages
 244           .add(String.format(Messages.CANT_LOAD_HEALING_CLASS.getErrorMessage(), healerClassName));
 245       return Optional.empty();
 246     }
 247   }
 248
 249   private Map<String, Collection<String>> getItemHealers(ItemType itemType) {
 250     Map healingConfig = FileUtils
 251         .readViaInputStream(HEALERS_BY_ENTITY_TYPE_FILE,
 252             stream -> JsonUtil.json2Object(stream, Map.class));
 253     return (Map<String, Collection<String>>) healingConfig.get(itemType.name());
 254   }
 255
 256   private String getUser() {
 257     return SessionContextProviderFactory.getInstance().createInterface().get().getUser()
 258         .getUserId();
 259   }
 260 }