Hi,

i have some concurrency problems with using the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
We are using springbootadmin to visit / visualize the actuator endpoints our springboot-apps.
springbootadmin uses WebClient to crawl the actuator endpoints available and their status.

Out springboot-apps are protected with the oauth2 resource-server. So springbootadmin uses client credentials flow to acquire a token from our IDP.
The token is attached to every crawling request with the following InstanceExchangeFilterFunction (springbootadmin specific equivalent to ExchangeFilterFunction):

@Component
public class AppTokenCrawlerInstanceExchangeFilterFunction implements InstanceExchangeFilterFunction {
	private final ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	private final OAuth2AuthorizeRequest authorizeRequestCrawler = OAuth2AuthorizeRequest
		.withClientRegistrationId("app-token-crawler")
		.principal("springbootadmin-crawler")
		.build();

	public AppTokenCrawlerInstanceExchangeFilterFunction(ReactiveOAuth2AuthorizedClientManager authorizedClientManager) {
		this.authorizedClientManager = authorizedClientManager;
	}

	@NonNull
	@Override
	public Mono<ClientResponse> filter(@NonNull Instance instance,
									   @NonNull ClientRequest request,
									   @NonNull ExchangeFunction next) {
		return Mono.just(request).flatMap(r -> {
			if (SecurityContextHolder.getContext().getAuthentication() == null) { // Crawler should only be used if now user is calling springbootadmin
				return authorizedClientManager.authorize(authorizeRequestCrawler)
					.map(oAuth2AuthorizedClient -> oAuth2AuthorizedClient.getAccessToken().getTokenValue())
					.map(accessToken -> ClientRequest.from(request).headers(headers -> headers.setBearerAuth(accessToken)).build());
			}
			return Mono.just(r);
		}).flatMap(next::exchange);
	}
}

