org.springframework.boot.actuate.endpoint.annotation.Selector Java Examples

@WriteOperation
public Mono<String> operate(@Selector String action) {
    if ("online".equalsIgnoreCase(action)) {
        this.rsocketServiceStatus = AppStatusEvent.STATUS_SERVING;
        return sendAppStatus(this.rsocketServiceStatus).thenReturn("Succeed to register RSocket services on brokers!");
    } else if ("offline".equalsIgnoreCase(action)) {
        this.rsocketServiceStatus = AppStatusEvent.STATUS_OUT_OF_SERVICE;
        return sendAppStatus(this.rsocketServiceStatus).thenReturn("Succeed to unregister RSocket services on brokers!");
    } else if ("shutdown".equalsIgnoreCase(action)) {
        this.rsocketServiceStatus = AppStatusEvent.STATUS_STOPPED;
        return sendAppStatus(this.rsocketServiceStatus)
                .thenReturn("Succeed to unregister RSocket services on brokers! Please wait almost 60 seconds to shutdown the Spring Boot App!");
    } else if ("refreshUpstreams".equalsIgnoreCase(action)) {
        Collection<UpstreamCluster> allClusters = this.upstreamManager.findAllClusters();
        for (UpstreamCluster upstreamCluster : allClusters) {
            upstreamCluster.getLoadBalancedRSocket().refreshUnHealthyUris();
        }
        return Mono.just("Begin to refresh unHealthy upstream clusters now!");
    } else {
        return Mono.just("Unknown action, please use online, offline and shutdown");
    }
}
 

@WriteOperation
public void changeState(@Selector String name, State state) {
	Binding<?> binding = BindingsEndpoint.this.locateBinding(name);
	if (binding != null) {
		switch (state) {
		case STARTED:
			binding.start();
			break;
		case STOPPED:
			binding.stop();
			break;
		case PAUSED:
			binding.pause();
			break;
		case RESUMED:
			binding.resume();
			break;
		default:
			break;
		}
	}
}
 

@WriteOperation
public CircuitBreakerUpdateStateResponse updateCircuitBreakerState(@Selector String name, UpdateState updateState) {
    final CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker(name);
    final String message = "%s state has been changed successfully";
    switch (updateState) {
        case CLOSE:
            circuitBreaker.transitionToClosedState();
            return createCircuitBreakerUpdateStateResponse(name, circuitBreaker.getState().toString(), String.format(message, name));
        case FORCE_OPEN:
            circuitBreaker.transitionToForcedOpenState();
            return createCircuitBreakerUpdateStateResponse(name, circuitBreaker.getState().toString(), String.format(message, name));
        case DISABLE:
            circuitBreaker.transitionToDisabledState();
            return createCircuitBreakerUpdateStateResponse(name, circuitBreaker.getState().toString(), String.format(message, name));
        default:
            return createCircuitBreakerUpdateStateResponse(name, circuitBreaker.getState().toString(), "State change value is not supported please use only " + Arrays.toString(UpdateState.values()));
    }

}
 

@WriteOperation
public void busEnvWithDestination(String name, String value,
		@Selector String destination) { // TODO: document params
	Map<String, String> params = Collections.singletonMap(name, value);
	publish(new EnvironmentChangeRemoteApplicationEvent(this, getInstanceId(),
			destination, params));
}
 

@ReadOperation
public RateLimiterEventsEndpointResponse getEventsFilteredByRateLimiterNameAndEventType(
    @Selector String name,
    @Selector String eventType) {
    RateLimiterEvent.Type targetType = RateLimiterEvent.Type.valueOf(eventType.toUpperCase());
    return new RateLimiterEventsEndpointResponse(getRateLimiterEvents(name)
        .filter(event -> event.getEventType() == targetType)
        .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList());
}
 

/**
 * @param name      backend name
 * @param eventType retry event type
 * @return the matching generated retry events
 */
@ReadOperation
public RetryEventsEndpointResponse getEventsFilteredByRetryNameAndEventType(
    @Selector String name, @Selector String eventType) {
    return new RetryEventsEndpointResponse(getRetryEvents(name)
        .filter(
            event -> event.getEventType() == RetryEvent.Type.valueOf(eventType.toUpperCase()))
        .map(RetryEventDTOFactory::createRetryEventDTO).toJavaList());
}
 

@ReadOperation
public TimeLimiterEventsEndpointResponse getEventsFilteredByTimeLimiterNameAndEventType(@Selector String name,
                                                                                        @Selector String eventType) {
    TimeLimiterEvent.Type targetType = TimeLimiterEvent.Type.valueOf(eventType.toUpperCase());
    return new TimeLimiterEventsEndpointResponse(getTimeLimiterEvents(name)
            .filter(event -> event.getEventType() == targetType)
            .map(TimeLimiterEventDTO::createTimeLimiterEventDTO).toJavaList());
}
 

