1 /*
   2  * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 4402649
  26  * @summary RMI should use new logging APIs. Unit test to exercise
  27  * RMI's use of the java.util.logging API.
  28  * @author Laird Dornin
  29  *
  30  * @library ../../../../../java/rmi/testlibrary
  31  * @modules java.rmi/sun.rmi.registry
  32  *          java.rmi/sun.rmi.server
  33  *          java.rmi/sun.rmi.transport
  34  *          java.rmi/sun.rmi.transport.tcp
  35  * @build TestLibrary
  36  * @run main/othervm CheckLogging
  37  */
  38 
  39 import java.util.logging.Level;
  40 import java.util.logging.LogRecord;
  41 import java.util.logging.Logger;
  42 import java.util.logging.SimpleFormatter;
  43 import java.util.logging.StreamHandler;
  44 
  45 import java.io.ByteArrayOutputStream;
  46 import java.io.IOException;
  47 import java.io.PrintStream;
  48 import java.io.OutputStream;
  49 
  50 import java.rmi.RemoteException;
  51 import java.rmi.Remote;
  52 import java.rmi.Naming;
  53 import java.rmi.registry.LocateRegistry;
  54 import java.rmi.server.LogStream;
  55 import java.rmi.server.RemoteServer;
  56 
  57 import java.rmi.registry.Registry;
  58 
  59 /**
  60  * Perform following checks:
  61  *
  62  * 1. If using java.util.logging, turn on client call logger using
  63  * system property, "sun.rmi.client.logCalls".  Collect client call
  64  * output using a custom stream handler. Verify client call output is
  65  * generated and contains the string "outbound call".
  66  *
  67  * 2. Turn on server call using
  68  * RemoteServer.setLog(ByteArrayOutputStream). Invoke some remote
  69  * method calls verify logger output is non-null.
  70  *
  71  * Turn off server call log by doing setLog(null), verify output is
  72  * zero length.  Verify that RemoteServer.getLog == null
  73  *
  74  * Use setLog to turn call log back on.  Invoke remote method that
  75  * throws an exception and contains the string "exception".
  76  *
  77  * 3. Print directly to return value of RemoteServer.getLog(), verify
  78  * logger output is non-null.
  79  */
  80 public class CheckLogging {
  81     private static int REGISTRY_PORT = -1;
  82     private static String LOCATION;
  83     private static Logger logger;
  84 
  85     private static final ByteArrayOutputStream clientCallOut =
  86         new ByteArrayOutputStream();
  87 
  88     private static final boolean usingOld =
  89         Boolean.getBoolean("sun.rmi.log.useOld");
  90 
  91     static {
  92         System.setProperty("sun.rmi.client.logCalls", "true");
  93         if (usingOld) {
  94             System.err.println("set default stream");
  95             LogStream.setDefaultStream(new PrintStream(clientCallOut));
  96         } else {
  97             logger = Logger.getLogger("sun.rmi.client.call");
  98             logger.addHandler(new InternalStreamHandler(clientCallOut));
  99         }
 100     }
 101 
 102     /* use registry to generate client & server call log info */
 103     private static Registry registry;
 104     static {
 105         try {
 106             registry = TestLibrary.createRegistryOnUnusedPort();
 107             REGISTRY_PORT = TestLibrary.getRegistryPort(registry);
 108             LOCATION = "rmi://localhost:" + REGISTRY_PORT + "/";
 109         } catch (Exception e) {
 110             TestLibrary.bomb("could not create registry");
 111         }
 112     }
 113 
 114     /**
 115      * Used to collect output from specific loggers
 116      */
 117     private static class InternalStreamHandler extends StreamHandler {
 118         private InternalStreamHandler(OutputStream out) {
 119             super(out, new SimpleFormatter());
 120             setLevel(Level.ALL);
 121         }
 122 
 123         public void publish(LogRecord record) {
 124             super.publish(record);
 125             flush();
 126         }
 127 
 128         public void close() {
 129             flush();
 130         }
 131     }
 132 
 133     /**
 134      * Ensure that a log has some output and that it contains a
 135      * certain string
 136      */
 137     private static void verifyLog(ByteArrayOutputStream bout,
 138                                   String mustContain)
 139     {
 140         byte[] bytes = bout.toByteArray();
 141         if (bytes.length == 0) {
 142             TestLibrary.bomb("log data length is zero");
 143         } else if ((mustContain != null) &&
 144                    (bout.toString().indexOf(mustContain) < 0))
 145         {
 146             TestLibrary.bomb("log output did not contain: " + mustContain);
 147         }
 148     }
 149 
 150     /**
 151      * Check serverCallLog output
 152      */
 153     private static void checkServerCallLog() throws Exception {
 154         ByteArrayOutputStream serverCallLog = new ByteArrayOutputStream();
 155         RemoteServer.setLog(serverCallLog);
 156         Naming.list(LOCATION);
 157         verifyLog(serverCallLog, "list");
 158 
 159         serverCallLog.reset();
 160         RemoteServer.setLog(null);
 161         PrintStream callStream = RemoteServer.getLog();
 162         if (callStream != null) {
 163             TestLibrary.bomb("call stream not null after calling " +
 164                              "setLog(null)");
 165         } else {
 166             System.err.println("call stream should be null and it is");
 167         }
 168         Naming.list(LOCATION);
 169 
 170         if (usingOld) {
 171             if (serverCallLog.toString().indexOf("UnicastServerRef") >= 0) {
 172                 TestLibrary.bomb("server call logging not turned off");
 173             }
 174         } else if (serverCallLog.toByteArray().length != 0) {
 175             TestLibrary.bomb("call log contains output but it " +
 176                              "should be empty");
 177         }
 178 
 179         serverCallLog.reset();
 180         RemoteServer.setLog(serverCallLog);
 181         try {
 182             // generates a notbound exception
 183             Naming.lookup(LOCATION + "notthere");
 184         } catch (Exception e) {
 185         }
 186         verifyLog(serverCallLog, "exception");
 187 
 188         serverCallLog.reset();
 189         RemoteServer.setLog(serverCallLog);
 190         callStream = RemoteServer.getLog();
 191         callStream.println("bingo, this is a getLog test");
 192         verifyLog(serverCallLog, "bingo");
 193     }
 194 
 195     private static void checkPermissions() {
 196         SecurityException ex = null;
 197         try {
 198             // should fail for lack of LoggingPermission "control"
 199             RemoteServer.setLog(System.err);
 200         } catch (SecurityException e) {
 201             System.err.println("security excepton caught correctly");
 202             ex = e;
 203         }
 204         if (ex == null) {
 205             TestLibrary.bomb("able to set log without permission");
 206         }
 207     }
 208 
 209     public static void main(String[] args) {
 210         try {
 211             checkServerCallLog();
 212 
 213             if (!usingOld) {
 214                 verifyLog(clientCallOut, "outbound call");
 215                 System.setSecurityManager(new java.lang.SecurityManager());
 216                 checkPermissions();
 217             }
 218             System.err.println("TEST PASSED");
 219 
 220         } catch (Exception e) {
 221             if (e instanceof RuntimeException) {
 222                 throw (RuntimeException) e;
 223             }
 224             TestLibrary.bomb("unexpected exception", e);
 225         } finally {
 226             TestLibrary.unexport(registry);
 227         }
 228     }
 229 }
--- EOF ---