Quelle  Basic.java   Sprache: JAVA

/*
 * Copyright (c) 2005, 2015, 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.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import javax.management.Descriptor;
import javax.management.ImmutableDescriptor;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.Notification;
import javax.management.NotificationBroadcasterSupport;
import javax.management.NotificationEmitter;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;

/**
 * Class Basic
 * Basic Description
 */
public class Basic implements BasicMXBean, NotificationEmitter,
                              MBeanRegistration {

    public static final String EXCEPTION_MESSAGE = "from Basic";
    public static final String NOTIFICATION_MESSAGE = "from Basic";
    /** Attribute : IntAtt */
    private int intAtt = 0;
    /** Attribute : IntegerAtt */
    private Integer integerAtt = 0;
    /** Attribute : BoolAtt */
    private boolean boolAtt = false;
    /** Attribute : BooleanAtt */
    private Boolean booleanAtt = false;
    /** Attribute : StringAtt */
    private String stringAtt = null;
    /** Attribute : DateAtt */
    private Date dateAtt = null;
    /** Attribute : ObjectNameAtt */
    private ObjectName objectNameAtt = null;
    /** Attribute : NotifDescriptorAsMapAtt */
    private Map<String, String> notifDescriptorAsMapAtt = null;
    /** Attribute : NotifDescriptorAtt */
    private Descriptor notifDescriptorAtt = null;
    /** Attribute : SqeParameter */
    private SqeParameter sqeParameterAtt = null;

    /* Creates a new instance of Basic */
    @SqeDescriptorKey("CONSTRUCTOR Basic")
    public Basic() {
    }

    /* Creates a new instance of Basic */
    @SqeDescriptorKey("CONSTRUCTOR Basic")
    public Basic(
            @SqeDescriptorKey("CONSTRUCTOR PARAMETER SqeParameter") SqeParameter param) {
    }

    /**
     * Get int attribute
     */
    public int getIntAtt() {
        return intAtt;
    }

    /**
     * Set int attribute
     */
    public void setIntAtt(int value) {
        intAtt = value;
    }

    /**
     * Get Integer attribute
     */
    public Integer getIntegerAtt() {
        return integerAtt;
    }

    /**
     * Set Integer attribute
     */
    public void setIntegerAtt(Integer value) {
        integerAtt = value;
    }

    /**
     * Get boolean attribute
     */
    public boolean getBoolAtt() {
        return boolAtt;
    }

    /**
     * Set boolean attribute
     */
    public void setBoolAtt(boolean value) {
        boolAtt = value;
    }

    /**
     * Get Boolean attribute
     */
    public Boolean getBooleanAtt() {
        return booleanAtt;
    }

    /**
     * Set Boolean attribute
     */
    public void setBooleanAtt(Boolean value) {
        booleanAtt = value;
    }

    /**
     * Get String attribute
     */
    public String getStringAtt() {
        return stringAtt;
    }

    /**
     * Set String attribute
     */
    public void setStringAtt(String value) {
        stringAtt = value;
    }

    /**
     * Get Date attribute
     */
    public Date getDateAtt() {
        return dateAtt;
    }

    /**
     * Set Date attribute
     */
    public void setDateAtt(Date value) {
        dateAtt = value;
    }

    /**
     * Get ObjectName attribute
     */
    public ObjectName getObjectNameAtt() {
        return objectNameAtt;
    }

    /**
     * Set ObjectName attribute
     */
    public void setObjectNameAtt(ObjectName value) {
        objectNameAtt = value;
    }

    /**
     * Get SqeParameter attribute
     */
    public SqeParameter getSqeParameterAtt() throws Exception {
        if (sqeParameterAtt == null) {
            sqeParameterAtt = new SqeParameter();
            sqeParameterAtt.setGlop("INITIALIZED");
        }

        return sqeParameterAtt;
    }

    /**
     * Set SqeParameter attribute
     */
    public void setSqeParameterAtt(SqeParameter value) {
        sqeParameterAtt = value;
    }

    /**
     * Get the Descriptor used to build the NotificationInfo
     * of emitted notifications.
     */
    public Map<String, String> getNotifDescriptorAsMapAtt() {
        if (notifDescriptorAsMapAtt == null) {
            initNotifDescriptorAtt();
        }

        return notifDescriptorAsMapAtt;
    }

    /**
     * Set the Descriptor used to build the NotificationInfo
     * of emitted notifications.
     * <br>A Map<String, Object> would better fit Descriptor needs but then
     * it is not convertible according the MXBean specification so the MBean
     * registration fails.
     * As we plan to test our custom Descriptor finds its way into
     * the metadata of emitted notifications, String is good enough.
     */
    public void setNotifDescriptorAsMapAtt(Map<String, String> value) {
        notifDescriptorAsMapAtt = new HashMap<String, String>(value);
        notifDescriptorAtt = new ImmutableDescriptor(value);
    }

    /**
     * Do nothing
     */
    public void doNothing() {
        // I said NOTHING !
    }

    /**
     * Do take SqeParameter as a parameter
     */
    public void doWeird(SqeParameter param) {
    }

    /**
     * Throw an Exception
     */
    public void throwException() throws Exception {
        throw new Exception(EXCEPTION_MESSAGE);
    }

    /**
     * Throw an Error
     */
    public void throwError() {
        throw new InternalError(EXCEPTION_MESSAGE);
    }

    /**
     * Reset all attributes
     */
    public void reset() {
        intAtt = 0;
        integerAtt = 0;
        boolAtt = false;
        booleanAtt = Boolean.FALSE;
        stringAtt = null;
        dateAtt = null;
        objectNameAtt = null;
    }

    /**
     * Returns the weather for the coming days
     * @param verbose <code>boolean</code> verbosity
     * @throws java.lang.Exception <code>storm</code>
     * @return <code>ObjectName</code>
     */
    public Weather getWeather(boolean verbose)
            throws java.lang.Exception {
        return Weather.SUNNY;
    }

    // Starting here are the 4 methods of MBeanRegistration interface.
    // We use that to grab the ObjectName the MBean is registered with.
    //
    public ObjectName preRegister(MBeanServer server, ObjectName name)
            throws Exception {
        // Grab a reference on the MBeanServer we're registered in.
        mbs = server;
        // Compute the name we're registered with.
        if (name != null) {
            mbeanName = name;
            return name;
        } else {
            mbeanName =
                new ObjectName("sqe:type=" + Basic.class.getName());
            return mbeanName;
        }
    }

    public void postRegister(Boolean registrationDone) {
        // Do nothing
    }

    public void preDeregister() throws Exception {
        // Do nothing
    }

    public void postDeregister() {
        // Do nothing
    }

    /**
     * Send one Notification of the provided notifType type.
     */
    public void sendNotification(String notifType) {
        Notification notification = null;

        if (notifType.equals(NOTIF_TYPE_0)) {
            notification = new Notification(NOTIF_TYPE_0,
                    mbeanName,
                    seqNumber,
                    NOTIFICATION_MESSAGE);
        } else if (notifType.equals(NOTIF_TYPE_1)) {
            notification = new SqeNotification(NOTIF_TYPE_1,
                    mbeanName,
                    seqNumber,
                    NOTIFICATION_MESSAGE);
        }

        seqNumber++;
        broadcaster.sendNotification(notification);
    }

    /**
     * That method starts a set of threads, each thread sends a given number of
     * notifications.
     * The number of threads can be set via the attribute numOfNotificationSenders.
     * The number of notification sent by each thread can be set via
     * the attribute numOfNotificationSenderLoops.
     * Depending on the parameter customNotification we send either custom
     * notification(s) or MBeanServer registration and unregistration notification(s).
     * When customNotification=true the total number of notification(s) sent is
     * (numOfNotificationSenders * numOfNotificationSenderLoops). They are
     * sequentially of type NOTIF_TYPE_0 then NOTIF_TYPE_1 and so on.
     *
     * When customNotification=false the total number of notification(s) sent is
     * (numOfNotificationSenders * numOfNotificationSenderLoops) registration
     * notification(s)
     * +
     * (numOfNotificationSenders * numOfNotificationSenderLoops) unregistration
     * notification(s)
     *
     * @throws java.lang.Exception
     */
    public void sendNotificationWave(boolean customNotification) throws
            Exception {
        // Build the set of notification sender.
        Collection<Callable<Integer>> tasks =
                new HashSet<Callable<Integer>>(numOfNotificationSenders);

        for (int i = 1; i <= numOfNotificationSenders; i++) {
            tasks.add(new NotifSender(numOfNotificationSenderLoops,
                    customNotification, i));
        }

        // Start all notification sender in parallel.
        ExecutorService execServ = null;
        try {
            execServ = Executors.newFixedThreadPool(numOfNotificationSenders);
            List<Future<Integer>> taskHandlers = execServ.invokeAll(tasks);
            checkNotifSenderThreadStatus(taskHandlers);
        } finally {
            if (!execServ.isShutdown()) {
                execServ.shutdown();
            }
        }
    }

    public void setNumOfNotificationSenders(int value) {
        numOfNotificationSenders = value;
    }

    public void setNumOfNotificationSenderLoops(int value) {
        numOfNotificationSenderLoops = value;
    }

    /**
     * MBean Notification support
     * You shouldn't update these methods
     */
    // <editor-fold defaultstate="collapsed" desc=" Generated Code ">
    public void addNotificationListener(NotificationListener listener,
                                        NotificationFilter filter,
                                        Object handback)
            throws IllegalArgumentException {
        broadcaster.addNotificationListener(listener, filter, handback);
    }

    public MBeanNotificationInfo[] getNotificationInfo() {
        if (notifDescriptorAtt == null) {
            initNotifDescriptorAtt();
        }

        return new MBeanNotificationInfo[]{
                    new MBeanNotificationInfo(new String[]{
                        NOTIF_TYPE_0
                    },
                    javax.management.Notification.class.getName(),
                    "Standard JMX Notification",
                    notifDescriptorAtt),
                    new MBeanNotificationInfo(new String[]{
                        NOTIF_TYPE_1
                    },
                    SqeNotification.class.getName(),
                    "SQE Notification",
                    notifDescriptorAtt)
                };
    }

    public void removeNotificationListener(NotificationListener listener)
            throws ListenerNotFoundException {
        broadcaster.removeNotificationListener(listener);
    }

    public void removeNotificationListener(NotificationListener listener,
                                           NotificationFilter filter,
                                           Object handback)
            throws ListenerNotFoundException {
        broadcaster.removeNotificationListener(listener, filter, handback);
    }
    // </editor-fold>
    private synchronized long getNextSeqNumber() {
        return seqNumber++;
    }

    private void initNotifDescriptorAtt() {
        String key = "CRABE";
        String value = "TAMBOUR";
        notifDescriptorAtt =
                new ImmutableDescriptor(new String[]{key + "=" + value});
        notifDescriptorAsMapAtt =
                new HashMap<String, String>();
        notifDescriptorAsMapAtt.put(key, value);
    }

    private void checkNotifSenderThreadStatus(
            List<Future<Integer>> taskHandlers)
            throws Exception {
        String msgTag = "Basic::checkNotifSenderThreadStatus: ";
        // Grab back status of each notification sender.
        for (Future<Integer> f : taskHandlers) {
            if (f.isCancelled()) {
                String message = msgTag +
                        "---- ERROR : One thread has been cancelled";
                System.out.println(message);
                throw new RuntimeException(message);
            } else {
                Integer effectiveNumOfLoops = f.get();

                if (effectiveNumOfLoops != numOfNotificationSenderLoops) {
                    String message = msgTag + "---- ERROR : One thread did " +
                            effectiveNumOfLoops + " loops in place of " +
                            numOfNotificationSenderLoops;
                    System.out.println(message);
                    throw new RuntimeException(message);
                }
            }
        }
    }
    //
    private int numOfNotificationSenderLoops = 2;
    private int numOfNotificationSenders = 13;

    private class NotifSender implements Callable<Integer> {

        private int cycles;
        private boolean customNotification;
        private int senderID;

        public NotifSender(int cycles, boolean customNotification, int id) {
            this.cycles = cycles;
            this.customNotification = customNotification;
            this.senderID = id;
        }

        public Integer call() throws Exception {
            int callsDone = 0;

            try {
                for (int i = 1; i <= cycles; i++) {
                    if (customNotification) {
                        if (i % 2 == 0) {
                            sendNotification(NOTIF_TYPE_0);
                        } else {
                            sendNotification(NOTIF_TYPE_1);
                        }
                    } else {
                        ObjectName mbeanName = new ObjectName("SQE:type=" +
                                mbeanClassName + ",senderID=" + senderID);
                        mbs.createMBean(mbeanClassName, mbeanName);
                        mbs.unregisterMBean(mbeanName);
                    }
                    callsDone++;
                }
            } catch (Exception e) {
                System.out.println("NotifSender::call: (ERROR) Thread [" + senderID +
                        "] failed after " + callsDone + " cycles");
                throw e;
            }

            return Integer.valueOf(callsDone);
        }
    }

    //
    private long seqNumber;
    private final NotificationBroadcasterSupport broadcaster =
            new NotificationBroadcasterSupport();
    private ObjectName mbeanName;
    private MBeanServer mbs;
    private String mbeanClassName = "Simple";

    /**
     * Notification types definitions. To use when creating JMX Notifications.
     */
    public static final String NOTIF_TYPE_0 =
            "sqe.notification.a.type";
    public static final String NOTIF_TYPE_1 =
            "sqe.notification.b.type";
}