/*
* Copyright 2001 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/* @test
* @bug 4402649
* @summary RMI should use new logging APIs. Unit test to exercise
* RMI's use of the java.util.logging API.
* @author Laird Dornin
*
* @library ../../../../../java/rmi/testlibrary
* @build TestLibrary
* @build TestParams
* @build TestFailedException
* @build CheckLogging
* @run main/othervm CheckLogging
*/
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.logging.StreamHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.OutputStream;
import java.rmi.RemoteException;
import java.rmi.Remote;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.LogStream;
import java.rmi.server.RemoteServer;
import java.rmi.registry.Registry;
/**
* Perform following checks:
*
* 1. If using java.util.logging, turn on client call logger using
* system property, "sun.rmi.client.logCalls". Collect client call
* output using a custom stream handler. Verify client call output is
* generated and contains the string "outbound call".
*
* 2. Turn on server call using
* RemoteServer.setLog(ByteArrayOutputStream). Invoke some remote
* method calls verify logger output is non-null.
*
* Turn off server call log by doing setLog(null), verify output is
* zero length. Verify that RemoteServer.getLog == null
*
* Use setLog to turn call log back on. Invoke remote method that
* throws an exception and contains the string "exception".
*
* 3. Print directly to return value of RemoteServer.getLog(), verify
* logger output is non-null.
*/
public class CheckLogging {
private static final String LOCATION =
"rmi://localhost:" + TestLibrary.REGISTRY_PORT + "/";
private static final ByteArrayOutputStream clientCallOut =
new ByteArrayOutputStream();
private static final boolean usingOld =
Boolean.getBoolean("sun.rmi.log.useOld");
static {
System.setProperty("sun.rmi.client.logCalls", "true");
if (usingOld) {
System.err.println("set default stream");
LogStream.setDefaultStream(new PrintStream(clientCallOut));
} else {
Logger.getLogger("sun.rmi.client.call").
addHandler(new InternalStreamHandler(clientCallOut));
}
}
/* use registry to generate client & server call log info */
private static Registry registry;
static {
try {
registry = LocateRegistry.createRegistry(TestLibrary.REGISTRY_PORT);
} catch (Exception e) {
TestLibrary.bomb("could not create registry");
}
}
/**
* Used to collect output from specific loggers
*/
private static class InternalStreamHandler extends StreamHandler {
private InternalStreamHandler(OutputStream out) {
super(out, new SimpleFormatter());
setLevel(Level.ALL);
}
public void publish(LogRecord record) {
super.publish(record);
flush();
}
public void close() {
flush();
}
}
/**
* Ensure that a log has some output and that it contains a
* certain string
*/
private static void verifyLog(ByteArrayOutputStream bout,
String mustContain)
{
byte[] bytes = bout.toByteArray();
if (bytes.length == 0) {
TestLibrary.bomb("log data length is zero");
} else if ((mustContain != null) &&
(bout.toString().indexOf(mustContain) < 0))
{
TestLibrary.bomb("log output did not contain: " + mustContain);
}
}
/**
* Check serverCallLog output
*/
private static void checkServerCallLog() throws Exception {
ByteArrayOutputStream serverCallLog = new ByteArrayOutputStream();
RemoteServer.setLog(serverCallLog);
Naming.list(LOCATION);
verifyLog(serverCallLog, "list");
serverCallLog.reset();
RemoteServer.setLog(null);
PrintStream callStream = RemoteServer.getLog();
if (callStream != null) {
TestLibrary.bomb("call stream not null after calling " +
"setLog(null)");
} else {
System.err.println("call stream should be null and it is");
}
Naming.list(LOCATION);
if (usingOld) {
if (serverCallLog.toString().indexOf("UnicastServerRef") >= 0) {
TestLibrary.bomb("server call logging not turned off");
}
} else if (serverCallLog.toByteArray().length != 0) {
TestLibrary.bomb("call log contains output but it " +
"should be empty");
}
serverCallLog.reset();
RemoteServer.setLog(serverCallLog);
try {
// generates a notbound exception
Naming.lookup(LOCATION + "notthere");
} catch (Exception e) {
}
verifyLog(serverCallLog, "exception");
serverCallLog.reset();
RemoteServer.setLog(serverCallLog);
callStream = RemoteServer.getLog();
callStream.println("bingo, this is a getLog test");
verifyLog(serverCallLog, "bingo");
}
private static void checkPermissions() {
SecurityException ex = null;
try {
// should fail for lack of LoggingPermission "control"
RemoteServer.setLog(System.err);
} catch (SecurityException e) {
System.err.println("security excepton caught correctly");
ex = e;
}
if (ex == null) {
TestLibrary.bomb("able to set log without permission");
}
}
public static void main(String[] args) {
try {
checkServerCallLog();
if (!usingOld) {
verifyLog(clientCallOut, "outbound call");
System.setSecurityManager(new java.lang.SecurityManager());
checkPermissions();
}
System.err.println("TEST PASSED");
} catch (Exception e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
}
TestLibrary.bomb("unexpected exception", e);
} finally {
TestLibrary.unexport(registry);
}
}
}