Enables interface inputs specified in a node_type to be imported and included in the generated csar
Signed-off-by: Vasyl Razinkov <vasyl.razinkov@est.tech>
Change-Id: Ia3acaad50b4091831d0c0471b07ba2b2e9bd380d
Issue-ID: SDC-3077
public static final String UI_JSON_PAYLOAD_NAME = "payloadName";
public static final String CVFC_DESCRIPTION = "Complex node type that is used as nested type in VF";
public static final String ESCAPED_DOUBLE_QUOTE = "\"";
+ public static final String QUOTE = "'";
private Constants() {}
}
package org.openecomp.sdc.be.components.impl;
+import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
+
import fj.data.Either;
+import java.util.LinkedHashMap;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
+import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
import org.openecomp.sdc.be.utils.TypeUtils;
+import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.common.util.ThreadLocalsHolder;
import org.openecomp.sdc.common.util.ValidationUtils;
@Component("resourceImportManager")
public class ResourceImportManager {
+ private static final Logger log = Logger.getLogger(ResourceImportManager.class);
+
static final Pattern PROPERTY_NAME_PATTERN_IGNORE_LENGTH = Pattern.compile("[\\w\\-\\_\\d\\:]+");
private static final String IMPLEMENTATION = "implementation";
+ private static final String INPUTS = "inputs";
+ private static final String TYPE = "type";
+ private static final String DESCRIPTION = "description";
+ private static final String REQUIRED = "required";
+ private static final String DEFAULT = "default";
+ private static final String STATUS = "status";
private ServletContext servletContext;
private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
private IGraphLockOperation graphLockOperation;
- protected ToscaOperationFacade toscaOperationFacade;
+ private ToscaOperationFacade toscaOperationFacade;
- protected final ComponentsUtils componentsUtils;
+ private final ComponentsUtils componentsUtils;
private final CapabilityTypeOperation capabilityTypeOperation;
private ResponseFormatManager responseFormatManager;
- private static final Logger log = Logger.getLogger(ResourceImportManager.class);
-
@Autowired
public ResourceImportManager(ComponentsUtils componentsUtils, CapabilityTypeOperation capabilityTypeOperation) {
this.componentsUtils = componentsUtils;
}
- void populateResourceFromYaml(String resourceYml, Resource resource) {
+ private void populateResourceFromYaml(String resourceYml, Resource resource) {
@SuppressWarnings("unchecked")
-// Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
Object ymlObj = new Yaml().load(resourceYml);
if (ymlObj instanceof Map) {
Map<String, Object> toscaJsonAll = (Map<String, Object>) ymlObj;
}
private Either<InterfaceDefinition, ResultStatusEnum> createModuleInterface(Object interfaceJson, Resource resource) {
- InterfaceDefinition interf = new InterfaceDefinition();
+ final InterfaceDefinition interf = new InterfaceDefinition();
Either<InterfaceDefinition, ResultStatusEnum> result = Either.left(interf);
try {
if (interfaceJson instanceof String) {
- String requirementJsonString = (String) interfaceJson;
+ final String requirementJsonString = (String) interfaceJson;
interf.setType(requirementJsonString);
- }
- else if (interfaceJson instanceof Map && ResourceTypeEnum.VFC.equals(resource.getResourceType())) {
- Map<String, Object> requirementJsonMap = (Map<String, Object>) interfaceJson;
- Map<String, OperationDataDefinition> operations = new HashMap<>();
+ } else if (interfaceJson instanceof Map && ResourceTypeEnum.VFC.equals(resource.getResourceType())) {
+ final Map<String, Object> requirementJsonMap = (Map<String, Object>) interfaceJson;
+ final Map<String, OperationDataDefinition> operations = new HashMap<>();
for (final Entry<String, Object> entry : requirementJsonMap.entrySet()) {
- if (entryIsInterfaceType(entry)) {
- String type = (String) requirementJsonMap.get(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName());
+ if (entryIsInterfaceType(entry)) {
+ final String type = (String) requirementJsonMap
+ .get(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName());
interf.setType(type);
interf.setUniqueId(type.toLowerCase());
- } else if (entryContainsImplementationForAKnownOperation(entry, interf.getType())){
-
- OperationDataDefinition operation = new OperationDataDefinition();
- operation.setName(entry.getKey());
-
- ArtifactDataDefinition implementation = new ArtifactDataDefinition();
- // Adding the artifact name in quotes to indicate that this is a literal value, rather than a reference to
- // an SDC artifact
- implementation.setArtifactName(Constants.ESCAPED_DOUBLE_QUOTE + ((Map<String, String>)entry.getValue()).get(IMPLEMENTATION) + Constants.ESCAPED_DOUBLE_QUOTE);
- operation.setImplementation(implementation);
-
- operations.put(entry.getKey(), operation);
+ } else if (entryContainsImplementationForAKnownOperation(entry, interf.getType())) {
+
+ final OperationDataDefinition operation = new OperationDataDefinition();
+ operation.setName(entry.getKey());
+
+ final Map<?, ?> entryValue = (Map<?, ?>) entry.getValue();
+ if (entryValue.containsKey(IMPLEMENTATION)) {
+ operation.setImplementation(handleOperationImplementation(entry));
+ }
+ if (entryValue.containsKey(INPUTS)) {
+ final Map<String, Object> interfaceInputs = (Map<String, Object>) entryValue
+ .get(ToscaTagNamesEnum.INPUTS.getElementName());
+ operation.setInputs(handleInterfaceInput(interfaceInputs));
+ }
+ operations.put(entry.getKey(), operation);
}
}
if (!operations.isEmpty()) {
- interf.setOperations(operations);
+ interf.setOperations(operations);
}
- }
- else {
+ } else {
result = Either.right(ResultStatusEnum.GENERAL_ERROR);
}
return result;
}
-
+
+ private ArtifactDataDefinition handleOperationImplementation(final Entry<String, Object> entry) {
+ final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+ final String artifactName = ((Map<String, String>) entry.getValue()).get(IMPLEMENTATION);
+ if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
+ implementation.setArtifactName(artifactName);
+ } else {
+ implementation.setArtifactName(QUOTE + artifactName + QUOTE);
+ }
+ return implementation;
+ }
+
+ private ListDataDefinition<OperationInputDefinition> handleInterfaceInput(final Map<String, Object> interfaceInputs) {
+ final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
+ for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
+ final OperationInputDefinition operationInput = new OperationInputDefinition();
+ operationInput.setName(interfaceInput.getKey());
+ if (interfaceInput.getValue() instanceof Map) {
+ final LinkedHashMap<String, Object> inputPropertyValue =
+ (LinkedHashMap<String, Object>) interfaceInput.getValue();
+ log.info("createModuleInterface: i interfaceInput.getKey() {}, {} , {} ",
+ interfaceInput.getKey(), inputPropertyValue.keySet(),
+ inputPropertyValue.values());
+ if (inputPropertyValue.get(TYPE) != null) {
+ operationInput.setType(inputPropertyValue.get(TYPE).toString());
+ }
+ if (inputPropertyValue.get(DESCRIPTION) != null) {
+ operationInput.setDescription(inputPropertyValue.get(DESCRIPTION).toString());
+ }
+ if (inputPropertyValue.get(REQUIRED) != null) {
+ operationInput.setRequired(
+ Boolean.getBoolean(inputPropertyValue.get(REQUIRED).toString()));
+ }
+ if (inputPropertyValue.get(DEFAULT) != null) {
+ operationInput.setToscaDefaultValue(inputPropertyValue.get(DEFAULT).toString());
+ }
+ if (inputPropertyValue.get(STATUS) != null) {
+ operationInput.setStatus(inputPropertyValue.get(STATUS).toString());
+ }
+
+ } else if (interfaceInput.getValue() instanceof String) {
+ final String value = (String) interfaceInput.getValue();
+ operationInput.setDefaultValue(value);
+ operationInput.setToscaDefaultValue(value);
+ operationInput.setValue(value);
+ }
+ inputs.getListToscaDataDefinition().add(operationInput);
+ inputs.add(operationInput);
+ }
+ return inputs;
+ }
+
private boolean entryIsInterfaceType(final Entry<String, Object> entry) {
if(entry.getKey().equals(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName())) {
if (entry.getValue() instanceof String) {
this.auditingManager = auditingManager;
}
-
}
import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
import org.openecomp.sdc.be.dao.cassandra.SdcSchemaFilesCassandraDao;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
private Either<ZipOutputStream, ResponseFormat> writeOperationsArtifactsToCsar(Component component,
ZipOutputStream zipstream) {
- if (checkComponentBeforeOperation(component)) return Either.left(zipstream);
+ if (checkComponentBeforeOperation(component)) {
+ return Either.left(zipstream);
+ }
final Map<String, InterfaceDefinition> interfaces = ((Resource) component).getInterfaces();
for (Map.Entry<String, InterfaceDefinition> interfaceEntry : interfaces.entrySet()) {
for (OperationDataDefinition operation : interfaceEntry.getValue().getOperations().values()) {
try {
- if (checkComponentBeforeWrite(component, interfaceEntry, operation)) continue;
+ if (checkComponentBeforeWrite(component, interfaceEntry, operation)) {
+ continue;
+ }
final String artifactUUID = operation.getImplementation().getArtifactUUID();
+ if (artifactUUID == null) {
+ continue;
+ }
final Either<byte[], ActionStatus> artifactFromCassandra = getFromCassandra(artifactUUID);
final String artifactName = operation.getImplementation().getArtifactName();
if (artifactFromCassandra.isRight()) {
log.error(ARTIFACT_NAME_UNIQUE_ID, artifactName, artifactUUID);
log.error("Failed to get {} payload from DB reason: {}", artifactName,
- artifactFromCassandra.right().value());
+ artifactFromCassandra.right().value());
return Either.right(componentsUtils.getResponseFormat(
- ActionStatus.ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION, "Resource",
- component.getUniqueId(), artifactName, artifactUUID));
+ ActionStatus.ARTIFACT_PAYLOAD_NOT_FOUND_DURING_CSAR_CREATION, "Resource",
+ component.getUniqueId(), artifactName, artifactUUID));
}
final byte[] payloadData = artifactFromCassandra.left().value();
zipstream.putNextEntry(new ZipEntry(OperationArtifactUtil.createOperationArtifactPath(
- component, null, operation,true)));
+ component, null, operation, true)));
zipstream.write(payloadData);
} catch (IOException e) {
log.error("Component Name {}, Interface Name {}, Operation Name {}", component.getNormalizedName(),
- interfaceEntry.getKey(), operation.getName());
+ interfaceEntry.getKey(), operation.getName());
log.error("Error while writing the operation's artifacts to the CSAR " + "{}", e);
return Either.right(componentsUtils
- .getResponseFormat(ActionStatus.ERROR_DURING_CSAR_CREATION, "Resource",
- component.getUniqueId()));
+ .getResponseFormat(ActionStatus.ERROR_DURING_CSAR_CREATION, "Resource",
+ component.getUniqueId()));
}
}
}
}
private boolean checkComponentBeforeWrite(Component component, Entry<String, InterfaceDefinition> interfaceEntry, OperationDataDefinition operation) {
- if (Objects.isNull(operation.getImplementation())) {
+ final ArtifactDataDefinition implementation = operation.getImplementation();
+ if (Objects.isNull(implementation)) {
log.debug("Component Name {}, Interface Id {}, Operation Name {} - no Operation Implementation found",
component.getNormalizedName(), interfaceEntry.getValue().getUniqueId(),
operation.getName());
return true;
}
- if (Objects.isNull(operation.getImplementation().getArtifactName())) {
+ final String artifactName = implementation.getArtifactName();
+ if (Objects.isNull(artifactName)) {
log.debug("Component Name {}, Interface Id {}, Operation Name {} - no artifact found",
component.getNormalizedName(), interfaceEntry.getValue().getUniqueId(),
operation.getName());
return true;
}
- if (operation.getImplementation().getArtifactName().startsWith(Constants.ESCAPED_DOUBLE_QUOTE) && operation.getImplementation().getArtifactName().endsWith(Constants.ESCAPED_DOUBLE_QUOTE)) {
+ if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
log.debug("Component Name {}, Interface Id {}, Operation Name {} - artifact name is a literal value rather than an SDC artifact",
component.getNormalizedName(), interfaceEntry.getValue().getUniqueId(),
operation.getName());
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
+import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
@org.springframework.stereotype.Component("tosca-export-handler")
public class ToscaExportHandler {
+ private static final Logger log = Logger.getLogger(ToscaExportHandler.class);
+
private ApplicationDataTypeCache dataTypeCache;
private ToscaOperationFacade toscaOperationFacade;
private CapabilityRequirementConverter capabilityRequirementConverter;
this.interfacesOperationsConverter = interfacesOperationsConverter;
}
-
- private static final Logger log = Logger.getLogger(ToscaExportHandler.class);
-
private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
private static final String SERVICE_NODE_TYPE_PREFIX = "org.openecomp.service.";
private static final String IMPORTS_FILE_KEY = "file";
if ("dependencies".equals(property.getName())) {
return null;
}
+ removeDefaultP(propertyValue);
NodeTuple defaultNode = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag);
return "_defaultp_".equals(property.getName())
? new NodeTuple(representData("default"), defaultNode.getValueNode()) : defaultNode;
}
+ private void removeDefaultP(final Object propertyValue) {
+ if (propertyValue instanceof Map) {
+ final Map mapPropertyValue = ((Map) propertyValue);
+
+ final Iterator<Entry> iter = mapPropertyValue.entrySet().iterator();
+ Object defaultValue = null;
+ while (iter.hasNext()) {
+ final Map.Entry entry = iter.next();
+
+ if ("_defaultp_".equals(entry.getKey())) {
+ defaultValue = entry.getValue();
+ iter.remove();
+ } else if (entry.getValue() instanceof Map) {
+ removeDefaultP(entry.getValue());
+ }
+ }
+ if (defaultValue != null) {
+ mapPropertyValue.putIfAbsent("default", defaultValue);
+ }
+ }
+ }
+
@Override
protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {
// remove the bean type from the output yaml (!! ...)
.forEach(operations -> operations.values().forEach(operation -> operation.setImplementation(null)));
}
}
-
}
/**
- * This method assumes that operation.getImplementation() is not NULL ( it should be verified by the caller method)
+ * This method assumes that operation.getImplementation() is not NULL ( it should be verified by the caller
+ * method)
*
- * @param operation the specific operation name
+ * @param operation the specific operation name
* @return the full path including file name for operation's artifacts
*/
public static String createOperationArtifactPath(Component component, ComponentInstance componentInstance,
- OperationDataDefinition operation, boolean isAssociatedComponent) {
+ OperationDataDefinition operation, boolean isAssociatedComponent) {
if (!(component instanceof Resource || component instanceof Service)) {
return null;
}
if (isAssociatedComponent) {
// Service Proxy is only in Node Template interface
- if(componentInstance != null) {
+ if (componentInstance != null) {
return createOperationArtifactPathInService(componentInstance.getToscaComponentName()
- + "_v" + componentInstance.getComponentVersion(), operation);
+ + "_v" + componentInstance.getComponentVersion(), operation);
}
// Resource Instance is part of Node Type interface
else {
ResourceMetadataDataDefinition resourceMetadataDataDefinition =
- (ResourceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition();
+ (ResourceMetadataDataDefinition) component.getComponentMetadataDefinition()
+ .getMetadataDataDefinition();
return createOperationArtifactPathInService(resourceMetadataDataDefinition.getToscaResourceName()
- + "_v" + component.getVersion(), operation);
+ + "_v" + component.getVersion(), operation);
}
}
return createOperationArtifactPathInComponent(operation);
}
-
private static String createOperationArtifactPathInComponent(OperationDataDefinition operation) {
- if (artifactNameIsALiteralValue(operation.getImplementation().getArtifactName())) {
- final String implementationArtifactName = operation.getImplementation().getArtifactName();
- return implementationArtifactName.substring(1, implementationArtifactName.length()-1);
- } else {
- return CsarUtils.ARTIFACTS + File.separator + WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name())
- + File.separator + ArtifactTypeEnum.WORKFLOW.getType() + File.separator + BPMN_ARTIFACT_PATH
- + File.separator + operation.getImplementation().getArtifactName();
- }
+ final String implementationArtifactName = operation.getImplementation().getArtifactName();
+ if (artifactNameIsALiteralValue(implementationArtifactName)) {
+ return implementationArtifactName.substring(1, implementationArtifactName.length()-1);
+ } else {
+ return CsarUtils.ARTIFACTS + File.separator + WordUtils
+ .capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name())
+ + File.separator + ArtifactTypeEnum.WORKFLOW.getType() + File.separator + BPMN_ARTIFACT_PATH
+ + File.separator + implementationArtifactName;
+ }
}
- private static boolean artifactNameIsALiteralValue(final String artifactName) {
- return artifactName.startsWith(Constants.ESCAPED_DOUBLE_QUOTE) && artifactName.endsWith(Constants.ESCAPED_DOUBLE_QUOTE);
+ public static boolean artifactNameIsALiteralValue(final String artifactName) {
+ return (artifactName.startsWith(Constants.QUOTE) || artifactName.startsWith(Constants.ESCAPED_DOUBLE_QUOTE))
+ && (artifactName.endsWith(Constants.QUOTE) || artifactName.endsWith(Constants.ESCAPED_DOUBLE_QUOTE));
}
private static String createOperationArtifactPathInService(String toscaComponentName,
- OperationDataDefinition operation) {
+ OperationDataDefinition operation) {
return CsarUtils.ARTIFACTS + File.separator + toscaComponentName + File.separator +
- WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name()) + File.separator +
- ArtifactTypeEnum.WORKFLOW.getType() + File.separator + BPMN_ARTIFACT_PATH + File.separator +
- operation.getImplementation().getArtifactName();
+ WordUtils.capitalizeFully(ArtifactGroupTypeEnum.DEPLOYMENT.name()) + File.separator +
+ ArtifactTypeEnum.WORKFLOW.getType() + File.separator + BPMN_ARTIFACT_PATH + File.separator +
+ operation.getImplementation().getArtifactName();
}
- public static Map<String, ArtifactDefinition> getDistinctInterfaceOperationArtifactsByName(Component originComponent) {
+ public static Map<String, ArtifactDefinition> getDistinctInterfaceOperationArtifactsByName(
+ Component originComponent) {
Map<String, ArtifactDefinition> distinctInterfaceArtifactsByName = new HashMap<>();
Map<String, InterfaceDefinition> interfaces = originComponent.getInterfaces();
if (MapUtils.isEmpty(interfaces)) {
return distinctInterfaceArtifactsByName;
}
Map<String, ArtifactDefinition> interfaceArtifacts = interfaces.values().stream()
- .flatMap(interfaceDefinition -> interfaceDefinition.getOperationsMap().values().stream())
- .map(Operation::getImplementationArtifact).filter(Objects::nonNull)
- .collect(Collectors.toMap(ArtifactDataDefinition::getUniqueId,
- artifactDefinition -> artifactDefinition, (a1, a2) -> a1));
+ .flatMap(interfaceDefinition -> interfaceDefinition.getOperationsMap().values().stream())
+ .map(Operation::getImplementationArtifact).filter(Objects::nonNull)
+ .collect(Collectors.toMap(ArtifactDataDefinition::getUniqueId,
+ artifactDefinition -> artifactDefinition, (a1, a2) -> a1));
if (MapUtils.isNotEmpty(interfaceArtifacts)) {
Set<String> artifactNameSet = new HashSet<>();
for (Map.Entry<String, ArtifactDefinition> interfaceArtifactEntry : interfaceArtifacts.entrySet()) {
continue;
}
distinctInterfaceArtifactsByName.put(interfaceArtifactEntry.getKey(),
- interfaceArtifactEntry.getValue());
+ interfaceArtifactEntry.getValue());
artifactNameSet.add(artifactName);
}
}
return distinctInterfaceArtifactsByName;
}
+
}
assertEquals(1, operations.size());
OperationDataDefinition operation = operations.get("configure");
- assertEquals("\"camunda/vnfConfigure\"", operation.getImplementation().getArtifactName());
+ assertEquals("'camunda/vnfConfigure'", operation.getImplementation().getArtifactName());
}
Code Review / sdc.git / commitdiff