/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package org.glassfish.admin.amxtest.ext.logging;
import com.sun.appserv.management.base.Util;
import com.sun.appserv.management.base.XTypes;
import com.sun.appserv.management.ext.logging.LogModuleNames;
import com.sun.appserv.management.ext.logging.LogQueryEntry;
import com.sun.appserv.management.ext.logging.LogQueryResult;
import com.sun.appserv.management.ext.logging.Logging;
import static com.sun.appserv.management.ext.logging.Logging.*;
import com.sun.appserv.management.j2ee.J2EEServer;
import com.sun.appserv.management.util.misc.CollectionUtil;
import com.sun.appserv.management.util.misc.GSetUtil;
import com.sun.appserv.management.util.misc.StringUtil;
import com.sun.appserv.management.util.stringifier.CollectionStringifier;
import org.glassfish.admin.amxtest.AMXTestBase;
import org.glassfish.admin.amxtest.Capabilities;
import javax.management.Attribute;
import javax.management.ListenerNotFoundException;
import javax.management.Notification;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
/**
Test the {@link Logging}.
*/
public final class LoggingTest
extends AMXTestBase {
public LoggingTest() {
}
public static Capabilities
getCapabilities() {
return getOfflineCapableCapabilities(false);
}
final Set<Logging>
getAllLogging() {
return getQueryMgr().queryJ2EETypeSet(XTypes.LOGGING);
}
public void
testGetModuleLogLevel() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
for (final String moduleName : LogModuleNames.ALL_NAMES) {
final String level = logging.getModuleLogLevel(moduleName);
}
}
printElapsed("testGetModuleLogLevel", loggings.size(), start);
}
public void
testSetModuleLogLevel() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
for (final String moduleName : LogModuleNames.ALL_NAMES) {
final String level = logging.getModuleLogLevel(moduleName);
logging.setModuleLogLevel(moduleName, "FINEST");
logging.setModuleLogLevel(moduleName, level);
}
}
printElapsed("testSetModuleLogLevel", loggings.size(), start);
}
public void
testGetLogFileNames() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final String[] serverLogs = logging.getLogFileNames(SERVER_KEY);
assert (serverLogs.length != 0);
//final String[] accessLogs = logging.getLogFileNames( ACCESS_KEY );
//assert( accessLogs.length != 0 );
}
printElapsed("testGetLogFileNames", loggings.size(), start);
}
public void
testGetLogFileKeys() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final String[] keys = logging.getLogFileKeys();
final Set<String> keysSet = GSetUtil.newSet(keys);
assert (keysSet.contains(SERVER_KEY));
assert (keysSet.contains(ACCESS_KEY));
assertEquals(2, keysSet.size());
}
printElapsed("testGetLogFileKeys", loggings.size(), start);
}
/*
!!!
Testing these is problematic because if they run
before the other tests, they create nearly-empty log files
public void
testRotateAllLogFiles()
{
logging.rotateAllLogFiles();
how to verify?
}
public void
testRotateLogFile()
{
warning( "testRotateLogFile: SKIPPING TEST" );
logging.rotateLogFile( SERVER_KEY );
logging.rotateLogFile( ACCESS_KEY );
}
*/
public void
testGetLogFile() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final String[] serverLogs = logging.getLogFileNames(SERVER_KEY);
assert (serverLogs.length != 0);
for (final String name : serverLogs) {
final long startGet = now();
final String contents = logging.getLogFile(SERVER_KEY, name);
assert (contents != null) : "contents of log file are null: " + name;
assert (contents.length() != 0) : "contents of log file are empty: " + name;
printVerbose("Log file " + StringUtil.quote(name) +
" has size " + (contents.length() / 1024) + "K, ms = " + (now() - startGet));
}
}
printElapsed("testGetLogFile", loggings.size(), start);
}
public void
testGetErrorInfo() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final Map<String, Number>[] infos = logging.getErrorInfo();
assert (infos != null);
for (final Map<String, Number> info : infos) {
assert (info != null && info.keySet().size() >= 3);
assert (info.containsKey(TIMESTAMP_KEY));
assert (info.containsKey(SEVERE_COUNT_KEY));
assert (info.containsKey(WARNING_COUNT_KEY));
}
}
printElapsed("testGetErrorInfo", loggings.size(), start);
}
public void
testGetErrorDistribution() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final Map<String, Number>[] infos = logging.getErrorInfo();
assert (infos != null);
for (final Map<String, Number> info : infos) {
final Long timeStamp = (Long) info.get(TIMESTAMP_KEY);
assert (timeStamp != null);
final Integer severeCount = (Integer) info.get(SEVERE_COUNT_KEY);
assert (severeCount != null);
final Integer warningCount = (Integer) info.get(WARNING_COUNT_KEY);
assert (warningCount != null);
final Map<String, Integer> warnings =
logging.getErrorDistribution(timeStamp.longValue(), "WARNING");
assert (warnings != null);
for (final String moduleID : warnings.keySet()) {
assert (warnings.get(moduleID) != null);
}
final Map<String, Integer> severes =
logging.getErrorDistribution(timeStamp, "SEVERE");
assert (severes != null);
for (final String moduleID : severes.keySet()) {
assert (severes.get(moduleID) != null);
}
// verify that there are no illegal keys.
final String[] loggerNames = logging.getLoggerNames();
final Set<String> illegal = GSetUtil.copySet(severes.keySet());
illegal.removeAll(GSetUtil.newSet(loggerNames));
assert (illegal.size() == 0) :
"Illegal logger names found in Map returned by getErrorDistribution: {" +
CollectionUtil.toString(illegal, ",") + "}";
try {
logging.getErrorDistribution(timeStamp, "INFO");
fail("expecting failure from getErrorDistribution( timeStamp, 'INFO' )");
}
catch (Exception e) {
}
}
}
printElapsed("testGetErrorDistribution", loggings.size(), start);
}
public void
testGetLoggerNamesAndGetLoggerNamesUnder() {
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final String[] names = logging.getLoggerNames();
assert (names != null && names.length != 0);
for (final String loggerName : names) {
final String[] under = logging.getLoggerNamesUnder(loggerName);
assert (under != null);
}
}
}
public void
testQuery() {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
final String filename = Logging.MOST_RECENT_NAME;
final int startRecord = FIRST_RECORD;
final boolean searchForward = true;
final int requestedCount = ALL_RECORDS;
final Long fromTime = now() - (24 * 60 * 60 * 1000);
final Long toTime = now();
final Set<String> modules = LogModuleNames.ALL_NAMES; // all
final List<Attribute> attrs = null;
final LogQueryResult result = logging.queryServerLog(
filename,
startRecord,
searchForward,
requestedCount,
fromTime,
toTime,
Level.WARNING.toString(),
modules,
attrs);
final String[] fieldNames = result.getFieldNames();
for (final LogQueryEntry entry : result.getEntries()) {
final String messageID = entry.getMessageID();
final String[] causes = logging.getDiagnosticCauses(messageID);
final String[] checks = logging.getDiagnosticChecks(messageID);
final String uri = logging.getDiagnosticURI(messageID);
}
}
printElapsed("testQuery", loggings.size(), start);
}
private Map<String, J2EEServer>
getAllJ2EEServer() {
final Map<String, J2EEServer> servers =
getDomainRoot().getJ2EEDomain().getJ2EEServerMap();
return servers;
}
public void
testHaveLoggingForEachRunningServer() {
final long start = now();
final Map<String, J2EEServer> servers = getAllJ2EEServer();
for (final J2EEServer server : servers.values()) {
final int state = server.getstate();
final String serverName = server.getName();
if (state != J2EEServer.STATE_RUNNING) {
warning("testHaveLoggingForEachRunningServer: server " +
serverName + " is not running");
} else {
final Set<Logging> loggings = getAllLogging();
final Set<ObjectName> loggingsObjectNames = Util.toObjectNames(loggings);
final Map<String, Logging> all =
Util.createNameMap(loggings);
assert (all.containsKey(serverName)) :
"Can't find Logging for server " + serverName +
", have: {" +
CollectionStringifier.toString(loggingsObjectNames, ", ") + "}";
}
}
printElapsed("testHaveLoggingForEachRunningServer", servers.size(), start);
}
private final class MyListener
implements NotificationListener {
private final String mID;
public MyListener(final String id) {
mNotifs = Collections.synchronizedList(new ArrayList<Notification>());
mID = id;
}
private final List<Notification> mNotifs;
public void
handleNotification(
final Notification notif,
final Object handback) {
//printVerbose( "Received notif: " + notif );
if (notif.getMessage().indexOf(mID) >= 0) {
mNotifs.add(notif);
}
}
public List<Notification>
getNotifications() {
return Collections.unmodifiableList(mNotifs);
}
public int
getNotificationCount() {
return mNotifs.size();
}
}
private void
testListening(final Logging logging)
throws ListenerNotFoundException {
final String message = "testListening:" + now();
final MyListener listener = new MyListener(message);
printVerbose("Testing Logging=" + logging.getName());
logging.addNotificationListener(listener, null, null);
try {
logging.testEmitLogMessage(Level.SEVERE.toString(), message);
logging.testEmitLogMessage(Level.WARNING.toString(), message);
logging.testEmitLogMessage(Level.CONFIG.toString(), message);
logging.testEmitLogMessage(Level.INFO.toString(), message);
logging.testEmitLogMessage(Level.FINE.toString(), message);
logging.testEmitLogMessage(Level.FINER.toString(), message);
logging.testEmitLogMessage(Level.FINEST.toString(), message);
int count = 0;
mySleep(200);
while ((count = listener.getNotificationCount()) != 7) {
mySleep(500);
trace("testListening: waiting for 7 Notifications, have: " + count);
}
}
finally {
logging.removeNotificationListener(listener);
}
}
public void
testListeningForAllLogging()
throws ListenerNotFoundException {
final long start = now();
final Set<Logging> loggings = getAllLogging();
for (final Logging logging : loggings) {
testListening(logging);
}
printElapsed("testListeningForAllLogging", loggings.size(), start);
}
public void
testNoStrayLogging()
throws ListenerNotFoundException {
final Set<String> validNames = getAllJ2EEServer().keySet();
final Set<Logging> loggings = getAllLogging();
assert (validNames.size() >= loggings.size());
for (final Logging logging : loggings) {
assert validNames.contains(logging.getName()) :
"Logging MBean name doesn't match any J2EEServer: " + logging.getName();
}
}
}