@ReadOperation
public BulkheadEventsEndpointResponse getEventsFilteredByBulkheadNameAndEventType(
    @Selector String bulkheadName, @Selector String eventType) {
    java.util.List<BulkheadEventDTO> response = getBulkheadEvent(bulkheadName)
        .filter(event -> event.getEventType() == BulkheadEvent.Type
            .valueOf(eventType.toUpperCase()))
        .map(BulkheadEventDTOFactory::createBulkheadEventDTO)
        .toJavaList();

    return new BulkheadEventsEndpointResponse(response);
}
 

@ReadOperation
public BulkheadEventsEndpointResponse getEventsFilteredByBulkheadName(
    @Selector String bulkheadName) {
    java.util.List<BulkheadEventDTO> response = getBulkheadEvent(bulkheadName)
        .map(BulkheadEventDTOFactory::createBulkheadEventDTO)
        .toJavaList();

    return new BulkheadEventsEndpointResponse(response);
}
 

@ReadOperation
public CircuitBreakerEventsEndpointResponse getEventsFilteredByCircuitBreakerNameAndEventType(
    @Selector String name, @Selector String eventType) {
    return new CircuitBreakerEventsEndpointResponse(getCircuitBreakerEvents(name)
        .filter(event -> event.getEventType() == CircuitBreakerEvent.Type
            .valueOf(eventType.toUpperCase()))
        .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList());
}
 

@WriteOperation
@Nullable
public CircuitBreakerView transitionTo(@Selector final String name, final CircuitBreaker.State state) {
    final CircuitBreaker breaker = breakers.get(name);

    if (breaker == null) {
        return null;
    }

    transitioner(state).accept(breaker);

    return toView(breaker);
}
 

@ReadOperation
@Nullable
public CircuitBreakerView circuitBreaker(@Selector final String name) {
    final CircuitBreaker breaker = breakers.get(name);

    if (breaker == null) {
        return null;
    }

    return toView(breaker);
}
 

@ReadOperation
public String kafkaStreamsTopology(@Selector String applicationId) {
	if (!StringUtils.isEmpty(applicationId)) {
		final StreamsBuilderFactoryBean streamsBuilderFactoryBean = this.kafkaStreamsRegistry.streamsBuilderFactoryBean(applicationId);
		if (streamsBuilderFactoryBean != null) {
			return streamsBuilderFactoryBean.getTopology().describe().toString();
		}
		else {
			return NO_TOPOLOGY_FOUND_MSG;
		}
	}
	return NO_TOPOLOGY_FOUND_MSG;
}
 

@ReadOperation
public CircuitBreakerEventsEndpointResponse getEventsFilteredByCircuitBreakerName(
    @Selector String name) {
    return new CircuitBreakerEventsEndpointResponse(getCircuitBreakerEvents(name)
        .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList());
}
 

@ReadOperation
public TimeLimiterEventsEndpointResponse getEventsFilteredByTimeLimiterName(@Selector String name) {
    return new TimeLimiterEventsEndpointResponse(getTimeLimiterEvents(name)
            .map(TimeLimiterEventDTO::createTimeLimiterEventDTO).toJavaList());
}
 

@WriteOperation
public void releaseLock(@Selector final String id) {
    this.lightminServerLockManager.releaseLock(id, Boolean.TRUE);
}
 

/**
 * @param name backend name
 * @return the retry events generated for this backend
 */
@ReadOperation
public RetryEventsEndpointResponse getEventsFilteredByRetryName(@Selector String name) {
    return new RetryEventsEndpointResponse(getRetryEvents(name)
        .map(RetryEventDTOFactory::createRetryEventDTO).toJavaList());
}
 

@ReadOperation
public RateLimiterEventsEndpointResponse getEventsFilteredByRateLimiterName(
    @Selector String name) {
    return new RateLimiterEventsEndpointResponse(getRateLimiterEvents(name)
        .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList());
}
 

@ReadOperation
public Binding<?> queryState(@Selector String name) {
	Assert.notNull(name, "'name' must not be null");
	return this.locateBinding(name);
}
 

@WriteOperation
public void busRefreshWithDestination(@Selector String destination) {
	publish(new RefreshRemoteApplicationEvent(this, getInstanceId(), destination));
}
 

@ReadOperation
@ResponseBody
public Resource retriveLogfile(@Selector String requiredLogFileName) throws FileNotFoundException {

    return this.registry.getFile(requiredLogFileName);
}