@Override public Exchange cancelAndGetOriginalExchange() { if (synchronizations != null) { for (Synchronization synchronization : synchronizations) { exchange.addOnCompletion(synchronization); } } return exchange; }
public void prepareForAcknowledge(Exchange exchange) throws JMSException { // grab the javax.jms.Message from the incoming Camel JmsMessage which has the getJmsMessage() // that returns the javax.jms.Message instance final javax.jms.Message jms = exchange.getIn(JmsMessage.class).getJmsMessage(); // add UoW completion to call the JMS client acknowledge when the routing is complete (commit) // if the routing fails with an exception, then onComplete is not called, and the Spring JMS // message listener will fail as well and trigger a rollback exchange.addOnCompletion(new SynchronizationAdapter() { @Override public void onComplete(Exchange exchange) { LOG.info("Using JMS client acknowledge to accept the JMS message consumed: {}", jms); try { jms.acknowledge(); } catch (JMSException e) { LOG.warn("JMS client acknowledge failed due: " + e.getMessage(), e); } } }); } }
@Override public void process(final Exchange exchange) { if (!onCompletion) { internalProcessing(exchange); } else { // set headers only for "on-completion" processing because // otherwise the service doing something is already done // and therefore cannot use this in-headers any more. setInHeaders(exchange); final TaskProcessor taskProcessor = this; exchange.addOnCompletion(new Synchronization() { @Override public void onFailure(final Exchange exchange) { taskProcessor.internalProcessing(exchange); } @Override public void onComplete(final Exchange exchange) { taskProcessor.internalProcessing(exchange); } }); } }
@SuppressWarnings("unchecked") private void doQuery(Message in, Message out, Exchange exchange) { Query<Object> query = in.getHeader(IgniteConstants.IGNITE_CACHE_QUERY, Query.class); if (query == null) { try { query = in.getMandatoryBody(Query.class); } catch (InvalidPayloadException e) { exchange.setException(e); return; } } final QueryCursor<Object> cursor = cache.query(query); out.setBody(cursor.iterator()); exchange.addOnCompletion(new Synchronization() { @Override public void onFailure(Exchange exchange) { cursor.close(); } @Override public void onComplete(Exchange exchange) { cursor.close(); } }); }
exchange.addOnCompletion(new ResultSetIteratorCompletion(iterator));
exchange.addOnCompletion(new JpaCloseEntityManagerOnCompletion(em)); exchange.addOnCompletion(new JpaCloseEntityManagerOnCompletion(em));
@Override public Object unmarshal(Exchange exchange, InputStream inputStream) throws IOException { Reader reader = null; try { reader = new InputStreamReader(inputStream, IOHelper.getCharsetName(exchange)); CSVParser parser = new CSVParser(reader, format); CsvIterator answer = new CsvIterator(parser, converter); // add to UoW so we can close the iterator so it can release any resources exchange.addOnCompletion(new CsvUnmarshalOnCompletion(answer)); return answer; } catch (Exception e) { IOHelper.close(reader); throw e; } } }
protected Publisher<Exchange> doRequest(String name, Exchange data) { ReactiveStreamsConsumer consumer = streamSubscriber(name).getConsumer(); if (consumer == null) { throw new IllegalStateException("No consumers attached to the stream " + name); } DelayedMonoPublisher<Exchange> publisher = new DelayedMonoPublisher<>(this.workerPool); data.addOnCompletion(new Synchronization() { @Override public void onComplete(Exchange exchange) { publisher.setData(exchange); } @Override public void onFailure(Exchange exchange) { Throwable throwable = exchange.getException(); if (throwable == null) { throwable = new IllegalStateException("Unknown Exception"); } publisher.setException(throwable); } }); consumer.process(data, doneSync -> { }); return publisher; }
exchange.addOnCompletion(new Synchronization() { public void onComplete(Exchange exchange) { try {
protected void handleActiveProviderExchange(MessageExchange exchange) throws Exception { // Fault message if (exchange.getFault() != null) { done(exchange); // In message } else if (exchange.getMessage("in") != null) { logger.debug("Received exchange: {}", exchange); final Exchange camelExchange = binding.createExchange(exchange); camelExchange.setFromEndpoint(camelEndpoint); camelExchange.addOnCompletion(this); binding.runWithCamelContextClassLoader(new Callable<Object>() { public Object call() throws Exception { camelProcessor.process(camelExchange, new AsyncCallback() { public void done(boolean doneSync) { // result processing done by onFailure/onSuccess methods } }); return null; } }); } else { // This is not complaint with the default MEPs throw new IllegalStateException("Provider exchange is ACTIVE, but no in or fault is provided"); } }
protected Publisher<Exchange> doRequest(String name, Exchange data) { ReactiveStreamsConsumer consumer = streamSubscriber(name).getConsumer(); if (consumer == null) { throw new IllegalStateException("No consumers attached to the stream " + name); } return Mono.<Exchange>create( sink -> data.addOnCompletion(new Synchronization() { @Override public void onComplete(Exchange exchange) { sink.success(exchange); } @Override public void onFailure(Exchange exchange) { Throwable throwable = exchange.getException(); if (throwable == null) { throwable = new IllegalStateException("Unknown Exception"); } sink.error(throwable); } }) ).doOnSubscribe( subs -> consumer.process(data, ReactorStreamsConstants.EMPTY_ASYNC_CALLBACK) ); } }
exchange.addOnCompletion(new SynchronizationAdapter() { public void onComplete(Exchange exchange) { processCommit(mail, exchange);
exchange.addOnCompletion(new Synchronization() { public void onComplete(Exchange exchange) { processCommit(exchange);
protected Publisher<Exchange> doRequest(String name, Exchange data) { ReactiveStreamsConsumer consumer = streamSubscriber(name).getConsumer(); if (consumer == null) { throw new IllegalStateException("No consumers attached to the stream " + name); } Single<Exchange> source = Single.<Exchange>create( emitter -> data.addOnCompletion(new Synchronization() { @Override public void onComplete(Exchange exchange) { emitter.onSuccess(exchange); } @Override public void onFailure(Exchange exchange) { Throwable throwable = exchange.getException(); if (throwable == null) { throwable = new IllegalStateException("Unknown Exception"); } emitter.onError(throwable); } }) ).doOnSubscribe( subs -> consumer.process(data, RxJavaStreamsConstants.EMPTY_ASYNC_CALLBACK) ); return source.toFlowable(); } }
data = new ExchangeData(); exchanges.put(exchange.getExchangeId(), data); exchange.addOnCompletion(data);
data = new ExchangeData(); exchanges.put(exchange.getExchangeId(), data); exchange.addOnCompletion(data);
@Override public Exchange aggregate(Exchange oldExchange, Exchange newExchange) { Exchange aggExchange = wrappedStrategy.aggregate(oldExchange, newExchange); if (aggExchange != null) { if (aggExchange != currentExchange) { if (currentExchange != null) { synchronizor.onComplete(currentExchange); } aggExchange.getContext().getInflightRepository().add(aggExchange); currentExchange = aggExchange; synchronizor = new AggregationSynchronizor(); currentExchange.addOnCompletion(synchronizor); } } return aggExchange; } }
exchange.addOnCompletion(new SynchronizationAdapter() { @Override public void onDone(Exchange exchange) {
exchange.addOnCompletion(new Synchronization() { final String reservationId = ExchangeHelper.getMandatoryHeader(exchange, IronMQConstants.MESSAGE_RESERVATION_ID, String.class); final String messageid = ExchangeHelper.getMandatoryHeader(exchange, IronMQConstants.MESSAGE_ID, String.class);
result.addOnCompletion(new Synchronization() { @Override public void onComplete(Exchange exchange) {