message: "Error: Uploaded YAML file is invalid.\n%1",
messageId: "SVC4010"
}
+
+ #---------SVC4019-----------------------------
+ # %1 - metadata property name
+ UNCHANGEABLE_PROPERTY_ERROR: {
+ code: 402,
+ message: "Error: '%1' cannot change",
+ messageId: "SVC4019"
+ }
+
+ #---------SVC4020-----------------------------
+ MISSING_SERVICE_METADATA: {
+ code: 402,
+ message: "Error: Missing metadata in Service",
+ messageId: "SVC4020"
+ }
message: "Error: Uploaded YAML file is invalid.\n%1",
messageId: "SVC4010"
}
+
+ #---------SVC4019-----------------------------
+ # %1 - metadata property name
+ UNCHANGEABLE_PROPERTY_ERROR: {
+ code: 402,
+ message: "Error: '%1' cannot change",
+ messageId: "SVC4019"
+ }
+
+ #---------SVC4020-----------------------------
+ MISSING_SERVICE_METADATA: {
+ code: 402,
+ message: "Error: Missing metadata in Service",
+ messageId: "SVC4020"
+ }
}
public void validateCsarBeforeCreate(Service resource, String csarUUID) {
- // check if VF with the same Csar UUID or with he same name already
-
- // exists
+ // check if VF with the same Csar UUID or with he same name already exists
StorageOperationStatus status = toscaOperationFacade.validateCsarUuidUniqueness(csarUUID);
log.debug("enter validateCsarBeforeCreate,get status:{}", status);
if (status == StorageOperationStatus.ENTITY_ALREADY_EXISTS) {
}
}
- public OnboardedCsarInfo getCsarInfo(Resource resource, Resource oldResource, User user, Map<String, byte[]> payload, String csarUUID) {
+ public OnboardedCsarInfo getCsarInfo(Resource resource, Resource oldResource, User user, Map<String, byte[]> payload, String csarUUID, AuditingActionEnum auditingAction) {
Map<String, byte[]> csar = payload;
if (csar == null) {
final var vendorSoftwareProduct = getCsar(resource, user);
csar = vendorSoftwareProduct.getFileMap();
}
- ImmutablePair<String, String> toscaYamlCsarStatus = validateAndParseCsar(resource, user, csar, csarUUID).left()
+ ImmutablePair<String, String> toscaYamlCsarStatus = validateAndParseCsar(resource, user, csar, csarUUID, auditingAction).left()
.on(this::throwComponentException);
String checksum = CsarValidationUtils.getToscaYamlChecksum(csar, csarUUID, componentsUtils).left()
.on(r -> logAndThrowComponentException(r, "Failed to calculate checksum for casrUUID {} error {} ", csarUUID));
}
}
- public ServiceCsarInfo getCsarInfo(Service service, Service oldResource, User user, Map<String, byte[]> payload, String csarUUID) {
+ public ServiceCsarInfo getCsarInfo(Service service, Service oldResource, User user, Map<String, byte[]> payload, String csarUUID, AuditingActionEnum auditingAction) {
Map<String, byte[]> csar = getCsar(service, user, payload, csarUUID);
- ImmutablePair<String, String> toscaYamlCsarStatus = validateAndParseCsar(service, user, csar, csarUUID).left()
+ ImmutablePair<String, String> toscaYamlCsarStatus = validateAndParseCsar(service, user, csar, csarUUID, auditingAction).left()
.on(this::throwComponentException);
String checksum = CsarValidationUtils.getToscaYamlChecksum(csar, csarUUID, componentsUtils).left()
.on(r -> logAndThrowComponentException(r, "Failed to calculate checksum for casrUUID {} error {} ", csarUUID));
}
private Either<ImmutablePair<String, String>, ResponseFormat> validateAndParseCsar(Component component, User user, Map<String, byte[]> csar,
- String csarUUID) {
+ String csarUUID, AuditingActionEnum auditingAction) {
Either<Boolean, ResponseFormat> validateCsarStatus = CsarValidationUtils.validateCsar(csar, csarUUID, componentsUtils);
if (validateCsarStatus.isRight()) {
ResponseFormat responseFormat = validateCsarStatus.right().value();
}
return Either.right(responseFormat);
}
- Either<ImmutablePair<String, String>, ResponseFormat> toscaYamlCsarStatus = CsarValidationUtils.getToscaYaml(csar, csarUUID, componentsUtils);
+ Either<ImmutablePair<String, String>, ResponseFormat> toscaYamlCsarStatus = CsarValidationUtils.getToscaYaml(csar, csarUUID, componentsUtils, auditingAction);
if (toscaYamlCsarStatus.isRight()) {
ResponseFormat responseFormat = toscaYamlCsarStatus.right().value();
log.debug("Error when try to get csar toscayamlFile with csar ID {}, error: {}", csarUUID, responseFormat);
}
private Either<ImmutablePair<String, String>, ResponseFormat> validateAndParseCsar(Service service, User user, Map<String, byte[]> payload,
- String csarUUID) {
+ String csarUUID, AuditingActionEnum auditingAction) {
Map<String, byte[]> csar = getCsar(service, user, payload, csarUUID);
Either<Boolean, ResponseFormat> validateCsarStatus = CsarValidationUtils.validateCsar(csar, csarUUID, componentsUtils);
if (validateCsarStatus.isRight()) {
BeEcompErrorManager.getInstance().logBeDaoSystemError(CREATING_RESOURCE_FROM_CSAR_FETCHING_CSAR_WITH_ID + csarUUID + FAILED);
return Either.right(responseFormat);
}
- Either<ImmutablePair<String, String>, ResponseFormat> toscaYamlCsarStatus = CsarValidationUtils.getToscaYaml(csar, csarUUID, componentsUtils);
+ Either<ImmutablePair<String, String>, ResponseFormat> toscaYamlCsarStatus = CsarValidationUtils.getToscaYaml(csar, csarUUID, componentsUtils, auditingAction);
if (toscaYamlCsarStatus.isRight()) {
ResponseFormat responseFormat = toscaYamlCsarStatus.right().value();
log.debug("Error when try to get csar toscayamlFile with csar ID {}, error: {}", csarUUID, responseFormat);
return getTypes(ToscaTagNamesEnum.CAPABILITY_TYPES);
}
- private Map<String, Object> getTypes(ToscaTagNamesEnum toscaTag) {
- final Map<String, Object> types = new HashMap<>();
- mainTemplateImports.entrySet().forEach(entry -> types.putAll(getTypesFromTemplate(entry.getValue(), toscaTag)));
- types.putAll(getTypesFromTemplate(getMappedToscaMainTemplate(), toscaTag));
- return types;
- }
-
+ @Override
public Map<String, Object> getArtifactTypes() {
- final Map<String, Object> artifactsTypes = new HashMap<>();
- mainTemplateImports.entrySet()
- .forEach(entry -> artifactsTypes.putAll(getTypesFromTemplate(entry.getValue(), TypeUtils.ToscaTagNamesEnum.ARTIFACT_TYPES)));
- artifactsTypes.putAll(getTypesFromTemplate(getMappedToscaMainTemplate(), TypeUtils.ToscaTagNamesEnum.ARTIFACT_TYPES));
- return artifactsTypes;
+ return getTypes(ToscaTagNamesEnum.ARTIFACT_TYPES);
}
@Override
return getTypes(ToscaTagNamesEnum.INTERFACE_TYPES);
}
+ private Map<String, Object> getTypes(ToscaTagNamesEnum toscaTag) {
+ final Map<String, Object> types = new HashMap<>();
+ mainTemplateImports.entrySet().forEach(entry -> types.putAll(getTypesFromTemplate(entry.getValue(), toscaTag)));
+ types.putAll(getTypesFromTemplate(getMappedToscaMainTemplate(), toscaTag));
+ return types;
+ }
+
public List<NodeTypeDefinition> getNodeTypesUsed() {
if (nodeTypeDefinitions == null) {
nodeTypeDefinitions = new ArrayList<>();
return nodeTypesToReturn;
}
-
private Map<String, NodeTypeDefinition> getTypes(final Set<String> nodeTypes) {
final Map<String, NodeTypeDefinition> nodeTypeDefinitionsMap = new HashMap<>();
final Set<String> lowerPrecedenceImports = new HashSet<>();
return nodeTypeDefinitionsMap;
}
-
private void addTypesFromTemplate(final Map<String, NodeTypeDefinition> nodeTypeDefinitionsMap, final Map<String, Object> mappedTemplate,
final Set<String> nodeTypes) {
final Map<String, Object> types = getTypesFromTemplate(mappedTemplate, ToscaTagNamesEnum.NODE_TYPES, nodeTypes);
Map<String, Object> substitutionMappings = getSubstitutionMappings(mappedToscaTemplate);
if (substitutionMappings != null) {
if (component.isService()) {
- if (!interfaceTemplateYaml.isEmpty()) {
- parsedToscaYamlInfo.setProperties(getProperties(loadYamlAsStrictMap(interfaceTemplateYaml)));
- parsedToscaYamlInfo.setSubstitutionFilterProperties(getSubstitutionFilterProperties(mappedToscaTemplate));
- } else {
+ if (interfaceTemplateYaml.isEmpty()) {
Resource resource = serviceBusinessLogic.fetchDerivedFromGenericType(component, null);
List<PropertyDefinition> properties = resource.getProperties();
parsedToscaYamlInfo.setProperties(properties.stream().collect(Collectors.toMap(PropertyDefinition::getName, prop -> prop)));
parsedToscaYamlInfo.setSubstitutionFilterProperties(getSubstitutionFilterProperties(mappedToscaTemplate));
+ } else {
+ parsedToscaYamlInfo.setProperties(getProperties(loadYamlAsStrictMap(interfaceTemplateYaml)));
+ parsedToscaYamlInfo.setSubstitutionFilterProperties(getSubstitutionFilterProperties(mappedToscaTemplate));
}
}
if (substitutionMappings.get("properties") != null) {
import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.be.tosca.CsarUtils;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.common.util.GeneralUtility;
}
public static Either<ImmutablePair<String, String>, ResponseFormat> getToscaYaml(Map<String, byte[]> csar, String csarUUID,
- ComponentsUtils componentsUtils) {
- Either<Boolean, ResponseFormat> validateStatus = validateIsTOSCAMetadataExist(csar, csarUUID, componentsUtils);
- if (validateStatus.isRight()) {
- return Either.right(validateStatus.right().value());
+ ComponentsUtils componentsUtils, AuditingActionEnum auditingAction) {
+ if (!AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction)) {
+ Either<Boolean, ResponseFormat> validateStatus = validateIsTOSCAMetadataExist(csar, csarUUID, componentsUtils);
+ if (validateStatus.isRight()) {
+ return Either.right(validateStatus.right().value());
+ }
}
Pattern pattern = Pattern.compile(TOSCA_METADATA_PATH_PATTERN);
Optional<String> keyOp = csar.keySet().stream().filter(k -> pattern.matcher(k).matches()).findAny();
if (!keyOp.isPresent()) {
log.debug(TOSCA_METADATA_TOSCA_META_FILE_IS_NOT_IN_EXPECTED_KEY_VALUE_FORM_IN_CSAR_CSAR_ID, csarUUID);
BeEcompErrorManager.getInstance()
- .logInternalDataError(TOSCA_METADATA_TOSCA_META_FILE_NOT_IN_EXPECTED_KEY_VALUE_FORM_IN_CSAR_WITH_ID + csarUUID,
- CSAR_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
+ .logInternalDataError(TOSCA_METADATA_TOSCA_META_FILE_NOT_IN_EXPECTED_KEY_VALUE_FORM_IN_CSAR_WITH_ID + csarUUID,
+ CSAR_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, csarUUID));
}
byte[] toscaMetaBytes = csar.get(keyOp.get());
} catch (IOException e) {
log.debug(TOSCA_METADATA_TOSCA_META_FILE_IS_NOT_IN_EXPECTED_KEY_VALUE_FORM_IN_CSAR_CSAR_ID, csarUUID, e);
BeEcompErrorManager.getInstance()
- .logInternalDataError(TOSCA_METADATA_TOSCA_META_FILE_NOT_IN_EXPECTED_KEY_VALUE_FORM_IN_CSAR_WITH_ID + csarUUID,
- CSAR_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
+ .logInternalDataError(TOSCA_METADATA_TOSCA_META_FILE_NOT_IN_EXPECTED_KEY_VALUE_FORM_IN_CSAR_WITH_ID + csarUUID,
+ CSAR_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.CSAR_INVALID_FORMAT, csarUUID));
}
String yamlFileName = props.getProperty(TOSCA_META_ENTRY_DEFINITIONS);
if (!keyOp.isPresent()) {
log.debug(ENTRY_DEFINITIONS_ENTRY_NOT_FOUND_IN_TOSCA_METADATA_TOSCA_META_FILE_CSAR_ID, csarUUID);
BeEcompErrorManager.getInstance()
- .logInternalDataError(ENTRY_DEFINITIONS_ENTRY_NOT_FOUND_IN_TOSCA_METADATA_TOSCA_META_FILE_CSAR_ID + csarUUID,
- CSAR_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
+ .logInternalDataError(ENTRY_DEFINITIONS_ENTRY_NOT_FOUND_IN_TOSCA_METADATA_TOSCA_META_FILE_CSAR_ID + csarUUID,
+ CSAR_INTERNALS_ARE_INVALID, ErrorSeverity.ERROR);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.YAML_NOT_FOUND_IN_CSAR, csarUUID, yamlFileName));
}
log.trace("Found Entry-Definitions property in TOSCA-Metadata/TOSCA.meta, Entry-Definitions: {}, CSAR id: {}", yamlFileName, csarUUID);
if (yamlFileBytes == null) {
log.debug("Entry-Definitions {} file not found in csar, csar ID {}", yamlFileName, csarUUID);
BeEcompErrorManager.getInstance()
- .logInternalDataError(ENTRY_DEFINITIONS + yamlFileName + FILE_NOT_FOUND_IN_CSAR_WITH_ID + csarUUID, CSAR_STRUCTURE_IS_INVALID,
- ErrorSeverity.ERROR);
+ .logInternalDataError(ENTRY_DEFINITIONS + yamlFileName + FILE_NOT_FOUND_IN_CSAR_WITH_ID + csarUUID, CSAR_STRUCTURE_IS_INVALID,
+ ErrorSeverity.ERROR);
return Either.right(componentsUtils.getResponseFormat(ActionStatus.YAML_NOT_FOUND_IN_CSAR, csarUUID, yamlFileName));
}
String yamlFileContents = new String(yamlFileBytes);
}
public static Either<String, ResponseFormat> getToscaYamlChecksum(Map<String, byte[]> csar, String csarUUID, ComponentsUtils componentsUtils) {
- Either<ImmutablePair<String, String>, ResponseFormat> toscaYamlRes = getToscaYaml(csar, csarUUID, componentsUtils);
+ Either<ImmutablePair<String, String>, ResponseFormat> toscaYamlRes = getToscaYaml(csar, csarUUID, componentsUtils, AuditingActionEnum.GET_TOSCA_MODEL);
if (toscaYamlRes.isRight() || toscaYamlRes.left().value() == null || toscaYamlRes.left().value().getRight() == null) {
log.debug("Faild to create toscaYamlChecksum for csar, csar ID {}", csarUUID);
return Either.right(toscaYamlRes.right().value());
validateLifecycleState(oldResource, user);
String lockedResourceId = oldResource.getUniqueId();
List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
- CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(newResource, oldResource, user, csarUIPayload, csarUUID);
+ CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(newResource, oldResource, user, csarUIPayload, csarUUID, null);
lockComponent(lockedResourceId, oldResource, "update Resource From Csar");
Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle(
loggerSupportability
.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML, StatusCode.STARTED, "Starting to create Resource From Csar by user {}",
user.getUserId());
- OnboardedCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, csarUIPayload, csarUUID);
+ OnboardedCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, csarUIPayload, csarUUID, null);
Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
final String model = resource.getModel();
}
}
- public ImmutablePair<Resource, ActionStatus> importNormativeResourceFromCsar(String resourceYml, UploadResourceInfo resourceMetaData,
- User creator, boolean createNewVersion, boolean needLock) {
- LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction();
- lifecycleChangeInfo.setUserRemarks("certification on import");
- Function<Resource, Boolean> validator = resource -> resourceBusinessLogic.validatePropertiesDefaultValues(resource);
- return importCertifiedResource(resourceYml, resourceMetaData, creator, validator, lifecycleChangeInfo, false, createNewVersion, needLock,
- null, null, false, null, null, false);
- }
-
public ImmutablePair<Resource, ActionStatus> importCertifiedResource(String resourceYml, UploadResourceInfo resourceMetaData, User creator,
Function<Resource, Boolean> validationFunction,
LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean isInTransaction,
import java.util.stream.Collectors;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
-
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
ComponentDescriptionValidator componentDescriptionValidator, ModelOperation modelOperation,
final ServiceRoleValidator serviceRoleValidator,
final ServiceInstantiationTypeValidator serviceInstantiationTypeValidator,
- final ServiceCategoryValidator serviceCategoryValidator, final ServiceValidator serviceValidator, KafkaHandler kafkaHandler) {
+ final ServiceCategoryValidator serviceCategoryValidator, final ServiceValidator serviceValidator,
+ KafkaHandler kafkaHandler) {
super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic, interfaceOperation,
interfaceLifecycleTypeOperation, artifactsBusinessLogic, artifactToscaOperation, componentContactIdValidator, componentNameValidator,
componentTagsValidator, componentValidator, componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
componentsUtils.auditComponentAdmin(responseFormat, user, service, AuditingActionEnum.CREATE_SERVICE, ComponentTypeEnum.SERVICE);
throw exp;
}
- service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
- service.setContactId(service.getContactId().toLowerCase());
- // Generate invariant UUID - must be here and not in operation since it
-
- // should stay constant during clone
- String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
- service.setInvariantUUID(invariantUUID);
+ if (!AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(actionEnum) &&
+ !AuditingActionEnum.UPDATE_SERVICE_TOSCA_MODEL.equals(actionEnum)) {
+ service.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
+ service.setContactId(service.getContactId().toLowerCase());
+ // Generate invariant UUID - must be here and not in operation since it should stay constant during clone
+ service.setInvariantUUID(UniqueIdBuilder.buildInvariantUUID());
+ }
return Either.left(service);
}
}
private void addInputsToService(Service currentService, List<PropertyDefinition> subNodePropsToBeAdded) {
- ListUtils.emptyIfNull(subNodePropsToBeAdded).forEach(prop -> {
- InputDefinition inputDef = new InputDefinition(prop);
- Either<InputDefinition, StorageOperationStatus> status =
- toscaOperationFacade.addInputToComponent(prop.getName(), inputDef, currentService);
- if (status.isRight()) {
- throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
- }
- });
+ ListUtils.emptyIfNull(subNodePropsToBeAdded).forEach(prop -> {
+ InputDefinition inputDef = new InputDefinition(prop);
+ Either<InputDefinition, StorageOperationStatus> status =
+ toscaOperationFacade.addInputToComponent(prop.getName(), inputDef, currentService);
+ if (status.isRight()) {
+ throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
+ }
+ });
}
private void removePropertiesFromService(Service currentService, List<String> subNodePropsToBeRemoved) {
if (!StringUtils.equals(currentService.getDerivedFromGenericType(), serviceUpdate.getDerivedFromGenericType())) {
return currentProps.stream().map(PropertyDefinition::getName).collect(Collectors.toList());
}
-
+
Map<String, PropertyDefinition> currentPropsMap = currentProps.stream().collect(Collectors.toMap(prop -> prop.getName(), prop -> prop));
Map<String, PropertyDefinition> updatedPropsMap = updatedProps.stream().collect(Collectors.toMap(prop -> prop.getName(), prop -> prop));
List<String> propNamesToBeRemoved = new ArrayList<>();
- for (String currentPropertyName: currentPropsMap.keySet()) {
+ for (String currentPropertyName : currentPropsMap.keySet()) {
if (updatedPropsMap.containsKey(currentPropertyName)) {
if (!haveSameType(currentPropsMap.get(currentPropertyName), updatedPropsMap.get(currentPropertyName))) {
propNamesToBeRemoved.add(currentPropertyName);
- }
+ }
} else {
propNamesToBeRemoved.add(currentPropertyName);
}
}
-
+
return propNamesToBeRemoved;
}
-
- private boolean haveSameType(final PropertyDefinition property1, final PropertyDefinition property2){
+
+ private boolean haveSameType(final PropertyDefinition property1, final PropertyDefinition property2) {
if (property1.getType().equals("list")) {
return property2.getType().equals("list") && property1.getSchema().equals(property2.getSchema());
}
}
return property1.getType().equals(property2.getType());
}
-
+
private List<PropertyDefinition> getSubstitutionNodePropertiesToBeAdded(Service currentService, Service serviceUpdate) {
List<PropertyDefinition> propsInCurrentVersion = ListUtils.emptyIfNull(fetchDerivedFromGenericType(currentService, null).getProperties());
List<PropertyDefinition> propsInUpdatedVersion = ListUtils.emptyIfNull(fetchDerivedFromGenericType(serviceUpdate, null).getProperties());
if (!StringUtils.equals(currentService.getDerivedFromGenericType(), serviceUpdate.getDerivedFromGenericType())) {
return propsInUpdatedVersion;
}
-
- Map<String, PropertyDefinition> mapOfPropsInCurrentVersion = propsInCurrentVersion.stream().collect(Collectors.toMap(prop -> prop.getName(), prop -> prop));
- Map<String, PropertyDefinition> mapOfPropsInUpdatedVersion = propsInUpdatedVersion.stream().collect(Collectors.toMap(prop -> prop.getName(), prop -> prop));
-
+
+ Map<String, PropertyDefinition> mapOfPropsInCurrentVersion = propsInCurrentVersion.stream()
+ .collect(Collectors.toMap(prop -> prop.getName(), prop -> prop));
+ Map<String, PropertyDefinition> mapOfPropsInUpdatedVersion = propsInUpdatedVersion.stream()
+ .collect(Collectors.toMap(prop -> prop.getName(), prop -> prop));
+
List<PropertyDefinition> propsToBeAdded = new ArrayList<>();
- for (Entry<String, PropertyDefinition> propertyInUpdatedVersion: mapOfPropsInUpdatedVersion.entrySet()) {
+ for (Entry<String, PropertyDefinition> propertyInUpdatedVersion : mapOfPropsInUpdatedVersion.entrySet()) {
if (mapOfPropsInCurrentVersion.containsKey(propertyInUpdatedVersion.getKey())) {
if (!haveSameType(mapOfPropsInCurrentVersion.get(propertyInUpdatedVersion.getKey()), propertyInUpdatedVersion.getValue())) {
propsToBeAdded.add(propertyInUpdatedVersion.getValue());
- }
+ }
} else {
propsToBeAdded.add(propertyInUpdatedVersion.getValue());
}
}
-
+
return propsToBeAdded;
}
if (serviceRes.isRight()) {
log.debug("failed retrieving service");
response = componentsUtils
- .getResponseFormat(componentsUtils.convertFromStorageResponse(serviceRes.right().value(), ComponentTypeEnum.SERVICE), serviceId);
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(serviceRes.right().value(), ComponentTypeEnum.SERVICE), serviceId);
componentsUtils.auditComponent(response, user, null, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
- new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()), ResourceVersionInfo.newBuilder().build(), did);
+ new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()), ResourceVersionInfo.newBuilder().build(), did);
return Either.right(response);
}
Service service = serviceRes.left().value();
if (service.getLifecycleState() != LifecycleStateEnum.CERTIFIED) {
log.info("service {} is not available for distribution. Should be in certified state", service.getUniqueId());
ResponseFormat responseFormat = componentsUtils
- .getResponseFormat(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, service.getVersion(), service.getName());
+ .getResponseFormat(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, service.getVersion(), service.getName());
return Either.right(responseFormat);
}
String dcurrStatus = service.getDistributionStatus().name();
ActionStatus notifyServiceResponse = distributionEngine.notifyService(did, service, notificationData, envName, user);
if (notifyServiceResponse == ActionStatus.OK) {
Either<Service, ResponseFormat> updateStateRes = updateDistributionStatusForActivation(service, user,
- DistributionStatusEnum.DISTRIBUTED);
+ DistributionStatusEnum.DISTRIBUTED);
if (updateStateRes.isLeft() && updateStateRes.left().value() != null) {
updatedService = updateStateRes.left().value();
updatedStatus = updatedService.getDistributionStatus().name();
}
} else {
response = componentsUtils
- .getResponseFormatByDE(componentsUtils.convertFromStorageResponse(readyForDistribution, ComponentTypeEnum.SERVICE), envName);
+ .getResponseFormatByDE(componentsUtils.convertFromStorageResponse(readyForDistribution, ComponentTypeEnum.SERVICE), envName);
result = Either.right(response);
}
componentsUtils.auditComponent(response, user, service, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
- new ResourceCommonInfo(service.getName(), ComponentTypeEnum.SERVICE.getValue()),
- ResourceVersionInfo.newBuilder().distributionStatus(dcurrStatus).build(),
- ResourceVersionInfo.newBuilder().distributionStatus(updatedStatus).build(), null, null, did);
+ new ResourceCommonInfo(service.getName(), ComponentTypeEnum.SERVICE.getValue()),
+ ResourceVersionInfo.newBuilder().distributionStatus(dcurrStatus).build(),
+ ResourceVersionInfo.newBuilder().distributionStatus(updatedStatus).build(), null, null, did);
return result;
}
return toscaOperationFacade.getLatestByServiceName(serviceName).isLeft();
}
- public void updateService(Service service, Map<String, Object> map) {
- }
-
interface ArtifactGenerator<CallVal> extends Callable<Either<CallVal, ResponseFormat>> {
}
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toMap;
import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.apache.hc.core5.http.HttpStatus.SC_BAD_REQUEST;
import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import fj.data.Either;
+import java.io.IOException;
+import java.io.InputStream;
+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.concurrent.atomic.AtomicReference;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
+import javax.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.janusgraph.core.JanusGraph;
+import org.janusgraph.core.JanusGraphTransaction;
import org.json.simple.JSONObject;
import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
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.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;
import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.common.util.ValidationUtils;
+import org.openecomp.sdc.common.zip.ZipUtils;
+import org.openecomp.sdc.common.zip.exception.ZipException;
import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.beans.factory.annotation.Autowired;
import org.yaml.snakeyaml.Yaml;
private final CapabilityTypeImportManager capabilityTypeImportManager;
private final CapabilityTypeOperation capabilityTypeOperation;
private ApplicationDataTypeCache applicationDataTypeCache;
- private InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
- private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
+ 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 {
- final ServiceCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
+ 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)) {
}
final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(serviceModel, csarInfo);
-
if (MapUtils.isNotEmpty(capabilityTypesToCreate)) {
capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), serviceModel, true);
}
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;
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<Artifact
sBusinessLogic.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);
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());
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);
*/
package org.openecomp.sdc.be.components.impl;
-import javax.servlet.ServletContext;
+import lombok.Getter;
import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
-import org.openecomp.sdc.be.impl.WebAppContextWrapper;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.model.UploadServiceInfo;
-import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
-import org.springframework.web.context.WebApplicationContext;
//upload Service model by Shiyong1989@hotmail.com
@Component("ServiceImportManager")
+@Getter
public class ServiceImportManager {
- private ServletContext servletContext;
- private ResponseFormatManager responseFormatManager;
- @Autowired
- private ServiceBusinessLogic serviceBusinessLogic;
- @Autowired
- private ServiceImportBusinessLogic serviceImportBusinessLogic;
+ private final ServiceBusinessLogic serviceBusinessLogic;
+ private final ServiceImportBusinessLogic serviceImportBusinessLogic;
- public ServiceImportBusinessLogic getServiceImportBusinessLogic() {
- return serviceImportBusinessLogic;
- }
-
- public void setServiceImportBusinessLogic(ServiceImportBusinessLogic serviceImportBusinessLogic) {
+ public ServiceImportManager(ServiceBusinessLogic serviceBusinessLogic, ServiceImportBusinessLogic serviceImportBusinessLogic) {
+ this.serviceBusinessLogic = serviceBusinessLogic;
this.serviceImportBusinessLogic = serviceImportBusinessLogic;
}
return serviceBusinessLogic.isServiceExist(serviceName);
}
- public ServiceBusinessLogic getServiceBusinessLogic() {
- return serviceBusinessLogic;
- }
-
- public void setServiceBusinessLogic(ServiceBusinessLogic serviceBusinessLogic) {
- this.serviceBusinessLogic = serviceBusinessLogic;
- }
-
public void populateServiceMetadata(UploadServiceInfo serviceMetaData, Service service) {
if (service != null && serviceMetaData != null) {
service.setDescription(serviceMetaData.getDescription());
service.setIcon(serviceMetaData.getServiceIconPath());
service.setServiceVendorModelNumber(serviceMetaData.getServiceVendorModelNumber());
ServiceMetadataDataDefinition serviceMetadataDataDefinition = (ServiceMetadataDataDefinition) service.getComponentMetadataDefinition()
- .getMetadataDataDefinition();
+ .getMetadataDataDefinition();
serviceMetadataDataDefinition.getServiceVendorModelNumber();
service.setServiceType(serviceMetaData.getServiceType());
service.setServiceRole(serviceMetaData.getServiceRole());
service.setNamingPolicy(serviceMetaData.getNamingPolicy());
boolean ecompGeneratedNaming = serviceMetaData.getEcompGeneratedNaming() == null
- || serviceMetaData.getEcompGeneratedNaming().equals("true");
+ || serviceMetaData.getEcompGeneratedNaming().equals("true");
service.setEcompGeneratedNaming(ecompGeneratedNaming);
service.setServiceFunction(serviceMetaData.getServiceFunction());
service.setInstantiationType(serviceMetaData.getInstantiationType());
}
}
- public synchronized void init(ServletContext servletContext) {
- if (this.servletContext == null) {
- this.servletContext = servletContext;
- responseFormatManager = ResponseFormatManager.getInstance();
- serviceBusinessLogic = getServiceBL(servletContext);
- }
- }
-
- private ServiceBusinessLogic getServiceBL(ServletContext context) {
- WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
- .getAttribute(org.openecomp.sdc.common.api.Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
- WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
- return webApplicationContext.getBean(ServiceBusinessLogic.class);
- }
}
*/
package org.openecomp.sdc.be.components.impl;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toMap;
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+
import fj.data.Either;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
import lombok.Getter;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.collections.CollectionUtils;
import org.openecomp.sdc.be.model.UploadCapInfo;
import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
import org.openecomp.sdc.be.model.UploadInfo;
-import org.openecomp.sdc.be.model.UploadInterfaceInfo;
import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
import org.openecomp.sdc.be.model.UploadPropInfo;
import org.openecomp.sdc.be.model.UploadReqInfo;
import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;
-import java.util.ArrayList;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Function;
-
-import static java.util.stream.Collectors.joining;
-import static java.util.stream.Collectors.toList;
-import static java.util.stream.Collectors.toMap;
-import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
-
@Getter
@org.springframework.stereotype.Component
public class ServiceImportParseLogic {
while (intItr.hasNext() && eitherResult.isLeft()) {
InterfaceDefinition interfaceDefinition = intItr.next();
String intType = interfaceDefinition.getUniqueId();
- Either<InterfaceDefinition, StorageOperationStatus> eitherCapTypeFound = interfaceTypeOperation.getInterface(UniqueIdBuilder.buildInterfaceTypeUid(resource.getModel(), intType));
+ Either<InterfaceDefinition, StorageOperationStatus> eitherCapTypeFound = interfaceTypeOperation.getInterface(
+ UniqueIdBuilder.buildInterfaceTypeUid(resource.getModel(), intType));
if (eitherCapTypeFound.isRight()) {
if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) {
BeEcompErrorManager.getInstance()
}
- public Service createServiceTransaction(Service service, User user, boolean isNormative) {
- // validate resource name uniqueness
- log.debug("validate resource name");
- Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
- .validateComponentNameExists(service.getName(), null, service.getComponentType());
- if (eitherValidation.isRight()) {
- log.debug("Failed to validate component name {}. Status is {}. ", service.getName(), eitherValidation.right().value());
- ResponseFormat errorResponse = componentsUtils
- .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
- throw new ComponentException(errorResponse);
- }
- if (eitherValidation.left().value()) {
- log.debug("resource with name: {}, already exists", service.getName());
- ResponseFormat errorResponse = componentsUtils
- .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), service.getName());
- throw new ComponentException(errorResponse);
+ public Service createServiceTransaction(Service service, User user, boolean isNormative, AuditingActionEnum auditingAction) {
+ if (!AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction) &&
+ !AuditingActionEnum.UPDATE_SERVICE_TOSCA_MODEL.equals(auditingAction)) {
+ // validate resource name uniqueness
+ log.debug("validate resource name");
+ Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
+ .validateComponentNameExists(service.getName(), null, service.getComponentType());
+ if (eitherValidation.isRight()) {
+ log.debug("Failed to validate component name {}. Status is {}. ", service.getName(), eitherValidation.right().value());
+ ResponseFormat errorResponse = componentsUtils
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
+ throw new ComponentException(errorResponse);
+ }
+ if (eitherValidation.left().value()) {
+ log.debug("resource with name: {}, already exists", service.getName());
+ ResponseFormat errorResponse = componentsUtils
+ .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), service.getName());
+ throw new ComponentException(errorResponse);
+ }
}
log.debug("send resource {} to dao for create", service.getName());
createArtifactsPlaceHolderData(service, user);
// enrich object
- if (!isNormative) {
+ if (!isNormative && !AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction) &&
+ !AuditingActionEnum.UPDATE_SERVICE_TOSCA_MODEL.equals(auditingAction)) {
log.debug("enrich resource with creator, version and state");
service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
service.setVersion(INITIAL_VERSION);
service.setHighestVersion(true);
}
+ if (AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction) ||
+ AuditingActionEnum.UPDATE_SERVICE_TOSCA_MODEL.equals(auditingAction)) {
+ toscaOperationFacade.deleteService(service.getInvariantUUID(), false);
+ }
return toscaOperationFacade.createToscaComponent(service).left().on(r -> throwComponentExceptionByResource(r, service));
}
}
public void associateComponentInstanceInterfacesToComponent(
- String yamlName,
- Service service,
- Map<String, Map<String, InterfaceDefinition>> instInterfaces
+ String yamlName,
+ Service service,
+ Map<String, Map<String, InterfaceDefinition>> instInterfaces
) {
if (MapUtils.isNotEmpty(instInterfaces)) {
Either<Map<String, MapInterfaceDataDefinition>, StorageOperationStatus> addInterfaceToInst =
- toscaOperationFacade
+ toscaOperationFacade
.associateComponentInstanceInterfacesToComponent(
- instInterfaces,
- service.getUniqueId()
+ instInterfaces,
+ service.getUniqueId()
);
if (addInterfaceToInst.isRight()) {
- log.error("failed to associate interfaces value of service {}, status is {}", service.getUniqueId(), addInterfaceToInst.right().value());
+ log.error("failed to associate interfaces value of service {}, status is {}", service.getUniqueId(),
+ addInterfaceToInst.right().value());
throw new ComponentException(
componentsUtils.getResponseFormat(
componentsUtils.convertFromStorageResponse(
log.debug("Component name {} has invalid format", componentName);
auditErrorAndThrow(user, component, actionEnum, ActionStatus.INVALID_COMPONENT_NAME);
}
- if (component.getComponentType().equals(ComponentTypeEnum.SERVICE)) {
+ if (component.getComponentType().equals(ComponentTypeEnum.SERVICE) &&
+ !AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(actionEnum) &&
+ !AuditingActionEnum.UPDATE_SERVICE_TOSCA_MODEL.equals(actionEnum)) {
validateComponentNameUnique(user, component, actionEnum);
}
//TODO remove assignment here
private void getAndValidateComponentCsarYaml(Map<String, byte[]> csarUIPayload, Component component, User user, String csarUUID) {
Either<ImmutablePair<String, String>, ResponseFormat> getToscaYamlRes = CsarValidationUtils
- .getToscaYaml(csarUIPayload, csarUUID, getComponentsUtils());
+ .getToscaYaml(csarUIPayload, csarUUID, getComponentsUtils(), null);
if (getToscaYamlRes.isRight()) {
ResponseFormat responseFormat = getToscaYamlRes.right().value();
log.debug("Error when try to get csar toscayamlFile with csar ID {}, error: {}", csarUUID, responseFormat);
*/
package org.openecomp.sdc.be.servlets;
+import static org.apache.hc.core5.http.HttpStatus.SC_BAD_REQUEST;
import static org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR;
import com.fasterxml.jackson.core.JsonProcessingException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
+import java.io.InputStream;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
+import javax.validation.constraints.NotNull;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
+import org.apache.commons.collections4.MapUtils;
import org.apache.http.HttpStatus;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import org.glassfish.jersey.media.multipart.FormDataParam;
+import org.keycloak.representations.AccessToken;
import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ElementBusinessLogic;
import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ResourceImportManager;
import org.openecomp.sdc.be.components.impl.ServiceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ServiceImportBusinessLogic;
import org.openecomp.sdc.be.components.impl.aaf.AafPermission;
import org.openecomp.sdc.be.components.impl.aaf.PermissionAllowed;
import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
import org.openecomp.sdc.common.zip.exception.ZipException;
import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.stereotype.Controller;
-import org.keycloak.representations.AccessToken;
+import org.yaml.snakeyaml.Yaml;
+
@Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
@Path("/v1/catalog")
@Server(url = "/sdc2/rest")
@ApiResponse(responseCode = "201", description = "Service created"), @ApiResponse(responseCode = "403", description = "Restricted operation"),
@ApiResponse(responseCode = "400", description = "Invalid content / Missing content"),
@ApiResponse(responseCode = "409", description = "Service already exist"),
- @ApiResponse(responseCode = "401", description = "Unauthorized Tenant")})
+ @ApiResponse(responseCode = "401", description = "Unauthorized Tenant")})
@PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
public Response createService(@Parameter(description = "Service object to be created", required = true) String data,
@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
throw new ByResponseFormatComponentException(actionResponse.right().value());
}
loggerSupportability.log(LoggerSupportabilityActions.CREATE_SERVICE, service.getComponentMetadataForSupportLog(), StatusCode.COMPLETE,
- "Service {} has been created by user {} ", service.getName(), userId);
+ "Service {} has been created by user {} ", service.getName(), userId);
return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), actionResponse.left().value());
} else {
log.debug("Unauthorized Tenant");
throw new ByResponseFormatComponentException(actionResponse.right().value());
}
loggerSupportability.log(LoggerSupportabilityActions.CREATE_SERVICE, service.getComponentMetadataForSupportLog(), StatusCode.COMPLETE,
- "Service {} has been created by user {} ", service.getName(), userId);
+ "Service {} has been created by user {} ", service.getName(), userId);
return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.CREATED), actionResponse.left().value());
}
}
public Either<Service, ResponseFormat> parseToService(String serviceJson, User user) {
return getComponentsUtils()
- .convertJsonToObjectUsingObjectMapper(serviceJson, user, Service.class, AuditingActionEnum.CREATE_RESOURCE, ComponentTypeEnum.SERVICE);
+ .convertJsonToObjectUsingObjectMapper(serviceJson, user, Service.class, AuditingActionEnum.CREATE_SERVICE, ComponentTypeEnum.SERVICE);
}
@GET
}
}
+
+ @PUT
+ @Path("/services/{serviceId}/toscaTemplate")
+ @Tag(name = "SDCE-2 APIs")
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Produces(MediaType.APPLICATION_JSON)
+ @Operation(description = "Update service by tosca template import", method = "PUT", summary = "Returns updated service",
+ responses = {
+ @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Service.class)))),
+ @ApiResponse(responseCode = "200", description = "Service Updated"),
+ @ApiResponse(responseCode = "403", description = "Restricted operation"),
+ @ApiResponse(responseCode = "400", description = "Invalid content / Missing content")})
+ @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE)
+ public Response importToscaTemplate(@PathParam("serviceId") final String serviceId,
+ @Parameter(description = "Service object to be Updated", required = true) final String data,
+ @Context final HttpServletRequest request,
+ @HeaderParam(value = Constants.USER_ID_HEADER) final String userId) throws IOException {
+ initSpringFromContext();
+ final String url = request.getMethod() + " " + request.getRequestURI();
+ log.debug(START_HANDLE_REQUEST_OF, url);
+ final User modifier = new User(userId);
+ log.debug(MODIFIER_ID_IS, userId);
+ try {
+ final ServiceImportBusinessLogic serviceImportBusinessLogic = serviceImportManager.getServiceImportBusinessLogic();
+ final Service updatedService = serviceImportBusinessLogic.updateServiceFromToscaTemplate(serviceId, modifier, data);
+ return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), RepresentationUtils.toRepresentation(updatedService));
+ } catch (Exception e) {
+ BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Update Service Metadata");
+ log.debug("update service metadata failed with exception", e);
+ throw e;
+ }
+ }
+
public enum Action {DELETE, MARK_AS_DELETE}
}
import com.jcabi.aspects.Loggable;
import io.swagger.v3.oas.annotations.tags.Tag;
-import io.swagger.v3.oas.annotations.tags.Tags;
-import javax.inject.Singleton;
-import javax.ws.rs.Path;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ResourceImportManager;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.impl.ServletUtils;
-import org.openecomp.sdc.common.log.wrappers.Logger;
+
+import javax.inject.Singleton;
+import javax.ws.rs.Path;
/**
* Root service (exposed at "/" path)
//upload Service model by Shiyong1989@hotmail.com
@Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
@Path("/v1/catalog/uploadservice")
-@Tags({@Tag(name = "SDCE-2 APIs")})
+@Tag(name = "SDCE-2 APIs")
@Singleton
public class ServiceUploadServlet extends AbstractValidationsServlet {
public static final String CSAR_TYPE_SERVICE = "csar";
public static final String USER_TYPE_SERVICE = "user-service";
public static final String USER_TYPE_SERVICE_UI_IMPORT = "user-servcie-ui-import";
- private static final Logger log = Logger.getLogger(ServiceUploadServlet.class);
public ServiceUploadServlet(ComponentInstanceBusinessLogic componentInstanceBL,
ComponentsUtils componentsUtils, ServletUtils servletUtils, ResourceImportManager resourceImportManager) {
super(componentInstanceBL, componentsUtils, servletUtils, resourceImportManager);
}
+ @AllArgsConstructor
+ @Getter
public enum ServiceAuthorityTypeEnum {
- NORMATIVE_TYPE_BE(NORMATIVE_TYPE_SERVICE, true, false), USER_TYPE_BE(USER_TYPE_SERVICE, true, true), USER_TYPE_UI(USER_TYPE_SERVICE_UI_IMPORT,
- false, true), CSAR_TYPE_BE(CSAR_TYPE_SERVICE, true, true);
- private String urlPath;
- private boolean isBackEndImport, isUserTypeService;
-
- private ServiceAuthorityTypeEnum(String urlPath, boolean isBackEndImport, boolean isUserTypeService) {
- this.urlPath = urlPath;
- this.isBackEndImport = isBackEndImport;
- this.isUserTypeService = isUserTypeService;
- }
-
- public static ServiceAuthorityTypeEnum findByUrlPath(String urlPath) {
- ServiceAuthorityTypeEnum found = null;
- for (ServiceAuthorityTypeEnum curr : ServiceAuthorityTypeEnum.values()) {
- if (curr.getUrlPath().equals(urlPath)) {
- found = curr;
- break;
- }
- }
- return found;
- }
-
- public String getUrlPath() {
- return urlPath;
- }
-
- public boolean isBackEndImport() {
- return isBackEndImport;
- }
+ NORMATIVE_TYPE_BE(NORMATIVE_TYPE_SERVICE, true, false),
+ USER_TYPE_BE(USER_TYPE_SERVICE, true, true),
+ USER_TYPE_UI(USER_TYPE_SERVICE_UI_IMPORT, false, true),
+ CSAR_TYPE_BE(CSAR_TYPE_SERVICE, true, true);
+ private final String urlPath;
+ private final boolean isBackEndImport;
+ private final boolean isUserTypeService;
- public boolean isUserTypeService() {
- return isUserTypeService;
- }
}
}
}
}
- private Map<String, String> convertMetadata(Component component) {
+ private Map<String, Object> convertMetadata(Component component) {
return convertMetadata(component, false, null);
}
- private Map<String, String> convertMetadata(Component component, boolean isInstance, ComponentInstance componentInstance) {
- Map<String, String> toscaMetadata = new LinkedHashMap<>();
+ private Map<String, Object> convertMetadata(Component component, boolean isInstance, ComponentInstance componentInstance) {
+ Map<String, Object> toscaMetadata = new LinkedHashMap<>();
toscaMetadata.put(convertMetadataKey(JsonPresentationFields.INVARIANT_UUID), component.getInvariantUUID());
toscaMetadata.put(JsonPresentationFields.UUID.getPresentation(), component.getUUID());
toscaMetadata
toscaMetadata.put(JsonPresentationFields.INSTANTIATION_TYPE.getPresentation(),
service.getEnvironmentContext() == null ? StringUtils.EMPTY : service.getInstantiationType());
if (!isInstance) {
- // DE268546
- toscaMetadata.put(JsonPresentationFields.ECOMP_GENERATED_NAMING.getPresentation(), service.isEcompGeneratedNaming().toString());
- toscaMetadata.put(JsonPresentationFields.ECOMP_GENERATED_NAMING.getPresentation(), service.isEcompGeneratedNaming().toString());
+ toscaMetadata.put(JsonPresentationFields.ECOMP_GENERATED_NAMING.getPresentation(), service.isEcompGeneratedNaming());
toscaMetadata.put(JsonPresentationFields.NAMING_POLICY.getPresentation(), service.getNamingPolicy());
}
break;
private List<Object> occurrences;
private Map<String, String> instance_count;
private List<String> directives;
- private Map<String, String> metadata;
+ private Map<String, Object> metadata;
private String description;
private Map<String, Object> properties;
private Map<String, Object> attributes;
public class ToscaTemplate {
private String tosca_definitions_version;
- private Map<String, String> metadata;
+ private Map<String, Object> metadata;
private List<Map<String, Map<String, String>>> imports;
private Map<String, Object> interface_types;
private Map<String, ToscaDataType> data_types;
message: "Error: Uploaded YAML file is invalid.\n%1",
messageId: "SVC4010"
}
+
+ #---------SVC4019-----------------------------
+ # %1 - metadata property name
+ UNCHANGEABLE_PROPERTY_ERROR: {
+ code: 402,
+ message: "Error: '%1' cannot change",
+ messageId: "SVC4019"
+ }
+
+ #---------SVC4020-----------------------------
+ MISSING_SERVICE_METADATA: {
+ code: 402,
+ message: "Error: Missing metadata in Service",
+ messageId: "SVC4020"
+ }
.thenReturn(Optional.of(vendorSoftwareProduct));
// when
- final CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID);
+ final CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID, null);
// then
assertNotNull(csarInfo);
when(csarOperation.findVsp(resource.getCsarUUID(), resource.getCsarVersionId(), user)).thenReturn(Optional.of(vendorSoftwareProduct));
final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
- () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID));
+ () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID, null));
assertEquals(ActionStatus.VSP_MODEL_NOT_ALLOWED, actualException.getActionStatus());
assertEquals(2, actualException.getParams().length);
assertEquals(resource.getModel(), actualException.getParams()[0]);
when(csarOperation.findVsp(resource.getCsarUUID(), resource.getCsarVersionId(), user)).thenReturn(Optional.of(vendorSoftwareProduct));
final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
- () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID));
+ () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID, null));
assertEquals(ActionStatus.VSP_MODEL_NOT_ALLOWED, actualException.getActionStatus());
assertEquals(2, actualException.getParams().length);
assertEquals(resource.getModel(), actualException.getParams()[0]);
when(csarOperation.findVsp(resource.getCsarUUID(), resource.getCsarVersionId(), user)).thenReturn(Optional.of(vendorSoftwareProduct));
final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
- () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID));
+ () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID, null));
assertEquals(ActionStatus.VSP_MODEL_NOT_ALLOWED, actualException.getActionStatus());
assertEquals(2, actualException.getParams().length);
assertEquals("SDC AID", actualException.getParams()[0]);
when(csarOperation.findVsp(resource.getCsarUUID(), resource.getCsarVersionId(), user)).thenThrow(new RuntimeException());
final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
- () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID));
+ () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID, null));
assertEquals(ActionStatus.VSP_FIND_ERROR, actualException.getActionStatus());
assertEquals(2, actualException.getParams().length);
assertEquals(resource.getCsarUUID(), actualException.getParams()[0]);
Map<String, byte[]> payload = loadPayload(PAYLOAD_NAME);
// when
- CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, payload, CSAR_UUID);
+ CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, payload, CSAR_UUID, null);
// then
assertNotNull(csarInfo);
when(csarOperation.findVspLatestPackage(anyString(), any(User.class))).thenReturn(Either.left(csar_data));
// when/then
- assertThrows(ComponentException.class, () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID));
+ assertThrows(ComponentException.class, () -> csarBusinessLogic.getCsarInfo(resource, null, user, null, CSAR_UUID, null));
}
@Test
.thenReturn(Either.left(newService));
when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
ServiceCsarInfo csarInfo = getCsarInfo();
- when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString())).thenReturn(csarInfo);
+ when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(csarInfo);
when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
.thenReturn(Either.left(new HashMap<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>>()));
doReturn(getParsedToscaYamlInfo()).when(csarBusinessLogic).getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), any(), any(Service.class));
// .thenReturn(getParsedToscaYamlInfo());
when(serviceBusinessLogic.lockComponentByName(newService.getSystemName(), oldService, CREATE_RESOURCE)).thenReturn(Either.left(true));
when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(createOldResource()));
- when(serviceImportParseLogic.createServiceTransaction(oldService, csarInfo.getModifier(), false)).thenReturn(newService);
+ when(serviceImportParseLogic.createServiceTransaction(oldService, csarInfo.getModifier(), false, AuditingActionEnum.CREATE_RESOURCE)).thenReturn(newService);
when(serviceImportParseLogic.createInputsOnService(eq(oldService), anyMap())).thenReturn(newService);
Assertions.assertDoesNotThrow(() -> {
when(serviceImportParseLogic.createSubstitutionFilterOnService(eq(oldService), any())).thenReturn(newService);
when(serviceBusinessLogic.validateServiceBeforeCreate(any(Service.class), any(User.class), any(AuditingActionEnum.class)))
.thenReturn(Either.left(newService));
when(toscaOperationFacade.validateCsarUuidUniqueness(anyString())).thenReturn(StorageOperationStatus.OK);
- when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString())).thenReturn(getCsarInfo());
+ when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class), any(Map.class), anyString(), any())).thenReturn(getCsarInfo());
when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class), any(Service.class)))
.thenReturn(Either.right(ActionStatus.GENERAL_ERROR));
when(csarBusinessLogic.getParsedToscaYamlInfo(anyString(), anyString(), any(), any(CsarInfo.class), anyString(),
new HashedMap();
when(csarBusinessLogic.getCsarInfo(any(Service.class), any(), any(User.class),
- any(Map.class), anyString())).thenReturn(csarInfo);
+ any(Map.class), anyString(), any())).thenReturn(csarInfo);
when(serviceImportParseLogic.findNodeTypesArtifactsToHandle(any(Map.class), any(CsarInfo.class),
any(Service.class))).thenReturn(Either.left(map));
Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromCsar(oldService,
- user, payload, csarUUID));
+ user, payload, csarUUID, null));
}
@Test
Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceFromYaml(oldService,
topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo,
- nodeTypesArtifactsToCreate, false, true, nodeName, user.getUserId()));
+ nodeTypesArtifactsToCreate, false, true, nodeName, user.getUserId(), null));
}
@Test
csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
- false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId()));
+ false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId(), null));
}
@Test
csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
when(toscaOperationFacade.getLatestResourceByToscaResourceName(anyString())).thenReturn(Either.left(resource));
Assertions.assertThrows(ComponentException.class, () -> sIBL.createServiceAndRIsFromYaml(oldService,
- false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId()));
+ false, nodeTypesArtifactsToCreate, false, true, csfyp, user.getUserId(), null));
}
@Test
preparedService.setDeploymentArtifacts(deploymentArtifacts);
String nodeName = "org.openecomp.resource.derivedFrom.zxjTestImportServiceAb.test";
Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
- NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(createServiceObject(true)));
when(csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(any(CsarInfo.class), any(Service.class),
anyString(), anyString(), anyList(), anyBoolean(), anyBoolean())).thenReturn(Either.left(preparedService));
Assertions.assertNotNull(
sIBL.createOrUpdateArtifacts(operation, createdArtifacts, yamlFileName, csarInfo,
- preparedService, nodeTypeInfoToUpdateArtifacts, true, true));
+ preparedService, true, true));
}
@Test
package org.openecomp.sdc.be.components.impl;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
-import org.mockito.Mockito;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
import org.mockito.junit.jupiter.MockitoExtension;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.model.UploadServiceInfo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+
@ExtendWith(MockitoExtension.class)
class ServiceImportManagerTest {
- private final ServiceBusinessLogic serviceBusinessLogic = Mockito.mock(ServiceBusinessLogic.class);
+ @Mock
+ private ServiceBusinessLogic serviceBusinessLogic;
+
@InjectMocks
private ServiceImportManager serviceImportManager;
@BeforeEach
public void setup() {
- serviceImportManager = new ServiceImportManager();
- }
-
- private ServiceImportManager createTestSubject() {
- return new ServiceImportManager();
- }
-
- @Test
- void testGetServiceImportBusinessLogic() {
- ServiceImportManager testSubject;
- ServiceImportBusinessLogic result;
-
- testSubject = createTestSubject();
- result = testSubject.getServiceImportBusinessLogic();
- assertNull(result);
- }
-
- @Test
- void testSetServiceImportBusinessLogic() {
- ServiceImportManager testSubject;
- ServiceImportBusinessLogic serviceImportBusinessLogic = null;
-
- testSubject = createTestSubject();
- testSubject.setServiceImportBusinessLogic(serviceImportBusinessLogic);
- assertNotNull(testSubject);
- }
-
- @Test
- void testGetServiceBusinessLogic() {
- ServiceImportManager testSubject;
- ServiceBusinessLogic result;
-
- testSubject = createTestSubject();
- result = testSubject.getServiceBusinessLogic();
- assertNull(result);
- }
-
- @Test
- void testSetServiceBusinessLogic() {
- ServiceImportManager testSubject;
- ServiceBusinessLogic serviceBusinessLogic = null;
-
- testSubject = createTestSubject();
- testSubject.setServiceBusinessLogic(serviceBusinessLogic);
- assertNotNull(testSubject);
+ MockitoAnnotations.openMocks(this);
+ serviceImportManager = new ServiceImportManager(serviceBusinessLogic, null);
}
@Test
serviceMetaData.setDescription("Description");
serviceMetaData.setVendorName("VendorName");
serviceMetaData.setVendorRelease("VendorRelease");
+ serviceMetaData.setDerivedFromGenericVersion("derivedFromGenericVersion");
Service service = new Service();
service.setName("service");
serviceImportManager.populateServiceMetadata(serviceMetaData, service);
+ assertEquals("derivedFromGenericVersion", service.getDerivedFromGenericVersion());
+ }
+
+ @Test
+ void testIsServiceExist() {
+ when(serviceBusinessLogic.isServiceExist(anyString())).thenReturn(false);
+ boolean result = serviceImportManager.isServiceExist("no exist");
+ assertFalse(result);
}
}
when(toscaOperationFacade.createToscaComponent(any(Service.class))).thenReturn(Either.left(service));
- Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true));
+ Assertions.assertThrows(NullPointerException.class, () -> testSubject.createServiceTransaction(service, user, true, null));
}
@Test
@Test
public void testGetMetadata() throws Exception {
ToscaNodeTemplate testSubject;
- Map<String, String> result;
+ Map<String, Object> result;
// default test
testSubject = createTestSubject();
@Test
public void testSetMetadata() throws Exception {
ToscaNodeTemplate testSubject;
- Map<String, String> metadata = null;
+ Map<String, Object> metadata = null;
// default test
testSubject = createTestSubject();
@Test
public void testGetMetadata() throws Exception {
ToscaTemplate testSubject;
- Map<String, String> result;
+ Map<String, Object> result;
// default test
testSubject = createTestSubject();
@Test
public void testSetMetadata() throws Exception {
ToscaTemplate testSubject;
- Map<String, String> metadata = null;
+ Map<String, Object> metadata = null;
// default test
testSubject = createTestSubject();
message: "Error: Uploaded YAML file is invalid.\n%1",
messageId: "SVC4010"
}
+
+ #---------SVC4019-----------------------------
+ # %1 - metadata property name
+ UNCHANGEABLE_PROPERTY_ERROR: {
+ code: 402,
+ message: "Error: '%1' cannot change",
+ messageId: "SVC4019"
+ }
+
+ #---------SVC4020-----------------------------
+ MISSING_SERVICE_METADATA: {
+ code: 402,
+ message: "Error: Missing metadata in Service",
+ messageId: "SVC4020"
+ }
// Service API URL
INVALID_SERVICE_API_URL,
// Property related
- PROPERTY_ALREADY_EXIST, PROPERTY_NAME_ALREADY_EXISTS, PROPERTY_NOT_FOUND, INVALID_PROPERTY, INVALID_PROPERTY_TYPE, INVALID_PROPERTY_INNER_TYPE, MISSING_PROPERTY_NAME, MISSING_PROPERTY_VALUE,
+ PROPERTY_ALREADY_EXIST, PROPERTY_NAME_ALREADY_EXISTS, PROPERTY_NOT_FOUND, INVALID_PROPERTY, INVALID_PROPERTY_TYPE, INVALID_PROPERTY_INNER_TYPE, MISSING_PROPERTY_NAME, MISSING_PROPERTY_VALUE, UNCHANGEABLE_PROPERTY_ERROR,
// Attribute related
ATTRIBUTE_ALREADY_EXIST, ATTRIBUTE_NOT_FOUND, INVALID_ATTRIBUTE,
// State related
ANNOTATION_TYPE_ALREADY_EXIST,
// CSAR
MISSING_CSAR_UUID, CSAR_INVALID, CSAR_INVALID_FORMAT, CSAR_NOT_FOUND, YAML_NOT_FOUND_IN_CSAR, VSP_ALREADY_EXISTS, RESOURCE_LINKED_TO_DIFFERENT_VSP, RESOURCE_FROM_CSAR_NOT_FOUND, AAI_ARTIFACT_GENERATION_FAILED, ASSET_NOT_FOUND_DURING_CSAR_CREATION, ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION, TOSCA_SCHEMA_FILES_NOT_FOUND, ARTIFACT_NAME_INVALID, ARTIFACT_PAYLOAD_EMPTY, ERROR_DURING_CSAR_CREATION, SERVICE_LINKED_TO_DIFFERENT_VSP,
- VSP_NOT_FOUND, VSP_FIND_ERROR, VSP_MODEL_NOT_ALLOWED,
+ VSP_NOT_FOUND, VSP_FIND_ERROR, VSP_MODEL_NOT_ALLOWED, MISSING_SERVICE_METADATA,
// Group
GROUP_HAS_CYCLIC_DEPENDENCY, GROUP_ALREADY_EXIST, GROUP_TYPE_IS_INVALID, GROUP_MISSING_GROUP_TYPE, GROUP_INVALID_COMPONENT_INSTANCE, GROUP_INVALID_TOSCA_NAME_OF_COMPONENT_INSTANCE, GROUP_IS_MISSING, GROUP_ARTIFACT_ALREADY_ASSOCIATED, GROUP_ARTIFACT_ALREADY_DISSOCIATED, GROUP_PROPERTY_NOT_FOUND, INVALID_VF_MODULE_NAME, INVALID_VF_MODULE_NAME_MODIFICATION, INVALID_VF_MODULE_TYPE,
// Group instance
CANCEL_CERTIFICATION_RESOURCE("CertificationCancel", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
CERTIFICATION_SUCCESS_RESOURCE("CertificationSuccess", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
CREATE_SERVICE("CreateService", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
+ UPDATE_SERVICE_TOSCA_TEMPLATE("UpdateService", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
+ UPDATE_SERVICE_TOSCA_MODEL("UpdateService", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
UPDATE_RESOURCE_METADATA("UpdateResourceMetadata", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
UPDATE_SERVICE_METADATA("UpdateServiceMetadata", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
ARTIFACT_UPLOAD("ArtifactUpload", AuditingTypesConstants.RESOURCE_ADMIN_EVENT_TYPE),
import java.util.List;
import java.util.Map;
import lombok.Getter;
+import lombok.NoArgsConstructor;
import lombok.Setter;
import org.openecomp.sdc.be.model.category.CategoryDefinition;
import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
@Getter
@Setter
+@NoArgsConstructor
public class UploadServiceInfo {
private String payloadData;
private String derivedFromGenericType;
private String derivedFromGenericVersion;
- public UploadServiceInfo() {
- }
-
public void addSubCategory(String category, String subCategory) {
if (category != null || subCategory != null) {
if (categories == null) {
}
public Either<TopologyTemplate, StorageOperationStatus> createTopologyTemplate(TopologyTemplate topologyTemplate) {
- topologyTemplate.generateUUID();
+ if (topologyTemplate.getUUID() == null) {
+ topologyTemplate.generateUUID();
+ }
topologyTemplate = getResourceMetaDataFromResource(topologyTemplate);
String resourceUniqueId = topologyTemplate.getUniqueId();
if (resourceUniqueId == null) {
if (associatePathProperties != StorageOperationStatus.OK) {
return Either.right(associatePathProperties);
}
+ StorageOperationStatus associateNodeFilterToComponent = associateNodeFilterToComponent(topologyTemplateVertex, topologyTemplate);
+ if (associateNodeFilterToComponent != StorageOperationStatus.OK) {
+ return Either.right(associateNodeFilterToComponent);
+ }
final StorageOperationStatus associateServiceToModel = associateComponentToModel(topologyTemplateVertex, topologyTemplate,
EdgeLabelEnum.MODEL);
if (associateServiceToModel != StorageOperationStatus.OK) {
}
private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) {
- return associatePoliciesToComponent(nodeTypeVertex, topologyTemplate.getPolicies());
- }
-
- private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, Map<String, PolicyDataDefinition> policies) {
+ Map<String, PolicyDataDefinition> policies = topologyTemplate.getPolicies();
if (policies != null && !policies.isEmpty()) {
policies.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> {
String uid = UniqueIdBuilder.buildGroupingUid(nodeTypeVertex.getUniqueId(), p.getName());
return StorageOperationStatus.OK;
}
- public StorageOperationStatus deleteInstInputsToComponent(GraphVertex nodeTypeVertex, Map<String, MapPropertiesDataDefinition> instInputs) {
- if (instInputs != null && !instInputs.isEmpty()) {
- instInputs.entrySet().forEach(i -> {
- List<String> uniqueKeys = new ArrayList<>(i.getValue().getMapToscaDataDefinition().keySet());
- List<String> pathKeys = new ArrayList<>();
- pathKeys.add(i.getKey());
- StorageOperationStatus status = deleteToscaDataDeepElements(nodeTypeVertex, EdgeLabelEnum.INST_INPUTS,
- uniqueKeys, pathKeys);
- if (status != StorageOperationStatus.OK) {
- return;
- }
- });
- }
- return StorageOperationStatus.OK;
- }
-
- public StorageOperationStatus addInstPropertiesToComponent(GraphVertex nodeTypeVertex, Map<String, MapPropertiesDataDefinition> instInputs) {
- if (instInputs != null && !instInputs.isEmpty()) {
- instInputs.entrySet().forEach(i -> {
- StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(nodeTypeVertex, EdgeLabelEnum.INST_PROPERTIES,
- VertexTypeEnum.INST_PROPERTIES, i.getValue(), i.getKey());
- if (status != StorageOperationStatus.OK) {
- return;
- }
- });
- }
- return StorageOperationStatus.OK;
- }
-
- public StorageOperationStatus associateInstDeploymentArtifactsToComponent(GraphVertex nodeTypeVertex,
- Map<String, MapArtifactDataDefinition> instArtifacts) {
+ protected StorageOperationStatus associateInstDeploymentArtifactsToComponent(GraphVertex nodeTypeVertex,
+ Map<String, MapArtifactDataDefinition> instArtifacts) {
return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS,
EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
}
public StorageOperationStatus associateInstArtifactsToComponent(GraphVertex nodeTypeVertex,
- Map<String, MapArtifactDataDefinition> instArtifacts) {
+ Map<String, MapArtifactDataDefinition> instArtifacts) {
return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INSTANCE_ARTIFACTS,
EdgeLabelEnum.INSTANCE_ARTIFACTS);
}
}
public StorageOperationStatus associateOrAddCalcCapReqToComponent(GraphVertex nodeTypeVertex,
- Map<String, MapListRequirementDataDefinition> calcRequirements,
- Map<String, MapListCapabilityDataDefinition> calcCapabilty,
- Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties) {
+ Map<String, MapListRequirementDataDefinition> calcRequirements,
+ Map<String, MapListCapabilityDataDefinition> calcCapabilty,
+ Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties) {
if (!MapUtils.isEmpty(calcRequirements)) {
Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateOrAddElementToData(nodeTypeVertex,
VertexTypeEnum.CALCULATED_REQUIREMENTS, EdgeLabelEnum.CALCULATED_REQUIREMENTS, calcRequirements);
}
public StorageOperationStatus associateForwardingPathToComponent(GraphVertex nodeTypeVertex,
- Map<String, ForwardingPathDataDefinition> forwardingPathMap) {
+ Map<String, ForwardingPathDataDefinition> forwardingPathMap) {
if (forwardingPathMap != null && !forwardingPathMap.isEmpty()) {
Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex,
VertexTypeEnum.FORWARDING_PATH, EdgeLabelEnum.FORWARDING_PATH, forwardingPathMap);
}
public StorageOperationStatus associateOutputsToComponent(final GraphVertex nodeTypeVertex,
- final Map<String, ? extends AttributeDataDefinition> outputs,
- final String id) {
+ final Map<String, ? extends AttributeDataDefinition> outputs,
+ final String id) {
if (MapUtils.isNotEmpty(outputs)) {
outputs.values().stream().filter(e -> e.getUniqueId() == null)
.forEach(e -> e.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(id, e.getName())));
return StorageOperationStatus.OK;
}
+ private StorageOperationStatus associateNodeFilterToComponent(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) {
+ Map<String, CINodeFilterDataDefinition> nodeFilterComponents = topologyTemplate.getNodeFilterComponents();
+ if (MapUtils.isNotEmpty(nodeFilterComponents)) {
+ Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(topologyTemplateVertex,
+ VertexTypeEnum.INTERFACE, EdgeLabelEnum.NODE_FILTER_TEMPLATE, nodeFilterComponents);
+ if (assosiateElementToData.isRight()) {
+ return assosiateElementToData.right().value();
+ }
+ }
+ return StorageOperationStatus.OK;
+ }
+
private JanusGraphOperationStatus setForwardingGraphPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) {
Either<Map<String, ForwardingPathDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV,
EdgeLabelEnum.FORWARDING_PATH);
log.debug("Failed to disassociate instances interfaces for {} error {}", toscaElementVertex.getUniqueId(), status);
return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
+ status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.NODE_FILTER_TEMPLATE);
+ if (status != JanusGraphOperationStatus.OK) {
+ log.debug("Failed to disassociate capabilities for {} error {}", toscaElementVertex.getUniqueId(), status);
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
+ }
+
toscaElementVertex.getVertex().remove();
log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId());
return nodeType;
}
public Either<GraphVertex, StorageOperationStatus> updateDistributionStatus(String uniqueId, User user,
- DistributionStatusEnum distributionStatus) {
+ DistributionStatusEnum distributionStatus) {
Either<GraphVertex, StorageOperationStatus> result = null;
String userId = user.getUserId();
Either<GraphVertex, JanusGraphOperationStatus> getRes = findUserVertex(userId);
* @return
*/
public Either<List<ComponentInstanceProperty>, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId,
- String instanceId,
- String capabilityName,
- String capabilityType,
- String ownerId) {
+ String instanceId,
+ String capabilityName,
+ String capabilityType,
+ String ownerId) {
Either<List<ComponentInstanceProperty>, StorageOperationStatus> result = null;
Map<String, MapCapabilityProperty> mapPropertiesDataDefinition = null;
Either<GraphVertex, StorageOperationStatus> componentByLabelAndId = getComponentByLabelAndId(componentId,
}
public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceId,
- MapCapabilityProperty instanceProperties) {
+ MapCapabilityProperty instanceProperties) {
return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES,
instanceProperties, componentInstanceId);
}
public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, String componentInstanceId,
- MapInterfaceDataDefinition instanceInterfaces) {
+ MapInterfaceDataDefinition instanceInterfaces) {
if (MapUtils.isNotEmpty(instanceInterfaces.getMapToscaDataDefinition())) {
return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INTERFACES, instanceInterfaces,
componentInstanceId);
public StorageOperationStatus updateComponentInterfaces(final String componentId, final MapInterfaceDataDefinition instanceInterfaces,
- final String componentInterfaceUpdatedKey) {
+ final String componentInterfaceUpdatedKey) {
if (MapUtils.isNotEmpty(instanceInterfaces.getMapToscaDataDefinition())) {
return updateToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.INTERFACE_ARTIFACTS, instanceInterfaces,
componentInterfaceUpdatedKey);
policyDefinition.setPolicyUUID(UniqueIdBuilder.generateUUID());
}
- void revertNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) {
+ protected void revertNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) {
if (MapUtils.isNotEmpty(toscaElement.getComponentInstances()) || MapUtils.isNotEmpty(toscaElement.getGroups())) {
GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse).left().on(this::throwStorageException);
if (MapUtils.isNotEmpty(toscaElement.getComponentInstances())) {
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.HttpMethod;
+import javax.ws.rs.core.MediaType;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.openecomp.sdc.common.util.DataValidator;
private boolean skipCheckBody(final HttpServletRequest requestWrapper) {
final String contentType = requestWrapper.getContentType();
- return StringUtils.isNotEmpty(contentType) && contentType.contains("multipart/form-data");
+ return StringUtils.isNotEmpty(contentType) && contentType.contains(MediaType.MULTIPART_FORM_DATA);
}
private boolean isValid(final HttpServletRequest request) {
Code Review / sdc.git / commitdiff