2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.healing.impl;
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.ErrorCode;
28 import org.openecomp.sdc.common.errors.Messages;
29 import org.openecomp.sdc.common.session.SessionContext;
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.HealCode;
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;
42 import java.lang.reflect.InvocationTargetException;
43 import java.util.ArrayList;
44 import java.util.Collection;
45 import java.util.List;
47 import java.util.Objects;
48 import java.util.Optional;
49 import java.util.stream.Collectors;
52 * Created by Talio on 11/29/2016.
54 public class HealingManagerImpl implements HealingManager {
56 private static final String HEALERS_BY_ENTITY_TYPE_FILE = "entityHealingConfiguration.json";
57 private static final String HEALING_USER_SUFFIX = "_healer";
58 private static final String PUBLIC_USER = "public";
60 private HealingDao healingDao;
61 private VersioningManager versioningManager;
63 public HealingManagerImpl(VersioningManager versioningManager, HealingDao healingDao) {
64 this.versioningManager = versioningManager;
65 this.healingDao = healingDao;
69 public Optional<Version> healItemVersion(String itemId, Version version, ItemType itemType,
71 String user = getUser();
72 if (force || isPrivateHealingNeededByFlag(itemId, version.getId(), user)) {
73 version = versioningManager.get(itemId, version);
74 Version origVersion = version;
75 if (version.getStatus() == VersionStatus.Certified) {
76 Optional<Version> newVersion = createNewVersion(itemId, version);
77 if (!newVersion.isPresent()) {
78 // do NOT turn off flag here (in thought of saving version calculate performance next
79 // time) because maybe next time the next version will be available (due to deletion of
81 return Optional.empty();
83 version = newVersion.get();
86 doHeal(itemId, version, origVersion, itemType, user, force);
87 return Optional.of(version);
89 return Optional.empty();
92 private void doHeal(String itemId, Version version, Version origVersion,
93 ItemType itemType, String user, boolean force) {
94 Optional<String> privateFailureMessages =
95 healPrivate(itemId, version, origVersion, getItemHealers(itemType), user);
97 Optional<String> publicFailureMessages =
98 force || origVersion.getStatus() == VersionStatus.Certified ||
99 isPublicHealingNeededByFlag(itemId, origVersion.getId())
100 ? healPublic(itemId, version, origVersion, getItemHealers(itemType), user)
103 if (privateFailureMessages.isPresent() || publicFailureMessages.isPresent()) {
104 throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage(
105 publicFailureMessages.orElse("") + " " + privateFailureMessages.orElse(""))
110 private Optional<String> healPrivate(String itemId, Version version, Version origVersion,
111 Map<String, Map<String, String>> itemHealers, String user) {
112 if (origVersion.getStatus() != VersionStatus.Certified) {
113 itemHealers.remove(HealerType.structure.name());
116 Optional<String> privateHealingFailureMessages = executeHealers(itemId, version, itemHealers);
117 markAsHealed(itemId, origVersion.getId(), user);
118 return privateHealingFailureMessages;
121 private Optional<String> healPublic(String itemId, Version version, Version origVersion,
122 Map<String, Map<String, String>> itemHealers, String user) {
123 Optional<String> healingFailureMessages = origVersion.getStatus() == VersionStatus.Certified
125 : healPublic(itemId, version, itemHealers, user);
127 markAsHealed(itemId, origVersion.getId(), PUBLIC_USER);
128 return healingFailureMessages;
131 private Optional<String> healPublic(String itemId, Version version,
132 Map<String, Map<String, String>> itemHealers, String user) {
133 SessionContext context =
134 SessionContextProviderFactory.getInstance().createInterface().get();
135 SessionContextProviderFactory.getInstance().createInterface().create(user
136 + HEALING_USER_SUFFIX,context.getTenant());
138 versioningManager.sync(itemId, version);
140 Optional<String> healingFailureMessages = executeHealers(itemId, version, itemHealers);
141 Version publicVersion = versioningManager.get(itemId, version);
143 if (Objects.nonNull(publicVersion.getState()) && publicVersion.getState().isDirty()) {
144 versioningManager.publish(itemId, version, "Healing vsp");
147 SessionContextProviderFactory.getInstance().createInterface().create(user, context.getTenant());
148 return healingFailureMessages;
151 private Optional<Version> createNewVersion(String itemId, Version version) {
152 Version newVersion = new Version();
153 newVersion.setBaseId(version.getId());
155 return Optional.of(versioningManager.create(itemId, newVersion, VersionCreationMethod.major));
156 } catch (Exception e) {
157 return Optional.empty();
162 public Object heal(String itemId, Version version, HealerType healerType, HealCode code,
164 String healerClassName = getItemHealers(itemType).get(healerType.name()).get(code.name());
165 ArrayList<String> healingFailureMessages = new ArrayList<>();
167 Object result = executeHealer(itemId, version, healerClassName, healingFailureMessages);
169 if (!healingFailureMessages.isEmpty()) {
170 throw new CoreException(new ErrorCode.ErrorCodeBuilder().withMessage(CommonMethods
171 .listToSeparatedString(healingFailureMessages, '\n')).build());
176 private Optional<String> executeHealers(String itemId, Version version,
177 Map<String, Map<String, String>> itemHealers) {
178 List<String> healers = itemHealers.values().stream()
180 .flatMap(Collection::stream)
181 .collect(Collectors.toList());
183 List<String> healingFailureMessages = new ArrayList<>();
184 for (String implClassName : healers) {
185 executeHealer(itemId, version, implClassName, healingFailureMessages);
188 return healingFailureMessages.isEmpty()
190 : Optional.of(CommonMethods.listToSeparatedString(healingFailureMessages, '\n'));
194 private Object executeHealer(String itemId, Version version, String healerClassName,
195 List<String> healingFailureMessages) {
198 healer = getHealerImplInstance(healerClassName);
199 } catch (Exception e) {
200 healingFailureMessages
201 .add(String.format(Messages.CANT_LOAD_HEALING_CLASS.getErrorMessage(),
207 return healer.heal(itemId, version);
208 } catch (Exception e) {
209 healingFailureMessages.add(e.getMessage() + " ,healer name :" + healerClassName);
214 private boolean isPrivateHealingNeededByFlag(String itemId, String version, String user) {
215 Optional<Boolean> userHealingFlag = getHealingFlag(itemId, version, user);
216 return userHealingFlag.orElseGet(() -> isPublicHealingNeededByFlag(itemId, version));
219 private boolean isPublicHealingNeededByFlag(String itemId, String versionId) {
220 Optional<Boolean> publicHealingFlag = getHealingFlag(itemId, versionId, PUBLIC_USER);
221 return publicHealingFlag.isPresent() && publicHealingFlag.get();
224 private Optional<Boolean> getHealingFlag(String itemId, String version, String user) {
225 return healingDao.getItemHealingFlag(user, itemId, version);
228 private void markAsHealed(String itemId, String versionId, String user) {
229 healingDao.setItemHealingFlag(false, user, itemId, versionId);
232 private Map<String, Map<String, String>> getItemHealers(ItemType itemType) {
233 Map healingConfig = FileUtils
234 .readViaInputStream(HEALERS_BY_ENTITY_TYPE_FILE,
235 stream -> JsonUtil.json2Object(stream, Map.class));
236 return (Map<String, Map<String, String>>) healingConfig.get(itemType.name());
239 private Healer getHealerImplInstance(String implClassName)
240 throws InstantiationException, IllegalAccessException, InvocationTargetException,
241 NoSuchMethodException, ClassNotFoundException {
242 return (Healer) Class.forName(implClassName).getConstructor().newInstance();
245 private String getUser() {
246 return SessionContextProviderFactory.getInstance().createInterface().get().getUser()