public abstract Map<String, Object> getArtifactTypes();
+ /**
+ * Get the interface types defined in the CSAR
+ *
+ * @return map with the interface type name as key and representation of the interface type definition as value
+ */
+ public abstract Map<String, Object> getInterfaceTypes();
+
public Map<String, Object> getPolicyTypes() {
if (policytypeDefinitions == null) {
policytypeDefinitions = new HashMap<>();
import static org.openecomp.sdc.be.components.impl.ImportUtils.findToscaElement;
import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DATA_TYPES;
import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.GROUP_TYPES;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INTERFACE_TYPES;
import fj.data.Either;
import java.util.ArrayList;
return getTypes(GROUP_TYPES);
}
+ @Override
+ public Map<String, Object> getInterfaceTypes() {
+ return getTypes(INTERFACE_TYPES);
+ }
+
@Override
public Map<String, Object> getCapabilityTypes() {
return getTypes(ToscaTagNamesEnum.CAPABILITY_TYPES);
types.putAll(getTypesFromTemplate(mappedToscaMainTemplate, toscaTag));
return types;
}
-
}
import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
import org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.NodeTypeDefinition;
import org.openecomp.sdc.be.model.NodeTypeInfo;
import org.openecomp.sdc.be.model.NodeTypeMetadata;
return artifactsTypes;
}
+ @Override
+ public Map<String, Object> getInterfaceTypes() {
+ return getTypes(ToscaTagNamesEnum.INTERFACE_TYPES);
+ }
+
public List<NodeTypeDefinition> getNodeTypesUsed() {
if (nodeTypeDefinitions == null) {
nodeTypeDefinitions = new ArrayList<>();
import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
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.UniqueIdBuilder;
import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
private final GroupTypeImportManager groupTypeImportManager;
private final GroupTypeOperation groupTypeOperation;
+ private InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
+ private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
private final CapabilityTypeImportManager capabilityTypeImportManager;
private final CapabilityTypeOperation capabilityTypeOperation;
final DataTypeBusinessLogic dataTypeBusinessLogic, final ArtifactTypeOperation artifactTypeOperation,
final ArtifactTypeImportManager artifactTypeImportManager, final GroupTypeImportManager groupTypeImportManager,
final GroupTypeOperation groupTypeOperation,
+ final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
+ final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager,
final CapabilityTypeImportManager capabilityTypeImportManager,
final CapabilityTypeOperation capabilityTypeOperation) {
this.componentsUtils = componentsUtils;
this.artifactTypeImportManager = artifactTypeImportManager;
this.groupTypeImportManager = groupTypeImportManager;
this.groupTypeOperation = groupTypeOperation;
+ this.interfaceLifecycleTypeOperation = interfaceLifecycleTypeOperation;
+ this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager;
this.capabilityTypeImportManager = capabilityTypeImportManager;
this.capabilityTypeOperation = capabilityTypeOperation;
}
groupTypeImportManager.createGroupTypes(toscaTypeImportData, service.getModel(), true);
}
+ final Map<String, Object> interfaceTypesToCreate = getInterfaceTypesToCreate(service.getModel(), csarInfo);
+ if (MapUtils.isNotEmpty(interfaceTypesToCreate)) {
+ interfaceLifecycleTypeImportManager
+ .createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), service.getModel(), true);
+ }
+
final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(service.getModel(), csarInfo);
if (MapUtils.isNotEmpty(capabilityTypesToCreate)) {
return artifactTypesToCreate;
}
- private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result,
- final Map<String, Map<String, Object>> dataType) {
+ private Map<String, Object> getInterfaceTypesToCreate(final String model, final CsarInfo csarInfo) {
+ final Map<String, Object> interfaceTypesToCreate = new HashMap<>();
+ Map<String, Object> interfacetypeMap = csarInfo.getInterfaceTypes();
+
+ interfacetypeMap.entrySet().forEach(interfacetypeDef -> {
+ Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinition =
+ interfaceLifecycleTypeOperation.getInterface(UniqueIdBuilder.buildInterfaceTypeUid(model, interfacetypeDef.getKey()));
+ if (interfaceDefinition.isRight() && interfaceDefinition.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
+ interfaceTypesToCreate.put(interfacetypeDef.getKey(), interfacetypeDef.getValue());
+ }
+ });
+ return interfaceTypesToCreate;
+ }
+
+ private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result, final Map<String, Map<String, Object>> dataType) {
return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
&& result.left().value().getProperties().size() != dataType.get("properties").size();
}
private User user;
private static final String CSAR_UUID = "csarUUID";
- private static final String PAYLOAD_NAME = "csars/serviceWithUnknownDataTypes.csar";
+ private static final String PAYLOAD_NAME = "csars/serviceWithUnknownTypes.csar";
private static final String SERVICE_NAME = "serviceWithDataType";
private static final String MAIN_TEMPLATE_NAME = "Definitions/service-Servicewithdatatype-template.yml";
((Map<String, Object>) ((Map<String, Object>) dataTypeDefinition.get("properties")).get("prop2")).get("type"));
}
+ @SuppressWarnings("unchecked")
+ @Test
+ void testGetInterfaceTypes() {
+ final Map<String, Object> interfaceTypes = csarInfo.getInterfaceTypes();
+ assertEquals(9, interfaceTypes.size());
+ final Map<String, Object> interfaceTypeDefinition = (Map<String, Object>) interfaceTypes.get(
+ "tosca.interfaces.test.node.lifecycle.Reconfigure");
+ assertNotNull(interfaceTypeDefinition);
+ assertEquals("tosca.interfaces.Root", interfaceTypeDefinition.get("derived_from"));
+ assertEquals("reconfigure", ((Map<String, Object>) interfaceTypeDefinition.get("Reconfigure")).get("description"));
+ }
+
}
private final GroupTypeOperation groupTypeOperation = mock(GroupTypeOperation.class);
private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
private final CapabilityTypeImportManager capabilityTypeImportManager = mock(CapabilityTypeImportManager.class);
+ private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager = mock(InterfaceLifecycleTypeImportManager.class);
@InjectMocks
private ServiceImportBusinessLogic sIBL;
when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.testartifacts.Name"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
when(artifactTypeOperation.getArtifactTypeByUid(contains("tosca.artifacts"))).thenReturn(Either.left(null));
+ when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces"))).thenReturn(Either.left(new InterfaceDefinition()));
+ when(interfaceLifecycleTypeOperation.getInterface(contains("tosca.interfaces.test"))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+
+
when(capabilityTypeOperation.getCapabilityType(anyString()))
.thenReturn(Either.left(new CapabilityTypeDefinition()));
when(capabilityTypeOperation.getCapabilityType(contains("tosca.testcapabilitytypes.Name")))
Map<String, Object> nodeTypesMap = nodeTypes.getValue();
Map<String, Object> newUpdatedNodeType = (Map<String, Object>) nodeTypesMap.get(updatedNodeType);
assertEquals(8, ((Map<String, Object>) newUpdatedNodeType.get("properties")).size());
+
+ ArgumentCaptor<String> interfaceTypes = ArgumentCaptor.forClass(String.class);
+ verify(interfaceLifecycleTypeImportManager).createLifecycleTypes(interfaceTypes.capture(), any(), anyBoolean());
+ Map<String, Object> yamlInterfaceMap = new Yaml().load(interfaceTypes.getValue());
+ assertEquals(3, yamlInterfaceMap.size());
+ assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Attach"));
+ assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Detach"));
+ assertNotNull(yamlInterfaceMap.get("tosca.interfaces.test.node.lifecycle.Reconfigure"));
+
}
@Test
//Operations
IMPLEMENTATION("implementation"),
SUBSTITUTION_FILTERS("substitution_filter"),
- DERIVED_FROM_NAME("derivedFromName");
+ DERIVED_FROM_NAME("derivedFromName"),
+ INTERFACE_TYPES("interface_types");
// @formatter:om
private final String elementName;