Package org.apache.camel

Examples of org.apache.camel.AsyncProcessor

753
754
755
756
757
758
759
760
761
762
763
            // store the last to endpoint as the failure endpoint
            exchange.setProperty(Exchange.FAILURE_ENDPOINT, exchange.getProperty(Exchange.TO_ENDPOINT));

            // the failure processor could also be asynchronous
            AsyncProcessor afp = AsyncProcessorConverterHelper.convert(processor);
            sync = AsyncProcessorHelper.process(afp, exchange, new AsyncCallback() {
                public void done(boolean sync) {
                    log.trace("Failure processor done: {} processing Exchange: {}", processor, exchange);
                    try {
                        prepareExchangeAfterFailure(exchange, data, shouldHandle, shouldContinue);
View Full Code Here
108
109
110
111
112
113
114
115
116
117
118
     * @param exchange input data.
     */
    public boolean process(final Exchange exchange, final AsyncCallback callback) {
        final Exchange resourceExchange = createResourceExchange(exchange, ExchangePattern.InOut);

        AsyncProcessor ap = AsyncProcessorConverterHelper.convert(producer);
        boolean sync = AsyncProcessorHelper.process(ap, resourceExchange, new AsyncCallback() {
            public void done(boolean doneSync) {
                // we only have to handle async completion of the routing slip
                if (doneSync) {
                    return;
View Full Code Here
148
149
150
151
152
153
154
155
156
157
158
                        exchange.setIn(exchange.getOut());
                        exchange.setOut(null);
                    }

                    // route to original destination leveraging the asynchronous routing engine
                    AsyncProcessor async = AsyncProcessorConverterHelper.convert(producer);
                    return AsyncProcessorHelper.process(async, exchange, callback);
                } else {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Stop() means skip sending exchange to original intended destination: {} for exchange: {}", getEndpoint(), exchange);
                    }
View Full Code Here
55
56
57
58
59
60
61
62
63
            // indicate its done synchronously
            exchange.setException(new CamelExchangeException("No consumers available on endpoint: " + endpoint, exchange));
            callback.done(true);
            return true;
        } else {
            AsyncProcessor processor = AsyncProcessorConverterHelper.convert(endpoint.getConsumer().getProcessor());
            return AsyncProcessorHelper.process(processor, exchange, callback);
        }
    }
View Full Code Here
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
    public void beforeWrap(RouteContext routeContext, ProcessorDefinition<?> definition) { 
        //Not implemented
    }
   
    public Processor wrap(RouteContext routeContext, final Processor processor) {       
        return new AsyncProcessor() {
            public boolean process(Exchange exchange, final AsyncCallback callback)  {
                boolean sync;
                try {
                    applySecurityPolicy(exchange);
                } catch (Exception e) {
                    // exception occurred so break out
                    exchange.setException(e);
                    callback.done(true);
                    return true;
                }
               
                // If here, then user is authenticated and authorized
                // Now let the original processor continue routing supporting the async routing engine
                AsyncProcessor ap = AsyncProcessorConverterHelper.convert(processor);
                sync = AsyncProcessorHelper.process(ap, exchange, new AsyncCallback() {
                    public void done(boolean doneSync) {
                        // we only have to handle async completion of this policy
                        if (doneSync) {
                            return;
View Full Code Here
139
140
141
142
143
144
145
146
147
148
149
            exchange.setException(e);
            callback.done(true);
            return true;
        }

        AsyncProcessor target = rlp;
        if (isShareUnitOfWork()) {
            // wrap answer in a sub unit of work, since we share the unit of work
            target = new SubUnitOfWorkProcessor(rlp);
        }
View Full Code Here
286
287
288
289
290
291
292
293
294
295
296
        try {
            if (exchange != null) {
                EventHelper.notifyExchangeSending(exchange.getContext(), exchange, endpoint);
            }
            // invoke the callback
            AsyncProcessor asyncProcessor = AsyncProcessorConverterHelper.convert(producer);
            sync = producerCallback.doInAsyncProducer(producer, asyncProcessor, exchange, pattern, new AsyncCallback() {
                @Override
                public void done(boolean doneSync) {
                    try {
                        if (watch != null) {
View Full Code Here
570
571
572
573
574
575
576
577
578
579
580
            if (producer != null) {
                EventHelper.notifyExchangeSending(exchange.getContext(), exchange, producer.getEndpoint());
            }
            // let the prepared process it, remember to begin the exchange pair
            AsyncProcessor async = AsyncProcessorConverterHelper.convert(processor);
            pair.begin();
            sync = AsyncProcessorHelper.process(async, exchange, new AsyncCallback() {
                public void done(boolean doneSync) {
                    // we are done with the exchange pair
                    pair.done();
View Full Code Here
707
708
709
710
711
712
713
714
715
716
717
            if (producer != null) {
                EventHelper.notifyExchangeSending(exchange.getContext(), exchange, producer.getEndpoint());
            }
            // let the prepared process it, remember to begin the exchange pair
            AsyncProcessor async = AsyncProcessorConverterHelper.convert(processor);
            pair.begin();
            // we invoke it synchronously as parallel async routing is too hard
            AsyncProcessorHelper.process(async, exchange);
        } finally {
            pair.done();
View Full Code Here
42
43
44
45
46
47
48
49
50
51
52
        }
        Processor processor = chooseProcessor(list, exchange);
        if (processor == null) {
            throw new IllegalStateException("No processors could be chosen to process " + exchange);
        } else {
            AsyncProcessor albp = AsyncProcessorTypeConverter.convert(processor);
            sync = AsyncProcessorHelper.process(albp, exchange, new AsyncCallback() {
                public void done(boolean doneSync) {
                    // only handle the async case
                    if (doneSync) {
                        return;
View Full Code Here
TOP

Related Classes of org.apache.camel.AsyncProcessor

  • $.DirectProducer
  • org.apache.camel.component.direct.DirectEndpoint$DirectProducer
  • org.apache.camel.component.direct.DirectProducer
  • org.apache.camel.component.directvm.DirectVmProducer
  • org.apache.camel.component.routebox.direct.RouteboxDirectProducer
  • org.apache.camel.component.shiro.security.ShiroSecurityPolicy
  • org.apache.camel.impl.DefaultRouteContext
  • org.apache.camel.impl.InterceptSendToEndpoint
  • org.apache.camel.impl.ProducerCache
  • org.apache.camel.impl.RouteContext
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.