* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
package org.openecomp.sdc.be.components.impl;
import static java.util.stream.Collectors.joining;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import fj.data.Either;
+import java.lang.reflect.Method;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import lombok.Setter;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.json.simple.JSONObject;
import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
-import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.CustomYamlFunction;
import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.SubPropertyToscaFunction;
import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
import org.openecomp.sdc.be.model.ComponentInstanceInput;
import org.openecomp.sdc.be.model.ComponentInstanceProperty;
import org.openecomp.sdc.be.model.ComponentParametersView;
import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
+import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
private final IGraphLockOperation graphLockOperation;
private final ToscaFunctionService toscaFunctionService;
private final DataTypeBusinessLogic dataTypeBusinessLogic;
- private ApplicationDataTypeCache applicationDataTypeCache;
private final ArtifactTypeOperation artifactTypeOperation;
-
private final GroupTypeImportManager groupTypeImportManager;
private final GroupTypeOperation groupTypeOperation;
- private InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
- private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
-
private final CapabilityTypeImportManager capabilityTypeImportManager;
private final CapabilityTypeOperation capabilityTypeOperation;
+ private ApplicationDataTypeCache applicationDataTypeCache;
+ private final InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
+ private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
+ private final ModelOperation modelOperation;
public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic,
final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade,
final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager,
final CapabilityTypeImportManager capabilityTypeImportManager,
- final CapabilityTypeOperation capabilityTypeOperation) {
+ final CapabilityTypeOperation capabilityTypeOperation,
+ final ModelOperation modelOperation) {
this.componentsUtils = componentsUtils;
this.toscaOperationFacade = toscaOperationFacade;
this.serviceBusinessLogic = serviceBusinessLogic;
this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager;
this.capabilityTypeImportManager = capabilityTypeImportManager;
this.capabilityTypeOperation = capabilityTypeOperation;
+ this.modelOperation = modelOperation;
}
@Autowired
this.applicationDataTypeCache = applicationDataTypeCache;
}
+ public Service updateServiceFromToscaTemplate(final String serviceId, final User modifier, final String data) {
+ final Either<Service, ResponseFormat> serviceResponseFormatEither = serviceBusinessLogic.getService(serviceId, modifier);
+ if (serviceResponseFormatEither.isRight()) {
+ throw new ByActionStatusComponentException(ActionStatus.SERVICE_NOT_FOUND, serviceId);
+ }
+ final Service serviceOriginal = serviceResponseFormatEither.left().value();
+ final Map<String, String> metadata = (Map<String, String>) new Yaml().loadAs(data, Map.class).get("metadata");
+ validateServiceMetadataBeforeCreate(serviceOriginal, metadata);
+
+ final Service newService = cloneServiceIdentifications(serviceOriginal);
+ final Map<String, byte[]> payload = new HashMap<>();
+ payload.put("Definitions/service-" + metadata.get("name") + "-template.yml", data.getBytes());
+ updateServiceMetadata(newService, metadata);
+ return createService(newService, AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE, modifier, payload, null);
+ }
+
+ private Service cloneServiceIdentifications(final Service serviceOriginal) {
+ final Service newService = new Service(serviceOriginal.getComponentMetadataDefinition());
+ newService.setCategories(serviceOriginal.getCategories());
+ newService.setInvariantUUID(serviceOriginal.getInvariantUUID());
+ newService.setUniqueId(serviceOriginal.getUniqueId());
+ newService.setName(serviceOriginal.getName());
+ newService.setUUID(serviceOriginal.getUUID());
+ return newService;
+ }
+
+ private void validateServiceMetadataBeforeCreate(final Service service, final Map<String, String> metadata) {
+ if (MapUtils.isEmpty(metadata)) {
+ throw new ByActionStatusComponentException(ActionStatus.MISSING_SERVICE_METADATA);
+ }
+ final String uuid = metadata.get("UUID");
+ if (!service.getUUID().equals(uuid)) {
+ throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "UUID");
+ }
+ final String invariantUUID = metadata.get("invariantUUID");
+ if (!service.getInvariantUUID().equals(invariantUUID)) {
+ throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "invariantUUID");
+ }
+ final String name = metadata.get("name");
+ if (!service.getName().equals(name)) {
+ throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "name");
+ }
+ final String version = metadata.get("template_version");
+ if (!service.getVersion().equals(version)) {
+ throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "template_version");
+ }
+ }
+
public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
String payloadName) {
log.debug("enter createService");
- service.setCreatorUserId(user.getUserId());
- service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
- service.setVersion(INITIAL_VERSION);
- service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
- service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
+ if (AuditingActionEnum.CREATE_SERVICE.equals(auditingAction)) {
+ service.setCreatorUserId(user.getUserId());
+ service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ service.setVersion(INITIAL_VERSION);
+ service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
+ service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
+ }
try {
final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
if (serviceBeforeCreate.isRight()) {
}
log.debug("enter createService,validateServiceBeforeCreate success");
String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
- log.debug("enter createService,get csarUUID:{}", csarUUID);
- csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
+ if (AuditingActionEnum.CREATE_SERVICE.equals(auditingAction)) {
+ log.debug("enter createService,get csarUUID:{}", csarUUID);
+ csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
+ }
log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
- return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
+ return createServiceFromCsar(service, user, csarUIPayload, csarUUID, auditingAction);
} catch (final ComponentException e) {
log.debug("Exception occurred when createService: {}", e.getMessage(), e);
throw e;
}
}
- protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
+ private void updateServiceMetadata(final Service service, final Map<String, String> metadata) {
+ metadata.entrySet().forEach(s -> {
+ final Optional<Method> find =
+ Arrays.stream(service.getClass().getMethods()).filter(method -> method.getName().equalsIgnoreCase("set" + s.getKey())).findAny();
+ if (find.isPresent()) {
+ try {
+ find.get().invoke(service, s.getValue());
+ } catch (final Exception e) {
+ log.warn("Unable to set '{}' with value '{}'", s.getKey(), s.getValue());
+ }
+ }
+ });
+ }
+
+ protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID,
+ AuditingActionEnum auditingAction) {
log.trace("************* created successfully from YAML, resource TOSCA ");
try {
- ServiceCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
-
- final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(service.getModel(), csarInfo);
+ final ServiceCsarInfo csarInfo;
+ if (AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction)) {
+ csarInfo = new ServiceCsarInfo(user, csarUUID, csarUIPayload, service.getName(), service.getModel(),
+ csarUIPayload.keySet().iterator().next(), new String(csarUIPayload.values().iterator().next()), true, modelOperation);
+ } else {
+ csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID, auditingAction);
+ }
+ final String serviceModel = service.getModel();
+ final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(serviceModel, csarInfo);
if (MapUtils.isNotEmpty(dataTypesToCreate)) {
- dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), service.getModel(), true);
- dataTypesToCreate.entrySet().stream().forEach(createdOrUpdatedDataType -> {
- applicationDataTypeCache.reload(service.getModel(),
- UniqueIdBuilder.buildDataTypeUid(service.getModel(), createdOrUpdatedDataType.getKey()));
- });
+ dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), serviceModel, true);
+ dataTypesToCreate.keySet().forEach(key ->
+ applicationDataTypeCache.reload(serviceModel, UniqueIdBuilder.buildDataTypeUid(serviceModel, key))
+ );
}
- final Map<String, Object> artifactTypesToCreate = getArtifactTypesToCreate(service.getModel(), csarInfo);
+ final Map<String, Object> artifactTypesToCreate = getArtifactTypesToCreate(serviceModel, csarInfo);
if (MapUtils.isNotEmpty(artifactTypesToCreate)) {
- artifactTypeImportManager.createArtifactTypes(new Yaml().dump(artifactTypesToCreate), service.getModel(), true);
+ artifactTypeImportManager.createArtifactTypes(new Yaml().dump(artifactTypesToCreate), serviceModel, true);
}
- final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(service.getModel(), csarInfo);
+ final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(serviceModel, csarInfo);
if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) {
- createNodeTypes(nodeTypesToCreate, service.getModel(), csarInfo.getModifier());
+ createNodeTypes(nodeTypesToCreate, serviceModel, csarInfo.getModifier());
}
- final Map<String, Object> groupTypesToCreate = getGroupTypesToCreate(service.getModel(), csarInfo);
+ final Map<String, Object> groupTypesToCreate = getGroupTypesToCreate(serviceModel, csarInfo);
if (MapUtils.isNotEmpty(groupTypesToCreate)) {
final Map<String, ToscaTypeMetadata> toscaTypeMetadata = fillToscaTypeMetadata(groupTypesToCreate);
final ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(new Yaml().dump(groupTypesToCreate), toscaTypeMetadata);
- groupTypeImportManager.createGroupTypes(toscaTypeImportData, service.getModel(), true);
+ groupTypeImportManager.createGroupTypes(toscaTypeImportData, serviceModel, true);
}
- final Map<String, Object> interfaceTypesToCreate = getInterfaceTypesToCreate(service.getModel(), csarInfo);
+ final Map<String, Object> interfaceTypesToCreate = getInterfaceTypesToCreate(serviceModel, csarInfo);
if (MapUtils.isNotEmpty(interfaceTypesToCreate)) {
- interfaceLifecycleTypeImportManager
- .createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), service.getModel(), true);
+ interfaceLifecycleTypeImportManager.createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), serviceModel, true);
}
- final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(service.getModel(), csarInfo);
-
+ final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(serviceModel, csarInfo);
if (MapUtils.isNotEmpty(capabilityTypesToCreate)) {
- capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), service.getModel(), true);
+ capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), serviceModel, true);
}
Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
- Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
- .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
+ Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes
+ = serviceImportParseLogic.findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
if (findNodeTypesArtifactsToHandleRes.isRight()) {
log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
}
return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
- findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
+ findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId(), auditingAction);
} catch (final ComponentException e) {
log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
throw e;
return interfaceTypesToCreate;
}
- private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result, final Map<String, Map<String, Object>> dataType) {
+ private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result,
+ final Map<String, Map<String, Object>> dataType) {
return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
&& result.left().value().getProperties().size() != dataType.get("properties").size();
}
NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
final Map<String, Object> allTypesToCreate = new HashMap<>();
- nodeTypesToCreate.stream().forEach(nodeType -> {
+ nodeTypesToCreate.forEach(nodeType -> {
allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
});
Map<String, Object> combinedMappedToscaTemplate =
getNewChangesToToscaTemplate(newMappedToscaTemplate, (Map<String, Object>) existingMappedToscaTemplate.getValue());
if (!combinedMappedToscaTemplate.equals(existingMappedToscaTemplate.getValue())) {
+ if (latestResource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative()) {
+ nodeTypeDefinition.getNodeTypeMetadata().setNormative(true);
+ }
existingMappedToscaTemplate.setValue(combinedMappedToscaTemplate);
nodeTypeDefinition.setMappedNodeType(existingMappedToscaTemplate);
namesOfNodeTypesToCreate.add(nodeTypeDefinition);
return eitherNodeTypes.left().value().entrySet().iterator().next();
}
- private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> newMappedToscaTemplate,
+ private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> newMappedToscaTemplate,
Map<String, Object> existingMappedToscaTemplate) {
Map<String, Object> combinedMappedToscaTemplate = new HashMap<>(existingMappedToscaTemplate);
combinePropertiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("properties"),
- (Map<String, Object>) existingMappedToscaTemplate.get("properties"), combinedMappedToscaTemplate);
+ (Map<String, Object>) existingMappedToscaTemplate.get("properties"), combinedMappedToscaTemplate);
combineAttributesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("attributes"),
- (Map<String, Object>) existingMappedToscaTemplate.get("attributes"), combinedMappedToscaTemplate);
+ (Map<String, Object>) existingMappedToscaTemplate.get("attributes"), combinedMappedToscaTemplate);
combineRequirementsIntoToscaTemplate((List<Map<String, Object>>) newMappedToscaTemplate.get("requirements"),
- (List<Map<String, Object>>) existingMappedToscaTemplate.get("requirements"), combinedMappedToscaTemplate);
+ (List<Map<String, Object>>) existingMappedToscaTemplate.get("requirements"), combinedMappedToscaTemplate);
combineCapabilitiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("capabilities"),
- (Map<String, Object>) existingMappedToscaTemplate.get("capabilities"), combinedMappedToscaTemplate);
+ (Map<String, Object>) existingMappedToscaTemplate.get("capabilities"), combinedMappedToscaTemplate);
combineInterfacesIntoToscaTemplate((Map<String, Map<String, Object>>) newMappedToscaTemplate.get("interfaces"),
- (Map<String, Map<String, Object>>) existingMappedToscaTemplate.get("interfaces"), combinedMappedToscaTemplate);
+ (Map<String, Map<String, Object>>) existingMappedToscaTemplate.get("interfaces"), combinedMappedToscaTemplate);
return combinedMappedToscaTemplate;
}
Map<String, Object> combinedMappedToscaTemplate) {
Map<String, Map<String, Object>> combinedInterfaces = combineAdditionalInterfaces(existingInterfaces, newInterfaces);
if ((MapUtils.isEmpty(existingInterfaces) && MapUtils.isNotEmpty(combinedInterfaces))
- || (MapUtils.isNotEmpty(existingInterfaces) && !existingInterfaces.equals(combinedInterfaces))) {
+ || (MapUtils.isNotEmpty(existingInterfaces) && !existingInterfaces.equals(combinedInterfaces))) {
combinedMappedToscaTemplate.put("interfaces", combinedInterfaces);
}
}
Map<String, Object> combinedMappedToscaTemplate) {
Map<String, Object> combinedCapabilities = combineEntries(newCapabilities, existingCapabilities);
if ((MapUtils.isEmpty(existingCapabilities) && MapUtils.isNotEmpty(combinedCapabilities)) ||
- ( MapUtils.isNotEmpty(existingCapabilities) && !combinedCapabilities.equals(existingCapabilities))) {
+ (MapUtils.isNotEmpty(existingCapabilities) && !combinedCapabilities.equals(existingCapabilities))) {
combinedMappedToscaTemplate.put("capabilities", combinedCapabilities);
}
}
Map<String, Object> combinedMappedToscaTemplate) {
List<Map<String, Object>> combinedRequirements = combineAdditionalRequirements(newRequirements, existingRequirements);
if ((CollectionUtils.isEmpty(existingRequirements) && CollectionUtils.isNotEmpty(combinedRequirements))
- || (CollectionUtils.isNotEmpty(existingRequirements) && !combinedRequirements.equals(existingRequirements))) {
+ || (CollectionUtils.isNotEmpty(existingRequirements) && !combinedRequirements.equals(existingRequirements))) {
combinedMappedToscaTemplate.put("requirements", combinedRequirements);
}
}
Map<String, Object> combinedMappedToscaTemplate) {
Map<String, Object> combinedAttributes = combineEntries(newAttributes, existingAttributes);
if ((MapUtils.isEmpty(existingAttributes) && MapUtils.isNotEmpty(combinedAttributes)) ||
- ( MapUtils.isNotEmpty(existingAttributes) && !combinedAttributes.equals(existingAttributes))) {
+ (MapUtils.isNotEmpty(existingAttributes) && !combinedAttributes.equals(existingAttributes))) {
combinedMappedToscaTemplate.put("attributes", combinedAttributes);
}
}
Map<String, Object> combinedMappedToscaTemplate) {
Map<String, Object> combinedProperties = combineEntries(newProperties, existingProperties);
if ((MapUtils.isEmpty(existingProperties) && MapUtils.isNotEmpty(combinedProperties)) ||
- (MapUtils.isNotEmpty(existingProperties) && !combinedProperties.equals(existingProperties))) {
+ (MapUtils.isNotEmpty(existingProperties) && !combinedProperties.equals(existingProperties))) {
combinedMappedToscaTemplate.put("properties", combinedProperties);
}
}
if (MapUtils.isEmpty(existingInterfaces)) {
return combinedEntries;
}
- existingInterfaces.entrySet().forEach(interfaceDef -> {
- combinedEntries.entrySet().stream().filter((interFace) -> interFace.getValue().get("type").equals(( interfaceDef.getValue()).get("type")))
- .findFirst().ifPresentOrElse((interFace) -> {
- interFace.getValue().putAll(interfaceDef.getValue());
- }, () -> {
- combinedEntries.put(interfaceDef.getKey(), interfaceDef.getValue());
- });
+ existingInterfaces.entrySet().forEach(interfaceDef -> {
+ combinedEntries.entrySet().stream().filter((interFace) -> interFace.getValue().get("type").equals((interfaceDef.getValue()).get("type")))
+ .findFirst().ifPresentOrElse((interFace) -> {
+ interFace.getValue().putAll(interfaceDef.getValue());
+ }, () -> {
+ combinedEntries.put(interfaceDef.getKey(), interfaceDef.getValue());
+ });
});
return combinedEntries;
}
- private List<Map<String, Object>> combineAdditionalRequirements(List<Map<String, Object>> newReqs, List<Map<String, Object>> existingResourceReqs) {
- if (CollectionUtils.isEmpty(newReqs)) {
- newReqs = new ArrayList<>();
+ private List<Map<String, Object>> combineAdditionalRequirements(List<Map<String, Object>> newReqs,
+ List<Map<String, Object>> existingResourceReqs) {
+ if (CollectionUtils.isEmpty(existingResourceReqs)) {
+ existingResourceReqs = new ArrayList<>();
}
Set<Map<String, Object>> combinedReqs = new TreeSet<>((map1, map2) ->
map1.keySet().equals(map2.keySet()) ? 0 : map1.keySet().iterator().next().compareTo(map2.keySet().iterator().next()));
protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
CsarInfo csarInfo,
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
- boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
+ Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
+ boolean shouldLock, boolean inTransaction, String nodeName, final String userId,
+ AuditingActionEnum auditingAction)
throws BusinessLogicException {
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
Service createdService;
csfyp.setNodeTypesInfo(nodeTypesInfo);
csfyp.setCsarInfo(csarInfo);
csfyp.setNodeName(nodeName);
- createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
+ createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId,
+ auditingAction);
log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
} catch (ComponentException | BusinessLogicException e) {
log.debug("Create Service from yaml failed", e);
}
protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
+ Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
- final String userId)
+ final String userId, AuditingActionEnum auditingAction)
throws BusinessLogicException {
+
List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
String yamlName = csfyp.getYamlName();
ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
if (shouldLock) {
Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
if (lockResult.isRight()) {
- serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
throw new ComponentException(lockResult.right().value());
}
log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
service.setProperties(propertiesList);
}
log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
- service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
+ service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative, auditingAction);
log.trace("************* Going to add inputs from yaml {}", yamlName);
Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
service = serviceImportParseLogic.createInputsOnService(service, inputs);
log.trace("************* Finished to add inputs from yaml {}", yamlName);
- ListDataDefinition<SubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
+ ListDataDefinition<SubstitutionFilterPropertyDataDefinition> substitutionFilterProperties =
+ parsedToscaYamlInfo.getSubstitutionFilterProperties();
service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
= groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
if (validateUpdateVfGroupNamesRes.isRight()) {
- serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
}
Map<String, GroupDefinition> groups;
}
Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
if (createGroupsOnResource.isRight()) {
- serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
throw new ComponentException(createGroupsOnResource.right().value());
}
service = createGroupsOnResource.left().value();
Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
if (createPoliciesOnResource.isRight()) {
- serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
throw new ComponentException(createPoliciesOnResource.right().value());
}
service = createPoliciesOnResource.left().value();
log.trace("************* Going to add artifacts from yaml {}", yamlName);
- NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
- createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
+ createdArtifacts, yamlName, csarInfo, service, inTransaction, shouldLock);
if (createArtifactsEither.isRight()) {
- serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
throw new ComponentException(createArtifactsEither.right().value());
}
service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
- service = updateInputs(service, userId);
+ service = updateInputs(service, userId, parsedToscaYamlInfo.getSubstitutionMappingProperties());
ASDCKpiApi.countCreatedResourcesKPI();
return service;
- } catch (ComponentException | StorageException | BusinessLogicException e) {
+ } catch (Exception e) {
rollback = true;
serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
throw e;
}
}
if (shouldLock) {
- graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
+ graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service);
}
}
}
- private Service updateInputs(final Service component, final String userId) {
+ private Service updateInputs(final Service component, final String userId, final Map<String, List<String>> substitutionMappingProperties) {
final List<InputDefinition> inputs = component.getInputs();
- final List<ComponentInstance> componentInstances = component.getComponentInstances();
- final String componentUniqueId = component.getUniqueId();
- final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
- for (final InputDefinition input : inputs) {
- if (isInputFromComponentInstanceProperty(input.getName(), componentInstances, componentInstancesProperties)) {
- associateInputToComponentInstanceProperty(userId, input, componentInstances, componentInstancesProperties,
- componentUniqueId);
- } else {
- associateInputToServiceProperty(userId, input, component);
+ if (CollectionUtils.isNotEmpty(inputs)) {
+ final List<ComponentInstance> componentInstances = component.getComponentInstances();
+ final String componentUniqueId = component.getUniqueId();
+ List<String> propertyMissingNames = new ArrayList<>();
+ for (final InputDefinition input : inputs) {
+ boolean isSubMapProp = false;
+ if (substitutionMappingProperties != null && !substitutionMappingProperties.isEmpty()) {
+ isSubMapProp = substitutionMappingProperties.entrySet().stream()
+ .anyMatch(stringEntry -> stringEntry.getValue().get(0).equals(input.getName()));
+ }
+ if (!isSubMapProp && isInputFromComponentInstanceProperty(input.getName(), componentInstances)) {
+ associateInputToComponentInstanceProperty(userId, input, componentInstances, componentUniqueId);
+ } else {
+ String propertyName = associateInputToServiceProperty(userId, input, component, substitutionMappingProperties);
+ if (StringUtils.isNotBlank(propertyName)) {
+ propertyMissingNames.add(propertyName);
+ }
+ }
+ }
+ if (CollectionUtils.isNotEmpty(propertyMissingNames)) {
+ throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.MISSING_PROPERTIES_ERROR, propertyMissingNames.toString()));
+ }
+ Either<List<InputDefinition>, StorageOperationStatus> either = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
+ if (either.isRight()) {
+ throw new ComponentException(ActionStatus.GENERAL_ERROR);
}
-
- }
-
- final Either<List<InputDefinition>, StorageOperationStatus> either
- = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
- if (either.isRight()) {
- throw new ComponentException(ActionStatus.GENERAL_ERROR);
}
return component;
}
- private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances,
- final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties) {
+ private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances) {
+
+ AtomicBoolean isInputFromCIProp = new AtomicBoolean(false);
if (CollectionUtils.isNotEmpty(componentInstances)) {
- // get instance's names
- final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
- .collect(toList());
- final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
- .filter(cin -> inputName.startsWith(cin + "_")).findFirst();
- if (componentInstancesNameOptional.isPresent() && MapUtils.isNotEmpty(componentInstancesProperties)) {
- final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
- .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
- if (componentInstanceIdOptional.isPresent()) {
- // get property's name
- final String propertyNameFromInput = extractPropertyNameFromInputName(inputName, componentInstancesNames);
- return componentInstancesProperties.get(componentInstanceIdOptional.get()).stream()
- .anyMatch(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
- && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName()));
+ outer:
+ for (ComponentInstance instance : componentInstances) {
+ for (PropertyDefinition instanceProperty : instance.getProperties()) {
+ if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) {
+ for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) {
+ if (inputName.equals(getInputValueDataDefinition.getInputName())) {
+ isInputFromCIProp.set(true);
+ break outer;
+ }
+ }
+ }
}
}
}
- return false;
+ return isInputFromCIProp.get();
}
private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input,
final List<ComponentInstance> componentInstances,
- final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties,
String componentUniqueId) {
- // From Instance
- final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
- .collect(toList());
- final String propertyNameFromInput = extractPropertyNameFromInputName(input.getName(), componentInstancesNames);
- final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
- .filter(cin -> input.getName().startsWith(cin + "_")).findFirst();
-
- final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
- .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
-
- final String componentInstanceId = componentInstanceIdOptional.get();
- final List<ComponentInstanceProperty> componentInstanceProperties = componentInstancesProperties.get(componentInstanceId);
+ String componentInstanceId = null;
+ ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
+
+ outer:
+ for (ComponentInstance instance : componentInstances) {
+ for (PropertyDefinition instanceProperty : instance.getProperties()) {
+ if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) {
+ for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) {
+ if (input.getName().equals(getInputValueDataDefinition.getInputName())) {
+ componentInstanceId = instance.getUniqueId();
+ componentInstanceProperty = new ComponentInstanceProperty(instanceProperty);
+ break outer;
+ }
+ }
+ }
+ }
+ }
- final ComponentInstanceProperty componentInstanceProperty = componentInstanceProperties.stream()
- .filter(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
- && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName())).findFirst().get();
+ //unmapping instance property declared inputs from substitution mapping
+ input.setMappedToComponentProperty(false);
// From Instance
updateInput(input, componentInstanceProperty, userId, componentInstanceId);
}
}
- private void associateInputToServiceProperty(final String userId,
- final InputDefinition input, final Service component) {
+ private String associateInputToServiceProperty(final String userId,
+ final InputDefinition input, final Service component,
+ final Map<String, List<String>> substitutionMappingProperties) {
final List<PropertyDefinition> properties = component.getProperties();
- if (CollectionUtils.isNotEmpty(properties)) {
- final String propertyNameFromInput = input.getName();
- final Optional<PropertyDefinition> propDefOptional = properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput))
- .findFirst();
+ if (CollectionUtils.isNotEmpty(properties) && MapUtils.isNotEmpty(substitutionMappingProperties)) {
+ AtomicReference<String> propertyNameFromInput = new AtomicReference<>(" ");
+ substitutionMappingProperties.entrySet().forEach(stringEntry -> {
+ if (stringEntry.getValue().get(0).equals(input.getName())) {
+ propertyNameFromInput.set(stringEntry.getKey());
+ }
+ });
+
+ final Optional<PropertyDefinition> propDefOptional =
+ properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput.get()))
+ .findFirst();
if (propDefOptional.isPresent()) {
// From SELF
final String componentUniqueId = component.getUniqueId();
if (either.isRight()) {
throw new ComponentException(ActionStatus.GENERAL_ERROR);
}
+ } else {
+ input.setMappedToComponentProperty(false);
+ return propertyNameFromInput.get();
}
}
+ return "";
}
private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) {
input.setParentPropertyType(propertyDefinition.getType());
}
- private String extractPropertyNameFromInputName(final String inputName, final List<String> componentInstancesNames) {
- final AtomicReference<String> result = new AtomicReference<>(inputName);
- componentInstancesNames.forEach(cin -> result.set(result.get().replace(cin + "_", "")));
- return result.get();
- }
-
protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
List<ArtifactDefinition> createdArtifacts, String yamlFileName,
CsarInfo csarInfo, Resource preparedResource,
boolean inTransaction, boolean shouldLock) {
String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
Resource resource = preparedResource;
- Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
- .getNodeTypesArtifactsToHandle();
+ Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle =
+ nodeTypeInfoToUpdateArtifacts
+ .getNodeTypesArtifactsToHandle();
if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
} else {
- Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
+ Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
+ findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
if (findVfCsarArtifactsToHandleRes.isRight()) {
resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
String yamlFileName, CsarInfo csarInfo, Service preparedService,
- NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
boolean inTransaction, boolean shouldLock) {
Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
ArtifactsBusinessLogic.ArtifactOperationEnum.class);
Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
- Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
+ Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
+ nodeTypeArtifactsToHandleRes = Either
.left(nodeTypeArtifactsToHandle);
try {
List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
if (MapUtils.isEmpty(policies)) {
return Either.left(service);
}
- final Map<String, List<AttributeDefinition>> instanceAttributeMap =
- service.getComponentInstancesAttributes()
+ Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = service.getComponentInstancesAttributes();
+ final Map<String, List<AttributeDefinition>> instanceAttributeMap = new HashMap<>();
+ if (MapUtils.isNotEmpty(componentInstancesAttributes)) {
+ instanceAttributeMap.putAll(componentInstancesAttributes
.entrySet().stream()
- .collect(
- toMap(Entry::getKey,
- entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))
- );
+ .collect(toMap(Entry::getKey, entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))));
+ }
policies.values().stream()
.map(PolicyDataDefinition::getProperties)
.flatMap(Collection::stream)
.filter(PropertyDataDefinition::isToscaFunction)
- .forEach(policyDefinition ->
- toscaFunctionService
- .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
- instanceAttributeMap)
+ .forEach(policyDefinition -> toscaFunctionService
+ .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
+ instanceAttributeMap)
);
policyBusinessLogic.createPolicies(service, policies);
return getServiceResponseFormatEither(service);
log.debug("************* Going to create all nodes {}", yamlName);
handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
nodeTypesInfo, csarInfo, nodeName);
+ List<PropertyDefinition> serviceProperties = null != service ? service.getProperties() : Collections.emptyList();
if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
log.debug("************* Going to create all resource instances {}", yamlName);
service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
log.debug("************* Going to create all relations {}", yamlName);
- service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
+ service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap, serviceProperties);
log.debug("************* Going to create positions {}", yamlName);
compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
log.debug("************* Finished to set positions {}", yamlName);
}
protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
- Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
+ Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
+ List<PropertyDefinition> serviceProperties) {
log.debug("#createResourceInstancesRelations - Going to create relations ");
List<ComponentInstance> componentInstancesList = service.getComponentInstances();
if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
final Map<String, DataTypeDefinition> allDataTypesMap =
componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
final Service service1 = service;
+ service1.setProperties(serviceProperties);
uploadResInstancesMap.values().forEach(
i -> processComponentInstance(yamlName, service1, componentInstancesList,
allDataTypesMap, instProperties,
.forEach(instanceProperty -> {
toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
updatedService, instancePropertyMap, instanceAttributeMap);
- instanceProperty.setValue(instanceProperty.getToscaFunction().getValue());
+ instanceProperty.setValue(StringEscapeUtils.unescapeJava(instanceProperty.getToscaFunction().getValue()));
})
);
}
instAttributes.put(resourceInstanceId, originResource.getAttributes());
addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
}
- if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
+ if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() == null) {
+ instNodeFilter.put(resourceInstanceId, new UploadNodeFilterInfo());
+ } else {
instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
}
if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) {
Map<String, OperationDataDefinition> operations = uploadInterfaceInfo.getOperations();
for (Map.Entry<String, OperationDataDefinition> operation : operations.entrySet()) {
- OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().get(operation.getKey());
OperationDataDefinition instanceOperation = operation.getValue();
+ OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().getOrDefault(operation.getKey(), new Operation(instanceOperation));
//Inputs
ListDataDefinition<OperationInputDefinition> instanceInputs = instanceOperation.getInputs();
- mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
- templateOperation.setInputs(instanceInputs);
+ if (null != instanceInputs) {
+ mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
+ component.getProperties()
+ .forEach(property -> instanceInputs.getListToscaDataDefinition().stream()
+ .filter(instanceInput ->
+ instanceInput.getToscaFunction() instanceof ToscaGetFunctionDataDefinition &&
+ property.getName().equals(instanceInput.getToscaFunction() != null ?
+ ((ToscaGetFunctionDataDefinition) instanceInput.getToscaFunction()).getPropertyName() : null))
+ .forEach(oldInput -> oldInput.setType(property.getType()))
+ );
+ templateOperation.setInputs(instanceInputs);
+ }
//Implementation
templateOperation.setImplementation(instanceOperation.getImplementation());
//Description
interfaceDef.setUniqueId(currentInterfaceDef.getType());
interfaceDef.setDescription(uploadInterfaceInfo.getDescription());
interfaceDef.setOperations(operationsToAdd);
- instInterfacesMap.put(interfaceName, interfaceDef);
+ instInterfacesMap.put(currentInterfaceDef.getType(), interfaceDef);
currInterfacesMap.remove(interfaceName);
}
}
if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
}
- Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
+ Resource refResource =
+ validateResourceInstanceBeforeCreate(yamlName, component.getModel(), uploadComponentInstanceInfo, existingnodeTypeMap);
ComponentInstance componentInstance = new ComponentInstance();
componentInstance.setComponentUid(refResource.getUniqueId());
Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
componentInstance.setName(uploadComponentInstanceInfo.getName());
componentInstance.setIcon(origResource.getIcon());
+ componentInstance.setMinOccurrences(uploadComponentInstanceInfo.getMinOccurrences());
+ componentInstance.setMaxOccurrences(uploadComponentInstanceInfo.getMaxOccurrences());
+ componentInstance.setInstanceCount(uploadComponentInstanceInfo.getInstanceCount());
resourcesInstancesMap.put(componentInstance, origResource);
- } catch (Exception e) {
+ } catch (final ComponentException e) {
+ throw e;
+ } catch (final Exception e) {
throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
}
}
- protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
+ protected Resource validateResourceInstanceBeforeCreate(String yamlName, String model, UploadComponentInstanceInfo uploadComponentInstanceInfo,
Map<String, Resource> nodeNamespaceMap) {
Resource refResource;
try {
if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
} else {
- Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
- .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
- if (findResourceEither.isRight()) {
+ final Either<Component, StorageOperationStatus> resourceEither =
+ toscaOperationFacade.getLatestByToscaResourceName(uploadComponentInstanceInfo.getType(), model);
+ if (resourceEither.isRight()) {
ResponseFormat responseFormat = componentsUtils
- .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(resourceEither.right().value()));
throw new ComponentException(responseFormat);
}
- refResource = findResourceEither.left().value();
+ refResource = (Resource) resourceEither.left().value();
nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
}
String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
throw new ComponentException(responseFormat);
}
return refResource;
- } catch (Exception e) {
+ } catch (final ComponentException e) {
+ throw e;
+ } catch (final Exception e) {
throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
}
}