/jboss-as-7.1.1.Final/logging/src/test/java/org/jboss/as/logging/LoggingOperationsSubsystemTestCase.java

  1/*
  2* JBoss, Home of Professional Open Source.
  3* Copyright 2011, Red Hat Middleware LLC, and individual contributors
  4* as indicated by the @author tags. See the copyright.txt file in the
  5* distribution for a full listing of individual contributors.
  6*
  7* This is free software; you can redistribute it and/or modify it
  8* under the terms of the GNU Lesser General Public License as
  9* published by the Free Software Foundation; either version 2.1 of
 10* the License, or (at your option) any later version.
 11*
 12* This software is distributed in the hope that it will be useful,
 13* but WITHOUT ANY WARRANTY; without even the implied warranty of
 14* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 15* Lesser General Public License for more details.
 16*
 17* You should have received a copy of the GNU Lesser General Public
 18* License along with this software; if not, write to the Free
 19* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 20* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 21*/
 22package org.jboss.as.logging;
 23
 24import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RESULT;
 25import static org.junit.Assert.assertEquals;
 26import static org.junit.Assert.assertFalse;
 27import static org.junit.Assert.assertTrue;
 28
 29import java.io.File;
 30import java.util.HashMap;
 31import java.util.LinkedList;
 32import java.util.List;
 33import java.util.Map;
 34
 35import org.apache.commons.io.FileUtils;
 36import org.jboss.as.subsystem.test.AbstractSubsystemTest;
 37import org.jboss.as.subsystem.test.KernelServices;
 38import org.jboss.dmr.ModelNode;
 39import org.jboss.logging.Logger;
 40import org.jboss.logging.Logger.Level;
 41import org.junit.BeforeClass;
 42import org.junit.Ignore;
 43import org.junit.Test;
 44
 45/**
 46 *
 47 * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
 48 */
 49public class LoggingOperationsSubsystemTestCase extends AbstractSubsystemTest {
 50
 51    private static File logDir;
 52
 53    static {
 54        System.setProperty("java.util.logging.manager", "org.jboss.logmanager.LogManager");
 55    }
 56
 57    private static final Logger log = Logger.getLogger(LoggingOperationsSubsystemTestCase.class.getName());
 58
 59    public LoggingOperationsSubsystemTestCase() {
 60        super(LoggingExtension.SUBSYSTEM_NAME, new LoggingExtension());
 61    }
 62
 63    @BeforeClass
 64    public static void setupLoggingDir() {
 65        logDir = new File("target/logs");
 66        logDir.mkdirs();
 67        for (String name : logDir.list()) {
 68            new File(logDir, name).delete();
 69        }
 70        System.setProperty("jboss.server.log.dir", logDir.getAbsolutePath());
 71    }
 72
 73    @Test
 74    public void testChangeRootLogLevel() throws Exception {
 75
 76        KernelServices kernelServices = installInController(readResource("/operations.xml"));
 77
 78        // add new file loger so we can track logged messages
 79        File logFile = new File(logDir, "test-fh.log");
 80        if (logFile.exists()) assertTrue(logFile.delete());
 81        addFileHandler(kernelServices, "test-logger", "TRACE", logFile, true);
 82
 83        Level[] levels = new Logger.Level[] {Level.ERROR, Level.WARN,
 84            Level.INFO, Level.DEBUG, Level.TRACE};
 85        Map<Level, Integer> levelOrd = new HashMap<Level,Integer>();
 86        levelOrd.put(Level.FATAL, 0);
 87        levelOrd.put(Level.ERROR, 1);
 88        levelOrd.put(Level.WARN, 2);
 89        levelOrd.put(Level.INFO, 3);
 90        levelOrd.put(Level.DEBUG, 4);
 91        levelOrd.put(Level.TRACE, 5);
 92
 93        // log messages on all levels with different root logger level settings
 94        for(Level level : levels) {
 95            // change root log level
 96            ModelNode op = createOpNode("subsystem=logging/root-logger=ROOT", "change-root-log-level");
 97            op.get("level").set(level.name());
 98            ModelNode ret = kernelServices.executeOperation(op);
 99
100            // log a message
101            for (Logger.Level lvl : Logger.Level.values()) {
102                log.log(lvl, "RootLoggerTestCaseTST " + level);
103            }
104        }
105
106        // stop logger
107        removeFileHandler(kernelServices, "test-logger", true);
108
109        // go through loggeded messages - test that with each root logger level settings
110        // message with equal priority and also messags with all higher
111        // priorities were logged
112
113        boolean[][] logFound = new boolean[levelOrd.size()][levelOrd.size()];
114
115        List<String> logLines = FileUtils.readLines(logFile);
116        for(String line : logLines) {
117            if (! line.contains("RootLoggerTestCaseTST")) continue; // not our log
118            String[] lWords = line.split(" +");
119            try {
120                Level lineLogLevel = Level.valueOf(lWords[1]);
121                Level rootLogLevel = Level.valueOf(lWords[5]);
122                int ll = levelOrd.get(lineLogLevel);
123                int rl = levelOrd.get(rootLogLevel);
124                assertTrue(ll <= rl);
125                logFound[ll][rl] = true;
126            } catch (Exception e) {
127                throw new Exception("Unexpected log:" + line);
128            }
129        }
130        for(Level level : levels) {
131            int rl = levelOrd.get(level);
132            for(int ll = 0; ll <= rl; ll++) assertTrue(logFound[ll][rl]);
133        }
134
135    }
136
137    @Test
138    @Ignore("AS7-2385")
139    public void testSetRootLogger() throws Exception {
140
141        KernelServices kernelServices = installInController(readResource("/operations.xml"));
142
143        // add new file loger so we can test root logger change
144        File logFile = new File(logDir, "test-fh.log");
145        if (logFile.exists()) assertTrue(logFile.delete());
146        addFileHandler(kernelServices, "test-logger", "TRACE", logFile, false);
147
148        // read root logger
149        ModelNode op = createOpNode("subsystem=logging", "read-attribute");
150        op.get("name").set("root-logger");
151        ModelNode rootLogger = kernelServices.executeOperation(op);
152        List<String> handlers = modelNodeAsStringList(rootLogger.get("handlers"));
153
154        // set new root logger
155        op = createOpNode("subsystem=logging", "set-root-logger");
156        op.get("level").set(rootLogger.get("level"));
157        for(String handler : handlers) op.get("handlers").add(handler);
158        op.get("handlers").add("test-logger");
159        kernelServices.executeOperation(op);
160
161        // log a message
162        for (Logger.Level lvl : Logger.Level.values())
163            log.log(lvl, "Test123");
164
165
166        // revert root logger
167        op = createOpNode("subsystem=logging", "set-root-logger");
168        op.get("level").set(rootLogger.get("level"));
169        op.get("handlers").set(rootLogger.get("handlers"));
170        kernelServices.executeOperation(op);
171
172        // remove file handler
173        removeFileHandler(kernelServices, "test-logger", false);
174
175        // check that root logger were changed - file logger was registered
176        String log = FileUtils.readFileToString(logFile);
177        assertTrue(log.contains("Test123."));
178
179        // remove log file
180        assertTrue(logFile.delete());
181    }
182
183    @Test
184    public void testAddRemoveFileHandler() throws Exception {
185        KernelServices kernelServices = installInController(readResource("/operations.xml"));
186
187        File logFile = new File(logDir, "test-fh.log");
188        if (logFile.exists()) assertTrue(logFile.delete());
189
190        // add file handler
191        ModelNode op = createOpNode("subsystem=logging/file-handler=test-fh", "add");
192        op.get("name").set("test-fh");
193        op.get("level").set("INFO");
194        op.get("file").get("path").set(logFile.getAbsolutePath());
195        kernelServices.executeOperation(op);
196
197        // register it with root logger
198        op = createOpNode("subsystem=logging/root-logger=ROOT", "root-logger-assign-handler");
199        op.get("name").set("test-fh");
200        kernelServices.executeOperation(op);
201
202        // check it is listed in root-logger
203        op = createOpNode("subsystem=logging/root-logger=ROOT", "read-attribute");
204        op.get("name").set("handlers");
205        ModelNode handlers = kernelServices.executeOperation(op).require(RESULT);
206        List<String> loggers = modelNodeAsStringList(handlers);
207        assertTrue(loggers.contains("test-fh"));
208
209        for (Logger.Level level : Logger.Level.values()) {
210            log.log(level, "Test123");
211        }
212
213        // deregister handler from logger
214        op = createOpNode("subsystem=logging/root-logger=ROOT", "root-logger-unassign-handler");
215        op.get("name").set("test-fh");
216        kernelServices.executeOperation(op);
217
218        // check it is not listed in root-logger
219        op = createOpNode("subsystem=logging/root-logger=ROOT", "read-attribute");
220        op.get("name").set("handlers");
221        handlers = kernelServices.executeOperation(op);
222        loggers = modelNodeAsStringList(handlers);
223        assertFalse(loggers.contains("test-fh"));
224
225        // remove handler
226        op = createOpNode("subsystem=logging/file-handler=test-fh", "remove");
227        kernelServices.executeOperation(op);
228
229        // check generated log file
230        assertTrue(FileUtils.readFileToString(logFile).contains("Test123"));
231
232        // verify that the logger is stopped, no more logs are comming to the file
233        long checksum = FileUtils.checksumCRC32(logFile);
234        for (Logger.Level level : Logger.Level.values()) {
235            log.log(level, "Test123");
236        }
237        assertEquals(checksum, FileUtils.checksumCRC32(logFile));
238
239        // remove log file
240        assertTrue(logFile.delete());
241    }
242
243
244
245    private void addFileHandler(KernelServices kernelServices, String name, String level, File file, boolean assign) throws Exception {
246
247        // add file handler
248        ModelNode op = createOpNode("subsystem=logging/file-handler=" + name, "add");
249        op.get("name").set(name);
250        op.get("level").set(level);
251        op.get("file").get("path").set(file.getAbsolutePath());
252        kernelServices.executeOperation(op);
253
254        if (!assign) return;
255
256        // register it with root logger
257        op = createOpNode("subsystem=logging/root-logger=ROOT", "root-logger-assign-handler");
258        op.get("name").set(name);
259        kernelServices.executeOperation(op);
260    }
261
262    private void removeFileHandler(KernelServices kernelServices, String name, boolean unassign) throws Exception {
263
264        if (unassign) {
265            // deregister handler from logger
266            ModelNode op = createOpNode("subsystem=logging/root-logger=ROOT", "root-logger-unassign-handler");
267            op.get("name").set(name);
268            kernelServices.executeOperation(op);
269        }
270
271        // remove handler
272        ModelNode op = createOpNode("subsystem=logging/file-handler=" + name, "remove");
273        kernelServices.executeOperation(op);
274    }
275
276    public static ModelNode createOpNode(String address, String operation) {
277        ModelNode op = new ModelNode();
278
279        // set address
280        ModelNode list = op.get("address").setEmptyList();
281        if (address != null) {
282            String [] pathSegments = address.split("/");
283            for (String segment : pathSegments) {
284                String[] elements = segment.split("=");
285                list.add(elements[0], elements[1]);
286            }
287        }
288        op.get("operation").set(operation);
289        return op;
290    }
291
292    private static List<String> modelNodeAsStringList(ModelNode node) {
293        List<String> ret = new LinkedList<String>();
294        for (ModelNode n : node.asList()) ret.add(n.asString());
295        return ret;
296    }
297
298}