Examples with TargetedNotification javax.management.remote.TargetedNotification used on opensource projects

Example 1 with TargetedNotification

use of javax.management.remote.TargetedNotification in project jdk8u_jdk by JetBrains.

the class NotificationBufferTest method sameTargetedNotifs.

private static boolean sameTargetedNotifs(TargetedNotification[] tn1, TargetedNotification[] tn2) {
    if (tn1.length != tn2.length) {
        System.out.println("Not same length");
        return false;
    }
    for (int i = 0; i < tn1.length; i++) {
        TargetedNotification n1 = tn1[i];
        TargetedNotification n2 = tn2[i];
        if (n1.getNotification() != n2.getNotification() || !n1.getListenerID().equals(n2.getListenerID()))
            return false;
    }
    return true;
}

Example 2 with TargetedNotification

use of javax.management.remote.TargetedNotification 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 TargetedNotification

use of javax.management.remote.TargetedNotification in project felix by apache.

the class RemoteNotificationClientHandler method sendNotification.

private void sendNotification(TargetedNotification notification) {
    NotificationTuple tuple = null;
    synchronized (tuples) {
        tuple = (NotificationTuple) tuples.get(notification.getListenerID());
    }
    // It may be possible that a notification arrived after the client already removed the listener
    if (tuple == null)
        return;
    Notification notif = notification.getNotification();
    if (tuple.getInvokeFilter()) {
        // Invoke the filter on client side
        NotificationFilter filter = tuple.getNotificationFilter();
        RmiConnectorActivator.log(LogService.LOG_DEBUG, "Filtering notification " + notif + ", filter = " + filter, null);
        if (filter != null) {
            try {
                boolean deliver = filter.isNotificationEnabled(notif);
                if (!deliver)
                    return;
            } catch (RuntimeException x) {
                RmiConnectorActivator.log(LogService.LOG_WARNING, "RuntimeException caught from isNotificationEnabled, filter = " + filter, x);
            // And go on quietly
            }
        }
    }
    RmiConnectorActivator.log(LogService.LOG_DEBUG, "Sending Notification " + notif + ", listener info is " + tuple, null);
    NotificationListener listener = tuple.getNotificationListener();
    try {
        listener.handleNotification(notif, tuple.getHandback());
    } catch (RuntimeException x) {
        RmiConnectorActivator.log(LogService.LOG_WARNING, "RuntimeException caught from handleNotification, listener = " + listener, x);
    // And return quietly
    }
}

Example 4 with TargetedNotification

use of javax.management.remote.TargetedNotification in project jdk8u_jdk by JetBrains.

the class ServerNotifForwarder method snoopOnUnregister.

// The standard RMI connector client will register a listener on the MBeanServerDelegate
// in order to be told when MBeans are unregistered.  We snoop on fetched notifications
// so that we can know too, and remove the corresponding entry from the listenerMap.
// See 6957378.
private void snoopOnUnregister(NotificationResult nr) {
    List<IdAndFilter> copy = null;
    synchronized (listenerMap) {
        Set<IdAndFilter> delegateSet = listenerMap.get(MBeanServerDelegate.DELEGATE_NAME);
        if (delegateSet == null || delegateSet.isEmpty()) {
            return;
        }
        copy = new ArrayList<>(delegateSet);
    }
    for (TargetedNotification tn : nr.getTargetedNotifications()) {
        Integer id = tn.getListenerID();
        for (IdAndFilter idaf : copy) {
            if (idaf.id == id) {
                // This is a notification from the MBeanServerDelegate.
                Notification n = tn.getNotification();
                if (n instanceof MBeanServerNotification && n.getType().equals(MBeanServerNotification.UNREGISTRATION_NOTIFICATION)) {
                    MBeanServerNotification mbsn = (MBeanServerNotification) n;
                    ObjectName gone = mbsn.getMBeanName();
                    synchronized (listenerMap) {
                        listenerMap.remove(gone);
                    }
                }
            }
        }
    }
}

