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.be.components.impl;
23 import fj.data.Either;
24 import org.apache.commons.lang3.tuple.ImmutablePair;
25 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
26 import org.openecomp.sdc.be.config.BeEcompErrorManager;
27 import org.openecomp.sdc.be.dao.api.ActionStatus;
28 import org.openecomp.sdc.be.impl.ComponentsUtils;
29 import org.openecomp.sdc.be.model.*;
30 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
31 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
32 import org.openecomp.sdc.exception.ResponseFormat;
33 import org.slf4j.Logger;
34 import org.slf4j.LoggerFactory;
35 import org.springframework.stereotype.Component;
36 import org.yaml.snakeyaml.Yaml;
38 import javax.annotation.Resource;
39 import java.util.ArrayList;
40 import java.util.Iterator;
41 import java.util.List;
43 import java.util.Map.Entry;
44 import java.util.function.BiFunction;
45 import java.util.function.Consumer;
46 import java.util.function.Function;
47 import java.util.stream.Collectors;
49 @Component("commonImportManager")
50 public class CommonImportManager {
52 private static final Logger log = LoggerFactory.getLogger(CommonImportManager.class);
55 private ComponentsUtils componentsUtils;
57 private PropertyOperation propertyOperation;
59 protected void setProperties(Map<String, Object> toscaJson, Consumer<List<PropertyDefinition>> consumer) {
60 consumer.accept(getProperties(toscaJson));
63 private List<PropertyDefinition> getProperties(Map<String, Object> toscaJson) {
64 List<PropertyDefinition> values = null;
65 Either<Map<String, PropertyDefinition>, ResultStatusEnum> properties = ImportUtils.getProperties(toscaJson);
67 if (properties.isLeft()) {
68 values = new ArrayList<>();
69 Map<String, PropertyDefinition> propertiesMap = properties.left().value();
70 if (propertiesMap != null && propertiesMap.isEmpty() == false) {
72 for (Entry<String, PropertyDefinition> entry : propertiesMap.entrySet()) {
73 String propName = entry.getKey();
74 PropertyDefinition propertyDefinition = entry.getValue();
75 PropertyDefinition newPropertyDefinition = new PropertyDefinition(propertyDefinition);
76 newPropertyDefinition.setName(propName);
77 values.add(newPropertyDefinition);
85 protected void setPropertiesMap(Map<String, Object> toscaJson, Consumer<Map<String, PropertyDefinition>> consumer) {
86 final List<PropertyDefinition> properties = getProperties(toscaJson);
87 if (properties != null) {
88 Map<String, PropertyDefinition> collect = properties.stream().collect(Collectors.toMap(e -> e.getName(), e -> e));
89 consumer.accept(collect);
94 interface ICreateElementType<T1, T2, ElementType> {
95 ElementType createElement(T1 firstArg, T2 secondArg);
98 protected <ElementDefinition> Either<List<ElementDefinition>, ActionStatus> createElementTypesFromYml(String elementTypesYml, ICreateElementType<String, Map<String, Object>, ElementDefinition> createApi) {
100 List<ElementDefinition> elementTypes = new ArrayList<>();
102 Map<String, Object> toscaJson = (Map<String, Object>) new Yaml().load(elementTypesYml);
104 elementTypes = createElementTypesFromToscaJsonMap(createApi, toscaJson);
105 } catch (Exception e) {
106 log.debug("Failed to yaml file {}", elementTypesYml, e);
107 return Either.right(ActionStatus.INVALID_YAML_FILE);
109 return Either.left(elementTypes);
113 * @param createApi * @param createApi
114 * @param elementTypes
117 protected <ElementDefinition> List<ElementDefinition> createElementTypesFromToscaJsonMap(
118 ICreateElementType<String, Map<String, Object>, ElementDefinition> createApi, Map<String, Object> toscaJson) {
119 List<ElementDefinition> elementTypes = new ArrayList<>();
121 Iterator<Entry<String, Object>> elementTypesEntryItr = toscaJson.entrySet().iterator();
122 while (elementTypesEntryItr.hasNext()) {
123 Entry<String, Object> elementTypeNameDataEntry = elementTypesEntryItr.next();
124 String elementTypeName = elementTypeNameDataEntry.getKey();
125 Map<String, Object> elementTypeJsonData = (Map<String, Object>) elementTypeNameDataEntry.getValue();
126 ElementDefinition elementDefinition = createApi.createElement(elementTypeName, elementTypeJsonData);
127 elementTypes.add(elementDefinition);
132 protected <FieldType> void setField(Map<String, Object> toscaJson, String fieldName, Consumer<FieldType> setter) {
133 if (toscaJson.containsKey(fieldName)) {
134 FieldType fieldValue = (FieldType) toscaJson.get(fieldName);
135 setter.accept(fieldValue);
140 public enum ElementTypeEnum {
141 PolicyType, GroupType, DataType, CapabilityType, InterfaceLifecycleType
144 private ActionStatus convertFromStorageResponseForElementType(StorageOperationStatus status, ElementTypeEnum elementTypeEnum) {
146 switch (elementTypeEnum) {
148 ret = componentsUtils.convertFromStorageResponseForGroupType(status);
151 ret = componentsUtils.convertFromStorageResponseForDataType(status);
154 ret = componentsUtils.convertFromStorageResponseForCapabilityType(status);
156 case InterfaceLifecycleType:
157 ret = componentsUtils.convertFromStorageResponseForLifecycleType(status);
160 ret = componentsUtils.convertFromStorageResponse(status);
166 private <ElementTypeDefinition> ResponseFormat getResponseFormatForElementType(ActionStatus actionStatus, ElementTypeEnum elementTypeEnum, ElementTypeDefinition elementTypeDefinition) {
168 switch (elementTypeEnum) {
170 ret = componentsUtils.getResponseFormatByGroupType(actionStatus, (GroupTypeDefinition) elementTypeDefinition);
173 ret = componentsUtils.getResponseFormatByPolicyType(actionStatus, (PolicyTypeDefinition) elementTypeDefinition);
176 ret = componentsUtils.getResponseFormatByDataType(actionStatus, (DataTypeDefinition) elementTypeDefinition, null);
179 ret = componentsUtils.getResponseFormatByCapabilityType(actionStatus, (CapabilityTypeDefinition) elementTypeDefinition);
183 ret = componentsUtils.getResponseFormat(actionStatus);
189 protected <ElementTypeDefinition> Either<List<ImmutablePair<ElementTypeDefinition, Boolean>>, ResponseFormat> createElementTypesByDao(List<ElementTypeDefinition> elementTypesToCreate,
190 Function<ElementTypeDefinition, Either<ActionStatus, ResponseFormat>> validator, Function<ElementTypeDefinition, ImmutablePair<ElementTypeEnum, String>> elementInfoGetter,
191 Function<String, Either<ElementTypeDefinition, StorageOperationStatus>> elementFetcher, Function<ElementTypeDefinition, Either<ElementTypeDefinition, StorageOperationStatus>> elementAdder,
192 BiFunction<ElementTypeDefinition, ElementTypeDefinition, Either<ElementTypeDefinition, StorageOperationStatus>> elementUpgrader) {
194 List<ImmutablePair<ElementTypeDefinition, Boolean>> createdElementTypes = new ArrayList<>();
196 Either<List<ImmutablePair<ElementTypeDefinition, Boolean>>, ResponseFormat> eitherResult = Either.left(createdElementTypes);
198 Iterator<ElementTypeDefinition> elementTypeItr = elementTypesToCreate.iterator();
202 while (elementTypeItr.hasNext()) {
203 ElementTypeDefinition elementType = elementTypeItr.next();
204 final ImmutablePair<ElementTypeEnum, String> elementInfo = elementInfoGetter.apply(elementType);
205 ElementTypeEnum elementTypeEnum = elementInfo.left;
206 String elementName = elementInfo.right;
208 Either<ActionStatus, ResponseFormat> validateElementType = validator.apply(elementType);
209 if (validateElementType.isRight()) {
210 ResponseFormat responseFormat = validateElementType.right().value();
211 log.debug("Failed in validation of element type: {}. Response is {}", elementType, responseFormat.getFormattedMessage());
212 eitherResult = Either.right(responseFormat);
216 log.info("send {} : {} to dao for create", elementTypeEnum, elementName);
218 Either<ElementTypeDefinition, StorageOperationStatus> findElementType = elementFetcher.apply(elementName);
219 if (findElementType.isRight()) {
220 StorageOperationStatus status = findElementType.right().value();
221 log.debug("searched {} finished with result:{}", elementTypeEnum, status.name());
222 if (status != StorageOperationStatus.NOT_FOUND) {
223 ResponseFormat responseFormat = getResponseFormatForElementType(convertFromStorageResponseForElementType(status, elementTypeEnum), elementTypeEnum, elementType);
224 eitherResult = Either.right(responseFormat);
227 Either<ElementTypeDefinition, StorageOperationStatus> dataModelResponse = elementAdder.apply(elementType);
229 if (dataModelResponse.isRight()) {
231 BeEcompErrorManager.getInstance().logBeFailedAddingNodeTypeError("Create {}", elementTypeEnum.name());
232 log.debug("failed to create {}: {}", elementTypeEnum, elementName);
233 if (dataModelResponse.right().value() != StorageOperationStatus.SCHEMA_VIOLATION) {
234 ResponseFormat responseFormat = getResponseFormatForElementType(convertFromStorageResponseForElementType(dataModelResponse.right().value(), elementTypeEnum), elementTypeEnum, elementType);
236 eitherResult = Either.right(responseFormat);
239 createdElementTypes.add(new ImmutablePair<ElementTypeDefinition, Boolean>(elementType, false));
242 propertyOperation.getTitanGenericDao().rollback();
245 propertyOperation.getTitanGenericDao().commit();
246 createdElementTypes.add(new ImmutablePair<ElementTypeDefinition, Boolean>(elementType, true));
247 log.debug("{} : {} was created successfully.", elementTypeEnum, elementName);
249 if (!elementTypeItr.hasNext()) {
250 log.info("all {} were created successfully!!!", elementTypeEnum);
256 if (elementUpgrader != null) {
257 Either<ElementTypeDefinition, StorageOperationStatus> upgradeResponse = null;
259 upgradeResponse = elementUpgrader.apply(elementType, findElementType.left().value());
260 if (upgradeResponse.isRight()) {
261 StorageOperationStatus status = upgradeResponse.right().value();
262 if (status == StorageOperationStatus.OK) {
263 createdElementTypes.add(new ImmutablePair<ElementTypeDefinition, Boolean>(elementType, false));
265 ResponseFormat responseFormat = getResponseFormatForElementType(convertFromStorageResponseForElementType(upgradeResponse.right().value(), elementTypeEnum), elementTypeEnum, elementType);
266 eitherResult = Either.right(responseFormat);
270 log.debug("{} : {} was upgraded successfully.", elementTypeEnum, elementName);
271 createdElementTypes.add(new ImmutablePair<ElementTypeDefinition, Boolean>(elementType, true));
274 if (upgradeResponse == null || upgradeResponse.isRight()) {
275 propertyOperation.getTitanGenericDao().rollback();
277 propertyOperation.getTitanGenericDao().commit();
282 // mshitrit Once GroupType Versions are supported add
284 createdElementTypes.add(new ImmutablePair<ElementTypeDefinition, Boolean>(elementType, false));
285 log.debug("{} : {} already exists.", elementTypeEnum, elementName);
292 if (eitherResult.isRight()) {
293 propertyOperation.getTitanGenericDao().rollback();
301 public <ElementTypeDefinition> Either<List<ImmutablePair<ElementTypeDefinition, Boolean>>, ResponseFormat> createElementTypes(String elementTypesYml, Function<String, Either<List<ElementTypeDefinition>, ActionStatus>> elementTypeFromYmlCreater,
302 Function<List<ElementTypeDefinition>, Either<List<ImmutablePair<ElementTypeDefinition, Boolean>>, ResponseFormat>> elementTypeDaoCreater, ElementTypeEnum elementTypeEnum) {
304 Either<List<ElementTypeDefinition>, ActionStatus> elementTypes = elementTypeFromYmlCreater.apply(elementTypesYml);
305 if (elementTypes.isRight()) {
306 ActionStatus status = elementTypes.right().value();
307 ResponseFormat responseFormat = getResponseFormatForElementType(status, elementTypeEnum, null);
308 return Either.right(responseFormat);
310 return elementTypeDaoCreater.apply(elementTypes.left().value());