util/logging/TestConfigurationListeners.java

/*
 * Copyright (c) 2014, 2019, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
import java.io.ByteArrayInputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.security.AccessControlException;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.PropertyPermission;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.LogManager;
import java.util.logging.LoggingPermission;

/**
 * @test
 * @bug 8043306
 * @summary tests LogManager.addConfigurationListener and
 *                LogManager.removeConfigurationListener;
 * @build TestConfigurationListeners
 * @run main/othervm TestConfigurationListeners UNSECURE
 * @run main/othervm TestConfigurationListeners PERMISSION
 * @run main/othervm TestConfigurationListeners SECURE
 * @author danielfuchs
 */
public class TestConfigurationListeners {

    /**
     * We will test add and remove ConfigurationListeners in 3 configurations.
     * UNSECURE: No security manager.
     * SECURE: With the security manager present - and the required
     *         LoggingPermission("control") granted.
     * PERMISSION: With the security manager present - and the required
     *         LoggingPermission("control") *not* granted. Here we will
     *         test that the expected security permission is thrown.
     */
    public static enum TestCase {
        UNSECURE, SECURE, PERMISSION;
        public void run(String name) throws Exception {
            System.out.println("Running test case: " + name());
            switch (this) {
                case UNSECURE:
                    testUnsecure(name);
                    break;
                case SECURE:
                    testSecure(name);
                    break;
                case PERMISSION:
                    testPermission(name);
                    break;
                default:
                    throw new Error("Unknown test case: "+this);
            }
        }
        public String loggerName(String name) {
            return name;
        }
    }

    public static void main(String... args) throws Exception {


        if (args == null || args.length == 0) {
            args = new String[] {
                TestCase.UNSECURE.name(),
                TestCase.SECURE.name(),
            };
        }

        for (String testName : args) {
            TestCase test = TestCase.valueOf(testName);
            test.run(test.loggerName("foo.bar"));
        }
    }

    /**
     * Test without security manager.
     * @param loggerName The logger to use.
     * @throws Exception if the test fails.
     */
    public static void testUnsecure(String loggerName) throws Exception {
        if (System.getSecurityManager() != null) {
            throw new Error("Security manager is set");
        }
        test(loggerName);
    }

    /**
     * Test with security manager.
     * @param loggerName The logger to use.
     * @throws Exception if the test fails.
     */
    public static void testSecure(String loggerName) throws Exception {
        if (System.getSecurityManager() != null) {
            throw new Error("Security manager is already set");
        }
        Policy.setPolicy(new SimplePolicy(TestCase.SECURE));
        System.setSecurityManager(new SecurityManager());
        test(loggerName);
    }

    /**
     * Test the LoggingPermission("control") is required.
     * @param loggerName The logger to use.
     */
    public static void testPermission(String loggerName) {
        TestConfigurationListener run = new TestConfigurationListener(
                TestCase.PERMISSION.toString());
        if (System.getSecurityManager() != null) {
            throw new Error("Security manager is already set");
        }
        Policy.setPolicy(new SimplePolicy(TestCase.PERMISSION));
        System.setSecurityManager(new SecurityManager());

        try {
            LogManager.getLogManager().addConfigurationListener(run);
            throw new RuntimeException("addConfigurationListener: Permission not checked!");
        } catch (AccessControlException x) {
            boolean ok = false;
            if (x.getPermission() instanceof LoggingPermission) {
                if ("control".equals(x.getPermission().getName())) {
                    System.out.println("addConfigurationListener: Got expected exception: " + x);
                    ok = true;
                }
            }
            if (!ok) {
                throw new RuntimeException("addConfigurationListener: Unexpected exception: "+x, x);
            }
        }

        try {
            LogManager.getLogManager().removeConfigurationListener(run);
            throw new RuntimeException("removeConfigurationListener: Permission not checked!");
        } catch (AccessControlException x) {
            boolean ok = false;
            if (x.getPermission() instanceof LoggingPermission) {
                if ("control".equals(x.getPermission().getName())) {
                    System.out.println("removeConfigurationListener: Got expected exception: " + x);
                    ok = true;
                }
            }
            if (!ok) {
                throw new RuntimeException("removeConfigurationListener: Unexpected exception: "+x, x);
            }
        }
        try {
            LogManager.getLogManager().addConfigurationListener(null);
            throw new RuntimeException(
                    "addConfigurationListener(null): Expected NPE not thrown.");
        } catch (NullPointerException npe) {
            System.out.println("Got expected NPE: "+npe);
        }

        try {
            LogManager.getLogManager().removeConfigurationListener(null);
            throw new RuntimeException(
                    "removeConfigurationListener(null): Expected NPE not thrown.");
        } catch (NullPointerException npe) {
            System.out.println("Got expected NPE: "+npe);
        }


    }


