org.springframework.cloud.netflix.eureka.server.event.EurekaInstanceRegisteredEvent Java Examples

/**
 * Translates service instance Eureka metadata from older versions to the current version
 */
@EventListener
public void listen(EurekaInstanceRegisteredEvent event) {
    final InstanceInfo instanceInfo = event.getInstanceInfo();
    final Map<String, String> metadata = instanceInfo.getMetadata();
    final String serviceId = EurekaUtils.getServiceIdFromInstanceId(instanceInfo.getInstanceId());

    metadataTranslationService.translateMetadata(serviceId, metadata);
    metadataDefaultsService.updateMetadata(serviceId, metadata);

    if (StringUtils.equalsIgnoreCase(GatewayNotifier.GATEWAY_SERVICE_ID, serviceId)) {
        /**
         * meanwhile gateway was down, another Gateway could receive logout, those invalidated credentials should
         * be distributed to this new Gateway
         */
        gatewayNotifier.distributeInvalidatedCredentials(instanceInfo.getInstanceId());
    }
    // ie. new instance can have different authentication (than other one), this is reason to evict caches on gateway
    gatewayNotifier.serviceUpdated(serviceId, instanceInfo.getInstanceId());
}
 

@Test
public void testRegister() throws Exception {
	// creating instance info
	final LeaseInfo leaseInfo = getLeaseInfo();
	final InstanceInfo instanceInfo = getInstanceInfo(APP_NAME, HOST_NAME, INSTANCE_ID, PORT, leaseInfo);
	// calling tested method
	instanceRegistry.register(instanceInfo, false);
	// event of proper type is registered
	assertEquals(1, this.testEvents.applicationEvents.size());
	assertTrue(this.testEvents.applicationEvents.get(0) instanceof EurekaInstanceRegisteredEvent);
	// event details are correct
	final EurekaInstanceRegisteredEvent registeredEvent =
			(EurekaInstanceRegisteredEvent) (this.testEvents.applicationEvents.get(0));
	assertEquals(instanceInfo, registeredEvent.getInstanceInfo());
	assertEquals(leaseInfo.getDurationInSecs(), registeredEvent.getLeaseDuration());
	assertEquals(instanceRegistry, registeredEvent.getSource());
	assertFalse(registeredEvent.isReplication());
}
 

@Test
public void testRegister() throws Exception {
	// creating instance info
	final LeaseInfo leaseInfo = getLeaseInfo();
	final InstanceInfo instanceInfo = getInstanceInfo(APP_NAME, HOST_NAME,
			INSTANCE_ID, PORT, leaseInfo);
	// calling tested method
	instanceRegistry.register(instanceInfo, false);
	// event of proper type is registered
	assertThat(this.testEvents.applicationEvents.size()).isEqualTo(1);
	assertThat(this.testEvents.applicationEvents
			.get(0) instanceof EurekaInstanceRegisteredEvent).isTrue();
	// event details are correct
	final EurekaInstanceRegisteredEvent registeredEvent = (EurekaInstanceRegisteredEvent) (this.testEvents.applicationEvents
			.get(0));
	assertThat(registeredEvent.getInstanceInfo()).isEqualTo(instanceInfo);
	assertThat(registeredEvent.getLeaseDuration())
			.isEqualTo(leaseInfo.getDurationInSecs());
	assertThat(registeredEvent.getSource()).isEqualTo(instanceRegistry);
	assertThat(registeredEvent.isReplication()).isFalse();
}
 

/**
 * 监听eureka实例注册事件，并发送信息给灰度服务器
 *
 * @param event eureka 实例注册事件
 */
@EventListener
public void listenRegistered(EurekaInstanceRegisteredEvent event) {
    com.netflix.appinfo.InstanceInfo instanceInfo = event.getInstanceInfo();
    InstanceStatus instanceStatus = EurekaInstatnceTransformer.toGrayInstanceStatus(instanceInfo.getStatus());
    sendNotice(instanceInfo, instanceStatus, "REGISTERED");
}
 

@Test
public void getServiceId() {
    MetadataTranslationService metadataTranslationService = Mockito.mock(MetadataTranslationService.class);
    MetadataDefaultsService metadataDefaultsService = Mockito.mock(MetadataDefaultsService.class);
    GatewayNotifier gatewayNotifier = mock(GatewayNotifier.class);

    EurekaInstanceRegisteredListener eirl = new EurekaInstanceRegisteredListener(metadataTranslationService, metadataDefaultsService, gatewayNotifier);

    doAnswer(
        x -> {
            assertEquals("serviceName", x.getArgument(0));
            return null;
        }
    ).when(metadataDefaultsService).updateMetadata(anyString(), any());

    final Map<String, String> metadata = new HashMap<>();

    InstanceInfo instanceInfo = mock(InstanceInfo.class);
    when(instanceInfo.getInstanceId()).thenReturn("1:serviceName:2");
    EurekaInstanceRegisteredEvent event = mock(EurekaInstanceRegisteredEvent.class);
    when(event.getInstanceInfo()).thenReturn(instanceInfo);

    eirl.listen(event);

    verify(metadataTranslationService, times(1)).translateMetadata("serviceName", metadata);
    verify(metadataDefaultsService, times(1)).updateMetadata("serviceName", metadata);
    verify(gatewayNotifier, times(1)).serviceUpdated("serviceName", "1:serviceName:2");
}
 

