RecordsMXBeanTest.java

/*
 * Copyright (c) 2021, 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.InvalidObjectException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.management.Attribute;
import javax.management.ConstructorParameters;
import javax.management.JMX;
import javax.management.MBeanException;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.MBeanServerFactory;
import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;
import javax.management.StandardMBean;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeDataView;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenType;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorServer;
import javax.management.remote.JMXConnectorServerFactory;
import javax.management.remote.JMXServiceURL;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.*;

/**
 * @test
 * @bug 8264124
 * @run testng RecordsMXBeanTest
 */
public class RecordsMXBeanTest {
    // Simple record with open types
    public record Data(List<Integer> ints, Map<String, List<String>> map) {}
    // Used to test case in component names
    public record MixedCases(int Foo, int BarBar, int foo) {}
    // Used to test nested records
    public record DataPoint(Data x, Data y, MixedCases mixed) {}
    // Used to test reconstruction using a non-canonical constructor
    public record Annotated(int x, int y, int z) {
        @ConstructorParameters(value = {"y", "x"})
        public Annotated(int y, int x) {
            this(x,y,-1);
        }
    }
    // Used to test reconstruction using a static `from` method
    public record FromMethod(int x, int y, int z) {
        public static FromMethod from(CompositeData cd) {
            int x = (int) cd.get("x");
            int y = (int) cd.get("y");
            int z = -x -y;
            return new FromMethod(x, y, z);
        }
    }
    // A record that exposes methods that look like
    // getters... These should be ignored - only the
    // record components should be considered.
    public record Trickster(int x, int y) {
        public int getZ() { return -x() -y(); }
        public boolean isTricky() { return true; }
    }
    // A regular class similar to the Trickster,
    // but this time z and tricky should appear
    // in the composite data
    public static class TricksterToo {
        final int x;
        final int y;
        @ConstructorParameters({"x", "y"})
        public TricksterToo(int x, int y) {
            this.x = x; this.y = y;
        }
        public int getX() { return x; }
        public int getY() { return y; }
        public int getZ() { return -x -y; }
        public boolean isTricky() { return true; }
    }
    // A record with a conflicting name getX/x which
    // should ensure that non component getters are ignored
    public record RWithGetter(int x, int y) {
        public int getX() { return x;}
    }
    // A record with an annotated cannonical constructor.
    // Annotation should be ignored
    public record WithAnno(int x, int y) {
        @ConstructorParameters({"y", "x"})
        public WithAnno(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    // A record that implements CompositeDataView
    public record WithCDV(int x, int y) implements CompositeDataView {
        @Override
        public CompositeData toCompositeData(CompositeType ct) {
            if (ct == null) return null;
            try {
                return new CompositeDataSupport(ct, new String[]{"x", "y"}, new Object[]{x() + 1, y() + 2});
            } catch (OpenDataException x) {
                throw new IllegalArgumentException(ct.getTypeName(), x);
            }
        }
    }

    // A read only MXBean interface
    public interface RecordsMXBean {
        public Data getData();
        public DataPoint getDataPoint();
        public default Map<String, DataPoint> allPoints() {
            return Map.of("allpoints", getDataPoint());
        }
    }

    // A read-write MXBean interface
    public interface Records2MXBean extends RecordsMXBean {
        public void setDataPoint(DataPoint point);
    }

    // An implementation of the read-only MXBean interface which is
    // itself a record (this is already supported)
    public record Records(DataPoint point) implements RecordsMXBean {
        @Override
        public Data getData() {
            return point().x();
        }

        @Override
        public DataPoint getDataPoint() {
            return point();
        }

        @Override
        public Map<String, DataPoint> allPoints() {
            return Map.of("point", point());
        }
    }

    // An implementation of the read-write MXBean interface
    public static class Records2 implements Records2MXBean {
        private volatile DataPoint point = new DataPoint(
                new Data(List.of(1, 2), Map.of("foo", List.of("bar"))),
                new Data(List.of(3, 4), Map.of("bar", List.of("foo"))),
                new MixedCases(5, 6, 7)
                );

        @Override
        public Data getData() {
            return point.x;
        }

        @Override
        public DataPoint getDataPoint() {
            return point;
        }

        @Override
        public void setDataPoint(DataPoint point) {
            this.point = point;
        }

        @Override
        public Map<String, DataPoint> allPoints() {
            return Map.of("point", point);
        }
    }

    // A complex MXBean interface used to test reconstruction
    // of records through non-canonical annotated constructors
    // and static `from` method
    public interface ComplexMXBean {
        Annotated getAnnotated();
        void setAnnotated(Annotated annotated);
        FromMethod getFromMethod();
        void setFromMethod(FromMethod fromMethod);
        Trickster getTrickster();
        void setTrickster(Trickster trick);
        TricksterToo getTricksterToo();
        void setTricksterToo(TricksterToo trick);
        RWithGetter getR();
        void setR(RWithGetter r);
        WithAnno getWithAnno();
        void setWithAnno(WithAnno r);
        WithCDV getCDV();
        void setCDV(WithCDV cdv);
    }

    // An implementation of the complex MXBean interface
    public static class Complex implements ComplexMXBean {
        private volatile Annotated annotated = new Annotated(1, 2, 3);
        private volatile FromMethod fromMethod = new FromMethod(1, 2, 3);
        private volatile Trickster trickster = new Trickster(4, 5);
        private volatile TricksterToo too = new TricksterToo(6, 7);
        private volatile RWithGetter r = new RWithGetter(8, 9);
        private volatile WithAnno withAnno = new WithAnno(10, 11);
        private volatile WithCDV withCDV = new WithCDV(12, 13);

        @Override
        public Annotated getAnnotated() {
            return annotated;
        }

        @Override
        public void setAnnotated(Annotated annotated) {
            this.annotated = annotated;
        }

        @Override
        public FromMethod getFromMethod() {
            return fromMethod;
        }

        @Override
        public void setFromMethod(FromMethod fromMethod) {
            this.fromMethod = fromMethod;
        }

        @Override
        public Trickster getTrickster() {
            return trickster;
        }

        @Override
        public void setTrickster(Trickster trickster) {
            this.trickster = trickster;
        }

        @Override
        public TricksterToo getTricksterToo() {
            return too;
        }

        @Override
        public void setTricksterToo(TricksterToo trick) {
            too = trick;
        }

        @Override
        public RWithGetter getR() {
            return r;
        }

        @Override
        public void setR(RWithGetter r) {
            this.r = r;
        }

        @Override
        public WithAnno getWithAnno() {
            return withAnno;
        }

        @Override
        public void setWithAnno(WithAnno r) {
            this.withAnno = r;
        }

        @Override
        public WithCDV getCDV() {
            return withCDV;
        }

        @Override
        public void setCDV(WithCDV cdv) {
            withCDV = cdv;
        }
    }

    public record NonCompliantR1(int x, Object y) {
        public int getX() { return x;}
    }
    public interface NC1MXBean {
        public NonCompliantR1 getNCR1();
    }
    public class NC1 implements NC1MXBean {
        private volatile NonCompliantR1 ncr1 = new NonCompliantR1(1,2);

        @Override
        public NonCompliantR1 getNCR1() {
            return ncr1;
        }
    }

    public record NonCompliantR2(int x, List<? super Integer> y) {
    }
    public interface NC2MXBean {
        public NonCompliantR2 getNCR2();
    }
    public class NC2 implements NC2MXBean {
        private volatile NonCompliantR2 ncr2 = new NonCompliantR2(1,List.of(2));

        @Override
        public NonCompliantR2 getNCR2() {
            return ncr2;
        }
    }

    public record NonCompliantR3() {
    }
    public interface NC3MXBean {
        public NonCompliantR3 getNCR3();
    }
    public class NC3 implements NC3MXBean {
        private volatile NonCompliantR3 ncr3 = new NonCompliantR3();

        @Override
        public NonCompliantR3 getNCR3() {
            return ncr3;
        }
    }

    @DataProvider(name = "wrapInStandardMBean")
    Object[][] wrapInStandardMBean() {
        return new Object[][] {
                new Object[] {"wrapped in StandardMBean", true},
                new Object[] {"not wrapped in StandardMBean", false}
        };
    }

    @Test(dataProvider = "wrapInStandardMBean")
    public void testLocal(String desc, boolean standard) throws Exception {
        // test local
        System.out.println("\nTest local " + desc);
        MBeanServer mbs = MBeanServerFactory.newMBeanServer("test");
        test(mbs, mbs, standard);
    }

    @Test(dataProvider = "wrapInStandardMBean")
    public void testRemote(String desc, boolean standard) throws Exception {
        // test remote
        System.out.println("\nTest remote " + desc);
        MBeanServer mbs = MBeanServerFactory.newMBeanServer("test");
        final JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
        JMXConnectorServer server =
                JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);
        server.start();
        try {
            JMXConnector ctor = server.toJMXConnector(null);
            ctor.connect();
            try {
                test(mbs, ctor.getMBeanServerConnection(), standard);
            } finally {
                ctor.close();
            }
        } finally {
            server.stop();
        }
    }

