org.springframework.cloud.context.refresh.ContextRefresher Java Examples

@Test
public void springMainSourcesEmptyInRefreshCycle() throws Exception {
	this.context = new SpringApplicationBuilder(Empty.class)
			.web(WebApplicationType.NONE).bannerMode(Mode.OFF)
			.properties("spring.cloud.bootstrap.name:none").run();
	RefreshScope scope = new RefreshScope();
	scope.setApplicationContext(this.context);
	// spring.main.sources should be empty when the refresh cycle starts (we don't
	// want any config files from the application context getting into the one used to
	// construct the environment for refresh)
	TestPropertyValues
			.of("spring.main.sources="
					+ ExternalPropertySourceLocator.class.getName())
			.applyTo(this.context);
	ContextRefresher contextRefresher = new ContextRefresher(this.context, scope);
	RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
	Collection<String> keys = endpoint.refresh();
	then(keys.contains("external.message")).as("Wrong keys: " + keys).isFalse();
}
 

@Test
public void keysComputedWhenChangesInExternalProperties() throws Exception {
	this.context = new SpringApplicationBuilder(Empty.class)
			.web(WebApplicationType.NONE).bannerMode(Mode.OFF)
			.properties("spring.cloud.bootstrap.name:none").run();
	RefreshScope scope = new RefreshScope();
	scope.setApplicationContext(this.context);
	TestPropertyValues
			.of("spring.cloud.bootstrap.sources="
					+ ExternalPropertySourceLocator.class.getName())
			.applyTo(this.context.getEnvironment(), Type.MAP, "defaultProperties");
	ContextRefresher contextRefresher = new ContextRefresher(this.context, scope);
	RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
	Collection<String> keys = endpoint.refresh();
	then(keys.contains("external.message")).isTrue().as("Wrong keys: " + keys);
}
 

@Test
public void should_work_with_flat_maps_with_on_last_operator_instrumentation(
		CapturedOutput capture) {
	// given
	ConfigurableApplicationContext context = new SpringApplicationBuilder(
			FlatMapTests.TestConfiguration.class, Issue866Configuration.class)
					.web(WebApplicationType.REACTIVE)
					.properties("server.port=0", "spring.jmx.enabled=false",
							"spring.sleuth.reactor.decorate-on-each=false",
							"spring.application.name=TraceWebFlux2Tests",
							"security.basic.enabled=false",
							"management.security.enabled=false")
					.run();
	assertReactorTracing(context, capture);

	try {
		System.setProperty("spring.sleuth.reactor.decorate-on-each", "true");
		// trigger context refreshed
		context.getBean(ContextRefresher.class).refresh();
		assertReactorTracing(context, capture);
	}
	finally {
		System.clearProperty("spring.sleuth.reactor.decorate-on-each");
	}
}
 

@Bean
@ConditionalOnProperty(name = "spring.cloud.servicecomb.config.watch.enabled",
    matchIfMissing = true)
public ConfigWatch configWatch(ServiceCombConfigProperties serviceCombConfigProperties,
    ServiceCombConfigClient serviceCombConfigClient,
    ContextRefresher contextRefresher, RefreshRecord refreshRecord,
    ServiceCombAkSkProperties serviceCombAkSkProperties) {
  ConfigWatch watch = new ConfigWatch();
  watch.setProject(serviceCombAkSkProperties.getProject());
  watch.setContextRefresher(contextRefresher);
  watch.setServiceCombConfigClient(serviceCombConfigClient);
  watch.setServiceCombConfigProperties(serviceCombConfigProperties);
  watch.setRefreshRecord(refreshRecord);
  return watch;
}
 

@Test
public void shouldReregisterHealthCheckHandlerAfterRefresh() throws Exception {
	TestPropertyValues.of("eureka.client.healthcheck.enabled=true")
			.applyTo(this.context);
	setupContext(RefreshAutoConfiguration.class,
			AutoServiceRegistrationConfiguration.class);

	EurekaClient oldEurekaClient = getLazyInitEurekaClient();

	HealthCheckHandler healthCheckHandler = this.context
			.getBean("eurekaHealthCheckHandler", HealthCheckHandler.class);

	assertThat(healthCheckHandler).isInstanceOf(EurekaHealthCheckHandler.class);
	assertThat(oldEurekaClient.getHealthCheckHandler()).isSameAs(healthCheckHandler);

	ContextRefresher refresher = this.context.getBean("contextRefresher",
			ContextRefresher.class);
	refresher.refresh();

	EurekaClient newEurekaClient = getLazyInitEurekaClient();
	HealthCheckHandler newHealthCheckHandler = this.context
			.getBean("eurekaHealthCheckHandler", HealthCheckHandler.class);

	assertThat(healthCheckHandler).isSameAs(newHealthCheckHandler);
	assertThat(oldEurekaClient).isNotSameAs(newEurekaClient);
	assertThat(newEurekaClient.getHealthCheckHandler()).isSameAs(healthCheckHandler);
}
 

