@SuppressWarnings("squid:S2095") @Override public Connection getConnection() throws SQLException { Connection c = dataSource.getConnection(); logger.trace("getConnection: ({})", c.getClass().getName()); c.setAutoCommit(true); return c; }
/** * Logs a message with parameters at the lowest level: trace. * * @param logger * @param msg * @param arguments */ public void trace(EELFLogger logger, String msg, Object... arguments) { if (logger.isTraceEnabled()) { MDC.put(LoggerProperties.MDC_CLASS_NAME, className); logger.trace(msg, arguments); MDC.remove(LoggerProperties.MDC_CLASS_NAME); } }
/** * Logs a message at the lowest level: trace. * * @param logger * @param msg */ public void trace(EELFLogger logger, String msg) { if (logger.isTraceEnabled()) { MDC.put(LoggerProperties.MDC_CLASS_NAME, className); logger.trace(msg); MDC.remove(LoggerProperties.MDC_CLASS_NAME); } }
/** * Logs a message and throwable at the lowest level: trace. * * @param logger * @param msg * @param th */ public void trace(EELFLogger logger, String msg, Throwable th) { if (logger.isTraceEnabled()) { MDC.put(LoggerProperties.MDC_CLASS_NAME, className); logger.trace(msg, th); MDC.remove(LoggerProperties.MDC_CLASS_NAME); } }
private String mergeJson(String requestParamJson, String systemParamJson) throws Exception { ObjectMapper mapper = new ObjectMapper(); Map<String, String> requestParamMap = mapper.readValue(requestParamJson, HashMap.class); if(requestParamMap != null){ Map<String, String> systemParamMap = mapper.readValue(systemParamJson, HashMap.class); if(systemParamMap != null){ for (String systemParamKey : systemParamMap.keySet()) { log.trace("Megging System Key Values " + systemParamKey); requestParamMap.put( systemParamKey , systemParamMap.get(systemParamKey)); } } requestParamJson = mapper.writeValueAsString(requestParamMap); log.info("Processed Request Param " + requestParamJson); } return requestParamJson; }
private String mergeJson(String requestParamJson, String systemParamJson) throws IOException { ObjectMapper mapper = new ObjectMapper(); Map<String, String> requestParamMap = mapper.readValue(requestParamJson, HashMap.class); if (requestParamMap != null) { Map<String, String> systemParamMap = mapper.readValue(systemParamJson, HashMap.class); if (systemParamMap != null) { for (Entry<String, String> entry : systemParamMap.entrySet()) { log.trace("Megging System Key Values " + entry.getKey()); requestParamMap.put(entry.getKey(), entry.getValue()); } } log.info("Processed Request Param " + requestParamJson); return mapper.writeValueAsString(requestParamMap); } return requestParamJson; }
/** * Read property value to set writeTopic, apiKey, apiSecret and pool. * * @param props of configuration */ private void updateProperties(Properties props) { logger.trace("Entering to updateProperties with Properties = " + ObjectUtils.toString(props)); pool = new HashSet<>(); if (props != null) { isDisabled = Boolean.parseBoolean(props.getProperty(PROP_APPC_OAM_DISABLED)); writeTopic = props.getProperty(PROP_APPC_OAM_TOPIC_WRITE); apiKey = props.getProperty(PROP_APPC_OAM_CLIENT_KEY); apiSecret = props.getProperty(PROP_APPC_OAM_CLIENT_SECRET); String hostnames = props.getProperty(PROP_APPC_OAM_POOLMEMBERS); if (hostnames != null && !hostnames.isEmpty()) { for (String name : hostnames.split(",")) { pool.add(name); } } } }
private void loadInitial() { if (serviceTemplate != null) { if (serviceTemplate.getDataTypes() != null) { serviceTemplate.getDataTypes().forEach((dataTypeKey, dataType) -> { stDataTypes.put(dataTypeKey, dataType); logger.trace("Data Type ({}) loaded successfully.", dataTypeKey); }); } if (serviceTemplate.getNodeTypes() != null) { serviceTemplate.getNodeTypes().forEach((nodeTypeKey, nodeType) -> { stNodeTypes.put(nodeTypeKey, nodeType); logger.trace("NodeType Type ({}) loaded successfully.", nodeTypeKey); }); } } }
public Map<String, String> convertDataTypes2Properties(ServiceTemplate serviceTemplate, final Map<String, String> context) { if (serviceTemplate != null && serviceTemplate.getDataTypes() != null) { serviceTemplate.getDataTypes().forEach((dataTypeKey, dataType) -> { logger.trace("Populating Data Type Key : ({})", dataTypeKey); String dataTypeContent = TransformationUtils.getJson(dataType); context.put("data_types." + dataTypeKey, dataTypeContent); }); } return context; }
public void copyNodeType2Template(Map<String, NodeType> nodeTypes, Map<String, NodeTemplate> nodeTemplates) { if (nodeTypes != null && nodeTemplates != null) { nodeTemplates.forEach((templateKey, nodeTemplate) -> { if (StringUtils.isNotBlank(templateKey) && nodeTemplate != null) { String type = nodeTemplate.getType(); // Check the Node Template Type is Present if (StringUtils.isNotBlank(type) && nodeTypes.containsKey(type)) { NodeType nodeType = nodeTypes.get(type); logger.trace("Checking Node Type Content : ({})", TransformationUtils.getJson(nodeType)); copyNodeTypeInterface2Template(nodeType.getInterfaces(), nodeTemplate.getInterfaces()); } } }); } }
public void copyNodeTypeInterface2Template(Map<String, InterfaceDefinition> nodeTypeInterfaces, Map<String, InterfaceAssignment> nodeTemplateInterfaces) { if (nodeTypeInterfaces != null && nodeTemplateInterfaces != null) { nodeTemplateInterfaces.forEach((interfaceKey, nodeTemplateinterface) -> { InterfaceDefinition nodeTypeInterface = nodeTypeInterfaces.get(interfaceKey); logger.trace("Checking Interface Type Content : ({})", TransformationUtils.getJson(nodeTypeInterface)); if (nodeTypeInterface != null && nodeTemplateinterface != null) { copyNodeTypeOperation2Template(nodeTypeInterface.getOperations(), nodeTemplateinterface.getOperations()); } }); } }
public Map<String, String> populateNodeTemplateArtifacts(String nodeTemplateKey, NodeTemplate nodeTemplate, final Map<String, String> context) { if (MapUtils.isNotEmpty(nodeTemplate.getArtifacts())) { nodeTemplate.getArtifacts().forEach((artifactName, artifact) -> { if (StringUtils.isNotBlank(artifactName) && artifact != null) { logger.trace("Populating Node Template Artifacts ({}) for Node Template ({})", artifactName, nodeTemplateKey); String fileKeyName = ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateKey + "." + ConfigModelConstant.PROPERTY_ARTIFACTS_DOT + artifactName + ".file"; String deployKeyName = ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateKey + "." + ConfigModelConstant.PROPERTY_ARTIFACTS_DOT + artifactName + ".deploy_path"; String contentKeyName = ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateKey + "." + ConfigModelConstant.PROPERTY_ARTIFACTS_DOT + artifactName + ".content"; context.put(fileKeyName, artifact.getFile()); context.put(deployKeyName, artifact.getDeployPath()); context.put(contentKeyName, artifact.getContent()); } }); } return context; }
@Override public void save(TransactionLog transactionLog) throws SvcLogicException { if (transactionLog != null && StringUtils.isNotBlank(transactionLog.getRequestId())) { String addSql = "INSERT INTO CONFIG_TRANSACTION_LOG ( config_transaction_log_id, request_id, message_type, message ) VALUES (?, ?, ?, ?) "; jdbcTemplate.update(addSql, transactionLog.getUniqueId(), transactionLog.getRequestId(), transactionLog.getMessageType(), transactionLog.getMessage()); logger.trace("TransactionLog Updated Successfully for message_type {}", transactionLog.getMessageType()); } }
public VnfcDependencyModel getVnfcDependencyModel(DependencyModelIdentifier modelIdentifier,DependencyTypes dependencyType) throws InvalidDependencyModel, DependencyModelNotFound { if (logger.isTraceEnabled()) { logger.trace("Entering to getVnfcDependencyModel with DependencyModelIdentifier = "+ modelIdentifier + " , DependencyTypes = " + dependencyType); } VnfcDependencyModel dependencyModel = cache.getObject(modelIdentifier); if(dependencyModel == null){ logger.debug("Dependency model not found in cache, creating strategy for reading it"); DependencyType strategy = getStrategy(dependencyType); dependencyModel = strategy.getVnfcDependencyModel(modelIdentifier); } if (logger.isTraceEnabled()) { logger.trace("Returning getVnfcDependencyModel with dependency model = "+ dependencyModel); } return dependencyModel; }
public VnfcDependencyModel getVnfcDependencyModel(DependencyModelIdentifier modelIdentifier,DependencyTypes dependencyType) throws InvalidDependencyModelException, DependencyModelNotFound { if (logger.isTraceEnabled()) { logger.trace("Entering to getVnfcDependencyModel with DependencyModelIdentifier = "+ modelIdentifier + " , DependencyTypes = " + dependencyType); } VnfcDependencyModel dependencyModel = cache.getObject(modelIdentifier); if(dependencyModel == null){ logger.debug("Dependency model not found in cache, creating strategy for reading it"); DependencyType strategy = getStrategy(dependencyType); // Throw exception if strategy could not be created because it is required // to retrieve the vnfc dependency model later if (strategy == null) { throw new NullPointerException("Strategy is null. Failed to retrieve Vnfc Dependency Model"); } dependencyModel = strategy.getVnfcDependencyModel(modelIdentifier); } if (logger.isTraceEnabled()) { logger.trace("Returning getVnfcDependencyModel with dependency model = "+ dependencyModel); } return dependencyModel; }
@Override public void generateOutputPayloadFromContext(Map<String, String> params, SvcLogicContext ctx) throws APPCException { if (logger.isTraceEnabled()) { logger.trace( "Entering to generateOutputPayloadFromContext with SvcLogicContext = " + ObjectUtils.toString(ctx)); } try { Set<String> keys = ctx.getAttributeKeySet(); ObjectMapper objectMapper = new ObjectMapper(); ObjectNode jsonNode = objectMapper.createObjectNode(); for (String key : keys) { updateJsonNode(ctx, objectMapper, jsonNode, key); } if (jsonNode.size() > 0) { ctx.setAttribute(Constants.OUTPUT_PAYLOAD, objectMapper.writeValueAsString(jsonNode)); } } catch (Exception e) { logger.error(e.toString()); ctx.setAttribute(Constants.DG_OUTPUT_STATUS_MESSAGE, e.toString()); throw new APPCException(e); } }
public VnfcDependencyModel getVnfcDependencyModel(DependencyModelIdentifier modelIdentifier) throws InvalidDependencyModelException, DependencyModelNotFound { if (logger.isTraceEnabled()) { logger.trace("Entering to getVnfcDependencyModel with DependencyModelIdentifier = "+ modelIdentifier); } String vnfModel = metadataService.getVnfModel(modelIdentifier); if(vnfModel ==null){ logger.debug("Vnf model not found from metadata service"); throw new DependencyModelNotFound("Invalid or Empty VNF Model"); } if (logger.isTraceEnabled()) { logger.trace("Building dependency model for Vnf Model : " + vnfModel); } DependencyModelParser modelParser = new DependencyModelParser(); return modelParser.generateDependencyModel(vnfModel,modelIdentifier.getVnfType()); } }
public VnfcDependencyModel getVnfcDependencyModel(DependencyModelIdentifier modelIdentifier) throws InvalidDependencyModel, DependencyModelNotFound { if (logger.isTraceEnabled()) { logger.trace("Entering to getVnfcDependencyModel with DependencyModelIdentifier = "+ modelIdentifier); } String vnfModel = metadataService.getVnfModel(modelIdentifier); if(vnfModel ==null){ logger.debug("Vnf model not found from metadata service"); throw new DependencyModelNotFound("Invalid or Empty VNF Model"); } if (logger.isTraceEnabled()) { logger.trace("Building dependency model for Vnf Model : " + vnfModel); } DependencyModelParser modelParser = new DependencyModelParser(); return modelParser.generateDependencyModel(vnfModel,modelIdentifier.getVnfType()); } }
public VnfcFlowModel buildFlowModel(VnfcDependencyModel dependencyModel, InventoryModel inventoryModel) throws InvalidDependencyModelException { if(logger.isTraceEnabled()){ logger.trace("Entering into buildFlowModel with dependency model = " + dependencyModel + "inventory model = " +inventoryModel); } if(dependencyModel == null || dependencyModel.getDependencies() ==null || dependencyModel.getDependencies().size() ==0){ logger.debug("Dependency model not available, building flow model with sequence"); throw new InvalidDependencyModelException("Dependency model either null or does not contain any dependency"); } VnfcFlowModel flowModel = buildFlowModel(dependencyModel); if(logger.isDebugEnabled()){ logger.debug("Flow Model without instance data: \n" + flowModel); } logger.info("Populating flow model with A&AI data"); populateFlowModel(flowModel,inventoryModel); if(logger.isDebugEnabled()){ logger.debug("Flow Model with instance data: \n" + flowModel); } return flowModel; }
public VnfcFlowModel buildFlowModel(VnfcDependencyModel dependencyModel, InventoryModel inventoryModel) { if(logger.isTraceEnabled()){ logger.trace("Entering into buildFlowModel with dependency model = " + dependencyModel + "inventory model = " +inventoryModel); } if(dependencyModel == null || dependencyModel.getDependencies() ==null || dependencyModel.getDependencies().size() ==0){ logger.debug("Dependency model not available, building flow model with sequence"); throw new InvalidDependencyModel("Dependency model either null or does not contain any dependency"); } VnfcFlowModel flowModel = buildFlowModel(dependencyModel); if(logger.isDebugEnabled()){ logger.debug("Flow Model without instance data: \n" + flowModel); } logger.info("Populating flow model with A&AI data"); populateFlowModel(flowModel,inventoryModel); if(logger.isDebugEnabled()){ logger.debug("Flow Model with instance data: \n" + flowModel); } return flowModel; }