How to use

ManagementRegistryServiceConfiguration

in

org.ehcache.management

 public EhcacheStatisticCollectorProvider(ManagementRegistryServiceConfiguration configuration) {
  super(configuration.getContext());
 }
}

private Descriptor cacheManagerSettings() {
 return new Settings()
   .set("cacheManagerDescription", ((HumanReadable)cacheManager.getRuntimeConfiguration()).readableString())
   // NEVER DO THAT: This might block cm.close() because getStatus() is blocking.
   //.set("status", cacheManager.getStatus())
   .set("instanceId", configuration.getInstanceId())
   .set("managementContext", new Settings(registryConfiguration.getContext()))
   .set("tags", registryConfiguration.getTags().toArray(new String[0]));
}

@Override
public void stateTransition(Status from, Status to) {
 // we are only interested when cache manager is initializing (but at the end of the initialization)
 switch (to) {
  case AVAILABLE: {
   nmsAgentService = createNmsAgentService();
   nmsAgentService.sendStates();
   nmsAgentService.setTags(managementRegistryService.getConfiguration().getTags());
   break;
  }
  case UNINITIALIZED: {
   this.cacheManager.deregisterListener(this);
   break;
  }
  case MAINTENANCE:
   // in case we need management capabilities in maintenance mode
   break;
  default:
   throw new AssertionError("Unsupported state: " + to);
 }
}

StandardEhcacheStatistics(ManagementRegistryServiceConfiguration registryConfiguration, CacheBinding cacheBinding, StatisticsService statisticsService, TimeSource timeSource) {
 super(registryConfiguration, cacheBinding);
 this.statisticRegistry = new StatisticRegistry(cacheBinding.getCache(), timeSource::getTimeMillis);
 String cacheName = cacheBinding.getAlias();
 CacheStatistics cacheStatistics = statisticsService.getCacheStatistics(cacheName);
 cacheStatistics.getKnownStatistics().forEach(statisticRegistry::registerStatistic);
 LatencyHistogramConfiguration latencyHistogramConfiguration = registryConfiguration.getLatencyHistogramConfiguration();
 // We want some latency statistics as well, so let's register them
 registerDerivedStatistics(cacheStatistics, "get", CacheOperationOutcomes.GetOutcome.HIT, "Cache:GetHitLatency", latencyHistogramConfiguration);
 registerDerivedStatistics(cacheStatistics, "get", CacheOperationOutcomes.GetOutcome.MISS, "Cache:GetMissLatency", latencyHistogramConfiguration);
 registerDerivedStatistics(cacheStatistics, "put", CacheOperationOutcomes.PutOutcome.PUT, "Cache:PutLatency", latencyHistogramConfiguration);
 registerDerivedStatistics(cacheStatistics, "remove", CacheOperationOutcomes.RemoveOutcome.SUCCESS, "Cache:RemoveLatency", latencyHistogramConfiguration);
}

@Override
public synchronized void start(ServiceProvider<Service> serviceProvider) {
 managementRegistry = serviceProvider.getService(ManagementRegistryService.class);
 configuration = managementRegistry.getConfiguration();
 cacheManager = serviceProvider.getService(CacheManagerProviderService.class).getCacheManager();
 scheduledExecutorService = serviceProvider.getService(ExecutionService.class).getScheduledExecutor(configuration.getCollectorExecutorAlias());
 TimeSource timeSource = serviceProvider.getService(TimeSourceService.class).getTimeSource();
 statisticCollector = new DefaultStatisticCollector(
  managementRegistry,
  scheduledExecutorService,
  collector::onStatistics,
  timeSource::getTimeMillis);
 cacheManager.registerListener(this);
}

protected ExposedCacheBinding(ManagementRegistryServiceConfiguration registryConfiguration, CacheBinding cacheBinding) {
 this.cacheBinding = cacheBinding;
 this.context = registryConfiguration.getContext().with("cacheName", cacheBinding.getAlias());
}

@Override
public ContextContainer getContextContainer() {
 Collection<ContextContainer> cacheCtx = new ArrayList<>();
 for (String cacheName : this.cacheManager.getRuntimeConfiguration().getCacheConfigurations().keySet()) {
  cacheCtx.add(new ContextContainer("cacheName", cacheName));
 }
 return new ContextContainer("cacheManagerName", getConfiguration().getContext().get("cacheManagerName"), cacheCtx);
}

@Override
public void cacheRemoved(String alias, Cache<?, ?> cache) {
 collector.onNotification(
  new ContextualNotification(
   configuration.getContext().with("cacheName", alias),
   EhcacheNotification.CACHE_REMOVED.name()));
}

private void cacheCleared(String alias) {
 collector.onNotification(
  new ContextualNotification(
   configuration.getContext().with("cacheName", alias),
   EhcacheNotification.CACHE_CLEARED.name()));
}