@Test
public void shutdownHooksCleaned() {
	try (ConfigurableApplicationContext context = new SpringApplicationBuilder(
			Empty.class).web(WebApplicationType.NONE).bannerMode(Mode.OFF).run()) {
		RefreshScope scope = new RefreshScope();
		scope.setApplicationContext(context);
		ContextRefresher contextRefresher = new ContextRefresher(context, scope);
		RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
		int count = countShutdownHooks();
		endpoint.refresh();
		int after = countShutdownHooks();
		then(count).isEqualTo(after).as("Shutdown hooks not cleaned on refresh");
	}
}
 

@Test
public void eventsPublishedInOrder() throws Exception {
	this.context = new SpringApplicationBuilder(Empty.class)
			.web(WebApplicationType.NONE).bannerMode(Mode.OFF).run();
	RefreshScope scope = new RefreshScope();
	scope.setApplicationContext(this.context);
	ContextRefresher contextRefresher = new ContextRefresher(this.context, scope);
	RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
	Empty empty = this.context.getBean(Empty.class);
	endpoint.refresh();
	int after = empty.events.size();
	then(2).isEqualTo(after).as("Shutdown hooks not cleaned on refresh");
	then(empty.events.get(0) instanceof EnvironmentChangeEvent).isTrue();
}
 

@Test
public void keysComputedWhenOveridden() throws Exception {
	this.context = new SpringApplicationBuilder(Empty.class)
			.web(WebApplicationType.NONE).bannerMode(Mode.OFF)
			.properties("spring.cloud.bootstrap.name:none").run();
	RefreshScope scope = new RefreshScope();
	scope.setApplicationContext(this.context);
	this.context.getEnvironment().setActiveProfiles("override");
	ContextRefresher contextRefresher = new ContextRefresher(this.context, scope);
	RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
	Collection<String> keys = endpoint.refresh();
	then(keys.contains("message")).isTrue().as("Wrong keys: " + keys);
}
 

@Test
public void keysComputedWhenAdded() throws Exception {
	this.context = new SpringApplicationBuilder(Empty.class)
			.web(WebApplicationType.NONE).bannerMode(Mode.OFF)
			.properties("spring.cloud.bootstrap.name:none").run();
	RefreshScope scope = new RefreshScope();
	scope.setApplicationContext(this.context);
	this.context.getEnvironment().setActiveProfiles("local");
	ContextRefresher contextRefresher = new ContextRefresher(this.context, scope);
	RefreshEndpoint endpoint = new RefreshEndpoint(contextRefresher);
	Collection<String> keys = endpoint.refresh();
	then(keys.contains("added")).isTrue().as("Wrong keys: " + keys);
}
 

@Test
public void neverRefreshable() {
	try (ConfigurableApplicationContext context = getApplicationContext(
			WebApplicationType.NONE, Config.class, "countingconfig.foo=bar",
			"spring.cloud.refresh.never-refreshable:"
					+ CountingConfigProps.class.getName())) {
		CountingConfigProps configProps = context.getBean(CountingConfigProps.class);
		context.getBean(ContextRefresher.class).refresh();
		assertThat(configProps.count)
				.as("config props was rebound when it should not have been")
				.hasValue(1);
	}
}
 

@Test
public void extraRefreshables() {
	try (ConfigurableApplicationContext context = getApplicationContext(
			WebApplicationType.NONE, Config.class, "sealedconfig.foo=bar",
			"spring.cloud.refresh.extra-refreshable:"
					+ SealedConfigProps.class.getName())) {
		context.getBean(SealedConfigProps.class);
		context.getBean(ContextRefresher.class).refresh();
	}
}
 

@Test
public void refreshables() {
	try (ConfigurableApplicationContext context = getApplicationContext(
			WebApplicationType.NONE, Config.class, "config.foo=bar",
			"spring.cloud.refresh.refreshable:"
					+ SealedConfigProps.class.getName())) {
		context.getBean(SealedConfigProps.class);
		context.getBean(ContextRefresher.class).refresh();
	}
}
 

@Bean
@ConditionalOnBean(ContextRefresher.class)
@ConditionalOnAvailableEndpoint
@ConditionalOnMissingBean
public RefreshEndpoint refreshEndpoint(ContextRefresher contextRefresher) {
	return new RefreshEndpoint(contextRefresher);
}
 

@Test
@Ignore // TODO: replicate problem
public void serviceMatcherIdIsConstantAfterRefresh() {
	this.context = SpringApplication.run(new Class[] { RefreshConfig.class, },
			new String[] { "--spring.main.allow-bean-definition-overriding=true" });
	String originalServiceId = this.context.getBean(ServiceMatcher.class)
			.getServiceId();
	this.context.getBean(ContextRefresher.class).refresh();
	String newServiceId = this.context.getBean(ServiceMatcher.class).getServiceId();
	assertThat(newServiceId).isEqualTo(originalServiceId);
}
 

