Sentinel source code analysis Part 6 - sentinel adapter module Chapter 4 zuul2 gateway

SentinelZuulInboundFilter

• The route extractor extracts resource information for flow restriction
• according to api And other information
• In case of current limiting, return
• structure ZUUL_CTX_SENTINEL_ENTRIES_KEY Information handover OutBound complete sentinel Job site cleaning

public class SentinelZuulInboundFilter extends HttpInboundFilter {
    

    @Override
    public Observable<HttpRequestMessage> applyAsync(HttpRequestMessage request) {
    
         Current limiting execution inlet 
        if (executor != null) {
    
            return Observable.just(request).subscribeOn(Schedulers.from(executor)).flatMap(this::apply);
        } else {
    
            return Observable.just(request).flatMap(this::apply);
        }
    }

     application sentinel Current limiting logic 
    private Observable<HttpRequestMessage> apply(HttpRequestMessage request) {
    
        SessionContext context = request.getContext();
        Deque<EntryHolder> holders = new ArrayDeque<>();
        String routeId = routeExtractor.apply(request);
        String fallBackRoute = routeId;
        try {
    
             Pick up the routing id
            if (StringUtil.isNotBlank(routeId)) {
    
                 structure context
                ContextUtil.enter(GATEWAY_CONTEXT_ROUTE_PREFIX + routeId);
                 Execute current limiting logic 
                doSentinelEntry(routeId, RESOURCE_MODE_ROUTE_ID, request, holders);
            }
             Extract matching api Information 
            Set<String> matchingApis = pickMatchingApiDefinitions(request);
            if (!matchingApis.isEmpty() && ContextUtil.getContext() == null) {
    
                ContextUtil.enter(SentinelZuul2Constants.ZUUL_DEFAULT_CONTEXT);
            }
             Current limiting interception 
            for (String apiName : matchingApis) {
    
                fallBackRoute = apiName;
                doSentinelEntry(apiName, RESOURCE_MODE_CUSTOM_API_NAME, request, holders);
            }
            return Observable.just(request);
        } catch (BlockException t) {
    
             Current limiting occurs 
            context.put(SentinelZuul2Constants.ZUUL_CTX_SENTINEL_BLOCKED_FLAG, Boolean.TRUE);
            context.put(SentinelZuul2Constants.ZUUL_CTX_SENTINEL_FALLBACK_ROUTE, fallBackRoute);
            if (fastError) {
    
                context.setShouldSendErrorResponse(true);
                context.setErrorEndpoint(blockedEndpointName);
            } else {
    
                context.setEndpoint(blockedEndpointName);
            }
            return Observable.error(t);
        } finally {
    
             Give me how to clear the stack filter entry
            if (!holders.isEmpty()) {
    
                context.put(SentinelZuul2Constants.ZUUL_CTX_SENTINEL_ENTRIES_KEY, holders);
            }
            ContextUtil.exit();
        }
    }

     Execute current limiting logic 
    private void doSentinelEntry(String resourceName, final int resType, HttpRequestMessage input, Deque<EntryHolder> holders) throws BlockException {
    
        Object[] params = paramParser.parseParameterFor(resourceName, input, r -> r.getResourceMode() == resType);
        AsyncEntry entry = SphU.asyncEntry(resourceName, ResourceTypeConstants.COMMON_API_GATEWAY, EntryType.IN, params);
        holders.push(new EntryHolder(entry, params));
    }
}

SentinelZuulOutboundFilter

• adopt Outbound Complete resource cleanup

public class SentinelZuulOutboundFilter extends HttpOutboundFilter {
    

    @Override
    public Observable<HttpResponseMessage> applyAsync(HttpResponseMessage input) {
    
        return Observable.just(apply(input));
    }

    public HttpResponseMessage apply(HttpResponseMessage response) {
    
        SessionContext context = response.getContext();
         non-existent entry Directly respond to 
        if (context.get(SentinelZuul2Constants.ZUUL_CTX_SENTINEL_ENTRIES_KEY) == null) {
    
            return response;
        }
         There is entry Through exit clear entry
        boolean previousBlocked = context.getFilterErrors().stream()
            .anyMatch(e -> BlockException.isBlockException(e.getException()));
        Deque<EntryHolder> holders = (Deque<EntryHolder>) context.get(SentinelZuul2Constants.ZUUL_CTX_SENTINEL_ENTRIES_KEY);
        while (!holders.isEmpty()) {
    
            EntryHolder holder = holders.pop();
            if (!previousBlocked) {
    
                Tracer.traceEntry(context.getError(), holder.getEntry());
                holder.getEntry().exit(1, holder.getParams());
            }
        }
        return response;
    }
}