@Override
public synchronized void stop() {
 // do not call deregisterListener here because the stateTransition event for UNINITIALIZED won't be caught.
 // so deregisterListener is done in the stateTransition listener
 //cacheManager.deregisterListener(this);
 collector.onNotification(
  new ContextualNotification(
   configuration.getContext(),
   EhcacheNotification.CACHE_MANAGER_CLOSED.name()));
 statisticCollector.stopStatisticCollector();
 shutdownNow(scheduledExecutorService);
}

@Override
public void cacheAdded(String alias, Cache<?, ?> cache) {
 registerClearNotification(alias, cache);
 collector.onNotification(
  new ContextualNotification(
   configuration.getContext().with("cacheName", alias),
   EhcacheNotification.CACHE_ADDED.name()));
}

@Override
public void stateTransition(Status from, Status to) {
 switch (to) {
  case AVAILABLE:
   // .register() call should be there when CM is AVAILABLE
   // this is to expose the stats collector for management calls
   managementRegistry.register(statisticCollector);
   collector.onNotification(
    new ContextualNotification(
     configuration.getContext(),
     EhcacheNotification.CACHE_MANAGER_AVAILABLE.name()));
   break;
  case MAINTENANCE:
   collector.onNotification(
    new ContextualNotification(
     configuration.getContext(),
     EhcacheNotification.CACHE_MANAGER_MAINTENANCE.name()));
   break;
  case UNINITIALIZED:
   // deregister me - should not be in stop() - see other comments
   cacheManager.deregisterListener(this);
   break;
  default:
   throw new AssertionError("Unsupported state: " + to);
 }
}

@Test
public void testSharedCapabilities() {
 assertEquals(2, service.getCapabilitiesByContext().size());
 Collection<? extends Capability> capabilities1 = service.getCapabilitiesByContext().get(config1.getContext());
 Collection<? extends Capability> capabilities2 = service.getCapabilitiesByContext().get(config2.getContext());
 assertThat(capabilities1, hasSize(4));
 assertThat(new ArrayList<Capability>(capabilities1).get(0).getName(), equalTo("ActionsCapability"));
 assertThat(new ArrayList<Capability>(capabilities1).get(1).getName(), equalTo("SettingsCapability"));
 assertThat(new ArrayList<Capability>(capabilities1).get(2).getName(), equalTo("StatisticCollectorCapability"));
 assertThat(new ArrayList<Capability>(capabilities1).get(3).getName(), equalTo("StatisticsCapability"));
 assertThat(capabilities2, hasSize(4));
 assertThat(new ArrayList<Capability>(capabilities2).get(0).getName(), equalTo("ActionsCapability"));
 assertThat(new ArrayList<Capability>(capabilities2).get(1).getName(), equalTo("SettingsCapability"));
 assertThat(new ArrayList<Capability>(capabilities2).get(2).getName(), equalTo("StatisticCollectorCapability"));
 assertThat(new ArrayList<Capability>(capabilities2).get(3).getName(), equalTo("StatisticsCapability"));
}

@Override
public void start(final ServiceProvider<Service> serviceProvider) {
 final ManagementRegistryService managementRegistry = serviceProvider.getService(ManagementRegistryService.class);
 final Context cmContext = managementRegistry.getConfiguration().getContext();
 final InternalCacheManager cacheManager =
  serviceProvider.getService(CacheManagerProviderService.class).getCacheManager();

@Test
public void testSharedContexts() {
 assertEquals(2, service.getContextContainers().size());
 ContextContainer contextContainer1 = service.getContextContainers().get(config1.getContext());
 ContextContainer contextContainer2 = service.getContextContainers().get(config2.getContext());
 assertThat(contextContainer1, is(notNullValue()));
 assertThat(contextContainer2, is(notNullValue()));
 assertThat(contextContainer1.getName(), equalTo("cacheManagerName"));
 assertThat(contextContainer1.getValue(), equalTo("myCM1"));
 assertThat(contextContainer2.getName(), equalTo("cacheManagerName"));
 assertThat(contextContainer2.getValue(), equalTo("myCM2"));
 assertThat(contextContainer1.getSubContexts().size(), equalTo(1));
 assertThat(contextContainer1.getSubContexts().iterator().next().getName(), equalTo("cacheName"));
 assertThat(contextContainer1.getSubContexts().iterator().next().getValue(), equalTo("aCache1"));
 assertThat(contextContainer2.getSubContexts().size(), equalTo(2));
 assertThat(contextContainer2.getSubContexts().iterator().next().getName(), equalTo("cacheName"));
 assertThat(new ArrayList<>(contextContainer2.getSubContexts()).get(1).getName(), equalTo("cacheName"));
 assertThat(new ArrayList<>(contextContainer2.getSubContexts()).get(0).getValue(), isIn(Arrays.asList("aCache2", "aCache3")));
 assertThat(new ArrayList<>(contextContainer2.getSubContexts()).get(1).getValue(), isIn(Arrays.asList("aCache2", "aCache3")));
}