Java IAsyncHandler类代码示例

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
@Test
public void changeResponseWhenCallbackParamNameIsSavedInContext() throws Exception {
    JsonpConfigBean config = new JsonpConfigBean();

    // given
    String functionName = "testFunction";
    sContext.setAttribute(JsonpPolicy.CALLBACK_FUNCTION_NAME, functionName);
    ApiResponse response = new ApiResponse();
    String json = "{\"name\": \"test\"}";
    IApimanBuffer chunk = new ByteBuffer(json.getBytes().length);
    chunk.append(json);
    IAsyncHandler<IApimanBuffer> bodyHandler = mock(IAsyncHandler.class);
    // when
    IReadWriteStream<ApiResponse> responseDataHandler = jsonpPolicy.getResponseDataHandler(response, sContext, config);
    ApiResponse head = responseDataHandler.getHead();
    responseDataHandler.bodyHandler(bodyHandler);
    responseDataHandler.write(chunk);
    responseDataHandler.end();
    // then
    assertSame(response, head);

    verify(bodyHandler).handle(refEq(new ByteBuffer("testFunction(")));
    verify(bodyHandler).handle(refEq(new ByteBuffer(json)));
    verify(bodyHandler).handle(refEq(new ByteBuffer(")")));
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.components.IPeriodicComponent#setPeriodicTimer(long, long,
 *      io.apiman.gateway.engine.async.IAsyncHandler)
 */
@Override
public long setPeriodicTimer(long periodMillis, long initialDelayMillis,
        final IAsyncHandler<Long> periodicHandler) {
    final long timerId = id.incrementAndGet();

    TimerTask task = new TimerTask() {

        @Override
        public void run() {
            periodicHandler.handle(timerId);
        }
    };
    // Keep reference to TimerTask and Timer ID we hand back (to cancel later).
    timerTaskMap.put(timerId, task);
    // Task, delay, frequency
    timer.schedule(task, initialDelayMillis, periodMillis);
    return timerId;
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.components.IPeriodicComponent#setOneshotTimer(long,
 *      io.apiman.gateway.engine.async.IAsyncHandler)
 */
@Override
public long setOneshotTimer(long deltaMillis, final IAsyncHandler<Long> timerHandler) {
    final long timerId = id.incrementAndGet();

    TimerTask task = new TimerTask() {

        @Override
        public void run() {
            timerHandler.handle(timerId);
        }
    };
    // Keep reference to TimerTask and Timer ID we hand back (to cancel later).
    timerTaskMap.put(timerId, task);
    // Task, delay, frequency
    timer.schedule(task, deltaMillis);
    return timerId;
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.components.IPeriodicComponent#setPeriodicTimer(long, long,
 *      io.apiman.gateway.engine.async.IAsyncHandler)
 */
