com.sun.xml.internal.ws.api.pipe.Fiber Java Examples

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

@Override
public NextAction processRequest(Packet request) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (request != null) ? request.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Request, position.requestState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processRequest(request);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processRequest(Packet request) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (request != null) ? request.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Request, position.requestState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processRequest(request);
}
 

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

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

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

@Override
public NextAction processRequest(Packet request) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (request != null) ? request.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Request, position.requestState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processRequest(request);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

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

@Override
public NextAction processRequest(Packet request) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (request != null) ? request.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Request, position.requestState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processRequest(request);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

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

@Override
public NextAction processRequest(Packet request) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (request != null) ? request.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Request, position.requestState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processRequest(request);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

@Override
public NextAction processException(Throwable t) {
    if (messageDumper.isLoggable()) {
        messageDumper.dump(MessageDumper.MessageType.Exception, position.responseState, Converter.toString(t), tubeId, Fiber.current().owner.id);
    }

    return super.processException(t);
}
 

@Override
public NextAction processResponse(Packet response) {
    if (messageDumper.isLoggable()) {
        Packet dumpPacket = (response != null) ? response.copy(true) : null;
        messageDumper.dump(MessageDumper.MessageType.Response, position.responseState, Converter.toString(dumpPacket), tubeId, Fiber.current().owner.id);
    }

    return super.processResponse(response);
}
 

@Override
public NextAction processException(Throwable t) {
    dump(MessageType.Exception, Converter.toString(t), Fiber.current().owner.id);

    return super.processException(t);
}
 

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

@Override
public NextAction processResponse(Packet response) {
    dump(MessageType.Response, Converter.toString(response), Fiber.current().owner.id);
    return super.processResponse(response);
}