Java example source code file (DerivedGaugeMonitorTest.java)

This example Java source code file (DerivedGaugeMonitorTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

along, anint, clonenotsupportedexception, countdownlatch, countermonitor, derivedgauge, exception, gaugemonitor, management, mbeanserver, mymbean, mythings, objectname, string, things, threading, threads

The DerivedGaugeMonitorTest.java Java example source code

/*
 * Copyright (c) 2008, 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.
 */

/*
 * @test
 * @bug 6683213
 * @summary Test that the initial derived gauge is (Integer)0
 * @author Daniel Fuchs
 * @run clean DerivedGaugeMonitorTest
 * @run build DerivedGaugeMonitorTest
 * @run main DerivedGaugeMonitorTest
 */

import java.io.Serializable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.ObjectName;
import javax.management.monitor.CounterMonitor;
import javax.management.monitor.GaugeMonitor;

public class DerivedGaugeMonitorTest {

    public static interface Things {
        public long getALong();
        public int getAnInt();
        public double getADouble();
        public short getAShort();
        public byte getAByte();
        public float getAFloat();
    }
    public static interface MyMBean extends Things {
        public Things getAThing();
    }

    public static class MyThings implements Things, Serializable {
        private static final long serialVersionUID = -4333982919572564126L;

        private volatile long along = 0;
        private volatile int anint = 0;
        private volatile short ashort = 0;
        private volatile byte abyte = 0;
        private volatile float afloat = 0;
        private volatile double adouble = 0;

        private volatile transient boolean mutable;

        public MyThings() {
            this(false);
        }

        protected MyThings(boolean mutable) {
            this.mutable=mutable;
        }

        public long getALong() {
            return mutable?along++:along;
        }

        public int getAnInt() {
            return mutable?anint++:anint;
        }

        public double getADouble() {
            return mutable?adouble++:adouble;
        }

        public short getAShort() {
            return mutable?ashort++:ashort;
        }

        public byte getAByte() {
            return mutable?abyte++:abyte;
        }

        public float getAFloat() {
            return mutable?afloat++:afloat;
        }

        @Override
        public Object clone() throws CloneNotSupportedException {
            final MyThings other = (MyThings)super.clone();
            other.mutable=false;
            return other;
        }
    }

    public static class My implements MyMBean {

        public final CountDownLatch cdl = new CountDownLatch(6);

        private final MyThings things = new MyThings(true);
        private volatile int count = 0;

        public Things getAThing() {
            count++;
            cdl.countDown();
            try {
                return (Things) things.clone();
            } catch (CloneNotSupportedException ex) {
                return null;
            }
        }

        public long getALong() {
            count++;
            cdl.countDown();
            return things.getALong();
        }

        public int getAnInt() {
            count++;
            cdl.countDown();
            return things.getAnInt();
        }

        public double getADouble() {
            count++;
            cdl.countDown();
            return things.getADouble();
        }

        public short getAShort() {
            count++;
            cdl.countDown();
            return things.getAShort();
        }

        public byte getAByte() {
            count++;
            cdl.countDown();
            return things.getAByte();
        }

        public float getAFloat() {
            count++;
            cdl.countDown();
            return things.getAFloat();
        }

    }


    public static String[] attributes = {
        "AByte","AShort","AnInt","ALong","AFloat","ADouble"
    };
    public static String[] things = {
        "AThing.AByte","AThing.AShort","AThing.AnInt","AThing.ALong",
        "AThing.AFloat","AThing.ADouble"
    };

    public static void check(String attr, MBeanServer server, ObjectName mon,
            ObjectName mbean) throws Exception {
        final Object obj = server.getAttribute(mon, "DerivedGauge");
        check(attr,server,mon,mbean,obj);
    }

    public static void check(String attr, MBeanServer server, ObjectName mon,
            ObjectName mbean, Object obj) throws Exception  {
        if (obj == null)
            throw new Exception("Derived gauge for: " + attr +
                    " ["+mon+", "+mbean+"] is null!");
        if (!Integer.valueOf(0).equals(obj))
            throw new Exception("Derived gauge for: " + attr +
                    " ["+mon+", "+mbean+"] is "+obj);
    }

    public static void check(String attr, MBeanServer server, ObjectName mon,
            ObjectName mbean, long start) throws Exception {
        final Object obj = server.getAttribute(mon, "DerivedGauge");
        final long now = System.currentTimeMillis();
        final long gran = (Long)server.getAttribute(mon, "GranularityPeriod");
        if (now > start +2*gran) {
            throw new Exception(attr+": Can't verify test case: " +
                    "granularity period expired!");
        }
        check(attr,server,mon,mbean,obj);
    }

    public static void test(String attr) throws Exception {
        System.err.println("Testing "+ attr);
        final MBeanServer server = MBeanServerFactory.createMBeanServer();
        final ObjectName mbean = new ObjectName("ugly:type=cr.p");
        final My my = new My();
        final GaugeMonitor mon2 = new GaugeMonitor();
        final ObjectName mon2n = new ObjectName("mon1:type=GaugeMonitor");
        final CounterMonitor mon1 = new CounterMonitor();
        final ObjectName mon1n = new ObjectName("mon2:type=CounterMonitor");

        server.registerMBean(my, mbean);
        server.registerMBean(mon1, mon1n);
        server.registerMBean(mon2, mon2n);

        mon1.addObservedObject(mbean);
        mon1.setGranularityPeriod(60000); // 60 sec...
        mon1.setObservedAttribute(attr);
        mon1.setDifferenceMode(true);
        check(attr,server,mon1n,mbean);

        mon2.addObservedObject(mbean);
        mon2.setGranularityPeriod(60000); // 60 sec...
        mon2.setObservedAttribute(attr);
        mon2.setDifferenceMode(true);
        check(attr,server,mon2n,mbean);

        final long approxStart = System.currentTimeMillis();
        mon1.start();
        mon2.start();

        try {
            check(attr,server,mon1n,mbean,approxStart);
            check(attr,server,mon2n,mbean,approxStart);
            check(attr,server,mon1n,mbean,approxStart);
            check(attr,server,mon2n,mbean,approxStart);


            mon1.setGranularityPeriod(5);
            mon2.setGranularityPeriod(5);

            my.cdl.await(1000, TimeUnit.MILLISECONDS);
            if (my.cdl.getCount() > 0)
                throw new Exception(attr+": Count down not reached!");

            // just check that we don't get an exception now...
            System.err.println(attr+": [" + mon1n+
                    "] DerivedGauge is now "+
                    server.getAttribute(mon1n, "DerivedGauge"));
            System.err.println(attr+": [" + mon2n+
                    "] DerivedGauge is now "+
                    server.getAttribute(mon2n, "DerivedGauge"));
        } finally {
           try {mon1.stop();} catch (Exception x) {}
           try {mon2.stop();} catch (Exception x) {}
        }
    }




    public static void main(String[] args) throws Exception {
        for (String attr:attributes) {
            test(attr);
        }
        for (String attr:things) {
            test(attr);
        }
    }

}