Examples with RMProperties org.apache.cxf.ws.rm.RMProperties used on opensource projects

Example 1 with RMProperties

use of org.apache.cxf.ws.rm.RMProperties in project cxf by apache.

the class RedeliveryQueueImpl method getRedeliveryStatuses.

public Map<Long, RetryStatus> getRedeliveryStatuses(DestinationSequence seq) {
    Map<Long, RetryStatus> cp = new HashMap<>();
    List<RedeliverCandidate> sequenceCandidates = getSequenceCandidates(seq);
    if (null != sequenceCandidates) {
        for (int i = 0; i < sequenceCandidates.size(); i++) {
            RedeliverCandidate candidate = sequenceCandidates.get(i);
            RMProperties properties = RMContextUtils.retrieveRMProperties(candidate.getMessage(), false);
            SequenceType st = properties.getSequence();
            cp.put(st.getMessageNumber(), candidate);
        }
    }
    return cp;
}

Example 2 with RMProperties

use of org.apache.cxf.ws.rm.RMProperties in project cxf by apache.

the class RedeliveryQueueImpl method purgeDelivered.

protected void purgeDelivered(RedeliverCandidate candidate) {
    RMProperties rmps = RMContextUtils.retrieveRMProperties(candidate.getMessage(), false);
    SequenceType st = rmps.getSequence();
    Identifier sid = st.getIdentifier();
    String key = sid.getValue();
    synchronized (this) {
        List<RedeliverCandidate> sequenceCandidates = getSequenceCandidates(key);
        if (null != sequenceCandidates) {
            // TODO use a constant op instead of this inefficient linear op
            sequenceCandidates.remove(candidate);
            undeliveredCount--;
        }
        if (sequenceCandidates.isEmpty()) {
            candidates.remove(sid.getValue());
        }
    }
    LOG.fine("Purged delivered message.");
}

Example 3 with RMProperties

use of org.apache.cxf.ws.rm.RMProperties in project cxf by apache.

the class RedeliveryQueueImpl method cacheUndelivered.

/**
 * Accepts a new resend candidate.
 *
 * @param ctx the message context.
 * @return ResendCandidate
 */
protected RedeliverCandidate cacheUndelivered(Message message) {
    RMProperties rmps = RMContextUtils.retrieveRMProperties(message, false);
    SequenceType st = rmps.getSequence();
    Identifier sid = st.getIdentifier();
    String key = sid.getValue();
    RedeliverCandidate candidate = null;
    synchronized (this) {
        List<RedeliverCandidate> sequenceCandidates = getSequenceCandidates(key);
        if (null == sequenceCandidates) {
            sequenceCandidates = new ArrayList<>();
            candidates.put(key, sequenceCandidates);
        }
        candidate = getRedeliverCandidate(st, sequenceCandidates);
        if (candidate == null) {
            candidate = new RedeliverCandidate(message);
            if (isSequenceSuspended(key)) {
                candidate.suspend();
            }
            sequenceCandidates.add(candidate);
            undeliveredCount++;
        }
    }
    LOG.fine("Cached undelivered message.");
    return candidate;
}

Example 4 with RMProperties

use of org.apache.cxf.ws.rm.RMProperties in project cxf by apache.

the class RetransmissionQueueImpl method doResend.

private void doResend(SoapMessage message) {
    InputStream is = null;
    try {
        // 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 && (((PhaseInterceptor<?>) incept).getPhase() == Phase.MARSHAL)) {
                // 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());
            rmps = new RMProperties();
        }
    } 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
            }
        }
    }
}

Example 5 with RMProperties

use of org.apache.cxf.ws.rm.RMProperties in project cxf by apache.

the class RetransmissionQueueImpl method cacheUnacknowledged.

/**
 * Accepts a new resend candidate.
 *
 * @param ctx the message context.
 * @return ResendCandidate
 */
protected ResendCandidate cacheUnacknowledged(Message message) {
    RMProperties rmps = RMContextUtils.retrieveRMProperties(message, true);
    SequenceType st = rmps.getSequence();
    Identifier sid = st.getIdentifier();
    String key = sid.getValue();
    ResendCandidate candidate = null;
    synchronized (this) {
        List<ResendCandidate> sequenceCandidates = getSequenceCandidates(key);
        if (null == sequenceCandidates) {
            sequenceCandidates = new ArrayList<>();
            candidates.put(key, sequenceCandidates);
        }
        candidate = createResendCandidate(message);
        if (isSequenceSuspended(key)) {
            candidate.suspend();
        }
        sequenceCandidates.add(candidate);
        unacknowledgedCount++;
    }
    LOG.fine("Cached unacknowledged message.");
    try {
        RMEndpoint rme = manager.getReliableEndpoint(message);
        rme.handleAccept(key, st.getMessageNumber(), message);
    } catch (RMException e) {
        LOG.log(Level.WARNING, "Could not find reliable endpoint for message");
    }
    return candidate;
}