/*

 * Copyright (c) 2014, 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.ByteArrayOutputStream;

import java.io.FilePermission;

import java.io.IOException;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.nio.file.Files;

import java.nio.file.Paths;

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.Enumeration;

import java.util.HashSet;

import java.util.List;

import java.util.Properties;

import java.util.Set;

import java.util.UUID;

import java.util.concurrent.Callable;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.FileHandler;

import java.util.logging.Handler;

import java.util.logging.LogManager;

import java.util.logging.Logger;

import java.util.logging.LoggingPermission;

/**

 * @test

 * @bug 8060132

 * @summary tests that FileHandlers configured on abstract nodes in logging.properties

 *          will be closed by reset().

 * @run main/othervm ParentLoggerWithHandlerGC UNSECURE

 * @run main/othervm ParentLoggerWithHandlerGC SECURE

 * @author danielfuchs

 * @key randomness

 */

public class ParentLoggerWithHandlerGC {

    /**

     * We will test the handling of abstract logger nodes with file handlers in

     * two configurations:

     * UNSECURE: No security manager.

     * SECURE: With the security manager present - and the required

     *         permissions granted.

     */

    public static enum TestCase {

        UNSECURE, SECURE;

        public void run(Properties propertyFile) throws Exception {

            System.out.println("Running test case: " + name());

            Configure.setUp(this, propertyFile);

            test(this.name() + " " + propertyFile.getProperty("test.name"), propertyFile);

        }

    }

    private static final String PREFIX =

            "FileHandler-" + UUID.randomUUID() + ".log";

    private static final String userDir = System.getProperty("user.dir", ".");

    private static final boolean userDirWritable = Files.isWritable(Paths.get(userDir));

    static enum ConfigMode { DEFAULT, ENSURE_CLOSE_ON_RESET_TRUE, ENSURE_CLOSE_ON_RESET_FALSE }

    private static final List<Properties> properties;

    static {

        Properties props1 = new Properties();

        props1.setProperty("test.name", "parent logger with handler");

        props1.setProperty("test.config.mode", ConfigMode.DEFAULT.name());

        props1.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);

