Java Code Examples for com.sun.xml.internal.ws.util.Pool#take()

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param receiver       The {@link Response} implementation
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    request.component = this;
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    final Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    receiver.setCancelable(fiber);

    // check race condition on cancel
    if (receiver.isCancelled()) {
        return;
    }

    FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class);
    if (fcsif != null) {
        fiber.addInterceptor(fcsif.create());
    }

    // then send it away!
    final Tube tube = pool.take();

    Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() {
        @Override
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }

        @Override
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    };

    // Check for SyncStartForAsyncInvokeFeature

    fiber.start(tube, request, fiberCallback,
                    getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) &&
                    !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE));
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}
 

/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param receiver       The {@link Response} implementation
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    request.component = this;
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    final Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    receiver.setCancelable(fiber);

    // check race condition on cancel
    if (receiver.isCancelled()) {
        return;
    }

    FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class);
    if (fcsif != null) {
        fiber.addInterceptor(fcsif.create());
    }

    // then send it away!
    final Tube tube = pool.take();

    Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() {
        @Override
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }

        @Override
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    };

    // Check for SyncStartForAsyncInvokeFeature

    fiber.start(tube, request, fiberCallback,
                    getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) &&
                    !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE));
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}
 

/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param receiver       The {@link Response} implementation
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    request.component = this;
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    final Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    receiver.setCancelable(fiber);

    // check race condition on cancel
    if (receiver.isCancelled()) {
        return;
    }

    FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class);
    if (fcsif != null) {
        fiber.addInterceptor(fcsif.create());
    }

    // then send it away!
    final Tube tube = pool.take();

    Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() {
        @Override
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }

        @Override
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    };

    // Check for SyncStartForAsyncInvokeFeature

    fiber.start(tube, request, fiberCallback,
                    getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) &&
                    !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE));
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}
 

/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param receiver       The {@link Response} implementation
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    request.component = this;
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    final Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    receiver.setCancelable(fiber);

    // check race condition on cancel
    if (receiver.isCancelled()) {
        return;
    }

    FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class);
    if (fcsif != null) {
        fiber.addInterceptor(fcsif.create());
    }

    // then send it away!
    final Tube tube = pool.take();

    Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() {
        @Override
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }

        @Override
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    };

    // Check for SyncStartForAsyncInvokeFeature

    fiber.start(tube, request, fiberCallback,
                    getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) &&
                    !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE));
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}
 

/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param receiver       The {@link Response} implementation
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    request.component = this;
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    final Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    receiver.setCancelable(fiber);

    // check race condition on cancel
    if (receiver.isCancelled()) {
        return;
    }

    FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class);
    if (fcsif != null) {
        fiber.addInterceptor(fcsif.create());
    }

    // then send it away!
    final Tube tube = pool.take();

    Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() {
        @Override
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }

        @Override
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    };

    // Check for SyncStartForAsyncInvokeFeature

    fiber.start(tube, request, fiberCallback,
                    getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) &&
                    !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE));
}
 

/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}