    static class TestConfigurationListener implements Runnable {
        final AtomicLong  count = new AtomicLong(0);
        final String name;
        TestConfigurationListener(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            final long times = count.incrementAndGet();
            System.out.println("Configured \"" + name + "\": " + times);
        }
    }

    static class ConfigurationListenerException extends RuntimeException {
        public ConfigurationListenerException(String msg) {
            super(msg);
        }

        @Override
        public String toString() {
            return this.getClass().getName() + ": " + getMessage();
        }
    }
    static class ConfigurationListenerError extends Error {
        public ConfigurationListenerError(String msg) {
            super(msg);
        }

        @Override
        public String toString() {
            return this.getClass().getName() + ": " + getMessage();
        }
    }

    static class ThrowingConfigurationListener extends TestConfigurationListener {

        final boolean error;
        public ThrowingConfigurationListener(String name, boolean error) {
            super(name);
            this.error = error;
        }

        @Override
        public void run() {
            if (error)
                throw new ConfigurationListenerError(name);
            else
                throw new ConfigurationListenerException(name);
        }

        @Override
        public String toString() {
            final Class<? extends Throwable> type =
                    error ? ConfigurationListenerError.class
                          : ConfigurationListenerException.class;
            return  type.getName()+ ": " + name;
        }

    }

    private static void expect(TestConfigurationListener listener, long value) {
        final long got = listener.count.longValue();
        if (got != value) {
            throw new RuntimeException(listener.name + " expected " + value +", got " + got);
        }

    }

    public interface ThrowingConsumer<T, I extends Exception> {
        public void accept(T t) throws I;
    }

    public static class ReadConfiguration implements ThrowingConsumer<LogManager, IOException> {

        @Override
        public void accept(LogManager t) throws IOException {
            t.readConfiguration();
        }

    }

    public static void test(String loggerName) throws Exception {
        System.out.println("Starting test for " + loggerName);
        test("m.readConfiguration()", (m) -> m.readConfiguration());
        test("m.readConfiguration(new ByteArrayInputStream(new byte[0]))",
                (m) -> m.readConfiguration(new ByteArrayInputStream(new byte[0])));
        System.out.println("Test passed for " + loggerName);
    }

