org.springframework.cloud.client.discovery.event.InstanceRegisteredEvent Java Examples

private URI registerInstance() {
    //We register the instance by setting static values for the SimpleDiscoveryClient and issuing a
    //InstanceRegisteredEvent that makes sure the instance gets registered.
    SimpleDiscoveryProperties.SimpleServiceInstance serviceInstance = new SimpleDiscoveryProperties.SimpleServiceInstance();
    serviceInstance.setServiceId("Test-Instance");
    serviceInstance.setUri(URI.create("http://localhost:" + port));
    serviceInstance.getMetadata().put("management.context-path", "/mgmt");
    simpleDiscovery.getInstances().put("Test-Application", singletonList(serviceInstance));

    instance.publishEvent(new InstanceRegisteredEvent<>(new Object(), null));

    //To get the location of the registered instances we fetch the instance with the name.
    List<JSONObject> applications = webClient.get()
                                             .uri("/instances?name=Test-Instance")
                                             .accept(MediaType.APPLICATION_JSON)
                                             .exchange()
                                             .expectStatus()
                                             .isOk()
                                             .returnResult(JSONObject.class)
                                             .getResponseBody()
                                             .collectList()
                                             .block();
    assertThat(applications).hasSize(1);
    return URI.create("http://localhost:" + port + "/instances/" + applications.get(0).optString("id"));
}
 

/**
 * Update grpc port of consul tags after Conusl Registered
 * */
@EventListener
public void listenInstanceRegisteredEvent(InstanceRegisteredEvent instanceRegisteredEvent){
  if(alphaServerPort == 0){
    if(instanceRegisteredEvent.getConfig() instanceof ConsulDiscoveryProperties){
      ConsulDiscoveryProperties properties = (ConsulDiscoveryProperties)instanceRegisteredEvent.getConfig();
      this.consuleInstanceId = formatConsulInstanceId(properties.getInstanceId());
      Response<List<CatalogService>> services = consulClient.getCatalogService(serviceName,null);
      if(services.getValue() != null){
        services.getValue().stream().filter(service ->
            service.getServiceId().equalsIgnoreCase(this.consuleInstanceId)).forEach(service -> {

          NewService newservice =  new NewService();
          newservice.setName(service.getServiceName());
          newservice.setId(service.getServiceId());
          newservice.setAddress(service.getAddress());
          newservice.setPort(service.getServicePort());
          List<String> tags = service.getServiceTags();
          tags.remove("alpha-server-port=0");
          tags.add("alpha-server-port="+actualAlphaServerPort);
          newservice.setTags(tags);
          consulClient.agentServiceRegister(newservice);
        });
      }
    }
  }
}
 

@Test
public void should_not_register_instances_when_instanceMetadata_matches_wanted_metadata_and_ignored_metadata() {
	when(this.discovery.getServices()).thenReturn(asList("service", "service-1"));
	when(this.discovery.getInstances("service")).thenReturn(singletonList(
			new DefaultServiceInstance("test-1", "service", "localhost", 80, false, new HashMap<String, String>() {
				{
					put("monitoring", "true");
					put("management", "true");
				}
			})));
	when(this.discovery.getInstances("service-1")).thenReturn(singletonList(new DefaultServiceInstance("test-1",
			"service-1", "localhost", 80, false, new HashMap<String, String>() {
				{
					put("monitoring", "true");
					put("management", "false");
				}
			})));

	this.listener.setInstancesMetadata(Collections.singletonMap("monitoring", "true"));
	this.listener.setIgnoredInstancesMetadata(Collections.singletonMap("management", "true"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances())
			.assertNext((a) -> assertThat(a.getRegistration().getName()).isEqualTo("service-1")).verifyComplete();
}
 

@Test
public void should_register_instance_when_new_service_instance_is_discovered() {
	when(this.discovery.getServices()).thenReturn(singletonList("service"));
	when(this.discovery.getInstances("service"))
			.thenReturn(singletonList(new DefaultServiceInstance("test-1", "service", "localhost", 80, false)));

	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances()).assertNext((application) -> {
		Registration registration = application.getRegistration();
		assertThat(registration.getHealthUrl()).isEqualTo("http://localhost:80/actuator/health");
		assertThat(registration.getManagementUrl()).isEqualTo("http://localhost:80/actuator");
		assertThat(registration.getServiceUrl()).isEqualTo("http://localhost:80");
		assertThat(registration.getName()).isEqualTo("service");
	}).verifyComplete();
}
 