@Bean
@ConditionalOnProperty(value = "spring.cloud.bus.refresh.enabled",
		matchIfMissing = true)
@ConditionalOnBean(ContextRefresher.class)
public RefreshListener refreshListener(ContextRefresher contextRefresher,
		ServiceMatcher serviceMatcher) {
	return new RefreshListener(contextRefresher, serviceMatcher);
}
 

/**
 * Provides the action to execute when the configuration changes.
 */
@Bean
@ConditionalOnMissingBean
public ConfigurationUpdateStrategy configurationUpdateStrategy(ConfigReloadProperties properties, ConfigurableApplicationContext ctx, RestartEndpoint restarter, ContextRefresher refresher) {
    switch (properties.getStrategy()) {
    case RESTART_CONTEXT:
        return new ConfigurationUpdateStrategy(properties.getStrategy().name(), restarter::restart);
    case REFRESH:
        return new ConfigurationUpdateStrategy(properties.getStrategy().name(), refresher::refresh);
    case SHUTDOWN:
        return new ConfigurationUpdateStrategy(properties.getStrategy().name(), ctx::close);
    }
    throw new IllegalStateException("Unsupported configuration update strategy: " + properties.getStrategy());
}
 

@Bean
@ConditionalOnMissingBean
public PeriodCheckRefreshEventEmitter refreshEventEmitter(ConfigServicePropertySourceLocator locator,
                                                          ContextRefresher refresher, Environment environment) {
    return new PeriodCheckRefreshEventEmitter((MultiModuleConfigServicePropertySourceLocator) locator,
            refresher, environment);
}
 

/**
 * @param properties config reload properties
 * @param ctx application context
 * @param restarter restart endpoint
 * @param refresher context refresher
 * @return provides the action to execute when the configuration changes.
 */
@Bean
@ConditionalOnMissingBean
public ConfigurationUpdateStrategy configurationUpdateStrategy(
		ConfigReloadProperties properties, ConfigurableApplicationContext ctx,
		@Autowired(required = false) RestartEndpoint restarter,
		ContextRefresher refresher) {
	switch (properties.getStrategy()) {
	case RESTART_CONTEXT:
		Assert.notNull(restarter, "Restart endpoint is not enabled");
		return new ConfigurationUpdateStrategy(properties.getStrategy().name(),
				() -> {
					wait(properties);
					restarter.restart();
				});
	case REFRESH:
		return new ConfigurationUpdateStrategy(properties.getStrategy().name(),
				refresher::refresh);
	case SHUTDOWN:
		return new ConfigurationUpdateStrategy(properties.getStrategy().name(),
				() -> {
					wait(properties);
					ctx.close();
				});
	}
	throw new IllegalStateException("Unsupported configuration update strategy: "
			+ properties.getStrategy());
}
 

public PeriodCheckRefreshEventEmitter(MultiModuleConfigServicePropertySourceLocator locator,
                                      ContextRefresher refresher, Environment environment) {
    super(locator, refresher, environment);

    thread = new Thread(this);
    thread.setDaemon(true);
    thread.setName("Config-Client-Period-Checker");
}
 

@Bean
public ContextRefresher contextRefresher(ConfigurableApplicationContext context,
		RefreshScope scope) {
	return new ContextRefresher(context, scope);
}
 

public ConfigClientWatch(ContextRefresher refresher) {
	this.refresher = refresher;
}
 

@Bean
public ConfigClientWatch configClientWatch(ContextRefresher contextRefresher) {
	return new ConfigClientWatch(contextRefresher);
}
 

public void setContextRefresher(ContextRefresher contextRefresher) {
  this.contextRefresher = contextRefresher;
}
 

public ConfigurationEventProcessor(TopicProcessor<CloudEventImpl> eventProcessor, ContextRefresher contextRefresher, String applicationName) {
    this.eventProcessor = eventProcessor;
    this.contextRefresher = contextRefresher;
    this.applicationName = applicationName;
}
 

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@Bean
public ConfigurationEventProcessor rSocketConfigListener(@Autowired ContextRefresher contextRefresher,
                                                         @Autowired @Qualifier("reactiveCloudEventProcessor") TopicProcessor<CloudEventImpl> eventProcessor) {
    return new ConfigurationEventProcessor(eventProcessor, contextRefresher, applicationName);
}
 

public RefreshEventEmitter(ConfigServicePropertySourceLocator locator, ContextRefresher refresher, Environment environment) {
    this.locator = locator;
    this.refresher = refresher;
    this.environment = environment;
}
 

ContextRefresher getRefresher() {
    return refresher;
}
 

public RefreshEventListener(ContextRefresher refresh) {
	this.refresh = refresh;
}
 

public RefreshEndpoint(ContextRefresher contextRefresher) {
	this.contextRefresher = contextRefresher;
}
 

@Bean
public RefreshEventListener refreshEventListener(ContextRefresher contextRefresher) {
	return new RefreshEventListener(contextRefresher);
}