    private void test(MBeanServer server, MBeanServerConnection connection, boolean standard)
            throws Exception {

        // test RecordsMXBean via MBeanServerConnection
        assertTrue(JMX.isMXBeanInterface(RecordsMXBean.class));
        Records records = new Records(new DataPoint(
                new Data(List.of(1, 2), Map.of("foo", List.of("bar"))),
                new Data(List.of(3, 4), Map.of("bar", List.of("foo"))),
                new MixedCases(5, 6, 7)
        ));
        ObjectName recname = new ObjectName("test:type=Records");
        var mbean = standard
                ? new StandardMBean(records, RecordsMXBean.class, true)
                : records;
        server.registerMBean(mbean, recname);
        RecordsMXBean mxBean = JMX.newMXBeanProxy(connection, recname, RecordsMXBean.class);
        Records retrieved = new Records(mxBean.getDataPoint());
        assertEquals(retrieved, records);
        assertEquals(mxBean.allPoints(), records.allPoints());

        // test Records2MXBean via MBeanServerConnection
        assertTrue(JMX.isMXBeanInterface(Records2MXBean.class));
        Records2 records2 = new Records2();
        assertEquals(records2.allPoints(), records.allPoints());
        ObjectName recname2 = new ObjectName("test:type=Records2");
        var mbean2 = standard
                ? new StandardMBean(records2, Records2MXBean.class, true)
                : records2;
        server.registerMBean(mbean2, recname2);
        Records2MXBean mxBean2 = JMX.newMXBeanProxy(connection, recname2, Records2MXBean.class);
        Records retrieved2 = new Records(mxBean2.getDataPoint());
        assertEquals(retrieved2, records);
        assertEquals(mxBean2.allPoints(), records.allPoints());

        // mutate Records2MXBean via MBeanServerConnection
        DataPoint point2 = new DataPoint(records.point().y(), records.point().x(), records.point().mixed());
        mxBean2.setDataPoint(point2);
        assertEquals(mxBean2.getDataPoint(), point2);
        assertEquals(mxBean2.allPoints(), Map.of("point", point2));

        // test reconstruction through non-canonical constructor and from method
        Complex complex = new Complex();
        var complexMBean = new StandardMBean(complex, ComplexMXBean.class, true);
        ObjectName recname3 = new ObjectName("test:type=Complex");
        var mbean3 = standard ? complexMBean : complex;
        server.registerMBean(complexMBean, recname3);
        ComplexMXBean mBean5 = JMX.newMXBeanProxy(connection, recname3, ComplexMXBean.class);
        var annotated = mBean5.getAnnotated();
        assertEquals(annotated, complex.getAnnotated());
        // Obtain the CompositeData that corresponds to the Annotated record
        var cd = (CompositeData) complexMBean.getAttribute("Annotated");
        var ct = cd.getCompositeType();
        // Construct a version of the "Annotated" composite data where z is missing
        var nct = new CompositeType(ct.getTypeName(), ct.getDescription(), new String[] {"x", "y"},
                new String[] {ct.getDescription("x"), ct.getDescription("y")},
                new OpenType<?>[] {ct.getType("x"), ct.getType("y")});
        var ncd = new CompositeDataSupport(nct, new String[] {"x", "y"},
                new Object[] {cd.get("x"), cd.get("y")});
        // send the modified composite data to remote, and check
        // that the non-canonical constructor was called (this constructor
        // sets z = -1)
        connection.setAttribute(recname3, new Attribute("Annotated", ncd));
        var annotated2 = mBean5.getAnnotated();
        assertEquals(annotated2.x(), annotated.x());
        assertEquals(annotated2.y(), annotated2.y());
        assertEquals(annotated2.z(), -1);
        // gets the FromMethod record, and check that the `from` method
        // we defined was called. When reconstructed from our `from` method,
        // z will be set to z = -x -y;
        var from = mBean5.getFromMethod();
        assertEquals(from.x(), 1);
        assertEquals(from.y(), 2);
        assertEquals(from.z(), -3);
        mBean5.setFromMethod(new FromMethod(2, 1, 3));
        from = mBean5.getFromMethod();
        assertEquals(from.x(), 2);
        assertEquals(from.y(), 1);
        assertEquals(from.z(), -3);
        // checks that the presence of getter-like methods doesn't
        // prevent the record from being reconstructed.
        var cdtrick = (CompositeData) connection.getAttribute(recname3, "Trickster");
        println("tricky", cdtrick);
        assertEquals(cdtrick.getCompositeType().keySet(), Set.of("x", "y"));
        var trick = mBean5.getTrickster();
        assertEquals(trick.x(), 4);
        assertEquals(trick.y(), 5);
        assertEquals(trick.getZ(), -9);
        assertTrue(trick.isTricky());
        mBean5.setTrickster(new Trickster(5, 4));
        trick = mBean5.getTrickster();
        assertEquals(trick.x(), 5);
        assertEquals(trick.y(), 4);
        assertEquals(trick.getZ(), -9);
        assertTrue(trick.isTricky());
        // get the "TricksterToo" composite data
        var cdtoo = (CompositeData) connection.getAttribute(recname3, "TricksterToo");
        println("tricky too", cdtoo);
        assertEquals(cdtoo.getCompositeType().keySet(), Set.of("x", "y", "tricky", "z"));
        var too = mBean5.getTricksterToo();
        assertEquals(too.getX(), 6);
        assertEquals(too.getY(), 7);
        assertEquals(too.getZ(), -13);
        assertTrue(too.isTricky());
        mBean5.setTricksterToo(new TricksterToo(7, 6));
        too = mBean5.getTricksterToo();
        assertEquals(too.getX(), 7);
        assertEquals(too.getY(), 6);
        assertEquals(too.getZ(), -13);
        assertTrue(too.isTricky());

        // builds a composite data that contains more fields than
        // the record...
        var cdtype = cdtrick.getCompositeType();
        var itemNames = List.of("x", "y", "z", "tricky").toArray(new String[0]);
        var itemDesc = Stream.of(itemNames)
                .map(cdtoo.getCompositeType()::getDescription)
                .toArray(String[]::new);
        var itemTypes = Stream.of(itemNames)
                .map(cdtoo.getCompositeType()::getType)
                .toArray(OpenType<?>[]::new);
        var cdtype2 = new CompositeType(cdtype.getTypeName(),
                cdtype.getDescription(), itemNames, itemDesc, itemTypes);
        var values = Stream.of(itemNames).map(cdtoo::get).toArray();
        var cdtrick2 = new CompositeDataSupport(cdtype2, itemNames, values);
        // sets the composite data with more fields - the superfluous fields
        // should be ignored...
        connection.setAttribute(recname3, new Attribute("Trickster", cdtrick2));
        // get the composite data we just set
        var cdtrick3 = (CompositeData) connection.getAttribute(recname3, "Trickster");
        assertEquals(cdtrick3.getCompositeType().keySet(), Set.of("x", "y"));
        // get the "Trickster" through the MXBean proxy
        var trick3 = mBean5.getTrickster();
        assertEquals(trick3.x(), 6);
        assertEquals(trick3.y(), 7);
        assertEquals(trick3.getZ(), -13);
        assertEquals(trick3.isTricky(), true);
        // get record that has both x() and getX()
        var rWithGetter = mBean5.getR();
        assertEquals(rWithGetter.x(), rWithGetter.getX());
        assertEquals(rWithGetter.x(), 8);
        assertEquals(rWithGetter.y(), 9);
        mBean5.setR(new RWithGetter(rWithGetter.y(), rWithGetter.x()));
        rWithGetter = mBean5.getR();
        assertEquals(rWithGetter.x(), rWithGetter.getX());
        assertEquals(rWithGetter.x(), 9);
        assertEquals(rWithGetter.y(), 8);

        var withAnno = mBean5.getWithAnno();
        assertEquals(withAnno.x(), 10);
        assertEquals(withAnno.y(), 11);
        withAnno = new WithAnno(12, 13);
        mBean5.setWithAnno(withAnno);
        withAnno = mBean5.getWithAnno();
        assertEquals(withAnno.x(), 12);
        assertEquals(withAnno.y(), 13);

        // WithCDV.toCompositeData adds 1 to x and 2 to y,
        // we can check how many time it's been called
        // by looking at the values for x and y.
        var cdv = mBean5.getCDV();
        assertEquals(cdv.x(), 13 /* 12 + 1 */, "x");
        assertEquals(cdv.y(), 15 /* 13 + 2 */, "y");
        mBean5.setCDV(new WithCDV(14, 15));
        cdv = mBean5.getCDV();
        assertEquals(cdv.x(), 16 /* 14 + 1*2 */, "x");
        assertEquals(cdv.y(), 19 /* 15 + 2*2 */, "y");

        // Test non compliant records: this one has an Object (not mappable to OpenType)
        var recname4 = new ObjectName("test:type=NCR1");
        var x = standard
                ? expectThrows(IllegalArgumentException.class,
                () -> new StandardMBean(new NC1(), NC1MXBean.class, true))
                : expectThrows(NotCompliantMBeanException.class,
                () -> server.registerMBean(new NC1(), recname4));
        reportExpected(x);
        assertEquals( originalCause(x).getClass(), OpenDataException.class);

        // Test non compliant records: this one has a List<? super Integer>
        // (not mappable to OpenType)
        var recname5 = new ObjectName("test:type=NCR2");
        var x2 = standard
                ? expectThrows(IllegalArgumentException.class,
                () -> new StandardMBean(new NC2(), NC2MXBean.class, true))
                : expectThrows(NotCompliantMBeanException.class,
                () -> server.registerMBean(new NC2(), recname5));
        reportExpected(x2);
        assertEquals( originalCause(x2).getClass(), OpenDataException.class);

        // Test non compliant records: this one has no getters
        // (not mappable to OpenType)
        var recname6 = new ObjectName("test:type=NCR3");
        var x3 = standard
                ? expectThrows(IllegalArgumentException.class,
                () -> new StandardMBean(new NC3(), NC3MXBean.class, true))
                : expectThrows(NotCompliantMBeanException.class,
                () -> server.registerMBean(new NC3(), recname6));
        reportExpected(x3);
        assertEquals( originalCause(x3).getClass(), OpenDataException.class);

        // test that a composite data that doesn't have all the records
        // components prevents the record from being reconstructed.
        var recname7 = new ObjectName("test:type=Records2,instance=6");
        Records2 rec2 = new Records2();
        var mbean7 = standard
                ? new StandardMBean(rec2, Records2MXBean.class, true)
                : rec2;
        server.registerMBean(mbean7, recname7);
        var cd7 = (CompositeData) server.getAttribute(recname7, "DataPoint");
        var cdt7 = cd7.getCompositeType();
        var itemNames7 = List.of("x", "mixed")
                .toArray(String[]::new);
        var itemDesc7 = Stream.of(itemNames7)
                .map(cdt7::getDescription)
                .toArray(String[]::new);
        var itemTypes7 = Stream.of(itemNames7)
                .map(cdt7::getType)
                .toArray(OpenType<?>[]::new);
        var notmappable = new CompositeType(cdt7.getTypeName(),
                cdt7.getDescription(),
                itemNames7,
                itemDesc7,
                itemTypes7);
        var itemValues7 = Stream.of(itemNames7)
                .map(cd7::get)
                .toArray();
        var notmappableVal = new CompositeDataSupport(notmappable, itemNames7, itemValues7);
        var attribute6 = new Attribute("DataPoint", notmappableVal);
        var x4 = expectThrows(MBeanException.class,
                standard ? () -> ((StandardMBean)mbean7).setAttribute(attribute6)
                         : () -> server.setAttribute(recname7, attribute6));
        reportExpected(x4);
        assertEquals(originalCause(x4).getClass(), InvalidObjectException.class);

    }

    static final void reportExpected(Throwable x) {
        System.out.println("\nGot expected exception: " + x);
        Throwable cause = x;
        while ((cause = cause.getCause()) != null) {
            System.out.println("\tCaused by: " + cause);
        }
    }

    static final Throwable originalCause(Throwable t) {
        while (t.getCause() != null) t = t.getCause();
        return t;
    }

    static void println(String name, CompositeData cd) {
        var cdt = cd.getCompositeType();
        System.out.printf("%s: %s %s\n", name, cdt.getTypeName(),
                cdt.keySet().stream()
                .map(k -> k + "=" + cd.get(k))
                .collect(Collectors.joining(", ", "{ ", " }")));

    }

}