(

The access token has a lifetime of 5 minutes. When the token expires (1 minute before) the access token is replaced by the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
The problem is that more or less twenty requests are simultaneously fired. If the token expires in that moment, the IDPs token endpoint is not called once but in worse case 20 times.

Is the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager not designed for multithreading?

Hi,

i have some concurrency problems with using the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
We are using springbootadmin to visit / visualize the actuator endpoints of our springboot-apps.
springbootadmin uses WebClient to crawl the actuator endpoints available and their status.

Out springboot-apps are protected with the oauth2 resource-server. So springbootadmin uses client credentials flow to acquire a token from our IDP.
The token is attached to every crawling request with the following InstanceExchangeFilterFunction (springbootadmin specific equivalent to ExchangeFilterFunction):

@Component
public class AppTokenCrawlerInstanceExchangeFilterFunction implements InstanceExchangeFilterFunction {
	private final ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	private final OAuth2AuthorizeRequest authorizeRequestCrawler = OAuth2AuthorizeRequest
		.withClientRegistrationId("app-token-crawler")
		.principal("springbootadmin-crawler")
		.build();

	public AppTokenCrawlerInstanceExchangeFilterFunction(ReactiveOAuth2AuthorizedClientManager authorizedClientManager) {
		this.authorizedClientManager = authorizedClientManager;
	}

	@NonNull
	@Override
	public Mono<ClientResponse> filter(@NonNull Instance instance,
									   @NonNull ClientRequest request,
									   @NonNull ExchangeFunction next) {
		return Mono.just(request).flatMap(r -> {
			if (SecurityContextHolder.getContext().getAuthentication() == null) { // Crawler should only be used if now user is calling springbootadmin
				return authorizedClientManager.authorize(authorizeRequestCrawler)
					.map(oAuth2AuthorizedClient -> oAuth2AuthorizedClient.getAccessToken().getTokenValue())
					.map(accessToken -> ClientRequest.from(request).headers(headers -> headers.setBearerAuth(accessToken)).build());
			}
			return Mono.just(r);
		}).flatMap(next::exchange);
	}
}

(

The access token has a lifetime of 5 minutes. When the token expires (1 minute before) the access token is replaced by the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
The problem is that more or less twenty requests are simultaneously fired. If the token expires in that moment, the IDPs token endpoint is not called once but in worse case 20 times.

Is the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager not designed for multithreading?

Hi,

i have some concurrency problems with using the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
We are using springbootadmin to visit / visualize the actuator endpoints of our springboot-apps.
springbootadmin uses WebClient to crawl the actuator endpoints available and their status.

The springboot-apps are protected with the oauth2 resource-server. So springbootadmin uses client credentials flow to acquire a token from our IDP.
The token is attached to every crawling request with the following InstanceExchangeFilterFunction (springbootadmin specific equivalent to ExchangeFilterFunction):

@Component
public class AppTokenCrawlerInstanceExchangeFilterFunction implements InstanceExchangeFilterFunction {
	private final ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	private final OAuth2AuthorizeRequest authorizeRequestCrawler = OAuth2AuthorizeRequest
		.withClientRegistrationId("app-token-crawler")
		.principal("springbootadmin-crawler")
		.build();

	public AppTokenCrawlerInstanceExchangeFilterFunction(ReactiveOAuth2AuthorizedClientManager authorizedClientManager) {
		this.authorizedClientManager = authorizedClientManager;
	}

	@NonNull
	@Override
	public Mono<ClientResponse> filter(@NonNull Instance instance,
									   @NonNull ClientRequest request,
									   @NonNull ExchangeFunction next) {
		return Mono.just(request).flatMap(r -> {
			if (SecurityContextHolder.getContext().getAuthentication() == null) { // Crawler should only be used if now user is calling springbootadmin
				return authorizedClientManager.authorize(authorizeRequestCrawler)
					.map(oAuth2AuthorizedClient -> oAuth2AuthorizedClient.getAccessToken().getTokenValue())
					.map(accessToken -> ClientRequest.from(request).headers(headers -> headers.setBearerAuth(accessToken)).build());
			}
			return Mono.just(r);
		}).flatMap(next::exchange);
	}
}

(

The access token has a lifetime of 5 minutes. When the token expires (1 minute before) the access token is replaced by the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
The problem is that more or less twenty requests are simultaneously fired. If the token expires in that moment, the IDPs token endpoint is not called once but in worse case 20 times.

Is the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager not designed for multithreading?

Hi,

i have some concurrency problems with using the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
We are using springbootadmin to visit / visualize the actuator endpoints of our springboot-apps.
springbootadmin uses WebClient to crawl the actuator endpoints available and their status.

The springboot-apps are protected with the oauth2 resource-server. So springbootadmin uses client credentials flow to acquire a token from our IDP for calling the springboot-apps
The token is attached to every crawling request with the following InstanceExchangeFilterFunction (springbootadmin specific equivalent to ExchangeFilterFunction):

@Component
public class AppTokenCrawlerInstanceExchangeFilterFunction implements InstanceExchangeFilterFunction {
	private final ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	private final OAuth2AuthorizeRequest authorizeRequestCrawler = OAuth2AuthorizeRequest
		.withClientRegistrationId("app-token-crawler")
		.principal("springbootadmin-crawler")
		.build();

	public AppTokenCrawlerInstanceExchangeFilterFunction(ReactiveOAuth2AuthorizedClientManager authorizedClientManager) {
		this.authorizedClientManager = authorizedClientManager;
	}

	@NonNull
	@Override
	public Mono<ClientResponse> filter(@NonNull Instance instance,
									   @NonNull ClientRequest request,
									   @NonNull ExchangeFunction next) {
		return Mono.just(request).flatMap(r -> {
			if (SecurityContextHolder.getContext().getAuthentication() == null) { // Crawler should only be used if now user is calling springbootadmin
				return authorizedClientManager.authorize(authorizeRequestCrawler)
					.map(oAuth2AuthorizedClient -> oAuth2AuthorizedClient.getAccessToken().getTokenValue())
					.map(accessToken -> ClientRequest.from(request).headers(headers -> headers.setBearerAuth(accessToken)).build());
			}
			return Mono.just(r);
		}).flatMap(next::exchange);
	}
}

(

The access token has a lifetime of 5 minutes. When the token expires (1 minute before) the access token is replaced by the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
The problem is that more or less twenty requests are simultaneously fired. If the token expires in that moment, the IDPs token endpoint is not called once but in worse case 20 times.

Is the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager not designed for multithreading?

Hi,

i have some concurrency problems with using the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
We are using springbootadmin to visit / visualize the actuator endpoints of our springboot-apps.
springbootadmin uses WebClient to crawl the actuator endpoints available and their status.

The springboot-apps are protected with the oauth2 resource-server. So springbootadmin uses client credentials flow to acquire a token from our IDP for calling the springboot-apps
The token is attached to every crawling request with the following InstanceExchangeFilterFunction (springbootadmin specific equivalent to ExchangeFilterFunction):

@Component
public class AppTokenCrawlerInstanceExchangeFilterFunction implements InstanceExchangeFilterFunction {
	private final ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	private final OAuth2AuthorizeRequest authorizeRequestCrawler = OAuth2AuthorizeRequest
		.withClientRegistrationId("app-token-crawler")
		.principal("springbootadmin-crawler")
		.build();

	public AppTokenCrawlerInstanceExchangeFilterFunction(ReactiveOAuth2AuthorizedClientManager authorizedClientManager) {
		this.authorizedClientManager = authorizedClientManager;
	}

	@NonNull
	@Override
	public Mono<ClientResponse> filter(@NonNull Instance instance,
									   @NonNull ClientRequest request,
									   @NonNull ExchangeFunction next) {
		return Mono.just(request).flatMap(r -> {
			if (SecurityContextHolder.getContext().getAuthentication() == null) { // Crawler should only be used if now user is calling springbootadmin
				return authorizedClientManager.authorize(authorizeRequestCrawler)
					.map(oAuth2AuthorizedClient -> oAuth2AuthorizedClient.getAccessToken().getTokenValue())
					.map(accessToken -> ClientRequest.from(request).headers(headers -> headers.setBearerAuth(accessToken)).build());
			}
			return Mono.just(r);
		}).flatMap(next::exchange);
	}
}

The access token has a lifetime of 5 minutes. When the token expires (1 minute before) the access token is replaced by the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager.
The problem is that more or less twenty requests are simultaneously fired. If the token expires in that moment, the IDPs token endpoint is not called once but in worse case 20 times.

Is the AuthorizedClientServiceReactiveOAuth2AuthorizedClientManager not designed for multithreading?