Java tutorial
/* * JBoss, Home of Professional Open Source. * Copyright 2011, Red Hat Middleware LLC, and individual contributors * as indicated by the @author tags. See the copyright.txt file in the * distribution for a full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */ package org.jboss.as.logging; import static org.junit.Assert.*; import java.io.File; import java.io.IOException; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.logging.Level; import org.apache.commons.io.FileUtils; import org.jboss.as.controller.client.helpers.ClientConstants; import org.jboss.as.controller.descriptions.ModelDescriptionConstants; import org.jboss.as.controller.operations.common.Util; import org.jboss.as.controller.services.path.PathResourceDefinition; import org.jboss.as.model.test.ModelTestUtils; import org.jboss.as.subsystem.test.KernelServices; import org.jboss.as.subsystem.test.SubsystemOperations; import org.jboss.dmr.ModelNode; import org.jboss.logmanager.LogContext; import org.jboss.logmanager.Logger; import org.junit.After; import org.junit.BeforeClass; import org.junit.Test; /** * @author <a href="kabir.khan@jboss.com">Kabir Khan</a> */ // TODO (jrp) all these operations should be tested on loggers as well as root loggers public class LoggingOperationsSubsystemTestCase extends AbstractLoggingSubsystemTest { private static final String PROFILE = "testProfile"; private static final String FQCN = LoggingOperationsSubsystemTestCase.class.getName(); private static final Level[] LEVELS = { org.jboss.logmanager.Level.FATAL, org.jboss.logmanager.Level.ERROR, org.jboss.logmanager.Level.WARN, org.jboss.logmanager.Level.INFO, org.jboss.logmanager.Level.DEBUG, org.jboss.logmanager.Level.TRACE, }; private static File logDir; @BeforeClass public static void setupLoggingDir() { logDir = LoggingTestEnvironment.get().getLogDir(); for (File file : logDir.listFiles()) { file.delete(); } } @After @Override public void clearLogContext() { super.clearLogContext(); final LoggingProfileContextSelector contextSelector = LoggingProfileContextSelector.getInstance(); if (contextSelector.exists(PROFILE)) { clearLogContext(contextSelector.get(PROFILE)); contextSelector.remove(PROFILE); } } @Override protected void standardSubsystemTest(final String configId) throws Exception { // do nothing as this is not a subsystem parsing test } @Override protected String getSubsystemXml() throws IOException { return readResource("/operations.xml"); } @Test public void testChangeRootLogLevel() throws Exception { testChangeRootLogLevel(null); testChangeRootLogLevel(PROFILE); } @Test public void testSetRootLogger() throws Exception { testSetRootLogger(null); testSetRootLogger(PROFILE); } @Test public void testAddRemoveFileHandler() throws Exception { testAddRemoveFileHandler(null); testAddRemoveFileHandler(PROFILE); } @Test public void testDisableHandler() throws Exception { testDisableHandler(null, false); testDisableHandler(PROFILE, false); } @Test public void testLegacyDisableHandler() throws Exception { testDisableHandler(null, true); testDisableHandler(PROFILE, true); } @Test public void testPatternFormatter() throws Exception { testPatternFormatter(null); testPatternFormatter(PROFILE); } @Test public void testCompositeOperations() throws Exception { testCompositeOperations(null); testCompositeOperations(PROFILE); } @Test public void testLegacyFilters() throws Exception { final KernelServices kernelServices = boot(); final String fileHandlerName = "test-file-handler"; // add new file logger so we can track logged messages final File logFile = createLogFile(); final ModelNode handlerAddress = createFileHandlerAddress(fileHandlerName).toModelNode(); addFileHandler(kernelServices, null, fileHandlerName, org.jboss.logmanager.Level.TRACE, logFile, true); // Write legacy filters for (Map.Entry<String, ModelNode> entry : FilterConversionTestCase.MAP.entrySet()) { // Validate the write-attribute operation ModelNode op = SubsystemOperations.createWriteAttributeOperation(handlerAddress, CommonAttributes.FILTER, entry.getValue()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(handlerAddress, CommonAttributes.FILTER_SPEC); String filterSpecResult = SubsystemOperations.readResultAsString(executeOperation(kernelServices, op)); assertEquals(entry.getKey(), filterSpecResult); // Validate an add operation final ModelNode tempHandlerAddress = createConsoleHandlerAddress("temp").toModelNode(); op = SubsystemOperations.createAddOperation(tempHandlerAddress); op.get(CommonAttributes.FILTER.getName()).set(entry.getValue()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(tempHandlerAddress, CommonAttributes.FILTER_SPEC); filterSpecResult = SubsystemOperations.readResultAsString(executeOperation(kernelServices, op)); assertEquals(entry.getKey(), filterSpecResult); // Remove the temp handler op = SubsystemOperations.createRemoveOperation(tempHandlerAddress, true); executeOperation(kernelServices, op); // Add to a logger final ModelNode loggerAddress = createLoggerAddress("test-logger").toModelNode(); op = SubsystemOperations.createAddOperation(loggerAddress); op.get(CommonAttributes.FILTER.getName()).set(entry.getValue()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER_SPEC); filterSpecResult = SubsystemOperations.readResultAsString(executeOperation(kernelServices, op)); assertEquals(entry.getKey(), filterSpecResult); // Remove the attribute op = SubsystemOperations.createUndefineAttributeOperation(loggerAddress, CommonAttributes.FILTER_SPEC); executeOperation(kernelServices, op); op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER); // Filter and filter spec should be undefined assertEquals("Filter was not undefined", SubsystemOperations.UNDEFINED, SubsystemOperations.readResult(executeOperation(kernelServices, op))); op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER_SPEC); assertEquals("Filter was not undefined", SubsystemOperations.UNDEFINED, SubsystemOperations.readResult(executeOperation(kernelServices, op))); // Test writing the attribute to the logger op = SubsystemOperations.createWriteAttributeOperation(loggerAddress, CommonAttributes.FILTER, entry.getValue()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER_SPEC); filterSpecResult = SubsystemOperations.readResultAsString(executeOperation(kernelServices, op)); assertEquals(entry.getKey(), filterSpecResult); // Remove the logger op = SubsystemOperations.createRemoveOperation(loggerAddress, true); executeOperation(kernelServices, op); } // Write new filters for (Map.Entry<String, ModelNode> entry : FilterConversionTestCase.MAP.entrySet()) { // Write to a handler ModelNode op = SubsystemOperations.createWriteAttributeOperation(handlerAddress, CommonAttributes.FILTER_SPEC, entry.getKey()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(handlerAddress, CommonAttributes.FILTER); ModelNode filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op)); ModelTestUtils.compare(entry.getValue(), filterResult); // Validate an add operation final ModelNode tempHandlerAddress = createConsoleHandlerAddress("temp").toModelNode(); op = SubsystemOperations.createAddOperation(tempHandlerAddress); op.get(CommonAttributes.FILTER_SPEC.getName()).set(entry.getKey()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(tempHandlerAddress, CommonAttributes.FILTER); filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op)); ModelTestUtils.compare(entry.getValue(), filterResult); // Remove the temp handler op = SubsystemOperations.createRemoveOperation(tempHandlerAddress, true); executeOperation(kernelServices, op); // Add to a logger final ModelNode loggerAddress = createLoggerAddress("test-logger").toModelNode(); op = SubsystemOperations.createAddOperation(loggerAddress); op.get(CommonAttributes.FILTER_SPEC.getName()).set(entry.getKey()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER); filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op)); ModelTestUtils.compare(entry.getValue(), filterResult); // Test writing the attribute to the logger op = SubsystemOperations.createWriteAttributeOperation(loggerAddress, CommonAttributes.FILTER_SPEC, entry.getKey()); executeOperation(kernelServices, op); // Read the current value op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER); filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op)); ModelTestUtils.compare(entry.getValue(), filterResult); // Remove the logger op = SubsystemOperations.createRemoveOperation(loggerAddress, true); executeOperation(kernelServices, op); } removeFileHandler(kernelServices, null, fileHandlerName, true); } @Test public void testLoggingProfile() throws Exception { final KernelServices kernelServices = boot(); final String handlerName = "test-file-handler"; final File logFile = createLogFile(); final File profileLogFile = createLogFile("profile.log"); final ModelNode handlerAddress = createFileHandlerAddress(handlerName).toModelNode(); final ModelNode profileHandlerAddress = createFileHandlerAddress(PROFILE, handlerName).toModelNode(); // Add handlers addFileHandler(kernelServices, null, handlerName, org.jboss.logmanager.Level.INFO, logFile, true); addFileHandler(kernelServices, PROFILE, handlerName, org.jboss.logmanager.Level.INFO, profileLogFile, true); // Change the format ModelNode op = SubsystemOperations.createReadAttributeOperation(handlerAddress, AbstractHandlerDefinition.FORMATTER); final String defaultHandlerFormat = SubsystemOperations .readResultAsString(executeOperation(kernelServices, op)); op = SubsystemOperations.createReadAttributeOperation(profileHandlerAddress, AbstractHandlerDefinition.FORMATTER); final String defaultProfileHandlerFormat = SubsystemOperations .readResultAsString(executeOperation(kernelServices, op)); op = SubsystemOperations.createWriteAttributeOperation(handlerAddress, AbstractHandlerDefinition.FORMATTER, "%m%n"); executeOperation(kernelServices, op); op = SubsystemOperations.createWriteAttributeOperation(profileHandlerAddress, AbstractHandlerDefinition.FORMATTER, "%m%n"); executeOperation(kernelServices, op); // Log with and without profile final String msg = "This is a test message"; doLog(null, LEVELS, msg); doLog(PROFILE, LEVELS, msg); // Reset the formatters op = SubsystemOperations.createWriteAttributeOperation(handlerAddress, AbstractHandlerDefinition.FORMATTER, defaultHandlerFormat); executeOperation(kernelServices, op); op = SubsystemOperations.createWriteAttributeOperation(profileHandlerAddress, AbstractHandlerDefinition.FORMATTER, defaultProfileHandlerFormat); executeOperation(kernelServices, op); // Remove the handler removeFileHandler(kernelServices, null, handlerName, true); removeFileHandler(kernelServices, PROFILE, handlerName, true); // Read the files to a string final String result = FileUtils.readFileToString(logFile); final String profileResult = FileUtils.readFileToString(profileLogFile); // Check generated log file assertTrue(result.contains(msg)); assertTrue(profileResult.contains(msg)); // The contents of the files should match assertTrue(String.format("Contents don't match: %nResult:%n%s%nProfileResult%n%s", result, profileResult), result.equals(profileResult)); } private void testChangeRootLogLevel(final String loggingProfile) throws Exception { final KernelServices kernelServices = boot(); final String fileHandlerName = "test-file-handler"; // add new file logger so we can track logged messages final File logFile = createLogFile(); addFileHandler(kernelServices, loggingProfile, fileHandlerName, org.jboss.logmanager.Level.TRACE, logFile, true); final Level[] levels = { org.jboss.logmanager.Level.FATAL, org.jboss.logmanager.Level.ERROR, org.jboss.logmanager.Level.WARN, org.jboss.logmanager.Level.INFO, org.jboss.logmanager.Level.DEBUG, org.jboss.logmanager.Level.TRACE }; final Map<Level, Integer> levelOrd = new HashMap<Level, Integer>(); levelOrd.put(org.jboss.logmanager.Level.FATAL, 0); levelOrd.put(org.jboss.logmanager.Level.ERROR, 1); levelOrd.put(org.jboss.logmanager.Level.WARN, 2); levelOrd.put(org.jboss.logmanager.Level.INFO, 3); levelOrd.put(org.jboss.logmanager.Level.DEBUG, 4); levelOrd.put(org.jboss.logmanager.Level.TRACE, 5); // log messages on all levels with different root logger level settings final ModelNode address = createRootLoggerAddress(loggingProfile).toModelNode(); for (Level level : levels) { // change root log level final ModelNode op = SubsystemOperations.createWriteAttributeOperation(address, CommonAttributes.LEVEL, level.getName()); executeOperation(kernelServices, op); doLog(loggingProfile, levels, "RootLoggerTestCaseTST %s", level); } // Remove the handler removeFileHandler(kernelServices, loggingProfile, fileHandlerName, true); // go through logged messages - test that with each root logger level settings // message with equal priority and also messages with all higher // priorities were logged final boolean[][] logFound = new boolean[levelOrd.size()][levelOrd.size()]; final List<String> logLines = FileUtils.readLines(logFile); for (String line : logLines) { if (!line.contains("RootLoggerTestCaseTST")) continue; // not our log final String[] words = line.split("\\s+"); try { final Level lineLogLevel = Level.parse(words[1]); final Level rootLogLevel = Level.parse(words[5]); final int producedLevel = levelOrd.get(lineLogLevel); final int loggedLevel = levelOrd.get(rootLogLevel); assertTrue(String.format("Produced level(%s) greater than logged level (%s)", lineLogLevel, rootLogLevel), producedLevel <= loggedLevel); logFound[producedLevel][loggedLevel] = true; } catch (Exception e) { throw new Exception("Unexpected log:" + line); } } for (Level level : levels) { final int rl = levelOrd.get(level); for (int ll = 0; ll <= rl; ll++) assertTrue(logFound[ll][rl]); } } private void testSetRootLogger(final String loggingProfile) throws Exception { final KernelServices kernelServices = boot(); final String fileHandlerName = "test-file-handler"; // Add new file logger so we can test root logger change final File logFile = createLogFile(); addFileHandler(kernelServices, loggingProfile, fileHandlerName, org.jboss.logmanager.Level.INFO, logFile, false); // Read root logger final ModelNode rootLoggerAddress = createRootLoggerAddress(loggingProfile).toModelNode(); ModelNode op = SubsystemOperations.createOperation(ClientConstants.READ_RESOURCE_OPERATION, rootLoggerAddress); final ModelNode rootLoggerResult = executeOperation(kernelServices, op); final List<String> handlers = modelNodeAsStringList( rootLoggerResult.get(CommonAttributes.HANDLERS.getName())); // Remove the root logger op = SubsystemOperations.createRemoveOperation(rootLoggerAddress); executeOperation(kernelServices, op); // Set a new root logger op = SubsystemOperations.createOperation(ModelDescriptionConstants.ADD, rootLoggerAddress); op.get(CommonAttributes.LEVEL.getName()).set(rootLoggerResult.get(CommonAttributes.LEVEL.getName())); for (String handler : handlers) op.get(CommonAttributes.HANDLERS.getName()).add(handler); op.get(CommonAttributes.HANDLERS.getName()).add(fileHandlerName); executeOperation(kernelServices, op); doLog(loggingProfile, LEVELS, "Test123"); // Remove the root logger op = SubsystemOperations.createRemoveOperation(rootLoggerAddress); executeOperation(kernelServices, op); // Revert root logger op = SubsystemOperations.createOperation(ModelDescriptionConstants.ADD, rootLoggerAddress); op.get(CommonAttributes.LEVEL.getName()).set(rootLoggerResult.get(CommonAttributes.LEVEL.getName())); op.get(CommonAttributes.HANDLERS.getName()).set(rootLoggerResult.get(CommonAttributes.HANDLERS.getName())); executeOperation(kernelServices, op); // remove file handler removeFileHandler(kernelServices, loggingProfile, fileHandlerName, false); // check that root logger were changed - file logger was registered String log = FileUtils.readFileToString(logFile); assertTrue(log.contains("Test123")); } private void testAddRemoveFileHandler(final String loggingProfile) throws Exception { final KernelServices kernelServices = boot(); final String fileHandlerName = "test-file-handler"; File logFile = createLogFile(); // Add file handler addFileHandler(kernelServices, loggingProfile, fileHandlerName, org.jboss.logmanager.Level.INFO, logFile, true); final ModelNode rootLoggerAddress = createRootLoggerAddress(loggingProfile).toModelNode(); // Ensure the model doesn't contain any erroneous attributes ModelNode op = SubsystemOperations.createReadResourceOperation(rootLoggerAddress); ModelNode result = executeOperation(kernelServices, op); final ModelNode rootLoggerResource = SubsystemOperations.readResult(result); validateResourceAttributes(rootLoggerResource, Logging.join(RootLoggerResourceDefinition.ATTRIBUTES, CommonAttributes.FILTER)); // Ensure the handler is listed op = SubsystemOperations.createReadAttributeOperation(rootLoggerAddress, CommonAttributes.HANDLERS); ModelNode handlerResult = executeOperation(kernelServices, op); List<String> handlerList = SubsystemOperations.readResultAsList(handlerResult); assertTrue(String.format("Handler '%s' was not found. Result: %s", fileHandlerName, handlerResult), handlerList.contains(fileHandlerName)); doLog(loggingProfile, LEVELS, "Test123"); // Remove handler from logger op = SubsystemOperations.createOperation( RootLoggerResourceDefinition.ROOT_LOGGER_REMOVE_HANDLER_OPERATION_NAME, rootLoggerAddress); op.get(CommonAttributes.NAME.getName()).set(fileHandlerName); executeOperation(kernelServices, op); // Ensure the handler is not listed op = SubsystemOperations.createReadAttributeOperation(rootLoggerAddress, CommonAttributes.HANDLERS); handlerResult = executeOperation(kernelServices, op); handlerList = SubsystemOperations.readResultAsList(handlerResult); assertFalse(String.format("Handler '%s' was not removed. Result: %s", fileHandlerName, handlerResult), handlerList.contains(fileHandlerName)); // Remove the handler removeFileHandler(kernelServices, loggingProfile, fileHandlerName, false); // check generated log file assertTrue(FileUtils.readFileToString(logFile).contains("Test123")); // verify that the logger is stopped, no more logs are coming to the file long checksum = FileUtils.checksumCRC32(logFile); doLog(loggingProfile, LEVELS, "Test123"); assertEquals(checksum, FileUtils.checksumCRC32(logFile)); } private void testDisableHandler(final String profileName, boolean legacy) throws Exception { final KernelServices kernelServices = boot(); final String fileHandlerName = "test-file-handler"; final File logFile = createLogFile(); // Add file handler addFileHandler(kernelServices, profileName, fileHandlerName, org.jboss.logmanager.Level.INFO, logFile, true); // Ensure the handler is listed final ModelNode rootLoggerAddress = createRootLoggerAddress(profileName).toModelNode(); ModelNode op = SubsystemOperations.createReadAttributeOperation(rootLoggerAddress, CommonAttributes.HANDLERS); ModelNode handlerResult = executeOperation(kernelServices, op); List<String> handlerList = SubsystemOperations.readResultAsList(handlerResult); assertTrue(String.format("Handler '%s' was not found. Result: %s", fileHandlerName, handlerResult), handlerList.contains(fileHandlerName)); // Get the logger final Logger logger = getLogger(profileName); // Log 3 lines logger.info("Test message 1"); logger.info("Test message 2"); logger.info("Test message 3"); // Disable the handler final ModelNode handlerAddress = createFileHandlerAddress(profileName, fileHandlerName).toModelNode(); ModelNode disableOp = legacy ? Util.getEmptyOperation("disable", handlerAddress) : SubsystemOperations.createWriteAttributeOperation(handlerAddress, CommonAttributes.ENABLED, false); executeOperation(kernelServices, disableOp); // The operation should set the enabled attribute to false final ModelNode readOp = SubsystemOperations.createReadAttributeOperation(handlerAddress, CommonAttributes.ENABLED); ModelNode result = executeOperation(kernelServices, readOp); assertFalse("enabled attribute should be false when the disable operation is invoked", SubsystemOperations.readResult(result).asBoolean()); // Log 3 more lines logger.info("Test message 4"); logger.info("Test message 5"); logger.info("Test message 6"); // Check the file, should only contain 3 lines List<String> lines = FileUtils.readLines(logFile); assertEquals("Handler was not disable.", 3, lines.size()); // Re-enable the handler ModelNode enableOp = legacy ? Util.getEmptyOperation("enable", handlerAddress) : SubsystemOperations.createWriteAttributeOperation(handlerAddress, CommonAttributes.ENABLED, true); executeOperation(kernelServices, enableOp); // The operation should set the enabled attribute to true result = executeOperation(kernelServices, readOp); assertTrue("enabled attribute should be true when the enable operation is invoked", SubsystemOperations.readResult(result).asBoolean()); // Log 3 more lines logger.info("Test message 7"); logger.info("Test message 8"); logger.info("Test message 9"); // Check the file, should contain 6 lines lines = FileUtils.readLines(logFile); assertEquals("Handler was not disable.", 6, lines.size()); } private void testPatternFormatter(final String profileName) throws Exception { final KernelServices kernelServices = boot(); final String fileHandlerName = "test-file-handler"; final File logFile = createLogFile(); // Add file handler final ModelNode handlerAddress = addFileHandler(kernelServices, profileName, fileHandlerName, org.jboss.logmanager.Level.INFO, logFile, false); // Get the logger final Logger logger = getLogger(profileName); // Create the logger final ModelNode loggerAddress = createLoggerAddress(profileName, logger.getName()).toModelNode(); ModelNode op = SubsystemOperations.createAddOperation(loggerAddress); op.get(LoggerResourceDefinition.USE_PARENT_HANDLERS.getName()).set(false); op.get(CommonAttributes.HANDLERS.getName()).setEmptyList().add(fileHandlerName); executeOperation(kernelServices, op); // Create a pattern formatter final ModelNode patternFormatterAddress = createPatternFormatterAddress(profileName, "PATTERN") .toModelNode(); op = SubsystemOperations.createAddOperation(patternFormatterAddress); // Add a format that can be read back to make sure it matches the pattern used in the handler op.get(PatternFormatterResourceDefinition.PATTERN.getName()).set("[NAMED-PATTERN] %s%n"); executeOperation(kernelServices, op); // Add the named formatter to the handler op = SubsystemOperations.createWriteAttributeOperation(handlerAddress, FileHandlerResourceDefinition.NAMED_FORMATTER, "PATTERN"); executeOperation(kernelServices, op); // Log 3 lines logger.info("Test message 1"); logger.info("Test message 2"); logger.info("Test message 3"); // Check the file, should only contain 3 lines final List<String> lines = FileUtils.readLines(logFile); assertEquals("Additional messages written to handler that should not be there.", 3, lines.size()); // Check each line assertEquals("Line patterns don't match.", "[NAMED-PATTERN] Test message 1", lines.get(0)); assertEquals("Line patterns don't match.", "[NAMED-PATTERN] Test message 2", lines.get(1)); assertEquals("Line patterns don't match.", "[NAMED-PATTERN] Test message 3", lines.get(2)); // Clean up op = SubsystemOperations.CompositeOperationBuilder.create() .addStep(SubsystemOperations.createRemoveOperation(loggerAddress)) .addStep(SubsystemOperations.createRemoveOperation(handlerAddress)) .addStep(SubsystemOperations.createRemoveOperation(patternFormatterAddress)).build().getOperation(); executeOperation(kernelServices, op); } private void testCompositeOperations(final String profileName) throws Exception { final KernelServices kernelServices = boot(); final String asyncHandlerName = "async"; final String consoleHandlerName = "console"; final ModelNode asyncHandlerAddress = createAsyncHandlerAddress(profileName, asyncHandlerName) .toModelNode(); final ModelNode consoleHandlerAddress = createConsoleHandlerAddress(profileName, consoleHandlerName) .toModelNode(); final ModelNode loggerAddress = createLoggerAddress(profileName, FQCN).toModelNode(); final ModelNode addAsyncHandlerOp = SubsystemOperations.createAddOperation(asyncHandlerAddress); addAsyncHandlerOp.get(AsyncHandlerResourceDefinition.QUEUE_LENGTH.getName()).set(10); // Add the handlers ModelNode op = SubsystemOperations.CompositeOperationBuilder.create().addStep(addAsyncHandlerOp) .addStep(SubsystemOperations.createAddOperation(consoleHandlerAddress)) .addStep(SubsystemOperations.createAddOperation(loggerAddress)).build().getOperation(); executeOperation(kernelServices, op); // Add the handlers to the logger and the console-handler to the async-handler op = SubsystemOperations.CompositeOperationBuilder.create() .addStep(createAddHandlerOperation(asyncHandlerAddress, consoleHandlerName)) .addStep(createAddHandlerOperation(loggerAddress, asyncHandlerName)) .addStep(createAddHandlerOperation(loggerAddress, consoleHandlerName)).build().getOperation(); executeOperation(kernelServices, op); // Check each resource for erroneous attributes op = SubsystemOperations.createReadResourceOperation(asyncHandlerAddress); ModelNode result = executeOperation(kernelServices, op); ModelNode resource = SubsystemOperations.readResult(result); validateResourceAttributes(resource, Logging.join(AsyncHandlerResourceDefinition.ATTRIBUTES, CommonAttributes.NAME, CommonAttributes.FILTER)); op = SubsystemOperations.createReadResourceOperation(consoleHandlerAddress); result = executeOperation(kernelServices, op); resource = SubsystemOperations.readResult(result); validateResourceAttributes(resource, Logging.join(ConsoleHandlerResourceDefinition.ATTRIBUTES, CommonAttributes.NAME, CommonAttributes.FILTER)); op = SubsystemOperations.createReadResourceOperation(loggerAddress); result = executeOperation(kernelServices, op); resource = SubsystemOperations.readResult(result); validateResourceAttributes(resource, Logging.join(LoggerResourceDefinition.EXPRESSION_ATTRIBUTES, LoggerResourceDefinition.CATEGORY)); // Remove all the resources op = SubsystemOperations.CompositeOperationBuilder.create() .addStep(SubsystemOperations.createRemoveOperation(loggerAddress)) .addStep(SubsystemOperations.createRemoveOperation(asyncHandlerAddress)) .addStep(SubsystemOperations.createRemoveOperation(consoleHandlerAddress)).build().getOperation(); executeOperation(kernelServices, op); } private ModelNode addFileHandler(final KernelServices kernelServices, final String loggingProfile, final String name, final Level level, final File file, final boolean assign) throws Exception { final ModelNode address = createFileHandlerAddress(loggingProfile, name).toModelNode(); // add file handler ModelNode op = SubsystemOperations.createAddOperation(address); op.get(CommonAttributes.NAME.getName()).set(name); op.get(CommonAttributes.LEVEL.getName()).set(level.getName()); op.get(CommonAttributes.FILE.getName()).get(PathResourceDefinition.PATH.getName()) .set(file.getAbsolutePath()); op.get(CommonAttributes.AUTOFLUSH.getName()).set(true); executeOperation(kernelServices, op); // register it with root logger if (assign) { op = SubsystemOperations.createOperation( RootLoggerResourceDefinition.ROOT_LOGGER_ADD_HANDLER_OPERATION_NAME, createRootLoggerAddress(loggingProfile).toModelNode()); op.get(CommonAttributes.NAME.getName()).set(name); executeOperation(kernelServices, op); } return address; } private void removeFileHandler(final KernelServices kernelServices, final String loggingProfile, final String name, final boolean unassign) throws Exception { if (unassign) { // Remove the handler from the logger final ModelNode op = SubsystemOperations.createOperation( RootLoggerResourceDefinition.ROOT_LOGGER_REMOVE_HANDLER_OPERATION_NAME, createRootLoggerAddress(loggingProfile).toModelNode()); op.get(CommonAttributes.NAME.getName()).set(name); executeOperation(kernelServices, op); } // Remove the handler final ModelNode op = SubsystemOperations .createRemoveOperation(createFileHandlerAddress(loggingProfile, name).toModelNode()); executeOperation(kernelServices, op); } private ModelNode executeOperation(final KernelServices kernelServices, final ModelNode op) { return executeOperation(kernelServices, op, true); } private ModelNode executeOperation(final KernelServices kernelServices, final ModelNode op, final boolean validateResult) { final ModelNode result = kernelServices.executeOperation(op); if (validateResult) assertTrue(SubsystemOperations.getFailureDescriptionAsString(result), SubsystemOperations.isSuccessfulOutcome(result)); return result; } private void doLog(final String loggingProfile, final Level[] levels, final String format, final Object... params) { final Logger log = getLogger(loggingProfile); // log a message for (Level lvl : levels) { log.log(lvl, String.format(format, params)); } } private Logger getLogger(final String profileName) { final LogContext logContext; if (profileName != null) { logContext = LoggingProfileContextSelector.getInstance().get(profileName); } else { logContext = LogContext.getSystemLogContext(); } return logContext.getLogger(FQCN); } private ModelNode createAddHandlerOperation(final ModelNode address, final String handlerName) { final ModelNode op = SubsystemOperations.createOperation(CommonAttributes.ADD_HANDLER_OPERATION_NAME, address); op.get(CommonAttributes.HANDLER_NAME.getName()).set(handlerName); return op; } private static File createLogFile() { return createLogFile("test-fh.log"); } private static File createLogFile(final String filename) { final File logFile = new File(logDir, filename); if (logFile.exists()) assertTrue("Log file was not deleted", logFile.delete()); return logFile; } }