@Override
public long setPeriodicTimer(final long periodMillis, final long initialDelayMillis,
        final IAsyncHandler<Long> periodicHandler) {
    // Make our own ID to cope with initial delay feature not being present in vert.x's timers.
    final long timerId = id++;

    // Do the initial delay, then map the next timer back to our ID.
    long vertxId = vertx.setTimer(initialDelayMillis, (Handler<Long>) tid -> {

        long newVertxId = vertx.setPeriodic(periodMillis,  (Handler<Long>) tid2 -> {
            periodicHandler.handle(timerId);
        });

        // Periodic delay - re-map to the new Vert.x timer ID, as original timer ID is now invalid.
        // Vert.x. is single-threaded per-verticle so this should be safe.
        timerMap.put(timerId, newVertxId);
    });

    timerMap.put(timerId, vertxId);
    return timerId;
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * Simple write to "/write". Must be valid Influx line format.
 *
 * @param lineDocument document to write, as string
 * @param failureHandler handler in case of failure
 */
public void write(String lineDocument,
        final IAsyncHandler<InfluxException> failureHandler) {
    // Make request to influx
    IHttpClientRequest request = httpClient.request(writeUrl.toString(), HttpMethod.POST,
            result -> {
                if (result.isError() || result.getResult().getResponseCode() < 200
                        || result.getResult().getResponseCode() > 299) {
                    failureHandler.handle(new InfluxException(result.getResult()));
                }
            });
    // For some reason Java's URLEncoding doesn't seem to be parseable by influx?
    //request.addHeader("Content-Type", "application/x-www-form-urlencoded");
    request.addHeader("Content-Type", "text/plain"); //$NON-NLS-1$ //$NON-NLS-2$
    request.write(lineDocument, StandardCharsets.UTF_8.name());
    request.end();
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
@Before
public void setup() {
    Policy policyBean = mock(Policy.class);
    given(policyBean.getPolicyImpl()).willReturn(PassthroughPolicy.QUALIFIED_NAME);
    given(policyBean.getPolicyJsonConfig()).willReturn("{}");

    mockBufferInbound = mock(IApimanBuffer.class);
    given(mockBufferInbound.toString()).willReturn("stottie");

    mockBufferOutbound = mock(IApimanBuffer.class);
    given(mockBufferOutbound.toString()).willReturn("bacon");

    policyList = new ArrayList<>();
    policyList.add(policyBean);

    mockBodyHandler = mock(IAsyncHandler.class);
    mockEndHandler = mock(IAsyncHandler.class);
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
@Test
public void shouldCallFailureHandlerOnDoFail() {
    policies.add(pwcOne);
    policies.add(pwcTwo);

    requestChain = new RequestChain(policies, mockContext);

    IAsyncHandler<PolicyFailure> mPolicyFailureHandler = mock(IAsyncHandler.class);

    PolicyFailure mPolicyFailure = mock(PolicyFailure.class);

    requestChain.policyFailureHandler(mPolicyFailureHandler);
    requestChain.bodyHandler(mockBodyHandler);
    requestChain.endHandler(mockEndHandler);

    requestChain.doApply(mockRequest);
    requestChain.doFailure(mPolicyFailure);

    verify(mPolicyFailureHandler).handle(mPolicyFailure);
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
@Test
public void shouldCallErrorHandlerOnThrowError() {
    policies.add(pwcOne);
    policies.add(pwcTwo);

    requestChain = new RequestChain(policies, mockContext);

    IAsyncHandler<Throwable> mThrowableFailureHandler = mock(IAsyncHandler.class);

    Throwable mThrowable = mock(Throwable.class);

    requestChain.policyErrorHandler(mThrowableFailureHandler);
    requestChain.bodyHandler(mockBodyHandler);
    requestChain.endHandler(mockEndHandler);

    requestChain.doApply(mockRequest);
    requestChain.throwError(mThrowable);

    verify(mThrowableFailureHandler).handle(mThrowable);
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
public static void reloadData(IAsyncHandler<Void> doneHandler) {
    synchronized(URILoadingRegistry.class) {
        if (instance == null) {
            doneHandler.handle((Void) null);
            return;
        }
        Map<URILoadingRegistry, IAsyncResultHandler<Void>> regs = instance.handlers;
        Vertx vertx = instance.vertx;
        URI uri = instance.uri;
        Map<String, String> config = instance.config;
        AtomicInteger ctr = new AtomicInteger(regs.size());
        OneShotURILoader newLoader = new OneShotURILoader(vertx, uri, config);

        regs.entrySet().stream().forEach(pair -> {
            // Clear the registrys' internal maps to prepare for reload.
            // NB: If we add production hot reloading, we'll need to work around this (e.g. clone?).
            pair.getKey().getMap().clear();
            // Re-subscribe the registry.
            newLoader.subscribe(pair.getKey(), result -> {
                checkAndFlip(ctr.decrementAndGet(), newLoader, doneHandler);
            });
        });
        checkAndFlip(ctr.get(), newLoader, doneHandler);
    }
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.components.IPeriodicComponent#setOneshotTimer(long,
 *      io.apiman.gateway.engine.async.IAsyncHandler)
 */
@Override
public long setOneshotTimer(long deltaMillis, final IAsyncHandler<Long> timerHandler) {
    final long timerId = id++;

    long vertxTimerId = vertx.setTimer(deltaMillis, (Handler<Long>) tid -> {
        timerHandler.handle(timerId);
    });

    timerMap.put(timerId, vertxTimerId);
    return timerId;
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
@Override
public <T> void executeBlocking(IAsyncHandler<IAsyncFuture<T>> blockingCode, IAsyncResultHandler<T> resultHandler) {
    vertx.<T>executeBlocking(future -> {
        blockingCode.handle(wrapFuture(future));
    }, result -> {
        resultHandler.handle(wrapResult(result));
    });
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
public synchronized void reload(IAsyncHandler<Void> reloadHandler) {
    this.reloadHandler = reloadHandler;
    awaiting.addAll(allRegistries);
    apis.clear();
    clients.clear();
    failureHandlers.clear();
    allRegistries.stream()
        .map(ThreeScaleImmutableRegistry::getMap)
        .forEach(Map::clear);
    dataProcessed = false;
    // Load again from scratch.
    fetchResource();
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
private void bind(final LDAPIdentitySource config, final LdapConfigBean ldapConfigBean, final ILdapComponent ldapComponent,
        final IPolicyContext context, final IAsyncResultHandler<ILdapResult> handler) {
    // If no role extraction is needed, just do a fast and simple BIND & exit
    if (!config.isExtractRoles()) {
        ldapComponent.bind(ldapConfigBean, handler);
    } else { // Otherwise open up longer-lived connection and query role info.
        ldapComponent.connect(ldapConfigBean, successHandler(handler, new IAsyncHandler<ILdapClientConnection>() {
            @Override // Extract the roles.
            public void handle(final ILdapClientConnection connection) {
                extractRoles(connection, ldapConfigBean.getBindDn(), config, context, handler);
            }
        }));
    }
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * 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(policyFailureHandler);
    chain.policyErrorHandler(policyErrorHandler);
    return chain;
}
 

import io.apiman.gateway.engine.async.IAsyncHandler; //导入依赖的package包/类
/**
 * Creates the chain used to apply policies in reverse order to the api response.
 */
private Chain<ApiResponse> createResponseChain(IAsyncHandler<ApiResponse> responseHandler) {
    ResponseChain chain = new ResponseChain(policyImpls, context);
    chain.headHandler(responseHandler);
    chain.policyFailureHandler(result -> {
        apiConnectionResponse.abort();
        policyFailureHandler.handle(result);
    });
    chain.policyErrorHandler(result -> {
        apiConnectionResponse.abort();
        policyErrorHandler.handle(result);
    });
    return chain;
}