@Test
public void should_not_register_instance_when_instanceMetadata_matches_ignored_metadata() {
	when(this.discovery.getServices()).thenReturn(asList("service", "rabbit-1", "rabbit-2"));
	when(this.discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1",
			"service", "localhost", 80, false, Collections.singletonMap("monitoring", "true"))));
	when(this.discovery.getInstances("rabbit-1"))
			.thenReturn(singletonList(new DefaultServiceInstance("rabbit-test-1", "rabbit-1", "localhost", 80,
					false, Collections.singletonMap("monitoring", "false"))));
	when(this.discovery.getInstances("rabbit-2"))
			.thenReturn(singletonList(new DefaultServiceInstance("rabbit-test-1", "rabbit-2", "localhost", 80,
					false, Collections.singletonMap("monitoring", "false"))));

	this.listener.setIgnoredInstancesMetadata(Collections.singletonMap("monitoring", "false"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances())
			.assertNext((a) -> assertThat(a.getRegistration().getName()).isEqualTo("service")).verifyComplete();
}
 

@Test
public void should_not_throw_error_when_conversion_fails_and_proceed_with_next_instance() {
	when(this.discovery.getServices()).thenReturn(singletonList("service"));
	when(this.discovery.getInstances("service"))
			.thenReturn(asList(new DefaultServiceInstance("test-1", "service", "localhost", 80, false),
					new DefaultServiceInstance("error-1", "error", "localhost", 80, false)));
	this.listener.setConverter((instance) -> {
		if (instance.getServiceId().equals("error")) {
			throw new IllegalStateException("Test-Error");
		}
		else {
			return new DefaultServiceInstanceConverter().convert(instance);
		}
	});

	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances())
			.assertNext((a) -> assertThat(a.getRegistration().getName()).isEqualTo("service")).verifyComplete();
}
 

@Test
public void shouldReturnUpStatusWithServices() {
	when(discoveryClient.getServices()).thenReturn(Flux.just("service"));
	when(properties.isIncludeDescription()).thenReturn(true);
	when(discoveryClient.description()).thenReturn("Mocked Service Discovery Client");
	Health expectedHealth = Health
			.status(new Status(Status.UP.getCode(),
					"Mocked Service Discovery Client"))
			.withDetail("services", singletonList("service")).build();

	indicator.onApplicationEvent(new InstanceRegisteredEvent<>(this, null));
	Mono<Health> health = indicator.health();

	assertThat(indicator.getName()).isEqualTo("Mocked Service Discovery Client");
	StepVerifier.create(health).expectNext(expectedHealth).expectComplete().verify();
}
 

public void start() {
	if (!isEnabled()) {
		if (logger.isDebugEnabled()) {
			logger.debug("Discovery Lifecycle disabled. Not starting");
		}
		return;
	}

	// only initialize if nonSecurePort is greater than 0 and it isn't already running
	// because of containerPortInitializer below
	if (!this.running.get()) {
		this.context.publishEvent(
				new InstancePreRegisteredEvent(this, getRegistration()));
		register();
		if (shouldRegisterManagement()) {
			registerManagement();
		}
		this.context.publishEvent(
				new InstanceRegisteredEvent<>(this, getConfiguration()));
		this.running.compareAndSet(false, true);
	}

}
 