Example 5 with TargetedNotification

use of javax.management.remote.TargetedNotification in project jdk8u_jdk by JetBrains.

the class ArrayNotificationBuffer method fetchNotifications.

/**
     * <p>Fetch notifications that match the given listeners.</p>
     *
     * <p>The operation only considers notifications with a sequence
     * number at least <code>startSequenceNumber</code>.  It will take
     * no longer than <code>timeout</code>, and will return no more
     * than <code>maxNotifications</code> different notifications.</p>
     *
     * <p>If there are no notifications matching the criteria, the
     * operation will block until one arrives, subject to the
     * timeout.</p>
     *
     * @param filter an object that will add notifications to a
     * {@code List<TargetedNotification>} if they match the current
     * listeners with their filters.
     * @param startSequenceNumber the first sequence number to
     * consider.
     * @param timeout the maximum time to wait.  May be 0 to indicate
     * not to wait if there are no notifications.
     * @param maxNotifications the maximum number of notifications to
     * return.  May be 0 to indicate a wait for eligible notifications
     * that will return a usable <code>nextSequenceNumber</code>.  The
     * {@link TargetedNotification} array in the returned {@link
     * NotificationResult} may contain more than this number of
     * elements but will not contain more than this number of
     * different notifications.
     */
public NotificationResult fetchNotifications(NotificationBufferFilter filter, long startSequenceNumber, long timeout, int maxNotifications) throws InterruptedException {
    logger.trace("fetchNotifications", "starts");
    if (startSequenceNumber < 0 || isDisposed()) {
        synchronized (this) {
            return new NotificationResult(earliestSequenceNumber(), nextSequenceNumber(), new TargetedNotification[0]);
        }
    }
    // Check arg validity
    if (filter == null || startSequenceNumber < 0 || timeout < 0 || maxNotifications < 0) {
        logger.trace("fetchNotifications", "Bad args");
        throw new IllegalArgumentException("Bad args to fetch");
    }
    if (logger.debugOn()) {
        logger.trace("fetchNotifications", "filter=" + filter + "; startSeq=" + startSequenceNumber + "; timeout=" + timeout + "; max=" + maxNotifications);
    }
    if (startSequenceNumber > nextSequenceNumber()) {
        final String msg = "Start sequence number too big: " + startSequenceNumber + " > " + nextSequenceNumber();
        logger.trace("fetchNotifications", msg);
        throw new IllegalArgumentException(msg);
    }
    /* Determine the end time corresponding to the timeout value.
           Caller may legitimately supply Long.MAX_VALUE to indicate no
           timeout.  In that case the addition will overflow and produce
           a negative end time.  Set end time to Long.MAX_VALUE in that
           case.  We assume System.currentTimeMillis() is positive.  */
    long endTime = System.currentTimeMillis() + timeout;
    if (// overflow
    endTime < 0)
        endTime = Long.MAX_VALUE;
    if (logger.debugOn())
        logger.debug("fetchNotifications", "endTime=" + endTime);
    /* We set earliestSeq the first time through the loop.  If we
           set it here, notifications could be dropped before we
           started examining them, so earliestSeq might not correspond
           to the earliest notification we examined.  */
    long earliestSeq = -1;
    long nextSeq = startSequenceNumber;
    List<TargetedNotification> notifs = new ArrayList<TargetedNotification>();
    /* On exit from this loop, notifs, earliestSeq, and nextSeq must
           all be correct values for the returned NotificationResult.  */
    while (true) {
        logger.debug("fetchNotifications", "main loop starts");
        NamedNotification candidate;
        /* Get the next available notification regardless of filters,
               or wait for one to arrive if there is none.  */
        synchronized (this) {
            /* First time through.  The current earliestSequenceNumber
                   is the first one we could have examined.  */
            if (earliestSeq < 0) {
                earliestSeq = earliestSequenceNumber();
                if (logger.debugOn()) {
                    logger.debug("fetchNotifications", "earliestSeq=" + earliestSeq);
                }
                if (nextSeq < earliestSeq) {
                    nextSeq = earliestSeq;
                    logger.debug("fetchNotifications", "nextSeq=earliestSeq");
                }
            } else
                earliestSeq = earliestSequenceNumber();
            /* If many notifications have been dropped since the
                   last time through, nextSeq could now be earlier
                   than the current earliest.  If so, notifications
                   may have been lost and we return now so the caller
                   can see this next time it calls.  */
            if (nextSeq < earliestSeq) {
                logger.trace("fetchNotifications", "nextSeq=" + nextSeq + " < " + "earliestSeq=" + earliestSeq + " so may have lost notifs");
                break;
            }
            if (nextSeq < nextSequenceNumber()) {
                candidate = notificationAt(nextSeq);
                // Skip security check if NotificationBufferFilter is not overloaded
                if (!(filter instanceof ServerNotifForwarder.NotifForwarderBufferFilter)) {
                    try {
                        ServerNotifForwarder.checkMBeanPermission(this.mBeanServer, candidate.getObjectName(), "addNotificationListener");
                    } catch (InstanceNotFoundException | SecurityException e) {
                        if (logger.debugOn()) {
                            logger.debug("fetchNotifications", "candidate: " + candidate + " skipped. exception " + e);
                        }
                        ++nextSeq;
                        continue;
                    }
                }
                if (logger.debugOn()) {
                    logger.debug("fetchNotifications", "candidate: " + candidate);
                    logger.debug("fetchNotifications", "nextSeq now " + nextSeq);
                }
            } else {
                /* nextSeq is the largest sequence number.  If we
                       already got notifications, return them now.
                       Otherwise wait for some to arrive, with
                       timeout.  */
                if (notifs.size() > 0) {
                    logger.debug("fetchNotifications", "no more notifs but have some so don't wait");
                    break;
                }
                long toWait = endTime - System.currentTimeMillis();
                if (toWait <= 0) {
                    logger.debug("fetchNotifications", "timeout");
                    break;
                }
                /* dispose called */
                if (isDisposed()) {
                    if (logger.debugOn())
                        logger.debug("fetchNotifications", "dispose callled, no wait");
                    return new NotificationResult(earliestSequenceNumber(), nextSequenceNumber(), new TargetedNotification[0]);
                }
                if (logger.debugOn())
                    logger.debug("fetchNotifications", "wait(" + toWait + ")");
                wait(toWait);
                continue;
            }
        }
        /* We have a candidate notification.  See if it matches
               our filters.  We do this outside the synchronized block
               so we don't hold up everyone accessing the buffer
               (including notification senders) while we evaluate
               potentially slow filters.  */
        ObjectName name = candidate.getObjectName();
        Notification notif = candidate.getNotification();
        List<TargetedNotification> matchedNotifs = new ArrayList<TargetedNotification>();
        logger.debug("fetchNotifications", "applying filter to candidate");
        filter.apply(matchedNotifs, name, notif);
        if (matchedNotifs.size() > 0) {
            /* We only check the max size now, so that our
                   returned nextSeq is as large as possible.  This
                   prevents the caller from thinking it missed
                   interesting notifications when in fact we knew they
                   weren't.  */
            if (maxNotifications <= 0) {
                logger.debug("fetchNotifications", "reached maxNotifications");
                break;
            }
            --maxNotifications;
            if (logger.debugOn())
                logger.debug("fetchNotifications", "add: " + matchedNotifs);
            notifs.addAll(matchedNotifs);
        }
        ++nextSeq;
    }
    // end while
    /* Construct and return the result.  */
    int nnotifs = notifs.size();
    TargetedNotification[] resultNotifs = new TargetedNotification[nnotifs];
    notifs.toArray(resultNotifs);
    NotificationResult nr = new NotificationResult(earliestSeq, nextSeq, resultNotifs);
    if (logger.debugOn())
        logger.debug("fetchNotifications", nr.toString());
    logger.trace("fetchNotifications", "ends");
    return nr;
}