</dependencies>
</dependencyManagement>
<dependencies>
- <dependency>
- <groupId>com.att.eelf</groupId>
- <artifactId>eelf-core</artifactId>
- <version>${version.eelf.core}</version>
- <exclusions>
- <exclusion>
- <groupId>org.powermock</groupId>
- <artifactId>powermock-module-junit4</artifactId>
- </exclusion>
- <exclusion>
- <groupId>org.powermock</groupId>
- <artifactId>powermock-api-mockito</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
<dependency>
<groupId>org.codehaus.janino</groupId>
<artifactId>janino</artifactId>
package org.onap.policy.clamp.authorization;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.util.Date;
import org.apache.camel.Exchange;
import org.onap.policy.clamp.clds.config.ClampProperties;
import org.onap.policy.clamp.clds.exception.NotAuthorizedException;
import org.onap.policy.clamp.clds.model.ClampInformation;
import org.onap.policy.clamp.clds.util.LoggingUtils;
+import org.onap.policy.common.utils.logging.LoggerUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
@Component
public class AuthorizationController {
- protected static final EELFLogger logger =
- EELFManager.getInstance().getLogger(AuthorizationController.class);
- protected static final EELFLogger auditLogger = EELFManager.getInstance().getAuditLogger();
- protected static final EELFLogger securityLogger = EELFManager.getInstance().getSecurityLogger();
+ protected static final Logger logger = LoggerFactory.getLogger(AuthorizationController.class);
// By default we'll set it to a default handler
@Autowired
Date startTime = new Date();
LoggingUtils.setTargetContext("Clamp", "authorize");
LoggingUtils.setTimeContext(startTime, new Date());
- securityLogger.debug("checking if {} has permission: {}", principalName, perm);
+ logger.debug(LoggerUtils.SECURITY_LOG_MARKER, "checking if {} has permission: {}", principalName, perm);
if (!isUserPermitted(perm)) {
String msg = principalName + " does not have permission: " + perm;
LoggingUtils.setErrorContext("100", "Authorization Error");
- securityLogger.warn(msg);
+ logger.warn(LoggerUtils.SECURITY_LOG_MARKER, msg);
throw new NotAuthorizedException(msg);
}
}
// check if the user has the permission key or the permission key with a
// combination of all instance and/or all action.
if (hasRole(inPermission.getKey()) || hasRole(inPermission.getKeyAllInstance())) {
- auditLogger.info("{} authorized because user has permission with * for instance: {}",
+ logger.info(LoggerUtils.AUDIT_LOG_MARKER,
+ "{} authorized because user has permission with * for instance: {}",
principalName, inPermission.getKey().replace("|", ":"));
return true;
// the rest of these don't seem to be required - isUserInRole method
// appears to take * as a wildcard
} else if (hasRole(inPermission.getKeyAllInstanceAction())) {
- auditLogger.info(
+ logger.info(LoggerUtils.AUDIT_LOG_MARKER,
"{} authorized because user has permission with * for instance and * for action: {}",
principalName, inPermission.getKey().replace("|", ":"));
return true;
} else if (hasRole(inPermission.getKeyAllAction())) {
- auditLogger.info("{} authorized because user has permission with * for action: {}",
+ logger.info(LoggerUtils.AUDIT_LOG_MARKER,
+ "{} authorized because user has permission with * for action: {}",
principalName, inPermission.getKey().replace("|", ":"));
return true;
} else {
package org.onap.policy.clamp.clds;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import org.onap.policy.clamp.clds.util.ClampVersioning;
import org.onap.policy.clamp.clds.util.ResourceFileUtils;
import org.onap.policy.clamp.util.PassDecoder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableJpaAuditing
public class Application extends SpringBootServletInitializer {
- protected static final EELFLogger eelfLogger = EELFManager.getInstance().getLogger(Application.class);
+ protected static final Logger logger = LoggerFactory.getLogger(Application.class);
// This settings is an additional one to Spring config,
// only if we want to have an additional port automatically redirected to
// HTTPS
*/
@Bean
public ServletRegistrationBean<ClampServlet> camelServletRegistrationBean() throws IOException {
- eelfLogger.info(ResourceFileUtils.getResourceAsString("boot-message.txt") + "(v"
- + ClampVersioning.getCldsVersionFromProps() + ")" + System.getProperty("line.separator")
- + getSslExpirationDate());
+ logger.info("{} (v {} ), {}, {}", ResourceFileUtils.getResourceAsString("boot-message.txt"),
+ ClampVersioning.getCldsVersionFromProps(), System.getProperty("line.separator"),
+ getSslExpirationDate());
var registration = new ServletRegistrationBean<ClampServlet>(new ClampServlet(), "/restservices/clds/*");
registration.setName("CamelServlet");
return registration;
private Connector createRedirectConnector(int redirectSecuredPort) {
if (redirectSecuredPort <= 0) {
- eelfLogger.warn("HTTP port redirection to HTTPS is disabled because the HTTPS port is 0 (random port) or -1"
- + " (Connector disabled)");
+ logger.warn(
+ "HTTP port redirection to HTTPS is disabled because the HTTPS"
+ + " port is 0 (random port) or -1 (Connector disabled)");
return null;
}
var connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
result.append("* NONE HAS been configured");
}
} catch (CertificateException | NoSuchAlgorithmException | KeyStoreException e) {
- eelfLogger.warn("SSL certificate access error ", e);
+ logger.warn("SSL certificate access error", e);
}
return result.toString();
package org.onap.policy.clamp.clds;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import java.security.Principal;
import java.util.ArrayList;
import org.apache.camel.component.servlet.CamelHttpTransportServlet;
import org.apache.commons.lang3.StringUtils;
import org.onap.policy.clamp.authorization.SecureServicePermission;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.http.HttpStatus;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
*/
private static final long serialVersionUID = -4198841134910211542L;
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(ClampServlet.class);
+ private static final Logger logger = LoggerFactory.getLogger(ClampServlet.class);
private static final String PERM_INSTANCE = "clamp.config.security.permission.instance";
private static final String PERM_CL = "clamp.config.security.permission.type.cl";
private static final String PERM_TEMPLATE = "clamp.config.security.permission.type.template";
import static java.lang.Boolean.parseBoolean;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.onap.policy.clamp.clds.model.cds.CdsBpWorkFlowListResponse;
import org.onap.policy.clamp.clds.util.JsonUtils;
import org.onap.policy.clamp.clds.util.LoggingUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
@Autowired
CamelContext camelContext;
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(CdsServices.class);
+ protected static final Logger logger = LoggerFactory.getLogger(CdsServices.class);
private static final String TYPE = "type";
private static final String PROPERTIES = "properties";
if (HttpStatus.valueOf((Integer) exchangeResponse.getIn().getHeader(Exchange.HTTP_RESPONSE_CODE))
.is2xxSuccessful()) {
String cdsResponse = (String) exchangeResponse.getIn().getBody();
- logger.info("getBlueprintWorkflowList, response from CDS:" + cdsResponse);
+ logger.info("getBlueprintWorkflowList, response from CDS: {}", cdsResponse);
LoggingUtils.setResponseContext("0", "Get Blueprint workflow list", this.getClass().getName());
Date startTime = new Date();
LoggingUtils.setTimeContext(startTime, new Date());
if (HttpStatus.valueOf((Integer) exchangeResponse.getIn().getHeader(Exchange.HTTP_RESPONSE_CODE))
.is2xxSuccessful()) {
String cdsResponse = (String) exchangeResponse.getIn().getBody();
- logger.info("getWorkflowInputProperties, response from CDS:" + cdsResponse);
+ logger.info("getWorkflowInputProperties, response from CDS: {}", cdsResponse);
LoggingUtils
.setResponseContext("0", "Get Blueprint workflow input properties", this.getClass().getName());
Date startTime = new Date();
package org.onap.policy.clamp.clds.client;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import java.util.Date;
import org.apache.camel.CamelContext;
import org.onap.policy.clamp.clds.model.dcae.DcaeInventoryResponse;
import org.onap.policy.clamp.clds.util.JsonUtils;
import org.onap.policy.clamp.clds.util.LoggingUtils;
+import org.onap.policy.common.utils.logging.LoggerUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
@Autowired
CamelContext camelContext;
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(DcaeInventoryServices.class);
- protected static final EELFLogger auditLogger = EELFManager.getInstance().getAuditLogger();
- protected static final EELFLogger metricsLogger = EELFManager.getInstance().getMetricsLogger();
+ protected static final Logger logger = LoggerFactory.getLogger(DcaeInventoryServices.class);
+
public static final String DCAE_INVENTORY_URL = "dcae.inventory.url";
public static final String DCAE_INVENTORY_RETRY_INTERVAL = "dcae.intentory.retry.interval";
public static final String DCAE_INVENTORY_RETRY_LIMIT = "dcae.intentory.retry.limit";
retryInterval = Integer.valueOf(refProp.getStringValue(DCAE_INVENTORY_RETRY_INTERVAL));
}
for (int i = 0; i < retryLimit; i++) {
- metricsLogger.info("Attempt n°" + i + " to contact DCAE inventory");
+ logger.info(LoggerUtils.METRIC_LOG_MARKER, "Attempt n° {} to contact DCAE inventory", i);
try (ProducerTemplate producerTemplate = camelContext.createProducerTemplate()) {
Exchange exchangeResponse = producerTemplate
.send("direct:get-dcae-blueprint-inventory", ExchangeBuilder.anExchange(camelContext)
.is2xxSuccessful()) {
String dcaeResponse = (String) exchangeResponse.getIn().getBody();
int totalCount = getTotalCountFromDcaeInventoryResponse(dcaeResponse);
- metricsLogger.info("getDcaeInformation complete: totalCount returned=" + totalCount);
+ logger.info(LoggerUtils.METRIC_LOG_MARKER,
+ "getDcaeInformation complete: totalCount returned= {}", totalCount);
if (totalCount > 0) {
- logger.info("getDcaeInformation, answer from DCAE inventory:" + dcaeResponse);
+ logger.info("getDcaeInformation, answer from DCAE inventory: {}", dcaeResponse);
LoggingUtils.setResponseContext("0", "Get Dcae Information success", this.getClass().getName());
Date startTime = new Date();
LoggingUtils.setTimeContext(startTime, new Date());
return getItemsFromDcaeInventoryResponse(dcaeResponse);
} else {
- logger.info("Dcae inventory totalCount returned is 0, so waiting " + retryInterval
- + "ms before retrying ...");
+ logger.info("Dcae inventory totalCount returned is 0, so waiting {} ms before retrying ...",
+ retryInterval);
// wait for a while and try to connect to DCAE again
Thread.sleep(retryInterval);
}
}
}
}
- logger.warn("Dcae inventory totalCount returned is still 0, after " + retryLimit + " attempts, returning NULL");
+ logger.warn("Dcae inventory totalCount returned is still 0, after {} attempts, returning NULL", retryLimit);
return null;
}
}
package org.onap.policy.clamp.clds.config;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import org.onap.policy.clamp.authorization.CldsUser;
import org.onap.policy.clamp.clds.exception.CldsConfigException;
import org.onap.policy.clamp.clds.exception.CldsUsersException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
@Profile("clamp-default-user")
public class DefaultUserConfiguration extends WebSecurityConfigurerAdapter {
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(DefaultUserConfiguration.class);
+ protected static final Logger logger = LoggerFactory.getLogger(DefaultUserConfiguration.class);
private static final String SETUP_WEB_USERS_EXCEPTION_MSG = "Exception occurred during the "
+ " setup of the Web users in memory";
package org.onap.policy.clamp.clds.config;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.util.Properties;
import javax.annotation.Resource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
@Component
public class SystemPropertiesLoader implements ApplicationListener<ContextRefreshedEvent> {
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(SystemPropertiesLoader.class);
+ protected static final Logger logger = LoggerFactory.getLogger(SystemPropertiesLoader.class);
@Resource(name = "mapper")
private Properties myTranslator;
@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
- logger.info("Loading additional JVM properties:" + myTranslator.toString());
+ logger.info("Loading additional JVM properties: {}", myTranslator);
System.getProperties().putAll(myTranslator);
}
}
package org.onap.policy.clamp.clds.config.spring;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
import org.onap.policy.clamp.clds.sdc.controller.SdcSingleController;
import org.onap.policy.clamp.clds.sdc.controller.SdcSingleControllerStatus;
import org.onap.policy.clamp.loop.CsarInstaller;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
@Profile("clamp-sdc-controller")
public class SdcControllerConfiguration {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(SdcControllerConfiguration.class);
+ private static final Logger logger = LoggerFactory.getLogger(SdcControllerConfiguration.class);
private List<SdcSingleController> sdcControllersList = new ArrayList<>();
private final ClampProperties clampProp;
private final CsarInstaller csarInstaller;
public void loadSdcControllers() {
SdcControllersConfiguration sdcControllersConfig = getSdcControllersConfiguration();
sdcControllersConfig.getAllDefinedControllers().forEach((key, value) -> {
- logger.info("Creating controller instance:" + key);
+ logger.info("Creating controller instance: {}", key);
SdcSingleController sdcController = new SdcSingleController(clampProp, csarInstaller, value, null);
sdcControllersList.add(sdcController);
});
package org.onap.policy.clamp.clds.filter;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import org.onap.aaf.cadi.config.Config;
import org.onap.aaf.cadi.filter.CadiFilter;
import org.onap.policy.clamp.clds.util.ResourceFileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
public class ClampCadiFilter extends CadiFilter {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(ClampCadiFilter.class);
+ private static final Logger logger = LoggerFactory.getLogger(ClampCadiFilter.class);
@Autowired
private ApplicationContext appContext;
package org.onap.policy.clamp.clds.sdc.controller;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.security.SecureRandom;
import java.util.Date;
import java.util.Map.Entry;
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
import org.onap.sdc.utils.DistributionActionResultEnum;
import org.onap.sdc.utils.DistributionStatusEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class handles one sdc controller defined in the config.
*/
public class SdcSingleController {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(SdcSingleController.class);
+ private static final Logger logger = LoggerFactory.getLogger(SdcSingleController.class);
private boolean isSdcClientAutoManaged = false;
private CsarInstaller csarInstaller;
private ClampProperties refProp;
@Override
public void activateCallback(INotificationData notificationData) {
Date startTime = new Date();
- logger.info("Receive a callback notification in SDC, nb of resources: "
- + notificationData.getResources().size());
+ logger.info("Receive a callback notification in SDC, nb of resources: {}",
+ notificationData.getResources().size());
sdcController.treatNotification(notificationData);
LoggingUtils.setTimeContext(startTime, new Date());
LoggingUtils.setResponseContext("0", "SDC Notification received and processed successfully",
* is done when already initialized
*/
public void initSdc() throws SdcControllerException {
- logger.info("Attempt to initialize the SDC Controller: " + sdcConfig.getSdcControllerName());
+ logger.info("Attempt to initialize the SDC Controller: {}", sdcConfig.getSdcControllerName());
if (this.getControllerStatus() != SdcSingleControllerStatus.STOPPED) {
throw new SdcControllerException("The controller is already initialized, call the closeSDC method first");
}
}
IDistributionClientResult result = distributionClient.init(sdcConfig, new SdcNotificationCallBack(this));
if (!result.getDistributionActionResult().equals(DistributionActionResultEnum.SUCCESS)) {
- logger.error("SDC distribution client init failed with reason:" + result.getDistributionMessageResult());
+ logger.error("SDC distribution client init failed with reason: {}", result.getDistributionMessageResult());
this.changeControllerStatus(SdcSingleControllerStatus.STOPPED);
throw new SdcControllerException("Initialization of the SDC Controller failed with reason: "
+ result.getDistributionMessageResult());
}
- logger.info("SDC Controller successfully initialized: " + sdcConfig.getSdcControllerName());
- logger.info("Attempt to start the SDC Controller: " + sdcConfig.getSdcControllerName());
+ logger.info("SDC Controller successfully initialized: {}", sdcConfig.getSdcControllerName());
+ logger.info("Attempt to start the SDC Controller: {}", sdcConfig.getSdcControllerName());
result = this.distributionClient.start();
if (!result.getDistributionActionResult().equals(DistributionActionResultEnum.SUCCESS)) {
logger.error("SDC distribution client start failed with reason:" + result.getDistributionMessageResult());
throw new SdcControllerException(
"Startup of the SDC Controller failed with reason: " + result.getDistributionMessageResult());
}
- logger.info("SDC Controller successfully started: " + sdcConfig.getSdcControllerName());
+ logger.info("SDC Controller successfully started: {}", sdcConfig.getSdcControllerName());
this.changeControllerStatus(SdcSingleControllerStatus.IDLE);
}
// wait for a random time, so that 2 running Clamp will not treat
// the same Notification at the same time
Thread.sleep((new SecureRandom().nextInt(10) + 1) * 1000L);
- logger.info("Notification received for service UUID:" + notificationData.getServiceUUID());
+ logger.info("Notification received for service UUID: {}", notificationData.getServiceUUID());
this.changeControllerStatus(SdcSingleControllerStatus.BUSY);
csar = new CsarHandler(notificationData, this.sdcConfig.getSdcControllerName(),
refProp.getStringValue(CONFIG_SDC_FOLDER));
}
private IDistributionClientDownloadResult downloadTheArtifact(IArtifactInfo artifact) throws SdcDownloadException {
- logger.info("Trying to download the artifact : " + artifact.getArtifactURL() + " UUID: "
- + artifact.getArtifactUUID());
+ logger.info("Trying to download the artifact : {} UUID: {}",
+ artifact.getArtifactURL(), artifact.getArtifactUUID());
IDistributionClientDownloadResult downloadResult;
try {
downloadResult = distributionClient.download(artifact);
throw new SdcDownloadException("Exception caught when downloading the artifact", e);
}
if (DistributionActionResultEnum.SUCCESS.equals(downloadResult.getDistributionActionResult())) {
- logger.info("Successfully downloaded the artifact " + artifact.getArtifactURL() + " UUID "
- + artifact.getArtifactUUID() + "Size of payload " + downloadResult.getArtifactPayload().length);
+ logger.info("Successfully downloaded the artifact {} UUID {} Size of payload {}", artifact.getArtifactURL(),
+ artifact.getArtifactUUID(), downloadResult.getArtifactPayload().length);
} else {
throw new SdcDownloadException("Artifact " + artifact.getArtifactName()
+ " could not be downloaded from SDC URL " + artifact.getArtifactURL() + " UUID "
break;
}
} catch (RuntimeException e) {
- logger.warn("Unable to send the SDC Notification (" + action + ") due to an exception", e);
+ logger.warn("Unable to send the SDC Notification ({}) due to an exception", action, e);
}
- logger.info("SDC Notification sent successfully(" + action + ")");
+ logger.info("SDC Notification sent successfully ({})", action);
}
private void sendComponentStatus(INotificationData notificationData, DistributionStatusEnum status,
this.distributionClient.sendComponentDoneStatus(message);
}
} catch (RuntimeException e) {
- logger.warn("Unable to send the SDC Notification (" + status.name() + ") due to an exception", e);
+ logger.warn("Unable to send the SDC Notification ({}) due to an exception", status.name(), e);
}
- logger.info("SDC Notification sent successfully(" + status.name() + ")");
+ logger.info("SDC Notification sent successfully ({})", status.name());
}
private void sendDownloadStatus(IDistributionStatusMessage message, String errorReason) {
package org.onap.policy.clamp.clds.sdc.controller.installer;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import java.util.Set;
import org.json.JSONObject;
import org.onap.policy.clamp.clds.exception.sdc.controller.BlueprintParserException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;
public class BlueprintParser {
private static final String TARGET = "target";
public static final String DEFAULT_VERSION = "1.0.0";
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(BlueprintParser.class);
+ private static final Logger logger = LoggerFactory.getLogger(BlueprintParser.class);
private BlueprintParser() {
if (!microService.getModelType().isBlank()) {
microServices.add(microService);
} else {
- logger.warn("Microservice " + microService.getName()
- + " will NOT be used by CLAMP as the model type is not defined or has not been found");
+ logger.warn(
+ "Microservice {} will NOT be used by CLAMP as the model"
+ + "type is not defined or has not been found",
+ microService.getName());
}
}
}
- logger.debug("Those microservices have been found in the blueprint:" + microServices);
+ logger.debug("Those microservices have been found in the blueprint: {}", microServices);
return microServices;
}
String versionFound = getPropertyValue(POLICY_MODEL_VERSION, nodeTemplateEntry, blueprintNodeTemplateList,
blueprintInputList);
if (modelIdFound.isBlank()) {
- logger.warn("policy_model_id is not defined for the node template:" + nodeTemplateEntry.getKey());
+ logger.warn("policy_model_id is not defined for the node template: {}", nodeTemplateEntry.getKey());
}
if (versionFound.isBlank()) {
- logger.warn("policy_model_version is not defined (setting it to a default value) for the node template:"
- + nodeTemplateEntry.getKey());
+ logger.warn("policy_model_version is not defined (setting it to a default value) for the node template: {}",
+ nodeTemplateEntry.getKey());
}
return new BlueprintMicroService(getName(nodeTemplateEntry), modelIdFound, getInput(nodeTemplateEntry),
!versionFound.isBlank() ? versionFound : DEFAULT_VERSION);
package org.onap.policy.clamp.clds.sdc.controller.installer;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* CsarDescriptor that will be used to deploy file in CLAMP file system. Some
*/
public class CsarHandler {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(CsarHandler.class);
+ private static final Logger logger = LoggerFactory.getLogger(CsarHandler.class);
private IArtifactInfo artifactElement;
private String csarFilePath;
private String controllerName;
public synchronized void save(IDistributionClientDownloadResult resultArtifact)
throws SdcArtifactInstallerException, SdcToscaParserException {
try {
- logger.info("Writing CSAR file to: " + csarFilePath + " UUID " + artifactElement.getArtifactUUID() + ")");
+ logger.info("Writing CSAR file to: {} UUID {}", csarFilePath, artifactElement.getArtifactUUID());
Path path = Paths.get(csarFilePath);
Files.createDirectories(path.getParent());
// Create or replace the file
+ RESOURCE_INSTANCE_NAME_PREFIX.length(),
entry.getName().indexOf(RESOURCE_INSTANCE_NAME_SUFFIX))));
this.mapOfBlueprints.put(blueprintArtifact.getBlueprintArtifactName(), blueprintArtifact);
- logger.info("Found a blueprint entry in the CSAR " + blueprintArtifact.getBlueprintArtifactName()
- + " for resource instance Name "
- + blueprintArtifact.getResourceAttached().getResourceInstanceName());
+ logger.info("Found a blueprint entry in the CSAR {} for resource instance Name {}",
+ blueprintArtifact.getBlueprintArtifactName(),
+ blueprintArtifact.getResourceAttached().getResourceInstanceName());
}
}
- logger.info(this.mapOfBlueprints.size() + " blueprint(s) will be converted to closed loop");
+ logger.info("{} blueprint(s) will be converted to closed loop", this.mapOfBlueprints.size());
}
}
result = IOUtils.toString(zipFile.getInputStream(entry), StandardCharsets.UTF_8);
}
} else {
- logger.info("Policy model not found inside the CSAR file: " + csarFilePath);
+ logger.info("Policy model not found inside the CSAR file: {}", csarFilePath);
}
return Optional.ofNullable(result);
}
package org.onap.policy.clamp.clds.tosca.update;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import java.io.IOException;
import org.onap.policy.clamp.clds.config.ClampProperties;
import org.onap.policy.clamp.clds.tosca.update.templates.JsonTemplateManager;
import org.onap.policy.clamp.clds.util.JsonUtils;
import org.onap.policy.clamp.loop.service.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ToscaConverterWithDictionarySupport {
- private static final EELFLogger logger =
- EELFManager.getInstance().getLogger(ToscaConverterWithDictionarySupport.class);
+ private static final Logger logger =
+ LoggerFactory.getLogger(ToscaConverterWithDictionarySupport.class);
private ClampProperties clampProperties;
private ToscaMetadataParser metadataParser;
package org.onap.policy.clamp.clds.tosca.update.execution;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import java.util.HashMap;
import java.util.Map;
import org.onap.policy.clamp.clds.tosca.update.execution.cds.ToscaMetadataCdsProcess;
import org.onap.policy.clamp.loop.service.Service;
import org.onap.policy.clamp.tosca.DictionaryService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ToscaMetadataExecutor {
- private static final EELFLogger logger =
- EELFManager.getInstance().getLogger(ToscaMetadataExecutor.class);
+ private static final Logger logger =
+ LoggerFactory.getLogger(ToscaMetadataExecutor.class);
@Autowired
private DictionaryService dictionaryService;
*/
public void executeTheProcess(String processInfo, JsonObject childObject, Service serviceModel) {
String[] processParameters = (processInfo + "/ ").split("/");
- logger.info("Executing the Tosca clamp process " + processParameters[0] + " with parameters "
- + processParameters[1].trim());
+ logger.info("Executing the Tosca clamp process {} with parameters {}",
+ processParameters[0], processParameters[1].trim());
mapOfProcesses.get(processParameters[0].trim())
.executeProcess(processParameters[1].trim(), childObject, serviceModel);
}
package org.onap.policy.clamp.clds.tosca.update.execution;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import org.onap.policy.clamp.loop.service.Service;
import org.onap.policy.clamp.policy.operational.OperationalPolicyRepresentationBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class is there to add the JsonObject for CDS in the json Schema according to what is found in the Tosca model.
public class ToscaMetadataTargetProcess extends ToscaMetadataProcess {
- private static final EELFLogger logger =
- EELFManager.getInstance().getLogger(ToscaMetadataTargetProcess.class);
+ private static final Logger logger =
+ LoggerFactory.getLogger(ToscaMetadataTargetProcess.class);
@Override
public void executeProcess(String parameters, JsonObject childObject, Service serviceModel) {
package org.onap.policy.clamp.clds.tosca.update.execution.cds;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import org.onap.policy.clamp.clds.tosca.ToscaSchemaConstants;
import org.onap.policy.clamp.clds.tosca.update.execution.ToscaMetadataProcess;
import org.onap.policy.clamp.loop.service.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
*/
public class ToscaMetadataCdsProcess extends ToscaMetadataProcess {
- private static final EELFLogger logger =
- EELFManager.getInstance().getLogger(ToscaMetadataCdsProcess.class);
+ private static final Logger logger =
+ LoggerFactory.getLogger(ToscaMetadataCdsProcess.class);
@Override
public void executeProcess(String parameters, JsonObject childObject, Service serviceModel) {
package org.onap.policy.clamp.clds.util;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.InputStream;
import java.util.Properties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class give a way to know the Clamp version easily, the version in that
public class ClampVersioning {
private static final String RESOURCE_NAME = "clds-version.properties";
private static final String CLDS_VERSION_PROPERTY = "clds.version";
- private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(ClampVersioning.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(ClampVersioning.class);
private ClampVersioning() {
}
package org.onap.policy.clamp.clds.util;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.time.Instant;
import org.onap.policy.clamp.authorization.SecureServicePermissionDeserializer;
import org.onap.policy.clamp.dao.model.gson.converter.InstantDeserializer;
import org.onap.policy.clamp.dao.model.gson.converter.InstantSerializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class is used to access the GSON with restricted type access.
*/
public class JsonUtils {
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(JsonUtils.class);
+ protected static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);
public static final Gson GSON = new GsonBuilder().setPrettyPrinting()
.registerTypeAdapter(SecureServicePermission.class, new SecureServicePermissionDeserializer()).create();
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * ONAP CLAMP
- * ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights
- * reserved.
- * ================================================================================
- * 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.
- * ============LICENSE_END============================================
- * ===================================================================
- *
- */
-
-package org.onap.policy.clamp.clds.util;
-
-import com.att.eelf.i18n.EELFResolvableErrorEnum;
-import com.att.eelf.i18n.EELFResourceManager;
-
-public enum LogMessages implements EELFResolvableErrorEnum {
- LOGSERVICE_HELLO_MESSAGE, LOGSERVICE_EMAIL_ERROR, LOGSERVICE_EMAIL_CLASS, LOGSERVICE_EMAIL_CLASS_NULL,
- PROCESS_INSTANCE_ID;
-
- static {
- EELFResourceManager.loadMessageBundle("logmessages");
- }
-}
package org.onap.policy.clamp.loop;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import org.onap.policy.clamp.loop.template.LoopTemplatesRepository;
import org.onap.policy.clamp.loop.template.PolicyModelsRepository;
import org.onap.policy.clamp.policy.PolicyEngineServices;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Qualifier("csarInstaller")
public class CsarInstaller {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(CsarInstaller.class);
+ private static final Logger logger = LoggerFactory.getLogger(CsarInstaller.class);
@Autowired
private PolicyModelsRepository policyModelsRepository;
*/
public void installTheCsar(CsarHandler csar)
throws SdcArtifactInstallerException, InterruptedException, BlueprintParserException {
- logger.info("Installing the CSAR " + csar.getFilePath());
+ logger.info("Installing the CSAR {}", csar.getFilePath());
var associatedService = csarServiceInstaller.installTheService(csar);
cdsDataInstaller.installCdsServiceProperties(csar, associatedService);
installTheLoopTemplates(csar, associatedService);
- logger.info("Successfully installed the CSAR " + csar.getFilePath());
+ logger.info("Successfully installed the CSAR {}", csar.getFilePath());
}
/**
try {
logger.info("Installing the Loops");
for (Entry<String, BlueprintArtifact> blueprint : csar.getMapOfBlueprints().entrySet()) {
- logger.info("Processing blueprint " + blueprint.getValue().getBlueprintArtifactName());
+ logger.info("Processing blueprint {}", blueprint.getValue().getBlueprintArtifactName());
loopTemplatesRepository.save(createLoopTemplateFromBlueprint(csar, blueprint.getValue(), service));
}
logger.info("Successfully installed the Loops ");
package org.onap.policy.clamp.loop.cds;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import org.onap.policy.clamp.clds.client.CdsServices;
import org.onap.policy.clamp.clds.model.cds.CdsBpWorkFlowListResponse;
import org.onap.policy.clamp.loop.service.ServicesRepository;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
@Component
public class CdsDataInstaller {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(CdsDataInstaller.class);
+ private static final Logger logger = LoggerFactory.getLogger(CdsDataInstaller.class);
@Autowired
CdsServices cdsServices;
.add(CONTROLLER_PROPERTIES, controllerProperties);
logger.info("Successfully installed the CDS data in Service");
} else {
- logger.warn("Skipping CDS data installation in Service, as sdnc_model_name and "
- + "sdnc_model_version are not provided in the CSAR");
+ logger.warn(
+ "Skipping CDS data installation in Service, as sdnc_model_name"
+ + " and sdnc_model_version are not provided in the CSAR");
}
}
}
JsonObject workFlowProps = new JsonObject();
for (String workFlow : response.getWorkflows()) {
- logger.info("Found CDS workflow " + workFlow + " for model name " + sdncModelName + " and version "
- + sdncModelVersion);
+ logger.info("Found CDS workflow {} for model name {} and version {}",
+ workFlow, sdncModelName, sdncModelVersion);
JsonObject inputs = queryCdsToGetWorkFlowInputProperties(response.getBlueprintName(),
response.getVersion(), workFlow);
workFlowProps.add(workFlow, inputs);
package org.onap.policy.clamp.loop.components.external;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import java.util.Iterator;
import java.util.LinkedList;
import org.onap.policy.clamp.clds.util.JsonUtils;
import org.onap.policy.clamp.loop.Loop;
import org.onap.policy.clamp.policy.microservice.MicroServicePolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class DcaeComponent extends ExternalComponent {
private static final String INSTALL = "install";
private static final String UNINSTALL = "uninstall";
@Transient
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(DcaeComponent.class);
+ private static final Logger logger = LoggerFactory.getLogger(DcaeComponent.class);
private static final String DCAE_DEPLOYMENT_PREFIX = "CLAMP_";
private static final String DEPLOYMENT_PARAMETER = "dcaeDeployParameters";
if (deploymentProp != null) {
rootObject.add(DCAE_INPUTS, deploymentProp);
}
- logger.info("DCAE Deploy payload for unique blueprint: " + rootObject.toString());
+ logger.info("DCAE Deploy payload for unique blueprint: {}", rootObject);
return rootObject.toString();
}
if (deploymentProp != null) {
rootObject.add(DCAE_INPUTS, deploymentProp);
}
- logger.info("DCAE Deploy payload for multiple blueprints: " + rootObject.toString());
+ logger.info("DCAE Deploy payload for multiple blueprints: {}", rootObject);
return rootObject.toString();
}
public static String getUndeployPayload(Loop loop) {
var rootObject = new JsonObject();
rootObject.addProperty(DCAE_SERVICETYPE_ID, loop.getLoopTemplate().getDcaeBlueprintId());
- logger.info("DCAE Undeploy payload for unique blueprint: " + rootObject.toString());
+ logger.info("DCAE Undeploy payload for unique blueprint: {}", rootObject);
return rootObject.toString();
}
public static String getUndeployPayload(MicroServicePolicy policy) {
var rootObject = new JsonObject();
rootObject.addProperty(DCAE_SERVICETYPE_ID, policy.getDcaeBlueprintId());
- logger.info("DCAE Undeploy payload for multiple blueprints: " + rootObject.toString());
+ logger.info("DCAE Undeploy payload for multiple blueprints: {}", rootObject);
return rootObject.toString();
}
package org.onap.policy.clamp.loop.components.external;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import javax.persistence.Transient;
import org.apache.camel.Exchange;
import org.onap.policy.clamp.loop.Loop;
import org.onap.policy.clamp.policy.pdpgroup.PdpGroupPayload;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class represents the policy state according to all policies involved in the control loop.
public class PolicyComponent extends ExternalComponent {
@Transient
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(PolicyComponent.class);
+ private static final Logger logger = LoggerFactory.getLogger(PolicyComponent.class);
public static final ExternalComponentState IN_ERROR = new ExternalComponentState("IN_ERROR",
"There was an error during the sending to policy, the policy engine may be corrupted or inconsistent", 100);
package org.onap.policy.clamp.loop.service;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import java.util.Map.Entry;
import org.onap.policy.clamp.clds.exception.sdc.controller.SdcArtifactInstallerException;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
import org.onap.sdc.toscaparser.api.NodeTemplate;
import org.onap.sdc.toscaparser.api.Property;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component
@Qualifier("csarInstaller")
public class CsarServiceInstaller {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(CsarServiceInstaller.class);
+ private static final Logger logger = LoggerFactory.getLogger(CsarServiceInstaller.class);
@Autowired
ServicesRepository serviceRepository;
package org.onap.policy.clamp.loop.service;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import com.google.gson.annotations.Expose;
import java.io.Serializable;
import org.hibernate.annotations.TypeDefs;
import org.onap.policy.clamp.clds.util.JsonUtils;
import org.onap.policy.clamp.dao.model.jsontype.StringJsonUserType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@Entity
@Table(name = "services")
private static final long serialVersionUID = 1331119060272760758L;
@Transient
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(Service.class);
+ private static final Logger logger = LoggerFactory.getLogger(Service.class);
@Id
@Column(name = "service_uuid", unique = true)
package org.onap.policy.clamp.policy;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import com.google.gson.annotations.Expose;
import java.io.UnsupportedEncodingException;
import org.onap.policy.clamp.loop.service.Service;
import org.onap.policy.clamp.loop.template.LoopElementModel;
import org.onap.policy.clamp.loop.template.PolicyModel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@MappedSuperclass
@TypeDef(name = "json", typeClass = StringJsonUserType.class)
public abstract class Policy extends AuditEntity {
@Transient
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(Policy.class);
+ private static final Logger logger = LoggerFactory.getLogger(Policy.class);
@Expose
@Type(type = "json")
package org.onap.policy.clamp.policy;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import java.util.LinkedHashMap;
import org.apache.camel.CamelContext;
import org.onap.policy.clamp.loop.template.PolicyModel;
import org.onap.policy.clamp.loop.template.PolicyModelsService;
import org.onap.policy.models.pdp.concepts.PdpGroups;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
private static final String RAISE_EXCEPTION_FLAG = "raiseHttpExceptionFlag";
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(PolicyEngineServices.class);
+ private static final Logger logger = LoggerFactory.getLogger(PolicyEngineServices.class);
private int retryInterval = 0;
private int retryLimit = 1;
return null;
}
} else {
- logger.info("Skipping policy model download as it exists already in the database " + policyType
- + "/" + policyVersion);
+ logger.info("Skipping policy model download as it exists already in the database {} / {}",
+ policyType, policyVersion);
return policyModelFound;
}
}
* @return A string with the whole policy tosca model
*/
public String downloadOnePolicyToscaModel(String policyType, String policyVersion) {
- logger.info("Downloading the policy tosca model " + policyType + "/" + policyVersion);
+ logger.info("Downloading the policy tosca model {} / {}",
+ policyType, policyVersion);
var options = new DumperOptions();
options.setDefaultScalarStyle(DumperOptions.ScalarStyle.PLAIN);
options.setIndent(4);
.is2xxSuccessful()) {
return (String) exchangeResponse.getIn().getBody();
} else {
- logger.info(logMsg + " query " + retryInterval + "ms before retrying ...");
+ logger.info("{} query ms before retrying {} ...", logMsg, retryInterval);
// wait for a while and try to connect to DCAE again
Thread.sleep(retryInterval);
}
} catch (IOException e) {
- logger.error("IOException caught when trying to call Camel flow:" + camelFlow, e);
+ logger.error("IOException caught when trying to call Camel flow: {}", camelFlow, e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
package org.onap.policy.clamp.policy;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import java.io.UnsupportedEncodingException;
import org.apache.commons.lang3.StringUtils;
import org.json.JSONObject;
import org.onap.policy.clamp.clds.util.JsonUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;
/**
*/
public class PolicyPayload {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(PolicyPayload.class);
+ private static final Logger logger = LoggerFactory.getLogger(PolicyPayload.class);
private static JsonObject createJsonFromPolicyTosca(String toscaContent) {
Map<String, Object> map =
policyDetails.add("properties", policyProperties);
String policyPayload = JsonUtils.GSON.toJson(policyPayloadResult);
- logger.info("Policy payload: " + policyPayload);
+ logger.info("Policy payload: {}", policyPayload);
return policyPayload;
}
}
\ No newline at end of file
package org.onap.policy.clamp.policy.downloader;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.time.Instant;
import org.json.simple.parser.ParseException;
import org.onap.policy.clamp.loop.template.PolicyModelsRepository;
import org.onap.policy.clamp.policy.PolicyEngineServices;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
@Profile("clamp-policy-controller")
public class PolicyEngineController {
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(PolicyEngineController.class);
- protected static final EELFLogger auditLogger = EELFManager.getInstance().getAuditLogger();
- protected static final EELFLogger metricsLogger = EELFManager.getInstance().getMetricsLogger();
+ protected static final Logger logger = LoggerFactory.getLogger(PolicyEngineController.class);
public static final String POLICY_RETRY_INTERVAL = "policy.retry.interval";
public static final String POLICY_RETRY_LIMIT = "policy.retry.limit";
package org.onap.policy.clamp.policy.operational;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonObject;
import com.google.gson.annotations.Expose;
import java.io.Serializable;
import org.onap.policy.clamp.loop.template.LoopElementModel;
import org.onap.policy.clamp.loop.template.PolicyModel;
import org.onap.policy.clamp.policy.Policy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@Entity
@Table(name = "operational_policies")
private static final long serialVersionUID = 6117076450841538255L;
@Transient
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(OperationalPolicy.class);
+ private static final Logger logger = LoggerFactory.getLogger(OperationalPolicy.class);
@Id
@Expose
package org.onap.policy.clamp.policy.operational;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import org.onap.policy.clamp.clds.util.JsonUtils;
import org.onap.policy.clamp.clds.util.ResourceFileUtils;
import org.onap.policy.clamp.loop.service.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class OperationalPolicyRepresentationBuilder {
- private static final EELFLogger logger =
- EELFManager.getInstance().getLogger(OperationalPolicyRepresentationBuilder.class);
+ private static final Logger logger =
+ LoggerFactory.getLogger(OperationalPolicyRepresentationBuilder.class);
public static final String PROPERTIES = "properties";
public static final String ITEMS = "items";
package org.onap.policy.clamp.policy.operational;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.onap.policy.clamp.loop.Loop;
import org.onap.policy.clamp.loop.template.PolicyModelsRepository;
import org.onap.policy.clamp.policy.PolicyService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
private final PolicyModelsRepository policyModelsRepository;
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(OperationalPolicyService.class);
+ private static final Logger logger = LoggerFactory.getLogger(OperationalPolicyService.class);
@Autowired
public OperationalPolicyService(OperationalPolicyRepository repository,
package org.onap.policy.clamp.policy.pdpgroup;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.google.gson.JsonElement;
import java.util.ArrayList;
import java.util.Arrays;
import org.onap.policy.models.pdp.concepts.DeploymentGroups;
import org.onap.policy.models.pdp.concepts.DeploymentSubGroup;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This is an utility class that build the PDP group policy payload.
*/
public class PdpGroupPayload {
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(PdpGroupPayload.class);
+ private static final Logger logger = LoggerFactory.getLogger(PdpGroupPayload.class);
/**
* The default node that will contain the actions array.
if (opParams.length == 5) {
this.updatePdpGroupMap(opParams[1], opParams[2], opParams[3], opParams[4], opParams[0]);
} else {
- logger.error("One PDP push command does not contain the right number of arguments: " + action);
+ logger.error("One PDP push command does not contain the right number of arguments: {}", action);
throw new PdpGroupPayloadException(
"One PDP push command does not contain the right number of arguments: " + action);
}
*/
public String generatePdpGroupPayload() {
String payload = JsonUtils.GSON.toJson(this.deploymentGroups);
- logger.info("PdpGroup policy payload: " + payload);
+ logger.info("PdpGroup policy payload: {}", payload);
return payload;
}
}
package org.onap.policy.clamp.util;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import java.io.IOException;
import org.onap.aaf.cadi.Symm;
import org.onap.policy.clamp.clds.util.ResourceFileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* PassDecoder for decrypting the truststore and keystore password.
/**
* Used to log PassDecoder class.
*/
- private static final EELFLogger logger = EELFManager.getInstance().getLogger(PassDecoder.class);
+ private static final Logger logger = LoggerFactory.getLogger(PassDecoder.class);
/**
* Decode the password.
async.max.pool.size=20
async.queue.capacity=500
-#For EELF logback file
+#For logback file
#clamp.config.logback.path=
clamp.config.logback.filename=logback-default.xml
#The log folder that will be used in logback.xml file
async.max.pool.size=20
async.queue.capacity=500
-#For EELF logback file
+#For logback file
#clamp.config.logback.path=
clamp.config.logback.filename=logback-default.xml
#The log folder that will be used in logback.xml file
<totalSizeCap>1GB</totalSizeCap>
</rollingPolicy>
</appender>
+ <appender name="asyncError" class="ch.qos.logback.classic.AsyncAppender">
+ <queueSize>256</queueSize>
+ <appender-ref ref="ERROR" />
+ </appender>
<appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${logDirectory}/debug.log</file>
<totalSizeCap>1GB</totalSizeCap>
</rollingPolicy>
</appender>
-
+ <appender name="asyncDebug" class="ch.qos.logback.classic.AsyncAppender">
+ <queueSize>256</queueSize>
+ <appender-ref ref="DEBUG" />
+ </appender>
<appender name="AUDIT" class="ch.qos.logback.core.rolling.RollingFileAppender">
- <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
- <evaluator class="ch.qos.logback.classic.boolex.OnMarkerEvaluator">
- <marker>ENTRY</marker>
- <marker>EXIT</marker>
- </evaluator>
- <onMismatch>DENY</onMismatch>
- <onMatch>ACCEPT</onMatch>
- </filter>
+ <filter class="org.onap.policy.clamp.clds.util.LoggerMarkerFilter$AuditLoggerMarkerFilter" />
<file>${logDirectory}/audit.log</file>
- <append>true</append>
<encoder>
<pattern>${auditPattern}</pattern>
</encoder>
<totalSizeCap>1GB</totalSizeCap>
</rollingPolicy>
</appender>
- <appender name="asyncEELFAudit" class="ch.qos.logback.classic.AsyncAppender">
+ <appender name="asyncAudit" class="ch.qos.logback.classic.AsyncAppender">
<queueSize>256</queueSize>
<appender-ref ref="AUDIT" />
</appender>
<appender name="METRIC" class="ch.qos.logback.core.rolling.RollingFileAppender">
- <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
- <evaluator class="ch.qos.logback.classic.boolex.OnMarkerEvaluator">
- <marker>INVOKE</marker>
- <marker>INVOKE-RETURN</marker>
- </evaluator>
- <onMismatch>DENY</onMismatch>
- <onMatch>ACCEPT</onMatch>
- </filter>
+ <filter class="org.onap.policy.clamp.clds.util.LoggerMarkerFilter$MetricLoggerMarkerFilter" />
<file>${logDirectory}/metric.log</file>
- <append>true</append>
<encoder>
<pattern>${metricPattern}</pattern>
</encoder>
<totalSizeCap>1GB</totalSizeCap>
</rollingPolicy>
</appender>
-
- <appender name="asyncEELFMetrics" class="ch.qos.logback.classic.AsyncAppender">
+ <appender name="asyncMetric" class="ch.qos.logback.classic.AsyncAppender">
<queueSize>256</queueSize>
<appender-ref ref="METRIC" />
</appender>
<!-- SECURITY related loggers -->
<appender name="SECURITY" class="ch.qos.logback.core.rolling.RollingFileAppender">
+ <filter class="org.onap.policy.clamp.clds.util.LoggerMarkerFilter$SecurityLoggerMarkerFilter" />
<file>${logDirectory}/security.log</file>
- <append>true</append>
<encoder>
<pattern>%X{EntryTimestamp}|%date{yyyy-MM-dd'T'HH:mm:ss.SSSXXX,UTC}|%X{RequestID}|%X{ServiceInstanceId}|%.20thread|%X{VirtualServerName}|%X{ServiceName}|%X{PartnerName}|%X{StatusCode}|%X{ResponseCode}|%X{ResponseDescription}|%X{InstanceUUID}|%.-5level|%X{AlertSeverity}|%X{ServerIPAddress}|%X{ElapsedTime}|%X{ServerFQDN}|%X{RemoteHost}|%X{ClassName}|%X{Unused}|%X{ProcessKey}|%X{CustomField1}|%X{CustomField2}|%X{CustomField3}|%X{CustomField4}|%msg%n
</pattern>
<totalSizeCap>1GB</totalSizeCap>
</rollingPolicy>
</appender>
-
- <appender name="asyncEELFSecurity" class="ch.qos.logback.classic.AsyncAppender">
+ <appender name="asyncSecurity" class="ch.qos.logback.classic.AsyncAppender">
<queueSize>256</queueSize>
<appender-ref ref="SECURITY" />
</appender>
+
<!-- logback jms appenders & loggers definition starts here -->
<appender name="auditLogs" class="ch.qos.logback.core.rolling.RollingFileAppender">
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<appender-ref ref="DEBUG" />
</logger>
- <logger name="com.att.eelf.error" level="OFF">
- <appender-ref ref="ERROR" />
- </logger>
- <!-- EELF related loggers -->
- <logger name="com.att.eelf.audit" level="INFO" additivity="false">
- <appender-ref ref="asyncEELFAudit" />
- </logger>
- <logger name="com.att.eelf.metrics" level="DEBUG" additivity="false">
- <appender-ref ref="asyncEELFMetrics" />
- </logger>
- <logger name="com.att.eelf.security" level="DEBUG" additivity="false">
- <appender-ref ref="asyncEELFSecurity" />
- </logger>
-
<!-- logback internals logging -->
<logger name="ch.qos.logback.classic" level="INFO" />
<logger name="ch.qos.logback.core" level="INFO" />
<!-- logback jms appenders & loggers definition ends here -->
<root level="DEBUG">
- <appender-ref ref="DEBUG" />
- <appender-ref ref="STDOUT" />
- <appender-ref ref="AUDIT" />
- <appender-ref ref="METRIC" />
- <appender-ref ref="ERROR" />
+ <appender-ref ref="asyncDebug" />
+ <appender-ref ref="asyncError" />
+ <appender-ref ref="asyncAudit" />
+ <appender-ref ref="asyncMetric" />
+ <appender-ref ref="asyncSecurity" />
</root>
</included>
import static org.apache.commons.io.FileUtils.copyInputStreamToFile;
-import com.att.eelf.configuration.EELFLogger;
-import com.att.eelf.configuration.EELFManager;
import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.command.BuildImageResultCallback;
import com.github.dockerjava.api.command.CreateContainerResponse;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;
@Value("${server.port}")
private String httpPort;
private static final int TIMEOUT_S = 150;
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(RobotItCase.class);
+ protected static final Logger logger = LoggerFactory.getLogger(RobotItCase.class);
@Test
public void robotTests() throws Exception {
exec = client.inspectContainerCmd(id).exec();
tries++;
} while (exec.getState().getRunning() && tries < TIMEOUT_S);
- logger.info("RobotFramework result:" + exec.getState());
+ logger.info("RobotFramework result: {}", exec.getState());
LogContainerCmd logContainerCmd = client.logContainerCmd(id);
logContainerCmd.withStdOut(true).withStdErr(true);
new File("target/robotframework/report.html"));
client.stopContainerCmd(id);
- logger.info("RobotFramework output.xml file: " + FileUtils.fileRead("target/robotframework/output.xml"));
+ logger.info("RobotFramework output.xml file: {}", FileUtils.fileRead("target/robotframework/output.xml"));
Assert.assertEquals(exec.getState().getError(), 0L,
Objects.requireNonNull(exec.getState().getExitCodeLong()).longValue());
package org.onap.policy.clamp.clds.util;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
async.max.pool.size=20
async.queue.capacity=500
-#For EELF logback file
-#com.att.eelf.logging.path=
+#For logback file
clamp.config.logback.filename=logback-default.xml
#The log folder that will be used in logback.xml file
clamp.config.log.path=log
camel.springboot.tracing=true
camel.springboot.message-history=true
-#For EELF logback file
-#com.att.eelf.logging.path=
-com.att.eelf.logging.file=logback-default.xml
+#For logback file
+clamp.config.logback.filename=logback-default.xml
#The log folder that will be used in logback.xml file
clamp.config.log.path=log
clamp.config.cadi.oauthIntrospectUrll=https://AAF_LOCATE_URL/locate/onap.org.osaaf.aaf.introspect:2.1/introspect
clamp.config.cadi.aafEnv=DEV
clamp.config.cadi.aafUrl=https://AAF_LOCATE_URL/onap.org.osaaf.aaf.service:2.1
-clamp.config.cadi.cadiX509Issuers=CN=intermediateCA_1, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_7, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_9, OU=OSAAF, O=ONAP, C=US
\ No newline at end of file
+clamp.config.cadi.cadiX509Issuers=CN=intermediateCA_1, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_7, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_9, OU=OSAAF, O=ONAP, C=US
</logger>
<!-- CLDS related loggers -->
- <logger
- name="com.att.eelf.error"
- level="OFF">
- <appender-ref ref="STDOUT" />
- </logger>
-
<logger
name="ch.qos.logback.classic"
level="INFO" >
async.max.pool.size=20
async.queue.capacity=500
-#For EELF logback file
-#com.att.eelf.logging.path=
+#For logback file
clamp.config.logback.filename=logback-default.xml
#The log folder that will be used in logback.xml file
clamp.config.log.path=log
## Tosca converter
clamp.config.tosca.converter.json.schema.templates=classpath:/clds/tosca-converter/templates.json
clamp.config.tosca.converter.default.datatypes=classpath:/clds/tosca-converter/default-tosca-types.yaml
-clamp.config.tosca.converter.dictionary.support.enabled=true
\ No newline at end of file
+clamp.config.tosca.converter.dictionary.support.enabled=true
Code Review / policy / clamp.git / commitdiff