private URI registerInstance() {
	// We register the instance by setting static values for the SimpleDiscoveryClient
	// and issuing a
	// InstanceRegisteredEvent that makes sure the instance gets registered.
	SimpleDiscoveryProperties.SimpleServiceInstance serviceInstance = new SimpleDiscoveryProperties.SimpleServiceInstance();
	serviceInstance.setServiceId("Test-Instance");
	serviceInstance.setUri(URI.create("http://localhost:" + this.port));
	serviceInstance.getMetadata().put("management.context-path", "/mgmt");
	this.simpleDiscovery.getInstances().put("Test-Application", singletonList(serviceInstance));

	this.instance.publishEvent(new InstanceRegisteredEvent<>(new Object(), null));

	// To get the location of the registered instances we fetch the instance with the
	// name.
	List<JSONObject> applications = this.webClient.get().uri("/instances?name=Test-Instance")
			.accept(MediaType.APPLICATION_JSON).exchange().expectStatus().isOk().returnResult(JSONObject.class)
			.getResponseBody().collectList().block();
	assertThat(applications).hasSize(1);
	return URI.create("http://localhost:" + this.port + "/instances/" + applications.get(0).optString("id"));
}
 

@Test
public void should_not_throw_error_when_conversion_fails_and_proceed_with_next_instance() {
    when(discovery.getServices()).thenReturn(singletonList("service"));
    when(discovery.getInstances("service")).thenReturn(asList(new DefaultServiceInstance("test-1", "service",
        "localhost",
        80,
        false
    ), new DefaultServiceInstance("error-1", "error", "localhost", 80, false)));
    listener.setConverter(instance -> {
        if (instance.getServiceId().equals("error")) {
            throw new IllegalStateException("Test-Error");
        } else {
            return new DefaultServiceInstanceConverter().convert(instance);
        }
    });

    listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

    StepVerifier.create(registry.getInstances())
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();
}
 

@Test
public void should_register_instance_when_new_service_instance_is_discovered() {
    when(discovery.getServices()).thenReturn(singletonList("service"));
    when(discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1", "service",
        "localhost",
        80,
        false
    )));

    listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

    StepVerifier.create(registry.getInstances()).assertNext(application -> {
        Registration registration = application.getRegistration();
        assertThat(registration.getHealthUrl()).isEqualTo("http://localhost:80/actuator/health");
        assertThat(registration.getManagementUrl()).isEqualTo("http://localhost:80/actuator");
        assertThat(registration.getServiceUrl()).isEqualTo("http://localhost:80/");
        assertThat(registration.getName()).isEqualTo("service");
    }).verifyComplete();


}
 

@Test
public void should_register_instances_when_serviceId_matches_wanted_pattern_and_igonred_pattern() {
    when(discovery.getServices()).thenReturn(asList("service-1", "service", "rabbit-1", "rabbit-2"));
    when(discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1", "service",
        "localhost",
        80,
        false
    )));
    when(discovery.getInstances("service-1")).thenReturn(singletonList(new DefaultServiceInstance("test-1",
        "service-1",
        "localhost",
        80,
        false
    )));

    listener.setServices(singleton("ser*"));
    listener.setIgnoredServices(singleton("service-*"));
    listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

    StepVerifier.create(registry.getInstances())
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();
}
 

@Test
public void should_register_instances_when_serviceId_matches_wanted_pattern() {
    when(discovery.getServices()).thenReturn(asList("service", "rabbit-1", "rabbit-2"));
    when(discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1", "service",
        "localhost",
        80,
        false
    )));

    listener.setServices(singleton("ser*"));
    listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

    StepVerifier.create(registry.getInstances())
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();
}
 

@Test
public void should_not_register_instance_when_serviceId_matches_ignored_pattern() {
    when(discovery.getServices()).thenReturn(asList("service", "rabbit-1", "rabbit-2"));
    when(discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1", "service",
        "localhost",
        80,
        false
    )));

    listener.setIgnoredServices(singleton("rabbit-*"));
    listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

    StepVerifier.create(registry.getInstances())
                .assertNext(a -> assertThat(a.getRegistration().getName()).isEqualTo("service"))
                .verifyComplete();
}
 

