Examples with IAsyncHandler io.apiman.gateway.engine.async.IAsyncHandler used on opensource projects

Example 1 with IAsyncHandler

use of io.apiman.gateway.engine.async.IAsyncHandler in project apiman by apiman.

the class ApiRequestExecutorImpl method createRequestChain.

/**
 * Creates the chain used to apply policies in order to the api request.
 */
private Chain<ApiRequest> createRequestChain(IAsyncHandler<ApiRequest> requestHandler) {
    RequestChain chain = new RequestChain(policyImpls, context);
    chain.headHandler(requestHandler);
    chain.policyFailureHandler(failure -> {
        // It will likely not have been initialised, so create one.
        if (responseChain == null) {
            // Its response will not be used as we take the failure path only, so we just use an empty lambda.
            responseChain = createResponseChain((ignored) -> {
            });
        }
        responseChain.doFailure(failure);
    });
    chain.policyErrorHandler(policyErrorHandler);
    return chain;
}

Example 2 with IAsyncHandler

use of io.apiman.gateway.engine.async.IAsyncHandler in project apiman by apiman.

the class InMemoryCacheStoreComponent method getBinary.

/**
 * @see io.apiman.gateway.engine.components.ICacheStoreComponent#getBinary(java.lang.String, java.lang.Class, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public <T> void getBinary(String cacheKey, Class<T> type, IAsyncResultHandler<ISignalReadStream<T>> handler) {
    boolean expired = false;
    ISignalReadStream<T> rval;
    Object object;
    IApimanBuffer buffer;
    synchronized (mapMutex) {
        object = objectCache.get(cacheKey);
        if (object != null) {
            Long expiresOn = expireOnMap.get(cacheKey);
            if (System.currentTimeMillis() > expiresOn) {
                expired = true;
            }
        }
        buffer = dataCache.get(cacheKey);
        if (buffer == null) {
            object = null;
        }
    }
    if (object == null) {
        rval = null;
    } else if (expired) {
        synchronized (cacheSizeMutex) {
            synchronized (mapMutex) {
                objectCache.remove(cacheKey);
                expireOnMap.remove(cacheKey);
                dataCache.remove(cacheKey);
                cacheSize -= buffer.length();
            }
        }
        rval = null;
    } else {
        @SuppressWarnings("unchecked") final T head = (T) object;
        final IApimanBuffer data = buffer;
        rval = new ISignalReadStream<T>() {

            IAsyncHandler<IApimanBuffer> bodyHandler;

            IAsyncHandler<Void> endHandler;

            boolean finished = false;

            @Override
            public void bodyHandler(IAsyncHandler<IApimanBuffer> bodyHandler) {
                this.bodyHandler = bodyHandler;
            }

            @Override
            public void endHandler(IAsyncHandler<Void> endHandler) {
                this.endHandler = endHandler;
            }

            @Override
            public T getHead() {
                return head;
            }

            @Override
            public boolean isFinished() {
                return finished;
            }

            @Override
            public void abort(Throwable t) {
                finished = true;
            }

            @Override
            public void transmit() {
                bodyHandler.handle(data);
                endHandler.handle(null);
            }
        };
    }
    handler.handle(AsyncResultImpl.create(rval));
}

Example 3 with IAsyncHandler

use of io.apiman.gateway.engine.async.IAsyncHandler in project apiman by apiman.

the class LDAPIdentityValidator method doValidate.

private void doValidate(final String username, final String password, final ApiRequest request, final IPolicyContext context, final LDAPIdentitySource config, final IAsyncResultHandler<Boolean> handler) {
    final ILdapComponent ldapComponent = context.getComponent(ILdapComponent.class);
    String bindDn = formatDn(config.getDnPattern(), username, request);
    String bindDnPwd = password;
    int port = config.getUri().getPort();
    String scheme = config.getUri().getScheme();
    if (port == -1) {
        if ("ldap".equalsIgnoreCase(scheme)) {
            // $NON-NLS-1$
            port = 389;
        }
        if ("ldaps".equalsIgnoreCase(scheme)) {
            // $NON-NLS-1$
            port = 636;
        }
    }
    final LdapConfigBean ldapConfigBean = new LdapConfigBean();
    ldapConfigBean.setBindDn(bindDn);
    ldapConfigBean.setBindPassword(bindDnPwd);
    ldapConfigBean.setHost(config.getUri().getHost());
    ldapConfigBean.setPort(port);
    ldapConfigBean.setScheme(scheme);
    // Bind as one account, search for other.
    if (config.getBindAs() == LDAPBindAsType.ServiceAccount) {
        ldapConfigBean.setBindDn(formatDn(config.getDnPattern(), config.getCredentials().getUsername(), request));
        ldapConfigBean.setBindPassword(config.getCredentials().getPassword());
        ldapComponent.connect(ldapConfigBean, successHandler(handler, new IAsyncHandler<ILdapClientConnection>() {

            @Override
            public void handle(final ILdapClientConnection connection) {
                String searchBaseDN = formatDn(config.getUserSearch().getBaseDn(), username, request);
                String searchExpr = formatDn(config.getUserSearch().getExpression(), username, request);
                connection.search(searchBaseDN, searchExpr, LdapSearchScope.SUBTREE).setLdapErrorHandler(new IAsyncHandler<LdapException>() {

                    // At the moment it's just generic, but in future we can make better use of it.
                    @Override
                    public void handle(LdapException exception) {
                        handler.handle(AsyncResultImpl.<Boolean>create(exception));
                    }
                }).search(successHandler(handler, new IAsyncHandler<List<ILdapSearchEntry>>() {

                    @Override
                    public void handle(List<ILdapSearchEntry> searchEntries) {
                        handleLdapSearch(connection, searchEntries, config, ldapConfigBean, ldapComponent, context, username, password, handler);
                    }
                }));
            }
        }));
    } else {
        bind(config, ldapConfigBean, ldapComponent, context, new IAsyncResultHandler<ILdapResult>() {

            @Override
            public void handle(IAsyncResult<ILdapResult> result) {
                if (result.isSuccess()) {
                    if (LdapResultCode.isSuccess(result.getResult().getResultCode())) {
                        handler.handle(AsyncResultImpl.create(Boolean.TRUE));
                    } else {
                        // An auth failure
                        handler.handle(AsyncResultImpl.create(Boolean.FALSE));
                    }
                } else {
                    // Unexpected exception
                    handler.handle(AsyncResultImpl.<Boolean>create(result.getError()));
                }
            }
        });
    }
}

Example 4 with IAsyncHandler

use of io.apiman.gateway.engine.async.IAsyncHandler in project apiman by apiman.

the class LDAPIdentityValidator method extractRoles.

private void extractRoles(final ILdapClientConnection connection, final String userDn, final LDAPIdentitySource config, final IPolicyContext context, final IAsyncResultHandler<ILdapResult> resultHandler) {
    final Set<String> roles = new HashSet<>();
    // $NON-NLS-1$
    connection.search(userDn, "(objectClass=*)", LdapSearchScope.SUBTREE).setLdapErrorHandler(new IAsyncHandler<LdapException>() {

        // At the moment it's just generic, but in future we can make better use of it.
        @Override
        public void handle(LdapException exception) {
            resultHandler.handle(AsyncResultImpl.<ILdapResult>create(exception));
        }
    }).search(successHandler(resultHandler, new IAsyncHandler<List<ILdapSearchEntry>>() {

        @Override
        public void handle(List<ILdapSearchEntry> result) {
            // Look through all results (usually should only be 1)
            for (ILdapSearchEntry searchResult : result) {
                // Get membership attribute (if any)
                List<ILdapAttribute> attrs = searchResult.getAttributes();
                try {
                    // Look through all attrs - grab relevant RDNS, for each attribute (e.g. cn)
                    for (ILdapAttribute attr : attrs) {
                        if (attr.getBaseName().equals(config.getMembershipAttribute())) {
                            addRoles(attr);
                        }
                    }
                    context.setAttribute(AuthorizationPolicy.AUTHENTICATED_USER_ROLES, roles);
                    resultHandler.handle(AsyncResultImpl.create(LdapResult.SUCCESS));
                } catch (Exception e) {
                    // Potentially invalid RDN format
                    resultHandler.handle(AsyncResultImpl.<ILdapResult>create(e));
                }
            }
        }

        private void addRoles(ILdapAttribute attr) {
            // Treat value as an RDN
            for (ILdapDn dn : attr.getValuesAsDn()) {
                for (ILdapRdn rdns : dn.getRdns()) {
                    if (rdns.hasAttribute(config.getRolenameAttribute())) {
                        for (String value : rdns.getAttributeValues()) {
                            roles.add(value);
                        }
                    }
                }
            }
        }
    }));
}

Example 5 with IAsyncHandler

use of io.apiman.gateway.engine.async.IAsyncHandler in project apiman by apiman.

the class GatewayServlet method doAction.

/**
 * Generic handler for all types of http actions/verbs.
 * @param req
 * @param resp
 * @param action
 */