private EurekaInstanceRegisteredEvent createEvent(String instanceId) {
    InstanceInfo instanceInfo = mock(InstanceInfo.class);
    when(instanceInfo.getInstanceId()).thenReturn(instanceId);

    EurekaInstanceRegisteredEvent out = mock(EurekaInstanceRegisteredEvent.class);
    when(out.getInstanceInfo()).thenReturn(instanceInfo);

    return out;
}
 

@Before
public void setUp() {
    mockRegistry = mock(PeerAwareInstanceRegistry.class);
    doAnswer(x -> {
        EurekaInstanceRegisteredEvent event = mock(EurekaInstanceRegisteredEvent.class);
        when(event.getInstanceInfo()).thenReturn(x.getArgument(0));
        eurekaInstanceRegisteredListener.listen(event);
        return mockRegistry;
    }).when(mockRegistry).register(any(), anyBoolean());
    EurekaServerContext mockEurekaServerContext = mock(EurekaServerContext.class);
    when(mockEurekaServerContext.getRegistry()).thenReturn(mockRegistry);
    EurekaServerContextHolder.initialize(mockEurekaServerContext);
}
 

private void handleRegistration(InstanceInfo info, int leaseDuration,
		boolean isReplication) {
	log("register " + info.getAppName() + ", vip " + info.getVIPAddress()
			+ ", leaseDuration " + leaseDuration + ", isReplication "
			+ isReplication);
	publishEvent(new EurekaInstanceRegisteredEvent(this, info, leaseDuration,
			isReplication));
}
 

@Test
public void testDefaultLeaseDurationRegisterEvent() throws Exception {
	// creating instance info
	final InstanceInfo instanceInfo = getInstanceInfo(APP_NAME, HOST_NAME, INSTANCE_ID, PORT, null);
	// calling tested method
	instanceRegistry.register(instanceInfo, false);
	// instance info duration is set to default
	final EurekaInstanceRegisteredEvent registeredEvent =
			(EurekaInstanceRegisteredEvent) (this.testEvents.applicationEvents.get(0));
	assertEquals(LeaseInfo.DEFAULT_LEASE_DURATION,
			registeredEvent.getLeaseDuration());
}
 

private void handleRegistration(InstanceInfo info, int leaseDuration,
		boolean isReplication) {
	log("register " + info.getAppName() + ", vip " + info.getVIPAddress()
			+ ", leaseDuration " + leaseDuration + ", isReplication "
			+ isReplication);
	publishEvent(new EurekaInstanceRegisteredEvent(this, info, leaseDuration,
			isReplication));
}
 

@Test
public void testDefaultLeaseDurationRegisterEvent() throws Exception {
	// creating instance info
	final InstanceInfo instanceInfo = getInstanceInfo(APP_NAME, HOST_NAME,
			INSTANCE_ID, PORT, null);
	// calling tested method
	instanceRegistry.register(instanceInfo, false);
	// instance info duration is set to default
	final EurekaInstanceRegisteredEvent registeredEvent = (EurekaInstanceRegisteredEvent) (this.testEvents.applicationEvents
			.get(0));
	assertThat(registeredEvent.getLeaseDuration())
			.isEqualTo(LeaseInfo.DEFAULT_LEASE_DURATION);
}
 

@EventListener //服务注册事件
public void listen(EurekaInstanceRegisteredEvent event) {
    InstanceInfo instanceInfo = event.getInstanceInfo();
    System.out.println("服务注册事件:"+instanceInfo.getAppName()+":"+instanceInfo.getIPAddr()+":"+instanceInfo.getPort());
}
 

@EventListener(EurekaInstanceRegisteredEvent.class)
public void onEvent(EurekaInstanceRegisteredEvent event) {
	this.applicationEvents.add(event);
}
 

@Override
public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
	return EurekaInstanceRegisteredEvent.class.isAssignableFrom(eventType)
			|| EurekaInstanceCanceledEvent.class.isAssignableFrom(eventType)
			|| EurekaInstanceRenewedEvent.class.isAssignableFrom(eventType);
}