closes #276

Author: afurer

README.adoc

@@ -269,14 +269,13 @@ public  class B implements ServerInterceptor{
 The starter uses built-in interceptors to implement error handling, Spring `Security`, `Validation` and `Metrics` integration.
 Their order can also be controlled by below properties :
 
+* `grpc.recovery.interceptor-order` (error handling interceptor order, defaults to `Ordered.HIGHEST_PRECEDENCE`)
 * `grpc.security.auth.interceptor-order` ( defaults to `Ordered.HIGHEST_PRECEDENCE+1`)
 * `grpc.validation.interceptor-order` ( defaults to `Ordered.HIGHEST_PRECEDENCE+10`)
 * `grpc.metrics.interceptor-order` ( defaults to `Ordered.HIGHEST_PRECEDENCE+20`)
 
 This gives you the ability to set up the desired order of built-in and your custom interceptors.
 
-Error handling interceptor has the `Ordered.HIGHEST_PRECEDENCE`.
-
 *Keep on reading !!! There is more*
 
 The way grpc interceptor works is that it intercepts the call and returns the server call listener, which in turn can intercept the request message as well, before forwarding it to the actual service call handler :

grpc-spring-boot-starter-demo/src/test/java/org/lognet/springboot/grpc/CustomInterceptorsOrderTest.java

@@ -16,6 +16,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.lognet.springboot.grpc.demo.DemoApp;
+import org.lognet.springboot.grpc.recovery.GRpcExceptionHandlerInterceptor;
 import org.lognet.springboot.grpc.security.AuthClientInterceptor;
 import org.lognet.springboot.grpc.security.AuthHeader;
 import org.lognet.springboot.grpc.security.GrpcSecurity;
@@ -28,6 +29,7 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Import;
 import org.springframework.context.annotation.Lazy;
+import org.springframework.core.Ordered;
 import org.springframework.core.annotation.Order;
 import org.springframework.security.authentication.AuthenticationProvider;
 import org.springframework.security.core.Authentication;
@@ -39,7 +41,9 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -51,9 +55,10 @@
 @SpringBootTest(classes = DemoApp.class,
         properties = {
                 "grpc.security.auth.fail-fast=false", // give validator a chance to run before failing auth
-                "grpc.security.auth.interceptor-order=3", //third
-                "grpc.metrics.interceptor-order=2", //second
-                "grpc.validation.interceptor-order=1" //first
+                "grpc.security.auth.interceptor-order=3",
+                "grpc.metrics.interceptor-order=2",
+                "grpc.validation.interceptor-order=1",
+                "grpc.recovery.interceptor-order=-1"
         }
         ,webEnvironment = SpringBootTest.WebEnvironment.NONE
         )
@@ -76,10 +81,12 @@ enum Interceptor {
     @Before
     public void setUp() throws Exception {
         calledInterceptors.clear();
-        final List<Class<? extends ServerInterceptor>> orderedInterceptorsClasses = Arrays.asList( //according the order define by properties
+        final List<Class<? extends ServerInterceptor>> orderedInterceptorsClasses = Arrays.asList( //according to the order defined by properties
+                GRpcExceptionHandlerInterceptor.class,
                 TestCfg.UserDefinedInterceptor.class,
                 ValidatingInterceptor.class,
                 SecurityInterceptor.class
+
         );
         final List<Class<?>> orderedInterceptors = interceptors
                 .stream()
@@ -89,6 +96,20 @@ public void setUp() throws Exception {
 
         assertThat(orderedInterceptors, Matchers.is(orderedInterceptorsClasses));
 
+        Function<Class<? extends Ordered>,Integer> getOrder = ordered->
+         interceptors
+                .stream()
+                .filter(ordered::isInstance)
+                .map(ordered::cast)
+                .map(Ordered::getOrder)
+                .findFirst()
+                .orElse(null);
+
+        assertThat(getOrder.apply(GRpcExceptionHandlerInterceptor.class),Matchers.is(-1));
+        assertThat(getOrder.apply(ValidatingInterceptor.class),Matchers.is(1));
+        assertThat(getOrder.apply(SecurityInterceptor.class),Matchers.is(3));
+
+
     }
 
     @Test

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/autoconfigure/GRpcAutoConfiguration.java

@@ -14,6 +14,7 @@
 import org.lognet.springboot.grpc.recovery.GRpcServiceAdvice;
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.AutoConfigureOrder;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
@@ -85,8 +86,9 @@ public FailureHandlingSupport failureHandlingSupport(GRpcExceptionHandlerMethodR
     @Bean
     @GRpcGlobalInterceptor
     public GRpcExceptionHandlerInterceptor exceptionHandlerInterceptor(FailureHandlingSupport failureHandlingSupport,
-                                                                       GRpcExceptionHandlerMethodResolver methodResolver) {
-        return new GRpcExceptionHandlerInterceptor(methodResolver,failureHandlingSupport);
+                                                                       GRpcExceptionHandlerMethodResolver methodResolver,
+                                                                       GRpcServerProperties serverProperties) {
+        return new GRpcExceptionHandlerInterceptor(methodResolver,failureHandlingSupport,serverProperties);
     }
 
     @Bean

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/autoconfigure/GRpcServerProperties.java

@@ -34,6 +34,8 @@ public class GRpcServerProperties {
 
     private SecurityProperties security;
 
+    private RecoveryProperties recovery;
+
     private NettyServerProperties nettyServer;
 
     private ConsulProperties consul = new ConsulProperties();
@@ -81,6 +83,11 @@ public Integer getRunningPort() {
 
     }
 
+    @Getter
+    @Setter
+    public static class RecoveryProperties{
+        private Integer interceptorOrder;
+    }
     @Getter
     @Setter
     public static class SecurityProperties {

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/recovery/GRpcExceptionHandlerInterceptor.java

@@ -1,27 +1,27 @@
 package org.lognet.springboot.grpc.recovery;
 
-import io.grpc.Context;
-import io.grpc.ForwardingServerCall;
-import io.grpc.Metadata;
-import io.grpc.ServerCall;
-import io.grpc.ServerCallHandler;
-import io.grpc.ServerInterceptor;
-import io.grpc.Status;
+import io.grpc.*;
 import org.lognet.springboot.grpc.FailureHandlingSupport;
 import org.lognet.springboot.grpc.MessageBlockingServerCallListener;
+import org.lognet.springboot.grpc.autoconfigure.GRpcServerProperties;
 import org.springframework.core.Ordered;
 
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class GRpcExceptionHandlerInterceptor implements ServerInterceptor, Ordered {
-    private static final Context.Key<AtomicBoolean> CALL_IS_CLOSED = Context.key("CALL_IS_CLOSED");
+
     private final GRpcExceptionHandlerMethodResolver methodResolver;
     private final FailureHandlingSupport failureHandlingSupport;
 
+    private Integer order;
 
-    public GRpcExceptionHandlerInterceptor(GRpcExceptionHandlerMethodResolver methodResolver, FailureHandlingSupport failureHandlingSupport) {
+    public GRpcExceptionHandlerInterceptor(GRpcExceptionHandlerMethodResolver methodResolver, FailureHandlingSupport failureHandlingSupport, GRpcServerProperties serverProperties) {
         this.methodResolver = methodResolver;
         this.failureHandlingSupport = failureHandlingSupport;
+        this.order = Optional.ofNullable(serverProperties.getRecovery())
+                .map(GRpcServerProperties.RecoveryProperties::getInterceptorOrder)
+                .orElse(Ordered.HIGHEST_PRECEDENCE);
     }
 
 
@@ -98,7 +98,7 @@ public void onHalfClose() {
 
     @Override
     public int getOrder() {
-        return Ordered.HIGHEST_PRECEDENCE;
+        return order;
     }