Java Code Examples for com.sun.xml.internal.ws.api.pipe.Fiber#start()

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}
 

/**
* Send a response to a non-anonymous address. Also closes the transport back channel
* of {@link Packet} if it's not closed already.
*
* @param packet
*      The response from our server, which will be delivered to the destination.
* @return The response packet that should be used to complete the tubeline response processing
*/
   public Packet process(Packet packet) {
   Fiber.CompletionCallback fiberCallback = null;
   Fiber currentFiber = Fiber.getCurrentIfSet();
   if (currentFiber != null) {
       // Link completion of the current fiber to the new fiber that will
       // deliver the async response. This allows access to the response
       // packet that may be generated by sending a new message for the
       // current async response.

           final Fiber.CompletionCallback currentFiberCallback =
               currentFiber.getCompletionCallback();

                   if (currentFiberCallback != null) {
                     fiberCallback = new Fiber.CompletionCallback() {
                     public void onCompletion(@NotNull Packet response) {
                       currentFiberCallback.onCompletion(response);
                     }

                     public void onCompletion(@NotNull Throwable error) {
                       currentFiberCallback.onCompletion(error);
                     }
                   };
                   currentFiber.setCompletionCallback(null);
           }
   }

   // we need to assemble a pipeline to talk to this endpoint.
           WSEndpoint<?> endpoint = packet.endpoint;
           WSBinding binding = endpoint.getBinding();
   Tube transport = TransportTubeFactory.create(Thread.currentThread().getContextClassLoader(),
       new ClientTubeAssemblerContext(
                   packet.endpointAddress, endpoint.getPort(), (WSService) null,
                   binding, endpoint.getContainer(),
                   ((BindingImpl) binding).createCodec(), null, null));
   Fiber fiber = endpoint.getEngine().createFiber();
   fiber.start(transport, packet, fiberCallback);

   // then we'll proceed the rest like one-way.
   Packet copy = packet.copy(false);
   copy.endpointAddress = null;

   return copy;
   }
 

/**
 * 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));
}