RestClient register ResponseExceptionMapper via Feature

[andycandy-de]

I added a Feature with the @RegisterProvider annotation to a restclient interface. In the Feature I registered a ClientRequestFilter and a ClientResponseFilter which works perfectly fine. But the registration of an ResponseExceptionMapper didn't work.
For my understanding, it should be possible to register a ResponseExceptionMapper via a Feature.

[jamezp]

This is likely better discussed here https://github.com/resteasy/resteasy-microprofile/discussions. That said, yes that should work. Do you have an example of what you're attempting to do?

[andycandy-de]

Thank you for the quick response. You are totally right. Should I post my question there?
I was looking for a easy implementation to request and cache an access token. Sadly I didn't find such feature in the microprofile specification. So I tried to implement it myself with filtes and exception mappers.

ServiceREST.java

@RegisterRestClient(baseUri = "http://localhost:4567/api")
@RegisterProvider(AuthorizationFeature.class)
@Retry(retryOn = RetryException.class, maxRetries = 1)
public interface ServiceREST {

    @GET
    @Path("test")
    String test() throws RetryException;
}

AuthorizationFeature.java

@ApplicationScoped
public class AuthorizationFeature implements Feature {

    private String currentToken;
    private final Object currentTokenLock = new Object();

    @Inject
    @RestClient
    AuthorizationREST authorizationREST;

    @Override
    public boolean configure(FeatureContext featureContext) {

        featureContext.register(clientRequestFilter((clientRequestContext) -> {
            try {
                final String token = getOrRequestCurrentToken();
                clientRequestContext.setProperty("TOKEN", token);
                clientRequestContext.getHeaders().add("Authorization", "Bearer " + token);
            }
            catch (WebApplicationException e) {
                final Response r = Response.fromResponse(e.getResponse())
                        .header("REQUEST_TOKEN_ERROR", "Unable to request Token")
                        .build();

                clientRequestContext.abortWith(r);
            }
        }));

        featureContext.register(clientResponseFilter((clientRequestContext, clientResponseContext) -> {
            if (clientResponseContext.getHeaderString("REQUEST_TOKEN_ERROR") != null) {
                clientResponseContext.getHeaders().add("ALLOW_RETRY", "FALSE");
            }
            else if (clientResponseContext.getStatus() == 401) {
                resetInvalidToken(clientRequestContext.getProperty("TOKEN").toString());
                clientResponseContext.getHeaders().add("ALLOW_RETRY", "TRUE");
            }
        }));

        featureContext.register(new ResponseExceptionMapper<RetryException>() {
            @Override
            public RetryException toThrowable(Response response) {
                return new RetryException();
            }

            @Override
            public boolean handles(int status, MultivaluedMap<String, Object> headers) {
                return status == 401 && "TRUE".equals(headers.get("ALLOW_RETRY"));
            }
        });

        return true;
    }

    protected ClientRequestFilter clientRequestFilter(ClientRequestFilter clientRequestFilter) {
        return clientRequestFilter;
    }

    protected ClientResponseFilter clientResponseFilter(ClientResponseFilter clientResponseFilter) {
        return clientResponseFilter;
    }

    public String getOrRequestCurrentToken() {
        String token = currentToken;
        if (token == null) {
            synchronized (currentTokenLock) {
                if (currentToken == null) {
                    currentToken = authorizationREST.token();
                }
                token = currentToken;
                if (token == null) {
                    throw new RuntimeException("Token is null!");
                }
            }
        }
        return token;
    }

    public void resetInvalidToken(String invalidToken) {
        if (invalidToken.equals(currentToken)) {
            synchronized (currentTokenLock) {
                if (invalidToken.equals(currentToken)) {
                    currentToken = null;
                }
            }
        }
    }
}

The problem is that the ResponseExceptionMapper is not registered. In my example AuthorizationREST is another restclient to request an access token.

[jamezp]

Something does seem odd here. One workaround is to register the ResponseExceptionMapper itself with @RegisterProvider. Feel free to file an issue at https://github.com/resteasy/resteasy-microprofile/issues. I'm not sure if the bug is in RESTEasy or RESTEasy MicroProfile, but that would be the place to start.

[andycandy-de]

@RegisterProviders({
    @RegisterProvider(AuthorizationFeature.class),
    @RegisterProvider(AuthorizationExceptionMapper.class)
})

It works if I define the exception mapper with the RegisterProvider annotation. But I ll open an issue. I think it should be possible to register the exceptionmapper with the feature definition, which would be a nicer solution.

Thank you for your help.