com.netflix.discovery.EurekaEvent Java Examples

@Inject
public EurekaContainerHealthService(ReadOnlyJobOperations jobOperations, EurekaClient eurekaClient, TitusRuntime titusRuntime) {
    this.jobOperations = jobOperations;
    this.eurekaClient = eurekaClient;
    this.titusRuntime = titusRuntime;

    Flux<EurekaEvent> eurekaCallbacks = ReactorExt.fromListener(
            EurekaEventListener.class,
            eurekaClient::registerEventListener,
            eurekaClient::unregisterEventListener
    );

    this.healthStatuses = Flux.defer(() -> {
        ConcurrentMap<String, ContainerHealthEvent> current = new ConcurrentHashMap<>();
        return Flux.merge(eurekaCallbacks, ReactorExt.toFlux(jobOperations.observeJobs()))
                .flatMap(event -> handleJobManagerOrEurekaStatusUpdate(event, current));
    }).share().compose(ReactorExt.badSubscriberHandler(logger));

}
 

@Override
    public void onEvent(EurekaEvent event) {
//		if(event instanceof CacheRefreshedEvent) {
//			log.info("触发刷新缓存事件[{}]", ((CacheRefreshedEvent) event).getTimestamp());
//		}else if(event instanceof StatusChangeEvent) {
//			log.info("触发状态变更事件,之前状态[{}],当前状态[{}]", ((StatusChangeEvent) event).getPreviousStatus(), ((StatusChangeEvent) event).getStatus());
//		}else {
//			log.info("触发EurekaEvent事件[{}]", event.getClass());
//		}
    }
 

@Override
public void onEvent(EurekaEvent event) {
    if (event instanceof CacheRefreshedEvent) {
        publisher.publishEvent(new EurekaClientLocalCacheRefreshedEvent((CacheRefreshedEvent)event));
    } else if (event instanceof StatusChangeEvent) {
        publisher.publishEvent(new EurekaClientStatusChangeEvent((StatusChangeEvent)event));
    }
}
 

@Override
public synchronized void onEvent(EurekaEvent event) {
    if (event instanceof CacheRefreshedEvent) {
        if (!evictAll && toEvict.isEmpty()) return;
        if (evictAll) {
            serviceCacheEvicts.forEach(ServiceCacheEvict::evictCacheAllService);
            loadBalancerRegistry.values().forEach(DynamicServerListLoadBalancer::updateListOfServers);
            evictAll = false;
        } else {
            toEvict.forEach(ServiceRef::evict);
            toEvict.clear();
        }
        loadBalancerRegistry.values().forEach(DynamicServerListLoadBalancer::updateListOfServers);
    }
}
 

@Test
void givenMockedEvent_whenOnEvent_thenCallProcess() {
    EurekaEvent event = mock(EurekaEvent.class);
    MetadataProcessor metadataProcessor = new RibbonMetadataProcessor(mock(EurekaApplications.class));
    MetadataProcessor spyProcessor = spy(metadataProcessor);
    spyProcessor.onEvent(event);

    verify(spyProcessor, times(1)).process(any());
}
 

private Flux<ContainerHealthEvent> handleJobManagerOrEurekaStatusUpdate(Object event, ConcurrentMap<String, ContainerHealthEvent> state) {
    if (event instanceof JobManagerEvent) {
        return handleJobManagerEvent((JobManagerEvent) event, state);
    }
    if (event instanceof EurekaEvent) {
        return handleEurekaEvent((EurekaEvent) event, state);
    }
    return Flux.empty();
}
 

private Flux<ContainerHealthEvent> handleEurekaEvent(EurekaEvent event, ConcurrentMap<String, ContainerHealthEvent> state) {
    if (!(event instanceof CacheRefreshedEvent)) {
        return Flux.empty();
    }

    List<Pair<Job, List<Task>>> allJobsAndTasks = jobOperations.getJobsAndTasks();
    List<Task> allTasks = new ArrayList<>();
    List<ContainerHealthEvent> events = new ArrayList<>();

    allJobsAndTasks.forEach(jobAndTasks -> {
        jobAndTasks.getRight().forEach(task -> {
            handleTaskStateUpdate(jobAndTasks.getLeft(), task, state).ifPresent(events::add);
            allTasks.add(task);
        });
    });

    // Cleanup, in case we have stale entries.
    Set<String> unknownTaskIds = CollectionsExt.copyAndRemove(state.keySet(), allTasks.stream().map(Task::getId).collect(Collectors.toSet()));
    unknownTaskIds.forEach(taskId -> {
        state.remove(taskId);

        // Assume the task was terminated.
        ContainerHealthStatus terminatedStatus = ContainerHealthStatus.newBuilder()
                .withTaskId(taskId)
                .withTimestamp(titusRuntime.getClock().wallTime())
                .withState(ContainerHealthState.Terminated)
                .withReason("terminated")
                .build();

        events.add(ContainerHealthUpdateEvent.healthChanged(terminatedStatus));
    });

    return Flux.fromIterable(events);
}
 

@Override
public void onEvent(EurekaEvent event) {
    log.debug("接收到eureka事件:{}, 刷新缓存的server list", event);
    reload();
}
 

@Override
public void onEvent(EurekaEvent event) {
    process(getApplications());
}
 

@Override
public void onEvent(EurekaEvent event) {
    if (event instanceof CacheRefreshedEvent) {
        refreshAgentDiscoveryStatus();
    }
}
 

@Override
public void onEvent(EurekaEvent event) {
    if (event instanceof CacheRefreshedEvent) {
        refreshAddressCache();
    }
}
 

@Override
public void onEvent(EurekaEvent event) {
    if (event instanceof CacheRefreshedEvent) {
        refresh();
    }
}
 

protected void refreshServerList(final EurekaEvent event) {
//        ReflectUtils.invokeMethod("fireEvent", discoveryClient, event);
    }