How to use rocks.inspectit.agent.java.sensor.jmx

/**
 * Informs {@link #mBeanServerListeners} that server has been removed.
 *
 * @param server
 *            {@link MBeanServer}
 */
private void mbeanServerRemoved(MBeanServer server) {
  if (null == server) {
    return;
  }
  if (CollectionUtils.isNotEmpty(mBeanServerListeners)) {
    for (IMBeanServerListener listener : mBeanServerListeners) {
      listener.mbeanServerRemoved(server);
    }
  }
}

/**
 * Informs {@link #mBeanServerListeners} that server has been added.
 *
 * @param server
 *            {@link MBeanServer}
 */
private void mbeanServerAdded(MBeanServer server) {
  if (null == server) {
    return;
  }
  if (CollectionUtils.isNotEmpty(mBeanServerListeners)) {
    for (IMBeanServerListener listener : mBeanServerListeners) {
      listener.mbeanServerAdded(server);
    }
  }
}

@BeforeMethod
public void init() {
  jmxSensor.init(sensorTypeConfig);
}

@Test
public void nullServer() {
  jmxSensor.mbeanServerAdded(null);
  verifyZeroInteractions(connection);
}

@Test
public void sensorSet() {
  JmxSensorTypeConfig sensorTypeConfig1 = mock(JmxSensorTypeConfig.class);
  jmxSensor.init(sensorTypeConfig1);
  assertThat(jmxSensor.getSensorTypeConfig(), is(sensorTypeConfig1));
}

  @Test
  public void wrongNotification() throws Exception {
    jmxSensor.mbeanServerAdded(mBeanServer);
    ArgumentCaptor<MBeanServerHolder> notificationListener = ArgumentCaptor.forClass(MBeanServerHolder.class);
    verify(mBeanServer).addNotificationListener(Matchers.<ObjectName> any(), notificationListener.capture(), Matchers.<NotificationFilter> any(), eq(null));
    Notification notification = mock(Notification.class);
    when(connection.isConnected()).thenReturn(true);
    notificationListener.getValue().handleNotification(notification, null);
    verifyZeroInteractions(mBeanServer);
  }
}

  @Test
  public void listenerUnregistered() throws Exception {
    ArgumentCaptor<MBeanServerHolder> captor = ArgumentCaptor.forClass(MBeanServerHolder.class);
    jmxSensor.mbeanServerAdded(mBeanServer);
    jmxSensor.mbeanServerRemoved(mBeanServer);
    verify(mBeanServer).removeNotificationListener(Matchers.<ObjectName> any(), captor.capture(), Matchers.<NotificationFilter> any(), eq(null));
    assertThat(captor.getValue().mBeanServer, is(mBeanServer));
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void mbeanServerAdded(MBeanServer server) {
  // if null or already registered do nothing
  if ((null == server) || activeServerMap.containsKey(server)) {
    return;
  }
  try {
    // create holder
    MBeanServerHolder holder = new MBeanServerHolder(server);
    // register listener
    try {
      server.addNotificationListener(new ObjectName(MBEAN_SERVER_DELEGATE_NAME), holder, NOTIFICATION_FILTER, null);
    } catch (Exception e) {
      log.warn("Failed to add notification listener to the MBean server " + server.toString() + ". New added beans/attributes will not be monitored.", e);
    }
    // register already existing beans
    registerMBeans(holder, null);
    // add to map if it all works
    activeServerMap.put(server, holder);
  } catch (Throwable t) { // NOPMD
    // catching throwable if anything goes wrong
    log.warn("Unable to add the MBean server " + server.toString() + ".", t);
  }
}

@Test
public void nothingToCollect() {
  jmxSensor.update(coreService);
  verifyZeroInteractions(coreService);
}

@Test
public void unknownServer() throws Exception {
  jmxSensor.mbeanServerRemoved(mBeanServer);
  verifyZeroInteractions(mBeanServer);
}

/**
 * {@inheritDoc}
 */
@Override
public void update(ICoreService coreService) {
  long sensorTypeIdent = sensorTypeConfig.getId();
  long currentTime = System.currentTimeMillis();
  // Check if the collectData method should be invoked
  if (MapUtils.isNotEmpty(activeServerMap) && ((currentTime - lastDataCollectionTimestamp) > DATA_COLLECT_INTERVAL)) {
    // store the invocation timestamp
    lastDataCollectionTimestamp = System.currentTimeMillis();
    for (MBeanServerHolder holder : activeServerMap.values()) {
      collectData(holder, coreService, sensorTypeIdent);
    }
  }
}

@BeforeMethod
public void init() {
  jmxSensor.init(sensorTypeConfig);
}

/**
 * {@inheritDoc}
 */
public void init(JmxSensorTypeConfig sensorTypeConfig) {
  this.sensorTypeConfig = sensorTypeConfig;
  // check for forcing server creation
  Map<String, Object> parameters = sensorTypeConfig.getParameters();
  if (MapUtils.isNotEmpty(parameters)) {
    if (Boolean.TRUE.equals(parameters.get("forceMBeanServer"))) {
      // create only, get it via hook
      MBeanServer server = ManagementFactory.getPlatformMBeanServer();
      mbeanServerAdded(server);
    }
  }
}

@Test
public void happyPathRemove() {
  when(ssc.getTargetMethodName()).thenReturn("removeMBeanServer");
  Object[] parameters = new Object[] { server };
  Object result = hook.beforeBody(METHOD_ID, object, parameters, ssc);
  assertThat(result, is(nullValue()));
  verify(ssc).getTargetMethodName();
  verify(listener).mbeanServerRemoved(server);
  verifyNoMoreInteractions(ssc, listener);
  verifyZeroInteractions(object);
}

@Test
public void happyPathAdd() {
  when(ssc.getTargetMethodName()).thenReturn("addMBeanServer");
  Object[] parameters = new Object[] { server };
  Object result = hook.beforeBody(METHOD_ID, object, parameters, ssc);
  assertThat(result, is(nullValue()));
  verify(ssc).getTargetMethodName();
  verify(listener).mbeanServerAdded(server);
  verifyNoMoreInteractions(ssc, listener);
  verifyZeroInteractions(object);
}

@BeforeMethod
public void init() {
  jmxSensor.init(sensorTypeConfig);
}

@Test
public void listenerRegistered() throws Exception {
  ArgumentCaptor<MBeanServerHolder> captor = ArgumentCaptor.forClass(MBeanServerHolder.class);
  jmxSensor.mbeanServerAdded(mBeanServer);
  verify(mBeanServer).addNotificationListener(Matchers.<ObjectName> any(), captor.capture(), Matchers.<NotificationFilter> any(), eq(null));
  assertThat(captor.getValue().mBeanServer, is(mBeanServer));
}

@BeforeMethod
public void init() {
  jmxSensor.init(sensorTypeConfig);
}

@Test
public void connectionOff() throws Exception {
  when(connection.isConnected()).thenReturn(false);
  jmxSensor.mbeanServerAdded(mBeanServer);
  verify(mBeanServer).addNotificationListener(Matchers.<ObjectName> any(), Matchers.<NotificationListener> any(), Matchers.<NotificationFilter> any(), eq(null));
  verifyNoMoreInteractions(mBeanServer);
}

/**
 * {@inheritDoc}
 */
@Override
public void afterPropertiesSet() throws Exception {
  for (JmxSensorTypeConfig config : configurationStorage.getJmxSensorTypes()) {
    if (config.getClassName().equals(this.getClass().getName())) {
      this.init(config);
      break;
    }
  }
}