<scope>import</scope>
</dependency>
- <dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- <version>${eelf.version}</version>
- </dependency>
- <dependency>
- <groupId>org.onap.logging-analytics</groupId>
- <artifactId>logging-slf4j</artifactId>
- <version>${onap.logger.slf4j}</version>
- </dependency>
-
<!--Swagger Dependencies -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${springfox.swagger2.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
</dependencyManagement>
<dependencies>
- <dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- </dependency>
- <dependency>
- <groupId>org.onap.logging-analytics</groupId>
- <artifactId>logging-slf4j</artifactId>
- </dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<outputDirectory>/opt/app/onap/lib</outputDirectory>
<outputFileNameMapping>${artifact.groupId}-${artifact.artifactId}-${artifact.version}${dashClassifier?}.${artifact.extension}</outputFileNameMapping>
<excludes>
+ <exclude>org.slf4j:slf4j-simple</exclude>
</excludes>
</dependencySet>
</dependencySets>
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.databind.node.NullNode
class ResourceAssignmentUtils {
companion object {
- private val logger: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentUtils::class.toString())
+ private val logger= LoggerFactory.getLogger(ResourceAssignmentUtils::class.toString())
// TODO("Modify Value type from Any to JsonNode")
@Throws(BluePrintProcessorException::class)
package org.onap.ccsdk.cds.blueprintsprocessor.core.factory
-import com.att.eelf.configuration.EELFManager
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.slf4j.LoggerFactory
import org.springframework.context.ApplicationContext
import org.springframework.context.ApplicationContextAware
* @author Brinda Santh
*/
open class ComponentNodeFactory : ApplicationContextAware {
- private val log = EELFManager.getInstance().getLogger(ComponentNodeFactory::class.java)
+ private val log = LoggerFactory.getLogger(ComponentNodeFactory::class.java)
var componentNodes: MutableMap<String, ComponentNode> = hashMapOf()
<scope>import</scope>
</dependency>
- <!-- Logging Dependencies -->
- <dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- <version>${eelf.version}</version>
- </dependency>
- <dependency>
- <groupId>org.onap.logging-analytics</groupId>
- <artifactId>logging-slf4j</artifactId>
- <version>${onap.logger.slf4j}</version>
- </dependency>
-
<!--Swagger Dependencies -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${springfox.swagger2.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.7</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<groupId>org.apache.sshd</groupId>
<artifactId>sshd-core</artifactId>
<version>${sshd.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>com.jcraft</groupId>
</dependencyManagement>
<dependencies>
- <dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- </dependency>
- <dependency>
- <groupId>org.onap.logging-analytics</groupId>
- <artifactId>logging-slf4j</artifactId>
- </dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-logging</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
package org.onap.ccsdk.cds.controllerblueprints;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@ComponentScan(basePackages = {"org.onap.ccsdk.cds.controllerblueprints"})
@EnableAutoConfiguration
public class ControllerBlueprintsApplication {
- private static EELFLogger log = EELFManager.getInstance().getLogger(ControllerBlueprintsApplication.class);
+ private static Logger log = LoggerFactory.getLogger(ControllerBlueprintsApplication.class);
public static void main(String[] args) {
log.info("****** Starting Controlled Blueprints Application ******");
package org.onap.ccsdk.cds.controllerblueprints.security;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
@Value("${basic-auth.hashed-pwd}")
private String userHashedPassword;
- private static EELFLogger log = EELFManager.getInstance().getLogger(ApplicationSecurityConfigurerAdapter.class);
+ private static Logger log = LoggerFactory.getLogger(ApplicationSecurityConfigurerAdapter.class);
@Bean
public SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) throws Exception {
\r
package org.onap.ccsdk.cds.controllerblueprints;\r
\r
-import com.att.eelf.configuration.EELFLogger;\r
-import com.att.eelf.configuration.EELFManager;\r
import org.apache.commons.lang3.StringUtils;\r
import org.junit.Assert;\r
import org.junit.Test;\r
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;\r
\r
/**\r
* @author Brinda Santh\r
*/\r
public class VersionSplitTest {\r
- private static EELFLogger log = EELFManager.getInstance().getLogger(VersionSplitTest.class);\r
+ private static Logger log = LoggerFactory.getLogger(VersionSplitTest.class);
\r
@Test\r
public void testVersionSplit() {\r
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
*/
class BluePrintContext(val serviceTemplate: ServiceTemplate) {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
/**
* Blueprint CBA extracted file location
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.ArrayNode
import com.fasterxml.jackson.databind.node.ObjectNode
* @author Brinda Santh
*/
object BluePrintExpressionService {
- val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ val log= LoggerFactory.getLogger(this::class.toString())
@JvmStatic
fun checkContainsExpression(propertyAssignmentNode: JsonNode): Boolean {
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.*
open class BluePrintRepoFileService(modelTypePath: String) : BluePrintRepoService {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintRepoFileService::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintRepoFileService::class.toString())
private val dataTypePath = modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
private val nodeTypePath = modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE)
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
import com.fasterxml.jackson.databind.node.ObjectNode
: BluePrintRuntimeService<MutableMap<String, JsonNode>> {
@Transient
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintRuntimeService::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintRuntimeService::class.toString())
private var store: MutableMap<String, JsonNode> = hashMapOf()
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.google.common.base.Preconditions
import org.apache.commons.lang3.StringUtils
@Deprecated("Decomposed implementation moved to blueprint-validation module")
open class BluePrintValidatorDefaultService : BluePrintValidatorService {
- val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintValidatorDefaultService::class.toString())
+ val log= LoggerFactory.getLogger(BluePrintValidatorDefaultService::class.toString())
lateinit var bluePrintContext: BluePrintContext
lateinit var serviceTemplate: ServiceTemplate
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
* @author Brinda Santh
*/
class PropertyAssignmentService(var bluePrintRuntimeService: BluePrintRuntimeService<MutableMap<String, JsonNode>>) {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
private var bluePrintContext: BluePrintContext = bluePrintRuntimeService.bluePrintContext()
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import kotlinx.coroutines.runBlocking
import org.apache.commons.io.FileUtils
import org.apache.commons.lang3.StringUtils
class BluePrintFileUtils {
companion object {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
fun createEmptyBluePrint(basePath: String) {
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
class BluePrintMetadataUtils {
companion object {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
suspend fun toscaMetaData(basePath: String): ToscaMetaData {
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
* @author Brinda Santh
*/
object BluePrintRuntimeUtils {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
fun assignInputsFromFile(bluePrintContext: BluePrintContext, fileName: String, context: MutableMap<String, JsonNode>) {
val jsonNode: JsonNode = JacksonUtils.jsonNodeFromFile(fileName)
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
class JacksonReactorUtils {
companion object {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
suspend fun getContent(fileName: String): String {
//log.info("Reading File($fileName)")
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import java.io.File
* @author Brinda Santh
*/
object ResourceResolverUtils {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
fun getFileContent(filename: String, basePath: String?): String {
log.trace("file ({}), basePath ({}) ", filename, basePath)
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.junit.Test
import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
*/
class BluePrintContextTest {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
val blueprintBasePath: String = ("./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration")
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
import org.junit.Test
* @author Brinda Santh
*/
class BluePrintRuntimeServiceTest {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
@Test
fun `test Resolve NodeTemplate Properties`() {
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import kotlinx.coroutines.runBlocking
import org.junit.Test
class JacksonReactorUtilsTest {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
@Test
fun testJsonNodeFromClassPathFile() {
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.junit.Test
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import kotlin.test.assertNotNull
*/
class JacksonUtilsTest {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
+ private val log= LoggerFactory.getLogger(this::class.toString())
@Test
fun testJsonNodeFromClassPathFile() {
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
open class BluePrintArtifactDefinitionValidatorImpl(
private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintArtifactDefinitionValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintArtifactDefinitionValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintArtifactDefinitionValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var bluePrintContext: BluePrintContext
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
open class BluePrintAttributeDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintAttributeDefinitionValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
private val resourceDefinitionValidator: ResourceDefinitionValidator)
: BluePrintValidatorService {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintDesignTimeValidatorService::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintDesignTimeValidatorService::class.toString())
override fun validateBluePrints(basePath: String): Boolean {
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.*
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintNodeTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintNodeTemplateValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintNodeTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintNodeTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var bluePrintContext: BluePrintContext
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmptyOrThrow
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintNodeTypeValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintNodeTypeValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var bluePrintContext: BluePrintContext
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintPropertyDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintPropertyDefinitionValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.google.common.base.Preconditions
import org.apache.commons.lang3.StringUtils
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintServiceTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintServiceTemplateValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var error: BluePrintError
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintTopologyTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintTopologyTemplateValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
package org.onap.ccsdk.cds.controllerblueprints.validation
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.validation.utils.PropertyAssignmentValidationUtils
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintWorkflowValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintWorkflowValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
var paths: MutableList<String> = arrayListOf()
package org.onap.ccsdk.cds.controllerblueprints.validation.extension
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionValidator
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
open class ArtifactMappingResourceValidator(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService)
: BluePrintArtifactDefinitionValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ArtifactMappingResourceValidator::class.toString())
+ private val log= LoggerFactory.getLogger(ArtifactMappingResourceValidator::class.toString())
override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String,
artifactDefinition: ArtifactDefinition) {
package org.onap.ccsdk.cds.controllerblueprints.validation.extension
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidator
import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class ResourceDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : ResourceDefinitionValidator {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceDefinitionValidatorImpl::class.java)
+ private val log= LoggerFactory.getLogger(ResourceDefinitionValidatorImpl::class.java)
override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String,
resourceDefinition: ResourceDefinition) {
</modules>
<dependencies>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-logging</artifactId>
+ </dependency>
<!-- Test Dependencies -->
<dependency>
<groupId>io.mockk</groupId>
package org.onap.ccsdk.cds.controllerblueprints.resource.dict.service
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.apache.commons.collections.CollectionUtils
import org.apache.commons.lang3.StringUtils
import org.apache.commons.lang3.text.StrBuilder
* @author Brinda Santh
*/
open class ResourceAssignmentValidationServiceImpl : ResourceAssignmentValidationService {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentValidationServiceImpl::class.java)
+ private val log= LoggerFactory.getLogger(ResourceAssignmentValidationServiceImpl::class.java)
open var resourceAssignmentMap: Map<String, ResourceAssignment> = hashMapOf()
open val validationMessage = StrBuilder()
package org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils
-import com.att.eelf.configuration.EELFLogger
import org.apache.commons.collections.CollectionUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.TopologicalSortingUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import java.util.ArrayList
/**
* BulkResourceSequencingUtils.
* @author Brinda Santh
*/
object BulkResourceSequencingUtils {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BulkResourceSequencingUtils::class.java)
+ private val log= LoggerFactory.getLogger(BulkResourceSequencingUtils::class.java)
@JvmStatic
fun process(resourceAssignments: MutableList<ResourceAssignment>): List<List<ResourceAssignment>> {
package org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
import org.apache.commons.collections.MapUtils
object ResourceDictionaryUtils {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceDictionaryUtils::class.java)
+ private val log= LoggerFactory.getLogger(ResourceDictionaryUtils::class.java)
@JvmStatic
fun populateSourceMapping(resourceAssignment: ResourceAssignment,
import org.junit.Assert;
import org.junit.Test;
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class ResourceDefinitionTest {
- private EELFLogger log = EELFManager.getInstance().getLogger(ResourceDefinitionTest.class);
+ private Logger log = LoggerFactory.getLogger(ResourceDefinitionTest.class);
private String basePath = "load/resource_dictionary";
@Test
package org.onap.ccsdk.cds.controllerblueprints.resource.dict.service
-import com.att.eelf.configuration.EELFLogger
import org.junit.Assert
import org.junit.Test
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
-import com.att.eelf.configuration.EELFManager
import org.junit.Before
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils.ResourceDictionaryTestUtils
+import org.slf4j.LoggerFactory
/**
* ResourceAssignmentValidationServiceTest.
* @author Brinda Santh
*/
class ResourceAssignmentValidationServiceTest {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentValidationServiceTest::class.java)
+ private val log = LoggerFactory.getLogger(ResourceAssignmentValidationServiceTest::class.java)
@Before
fun setUp() {
// Setup dummy Source Instance Mapping
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment;
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition;
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDictionaryConstants;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.util.HashMap;
import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
* ResourceDictionaryUtilsTest.
*
* @author Brinda Santh
*/
public class ResourceDictionaryUtilsTest {
- private static final EELFLogger log = EELFManager.getInstance().getLogger(ResourceDictionaryUtilsTest.class);
+ private static final Logger log = LoggerFactory.getLogger(ResourceDictionaryUtilsTest.class);
@Test
public void testPopulateSourceMapping() {
package org.onap.ccsdk.cds.controllerblueprints.service;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import org.apache.commons.collections.CollectionUtils;
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.factory.ResourceSourceMappingFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
@SuppressWarnings("unused")
public class ApplicationRegistrationService {
- private static EELFLogger log = EELFManager.getInstance().getLogger(ApplicationRegistrationService.class);
+ private static Logger log = LoggerFactory.getLogger(ApplicationRegistrationService.class);
@Value("#{'${resourceSourceMappings}'.split(',')}")
private List<String> resourceSourceMappings;
package org.onap.ccsdk.cds.controllerblueprints.service;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.common.base.Preconditions;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.onap.ccsdk.cds.controllerblueprints.service.domain.ResourceDictionary;
import org.onap.ccsdk.cds.controllerblueprints.service.model.AutoMapResponse;
import org.onap.ccsdk.cds.controllerblueprints.service.repository.ResourceDictionaryRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
@SuppressWarnings("unused")
public class AutoResourceMappingService {
- private static EELFLogger log = EELFManager.getInstance().getLogger(AutoResourceMappingService.class);
+ private static Logger log = LoggerFactory.getLogger(AutoResourceMappingService.class);
private ResourceDictionaryRepository dataDictionaryRepository;
package org.onap.ccsdk.cds.controllerblueprints.service;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.common.base.Preconditions;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.HashMap;
import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* SchemaGeneratorService.java Purpose: Provide Service to generate service template input schema definition and Sample
*/
@Deprecated
public class SchemaGeneratorService {
- private static EELFLogger log = EELFManager.getInstance().getLogger(SchemaGeneratorService.class);
+ private static Logger log = LoggerFactory.getLogger(SchemaGeneratorService.class);
private Map<String, DataType> dataTypes;
+++ /dev/null
-/*
- * Copyright © 2017-2018 AT&T Intellectual Property.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onap.ccsdk.apps.controllerblueprints.service.load
-
-import com.att.eelf.configuration.EELFManager
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.async
-import kotlinx.coroutines.runBlocking
-import org.apache.commons.lang3.text.StrBuilder
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
-import org.springframework.stereotype.Service
-import java.io.File
-import java.util.*
-
-@Service
-open class BluePrintCatalogLoadService(private val bluePrintCatalogService: BluePrintCatalogService) {
-
- private val log = EELFManager.getInstance().getLogger(BluePrintCatalogLoadService::class.java)
-
- open fun loadPathsBluePrintModelCatalog(paths: List<String>) {
- paths.forEach { loadPathBluePrintModelCatalog(it) }
- }
-
- open fun loadPathBluePrintModelCatalog(path: String) {
-
- val files = File(path).listFiles()
- runBlocking {
- val errorBuilder = StrBuilder()
- val deferredResults = mutableListOf<Deferred<Unit>>()
-
- for (file in files) {
- deferredResults += async {
- loadBluePrintModelCatalog(errorBuilder, file)
- }
- }
-
- for (deferredResult in deferredResults) {
- deferredResult.await()
- }
-
- if (!errorBuilder.isEmpty) {
- log.error(errorBuilder.toString())
- }
- }
- }
-
- open suspend fun loadBluePrintModelCatalog(errorBuilder: StrBuilder, file: File) {
- try {
- bluePrintCatalogService.saveToDatabase(UUID.randomUUID().toString(), file)
- } catch (e: Exception) {
- errorBuilder.appendln("Couldn't load BlueprintModel(${file.name}: ${e.message}")
- }
- }
-
-}
\ No newline at end of file
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
}
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintArtifactDefinitionEnhancerImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintArtifactDefinitionEnhancerImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var bluePrintContext: BluePrintContext
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
open class BluePrintEnhancerServiceImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
private val resourceDefinitionEnhancerService: ResourceDefinitionEnhancerService) : BluePrintEnhancerService {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerServiceImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintEnhancerServiceImpl::class.toString())
override suspend fun enhance(basePath: String, enrichedBasePath: String): BluePrintContext {
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateEnhancer
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
: BluePrintNodeTemplateEnhancer {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintNodeTemplateEnhancerImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintNodeTemplateEnhancerImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var bluePrintContext: BluePrintContext
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceDefinition
open class BluePrintNodeTypeEnhancerImpl(private val bluePrintRepoService: BluePrintRepoService,
private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService) : BluePrintNodeTypeEnhancer {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintNodeTypeEnhancerImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintNodeTypeEnhancerImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
lateinit var bluePrintContext: BluePrintContext
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintServiceTemplateEnhancer
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class BluePrintServiceTemplateEnhancerImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService)
: BluePrintServiceTemplateEnhancer {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintServiceTemplateEnhancerImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintServiceTemplateEnhancerImpl::class.toString())
lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
private val resourceAssignmentEnhancerService: ResourceAssignmentEnhancerService)
: BluePrintWorkflowEnhancer {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintWorkflowEnhancerImpl::class.toString())
+ private val log= LoggerFactory.getLogger(BluePrintWorkflowEnhancerImpl::class.toString())
companion object {
const val ARTIFACT_TYPE_MAPPING_SOURCE: String = "artifact-mapping-resource"
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class ResourceAssignmentEnhancerServiceImpl(private val resourceDefinitionRepoService: ResourceDefinitionRepoService)
: ResourceAssignmentEnhancerService {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentEnhancerServiceImpl::class.java)
+ private val log= LoggerFactory.getLogger(ResourceAssignmentEnhancerServiceImpl::class.java)
/**
* Get the defined source instance from the ResourceAssignment,
package org.onap.ccsdk.cds.controllerblueprints.service.enhancer
-import com.att.eelf.configuration.EELFLogger
-import com.att.eelf.configuration.EELFManager
+import org.slf4j.LoggerFactory
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
class ResourceDefinitionEnhancerServiceImpl(private val resourceDefinitionRepoService: ResourceDefinitionRepoService) :
ResourceDefinitionEnhancerService {
- private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceDefinitionEnhancerService::class.toString())
+ private val log= LoggerFactory.getLogger(ResourceDefinitionEnhancerService::class.toString())
companion object {
const val ARTIFACT_TYPE_MAPPING_SOURCE: String = "artifact-mapping-resource"
package org.onap.ccsdk.cds.controllerblueprints.service.handler
-import com.att.eelf.configuration.EELFManager
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
import org.onap.ccsdk.cds.controllerblueprints.service.domain.ModelType
import org.onap.ccsdk.cds.controllerblueprints.service.repository.ModelTypeRepository
import org.onap.ccsdk.cds.controllerblueprints.service.validator.ModelTypeValidator
+import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
@Service
open class ModelTypeHandler(private val modelTypeRepository: ModelTypeRepository) {
- private val log = EELFManager.getInstance().getLogger(ModelTypeHandler::class.java)!!
+ private val log = LoggerFactory.getLogger(ModelTypeHandler::class.java)!!
/**
* This is a getModelTypeByName service
package org.onap.ccsdk.cds.controllerblueprints.service.load
-import com.att.eelf.configuration.EELFManager
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import org.apache.commons.lang.text.StrBuilder
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
+import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import java.io.File
import java.util.*
@Service
open class BluePrintCatalogLoadService(private val bluePrintCatalogService: BluePrintCatalogService) {
- private val log = EELFManager.getInstance().getLogger(BluePrintCatalogLoadService::class.java)
+ private val log = LoggerFactory.getLogger(BluePrintCatalogLoadService::class.java)
- open suspend fun loadPathsBluePrintModelCatalog(paths: List<String>) {
+ open fun loadPathsBluePrintModelCatalog(paths: List<String>) {
paths.forEach { loadPathBluePrintModelCatalog(it) }
}
- open suspend fun loadPathBluePrintModelCatalog(path: String) {
+ open fun loadPathBluePrintModelCatalog(path: String) {
- val files = normalizedFile(path).listFiles()
- val errors = mutableListOf<String>()
- files.forEach {
- loadBluePrintModelCatalog(errors, it)
- }
- if (!errors.isEmpty()) {
- log.error(errors.joinToString("\n"))
+ val files = File(path).listFiles()
+ runBlocking {
+ val errorBuilder = StrBuilder()
+ val deferredResults = mutableListOf<Deferred<Unit>>()
+
+ for (file in files) {
+ deferredResults += async {
+ loadBluePrintModelCatalog(errorBuilder, file)
+ }
+ }
+
+ for (deferredResult in deferredResults) {
+ deferredResult.await()
+ }
+
+ if (!errorBuilder.isEmpty) {
+ log.error(errorBuilder.toString())
+ }
}
}
- open suspend fun loadBluePrintModelCatalog(errorBuilder: MutableList<String>, file: File) {
+ open suspend fun loadBluePrintModelCatalog(errorBuilder: StrBuilder, file: File) {
try {
- log.info("loading blueprint cba(${file.absolutePath})")
bluePrintCatalogService.saveToDatabase(UUID.randomUUID().toString(), file)
} catch (e: Exception) {
- errorBuilder.add("Couldn't load BlueprintModel(${file.name}: ${e.message}")
+ errorBuilder.appendln("Couldn't load BlueprintModel(${file.name}: ${e.message}")
}
}
package org.onap.ccsdk.cds.controllerblueprints.service.load
-import com.att.eelf.configuration.EELFManager
import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.slf4j.LoggerFactory
import org.springframework.boot.context.event.ApplicationReadyEvent
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Service
private val resourceDictionaryLoadService: ResourceDictionaryLoadService,
private val bluePrintCatalogLoadService: BluePrintCatalogLoadService) {
- private val log = EELFManager.getInstance().getLogger(BluePrintDatabaseLoadService::class.java)
+ private val log = LoggerFactory.getLogger(BluePrintDatabaseLoadService::class.java)
@EventListener(ApplicationReadyEvent::class)
package org.onap.ccsdk.cds.controllerblueprints.service.load
-import com.att.eelf.configuration.EELFManager
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.service.domain.ModelType
import org.onap.ccsdk.cds.controllerblueprints.service.handler.ModelTypeHandler
+import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import java.io.File
@Service
open class ModelTypeLoadService(private val modelTypeHandler: ModelTypeHandler) {
- private val log = EELFManager.getInstance().getLogger(ModelTypeLoadService::class.java)
+ private val log = LoggerFactory.getLogger(ModelTypeLoadService::class.java)
private val updateBySystem = "System"
open suspend fun loadPathsModelType(modelTypePaths: List<String>) {
package org.onap.ccsdk.cds.controllerblueprints.service.load
-import com.att.eelf.configuration.EELFManager
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.onap.ccsdk.cds.controllerblueprints.service.domain.ResourceDictionary
import org.onap.ccsdk.cds.controllerblueprints.service.handler.ResourceDictionaryHandler
+import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import java.io.File
@Service
open class ResourceDictionaryLoadService(private val resourceDictionaryHandler: ResourceDictionaryHandler) {
- private val log = EELFManager.getInstance().getLogger(ResourceDictionaryLoadService::class.java)
+ private val log = LoggerFactory.getLogger(ResourceDictionaryLoadService::class.java)
open suspend fun loadPathsResourceDictionary(paths: List<String>) {
paths.forEach {
package org.onap.ccsdk.cds.controllerblueprints.service.common;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import org.apache.commons.io.FileUtils;
import org.junit.Assert;
import org.junit.FixMethodOrder;
import java.io.File;
import java.nio.charset.Charset;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SchemaGeneratorServiceTest {
- private static EELFLogger log = EELFManager.getInstance().getLogger(SchemaGeneratorServiceTest.class);
+ private static Logger log = LoggerFactory.getLogger(SchemaGeneratorServiceTest.class);
@Test
public void test01GenerateSwaggerData() throws Exception {
package org.onap.ccsdk.cds.controllerblueprints.service
-import com.att.eelf.configuration.EELFManager
import kotlinx.coroutines.runBlocking
import org.junit.Assert
import org.junit.FixMethodOrder
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.service.domain.ModelType
import org.onap.ccsdk.cds.controllerblueprints.service.handler.ModelTypeHandler
+import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.test.annotation.Commit
internal var modelName = "test-datatype"
- private val log = EELFManager.getInstance().getLogger(ModelTypeServiceTest::class.java)
+ private val log = LoggerFactory.getLogger(ModelTypeServiceTest::class.java)
@Test
@Commit
package org.onap.ccsdk.cds.controllerblueprints.service.controller
-import com.att.eelf.configuration.EELFManager
import org.junit.Assert
import org.junit.FixMethodOrder
import org.junit.Test
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.service.domain.ModelType
+import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.test.annotation.Commit
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
class ModelTypeControllerTest {
- private val log = EELFManager.getInstance().getLogger(ModelTypeControllerTest::class.java)!!
+ private val log = LoggerFactory.getLogger(ModelTypeControllerTest::class.java)!!
@Autowired
internal var modelTypeController: ModelTypeController? = null
</dependency>
<dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- <version>${eelf.version}</version>
- </dependency>
- <dependency>
- <groupId>org.onap.logging-analytics</groupId>
- <artifactId>logging-slf4j</artifactId>
- <version>${onap.logger.slf4j}</version>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-logging</artifactId>
+ <version>${spring.boot.version}</version>
</dependency>
<!--Swagger Dependencies -->
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${springfox.swagger2.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
</dependencyManagement>
<dependencies>
- <dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- </dependency>
- <dependency>
- <groupId>org.onap.logging-analytics</groupId>
- <artifactId>logging-slf4j</artifactId>
- </dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
Code Review / ccsdk / cds.git / commitdiff