        props1.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));

        props1.setProperty(FileHandler.class.getName() + ".level", "ALL");

        props1.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");

        props1.setProperty("com.foo.handlers", FileHandler.class.getName());

        props1.setProperty("com.bar.level", "FINEST");

        Properties props2 = new Properties();

        props2.setProperty("test.name", "parent logger with handler");

        props2.setProperty("test.config.mode", ConfigMode.ENSURE_CLOSE_ON_RESET_TRUE.name());

        props2.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);

        props2.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));

        props2.setProperty(FileHandler.class.getName() + ".level", "ALL");

        props2.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");

        props2.setProperty("com.foo.handlers", FileHandler.class.getName());

        props2.setProperty("com.foo.handlers.ensureCloseOnReset", "true");

        props2.setProperty("com.bar.level", "FINEST");

        Properties props3 = new Properties();

        props3.setProperty("test.name", "parent logger with handler");

        props3.setProperty("test.config.mode", ConfigMode.ENSURE_CLOSE_ON_RESET_FALSE.name());

        props3.setProperty(FileHandler.class.getName() + ".pattern", PREFIX);

        props3.setProperty(FileHandler.class.getName() + ".limit", String.valueOf(Integer.MAX_VALUE));

        props3.setProperty(FileHandler.class.getName() + ".level", "ALL");

        props3.setProperty(FileHandler.class.getName() + ".formatter", "java.util.logging.SimpleFormatter");

        props3.setProperty("com.foo.handlers", FileHandler.class.getName());

        props3.setProperty("com.foo.handlers.ensureCloseOnReset", "false");

        props3.setProperty("com.bar.level", "FINEST");

        properties = Collections.unmodifiableList(Arrays.asList(

                    props1, props2, props3));

    }

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

        if (args == null || args.length == 0) {

            args = new String[] {

                TestCase.UNSECURE.name(),

                TestCase.SECURE.name(),

            };

        }

        try {

            for (String testName : args) {

                for (Properties propertyFile : properties) {

                    TestCase test = TestCase.valueOf(testName);

                    test.run(propertyFile);

                }

            }

        } finally {

            if (userDirWritable) {

                Configure.doPrivileged(() -> {

                    // cleanup - delete files that have been created

                    try {

                        Files.list(Paths.get(userDir))

                            .filter((f) -> f.toString().contains(PREFIX))

                            .forEach((f) -> {

                                try {

                                    System.out.println("deleting " + f);

                                    Files.delete(f);

                                } catch(Throwable t) {

                                    System.err.println("Failed to delete " + f + ": " + t);

                                }

                            });

                    } catch(Throwable t) {

                        System.err.println("Cleanup failed to list files: " + t);

                        t.printStackTrace();

                    }

                });

            }

        }

    }

    static class Configure {

        static Policy policy = null;

        static final AtomicBoolean allowAll = new AtomicBoolean(false);

        static void setUp(TestCase test, Properties propertyFile) {

            switch (test) {

                case SECURE:

                    if (policy == null && System.getSecurityManager() != null) {

                        throw new IllegalStateException("SecurityManager already set");

                    } else if (policy == null) {

                        policy = new SimplePolicy(TestCase.SECURE, allowAll);

                        Policy.setPolicy(policy);

                        System.setSecurityManager(new SecurityManager());

                    }

                    if (System.getSecurityManager() == null) {

                        throw new IllegalStateException("No SecurityManager.");

                    }

                    if (policy == null) {

                        throw new IllegalStateException("policy not configured");

                    }

                    break;

                case UNSECURE:

                    if (System.getSecurityManager() != null) {

                        throw new IllegalStateException("SecurityManager already set");

                    }

                    break;

                default:

                    new InternalError("No such testcase: " + test);

            }

            doPrivileged(() -> {

                try {

                    ByteArrayOutputStream bytes = new ByteArrayOutputStream();

                    propertyFile.store(bytes, propertyFile.getProperty("test.name"));

                    ByteArrayInputStream bais = new ByteArrayInputStream(bytes.toByteArray());

                    LogManager.getLogManager().readConfiguration(bais);

                } catch (IOException ex) {

                    throw new RuntimeException(ex);

                }

            });

        }

        static void doPrivileged(Runnable run) {

            allowAll.set(true);

            try {

                run.run();

            } finally {

                allowAll.set(false);

            }

        }

        static <T> T callPrivileged(Callable<T> call) throws Exception {

            allowAll.set(true);

            try {

                return call.call();

            } finally {

                allowAll.set(false);

            }

        }

    }

    @FunctionalInterface

    public static interface FileHandlerSupplier {

        public FileHandler test() throws Exception;

    }

    static final class TestAssertException extends RuntimeException {

        TestAssertException(String msg) {

            super(msg);

        }

    }

    private static void assertEquals(long expected, long received, String msg) {

        if (expected != received) {

            throw new TestAssertException("Unexpected result for " + msg

                    + ".\n\texpected: " + expected

                    +  "\n\tactual:   " + received);

        } else {

            System.out.println("Got expected " + msg + ": " + received);

        }

    }

    public static void test(String name, Properties props) throws Exception {

        ConfigMode configMode = ConfigMode.valueOf(props.getProperty("test.config.mode"));

        System.out.println("\nTesting: " + name + " mode=" + configMode);

        if (!userDirWritable) {

            throw new RuntimeException("Not writable: "+userDir);

        }

        switch(configMode) {

            case DEFAULT:

            case ENSURE_CLOSE_ON_RESET_TRUE:

                testCloseOnResetTrue(name, props); break;

            case ENSURE_CLOSE_ON_RESET_FALSE:

                testCloseOnResetFalse(name, props); break;

            default:

                throw new RuntimeException("Unknwown mode: " + configMode);

        }

    }

    // Test a configuration which has either

    // com.foo.handlers.ensureCloseOnReset=true, or where

    // com.foo.handlers.ensureCloseOnReset is not specified.

    public static void testCloseOnResetTrue(String name, Properties props)

            throws Exception {

        Logger fooChild = Logger.getLogger("com.foo.child");

        fooChild.info("hello world");

        Logger barChild = Logger.getLogger("com.bar.child");

        barChild.info("hello world");

        ReferenceQueue<Logger> queue = new ReferenceQueue();

        WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);

        if (fooRef.get() != fooChild.getParent()) {

            throw new RuntimeException("Unexpected parent logger: "

                    + fooChild.getParent() +"\n\texpected: " + fooRef.get());

        }

        WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);

        if (barRef.get() != barChild.getParent()) {

            throw new RuntimeException("Unexpected parent logger: "

                    + barChild.getParent() +"\n\texpected: " + barRef.get());

        }

        fooChild = barChild = null;

        Reference<? extends Logger> ref2 = null;

        while ((ref2 = queue.poll()) == null) {

            System.gc();

            Thread.sleep(1000);

        }

        Throwable failed = null;

        try {

            do {

                if (ref2 != barRef) {

                    throw new RuntimeException("Unexpected reference: "

                            + ref2 +"\n\texpected: " + barRef);

                }

                if (ref2.get() != null) {

                    throw new RuntimeException("Referent not cleared: "

                            + ref2.get());

                }

                System.out.println("Got barRef");

                System.gc();

                Thread.sleep(1000);

            } while( (ref2 = queue.poll()) != null);

            System.out.println("Parent logger GCed");

        } catch(Throwable t) {

            failed = t;

        } finally {

            final Throwable suppressed = failed;

            Configure.doPrivileged(() -> LogManager.getLogManager().reset());

            Configure.doPrivileged(() -> {

                try {

                    StringBuilder builder = new StringBuilder();

                    Files.list(Paths.get(userDir))

                        .filter((f) -> f.toString().contains(PREFIX))

                        .filter((f) -> f.toString().endsWith(".lck"))

                        .forEach((f) -> {

                                builder.append(f.toString()).append('\n');

                        });

                    if (!builder.toString().isEmpty()) {

                        throw new RuntimeException("Lock files not cleaned:\n"

                                + builder.toString());

                    }

                } catch(RuntimeException | Error x) {

                    if (suppressed != null) x.addSuppressed(suppressed);

                    throw x;

                } catch(Exception x) {

                    if (suppressed != null) x.addSuppressed(suppressed);

                    throw new RuntimeException(x);

                }

            });

            while ((ref2 = queue.poll()) == null) {

                System.gc();

                Thread.sleep(1000);

            }

            if (ref2 != fooRef) {

                throw new RuntimeException("Unexpected reference: "

                        + ref2 +"\n\texpected: " + fooRef);

            }

            if (ref2.get() != null) {

                throw new RuntimeException("Referent not cleared: " + ref2.get());

            }

            System.out.println("Got fooRef after reset()");

        }

        if (failed != null) {

            // should rarely happen...

            throw new RuntimeException(failed);

        }

    }

    private static Handler getHandlerToClose() throws Exception {

        return Configure.callPrivileged(

                () -> Logger.getLogger("com.foo.child").getParent().getHandlers()[0]);

    }

    // Test a configuration which has com.foo.handlers.ensureCloseOnReset=false

    public static void testCloseOnResetFalse(String name, Properties props)

            throws Exception {

        Logger fooChild = Logger.getLogger("com.foo.child");

        fooChild.info("hello world");

        Logger barChild = Logger.getLogger("com.bar.child");

        barChild.info("hello world");

        Handler toClose = getHandlerToClose();

        ReferenceQueue<Logger> queue = new ReferenceQueue();

        WeakReference<Logger> fooRef = new WeakReference<>(Logger.getLogger("com.foo"), queue);

        if (fooRef.get() != fooChild.getParent()) {

            throw new RuntimeException("Unexpected parent logger: "

                    + fooChild.getParent() +"\n\texpected: " + fooRef.get());

        }

        WeakReference<Logger> barRef = new WeakReference<>(Logger.getLogger("com.bar"), queue);

        if (barRef.get() != barChild.getParent()) {

            throw new RuntimeException("Unexpected parent logger: "

                    + barChild.getParent() +"\n\texpected: " + barRef.get());

        }

        fooChild = barChild = null;

        Reference<? extends Logger> ref2 = null;

        Set<WeakReference<Logger>> expectedRefs = new HashSet<>(Arrays.asList(fooRef, barRef));

        Throwable failed = null;

        try {

            int l=0;

            while (failed == null && !expectedRefs.isEmpty()) {

                int max = 60;

                while ((ref2 = queue.poll()) == null) {

                    if (l > 0 && max-- <= 0) {

                        throw new RuntimeException("Logger #2 not GC'ed!"

                                + " max too short (max=60) or "

                                + "com.foo.handlers.ensureCloseOnReset=false"

                                + " does not work");

                    }

                    System.gc();

                    Thread.sleep(1000);

                }

                do {

                    if (!expectedRefs.contains(ref2)) {

                        throw new RuntimeException("Unexpected reference: "

                                + ref2 +"\n\texpected: " + expectedRefs);

                    }

                    if (ref2.get() != null) {

                        throw new RuntimeException("Referent not cleared: "

                                + ref2.get());

                    }

                    expectedRefs.remove(ref2);

                    System.out.println("Got "+

                            (ref2 == barRef ? "barRef"

                                    : (ref2 == fooRef ? "fooRef"

                                            : ref2.toString())));

                    System.gc();

                    Thread.sleep(1000);

                    System.out.println("Logger #" + (++l) + " GCed");

                } while( (ref2 = queue.poll()) != null);

            }

        } catch(Throwable t) {

            failed = t;

        } finally {

            final Throwable suppressed = failed;

            Configure.doPrivileged(() -> LogManager.getLogManager().reset());

            Configure.doPrivileged(() -> {

                try {

                    toClose.close();

                    StringBuilder builder = new StringBuilder();

                    Files.list(Paths.get(userDir))

                        .filter((f) -> f.toString().contains(PREFIX))

                        .filter((f) -> f.toString().endsWith(".lck"))

                        .forEach((f) -> {

                                builder.append(f.toString()).append('\n');

                        });

                    if (!builder.toString().isEmpty()) {

                        throw new RuntimeException("Lock files not cleaned:\n" + builder.toString());

                    }

                } catch(RuntimeException | Error x) {

                    if (suppressed != null) x.addSuppressed(suppressed);

                    throw x;

                } catch(Exception x) {

                    if (suppressed != null) x.addSuppressed(suppressed);

                    throw new RuntimeException(x);

                }

            });

        }

        if (failed != null) {

            // should rarely happen...

            throw new RuntimeException(failed);

        }

    }

        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 {

        final Permissions permissions;

        final Permissions allPermissions;

        final AtomicBoolean allowAll;

        public SimplePolicy(TestCase test, AtomicBoolean allowAll) {

            this.allowAll = allowAll;

            permissions = new Permissions();

            permissions.add(new LoggingPermission("control", null));

            permissions.add(new FilePermission(PREFIX+".lck", "read,write,delete"));

            permissions.add(new FilePermission(PREFIX, "read,write"));

            // these are used for configuring the test itself...

            allPermissions = new Permissions();

            allPermissions.add(new java.security.AllPermission());

        }

        @Override

        public boolean implies(ProtectionDomain domain, Permission permission) {

            if (allowAll.get()) return allPermissions.implies(permission);

            return permissions.implies(permission);

        }

        @Override

        public PermissionCollection getPermissions(CodeSource codesource) {

            return new PermissionsBuilder().addAll(allowAll.get()

                    ? allPermissions : permissions).toPermissions();

        }

        @Override

        public PermissionCollection getPermissions(ProtectionDomain domain) {

            return new PermissionsBuilder().addAll(allowAll.get()

                    ? allPermissions : permissions).toPermissions();

        }

    }

}