protected void doAction(final HttpServletRequest req, final HttpServletResponse resp, String action) {
    // Read the request.
    ApiRequest srequest;
    try {
        srequest = readRequest(req);
        srequest.setType(action);
    } catch (Exception e) {
        writeError(null, resp, e);
        return;
    }
    final CountDownLatch latch = new CountDownLatch(1);
    final ApiRequest finalRequest = srequest;
    // Now execute the request via the apiman engine
    IApiRequestExecutor executor = getEngine().executor(srequest, new IAsyncResultHandler<IEngineResult>() {

        @Override
        public void handle(IAsyncResult<IEngineResult> asyncResult) {
            if (asyncResult.isSuccess()) {
                IEngineResult engineResult = asyncResult.getResult();
                if (engineResult.isResponse()) {
                    try {
                        writeResponse(resp, engineResult.getApiResponse());
                        final ServletOutputStream outputStream = resp.getOutputStream();
                        engineResult.bodyHandler(new IAsyncHandler<IApimanBuffer>() {

                            @Override
                            public void handle(IApimanBuffer chunk) {
                                try {
                                    if (chunk instanceof ByteBuffer) {
                                        byte[] buffer = (byte[]) chunk.getNativeBuffer();
                                        outputStream.write(buffer, 0, chunk.length());
                                    } else {
                                        outputStream.write(chunk.getBytes());
                                    }
                                } catch (IOException e) {
                                    // connection to the back-end API.
                                    throw new RuntimeException(e);
                                }
                            }
                        });
                        engineResult.endHandler(new IAsyncHandler<Void>() {

                            @Override
                            public void handle(Void result) {
                                try {
                                    resp.flushBuffer();
                                } catch (IOException e) {
                                    // connection to the back-end API.
                                    throw new RuntimeException(e);
                                } finally {
                                    latch.countDown();
                                }
                            }
                        });
                    } catch (IOException e) {
                        // this would mean we couldn't get the output stream from the response, so we
                        // need to abort the engine result (which will let the back-end connection
                        // close down).
                        engineResult.abort(e);
                        latch.countDown();
                        throw new RuntimeException(e);
                    }
                } else {
                    writeFailure(finalRequest, resp, engineResult.getPolicyFailure());
                    latch.countDown();
                }
            } else {
                writeError(finalRequest, resp, asyncResult.getError());
                latch.countDown();
            }
        }
    });
    executor.streamHandler(new IAsyncHandler<ISignalWriteStream>() {

        @Override
        public void handle(ISignalWriteStream connectorStream) {
            try {
                final InputStream is = req.getInputStream();
                ByteBuffer buffer = new ByteBuffer(2048);
                int numBytes = buffer.readFrom(is);
                while (numBytes != -1) {
                    connectorStream.write(buffer);
                    numBytes = buffer.readFrom(is);
                }
                connectorStream.end();
            } catch (Throwable e) {
                connectorStream.abort(e);
            }
        }
    });
    executor.execute();
    try {
        latch.await();
    } catch (InterruptedException e) {
    }
}