@Override
public void start() {
	// only set the port if the nonSecurePort or securePort is 0 and this.port != 0
	if (this.port.get() != 0) {
		if (this.registration.getNonSecurePort() == 0) {
			this.registration.setNonSecurePort(this.port.get());
		}

		if (this.registration.getSecurePort() == 0 && this.registration.isSecure()) {
			this.registration.setSecurePort(this.port.get());
		}
	}

	// only initialize if nonSecurePort is greater than 0 and it isn't already running
	// because of containerPortInitializer below
	if (!this.running.get() && this.registration.getNonSecurePort() > 0) {

		this.serviceRegistry.register(this.registration);

		this.context.publishEvent(new InstanceRegisteredEvent<>(this,
				this.registration.getInstanceConfig()));
		this.running.set(true);
	}
}
 

@Test
public void should_register_instances_when_instanceMetadata_matches_wanted_metadata() {
	when(this.discovery.getServices()).thenReturn(asList("service", "rabbit-1", "rabbit-2"));
	when(this.discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1",
			"service", "localhost", 80, false, Collections.singletonMap("monitoring", "true"))));
	when(this.discovery.getInstances("rabbit-1"))
			.thenReturn(singletonList(new DefaultServiceInstance("rabbit-test-1", "rabbit-1", "localhost", 80,
					false, Collections.singletonMap("monitoring", "false"))));
	when(this.discovery.getInstances("rabbit-2"))
			.thenReturn(singletonList(new DefaultServiceInstance("rabbit-test-1", "rabbit-2", "localhost", 80,
					false, Collections.singletonMap("monitoring", "false"))));

	this.listener.setInstancesMetadata(Collections.singletonMap("monitoring", "true"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances())
			.assertNext((a) -> assertThat(a.getRegistration().getName()).isEqualTo("service")).verifyComplete();
}
 

@Test
public void should_register_instance_when_instanceMetadata_is_not_ignored() {
	when(this.discovery.getServices()).thenReturn(singletonList("service"));
	when(this.discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1",
			"service", "localhost", 80, false, Collections.singletonMap("monitoring", "true"))));

	this.listener.setInstancesMetadata(Collections.singletonMap("monitoring", "false"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances()).verifyComplete();
}
 

@Override
public void onApplicationEvent(InstanceRegisteredEvent<?> event) {
	this.cache = TreeCache.newBuilder(this.curator, this.properties.getRoot())
			.build();
	this.cache.getListenable().addListener(this);
	try {
		this.cache.start();
	}
	catch (Exception e) {
		ReflectionUtils.rethrowRuntimeException(e);
	}
}
 

