Examples with NotificationFilter javax.management.NotificationFilter used on opensource projects

Example 1 with NotificationFilter

use of javax.management.NotificationFilter in project jdk8u_jdk by JetBrains.

the class ConnectionListenerNullTest method test.

public static int test(String... urls) {
    int errCount = 0;
    for (int i = 0; i < urls.length; i++) {
        try {
            final JMXServiceURL url = new JMXServiceURL(urls[i]);
            final JMXConnector c = JMXConnectorFactory.newJMXConnector(url, (Map<String, String>) null);
            final NotificationListener nl = null;
            final NotificationFilter nf = null;
            final Object h = null;
            System.out.println("Testing " + c.getClass().getName());
            try {
                System.out.println("addConnectionNotificationListener(null,null,null)");
                c.addConnectionNotificationListener(nl, nf, h);
                throw new AssertionError("No exception raised");
            } catch (NullPointerException npe) {
            // OK.
            }
            final NotificationListener listener = new NotificationListener() {

                public void handleNotification(Notification notification, Object handback) {
                }
            };
            c.addConnectionNotificationListener(listener, nf, h);
            try {
                System.out.println("removeConnectionNotificationListener(null)");
                c.removeConnectionNotificationListener(nl);
                throw new AssertionError("No exception raised");
            } catch (NullPointerException npe) {
            // OK.
            }
            try {
                System.out.println("removeConnectionNotificationListener(null,null,null)");
                c.removeConnectionNotificationListener(nl, nf, h);
                throw new AssertionError("No exception raised");
            } catch (NullPointerException npe) {
            // OK.
            }
            c.removeConnectionNotificationListener(listener);
            System.out.println(c.getClass().getName() + " successfully tested.");
        } catch (Exception x) {
            System.err.println("Unexpected exception for " + urls[i] + ": " + x);
            x.printStackTrace();
            errCount++;
        } catch (AssertionError e) {
            System.err.println("Unexpected assertion error for " + urls[i] + ": " + e);
            e.printStackTrace();
            errCount++;
        }
    }
    return errCount;
}

Example 2 with NotificationFilter

use of javax.management.NotificationFilter in project jdk8u_jdk by JetBrains.

the class NotificationBufferTest method test.

