Java IAsyncResult.isSuccess方法代码示例

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * Verify the session data.
 *
 * @param result    the result of retrieving session data
 * @param sessionId the ID of the session
 * @param request   the service request
 * @param context   the policy context
 * @param config    the policy configuration
 * @return the result of the validation
 */
private ValidationResult verifyResult(IAsyncResult<Session> result, String sessionId, ApiRequest request,
                                      IPolicyContext context, CookieValidateConfigBean config) {

    final ValidationResult validationResult;
    final Session sessionData = result.getResult();

    if (result.isSuccess() && null != sessionData && StringUtils.isNotBlank(sessionData.getSessionId())) {
        validationResult = verifySessionData(sessionData, sessionId, request, context, config);

    } else {
        //noinspection ThrowableResultOfMethodCallIgnored
        if (null != result.getError()) {
            LOGGER.error(MESSAGES.format("ErrorReadingSessionData", sessionId), result.getError());
        }

        // session not present
        validationResult = new ValidationResult(false,
                MESSAGES.format("MissingSessionData", sessionId));
    }

    return validationResult;
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
@Override
    public void handle(IAsyncResult<IHttpClientResponse> result) {
        if (result.isSuccess()) {
            IHttpClientResponse postResponse = result.getResult();
            if ((postResponse.getResponseCode() / 100) == 2) {
                resultHandler.handle(RESULT_OK);
            } else {
                try {
//                  ReportResponse reportResponse = parseReport(postResponse.getBody());
//                  RuntimeException re = new RuntimeException(String.format("Backend report failed. Code: %s, Message: %s",
//                          reportResponse.getErrorCode(), reportResponse.getErrorMessage()));
                    ReportResponse reportResponse = parseReport(postResponse.getBody());
                    resultHandler.handle(AsyncResultImpl.create(reportResponse));
                } catch (Exception e) {
                    RuntimeException re = new RuntimeException("Unable to parse report response", e); // TODO more specific //$NON-NLS-1$
                    resultHandler.handle(AsyncResultImpl.create(re));
                }
            }
        }
    }
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.CachingJdbcRegistry.CachingESRegistry#registerClient(io.apiman.gateway.engine.beans.Client, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void registerClient(Client client, final IAsyncResultHandler<Void> handler) {
    super.registerClient(client, new IAsyncResultHandler<Void>() {
        /**
         * @see io.apiman.gateway.engine.async.IAsyncHandler#handle(java.lang.Object)
         */
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.es.CachingESRegistry#registerClient(io.apiman.gateway.engine.beans.Client, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void registerClient(Client client, final IAsyncResultHandler<Void> handler) {
    super.registerClient(client, new IAsyncResultHandler<Void>() {
        /**
         * @see io.apiman.gateway.engine.async.IAsyncHandler#handle(java.lang.Object)
         */
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * Downloads the plugin via its maven GAV information.  This will first look in the local
 * .m2 directory.  If the plugin is not found there, then it will try to download the
 * plugin from one of the configured remote maven repositories.
 */
protected void downloadPlugin(final PluginCoordinates coordinates, final IAsyncResultHandler<File> handler) {
    if (pluginRepositories.isEmpty()) {
        // Didn't find it - no repositories configured!
        handler.handle(AsyncResultImpl.create((File) null));
        return;
    }

    final Iterator<URI> iterator = pluginRepositories.iterator();
    URI repoUrl = iterator.next();
    final IAsyncResultHandler<File> handler2 = new IAsyncResultHandler<File>() {
        @Override
        public void handle(IAsyncResult<File> result) {
            if (result.isSuccess() && result.getResult() == null && iterator.hasNext()) {
                downloadFromMavenRepo(coordinates, iterator.next(), this);
            } else {
                handler.handle(result);
            }
        }
    };
    downloadFromMavenRepo(coordinates, repoUrl, handler2);
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
@Override
public void flush(IAsyncResult<ReportResponse> reportResponse) {
    if (reportResponse.isSuccess()) {
        flushHandler.handle(AsyncResultImpl.create(reports));
    } else { // Flushing failed! Likely same result -- want to flush from cache somewhere.
        flushHandler.handle(new IAsyncResult<List<BatchedReportData>>() {

            @Override
            public boolean isSuccess() {
                return false;
            }

            @Override
            public boolean isError() {
                return true;
            }

            @Override
            public List<BatchedReportData> getResult() {
                return reports;
            }

            @Override
            public Throwable getError() {
                return new RuntimeException("Reporting failed; see #getResult for failed entries."); //$NON-NLS-1$
            }
        });
    }
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * Handler that fails tests if result is unsuccessful, with the exception included in the error.
 *
 * @param context the test context
 * @param async the async object
 * @param successHandler the success handler, called only if the result was successful
 * @return the result handler
 */
static <T> IAsyncResultHandler<T> explodeOnFailure(TestContext context, Async async, Handler<T> successHandler) {
    return new IAsyncResultHandler<T>() {

        @Override
        public void handle(IAsyncResult<T> result) {
            if (result.isSuccess()) {
                successHandler.handle(result.getResult());
            } else {
                System.err.println("Operation failed"); //$NON-NLS-1$
                context.fail(result.getError());
            }
        }
    };
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.CachingJdbcRegistry.CachingESRegistry#publishApi(io.apiman.gateway.engine.beans.Api, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void publishApi(Api api, final IAsyncResultHandler<Void> handler) {
    super.publishApi(api, new IAsyncResultHandler<Void>() {
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.CachingJdbcRegistry.CachingESRegistry#retireApi(io.apiman.gateway.engine.beans.Api, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void retireApi(Api api, final IAsyncResultHandler<Void> handler) {
    super.retireApi(api, new IAsyncResultHandler<Void>() {
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.CachingJdbcRegistry.CachingESRegistry#unregisterClient(io.apiman.gateway.engine.beans.Client, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void unregisterClient(Client client, final IAsyncResultHandler<Void> handler) {
    super.unregisterClient(client, new IAsyncResultHandler<Void>() {
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.es.CachingESRegistry#publishApi(io.apiman.gateway.engine.beans.Api, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void publishApi(Api api, final IAsyncResultHandler<Void> handler) {
    super.publishApi(api, new IAsyncResultHandler<Void>() {
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.es.CachingESRegistry#retireApi(io.apiman.gateway.engine.beans.Api, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void retireApi(Api api, final IAsyncResultHandler<Void> handler) {
    super.retireApi(api, new IAsyncResultHandler<Void>() {
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * @see io.apiman.gateway.engine.es.CachingESRegistry#unregisterClient(io.apiman.gateway.engine.beans.Client, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void unregisterClient(Client client, final IAsyncResultHandler<Void> handler) {
    super.unregisterClient(client, new IAsyncResultHandler<Void>() {
        @Override
        public void handle(IAsyncResult<Void> result) {
            if (result.isSuccess()) {
                updateDataVersion();
            }
            handler.handle(result);
        }
    });
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
@Override
public void handle(IAsyncResult<IHttpClientResponse> result) {
    if (result.isSuccess()) {
        response = result.getResult();
        status = parseStatus(response.getBody());
        PolicyFailure policyFailure = null;

        switch (response.getResponseCode()) {
            case 200:
            case 202:
                break;
            case 403:
                // May be able to treat all error cases without distinction by using parsed response, maybe?
                policyFailure = policyFailure(PolicyFailureType.Authentication,
                        PolicyFailureCodes.BASIC_AUTH_FAILED,
                        403,
                        status.getReason());
                break;
            case 409: // Over limit.
                policyFailure = policyFailure(PolicyFailureType.Other,
                        PolicyFailureCodes.RATE_LIMIT_EXCEEDED,
                        409,
                        status.getReason());
                break;
            default:
                RuntimeException re = new RuntimeException("Unexpected or undocumented response code: " + response.getResponseCode()); //$NON-NLS-1$
                exceptionHandler.handle(re); // TODO catch-all. policy failure or exception?
                break;
        }

        if (policyFailure != null) {
            policyFailureHandler.handle(policyFailure);
        }

        statusHandler.handle(status);

        response.close();
    } else {
        exceptionHandler.handle(result.getError());
    }
}
 

import io.apiman.gateway.engine.async.IAsyncResult; //导入方法依赖的package包/类
/**
 * Creates a response handler that is called by the api connector once a connection
 * to the back end api has been made and a response received.
 */
private IAsyncResultHandler<IApiConnectionResponse> createApiConnectionResponseHandler() {
    return (IAsyncResult<IApiConnectionResponse> result) -> {
        if (result.isSuccess()) {
            requestMetric.setApiEnd(new Date());
            // The result came back. NB: still need to put it through the response chain.
            apiConnectionResponse = result.getResult();
            ApiResponse apiResponse = apiConnectionResponse.getHead();
            context.setAttribute("apiman.engine.apiResponse", apiResponse); //$NON-NLS-1$

            // Execute the response chain to evaluate the response.
            responseChain = createResponseChain((ApiResponse response) -> {
                // Send the api response to the caller.
                final EngineResultImpl engineResult = new EngineResultImpl(response);
                engineResult.setConnectorResponseStream(apiConnectionResponse);

                resultHandler.handle(AsyncResultImpl.create(engineResult));

                // We've come all the way through the response chain successfully
                responseChain.bodyHandler(buffer -> {
                    requestMetric.setBytesDownloaded(requestMetric.getBytesDownloaded() + buffer.length());
                    engineResult.write(buffer);
                });

                responseChain.endHandler(isEnd -> {
                    engineResult.end();
                    finished = true;
                    metrics.record(requestMetric);
                });

                // Signal to the connector that it's safe to start transmitting data.
                apiConnectionResponse.transmit();
            });

            // Write data from the back-end response into the response chain.
            apiConnectionResponse.bodyHandler(buffer -> responseChain.write(buffer));

            // Indicate back-end response is finished to the response chain.
            apiConnectionResponse.endHandler(isEnd -> responseChain.end());

            responseChain.doApply(apiResponse);
        } else {
            resultHandler.handle(AsyncResultImpl.create(result.getError()));
        }
    };
}