531 lines
16 KiB
Java
531 lines
16 KiB
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";
|
|
}
|