private static boolean test() throws Exception {
    MBeanServer mbs = MBeanServerFactory.createMBeanServer();
    Integer queuesize = new Integer(10);
    HashMap env = new HashMap();
    env.put(com.sun.jmx.remote.util.EnvHelp.BUFFER_SIZE_PROPERTY, queuesize);
    final NotificationBuffer nb = ArrayNotificationBuffer.getNotificationBuffer(mbs, env);
    final ObjectName senderName = new ObjectName("dom:type=sender");
    final ObjectName wildcardName = new ObjectName("*:*");
    final String notifType = MBeanServerNotification.REGISTRATION_NOTIFICATION;
    Integer allListenerId = new Integer(99);
    NotificationBufferFilter allListenerFilter = makeFilter(allListenerId, wildcardName, null);
    NotificationFilterSupport regFilter = new NotificationFilterSupport();
    regFilter.enableType(notifType);
    // Get initial sequence number
    NotificationResult nr = nb.fetchNotifications(allListenerFilter, 0, 0L, 0);
    int nnotifs = nr.getTargetedNotifications().length;
    if (nnotifs > 0) {
        System.out.println("Expected 0 notifs for initial fetch, " + "got " + nnotifs);
        return false;
    }
    System.out.println("Got 0 notifs for initial fetch, OK");
    long earliest = nr.getEarliestSequenceNumber();
    long next = nr.getNextSequenceNumber();
    if (earliest != next) {
        System.out.println("Expected earliest==next in initial fetch, " + "earliest=" + earliest + "; next=" + next);
        return false;
    }
    System.out.println("Got earliest==next in initial fetch, OK");
    mbs.createMBean(MLet.class.getName(), null);
    mbs.createMBean(NotificationSender.class.getName(), senderName);
    NotificationSenderMBean sender = (NotificationSenderMBean) MBeanServerInvocationHandler.newProxyInstance(mbs, senderName, NotificationSenderMBean.class, false);
    /* We test here that MBeans already present when the
           NotificationBuffer was created get a listener for the
           buffer, as do MBeans created later.  The
           MBeanServerDelegate was already present, while the
           NotificationSender was created later.  */
    // Check that the NotificationSender does indeed have a listener
    /* Note we are dependent on the specifics of our JMX
           implementation here.  There is no guarantee that the MBean
           creation listeners will have run to completion when
           creation of the MBean returns.  */
    int nlisteners = sender.getListenerCount();
    if (nlisteners != 1) {
        System.out.println("Notification sender should have 1 listener, " + "has " + nlisteners);
        return false;
    }
    System.out.println("Notification sender has 1 listener, OK");
    // Now we should see two creation notifications
    nr = nb.fetchNotifications(allListenerFilter, next, 0L, Integer.MAX_VALUE);
    TargetedNotification[] tns = nr.getTargetedNotifications();
    if (tns.length != 2) {
        System.out.println("Expected 2 notifs, got: " + Arrays.asList(tns));
        return false;
    }
    if (!(tns[0].getNotification() instanceof MBeanServerNotification) || !(tns[1].getNotification() instanceof MBeanServerNotification)) {
        System.out.println("Expected 2 MBeanServerNotifications, got: " + Arrays.asList(tns));
        return false;
    }
    if (!tns[0].getListenerID().equals(tns[1].getListenerID()) || !tns[0].getListenerID().equals(allListenerId)) {
        System.out.println("Bad listener IDs: " + Arrays.asList(tns));
        return false;
    }
    System.out.println("Got 2 different MBeanServerNotifications, OK");
    // If we ask for max 1 notifs, we should only get one
    nr = nb.fetchNotifications(allListenerFilter, next, 0L, 1);
    tns = nr.getTargetedNotifications();
    if (tns.length != 1) {
        System.out.println("Expected 1 notif, got: " + Arrays.asList(tns));
        return false;
    }
    TargetedNotification tn1 = tns[0];
    System.out.println("Got 1 notif when asked for 1, OK");
    // Now we should get the other one
    nr = nb.fetchNotifications(allListenerFilter, nr.getNextSequenceNumber(), 0L, 1);
    tns = nr.getTargetedNotifications();
    if (tns.length != 1) {
        System.out.println("Expected 1 notif, got: " + Arrays.asList(tns));
        return false;
    }
    TargetedNotification tn2 = tns[0];
    System.out.println("Got 1 notif when asked for 1 again, OK");
    if (tn1.getNotification() == tn2.getNotification()) {
        System.out.println("Returned same notif twice: " + tn1);
        return false;
    }
    System.out.println("2 creation notifs are different, OK");
    // Now we should get none (timeout is 0)
    long oldNext = nr.getNextSequenceNumber();
    nr = nb.fetchNotifications(allListenerFilter, oldNext, 0L, Integer.MAX_VALUE);
    tns = nr.getTargetedNotifications();
    if (tns.length != 0) {
        System.out.println("Expected 0 notifs, got: " + Arrays.asList(tns));
        return false;
    }
    System.out.println("Got 0 notifs with 0 timeout, OK");
    if (nr.getNextSequenceNumber() != oldNext) {
        System.out.println("Sequence number changed: " + oldNext + " -> " + nr.getNextSequenceNumber());
        return false;
    }
    System.out.println("Next seqno unchanged with 0 timeout, OK");
    // Check that timeouts work
    long startTime = System.currentTimeMillis();
    nr = nb.fetchNotifications(allListenerFilter, oldNext, 250L, Integer.MAX_VALUE);
    tns = nr.getTargetedNotifications();
    if (tns.length != 0) {
        System.out.println("Expected 0 notifs, got: " + Arrays.asList(tns));
        return false;
    }
    long endTime = System.currentTimeMillis();
    long elapsed = endTime - startTime;
    if (elapsed < 250L) {
        System.out.println("Elapsed time shorter than timeout: " + elapsed);
        return false;
    }
    System.out.println("Timeout worked, OK");
    // Check that notification filtering works
    NotificationFilter senderFilter = new NotificationFilter() {

        public boolean isNotificationEnabled(Notification n) {
            if (!(n instanceof MBeanServerNotification))
                return false;
            MBeanServerNotification mbsn = (MBeanServerNotification) n;
            return (mbsn.getMBeanName().equals(senderName));
        }
    };
    Integer senderListenerId = new Integer(88);
    NotificationBufferFilter senderListenerFilter = makeFilter(senderListenerId, wildcardName, senderFilter);
    nr = nb.fetchNotifications(senderListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    tns = nr.getTargetedNotifications();
    if (tns.length != 1) {
        System.out.println("Expected 1 notif, got: " + Arrays.asList(tns));
        return false;
    }
    MBeanServerNotification mbsn = (MBeanServerNotification) tns[0].getNotification();
    if (!mbsn.getMBeanName().equals(senderName)) {
        System.out.println("Expected notif with senderName, got: " + mbsn + " (" + mbsn.getMBeanName() + ")");
        return false;
    }
    System.out.println("Successfully applied NotificationFilter, OK");
    // Now send 8 notifs to fill up our 10-element buffer
    sender.sendNotifs("tiddly.pom", 8);
    nr = nb.fetchNotifications(allListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    tns = nr.getTargetedNotifications();
    if (tns.length != 10) {
        System.out.println("Expected 10 notifs, got: " + Arrays.asList(tns));
        return false;
    }
    System.out.println("Got full buffer of 10 notifications, OK");
    // Check that the 10 notifs are the ones we expected
    for (int i = 0; i < 10; i++) {
        String expected = (i < 2) ? notifType : "tiddly.pom";
        String found = tns[i].getNotification().getType();
        if (!found.equals(expected)) {
            System.out.println("Notif " + i + " bad type: expected <" + expected + ">, found <" + found + ">");
            return false;
        }
    }
    System.out.println("Notifs have right types, OK");
    // Check that ObjectName filtering works
    NotificationBufferFilter senderNameFilter = makeFilter(new Integer(66), senderName, null);
    nr = nb.fetchNotifications(senderNameFilter, 0, 0L, Integer.MAX_VALUE);
    tns = nr.getTargetedNotifications();
    if (tns.length != 8) {
        System.out.println("Bad result from ObjectName filtering: " + Arrays.asList(tns));
        return false;
    }
    System.out.println("ObjectName filtering works, OK");
    // Send one more notif, which should cause the oldest one to drop
    sender.sendNotifs("foo.bar", 1);
    nr = nb.fetchNotifications(allListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    if (nr.getEarliestSequenceNumber() <= earliest) {
        System.out.println("Expected earliest to increase: " + nr.getEarliestSequenceNumber() + " should be > " + earliest);
        return false;
    }
    System.out.println("Earliest notif dropped, OK");
    // Check that the 10 notifs are the ones we expected
    tns = nr.getTargetedNotifications();
    for (int i = 0; i < 10; i++) {
        String expected = (i < 1) ? notifType : (i < 9) ? "tiddly.pom" : "foo.bar";
        String found = tns[i].getNotification().getType();
        if (!found.equals(expected)) {
            System.out.println("Notif " + i + " bad type: expected <" + expected + ">, found <" + found + ">");
            return false;
        }
    }
    System.out.println("Notifs have right types, OK");
    // Apply a filter that only selects the first notif, with max notifs 1,
    // then check that it skipped past the others even though it already
    // had its 1 notif
    NotificationBufferFilter firstFilter = makeFilter(new Integer(55), wildcardName, regFilter);
    nr = nb.fetchNotifications(firstFilter, 0, 1000L, 1);
    tns = nr.getTargetedNotifications();
    if (tns.length != 1 || !tns[0].getNotification().getType().equals(notifType)) {
        System.out.println("Unexpected return from filtered call: " + Arrays.asList(tns));
        return false;
    }
    nr = nb.fetchNotifications(allListenerFilter, nr.getNextSequenceNumber(), 0L, 1000);
    tns = nr.getTargetedNotifications();
    if (tns.length != 0) {
        System.out.println("Expected 0 notifs, got: " + Arrays.asList(tns));
        return false;
    }
    // Create a second, larger buffer, which should share the same notifs
    nr = nb.fetchNotifications(allListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    queuesize = new Integer(20);
    env.put(com.sun.jmx.remote.util.EnvHelp.BUFFER_SIZE_PROPERTY, queuesize);
    NotificationBuffer nb2 = ArrayNotificationBuffer.getNotificationBuffer(mbs, env);
    NotificationResult nr2 = nb2.fetchNotifications(allListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    if (nr.getEarliestSequenceNumber() != nr2.getEarliestSequenceNumber() || nr.getNextSequenceNumber() != nr2.getNextSequenceNumber() || !sameTargetedNotifs(nr.getTargetedNotifications(), nr2.getTargetedNotifications()))
        return false;
    System.out.println("Adding second buffer preserved notif list, OK");
    // Check that the capacity is now 20
    sender.sendNotifs("propter.hoc", 10);
    nr2 = nb2.fetchNotifications(allListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    if (nr.getEarliestSequenceNumber() != nr2.getEarliestSequenceNumber()) {
        System.out.println("Earliest seq number changed after notifs " + "that should have fit");
        return false;
    }
    TargetedNotification[] tns2 = new TargetedNotification[10];
    Arrays.asList(nr2.getTargetedNotifications()).subList(0, 10).toArray(tns2);
    if (!sameTargetedNotifs(nr.getTargetedNotifications(), tns2)) {
        System.out.println("Early notifs changed after notifs " + "that should have fit");
        return false;
    }
    System.out.println("New notifications fit in now-larger buffer, OK");
    // Drop the second buffer and check that the capacity shrinks
    nb2.dispose();
    NotificationResult nr3 = nb.fetchNotifications(allListenerFilter, 0, 1000L, Integer.MAX_VALUE);
    if (nr3.getEarliestSequenceNumber() != nr.getNextSequenceNumber()) {
        System.out.println("After shrink, notifs not dropped as expected");
        return false;
    }
    if (nr3.getNextSequenceNumber() != nr2.getNextSequenceNumber()) {
        System.out.println("After shrink, next seq no does not match");
        return false;
    }
    tns2 = new TargetedNotification[10];
    Arrays.asList(nr2.getTargetedNotifications()).subList(10, 20).toArray(tns2);
    if (!sameTargetedNotifs(nr3.getTargetedNotifications(), tns2)) {
        System.out.println("Later notifs not preserved after shrink");
        return false;
    }
    System.out.println("Dropping second buffer shrank capacity, OK");
    // Final test: check that destroying the final shared buffer
    // removes its listeners
    nb.dispose();
    nlisteners = sender.getListenerCount();
    if (nlisteners != 0) {
        System.out.println("Disposing buffer should leave 0 listeners, " + "but notification sender has " + nlisteners);
        return false;
    }
    System.out.println("Dropping first buffer drops listeners, OK");
    return true;
}

Example 3 with NotificationFilter

use of javax.management.NotificationFilter in project geode by apache.

the class DistributedSystemDUnitTest method addAlertListener.

private void addAlertListener(final VM managerVM) {
    managerVM.invoke("addAlertListener", () -> {
        AlertNotificationListener listener = AlertNotificationListener.getInstance();
        listener.resetCount();
        NotificationFilter notificationFilter = (Notification notification) -> notification.getType().equals(JMXNotificationType.SYSTEM_ALERT);
        getPlatformMBeanServer().addNotificationListener(getDistributedSystemName(), listener, notificationFilter, null);
    });
}

Example 4 with NotificationFilter

use of javax.management.NotificationFilter in project geode by apache.

the class MBeanProxyInvocationHandler method invokeBroadcasterMethod.

/**
   * The call will delegate to Managed Node for NotificationHub to register a local listener to
   * listen for notification from the MBean
   * 
   * Moreover it will also add the client to local listener list by adding to the contained emitter.
   * 
   * @param proxy the proxy object
   * @param method method to be invoked
   * @param args method arguments
   * @return result value if any
   * @throws Exception
   */
private Object invokeBroadcasterMethod(Object proxy, Method method, Object[] args) throws Throwable {
    final String methodName = method.getName();
    final int nargs = (args == null) ? 0 : args.length;
    final Class[] paramTypes = method.getParameterTypes();
    final String[] signature = new String[paramTypes.length];
    if (methodName.equals("addNotificationListener")) {
        if (nargs != 3) {
            final String msg = "Bad arg count to addNotificationListener: " + nargs;
            throw new IllegalArgumentException(msg);
        }
        /*
       * Other inconsistencies will produce ClassCastException below.
       */
        NotificationListener listener = (NotificationListener) args[0];
        NotificationFilter filter = (NotificationFilter) args[1];
        Object handback = args[2];
        emitter.addNotificationListener(listener, filter, handback);
        delegateToFucntionService(objectName, methodName, null, signature);
        return null;
    } else if (methodName.equals("removeNotificationListener")) {
        /*
       * NullPointerException if method with no args, but that shouldn't happen because removeNL
       * does have args.
       */
        NotificationListener listener = (NotificationListener) args[0];
        switch(nargs) {
            case 1:
                emitter.removeNotificationListener(listener);
                /**
           * No need to send listener and filter details to other members. We only need to send a
           * message saying remove the listner registered for this object on your side. Fixes Bug[
           * #47075 ]
           */
                delegateToFucntionService(objectName, methodName, null, signature);
                return null;
            case 3:
                NotificationFilter filter = (NotificationFilter) args[1];
                Object handback = args[2];
                emitter.removeNotificationListener(listener, filter, handback);
                delegateToFucntionService(objectName, methodName, null, signature);
                return null;
            default:
                final String msg = "Bad arg count to removeNotificationListener: " + nargs;
                throw new IllegalArgumentException(msg);
        }
    } else if (methodName.equals("getNotificationInfo")) {
        if (args != null) {
            throw new IllegalArgumentException("getNotificationInfo has " + "args");
        }
        if (!MBeanJMXAdapter.mbeanServer.isRegistered(objectName)) {
            return new MBeanNotificationInfo[0];
        }
        /**
       * MBean info is delegated to function service as intention is to get the info of the actual
       * mbean rather than the proxy
       */
        Object obj = delegateToFucntionService(objectName, methodName, args, signature);
        if (obj instanceof String) {
            return new MBeanNotificationInfo[0];
        }
        MBeanInfo info = (MBeanInfo) obj;
        return info.getNotifications();
    } else {
        throw new IllegalArgumentException("Bad method name: " + methodName);
    }
}

Example 5 with NotificationFilter

use of javax.management.NotificationFilter in project spring-framework by spring-projects.

the class NotificationListenerTests method testRegisterNotificationListenerWithFilter.

@SuppressWarnings("serial")
@Test
public void testRegisterNotificationListenerWithFilter() throws Exception {
    ObjectName objectName = ObjectName.getInstance("spring:name=Test");
    JmxTestBean bean = new JmxTestBean();
    Map<String, Object> beans = new HashMap<>();
    beans.put(objectName.getCanonicalName(), bean);
    CountingAttributeChangeNotificationListener listener = new CountingAttributeChangeNotificationListener();
    NotificationListenerBean listenerBean = new NotificationListenerBean();
    listenerBean.setNotificationListener(listener);
    listenerBean.setNotificationFilter(new NotificationFilter() {

        @Override
        public boolean isNotificationEnabled(Notification notification) {
            if (notification instanceof AttributeChangeNotification) {
                AttributeChangeNotification changeNotification = (AttributeChangeNotification) notification;
                return "Name".equals(changeNotification.getAttributeName());
            } else {
                return false;
            }
        }
    });
    MBeanExporter exporter = new MBeanExporter();
    exporter.setServer(server);
    exporter.setBeans(beans);
    exporter.setNotificationListeners(new NotificationListenerBean[] { listenerBean });
    start(exporter);
    // update the attributes
    String nameAttribute = "Name";
    String ageAttribute = "Age";
    server.setAttribute(objectName, new Attribute(nameAttribute, "Rob Harrop"));
    server.setAttribute(objectName, new Attribute(ageAttribute, new Integer(90)));
    assertEquals("Listener not notified for Name", 1, listener.getCount(nameAttribute));
    assertEquals("Listener incorrectly notified for Age", 0, listener.getCount(ageAttribute));
}