<!-- <div style="width:inherit; height: inherit; position: fixed;z-index: 1; background-color: rgb(0,0,0);background-color: rgba(0,0,0,0.4);"></div> -->
<div style="display: flex;">
<div>
- <i class="fa fa-folder" aria-hidden="true" style="color:#3f51b5; font-size: 20px;margin: 3px; cursor: pointer;" [ngClass] ="{'fa-disabled': selectedFileObj.type == 'file' || selectedFileObj.type == ''}" (click)="enableNameInputEl('createFolder')"></i>
- <i class="fa fa-file" aria-hidden="true" style="color:#3f51b5; font-size: 18px; margin: 3px; cursor: pointer;" [ngClass] ="{'fa-disabled' : selectedFileObj.type == 'file' ||selectedFileObj.type == ''}" (click)="enableNameInputEl('createFile')"></i>
- <i class="fa fa-trash" aria-hidden="true" style="color:#3f51b5; font-size: 20px; margin: 3px; cursor: pointer;" [ngClass] ="{'fa-disabled' : selectedFileObj.type == ''}" (click)="deleteFolderOrFile('deleteFile')"></i>
+ <i class="fa fa-folder delete-add-file" aria-hidden="true" [ngClass] ="{'fa-disabled': selectedFileObj.type == 'file' || selectedFileObj.type == ''}" (click)="enableNameInputEl('createFolder')"></i>
+ <i class="fa fa-file add-file" aria-hidden="true" [ngClass] ="{'fa-disabled' : selectedFileObj.type == 'file' ||selectedFileObj.type == ''}" (click)="enableNameInputEl('createFile')"></i>
+ <i class="fa fa-trash delete-add-file" aria-hidden="true" [ngClass] ="{'fa-disabled' : selectedFileObj.type == ''}" (click)="deleteFolderOrFile('deleteFile')"></i>
</div>
<div>
<input *ngIf="isNameTextboxEnablled" type="text" (focusout)="createFolderOrFile($event)"/>
.mat-tree-node {
min-height: 40px !important;
+ }
+
+ .delete-add-file {
+ color:#3f51b5;
+ font-size: 20px;
+ margin: 3px;
+ cursor: pointer;
+ }
+
+ .add-file {
+ color:#3f51b5;
+ font-size: 18px;
+ margin: 3px;
+ cursor: pointer;
}
\ No newline at end of file
"node_modules/**",
"packages/*/node_modules/**",
"**/*.d.ts"
- ]
+ ],
+ "compilerOptions": {
+ "experimentalDecorators": true
+ }
}
web_client_service = self.restClientService(self.restconf_server_identifier)
try:
+ # mount the device
mount_payload = self.resolveAndGenerateMessage("config-deploy-mapping", "config-deploy-template")
restconf_client.mount_device(web_client_service, pnf_id, mount_payload)
+ # log the current configuration subtree
+ current_configuration = restconf_client.retrieve_device_configuration_subtree(
+ web_client_service, pnf_id, self.configlet_resource_path)
+ self.log.info("Current configuration subtree: {}", current_configuration)
+
+ # apply configuration
configlet = self.resolveFromDatabase(resolution_key, self.configlet_template_name)
- restconf_client.configure_device(web_client_service, pnf_id, self.configlet_resource_path, configlet)
+ restconf_client.configure_device_json_patch(
+ web_client_service, pnf_id, self.configlet_resource_path, configlet)
except Exception, err:
self.log.error("an error occurred while configuring device {}", err)
raise err
<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>
class RestconfClient:
+ __base_odl_url = "restconf/config/network-topology:network-topology/topology/topology-netconf/node/"
__odl_status_check_limit = 10
__odl_status_check_pause = 1
+ # Once confirmed to be reliable, the check should change to use the connection-status API
__odl_status_check_url = "restconf/operational/network-topology:network-topology/topology/topology-netconf/node/"
- __base_odl_url = "restconf/config/network-topology:network-topology/topology/topology-netconf/node/"
def __init__(self, log, restconf_component_function):
self.__log = log
self.__component_function = restconf_component_function
- def mount_device(self, web_client_service, pnf_id, mount_payload):
- self.__log.debug("mounting device {}", pnf_id)
+ def mount_device(self, web_client_service, nf_id, mount_payload):
+ self.__log.debug("mounting device {}", nf_id)
headers = {"Content-Type": "application/xml"}
- url = self.__base_odl_url + pnf_id
+ url = self.__base_odl_url + nf_id
self.__log.debug("sending mount request, url: {}", url)
web_client_service.exchangeResource("PUT", url, mount_payload, headers)
- self.__wait_for_odl_to_mount(web_client_service, pnf_id)
+ self.__wait_for_odl_to_mount(web_client_service, nf_id)
- def __wait_for_odl_to_mount(self, web_client_service, pnf_id):
+ def __wait_for_odl_to_mount(self, web_client_service, nf_id):
counter = 0
- url = self.__odl_status_check_url + pnf_id
+ url = self.__odl_status_check_url + nf_id
self.__log.info("url for ODL status check: {}", url)
expected_result = '"netconf-node-topology:connection-status":"connected"'
while counter < self.__odl_status_check_limit:
result = web_client_service.exchangeResource("GET", url, "")
if expected_result in result:
- self.__log.info("PNF was mounted successfully on ODL")
+ self.__log.info("NF was mounted successfully on ODL")
return None
sleep(self.__odl_status_check_pause)
counter += 1
- raise Exception("PNF was not mounted on ODL, aborting configuration procedure")
+ raise Exception("NF was not mounted on ODL, aborting configuration procedure")
- def configure_device(self, web_client_service, pnf_id, configlet_resource_path, configlet_to_apply):
- self.log_current_configlet(web_client_service, pnf_id, configlet_resource_path)
- self.__log.info("configuring device: {}, Configlet: {}", pnf_id, configlet_to_apply)
+ def configure_device_json_patch(self, web_client_service, nf_id, configlet_resource_path, configlet_to_apply):
headers = {"Content-Type": "application/yang.patch+json"}
- url = self.__base_odl_url + pnf_id + configlet_resource_path
+ self.__configure_device(web_client_service, nf_id, configlet_resource_path, configlet_to_apply, headers)
+
+ def configure_device_xml_patch(self, web_client_service, nf_id, configlet_resource_path, configlet_to_apply):
+ headers = {"Content-Type": "application/yang.patch+xml"}
+ self.__configure_device(web_client_service, nf_id, configlet_resource_path, configlet_to_apply, headers)
+
+ def __configure_device(self, web_client_service, nf_id, configlet_resource_path, configlet_to_apply, headers):
+ self.__log.debug("headers: {}", headers)
+ self.__log.info("configuring device: {}, Configlet: {}", nf_id, configlet_to_apply)
+ url = self.__base_odl_url + nf_id + configlet_resource_path
self.__log.debug("sending patch request, url: {}", url)
result = web_client_service.exchangeResource("PATCH", url, configlet_to_apply, headers)
self.__log.info("Configuration application result: {}", result)
- def log_current_configlet(self, web_client_service, pnf_id, configlet_resource_path):
- url = self.__base_odl_url + pnf_id + configlet_resource_path
+ def retrieve_device_configuration_subtree(self, web_client_service, nf_id, configlet_resource_path):
+ url = self.__base_odl_url + nf_id + configlet_resource_path
self.__log.debug("sending GET request, url: {}", url)
result = web_client_service.exchangeResource("GET", url, "")
- self.__log.info("Current configuration: {}", result)
+ return result
- def unmount_device(self, web_client_service, pnf_id):
- url = self.__base_odl_url + str(pnf_id)
+ def unmount_device(self, web_client_service, nf_id):
+ url = self.__base_odl_url + nf_id
self.__log.debug("sending unmount request, url: {}", url)
web_client_service.exchangeResource("DELETE", url, "")
<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>
import com.google.common.collect.ImmutableList
import com.google.common.collect.ImmutableSet
import org.apache.sshd.client.SshClient
-import org.apache.sshd.client.channel.ChannelSubsystem
import org.apache.sshd.client.channel.ClientChannel
import org.apache.sshd.client.session.ClientSession
-import org.apache.sshd.client.session.ClientSessionImpl
import org.apache.sshd.common.FactoryManager
import org.apache.sshd.server.keyprovider.SimpleGeneratorHostKeyProvider
import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.api.DeviceInfo
private fun startClient() {
client = SshClient.setUpDefaultClient()
+
client.properties.putIfAbsent(FactoryManager.IDLE_TIMEOUT, TimeUnit.SECONDS.toMillis(idleTimeout.toLong()))
client.properties.putIfAbsent(FactoryManager.NIO2_READ_TIMEOUT, TimeUnit.SECONDS.toMillis(idleTimeout + 15L))
- client.keyPairProvider = SimpleGeneratorHostKeyProvider()
client.start()
startSession()
import org.apache.sshd.common.NamedFactory
-import org.apache.sshd.server.Command
+import org.apache.sshd.server.command.Command
import org.apache.sshd.server.SshServer
import org.apache.sshd.server.auth.UserAuth
import org.apache.sshd.server.auth.UserAuthNoneFactory
import org.apache.sshd.server.keyprovider.SimpleGeneratorHostKeyProvider
-import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.utils.NetconfSubsystemFactory
import java.util.*
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.utils
+package org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.mocks
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import org.apache.sshd.common.NamedFactory;
-import org.apache.sshd.server.Command;
+import org.apache.sshd.server.command.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
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()
<kotlin.maven.version>1.3.21</kotlin.maven.version>
<kotlin.couroutines.version>1.1.1</kotlin.couroutines.version>
<grpc.version>1.18.0</grpc.version>
- <!-- TODO("Migrate SSHD to 2.x version") -->
- <sshd.version>1.7.0</sshd.version>
+ <sshd.version>2.2.0</sshd.version>
<jsch.version>0.1.55</jsch.version>
<protobuff.java.utils.version>3.6.1</protobuff.java.utils.version>
<eelf.version>1.0.0</eelf.version>
<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