下面列出了org.springframework.boot.actuate.endpoint.annotation.ReadOperation#org.springframework.boot.actuate.endpoint.annotation.Selector 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@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 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 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;
}
}
}
@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
@Nullable
public CircuitBreakerView circuitBreaker(@Selector final String name) {
final CircuitBreaker breaker = breakers.get(name);
if (breaker == null) {
return null;
}
return toView(breaker);
}
@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
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());
}
@ReadOperation
public BulkheadEventsEndpointResponse getEventsFilteredByBulkheadName(
@Selector String bulkheadName) {
java.util.List<BulkheadEventDTO> response = getBulkheadEvent(bulkheadName)
.map(BulkheadEventDTOFactory::createBulkheadEventDTO)
.toJavaList();
return new BulkheadEventsEndpointResponse(response);
}
@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 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());
}
/**
* @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 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());
}
@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
@ResponseBody
public Resource retriveLogfile(@Selector String requiredLogFileName) throws FileNotFoundException {
return this.registry.getFile(requiredLogFileName);
}
@WriteOperation
public void releaseLock(@Selector final String id) {
this.lightminServerLockManager.releaseLock(id, Boolean.TRUE);
}
@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());
}
/**
* @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));
}