@Test
public void should_not_register_instance_when_serviceId_matches_ignored_pattern() {
	when(this.discovery.getServices()).thenReturn(asList("service", "rabbit-1", "rabbit-2"));
	when(this.discovery.getInstances("service"))
			.thenReturn(singletonList(new DefaultServiceInstance("test-1", "service", "localhost", 80, false)));

	this.listener.setIgnoredServices(singleton("rabbit-*"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances())
			.assertNext((a) -> assertThat(a.getRegistration().getName()).isEqualTo("service")).verifyComplete();
}
 

@RequestMapping(value = "/upload", method = RequestMethod.POST)
public void upload(MultipartFile file, HttpServletResponse response) throws Exception {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    IOUtils.copy(file.getInputStream(), out);
    Swagger swagger = new SwaggerParser()
            .parse(out.toString("utf-8"));
    out.close();
    String content = objectMapper.writeValueAsString(swagger);
    documentService.save(new Document()
            .setContent(content)
            .setTitle(file.getOriginalFilename()));
    applicationEventPublisher.publishEvent(new InstanceRegisteredEvent<>(SwaggerDocDiscovery.class, swagger));
    response.sendRedirect("/#/document.html");
}
 

@Test
public void should_register_instance_when_serviceId_is_not_ignored() {
	when(this.discovery.getServices()).thenReturn(singletonList("service"));
	when(this.discovery.getInstances("service"))
			.thenReturn(singletonList(new DefaultServiceInstance("test-1", "service", "localhost", 80, false)));

	this.listener.setServices(singleton("notService2"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances()).verifyComplete();
}
 

@Test
public void testHealthIndicatorDescriptionDisabled() {
	then(this.healthContributor).as("healthIndicator was null").isNotNull();
	assertHealth(getHealth("testDiscoveryHealthIndicator"), Status.UNKNOWN);
	assertHealth(getHealth("discoveryClient"), Status.UNKNOWN);

	this.clientHealthIndicator
			.onApplicationEvent(new InstanceRegisteredEvent<>(this, null));

	assertHealth(getHealth("testDiscoveryHealthIndicator"), Status.UNKNOWN);
	Status status = assertHealth(getHealth("discoveryClient"), Status.UP);
	then(status.getDescription()).as("status description was wrong")
			.isEqualTo("TestDiscoveryClient");
}
 

@Test
public void shouldReturnUpStatusWithoutServices() {
	when(discoveryClient.description()).thenReturn("Mocked Service Discovery Client");
	when(discoveryClient.getServices()).thenReturn(Flux.empty());
	Health expectedHealth = Health.status(new Status(Status.UP.getCode(), ""))
			.withDetail("services", emptyList()).build();

	indicator.onApplicationEvent(new InstanceRegisteredEvent<>(this, null));
	Mono<Health> health = indicator.health();

	assertThat(indicator.getName()).isEqualTo("Mocked Service Discovery Client");
	StepVerifier.create(health).expectNext(expectedHealth).expectComplete().verify();
}
 

@Test
public void shouldReturnDownStatusWhenServicesCouldNotBeRetrieved() {
	RuntimeException ex = new RuntimeException("something went wrong");
	Health expectedHealth = Health.down(ex).build();
	when(discoveryClient.getServices()).thenReturn(Flux.error(ex));

	indicator.onApplicationEvent(new InstanceRegisteredEvent<>(this, null));
	Mono<Health> health = indicator.health();

	StepVerifier.create(health).expectNext(expectedHealth).expectComplete()
			.verifyThenAssertThat();
}
 

@Test
public void should_not_register_instance_when_instanceMetadata_is_ignored() {
	when(this.discovery.getServices()).thenReturn(singletonList("service"));
	when(this.discovery.getInstances("service")).thenReturn(singletonList(new DefaultServiceInstance("test-1",
			"service", "localhost", 80, false, Collections.singletonMap("monitoring", "false"))));

	this.listener.setIgnoredInstancesMetadata(Collections.singletonMap("monitoring", "false"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances()).verifyComplete();
}
 

@Test
public void should_not_register_instance_when_serviceId_is_ignored() {
	when(this.discovery.getServices()).thenReturn(singletonList("service"));
	when(this.discovery.getInstances("service"))
			.thenReturn(singletonList(new DefaultServiceInstance("test-1", "service", "localhost", 80, false)));

	this.listener.setIgnoredServices(singleton("service"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances()).verifyComplete();
}
 

@Test
public void should_register_instances_when_serviceId_matches_wanted_pattern() {
	when(this.discovery.getServices()).thenReturn(asList("service", "rabbit-1", "rabbit-2"));
	when(this.discovery.getInstances("service"))
			.thenReturn(singletonList(new DefaultServiceInstance("test-1", "service", "localhost", 80, false)));

	this.listener.setServices(singleton("ser*"));
	this.listener.onInstanceRegistered(new InstanceRegisteredEvent<>(new Object(), null));

	StepVerifier.create(this.registry.getInstances())
			.assertNext((a) -> assertThat(a.getRegistration().getName()).isEqualTo("service")).verifyComplete();
}
 

@Override
public void start() {
    if (!isEnabled()) {
        return;
    }
    if (running.compareAndSet(false, true)) {
        register();
        getContext().publishEvent(new InstanceRegisteredEvent<>(this,
                getConfiguration()));
    }
}
 

@Test
public void onInstanceRegisteredEvent() {
	ApplicationEventPublisher publisher = mock(ApplicationEventPublisher.class);
	RouteRefreshListener listener = new RouteRefreshListener(publisher);

	listener.onApplicationEvent(new InstanceRegisteredEvent<>(this, new Object()));

	verify(publisher).publishEvent(any(RefreshRoutesEvent.class));
}
 

@Override
public void start() {
	this.serviceRegistry.register(this.registration);

	this.context.publishEvent(
			new InstanceRegisteredEvent<>(this, this.registration.getProperties()));
	this.running.set(true);
}