use of org.apache.cxf.io.WriteOnCloseOutputStream in project cxf by apache.
the class SoapOutInterceptor method handleMessage.
public void handleMessage(SoapMessage message) {
// Yes this is ugly, but it avoids us from having to implement any kind of caching strategy
boolean wroteStart = PropertyUtils.isTrue(message.get(WROTE_ENVELOPE_START));
if (!wroteStart) {
writeSoapEnvelopeStart(message);
OutputStream os = message.getContent(OutputStream.class);
// if there's a fault later.
if (!(os instanceof WriteOnCloseOutputStream) && !MessageUtils.isDOMPresent(message)) {
message.put(WROTE_ENVELOPE_START, Boolean.TRUE);
}
}
String cte = (String) message.get("soap.attachement.content.transfer.encoding");
if (cte != null) {
message.put(Message.CONTENT_TRANSFER_ENCODING, cte);
}
// Add a final interceptor to write end elements
message.getInterceptorChain().add(new SoapOutEndingInterceptor());
}
use of org.apache.cxf.io.WriteOnCloseOutputStream in project cxf by apache.
the class RetransmissionQueueImpl method doResend.
private void doResend(SoapMessage message) {
InputStream is = null;
try {
// NOPMD
// initialize copied interceptor chain for message
PhaseInterceptorChain retransmitChain = manager.getRetransmitChain(message);
ProtocolVariation protocol = RMContextUtils.getProtocolVariation(message);
Endpoint endpoint = manager.getReliableEndpoint(message).getEndpoint(protocol);
PhaseChainCache cache = new PhaseChainCache();
boolean after = true;
if (retransmitChain == null) {
// no saved retransmit chain, so construct one from scratch (won't work for WS-Security on server, so
// need to fix)
retransmitChain = buildRetransmitChain(endpoint, cache);
after = false;
}
message.setInterceptorChain(retransmitChain);
// clear flag for SOAP out interceptor so envelope will be written
message.remove(SoapOutInterceptor.WROTE_ENVELOPE_START);
// discard all saved content
Set<Class<?>> formats = message.getContentFormats();
List<CachedOutputStreamCallback> callbacks = null;
for (Class<?> clas : formats) {
Object content = message.getContent(clas);
if (content != null) {
LOG.info("Removing " + clas.getName() + " content of actual type " + content.getClass().getName());
message.removeContent(clas);
if (clas == OutputStream.class && content instanceof WriteOnCloseOutputStream) {
callbacks = ((WriteOnCloseOutputStream) content).getCallbacks();
}
}
}
// read SOAP headers from saved input stream
CachedOutputStream cos = (CachedOutputStream) message.get(RMMessageConstants.SAVED_CONTENT);
// CachedOutputStream is hold until delivering was successful
cos.holdTempFile();
// instance is needed to close input stream later on
is = cos.getInputStream();
XMLStreamReader reader = StaxUtils.createXMLStreamReader(is, StandardCharsets.UTF_8.name());
message.getHeaders().clear();
if (reader.getEventType() != XMLStreamConstants.START_ELEMENT && reader.nextTag() != XMLStreamConstants.START_ELEMENT) {
throw new IllegalStateException("No document found");
}
readHeaders(reader, message);
int event;
while ((event = reader.nextTag()) != XMLStreamConstants.START_ELEMENT) {
if (event == XMLStreamConstants.END_ELEMENT) {
throw new IllegalStateException("No body content present");
}
}
// set message addressing properties
AddressingProperties maps = MAPCodec.getInstance(message.getExchange().getBus()).unmarshalMAPs(message);
RMContextUtils.storeMAPs(maps, message, true, MessageUtils.isRequestor(message));
AttributedURIType to = null;
if (null != maps) {
to = maps.getTo();
}
if (null == to) {
LOG.log(Level.SEVERE, "NO_ADDRESS_FOR_RESEND_MSG");
return;
}
if (RMUtils.getAddressingConstants().getAnonymousURI().equals(to.getValue())) {
LOG.log(Level.FINE, "Cannot resend to anonymous target");
return;
}
// initialize conduit for new message
Conduit c = message.getExchange().getConduit(message);
if (c == null) {
c = buildConduit(message, endpoint, to);
}
c.prepare(message);
// replace standard message marshaling with copy from saved stream
ListIterator<Interceptor<? extends Message>> iterator = retransmitChain.getIterator();
while (iterator.hasNext()) {
Interceptor<? extends Message> incept = iterator.next();
// remove JAX-WS interceptors which handle message modes and such
if (incept.getClass().getName().startsWith("org.apache.cxf.jaxws.interceptors")) {
retransmitChain.remove(incept);
} else if (incept instanceof PhaseInterceptor && Phase.MARSHAL.equals(((PhaseInterceptor<?>) incept).getPhase())) {
// remove any interceptors from the marshal phase
retransmitChain.remove(incept);
}
}
retransmitChain.add(new CopyOutInterceptor(reader));
// restore callbacks on output stream
if (callbacks != null) {
OutputStream os = message.getContent(OutputStream.class);
if (os != null) {
WriteOnCloseOutputStream woc;
if (os instanceof WriteOnCloseOutputStream) {
woc = (WriteOnCloseOutputStream) os;
} else {
woc = new WriteOnCloseOutputStream(os);
message.setContent(OutputStream.class, woc);
}
for (CachedOutputStreamCallback cb : callbacks) {
woc.registerCallback(cb);
}
}
}
// send the message
message.put(RMMessageConstants.RM_RETRANSMISSION, Boolean.TRUE);
if (after) {
retransmitChain.doInterceptStartingAfter(message, RMCaptureOutInterceptor.class.getName());
} else {
retransmitChain.doIntercept(message);
}
if (LOG.isLoggable(Level.INFO)) {
RMProperties rmps = RMContextUtils.retrieveRMProperties(message, true);
SequenceType seq = rmps.getSequence();
LOG.log(Level.INFO, "Retransmitted message " + seq.getMessageNumber() + " in sequence " + seq.getIdentifier().getValue());
}
} catch (Exception ex) {
LOG.log(Level.SEVERE, "RESEND_FAILED_MSG", ex);
} finally {
// make sure to always close InputStreams of the CachedOutputStream to avoid leaving temp files undeleted
if (null != is) {
try {
is.close();
} catch (IOException e) {
// Ignore
}
}
}
}
use of org.apache.cxf.io.WriteOnCloseOutputStream in project cxf by apache.
the class RMCaptureOutInterceptor method handle.
protected void handle(Message msg) throws SequenceFault, RMException {
AddressingProperties maps = ContextUtils.retrieveMAPs(msg, false, true, false);
if (null == maps) {
LogUtils.log(LOG, Level.WARNING, "MAPS_RETRIEVAL_FAILURE_MSG");
return;
}
if (Boolean.TRUE.equals(msg.get(RMMessageConstants.RM_RETRANSMISSION))) {
return;
}
if (isRuntimeFault(msg)) {
LogUtils.log(LOG, Level.WARNING, "RUNTIME_FAULT_MSG");
// in case of a SequenceFault or other WS-RM related fault, set action appropriately.
// the received inbound maps is available to extract some values in case if needed.
Throwable cause = msg.getContent(Exception.class).getCause();
if (cause instanceof SequenceFault || cause instanceof RMException) {
maps.getAction().setValue(getAddressingNamespace(maps) + "/fault");
}
return;
}
Source source = getManager().getSource(msg);
RMConfiguration config = getManager().getEffectiveConfiguration(msg);
String wsaNamespace = config.getAddressingNamespace();
String rmNamespace = config.getRMNamespace();
ProtocolVariation protocol = ProtocolVariation.findVariant(rmNamespace, wsaNamespace);
RMContextUtils.setProtocolVariation(msg, protocol);
maps.exposeAs(wsaNamespace);
String action = null;
if (null != maps.getAction()) {
action = maps.getAction().getValue();
}
// make sure we use the appropriate namespace
maps.exposeAs(wsaNamespace);
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Action: " + action);
}
boolean isApplicationMessage = !RMContextUtils.isRMProtocolMessage(action);
boolean isPartialResponse = MessageUtils.isPartialResponse(msg);
RMConstants constants = protocol.getConstants();
boolean isLastMessage = RM10Constants.CLOSE_SEQUENCE_ACTION.equals(action);
RMProperties rmpsOut = RMContextUtils.retrieveRMProperties(msg, true);
if (null == rmpsOut) {
rmpsOut = new RMProperties();
rmpsOut.exposeAs(protocol.getWSRMNamespace());
RMContextUtils.storeRMProperties(msg, rmpsOut, true);
}
// Activate process response for oneWay
if (msg.getExchange().isOneWay()) {
msg.getExchange().put(Message.PROCESS_ONEWAY_RESPONSE, true);
}
RMProperties rmpsIn = null;
Identifier inSeqId = null;
long inMessageNumber = 0;
if (isApplicationMessage) {
rmpsIn = RMContextUtils.retrieveRMProperties(msg, false);
if (null != rmpsIn && null != rmpsIn.getSequence()) {
inSeqId = rmpsIn.getSequence().getIdentifier();
inMessageNumber = rmpsIn.getSequence().getMessageNumber();
}
ContextUtils.storeDeferUncorrelatedMessageAbort(msg);
}
Map<?, ?> invocationContext = (Map<?, ?>) msg.get(Message.INVOCATION_CONTEXT);
if ((isApplicationMessage || (isLastMessage && invocationContext != null)) && !isPartialResponse) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("inbound sequence: " + (null == inSeqId ? "null" : inSeqId.getValue()));
}
// get the current sequence, requesting the creation of a new one if necessary
synchronized (source) {
final SourceSequence seq;
if (isLastMessage) {
seq = (SourceSequence) invocationContext.get(SourceSequence.class.getName());
} else {
seq = getManager().getSequence(inSeqId, msg, maps);
}
assert null != seq;
// increase message number and store a sequence type object in
// context
seq.nextMessageNumber(inSeqId, inMessageNumber, isLastMessage);
if (Boolean.TRUE.equals(msg.getContextualProperty(RMManager.WSRM_LAST_MESSAGE_PROPERTY))) {
// mark the message as the last one
seq.setLastMessage(true);
}
rmpsOut.setSequence(seq);
if (seq.isLastMessage()) {
source.setCurrent(null);
}
}
} else if (!MessageUtils.isRequestor(msg) && constants.getCreateSequenceAction().equals(action)) {
maps.getAction().setValue(constants.getCreateSequenceResponseAction());
} else if (isPartialResponse && action == null && isResponseToAction(msg, constants.getSequenceAckAction())) {
Collection<SequenceAcknowledgement> acks = rmpsIn != null ? rmpsIn.getAcks() : null;
if (acks != null && acks.size() == 1) {
SourceSequence ss = source.getSequence(acks.iterator().next().getIdentifier());
if (ss != null && ss.allAcknowledged()) {
setAction(maps, constants.getTerminateSequenceAction());
setTerminateSequence(msg, ss.getIdentifier(), protocol);
msg.remove(Message.EMPTY_PARTIAL_RESPONSE_MESSAGE);
// removing this sequence now. See the comment in SourceSequence.setAcknowledged()
source.removeSequence(ss);
}
}
}
// capture message if retransmission possible
if (isApplicationMessage && !isPartialResponse) {
OutputStream os = msg.getContent(OutputStream.class);
// message until connection is setup
if (!(os instanceof WriteOnCloseOutputStream)) {
msg.setContent(OutputStream.class, new WriteOnCloseOutputStream(os));
}
getManager().initializeInterceptorChain(msg);
// doneCaptureMessage(msg);
captureMessage(msg);
} else if (isLastMessage) {
// got either the rm11 CS or the rm10 empty LM
RMStore store = getManager().getStore();
if (null != store) {
store.persistOutgoing(rmpsOut.getSourceSequence(), null);
}
}
}
use of org.apache.cxf.io.WriteOnCloseOutputStream in project cxf by apache.
the class OutMessageRecorder method handleMessage.
public void handleMessage(Message message) throws Fault {
OutputStream os = message.getContent(OutputStream.class);
if (null == os) {
return;
}
WriteOnCloseOutputStream stream = createCachedStream(message, os);
stream.registerCallback(new RecorderCallback());
}
use of org.apache.cxf.io.WriteOnCloseOutputStream in project cxf by apache.
the class OutMessageRecorder method createCachedStream.
public static WriteOnCloseOutputStream createCachedStream(Message message, OutputStream os) {
// message until we have a chance to send a createsequence
if (!(os instanceof WriteOnCloseOutputStream)) {
WriteOnCloseOutputStream cached = new WriteOnCloseOutputStream(os);
message.setContent(OutputStream.class, cached);
os = cached;
}
return (WriteOnCloseOutputStream) os;
}
Aggregations