    public static void test(String testName,
            ThrowingConsumer<LogManager, IOException> readConfiguration) throws Exception {


        System.out.println("\nBEGIN " + testName);
        LogManager m = LogManager.getLogManager();

        final TestConfigurationListener l1 = new TestConfigurationListener("l#1");
        final TestConfigurationListener l2 = new TestConfigurationListener("l#2");
        final TestConfigurationListener l3 = new ThrowingConfigurationListener("l#3", false);
        final TestConfigurationListener l4 = new ThrowingConfigurationListener("l#4", true);
        final TestConfigurationListener l5 = new ThrowingConfigurationListener("l#5", false);

        final Set<String> expectedExceptions =
                Collections.unmodifiableSet(
                        new HashSet<>(Arrays.asList(
                                l3.toString(), l4.toString(), l5.toString())));

        m.addConfigurationListener(l1);
        m.addConfigurationListener(l2);
        expect(l1, 0);
        expect(l2, 0);

        readConfiguration.accept(m);
        expect(l1, 1);
        expect(l2, 1);
        m.addConfigurationListener(l1);
        expect(l1, 1);
        expect(l2, 1);
        readConfiguration.accept(m);
        expect(l1, 2);
        expect(l2, 2);
        m.removeConfigurationListener(l1);
        expect(l1, 2);
        expect(l2, 2);
        readConfiguration.accept(m);
        expect(l1, 2);
        expect(l2, 3);
        m.removeConfigurationListener(l1);
        expect(l1, 2);
        expect(l2, 3);
        readConfiguration.accept(m);
        expect(l1, 2);
        expect(l2, 4);
        m.removeConfigurationListener(l2);
        expect(l1, 2);
        expect(l2, 4);
        readConfiguration.accept(m);
        expect(l1, 2);
        expect(l2, 4);

        // l1 and l2 should no longer be present: this should not fail...
        m.removeConfigurationListener(l1);
        m.removeConfigurationListener(l1);
        m.removeConfigurationListener(l2);
        m.removeConfigurationListener(l2);
        expect(l1, 2);
        expect(l2, 4);

        readConfiguration.accept(m);
        expect(l1, 2);
        expect(l2, 4);

        // add back l1 and l2
        m.addConfigurationListener(l1);
        m.addConfigurationListener(l2);
        expect(l1, 2);
        expect(l2, 4);

        readConfiguration.accept(m);
        expect(l1, 3);
        expect(l2, 5);

        m.removeConfigurationListener(l1);
        m.removeConfigurationListener(l2);
        expect(l1, 3);
        expect(l2, 5);

        readConfiguration.accept(m);
        expect(l1, 3);
        expect(l2, 5);

        // Check the behavior when listeners throw exceptions
        // l3, l4, and l5 will throw an error/exception.
        // The first that is raised will be propagated, after all listeners
        // have been invoked. The other exceptions will be added to the
        // suppressed list.
        //
        // We will check that all listeners have been invoked and that we
        // have the set of 3 exceptions expected from l3, l4, l5.
        //
        m.addConfigurationListener(l4);
        m.addConfigurationListener(l1);
        m.addConfigurationListener(l2);
        m.addConfigurationListener(l3);
        m.addConfigurationListener(l5);

        try {
            readConfiguration.accept(m);
            throw new RuntimeException("Excpected exception/error not raised");
        } catch(ConfigurationListenerException | ConfigurationListenerError t) {
            final Set<String> received = new HashSet<>();
            received.add(t.toString());
            for (Throwable s : t.getSuppressed()) {
                received.add(s.toString());
            }
            System.out.println("Received exceptions: " + received);
            if (!expectedExceptions.equals(received)) {
                throw new RuntimeException(
                        "List of received exceptions differs from expected:"
                                + "\n\texpected: " + expectedExceptions
                                + "\n\treceived: " + received);
            }
        }
        expect(l1, 4);
        expect(l2, 6);

        m.removeConfigurationListener(l1);
        m.removeConfigurationListener(l2);
        m.removeConfigurationListener(l3);
        m.removeConfigurationListener(l4);
        m.removeConfigurationListener(l5);
        readConfiguration.accept(m);
        expect(l1, 4);
        expect(l2, 6);


        try {
            m.addConfigurationListener(null);
            throw new RuntimeException(
                    "addConfigurationListener(null): Expected NPE not thrown.");
        } catch (NullPointerException npe) {
            System.out.println("Got expected NPE: "+npe);
        }

        try {
            m.removeConfigurationListener(null);
            throw new RuntimeException(
                    "removeConfigurationListener(null): Expected NPE not thrown.");
        } catch (NullPointerException npe) {
            System.out.println("Got expected NPE: "+npe);
        }

        System.out.println("END " + testName+"\n");

    }


    static final class PermissionsBuilder {
        final Permissions perms;
        public PermissionsBuilder() {
            this(new Permissions());
        }
        public PermissionsBuilder(Permissions perms) {
            this.perms = perms;
        }
        public PermissionsBuilder add(Permission p) {
            perms.add(p);
            return this;
        }
        public PermissionsBuilder addAll(PermissionCollection col) {
            if (col != null) {
                for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
                    perms.add(e.nextElement());
                }
            }
            return this;
        }
        public Permissions toPermissions() {
            final PermissionsBuilder builder = new PermissionsBuilder();
            builder.addAll(perms);
            return builder.perms;
        }
    }

    public static class SimplePolicy extends Policy {

        static final Policy DEFAULT_POLICY = Policy.getPolicy();

        final Permissions permissions;
        public SimplePolicy(TestCase test) {
            permissions = new Permissions();
            if (test != TestCase.PERMISSION) {
                permissions.add(new LoggingPermission("control", null));
                permissions.add(new PropertyPermission("java.util.logging.config.class", "read"));
                permissions.add(new PropertyPermission("java.util.logging.config.file", "read"));
                permissions.add(new PropertyPermission("java.home", "read"));
                permissions.add(new FilePermission("<<ALL FILES>>", "read"));
            }
        }

        @Override
        public boolean implies(ProtectionDomain domain, Permission permission) {
            return permissions.implies(permission) || DEFAULT_POLICY.implies(domain, permission);
        }

        @Override
        public PermissionCollection getPermissions(CodeSource codesource) {
            return new PermissionsBuilder().addAll(permissions).toPermissions();
        }

        @Override
        public PermissionCollection getPermissions(ProtectionDomain domain) {
            return new PermissionsBuilder().addAll(permissions).toPermissions();
        }
    }

}