Java Context.create方法代码示例

import org.terracotta.management.model.context.Context; //导入方法依赖的package包/类
@Override
public void addStatisticCollector(EntityManagementRegistry registry) {
  long consumerId = registry.getMonitoringService().getConsumerId();
  LOGGER.trace("[{}] addStatisticCollector()", consumerId);

  // The context for the collector is created from the the registry of the entity wanting server-side providers.
  // We create a provider that will receive management calls to control the global voltron's statistic collector.
  // This provider will thus be on top of the entity wanting to collect server-side stats
  ContextContainer contextContainer = registry.getContextContainer();
  Context context = Context.create(contextContainer.getName(), contextContainer.getValue());
  StatisticCollectorManagementProvider collectorManagementProvider = new StatisticCollectorManagementProvider(context);
  registry.addManagementProvider(collectorManagementProvider);

  EntityMonitoringService monitoringService = registry.getMonitoringService();

  StatisticCollector statisticCollector = new DefaultStatisticCollector(
      // Create a statistics collector which can collect stats over all management registries and only the registry combined.
      // This will avoid collecting stats on a registry from another NMS entity that already has its own stat collector.
      new CombiningCapabilityManagementSupport(sharedEntityManagementRegistry, registry),
      managementScheduler,
      list -> {
        // Add a marker on the statistics to know which statistics collector has collected them (from which NMS entity)
        list.forEach(stats -> stats.setContext(stats.getContext().with("collectorId", "" + consumerId)));
        monitoringService.pushStatistics(list.toArray(new ContextualStatistics[list.size()]));
      }
  );

  // add a collector service, not started by default, but that can be started through a remote management call
  registry.register(statisticCollector);

  registry.refresh();
}
 

import org.terracotta.management.model.context.Context; //导入方法依赖的package包/类
@Test
public void execute_handles_unexpected_exceptions() throws Exception {
  final Context context = Context.create("key", "val");
  Parameter[] parameters = new Parameter[]{new Parameter("toto")};
  Collection<Context> contexts = new ArrayList<Context>() {{
    add(context);
  }};

  //necessary mock
  ManagementProvider<?> managementProvider = mock(ManagementProvider.class);
  when(managementProvider.supports(context)).thenReturn(true);
  RuntimeException runtimeException = new RuntimeException("Oups, that was not supposed to happen !");
  when(managementProvider.callAction(context, "myMethodName", String.class, parameters)).thenThrow(runtimeException);

  CapabilityManagementSupport capabilityManagementSupport = mock(CapabilityManagementSupport.class);
  Collection<ManagementProvider<?>> managementProviders = new ArrayList<ManagementProvider<?>>();
  managementProviders.add(managementProvider);
  when(capabilityManagementSupport.getManagementProvidersByCapability("myCapabilityName")).thenReturn(managementProviders);

  DefaultCallQuery<String> defaultCallQuery = new DefaultCallQuery<String>(capabilityManagementSupport, "myCapabilityName", "myMethodName", String.class, parameters, contexts);
  ResultSet executeResults = defaultCallQuery.execute();

  ContextualReturn singleResult = (ContextualReturn) executeResults.getSingleResult();
  try {
    singleResult.getValue();
    fail();
  } catch (Exception e) {
    assertThat(e, is(instanceOf(ExecutionException.class)));
    assertThat(e.getMessage(), equalTo("Oups, that was not supposed to happen !"));
  }

}
 

import org.terracotta.management.model.context.Context; //导入方法依赖的package包/类
public Management(ContextContainer contextContainer) {
  this.parentContext = Context.create(contextContainer.getName(), contextContainer.getValue());

  // create a client-side management registry and add some providers for stats, calls and settings
  this.managementRegistry = new DefaultManagementRegistry(contextContainer);
  managementRegistry.addManagementProvider(new CacheSettingsManagementProvider(parentContext));
  managementRegistry.addManagementProvider(new CacheStatisticsManagementProvider(parentContext, System::currentTimeMillis));
  managementRegistry.addManagementProvider(new CacheCallManagementProvider(parentContext));
  managementRegistry.addManagementProvider(new CacheStatisticCollectorManagementProvider(parentContext));

  // create a statistic collector
  this.statisticCollector = new DefaultStatisticCollector(
      managementRegistry,
      scheduledExecutorService,
      statistics -> {
        try {
          nmsAgentService.pushStatistics(statistics);
        } catch (ExecutionException e) {
          LOGGER.warn("Unable to push statistics: " + e.getCause().getMessage(), e.getCause());
        } catch (ConnectionClosedException ignored) {
          // avoid printing warnings each time we close the connection when tests ends
        } catch (Exception e) {
          LOGGER.warn("Unable to push statistics: " + e.getMessage(), e);
        }
      });

  // register the collector in the registry so that we can manage it
  managementRegistry.register(statisticCollector);
}
 

import org.terracotta.management.model.context.Context; //导入方法依赖的package包/类
@Test
public void test_contextualNotif() throws Exception {
  ContextualNotification notif = new ContextualNotification(context, "TYPE", Context.create("key", "val"));
  assertEquals(notif, copy(notif));
  assertEquals(notif.hashCode(), copy(notif).hashCode());
}
 

import org.terracotta.management.model.context.Context; //导入方法依赖的package包/类
@Override
protected ExposedObject<T> wrap(T managedObject) {
  Context context = Context.create("consumerId", String.valueOf(getMonitoringService().getConsumerId()));
  return internalWrap(context, managedObject);
}