+++ /dev/null
-Bag Attributes
- friendlyName: clamp@clamp.onap.org
- localKeyID: 54 69 6D 65 20 31 35 33 30 36 32 36 36 37 38 32 30 31
-Key Attributes: <No Attributes>
------BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHXy3ZbCHGPhEe
-hvmv44infMBmJv5UAz4cxI6zUJV4mDXyjJxMy0hbjSZx9x6sZSBDXeiWwz6pQafk
-VKP06BfBmjvJz0d07pRugI5tczLyJIm8umPJ2igTPjAj/+NuO6Dwt0XeGPVF7otx
-0IB96RFFSE8bsTIXrUW9Eg8/oKicjhCbvJnxv49aj6Po23o2+59t2t8SotccRt2A
-bkMpAy1wh2qUcRveSkrXnT8IbvxwwgdYM/07OwcQTVIbKPiSDsdxO4bUdL8cAZ/3
-S4ulB33QzNAII2syzWAl6pY53Mjl8tJEIirt2OvNyKNjFYh3m+UcGuhoquVHm1Ev
-ZH5DLtWJAgMBAAECggEAIxvywggVxohlkV+plrzV8tC4PQT+4qKTjJNcod0+BTeg
-wG7ck3V075Jiw80F3MwOK27dJ7eIUFwcicwR923ryQ81GivjZIcjInaHHmUcAqJG
-kzKrof9F8WWRKrXEQkRD6kAMELmKb987NTbHeeTSQsYiEDlbHepIjqwgfU74gmD+
-hJ/w4K9wcAEfbxLvo/Iks45Dx7+ruYNGt48xJ6Or2kyKmOAdmojvK3SlJXv+DzNv
-CYzRE577oxw7eTw85XTz2R4BEE4U1PJOJ3J1gcGeI93Sv/nKkr3etEy1Ovqza/iR
-zWOVhh/VreJSso4ejlv8U9lwcvYMIAo5P44JVMW/EQKBgQDt8PzTzNU6lewCF00Q
-q6LthcCKozICQgzpP4s1IrgFxIYGuLVt2JRSKgZq56IkpH5OAJHducWu5NGmwrya
-PU8j44Tuhw4qWT7QB/rx3AezMsOxZyNWOlXIpkis3qy2WL6Jth1/kfcuTpGp0Fqu
-ENhdyulPyuTA3OYwQwOMfWPfRQKBgQDWgNC7X0TDd7NIYJOFOtTVAUH7wJJcHOeh
-5WlIejKABcnfEaQoDVRVbwS53K1EJtJkV5HqnVbtbdTqduKji4TOVzdEeHPMZF/b
-aIZTdtAaWaC37oN/L/TGoY+7n9Hbhp3OpQMeWxNGyUeZLH+DrqSXiSQxFcQ15OY1
-49rE8o3PdQKBgQCj8Q4SVKh6FEAndKyJlujMZQKzwxu6yI2izEB7HO/UMYLy8KM5
-CyeusPv4/p4ORzQrRGM8dTpKdagqETTnxORZYvL9chqFfTY1GbqCmErJ4mlJOzny
-uIDQnhmm2kn/3Ydy1QLgGc9InaPpcAB6vGqHvT4h1zbj14/WouW4D9EXTQKBgDpA
-xW79UmlbKp8vSyDVd1NZghfillzZpLY83TjHpstJxycDXXdbF1oUSk5Hde6aNGz3
-szLqA997AmWiX65Wh3yaBvJbW+dYIwgs/L3R+HYPfSw2ZBO4bFs9KRGlN5LMnjKu
-cYhe539DzmP0x7R1S1Gz9tY1uRGB1lswRAtUa9q5AoGAb7bNvexDAmiHAKe96j0A
-tjHAYInJvvont5vdUZipsoY+RbWitsDwv5UsjuRcMkZlMydzQpU0Glc1JcnuJGCf
-AEFex2V9xru1CFJQtWxD7qeIqYlYUPLZuoLVNbgtAXBAFyUjcUeXIAEg4Ti2tlvc
-86nrgb7/kSLXqHV4/Ykg15s=
------END PRIVATE KEY-----
<java.version>1.8</java.version>
<eelf.core.version>1.0.0</eelf.core.version>
+ <logging.analytics.version>1.2.2-SNAPSHOT</logging.analytics.version>
<camel.version>2.22.0</camel.version>
<springboot.version>2.0.2.RELEASE</springboot.version>
<artifactId>eelf-core</artifactId>
<version>${eelf.core.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.onap.logging-analytics</groupId>
+ <artifactId>logging-library</artifactId>
+ <version>${logging.analytics.version}</version>
+ </dependency>
<dependency>
<groupId>org.codehaus.janino</groupId>
<artifactId>janino</artifactId>
private static String doHttpQuery(URL url, String requestMethod, String payload, String contentType)
throws IOException {
+ LoggingUtils utils = new LoggingUtils (logger);
logger.info("Using HTTP URL to contact DCAE:" + url);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+ connection = utils.invoke(connection,"DCAE", requestMethod);
connection.setRequestMethod(requestMethod);
connection.setRequestProperty("X-ECOMP-RequestID", LoggingUtils.getRequestId());
if (payload != null && contentType != null) {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
String responseStr = IOUtils.toString(reader);
logger.info("Response Content: " + responseStr);
+ utils.invokeReturn();
return responseStr;
}
} else {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getErrorStream()))) {
String responseStr = IOUtils.toString(reader);
logger.error(DCAE_REQUEST_FAILED_LOG + responseStr);
+ utils.invokeReturn();
throw new BadRequestException(responseStr);
}
}
private static final String SDC_SERVICE_URL_PROPERTY_NAME = "sdc.serviceUrl";\r
private static final String SDC_INSTANCE_ID_CLAMP = "CLAMP-Tool";\r
private static final String RESOURCE_URL_PREFIX = "resources";\r
+ private static final LoggingUtils utils = new LoggingUtils (logger);\r
@Autowired\r
private ClampProperties refProp;\r
\r
Date startTime = new Date();\r
String baseUrl = refProp.getStringValue(SDC_SERVICE_URL_PROPERTY_NAME);\r
String basicAuth = getSdcBasicAuth();\r
- LoggingUtils.setTargetContext("SDC", "getSdcServicesInformation");\r
try {\r
String url = baseUrl;\r
if (uuid != null && !uuid.isEmpty()) {\r
}\r
URL urlObj = new URL(url);\r
HttpURLConnection conn = (HttpURLConnection) urlObj.openConnection();\r
+ conn = utils.invoke(conn,"SDC", "getSdcServicesInformation");\r
conn.setRequestProperty(refProp.getStringValue(SDC_INSTANCE_ID_PROPERTY_NAME), SDC_INSTANCE_ID_CLAMP);\r
conn.setRequestProperty(HttpHeaders.AUTHORIZATION, basicAuth);\r
conn.setRequestProperty(HttpHeaders.CONTENT_TYPE, "application/json;charset=UTF-8");\r
conn.setRequestMethod("GET");\r
String resp = getResponse(conn);\r
logger.debug("Services list received from SDC:" + resp);\r
- // metrics log\r
- LoggingUtils.setResponseContext("0", "Get sdc services success", this.getClass().getName());\r
+ utils.invokeReturn();\r
return resp;\r
} catch (IOException e) {\r
LoggingUtils.setResponseContext("900", "Get sdc services failed", this.getClass().getName());\r
LoggingUtils.setTimeContext(startTime, new Date());\r
metricsLogger.info("getSdcServicesInformation complete");\r
}\r
+ utils.invokeReturn();\r
return "";\r
}\r
\r
byte[] postData = formattedSdcReq.getBytes(StandardCharsets.UTF_8);\r
int postDataLength = postData.length;\r
HttpURLConnection conn = getSdcHttpUrlConnection(userid, postDataLength, url, formattedSdcReq);\r
+ conn = utils.invoke(conn,"SDC", "uploadArtifact");\r
try (DataOutputStream wr = new DataOutputStream(conn.getOutputStream())) {\r
wr.write(postData);\r
}\r
String responseStr = getResponse(conn);\r
if (responseStr != null && requestFailed) {\r
logger.error("requestFailed - responseStr=" + responseStr);\r
+ utils.invokeReturn();\r
throw new BadRequestException(responseStr);\r
}\r
+ utils.invokeReturn();\r
return responseStr;\r
} catch (IOException e) {\r
logger.error("Exception when attempting to communicate with SDC", e);\r
+ utils.invokeReturn();\r
throw new SdcCommunicationException("Exception when attempting to communicate with SDC", e);\r
}\r
}\r
String urlReworked = removeUnwantedBracesFromString(url);\r
URL urlObj = new URL(urlReworked);\r
HttpURLConnection conn = (HttpURLConnection) urlObj.openConnection();\r
+ conn = utils.invoke(conn,"SDC", "getSdcResources");\r
String basicAuth = getSdcBasicAuth();\r
conn.setRequestProperty(refProp.getStringValue(SDC_INSTANCE_ID_PROPERTY_NAME), SDC_INSTANCE_ID_CLAMP);\r
conn.setRequestProperty(HttpHeaders.AUTHORIZATION, basicAuth);\r
logger.info("Sdc resource url - " + urlReworked + " , responseCode=" + responseCode);\r
try (BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {\r
String response = IOUtils.toString(in);\r
- LoggingUtils.setResponseContext("0", "Get sdc resources success", this.getClass().getName());\r
return response;\r
}\r
} catch (IOException e) {\r
- LoggingUtils.setResponseContext("900", "Get sdc resources failed", this.getClass().getName());\r
LoggingUtils.setErrorContext("900", "Get sdc resources error");\r
logger.error("Exception occurred during query to SDC", e);\r
return "";\r
} catch (DecoderException e) {\r
- LoggingUtils.setResponseContext("900", "Get sdc resources failed", this.getClass().getName());\r
LoggingUtils.setErrorContext("900", "Get sdc resources error");\r
logger.error("Exception when attempting to decode the Hex string", e);\r
throw new SdcCommunicationException("Exception when attempting to decode the Hex string", e);\r
} catch (GeneralSecurityException e) {\r
- LoggingUtils.setResponseContext("900", "Get sdc resources failed", this.getClass().getName());\r
LoggingUtils.setErrorContext("900", "Get sdc resources error");\r
logger.error("Exception when attempting to decrypt the encrypted password", e);\r
throw new SdcCommunicationException("Exception when attempting to decrypt the encrypted password", e);\r
} finally {\r
LoggingUtils.setTimeContext(startTime, new Date());\r
metricsLogger.info("getCldsServicesOrResourcesBasedOnURL completed");\r
+ utils.invokeReturn();\r
}\r
}\r
\r
url = url + "/" + uploadedArtifactUuid;\r
URL urlObj = new URL(url);\r
HttpURLConnection conn = (HttpURLConnection) urlObj.openConnection();\r
+ conn = utils.invoke(conn,"SDC", "deleteArtifact");\r
conn.setDoOutput(true);\r
conn.setRequestProperty(refProp.getStringValue(SDC_INSTANCE_ID_PROPERTY_NAME), sdcXonapInstanceId);\r
conn.setRequestProperty(HttpHeaders.AUTHORIZATION, basicAuth);\r
responseStr = getResponse(conn);\r
if (responseStr != null && requestFailed) {\r
logger.error("requestFailed - responseStr=" + responseStr);\r
+ utils.invokeReturn();\r
throw new BadRequestException(responseStr);\r
}\r
}\r
+ utils.invokeReturn();\r
return responseStr;\r
} catch (IOException | DecoderException | GeneralSecurityException e) {\r
logger.error("Exception when attempting to communicate with SDC", e);\r
+ utils.invokeReturn();\r
throw new SdcCommunicationException("Exception when attempting to communicate with SDC", e);\r
}\r
}\r
import java.util.Optional;
import java.util.UUID;
+import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.BadRequestException;
import javax.ws.rs.NotAuthorizedException;
import javax.xml.transform.TransformerException;
import org.onap.clamp.clds.transform.XslTransformer;
import org.onap.clamp.clds.util.JacksonUtils;
import org.onap.clamp.clds.util.LoggingUtils;
+import org.onap.logging.ref.slf4j.ONAPLogConstants;
+import org.slf4j.event.Level;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
@Produce(uri = "direct:processSubmit")
private CamelProxy camelProxy;
protected static final EELFLogger securityLogger = EELFManager.getInstance().getSecurityLogger();
+ protected static final EELFLogger logger = EELFManager.getInstance().getLogger(CldsService.class);
public static final String GLOBAL_PROPERTIES_KEY = "files.globalProperties";
private final String cldsPersmissionTypeCl;
private final SdcCatalogServices sdcCatalogServices;
private final DcaeDispatcherServices dcaeDispatcherServices;
private final DcaeInventoryServices dcaeInventoryServices;
+ private LoggingUtils util = new LoggingUtils(logger);
+ @Autowired
+ private HttpServletRequest request;
@Autowired
public CldsService(CldsDao cldsDao, XslTransformer cldsBpmnTransformer, ClampProperties refProp,
SdcCatalogServices sdcCatalogServices, DcaeDispatcherServices dcaeDispatcherServices,
* ClosedLoop in CLDS application.
*/
public List<CldsMonitoringDetails> getCLDSDetails() {
+ util.entering(request, "CldsService: GET model details");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET model details", getPrincipalName());
List<CldsMonitoringDetails> cldsMonitoringDetailsList = cldsDao.getCLDSMonitoringDetails();
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get cldsDetails success", this.getClass().getName());
auditLogger.info("GET cldsDetails completed");
+ util.exiting("200", "Get cldsDetails success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return cldsMonitoringDetailsList;
}
* is currently installed from pom.xml file 3. User permissions
*/
public CldsInfo getCldsInfo() {
+ util.entering(request, "CldsService: GET cldsInfo");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET cldsInfo", getPrincipalName());
LoggingUtils.setTimeContext(startTime, new Date());
CldsInfoProvider cldsInfoProvider = new CldsInfoProvider(this);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get cldsInfo success", this.getClass().getName());
securityLogger.info("GET cldsInfo completed");
+ util.exiting("200", "Get cldsInfo success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return cldsInfo;
}
* @return bpmn xml text - content of bpmn given name
*/
public String getBpmnXml(String modelName) {
+ util.entering(request, "CldsService: GET model bpmn");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET model bpmn", getPrincipalName());
isAuthorized(permissionReadCl);
logger.info("GET bpmnText for modelName={}", modelName);
CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get model bpmn success", this.getClass().getName());
auditLogger.info("GET model bpmn completed");
+ util.exiting("200", "Get model bpmn success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return model.getBpmnText();
}
* @return image xml text - content of image given name
*/
public String getImageXml(String modelName) {
+ util.entering(request, "CldsService: GET model image");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET model image", getPrincipalName());
isAuthorized(permissionReadCl);
logger.info("GET imageText for modelName={}", modelName);
CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get model image success", this.getClass().getName());
auditLogger.info("GET model image completed");
+ util.exiting("200", "Get model image success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return model.getImageText();
}
* @return clds model - clds model for the given model name
*/
public CldsModel getModel(String modelName) {
+ util.entering(request, "CldsService: GET model");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET model", getPrincipalName());
isAuthorized(permissionReadCl);
logger.debug("GET model for modelName={}", modelName);
CldsModel cldsModel = CldsModel.retrieve(cldsDao, modelName, false);
}
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get model success", this.getClass().getName());
auditLogger.info("GET model completed");
+ util.exiting("200", "Get model success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return cldsModel;
}
* @param modelName
*/
public CldsModel putModel(String modelName, CldsModel cldsModel) {
+ util.entering(request, "CldsService: PUT model");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: PUT model", getPrincipalName());
isAuthorized(permissionUpdateCl);
isAuthorizedForVf(cldsModel);
logger.info("PUT model for modelName={}", modelName);
cldsModel.save(cldsDao, getUserId());
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Put model success", this.getClass().getName());
auditLogger.info("PUT model completed");
+ util.exiting("200", "Put model success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return cldsModel;
}
* @return model names in JSON
*/
public List<ValueItem> getModelNames() {
+ util.entering(request, "CldsService: GET model names");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET model names", getPrincipalName());
isAuthorized(permissionReadCl);
logger.info("GET list of model names");
List<ValueItem> names = cldsDao.getBpmnNames();
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get model names success", this.getClass().getName());
auditLogger.info("GET model names completed");
+ util.exiting("200", "Get model names success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return names;
}
public ResponseEntity<?> putModelAndProcessAction(String action,
String modelName,String test, CldsModel model)
throws TransformerException, ParseException {
+ util.entering(request, "CldsService: Process model action");
Date startTime = new Date();
CldsModel retrievedModel = null;
Boolean errorCase = false;
try {
- LoggingUtils.setRequestContext("CldsService: Process model action", getPrincipalName());
String actionCd = action.toUpperCase();
SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
cldsPermissionInstance, actionCd);
}
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Process model action success", this.getClass().getName());
auditLogger.info("Process model action completed");
} else {
logger.error("CldsModel not found in database with modelName: " + modelName);
+ util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "CldsModel not found in database with modelName " + "modelName", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
return new ResponseEntity<String>("CldsModel not found in database with modelName: \" + modelName", HttpStatus.INTERNAL_SERVER_ERROR);
}
} catch (Exception e) {
logger.error("Exception occured during putModelAndProcessAction", e);
}
if (errorCase) {
+ util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "putModelAndProcessAction failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
return new ResponseEntity<>(retrievedModel, HttpStatus.INTERNAL_SERVER_ERROR);
}
+ util.exiting(HttpStatus.OK.toString(), "Successful", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return new ResponseEntity<>(retrievedModel, HttpStatus.OK);
}
* @param dcaeEvent
*/
public String postDcaeEvent(String test, DcaeEvent dcaeEvent) {
+ util.entering(request, "CldsService: Post dcae event");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: Post dcae event", getPrincipalName());
String userid = null;
// TODO: allow auth checking to be turned off by removing the permission
// type property
}
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Post dcae event success", this.getClass().getName());
auditLogger.info("Post dcae event completed");
+ util.exiting("200", "Post dcae event success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return msgInfo;
}
* In case of issues with the decoding of the Hex String
*/
public String getSdcServices() throws GeneralSecurityException, DecoderException {
+ util.entering(request, "CldsService: GET sdc services");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET sdc services", getPrincipalName());
String retStr;
try {
retStr = createUiServiceFormatJson(sdcCatalogServices.getSdcServicesInformation(null));
logger.info("value of sdcServices : {}", retStr);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get sdc services success", this.getClass().getName());
auditLogger.info("GET sdc services completed");
+ util.exiting("200", "Get sdc services success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return retStr;
}
public String getSdcPropertiesByServiceUUIDForRefresh(
String serviceInvariantUUID, Boolean refresh)
throws GeneralSecurityException, DecoderException, IOException {
+ util.entering(request, "CldsService: GET sdc properties by uuid");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: GET sdc properties by uuid", getPrincipalName());
CldsServiceData cldsServiceData = new CldsServiceData();
cldsServiceData.setServiceInvariantUUID(serviceInvariantUUID);
if (!Optional.ofNullable(refresh).orElse(false)) {
String sdcProperties = sdcCatalogServices.createPropertiesObjectByUUID(cldsServiceData);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get sdc properties by uuid success", this.getClass().getName());
auditLogger.info("GET sdc properties by uuid completed");
+ util.exiting("200", "Get sdc properties by uuid success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return sdcProperties;
}
}
public ResponseEntity<CldsModel> deployModel(String modelName, CldsModel model) {
+ util.entering(request, "CldsService: Deploy model");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: Deploy model", getPrincipalName());
Boolean errorCase = false;
try {
fillInCldsModel(model);
model.save(cldsDao, getUserId());
} else {
logger.info("Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
+ util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "DeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
"Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
}
logger.info("Deploy model (" + modelName + ") succeeded...Deployment Id is - " + deploymentId);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Deploy model success", this.getClass().getName());
auditLogger.info("Deploy model completed");
} catch (Exception e) {
errorCase = true;
logger.error("Exception occured during deployModel", e);
}
if (errorCase) {
+ util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "DeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
return new ResponseEntity<>(model, HttpStatus.INTERNAL_SERVER_ERROR);
}
+ util.exiting(HttpStatus.OK.toString(), "Successful", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return new ResponseEntity<>(model, HttpStatus.OK);
}
public ResponseEntity<CldsModel> unDeployModel(String modelName, CldsModel model) {
+ util.entering(request, "CldsService: Undeploy model");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsService: Undeploy model", getPrincipalName());
Boolean errorCase = false;
try {
SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
model.save(cldsDao, getUserId());
} else {
logger.info("Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
+ util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "UndeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
"Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
}
logger.info("Undeploy model (" + modelName + ") succeeded.");
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Undeploy model success", this.getClass().getName());
auditLogger.info("Undeploy model completed");
} catch (Exception e) {
errorCase = true;
logger.error("Exception occured during unDeployModel", e);
}
if (errorCase) {
+ util.exiting(HttpStatus.INTERNAL_SERVER_ERROR.toString(), "UndeployModel failed", Level.INFO, ONAPLogConstants.ResponseStatus.ERROR);
return new ResponseEntity<>(model, HttpStatus.INTERNAL_SERVER_ERROR);
}
+ util.exiting(HttpStatus.OK.toString(), "Successful", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return new ResponseEntity<>(model, HttpStatus.OK);
}
cldsDao.insEvent(cldsModelName, cldsControlNamePrfx, null, newEvent);
}
}
+
+ // Created for the integration test
+ public void setLoggingUtil (LoggingUtils utilP) {
+ util = utilP;
+ }
}
\ No newline at end of file
import java.util.List;
import javax.annotation.PostConstruct;
+import javax.servlet.http.HttpServletRequest;
import org.onap.clamp.clds.dao.CldsDao;
import org.onap.clamp.clds.model.CldsTemplate;
import org.onap.clamp.clds.model.ValueItem;
import org.onap.clamp.clds.util.LoggingUtils;
+import org.onap.logging.ref.slf4j.ONAPLogConstants;
+import org.slf4j.event.Level;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
private String cldsPermissionInstance;
private SecureServicePermission permissionReadTemplate;
private SecureServicePermission permissionUpdateTemplate;
+ @Autowired
+ private HttpServletRequest request;
@PostConstruct
private final void afterConstruction() {
@Autowired
private CldsDao cldsDao;
+ private LoggingUtils util = new LoggingUtils(logger);
/**
* REST service that retrieves BPMN for a CLDS template name from the
* @return bpmn xml text - content of bpmn given name
*/
public String getBpmnTemplate(String templateName) {
+ util.entering(request, "CldsTemplateService: GET template bpmn");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsTemplateService: GET template bpmn", getPrincipalName());
isAuthorized(permissionReadTemplate);
logger.info("GET bpmnText for templateName=" + templateName);
CldsTemplate template = CldsTemplate.retrieve(cldsDao, templateName, false);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get template bpmn success", this.getClass().getName());
auditLogger.info("GET template bpmn completed");
+ util.exiting("200", "Get template bpmn success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return template.getBpmnText();
}
* @return image xml text - content of image given name
*/
public String getImageXml(String templateName) {
+ util.entering(request, "CldsTemplateService: GET template image");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsTemplateService: GET template image", getPrincipalName());
isAuthorized(permissionReadTemplate);
logger.info("GET imageText for templateName=" + templateName);
CldsTemplate template = CldsTemplate.retrieve(cldsDao, templateName, false);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get template image success", this.getClass().getName());
auditLogger.info("GET template image completed");
+ util.exiting("200", "Get template image success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return template.getImageText();
}
* @return clds template - clds template for the given template name
*/
public CldsTemplate getTemplate(String templateName) {
+ util.entering(request, "CldsTemplateService: GET template");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsTemplateService: GET template", getPrincipalName());
isAuthorized(permissionReadTemplate);
logger.info("GET model for templateName=" + templateName);
CldsTemplate template = CldsTemplate.retrieve(cldsDao, templateName, false);
template.setUserAuthorizedToUpdate(isAuthorizedNoException(permissionUpdateTemplate));
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get template success", this.getClass().getName());
auditLogger.info("GET template completed");
+ util.exiting("200", "Get template success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return template;
}
* @return The CldsTemplate modified and saved in DB
*/
public CldsTemplate putTemplate(String templateName, CldsTemplate cldsTemplate) {
+ util.entering(request, "CldsTemplateService: PUT template");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsTemplateService: PUT template", getPrincipalName());
isAuthorized(permissionUpdateTemplate);
logger.info("PUT Template for templateName=" + templateName);
logger.info("PUT bpmnText=" + cldsTemplate.getBpmnText());
cldsTemplate.save(cldsDao, null);
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Put template success", this.getClass().getName());
auditLogger.info("PUT template completed");
+ util.exiting("200", "Put template success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return cldsTemplate;
}
* @return template names in JSON
*/
public List<ValueItem> getTemplateNames() {
+ util.entering(request, "CldsTemplateService: GET template names");
Date startTime = new Date();
- LoggingUtils.setRequestContext("CldsTemplateService: GET template names", getPrincipalName());
isAuthorized(permissionReadTemplate);
logger.info("GET list of template names");
List<ValueItem> names = cldsDao.getTemplateNames();
// audit log
LoggingUtils.setTimeContext(startTime, new Date());
- LoggingUtils.setResponseContext("0", "Get template names success", this.getClass().getName());
auditLogger.info("GET template names completed");
+ util.exiting("200", "Get template names success", Level.INFO, ONAPLogConstants.ResponseStatus.COMPLETED);
return names;
}
+
+ // Created for the integration test
+ public void setLoggingUtil (LoggingUtils utilP) {
+ util = utilP;
+ }
}
\r
package org.onap.clamp.clds.util;\r
\r
+import com.att.eelf.configuration.EELFLogger;\r
+import com.att.eelf.configuration.EELFManager;\r
+\r
+import java.net.HttpURLConnection;\r
import java.net.InetAddress;\r
import java.net.UnknownHostException;\r
import java.text.DateFormat;\r
import java.util.Date;\r
import java.util.TimeZone;\r
import java.util.UUID;\r
+import java.time.ZoneOffset;\r
+import java.time.ZonedDateTime;\r
+import java.time.format.DateTimeFormatter;\r
import javax.validation.constraints.NotNull;\r
+import javax.servlet.http.HttpServletRequest;\r
+\r
import org.slf4j.MDC;\r
+import org.slf4j.event.Level;\r
+import org.springframework.security.core.context.SecurityContextHolder;\r
\r
-import com.att.eelf.configuration.EELFLogger;\r
-import com.att.eelf.configuration.EELFManager;\r
+import org.onap.clamp.clds.service.DefaultUserNameHandler;\r
+import org.onap.logging.ref.slf4j.ONAPLogConstants;\r
\r
/**\r
* This class handles the special info that appear in the log, like RequestID,\r
* time context, ...\r
*/\r
-public final class LoggingUtils {\r
- \r
- protected static final EELFLogger logger = EELFManager.getInstance().getLogger(LoggingUtils.class);\r
+public class LoggingUtils {\r
+ protected static final EELFLogger logger = EELFManager.getInstance().getLogger(LoggingUtils.class);\r
\r
private static final DateFormat DATE_FORMAT = createDateFormat();\r
\r
+ /** String constant for messages <tt>ENTERING</tt>, <tt>EXITING</tt>, etc. */\r
+ private static final String EMPTY_MESSAGE = "";\r
+ private static final String INVOCATIONID_OUT = "InvocationIDOut";\r
+ private static final String TARGET_ENTITY = "TargetEngity";\r
+\r
+ /** Logger delegate. */\r
+ private EELFLogger mLogger;\r
+ /** Automatic UUID, overrideable per adapter or per invocation. */\r
+ private static UUID sInstanceUUID = UUID.randomUUID();\r
/**\r
- * Private constructor to avoid creating instances of util class.\r
+ * Constructor\r
*/\r
- private LoggingUtils() {\r
+ public LoggingUtils(final EELFLogger loggerP) {\r
+ this.mLogger = checkNotNull(loggerP);\r
}\r
\r
/**\r
//Defaulting to HTTP/1.1 protocol\r
MDC.put("Protocol", "HTTP/1.1");\r
try {\r
- MDC.put("ServerFQDN", InetAddress.getLocalHost().getCanonicalHostName());\r
- MDC.put("ServerIPAddress", InetAddress.getLocalHost().getHostAddress());\r
+ MDC.put("ServerFQDN", InetAddress.getLocalHost().getCanonicalHostName());\r
+ MDC.put("ServerIPAddress", InetAddress.getLocalHost().getHostAddress());\r
} catch (UnknownHostException e) {\r
- logger.error("Failed to initiate setRequestContext", e);\r
+ logger.error("Failed to initiate setRequestContext", e);\r
}\r
}\r
\r
* @return A string with the request ID\r
*/\r
public static String getRequestId() {\r
- String requestId;\r
-\r
- requestId = (String) MDC.get("RequestID");\r
+ String requestId = (String) MDC.get(ONAPLogConstants.MDCs.REQUEST_ID);\r
if (requestId == null || requestId.isEmpty()) {\r
requestId = UUID.randomUUID().toString();\r
- MDC.put("RequestId", requestId);\r
+ MDC.put(ONAPLogConstants.MDCs.REQUEST_ID, requestId);\r
}\r
return requestId;\r
}\r
dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));\r
return dateFormat;\r
}\r
+ \r
+ \r
+ \r
+ /*********************************************************************************************\r
+ * Method for ONAP Application Logging Specification v1.2\r
+ ********************************************************************************************/\r
+\r
+ /**\r
+ * Report <tt>ENTERING</tt> marker.\r
+ *\r
+ * @param request non-null incoming request (wrapper).\r
+ * @return this.\r
+ */\r
+ public void entering(HttpServletRequest request, String serviceName) {\r
+ checkNotNull(request);\r
+ // Extract MDC values from standard HTTP headers.\r
+ final String requestID = defaultToUUID(request.getHeader(ONAPLogConstants.Headers.REQUEST_ID));\r
+ final String invocationID = defaultToUUID(request.getHeader(ONAPLogConstants.Headers.INVOCATION_ID));\r
+ final String partnerName = defaultToEmpty(request.getHeader(ONAPLogConstants.Headers.PARTNER_NAME));\r
+ \r
+ // Default the partner name to the user name used to login to clamp\r
+ if (partnerName.equalsIgnoreCase(EMPTY_MESSAGE)) {\r
+ MDC.put(ONAPLogConstants.MDCs.PARTNER_NAME, new DefaultUserNameHandler().retrieveUserName(SecurityContextHolder.getContext()));\r
+ }\r
+\r
+ // Set standard MDCs. Override this entire method if you want to set\r
+ // others, OR set them BEFORE or AFTER the invocation of #entering,\r
+ // depending on where you need them to appear, OR extend the\r
+ // ServiceDescriptor to add them.\r
+ MDC.put(ONAPLogConstants.MDCs.ENTRY_TIMESTAMP,\r
+ ZonedDateTime.now(ZoneOffset.UTC)\r
+ .format(DateTimeFormatter.ISO_INSTANT));\r
+ MDC.put(ONAPLogConstants.MDCs.REQUEST_ID, requestID);\r
+ MDC.put(ONAPLogConstants.MDCs.INVOCATION_ID, invocationID);\r
+ MDC.put(ONAPLogConstants.MDCs.CLIENT_IP_ADDRESS, defaultToEmpty(request.getRemoteAddr()));\r
+ MDC.put(ONAPLogConstants.MDCs.SERVER_FQDN, defaultToEmpty(request.getServerName()));\r
+ MDC.put(ONAPLogConstants.MDCs.INSTANCE_UUID, defaultToEmpty(sInstanceUUID));\r
+\r
+ // Default the service name to the requestURI, in the event that\r
+ // no value has been provided.\r
+ if (serviceName == null ||\r
+ serviceName.equalsIgnoreCase(EMPTY_MESSAGE)) {\r
+ MDC.put(ONAPLogConstants.MDCs.SERVICE_NAME, request.getRequestURI());\r
+ }\r
+ \r
+ this.mLogger.info("ENTRY");\r
+ }\r
+\r
+ /**\r
+ * Report <tt>EXITING</tt> marker.\r
+ *\r
+ * @return this.\r
+ */\r
+ public void exiting(String code, String descrption, Level severity, ONAPLogConstants.ResponseStatus status) {\r
+ try {\r
+ MDC.put(ONAPLogConstants.MDCs.RESPONSE_CODE, defaultToEmpty(code));\r
+ MDC.put(ONAPLogConstants.MDCs.RESPONSE_DESCRIPTION, defaultToEmpty(descrption));\r
+ MDC.put(ONAPLogConstants.MDCs.RESPONSE_SEVERITY, defaultToEmpty(severity));\r
+ MDC.put(ONAPLogConstants.MDCs.RESPONSE_STATUS_CODE, defaultToEmpty(status));\r
+ this.mLogger.info("EXIT");\r
+ }\r
+ finally {\r
+ MDC.clear();\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Report pending invocation with <tt>INVOKE</tt> marker,\r
+ * setting standard ONAP logging headers automatically.\r
+ *\r
+ * @param builder request builder, for setting headers.\r
+ * @param sync whether synchronous, nullable.\r
+ * @return invocation ID to be passed with invocation.\r
+ */\r
+ public HttpURLConnection invoke(final HttpURLConnection con, String targetEntity, String targetServiceName) {\r
+ final String invocationID = UUID.randomUUID().toString();\r
+\r
+ // Set standard HTTP headers on (southbound request) builder.\r
+ con.setRequestProperty(ONAPLogConstants.Headers.REQUEST_ID,\r
+ defaultToEmpty(MDC.get(ONAPLogConstants.MDCs.REQUEST_ID)));\r
+ con.setRequestProperty(ONAPLogConstants.Headers.INVOCATION_ID,\r
+ invocationID);\r
+ con.setRequestProperty(ONAPLogConstants.Headers.PARTNER_NAME,\r
+ defaultToEmpty(MDC.get(ONAPLogConstants.MDCs.PARTNER_NAME)));\r
+\r
+ invokeContext(targetEntity, targetServiceName, invocationID);\r
+\r
+ // Log INVOKE*, with the invocationID as the message body.\r
+ // (We didn't really want this kind of behavior in the standard,\r
+ // but is it worse than new, single-message MDC?)\r
+ this.mLogger.info("INVOKE");\r
+ this.mLogger.info("INVOKE-" + ONAPLogConstants.InvocationMode.SYNCHRONOUS.toString() + "{"+ invocationID +"}");\r
+ return con;\r
+ }\r
+ public void invokeReturn() {\r
+ // Add the Invoke-return marker and clear the needed MDC\r
+ this.mLogger.info("INVOKE-RETURN");\r
+ invokeReturnContext();\r
+ }\r
+\r
+ /**\r
+ * Dependency-free nullcheck.\r
+ *\r
+ * @param in to be checked.\r
+ * @param <T> argument (and return) type.\r
+ * @return input arg.\r
+ */\r
+ private static <T> T checkNotNull(final T in) {\r
+ if (in == null) {\r
+ throw new NullPointerException();\r
+ }\r
+ return in;\r
+ }\r
+\r
+ /**\r
+ * Dependency-free string default.\r
+ *\r
+ * @param in to be filtered.\r
+ * @return input string or null.\r
+ */\r
+ private static String defaultToEmpty(final Object in) {\r
+ if (in == null) {\r
+ return "";\r
+ }\r
+ return in.toString();\r
+ }\r
+\r
+ /**\r
+ * Dependency-free string default.\r
+ *\r
+ * @param in to be filtered.\r
+ * @return input string or null.\r
+ */\r
+ private static String defaultToUUID(final String in) {\r
+ if (in == null) {\r
+ return UUID.randomUUID().toString();\r
+ }\r
+ return in;\r
+ }\r
+\r
+ /**\r
+ * Set target related logging variables in thread local data via MDC\r
+ *\r
+ * @param targetEntity Target entity (an external/sub component, for ex. "sdc")\r
+ * @param targetServiceName Target service name (name of API invoked on target)\r
+ * @param invocationId The invocation ID\r
+ */\r
+ private void invokeContext (String targetEntity, String targetServiceName, String invocationID) {\r
+ MDC.put(TARGET_ENTITY, defaultToEmpty(targetEntity));\r
+ MDC.put(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME, defaultToEmpty(targetServiceName));\r
+ MDC.put(INVOCATIONID_OUT, invocationID);\r
+ MDC.put(ONAPLogConstants.MDCs.INVOKE_TIMESTAMP,\r
+ ZonedDateTime.now(ZoneOffset.UTC)\r
+ .format(DateTimeFormatter.ISO_INSTANT));\r
+ }\r
\r
+ /**\r
+ * Clear target related logging variables in thread local data via MDC\r
+ *\r
+ */\r
+ private void invokeReturnContext () {\r
+ MDC.remove(TARGET_ENTITY);\r
+ MDC.remove(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME);\r
+ MDC.remove(INVOCATIONID_OUT);\r
+ }\r
}\r
#com.att.eelf.logging.path=
com.att.eelf.logging.file=logback-default.xml
#The log folder that will be used in logback.xml file
-clamp.config.log.path=/var/log/onap
+clamp.config.log.path=/var/log/ONAP/clamp
clamp.config.files.systemProperties=classpath:/system.properties
clamp.config.files.cldsUsers=classpath:/clds/clds-users.json
clamp.config.files.globalProperties=classpath:/clds/templates/globalProperties.json
#com.att.eelf.logging.path=
com.att.eelf.logging.file=logback-default.xml
#The log folder that will be used in logback.xml file
-clamp.config.log.path=/var/log/onap
+clamp.config.log.path=/var/log/ONAP/clamp
clamp.config.files.systemProperties=classpath:/system.properties
clamp.config.files.cldsUsers=classpath:/clds/clds-users.json
clamp.config.files.globalProperties=classpath:/clds/templates/globalProperties.json
<included>
<jmxConfigurator />
<!-- Example evaluator filter applied against console appender -->
- <appender name="STDOUT"
- class="ch.qos.logback.core.ConsoleAppender">
- <!-- filter class="ch.qos.logback.classic.filter.LevelFilter"> <level>ERROR</level>
- <onMatch>ACCEPT</onMatch> <onMismatch>DENY</onMismatch> </filter -->
- <!-- deny all events with a level below INFO, that is TRACE and DEBUG -->
- <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
- <level>INFO</level>
- </filter>
- <encoder>
- <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
- </pattern>
- </encoder>
- </appender>
+<property name="p_tim" value="%d{"yyyy-MM-dd'T'HH:mm:ss.SSSXXX", UTC}"/>
+ <property name="p_lvl" value="%level"/>
+ <property name="p_log" value="%logger"/>
+ <property name="p_mdc" value="%replace(%replace(%mdc){'\t','\\\\t'}){'\n', '\\\\n'}"/>
+ <property name="p_msg" value="%replace(%replace(%msg){'\t', '\\\\t'}){'\n','\\\\n'}"/>
+ <property name="p_exc" value="%replace(%replace(%rootException){'\t', '\\\\t'}){'\n','\\\\n'}"/>
+ <property name="p_mak" value="%replace(%replace(%marker){'\t', '\\\\t'}){'\n','\\\\n'}"/>
+ <property name="p_thr" value="%thread"/>
+ <property name="defaultPattern" value="%nopexception${p_tim}\t${p_thr}\t${p_lvl}\t${p_log}\t${p_mdc}\t${p_msg}\t${p_exc}\t${p_mak}\t%n"/>
- <appender name="ERROR"
- class="ch.qos.logback.core.rolling.RollingFileAppender">
- <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
- <level>INFO</level>
- </filter>
- <file>${logDirectory}/clamp/error.log</file>
- <append>true</append>
- <encoder>
- <pattern>%date{"yyyy-MM-dd'T'HH:mm:ss,SSSXXX",
- UTC}|%X{RequestId}|%.20thread|%X{ServiceName}|%X{PartnerName}|%X{TargetEntity}|%X{TargetServiceName}|%.-5level|%X{ErrorCode}|%X{ErrorDescription}|%msg%n
- </pattern>
- </encoder>
- <rollingPolicy
- class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
- <maxIndex>10</maxIndex>
- <FileNamePattern>${logDirectory}/clamp/error.%i.log.zip
- </FileNamePattern>
- </rollingPolicy>
- <triggeringPolicy
- class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
- <maxFileSize>10MB</maxFileSize>
- </triggeringPolicy>
- </appender>
+ <!-- Example evaluator filter applied against console appender -->
+ <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+ <!-- filter class="ch.qos.logback.classic.filter.LevelFilter"> <level>ERROR</level>
+ <onMatch>ACCEPT</onMatch> <onMismatch>DENY</onMismatch> </filter -->
+ <!-- deny all events with a level below INFO, that is TRACE and DEBUG -->
+ <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+ <level>INFO</level>
+ </filter>
+ <encoder>
+ <pattern>${defaultPattern}</pattern>
+ </encoder>
+ </appender>
+
+ <appender name="ERROR"
+ class="ch.qos.logback.core.rolling.RollingFileAppender">
+ <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+ <level>INFO</level>
+ </filter>
+ <file>${logDirectory}/error.log</file>
+ <append>true</append>
+ <encoder>
+ <pattern>${defaultPattern}</pattern>
+ </encoder>
+ <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+ <fileNamePattern>${outputDirectory}/clamp/error.%d{yyyy-MM-dd}.%i.log.zip</fileNamePattern>
+ <maxFileSize>50MB</maxFileSize>
+ <maxHistory>30</maxHistory>
+ <totalSizeCap>10GB</totalSizeCap>
+ </rollingPolicy>
+ <triggeringPolicy
+ class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
+ <maxFileSize>10MB</maxFileSize>
+ </triggeringPolicy>
+ </appender>
+
+ <appender name="DEBUG"
+ class="ch.qos.logback.core.rolling.RollingFileAppender">
+ <file>${logDirectory}/debug.log</file>
+ <append>true</append>
+ <encoder>
+ <pattern>${defaultPattern}</pattern>
+ </encoder>
+ <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+ <fileNamePattern>${outputDirectory}/clamp/debug.%d{yyyy-MM-dd}.%i.log.zip</fileNamePattern>
+ <maxFileSize>50MB</maxFileSize>
+ <maxHistory>30</maxHistory>
+ <totalSizeCap>10GB</totalSizeCap>
+ </rollingPolicy>
+ </appender>
- <appender name="DEBUG"
- class="ch.qos.logback.core.rolling.RollingFileAppender">
- <file>${logDirectory}/clamp/debug.log</file>
- <append>true</append>
- <encoder>
- <pattern>%date{"yyyy-MM-dd'T'HH:mm:ss,SSSXXX",UTC}|%X{RequestId}|%.20thread|%.-5level|%logger{36}|%msg%n
- </pattern>
- </encoder>
- <rollingPolicy
- class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
- <fileNamePattern>${logDirectory}/clamp/debug.%d{yyyy-MM-dd}.%i.log.zip
- </fileNamePattern>
- <timeBasedFileNamingAndTriggeringPolicy
- class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
- <maxFileSize>10MB</maxFileSize>
- </timeBasedFileNamingAndTriggeringPolicy>
- <maxHistory>5</maxHistory>
- </rollingPolicy>
- </appender>
<appender name="AUDIT"
class="ch.qos.logback.core.rolling.RollingFileAppender">
- <file>${logDirectory}/clamp/audit.log</file>
+ <file>${logDirectory}/audit.log</file>
<append>true</append>
<encoder>
<pattern>%X{BeginTimestamp}|%X{EndTimestamp}|%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
<rollingPolicy
class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
<maxIndex>10</maxIndex>
- <FileNamePattern>${logDirectory}/clamp/audit.%i.log.zip
+ <FileNamePattern>${logDirectory}/audit.%i.log.zip
</FileNamePattern>
</rollingPolicy>
<triggeringPolicy
<appender name="METRIC"
class="ch.qos.logback.core.rolling.RollingFileAppender">
- <file>${logDirectory}/clamp/metric.log</file>
+ <file>${logDirectory}/metric.log</file>
<append>true</append>
<encoder>
<pattern>%X{BeginTimestamp}|%X{EndTimestamp}|%X{RequestId}|%X{ServiceInstanceId}|%.20thread|%X{VirtualServerName}|%X{ServiceName}|%X{PartnerName}|%X{TargetEntity}|%X{TargetServiceName}|%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{TargetVirtualEntity}|%X{CustomField1}|%X{CustomField2}|%X{CustomField3}|%X{CustomField4}|
<rollingPolicy
class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
<maxIndex>10</maxIndex>
- <FileNamePattern>${logDirectory}/clamp/metric.%i.log.zip
+ <FileNamePattern>${logDirectory}/metric.%i.log.zip
</FileNamePattern>
</rollingPolicy>
<triggeringPolicy
<!-- SECURITY related loggers -->
<appender name="SECURITY"
class="ch.qos.logback.core.rolling.RollingFileAppender">
- <file>${logDirectory}/clamp/security.log</file>
+ <file>${logDirectory}/security.log</file>
<append>true</append>
<encoder>
<pattern>%X{BeginTimestamp}|%X{EndTimestamp}|%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
<rollingPolicy
class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
<maxIndex>10</maxIndex>
- <FileNamePattern>${logDirectory}/clamp/security.%i.log.zip
+ <FileNamePattern>${logDirectory}/security.%i.log.zip
</FileNamePattern>
</rollingPolicy>
<triggeringPolicy
import java.util.List;
import java.util.Properties;
+import javax.servlet.http.HttpServletRequest;
+
import org.apache.commons.codec.DecoderException;
import org.json.JSONException;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.Matchers;
import org.mockito.Mockito;
import org.onap.clamp.clds.dao.CldsDao;
import org.onap.clamp.clds.model.CldsHealthCheck;
import org.onap.clamp.clds.model.CldsServiceData;
import org.onap.clamp.clds.model.CldsTemplate;
import org.onap.clamp.clds.service.CldsService;
+import org.onap.clamp.clds.util.LoggingUtils;
import org.onap.clamp.clds.util.ResourceFileUtil;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
-import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
private CldsDao cldsDao;
private Authentication authentication;
private List<GrantedAuthority> authList = new LinkedList<GrantedAuthority>();
-
+ private LoggingUtils util;
/**
* Setup the variable before the tests execution.
*
authList.add(new SimpleGrantedAuthority("permission-type-template|dev|update"));
authList.add(new SimpleGrantedAuthority("permission-type-filter-vf|dev|*"));
authentication = new UsernamePasswordAuthenticationToken(new User("admin", "", authList), "", authList);
+
+ util = Mockito.mock(LoggingUtils.class);
+ Mockito.doNothing().when(util).entering(Matchers.any(HttpServletRequest.class), Matchers.any(String.class));
+ cldsService.setLoggingUtil(util);
}
@Test
public void testPutModel() {
SecurityContext securityContext = Mockito.mock(SecurityContext.class);
Mockito.when(securityContext.getAuthentication()).thenReturn(authentication);
+
cldsService.setSecurityContext(securityContext);
// Add the template first
CldsTemplate newTemplate = new CldsTemplate();
import java.util.LinkedList;
import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.Matchers;
import org.mockito.Mockito;
import org.onap.clamp.clds.dao.CldsDao;
import org.onap.clamp.clds.model.CldsTemplate;
import org.onap.clamp.clds.model.ValueItem;
import org.onap.clamp.clds.service.CldsTemplateService;
+import org.onap.clamp.clds.util.LoggingUtils;
import org.onap.clamp.clds.util.ResourceFileUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
private CldsTemplate cldsTemplate;
private Authentication authentication;
private List<GrantedAuthority> authList = new LinkedList<GrantedAuthority>();
+ private LoggingUtils util;
/**
* Setup the variable before the tests execution.
authList.add(new SimpleGrantedAuthority("permission-type-template|dev|update"));
authList.add(new SimpleGrantedAuthority("permission-type-filter-vf|dev|*"));
authentication = new UsernamePasswordAuthenticationToken(new User("admin", "", authList), "", authList);
-
+
SecurityContext securityContext = Mockito.mock(SecurityContext.class);
Mockito.when(securityContext.getAuthentication()).thenReturn(authentication);
-
-
+
+ util = Mockito.mock(LoggingUtils.class);
+ Mockito.doNothing().when(util).entering(Matchers.any(HttpServletRequest.class), Matchers.any(String.class));
+ cldsTemplateService.setLoggingUtil(util);
+
cldsTemplateService.setSecurityContext(securityContext);
bpmnText = ResourceFileUtil.getResourceAsString("example/dao/bpmn-template.xml");
imageText = ResourceFileUtil.getResourceAsString("example/dao/image-template.xml");