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

Example 76 with Notification

use of javax.management.Notification in project quasar by puniverse.

the class ActorLoader method notify.

private synchronized void notify(ActorModule module, String action) {
    final Notification n = new ModuleNotification(this, notificationSequenceNumber++, System.currentTimeMillis(), "Module " + module + " has been " + action);
    notificationBroadcaster.sendNotification(n);
}

Example 77 with Notification

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

the class MBeanExporterTests method testRegisterNotificationListenerForNonExistentMBean.

@Test
public void testRegisterNotificationListenerForNonExistentMBean() throws Exception {
    Map<String, NotificationListener> listeners = new HashMap<>();
    NotificationListener dummyListener = new NotificationListener() {

        @Override
        public void handleNotification(Notification notification, Object handback) {
            throw new UnsupportedOperationException();
        }
    };
    // the MBean with the supplied object name does not exist...
    listeners.put("spring:type=Test", dummyListener);
    MBeanExporter exporter = new MBeanExporter();
    exporter.setBeans(getBeanMap());
    exporter.setServer(server);
    exporter.setNotificationListenerMappings(listeners);
    try {
        start(exporter);
        fail("Must have thrown an MBeanExportException when registering a " + "NotificationListener on a non-existent MBean.");
    } catch (MBeanExportException expected) {
        assertTrue(expected.contains(InstanceNotFoundException.class));
    }
}

Example 78 with Notification

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

the class ModelMBeanNotificationPublisherTests method testSendAttributeChangeNotificationWhereSourceIsNotTheManagedResource.

public void testSendAttributeChangeNotificationWhereSourceIsNotTheManagedResource() throws Exception {
    StubSpringModelMBean mbean = new StubSpringModelMBean();
    Notification notification = new AttributeChangeNotification(this, 1872, System.currentTimeMillis(), "Shall we break for some tea?", "agree", "java.lang.Boolean", Boolean.FALSE, Boolean.TRUE);
    ObjectName objectName = createObjectName();
    NotificationPublisher publisher = new ModelMBeanNotificationPublisher(mbean, objectName, mbean);
    publisher.sendNotification(notification);
    assertNotNull(mbean.getActualNotification());
    assertTrue(mbean.getActualNotification() instanceof AttributeChangeNotification);
    assertSame("The exact same Notification is not being passed through from the publisher to the mbean.", notification, mbean.getActualNotification());
    assertSame("The 'source' property of the Notification is *wrongly* being set to the ObjectName of the associated MBean.", this, mbean.getActualNotification().getSource());
}

Example 79 with Notification

use of javax.management.Notification in project intellij-community by JetBrains.

the class PerformanceWatcher method watchCodeCache.

private void watchCodeCache(final MemoryPoolMXBean bean) {
    final long threshold = bean.getUsage().getMax() - 5 * 1024 * 1024;
    if (!bean.isUsageThresholdSupported() || threshold <= 0)
        return;
    bean.setUsageThreshold(threshold);
    final NotificationEmitter emitter = (NotificationEmitter) ManagementFactory.getMemoryMXBean();
    emitter.addNotificationListener(new NotificationListener() {

        @Override
        public void handleNotification(Notification n, Object hb) {
            if (bean.getUsage().getUsed() > threshold) {
                LOG.info("Code Cache is almost full");
                dumpThreads("codeCacheFull", true);
                try {
                    emitter.removeNotificationListener(this);
                } catch (ListenerNotFoundException e) {
                    LOG.error(e);
                }
            }
        }
    }, null, null);
}

Example 80 with Notification

use of javax.management.Notification 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;
}