Java ActionFilterChain类代码示例

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public <Request extends ActionRequest, Response extends ActionResponse> void apply(Task task, String action,
        Request request, ActionListener<Response> listener, ActionFilterChain<Request, Response> chain) {
    if (false == action.equals(SearchAction.NAME)) {
        chain.proceed(task, action, request, listener);
        return;
    }
    if (context.getHeader(EXAMPLE_HEADER) != null) {
        throw new IllegalArgumentException("Hurray! Sent the header!");
    }
    String auth = context.getHeader(AUTHORIZATION_HEADER);
    if (auth == null) {
        ElasticsearchSecurityException e = new ElasticsearchSecurityException("Authentication required",
                RestStatus.UNAUTHORIZED);
        e.addHeader("WWW-Authenticate", "Basic realm=auth-realm");
        throw e;
    }
    if (false == REQUIRED_AUTH.equals(auth)) {
        throw new ElasticsearchSecurityException("Bad Authorization", RestStatus.FORBIDDEN);
    }
    chain.proceed(task, action, request, listener);
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public <Request extends ActionRequest, Response extends ActionResponse> void apply(final Task task, final String action,
        final Request request, final ActionListener<Response> listener, final ActionFilterChain<Request, Response> chain) {
    if (logger.isDebugEnabled()) {
        logger.debug("node: " + nodeName() + ", action: " + action + ", request: " + request);
    }
    final Supplier<Response> executor = getExecutor(task, action, request);
    if (executor != null) {
        indexingProxyService.write(request, ActionListener.wrap(res -> {
            listener.onResponse(executor.get());
        }, listener::onFailure));
    } else if (indexingProxyService.isRenewAction(action)) {
        indexingProxyService.renew(ActionListener.wrap(res -> {
            chain.proceed(task, action, request, listener);
        }, listener::onFailure));
    } else {
        chain.proceed(task, action, request, listener);
    }
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void apply(final Task task, final String action,
        @SuppressWarnings("rawtypes") final ActionRequest request,
        @SuppressWarnings("rawtypes") final ActionListener listener,
        final ActionFilterChain chain) {
    if (!DeleteSnapshotAction.NAME.equals(action)) {
        chain.proceed(task, action, request, listener);
    } else {
        final DeleteSnapshotRequest deleteSnapshotRequest = (DeleteSnapshotRequest) request;
        dictionarySnapshotService.deleteDictionarySnapshot(
                deleteSnapshotRequest.repository(),
                deleteSnapshotRequest.snapshot(),
                new ActionListener<Void>() {

                    @Override
                    public void onResponse(Void response) {
                        chain.proceed(task, action, request, listener);
                    }

                    @Override
                    public void onFailure(Throwable e) {
                        listener.onFailure(e);
                    }
                });
    }
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void apply(final String action, final ActionResponse response,
        @SuppressWarnings("rawtypes") final ActionListener listener,
        final ActionFilterChain chain) {
    if (!CreateSnapshotAction.NAME.equals(action) || !clusterService.state().nodes().localNodeMaster()) {
        chain.proceed(action, response, listener);
    } else {
        final CreateSnapshotResponse createSnapshotResponse = (CreateSnapshotResponse) response;
        final SnapshotInfo snapshotInfo = createSnapshotResponse
                .getSnapshotInfo();
        dictionarySnapshotService.createDictionarySnapshot(
                ((ActionListenerWrapper<?>) listener).getSnapshotId(),
                snapshotInfo, new ActionListener<Void>() {

                    @Override
                    public void onResponse(final Void resp) {
                        chain.proceed(action, response, listener);
                    }

                    @Override
                    public void onFailure(final Throwable e) {
                        listener.onFailure(e);
                    }
                });
    }
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
public void apply(Task task, String action, ActionRequest request,
                  ActionListener listener, ActionFilterChain chain) {
    try {
        // authentication
        ActionSourceType sourceType = ActionSourceType.getActionSourceType(action);
        LoginUserContext userInfoContext = request.getHeader(LoginUserContext.USER_INFO_KEY);
        // authentication and authorization only happened on the proxy node(the node user connected to)
        // for sql, the authorized value will be set to true
        // for rest,
        if (sourceType == ActionSourceType.OTHERS
                && userInfoContext != null
                && !userInfoContext.authorized()
                && userInfoContext.getUserProperty() != null) {
            AuthResult authResult = authService.authenticate(request, action);
            if (authResult.getStatus() != RestStatus.OK) {
                throw new NoPermissionException(authResult.getStatus().getStatus(), authResult.getMessage());
            }
            userInfoContext.setAuthorized(true);
        }
        // filter other tenants in clusterState if necessary
        AuthService.setStateFilter(request, action);
        chain.proceed(task, action, request, listener);
    } catch (Throwable t) {
        logger.error("errors while check auth", t);
        throw t;
    }
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public <Request extends ActionRequest, Response extends ActionResponse> void apply(Task task, String action, Request request,
		ActionListener<Response> listener, ActionFilterChain<Request, Response> chain) {
	// TODO Auto-generated method stub
	log(1, "apply... " + action);

	boolean usingAuth = auther.isUsing();
	boolean usinglog = actionLogger.isUsing();

	if (usingAuth || usinglog) {
		boolean isJavaClient = isJavaClient(task, request);
		boolean isSystemAction = checkSystemAction(task, action);
		boolean isAuthed = false;
		if (!isSystemAction) {
			SpActionFilterUtil.checkRemoteAddress(request, listener);

			isAuthed = usingAuth ? auther.auth(task, action, request, listener, isJavaClient) : true;
			log(1, "remoteAddress:" + request.remoteAddress());

			if(usinglog) {
				actionLogger.log(task, action, request, isAuthed, isJavaClient);
			}
		}

		if (!isAuthed && !isSystemAction) {
			// listener.onResponse();
			// listener.onResponse(new BytesRestResponse(RestStatus.OK, helpString));
			if (!isJavaClient) {
				listener.onFailure(new Exception("the auth is must please do the auth, this message is from sp tools"));
			}

		} else {
			chain.proceed(task, action, request, listener);
		}
	} else {
		chain.proceed(task, action, request, listener);
	}

}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void applySecure(Task task, final String action, final ActionRequest request, final ActionListener listener, final ActionFilterChain chain) {

    if (filterMap.size() == 0) {
        chain.proceed(task, action, request, listener);
        return;
    }

    for (final Iterator<Entry<String, Tuple<List<String>, List<String>>>> it = filterMap.entrySet().iterator(); it.hasNext();) {

        final Entry<String, Tuple<List<String>, List<String>>> entry = it.next();

        final String filterName = entry.getKey();
        final List<String> allowedActions = entry.getValue().v1();
        final List<String> forbiddenActions = entry.getValue().v2();

        request.putInContext("armor." + filterType + "." + filterName + ".allowed_actions", allowedActions);
        request.putInContext("armor." + filterType + "." + filterName + ".forbidden_actions", forbiddenActions);

        if (request.hasInContext("armor_filter") && filterType != null) {
            if (!((List<String>) request.getFromContext("armor_filter")).contains(filterType + ":" + filterName)) {
                ((List<String>) request.getFromContext("armor_filter")).add(filterType + ":" + filterName);
            }
        } else if (filterType != null) {
            final List<String> _filters = new ArrayList<String>();
            _filters.add(filterType + ":" + filterName);
            request.putInContext("armor_filter", _filters);
        }
    }

    chain.proceed(task, action, request, listener);
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public <Request extends ActionRequest, Response extends ActionResponse> void apply(final Task task, final String action, final Request request,
        final ActionListener<Response> listener, final ActionFilterChain<Request, Response> chain) {
    if (!SearchAction.INSTANCE.name().equals(action)) {
        chain.proceed(task, action, request, listener);
        return;
    }

    final SearchRequest searchRequest = (SearchRequest) request;
    final ActionListener<Response> wrappedListener = DynamicRanker.getInstance().wrapActionListener(action, searchRequest, listener);
    chain.proceed(task, action, request, wrappedListener == null ? listener : wrappedListener);
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void apply(final Task task, final String action,
        @SuppressWarnings("rawtypes") final ActionRequest request,
        @SuppressWarnings("rawtypes") final ActionListener listener,
        final ActionFilterChain chain) {
    if (!RestoreSnapshotAction.NAME.equals(action) || !clusterService.state().nodes().localNodeMaster()) {
        chain.proceed(task, action, request, listener);
    } else {
        final RestoreSnapshotRequest restoreSnapshotRequest = (RestoreSnapshotRequest) request;
        dictionaryRestoreService.restoreDictionarySnapshot(
                restoreSnapshotRequest.repository(), restoreSnapshotRequest.snapshot(),
                restoreSnapshotRequest.indices(), new ActionListener<Void>() {

                    @Override
                    public void onResponse(final Void response) {
                        chain.proceed(task, action, request, listener);
                    }

                    @Override
                    public void onFailure(final Throwable e) {
                        if (logger.isDebugEnabled()) {
                            logger.debug(
                                    "Failed to restore dictionaries for {} snapshot in {} repository.",
                                    e, restoreSnapshotRequest.repository(),
                                    restoreSnapshotRequest.snapshot());
                        }
                        listener.onFailure(e);
                    }
                });
    }
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void apply(final String action,
        @SuppressWarnings("rawtypes") final ActionRequest request,
        @SuppressWarnings("rawtypes") final ActionListener listener,
        final ActionFilterChain chain) {
    if (!SearchAction.INSTANCE.name().equals(action)) {
        chain.proceed(action, request, listener);
        return;
    }

    final SearchRequest searchRequest = (SearchRequest) request;
    final Boolean invoked = searchRequest.getHeader(SEARCH_REQUEST_INVOKED);
    if (invoked != null && invoked.booleanValue()) {
        if (queryResultCache.canCache(searchRequest)) {
            @SuppressWarnings({ "rawtypes", "unchecked" })
            final ActionListener cacheListener = queryResultCache
                    .execute(searchRequest, listener, chain);
            if (cacheListener != null) {
                chain.proceed(action, request, cacheListener);
            }
        } else {
            chain.proceed(action, request, listener);
        }
    } else {
        searchRequest.putHeader(SEARCH_REQUEST_INVOKED, Boolean.TRUE);
        chain.proceed(action, request, listener);
    }
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void apply(Task task, String action, ActionRequest request, ActionListener listener,
        ActionFilterChain chain) {
    chain.proceed(task, action, request, listener);
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
public  void apply(String action, ActionResponse response, ActionListener listener, ActionFilterChain chain) {
    chain.proceed(action, response, listener);
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public final void apply(Task task, final String action, final ActionRequest request, final ActionListener listener, final ActionFilterChain chain) {
    log.debug("REQUEST on node {}: {} ({}) from {}", clusterService.localNode().getName(), action, request.getClass(),
            request.remoteAddress() == null ? "INTRANODE" : request.remoteAddress().toString());
    log.debug("Context {}", request.getContext());
    log.debug("Headers {}", request.getHeaders());

    if (settings.getAsBoolean(ConfigConstants.ARMOR_ALLOW_KIBANA_ACTIONS, true) && (action.startsWith("cluster:monitor/") || action.contains("indices:data/read/field_stats"))) {
        chain.proceed(task, action, request, listener);
        return;
    }

    final User restUser = request.getFromContext("armor_authenticated_user", null);

    final boolean restAuthenticated = restUser != null;

    if (restAuthenticated) {
        log.debug("TYPE: rest authenticated request, apply filters");
        applySecure(task, action, request, listener, chain);
        return;
    }

    final boolean intraNodeRequest = request.remoteAddress() == null;

    if (intraNodeRequest) {
        log.debug("TYPE: intra node request, skip filters");
        chain.proceed(task, action, request, listener);
        return;
    }

    final Object authHeader = request.getHeader("armor_authenticated_transport_request");
    boolean interNodeAuthenticated = false;

    if (authHeader != null && authHeader instanceof String) {
        final Object decrypted = SecurityUtil.decryptAnDeserializeObject((String) authHeader, ArmorService.getSecretKey());

        if (decrypted != null && (decrypted instanceof String) && decrypted.equals("authorized")) {
            interNodeAuthenticated = true;
        }

    }

    if (interNodeAuthenticated) {
        log.debug("TYPE: inter node cluster request, skip filters");
        chain.proceed(task, action, request, listener);
        return;
    }

    final Object transportCreds = request.getHeader("armor_transport_creds");
    User authenticatedTransportUser = null;
    boolean transportAuthenticated = false;
    if (transportCreds != null && transportCreds instanceof String
            && settings.getAsBoolean(ConfigConstants.ARMOR_TRANSPORT_AUTH_ENABLED, false)) {

        try {

            final String decodedBasicHeader = new String(DatatypeConverter.parseBase64Binary((String) transportCreds),
                    StandardCharsets.US_ASCII);

            final String username = decodedBasicHeader.split(":")[0];
            final char[] password = decodedBasicHeader.split(":")[1].toCharArray();

            authenticatedTransportUser = backend.authenticate(new AuthCredentials(username, password));
            authorizator.fillRoles(authenticatedTransportUser, new AuthCredentials(authenticatedTransportUser.getName(), null));
            request.putInContext("armor_authenticated_user", authenticatedTransportUser);
        } catch (final Exception e) {
            throw new RuntimeException("Transport authentication failed due to " + e, e);
        }

    }

    transportAuthenticated = authenticatedTransportUser != null;

    if (transportAuthenticated) {
        log.debug("TYPE: transport authenticated request, apply filters");
        applySecure(task, action, request, listener, chain);
        return;
    }

    throw new RuntimeException("Unauthenticated request (SEARCHGUARD_UNAUTH_REQ) for action " + action);
}
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
public abstract void applySecure(Task task, final String action, final ActionRequest request, final ActionListener listener,
final ActionFilterChain chain);
 

import org.elasticsearch.action.support.ActionFilterChain; //导入依赖的package包/类
@Override
public void apply(final String action, final ActionResponse response, final ActionListener listener, final ActionFilterChain chain) {
    chain.proceed(action, response, listener);
}