\r
const val USER_SYSTEM: String = "System"\r
\r
- const val MODEL_CONTENT_TYPE_JSON: String = "JSON"\r
- const val MODEL_CONTENT_TYPE_YAML: String = "YAML"\r
- const val MODEL_CONTENT_TYPE_YANG: String = "YANG"\r
- const val MODEL_CONTENT_TYPE_SCHEMA: String = "SCHEMA"\r
-\r
const val PATH_DIVIDER: String = "/"\r
const val PATH_SERVICE_TEMPLATE: String = "service_template"\r
const val PATH_TOPOLOGY_TEMPLATE: String = "topology_template"\r
const val PATH_METADATA: String = "metadata"\r
const val PATH_NODE_TYPES: String = "node_types"\r
const val PATH_POLICY_TYPES: String = "policy_types"\r
+ const val PATH_RELATIONSHIP_TYPES: String = "relationship_types"\r
const val PATH_ARTIFACT_TYPES: String = "artifact_types"\r
const val PATH_DATA_TYPES: String = "data_types"\r
const val PATH_INPUTS: String = "inputs"\r
var artifactTypes: MutableMap<String, ArtifactType>? = null\r
@get:JsonProperty("data_types")\r
var dataTypes: MutableMap<String, DataType>? = null\r
+ @get:JsonProperty("relationship_types")\r
+ var relationshipTypes: MutableMap<String, RelationshipType>? = null\r
@get:JsonProperty("node_types")\r
var nodeTypes: MutableMap<String, NodeType>? = null\r
@get:JsonProperty("policy_types")\r
import java.nio.charset.Charset
class BluePrintImportService(private val parentServiceTemplate: ServiceTemplate, private val blueprintBasePath: String) {
+ companion object {
+ private const val PARENT_SERVICE_TEMPLATE: String = "parent"
+ }
private val log: Logger = LoggerFactory.getLogger(this::class.toString())
- val PARENT_SERVICE_TEMPLATE: String = "parent"
- var importServiceTemplateMap: MutableMap<String, ServiceTemplate> = hashMapOf()
+ private var importServiceTemplateMap: MutableMap<String, ServiceTemplate> = hashMapOf()
fun getImportResolvedServiceTemplate(): ServiceTemplate {
import java.nio.file.Path
import java.nio.file.Paths
import java.nio.file.StandardOpenOption
-import java.text.MessageFormat
-import java.time.Instant
-import java.time.temporal.ChronoUnit
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
-
class BluePrintFileUtils {
val metaDataDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_METADATA_DIR))
Files.createDirectories(metaDataDir.toPath())
- val metafile = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE))
- Files.write(metafile.toPath(), getMetaDataContent().toByteArray(), StandardOpenOption.CREATE_NEW)
+ val metaFile = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants
+ .TOSCA_METADATA_ENTRY_DEFINITION_FILE))
+ Files.write(metaFile.toPath(), getMetaDataContent().toByteArray(), StandardOpenOption.CREATE_NEW)
val definitionsDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR))
Files.createDirectories(definitionsDir.toPath())
}
}
- fun populateDefaultImports(blueprintContext: BluePrintContext) {
- // Get the Default Types
- val types = arrayListOf(BluePrintConstants.PATH_DATA_TYPES, BluePrintConstants.PATH_ARTIFACT_TYPES,
- BluePrintConstants.PATH_NODE_TYPES, BluePrintConstants.PATH_POLICY_TYPES)
-
- // Clean Type Imports
- cleanImportTypes(blueprintContext.serviceTemplate)
-
- val imports = mutableListOf<ImportDefinition>()
- types.forEach { typeName ->
- val import = ImportDefinition()
- import.file = BluePrintConstants.TOSCA_DEFINITIONS_DIR.plus("/$typeName.json")
- imports.add(import)
- }
-
- blueprintContext.serviceTemplate.imports = imports
- }
-
- fun cleanImportTypes(serviceTemplate: ServiceTemplate) {
- // Clean the Type imports
- val toDeleteTypes = serviceTemplate.imports?.filter {
- it.file.endsWith("_types.json")
- }
-
- if (toDeleteTypes != null && toDeleteTypes.isNotEmpty()) {
- serviceTemplate.imports?.removeAll(toDeleteTypes)
- }
- }
-
fun writeEnhancedBluePrint(blueprintContext: BluePrintContext) {
// Write Blueprint Types
writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_DATA_TYPES, dataTypesContent)
}
+ blueprintContext.serviceTemplate.relationshipTypes?.let {
+ val nodeTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_RELATIONSHIP_TYPES, it.toSortedMap(), true)
+ writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_RELATIONSHIP_TYPES, nodeTypesContent)
+ }
+
blueprintContext.serviceTemplate.artifactTypes?.let {
val artifactTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_ARTIFACT_TYPES, it.toSortedMap(), true)
writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_ARTIFACT_TYPES, artifactTypesContent)
}
}
- fun writeEntryDefinitionFile(blueprintContext: BluePrintContext) {
+ private fun populateDefaultImports(blueprintContext: BluePrintContext) {
+ // Get the Default Types
+ val types = arrayListOf(BluePrintConstants.PATH_DATA_TYPES, BluePrintConstants.PATH_RELATIONSHIP_TYPES,
+ BluePrintConstants.PATH_ARTIFACT_TYPES, BluePrintConstants.PATH_NODE_TYPES,
+ BluePrintConstants.PATH_POLICY_TYPES)
+
+ // Clean Type Imports
+ cleanImportTypes(blueprintContext.serviceTemplate)
+
+ val imports = mutableListOf<ImportDefinition>()
+ types.forEach { typeName ->
+ val import = ImportDefinition()
+ import.file = BluePrintConstants.TOSCA_DEFINITIONS_DIR.plus("/$typeName.json")
+ imports.add(import)
+ }
+
+ blueprintContext.serviceTemplate.imports = imports
+ }
+
+ fun cleanImportTypes(serviceTemplate: ServiceTemplate) {
+ // Clean the Type imports
+ val toDeleteTypes = serviceTemplate.imports?.filter {
+ it.file.endsWith("_types.json")
+ }
+
+ if (toDeleteTypes != null && toDeleteTypes.isNotEmpty()) {
+ serviceTemplate.imports?.removeAll(toDeleteTypes)
+ }
+ }
+
+ /**
+ * Re Generate the Blueprint Service Template Definition file based on BluePrint Context.
+ */
+ private fun writeEntryDefinitionFile(blueprintContext: BluePrintContext) {
val absoluteEntryDefinitionFile = blueprintContext.rootPath.plus(File.separator).plus(blueprintContext.entryDefinition)
writeServiceTemplate.dataTypes = null
writeServiceTemplate.artifactTypes = null
writeServiceTemplate.policyTypes = null
+ writeServiceTemplate.relationshipTypes = null
writeServiceTemplate.nodeTypes = null
- // Write the Serivice Template
+ // Write the Service Template
writeDefinitionFile(absoluteEntryDefinitionFile, JacksonUtils.getJson(writeServiceTemplate, true))
}
- fun writeDefinitionFile(definitionFile: String, content: String) = runBlocking {
- val definitionFile = File(definitionFile)
+ fun writeDefinitionFile(definitionFileName: String, content: String) = runBlocking {
+ val definitionFile = File(definitionFileName)
// Delete the File If exists
Files.deleteIfExists(definitionFile.toPath())
"\nEntry-Definitions: Definitions/<BLUEPRINT_NAME>.json" +
"\nTemplate-Tags: <TAGS>"
}
-
- fun getBluePrintFile(fileName: String, targetPath: Path) : File {
- val filePath = targetPath.resolve(fileName).toString()
- val file = File(filePath)
- check(file.exists()) {
- throw BluePrintException("couldn't get definition file under path(${file.absolutePath})")
- }
- return file
- }
-
- fun getCBAGeneratedFileName(fileName: String, prefix: String): String {
- val DATE_FORMAT = "yyyyMMddHHmmss"
- val formatter = DateTimeFormatter.ofPattern(DATE_FORMAT)
- val datePrefix = Instant.now().atZone(ZoneId.systemDefault()).toLocalDateTime().format(formatter)
- return MessageFormat.format(prefix, datePrefix, fileName)
- }
fun getCbaStorageDirectory(path: String): Path {
check(StringUtils.isNotBlank(path)) {
{
"file": "Definitions/data_types.json"
},
+ {
+ "file": "Definitions/relationship_types.json"
+ },
{
"file": "Definitions/artifact_types.json"
},
--- /dev/null
+{
+ "relationship_types": {
+ "tosca.relationships.ConnectsTo": {
+ "description": "Relationship tosca.relationships.ConnectsTo",
+ "version": "1.0.0",
+ "derived_from": "tosca.relationships.Root"
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "description": "Relationship tosca.relationships.AttachesTo",
+ "version": "1.0.0",
+ "derived_from": "tosca.relationships.Root"
+}
\ No newline at end of file
--- /dev/null
+{
+ "description": "Relationship tosca.relationships.HostedOn",
+ "version": "1.0.0",
+ "derived_from": "tosca.relationships.Root"
+}
\ No newline at end of file
--- /dev/null
+{
+ "description": "Relationship tosca.relationships.RoutesTo",
+ "version": "1.0.0",
+ "derived_from": "tosca.relationships.Root"
+}
\ No newline at end of file
import com.att.eelf.configuration.EELFManager\r
import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException\r
import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintEnhancerService\r
-import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService\r
import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService\r
import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext\r
import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService\r
import java.util.*\r
\r
@Service\r
-open class BluePrintEnhancerServiceImpl(private val bluePrintRepoService: BluePrintRepoService,\r
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,\r
+open class BluePrintEnhancerServiceImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,\r
private val resourceDefinitionEnhancerService: ResourceDefinitionEnhancerService) : BluePrintEnhancerService {\r
\r
private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerServiceImpl::class.toString())\r
import com.att.eelf.configuration.EELFLogger
import com.att.eelf.configuration.EELFManager
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.apps.controllerblueprints.core.data.InterfaceDefinition
import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType
}
// NodeType Attribute Definitions
- enrichNodeTypeAtributes(name, nodeType)
+ enrichNodeTypeAttributes(name, nodeType)
// NodeType Property Definitions
enrichNodeTypeProperties(name, nodeType)
}
- open fun enrichNodeTypeAtributes(nodeTypeName: String, nodeType: NodeType) {
+ open fun enrichNodeTypeAttributes(nodeTypeName: String, nodeType: NodeType) {
nodeType.attributes?.let {
bluePrintTypeEnhancerService.enhanceAttributeDefinitions(bluePrintRuntimeService, nodeType.attributes!!)
}
open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {
- nodeType.requirements?.forEach { _, requirementDefinition ->
+ nodeType.requirements?.forEach { requirementName, requirementDefinition ->
// Populate Requirement Node
requirementDefinition.node?.let { requirementNodeTypeName ->
// Get Requirement NodeType from Repo and Update Service Template
val requirementNodeType = BluePrintEnhancerUtils.populateNodeType(bluePrintContext,
bluePrintRepoService, requirementNodeTypeName)
- // Enhanypece Node T
+ // Enhance Node Type
enhance(bluePrintRuntimeService, requirementNodeTypeName, requirementNodeType)
+
+ // Enhance Relationship Type
+ val relationShipTypeName = requirementDefinition.relationship
+ ?: throw BluePrintException("couldn't get relationship name for the NodeType($nodeTypeName) " +
+ "Requirement($requirementName)")
+ enrichRelationShipType(relationShipTypeName)
}
}
}
interfaceObj.operations?.forEach { operationName, operation ->
enrichNodeTypeInterfaceOperationInputs(nodeTypeName, operationName, operation)
- enrichNodeTypeInterfaceOperationOputputs(nodeTypeName, operationName, operation)
+ enrichNodeTypeInterfaceOperationOutputs(nodeTypeName, operationName, operation)
}
}
}
}
- open fun enrichNodeTypeInterfaceOperationOputputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {
+ open fun enrichNodeTypeInterfaceOperationOutputs(nodeTypeName: String, operationName: String,
+ operation: OperationDefinition) {
operation.outputs?.let { inputs ->
bluePrintTypeEnhancerService.enhancePropertyDefinitions(bluePrintRuntimeService, inputs)
}
}
+ /**
+ * Get the Relationship Type from database and add to Blueprint Context
+ */
+ open fun enrichRelationShipType(relationshipName: String) {
+ BluePrintEnhancerUtils.populateRelationshipType(bluePrintContext, bluePrintRepoService, relationshipName)
+ }
+
}
\ No newline at end of file
import com.att.eelf.configuration.EELFLogger
import com.att.eelf.configuration.EELFManager
import org.onap.ccsdk.apps.controllerblueprints.core.data.ServiceTemplate
-import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintServiceTemplateEnhancer
import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintServiceTemplateEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
+open class BluePrintServiceTemplateEnhancerImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
: BluePrintServiceTemplateEnhancer {
private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateEnhancerImpl::class.toString())
bluePrintContext.serviceTemplate.nodeTypes?.clear()
bluePrintContext.serviceTemplate.dataTypes?.clear()
bluePrintContext.serviceTemplate.policyTypes?.clear()
+ bluePrintContext.serviceTemplate.relationshipTypes?.clear()
bluePrintContext.serviceTemplate.artifactTypes = mutableMapOf()
bluePrintContext.serviceTemplate.nodeTypes = mutableMapOf()
bluePrintContext.serviceTemplate.dataTypes = mutableMapOf()
bluePrintContext.serviceTemplate.policyTypes = mutableMapOf()
+ bluePrintContext.serviceTemplate.relationshipTypes = mutableMapOf()
+ log.info("reinitialized all type definitions")
}
import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType
import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType
-import org.onap.ccsdk.apps.controllerblueprints.core.format
+import org.onap.ccsdk.apps.controllerblueprints.core.data.RelationshipType
import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintRepoService
import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
import org.springframework.http.codec.multipart.FilePart
return dataType
}
+ fun populateRelationshipType(bluePrintContext: BluePrintContext, bluePrintRepoService: BluePrintRepoService,
+ relationshipName: String): RelationshipType {
+
+ val relationshipType = bluePrintContext.serviceTemplate.relationshipTypes?.get(relationshipName)
+ ?: bluePrintRepoService.getRelationshipType(relationshipName)
+ ?: throw BluePrintException("couldn't get RelationshipType($relationshipName) from repo.")
+ bluePrintContext.serviceTemplate.relationshipTypes?.put(relationshipName, relationshipType)
+ return relationshipType
+ }
+
fun populateNodeType(bluePrintContext: BluePrintContext, bluePrintRepoService: BluePrintRepoService,
nodeTypeName: String): NodeType {
val nodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(nodeTypeName)
?: bluePrintRepoService.getNodeType(nodeTypeName)
- ?: throw BluePrintException(format("Couldn't get NodeType({}) from repo.", nodeTypeName))
+ ?: throw BluePrintException("couldn't get NodeType($nodeTypeName) from repo.")
bluePrintContext.serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)
return nodeType
}