private void doResend()

in rt/ws/rm/src/main/java/org/apache/cxf/ws/rm/soap/RetransmissionQueueImpl.java [742:880]
110 lines of code
27 McCabe index (conditional complexity)

    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);
            cos.holdTempFile(); // CachedOutputStream is hold until delivering was successful
            is = cos.getInputStream(); // instance is needed to close input stream later on
            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
                }
            }
        }
    }