001/**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.camel;
018
019import java.util.Date;
020import java.util.List;
021import java.util.Map;
022
023import org.apache.camel.spi.Synchronization;
024import org.apache.camel.spi.UnitOfWork;
025
026/**
027 * An Exchange is the message container holding the information during the entire routing of
028 * a {@link  Message} received by a {@link Consumer}. 
029 * <p/>
030 * During processing down the {@link Processor} chain, the {@link Exchange} provides access to the 
031 * current (not the original) request and response {@link Message} messages. The {@link Exchange} 
032 * also holds meta-data during its entire lifetime stored as properties accessible using the 
033 * various {@link #getProperty(String)} methods. The {@link #setProperty(String, Object)} is 
034 * used to store a property. For example you can use this to store security, SLA related 
035 * data or any other information deemed useful throughout processing. If an {@link Exchange} 
036 * failed during routing the {@link Exception} that caused the failure is stored and accessible 
037 * via the {@link #getException()} method.
038 * <p/>
039 * An Exchange is created when a {@link Consumer} receives a request. A new {@link Message} is
040 * created, the request is set as the body of the {@link Message} and depending on the {@link Consumer}
041 * other {@link Endpoint} and protocol related information is added as headers on the {@link Message}.
042 * Then an Exchange is created and the newly created {@link Message} is set as the in on the Exchange.
043 * Therefore an Exchange starts its life in a {@link Consumer}. The Exchange is then sent down the
044 * {@link Route} for processing along a {@link Processor} chain. The {@link Processor} as the name
045 * suggests is what processes the {@link Message} in the Exchange and Camel, in addition to 
046 * providing out-of-the-box a large number of useful processors, it also allows you to create your own. 
047 * The rule Camel uses is to take the out {@link Message} produced by the previous {@link Processor} 
048 * and set it as the in for the next {@link Processor}. If the previous {@link Processor} did not
049 * produce an out, then the in of the previous {@link Processor} is sent as the next in. At the
050 * end of the processing chain, depending on the {@link ExchangePattern Message Exchange Pattern} (or MEP)
051 * the last out (or in of no out available) is sent by the {@link Consumer} back to the original caller.
052 * <p/>
053 * Camel, in addition to providing out-of-the-box a large number of useful processors, it also allows 
054 * you to implement and use your own. When the Exchange is passed to a {@link Processor}, it always 
055 * contains an in {@link Message} and no out {@link Message}. The {@link Processor} <b>may</b> produce 
056 * an out, depending on the nature of the {@link Processor}. The in {@link Message} can be accessed 
057 * using the {@link #getIn()} method. Since the out message is null when entering the {@link Processor}, 
058 * the {@link #getOut()} method is actually a convenient factory method that will lazily instantiate a 
059 * {@link org.apache.camel.impl.DefaultMessage} which you could populate. As an alternative you could 
060 * also instantiate your specialized  {@link Message} and set it on the exchange using the 
061 * {@link #setOut(org.apache.camel.Message)} method. Please note that a {@link Message} contains not only 
062 * the body but also headers and attachments. If you are creating a new {@link Message} the headers and 
063 * attachments of the in {@link Message} are not automatically copied to the out by Camel and you'll have 
064 * to set the headers and attachments you need yourself. If your {@link Processor} is not producing a 
065 * different {@link Message} but only needs to slightly  modify the in, you can simply update the in 
066 * {@link Message} returned by {@link #getIn()}. 
067 * <p/>
068 * See this <a href="http://camel.apache.org/using-getin-or-getout-methods-on-exchange.html">FAQ entry</a> 
069 * for more details.
070 * 
071 */
072public interface Exchange {
073
074    String AUTHENTICATION                   = "CamelAuthentication";
075    String AUTHENTICATION_FAILURE_POLICY_ID = "CamelAuthenticationFailurePolicyId";
076    @Deprecated
077    String ACCEPT_CONTENT_TYPE              = "CamelAcceptContentType";
078    String AGGREGATED_SIZE                  = "CamelAggregatedSize";
079    String AGGREGATED_TIMEOUT               = "CamelAggregatedTimeout";
080    String AGGREGATED_COMPLETED_BY          = "CamelAggregatedCompletedBy";
081    String AGGREGATED_CORRELATION_KEY       = "CamelAggregatedCorrelationKey";
082    String AGGREGATED_COLLECTION_GUARD      = "CamelAggregatedCollectionGuard";
083    String AGGREGATION_STRATEGY             = "CamelAggregationStrategy";
084    String AGGREGATION_COMPLETE_CURRENT_GROUP = "CamelAggregationCompleteCurrentGroup";
085    String AGGREGATION_COMPLETE_ALL_GROUPS  = "CamelAggregationCompleteAllGroups";
086    String AGGREGATION_COMPLETE_ALL_GROUPS_INCLUSIVE  = "CamelAggregationCompleteAllGroupsInclusive";
087    String ASYNC_WAIT                       = "CamelAsyncWait";
088
089    String BATCH_INDEX                = "CamelBatchIndex";
090    String BATCH_SIZE                 = "CamelBatchSize";
091    String BATCH_COMPLETE             = "CamelBatchComplete";
092    String BEAN_METHOD_NAME           = "CamelBeanMethodName";
093    @Deprecated
094    String BEAN_MULTI_PARAMETER_ARRAY = "CamelBeanMultiParameterArray";
095    String BINDING                    = "CamelBinding";
096    // do not prefix with Camel and use lower-case starting letter as its a shared key
097    // used across other Apache products such as AMQ, SMX etc.
098    String BREADCRUMB_ID              = "breadcrumbId";
099
100    String CHARSET_NAME          = "CamelCharsetName";
101    String CIRCUIT_BREAKER_STATE = "CamelCircuitBreakerState";
102    String CREATED_TIMESTAMP     = "CamelCreatedTimestamp";
103    String CONTENT_ENCODING      = "Content-Encoding";
104    String CONTENT_LENGTH        = "Content-Length";
105    String CONTENT_TYPE          = "Content-Type";
106    String COOKIE_HANDLER        = "CamelCookieHandler";
107    String CORRELATION_ID        = "CamelCorrelationId";
108
109    String DATASET_INDEX             = "CamelDataSetIndex";
110    String DEFAULT_CHARSET_PROPERTY  = "org.apache.camel.default.charset";
111    String DESTINATION_OVERRIDE_URL = "CamelDestinationOverrideUrl";
112    String DISABLE_HTTP_STREAM_CACHE = "CamelDisableHttpStreamCache";
113    String DUPLICATE_MESSAGE         = "CamelDuplicateMessage";
114    
115    String DOCUMENT_BUILDER_FACTORY = "CamelDocumentBuilderFactory";
116
117    String EXCEPTION_CAUGHT              = "CamelExceptionCaught";
118    String EXCEPTION_HANDLED             = "CamelExceptionHandled";
119    String EVALUATE_EXPRESSION_RESULT    = "CamelEvaluateExpressionResult";
120    String ERRORHANDLER_CIRCUIT_DETECTED = "CamelFErrorHandlerCircuitDetected";
121    String ERRORHANDLER_HANDLED          = "CamelErrorHandlerHandled";
122    String EXTERNAL_REDELIVERED          = "CamelExternalRedelivered";
123
124    String FAILURE_HANDLED      = "CamelFailureHandled";
125    String FAILURE_ENDPOINT     = "CamelFailureEndpoint";
126    String FAILURE_ROUTE_ID     = "CamelFailureRouteId";
127    String FATAL_FALLBACK_ERROR_HANDLER  = "CamelFatalFallbackErrorHandler";
128    String FILE_CONTENT_TYPE    = "CamelFileContentType";
129    String FILE_LOCAL_WORK_PATH = "CamelFileLocalWorkPath";
130    String FILE_NAME            = "CamelFileName";
131    String FILE_NAME_ONLY       = "CamelFileNameOnly";
132    String FILE_NAME_PRODUCED   = "CamelFileNameProduced";
133    String FILE_NAME_CONSUMED   = "CamelFileNameConsumed";
134    String FILE_PATH            = "CamelFilePath";
135    String FILE_PARENT          = "CamelFileParent";
136    String FILE_LAST_MODIFIED   = "CamelFileLastModified";
137    String FILE_LENGTH          = "CamelFileLength";
138    String FILE_LOCK_FILE_ACQUIRED = "CamelFileLockFileAcquired";
139    String FILE_LOCK_FILE_NAME  = "CamelFileLockFileName";
140    String FILE_LOCK_EXCLUSIVE_LOCK = "CamelFileLockExclusiveLock";
141    String FILE_LOCK_RANDOM_ACCESS_FILE = "CamelFileLockRandomAccessFile";
142    String FILTER_MATCHED       = "CamelFilterMatched";
143    String FILTER_NON_XML_CHARS = "CamelFilterNonXmlChars";
144
145    String GROUPED_EXCHANGE = "CamelGroupedExchange";
146    
147    String HTTP_BASE_URI           = "CamelHttpBaseUri";
148    String HTTP_CHARACTER_ENCODING = "CamelHttpCharacterEncoding";
149    String HTTP_METHOD             = "CamelHttpMethod";
150    String HTTP_PATH               = "CamelHttpPath";
151    String HTTP_PROTOCOL_VERSION   = "CamelHttpProtocolVersion";
152    String HTTP_QUERY              = "CamelHttpQuery";
153    String HTTP_RAW_QUERY          = "CamelHttpRawQuery";
154    String HTTP_RESPONSE_CODE      = "CamelHttpResponseCode";
155    String HTTP_RESPONSE_TEXT      = "CamelHttpResponseText";
156    String HTTP_URI                = "CamelHttpUri";
157    String HTTP_URL                = "CamelHttpUrl";
158    String HTTP_CHUNKED            = "CamelHttpChunked";
159    String HTTP_SERVLET_REQUEST    = "CamelHttpServletRequest";
160    String HTTP_SERVLET_RESPONSE   = "CamelHttpServletResponse";
161
162    String INTERCEPTED_ENDPOINT = "CamelInterceptedEndpoint";
163    String INTERCEPT_SEND_TO_ENDPOINT_WHEN_MATCHED = "CamelInterceptSendToEndpointWhenMatched";
164    String INTERRUPTED = "CamelInterrupted";
165
166    String LANGUAGE_SCRIPT          = "CamelLanguageScript";
167    String LOG_DEBUG_BODY_MAX_CHARS = "CamelLogDebugBodyMaxChars";
168    String LOG_DEBUG_BODY_STREAMS   = "CamelLogDebugStreams";
169    String LOG_EIP_NAME             = "CamelLogEipName";
170    String LOOP_INDEX               = "CamelLoopIndex";
171    String LOOP_SIZE                = "CamelLoopSize";
172
173    String MAXIMUM_CACHE_POOL_SIZE     = "CamelMaximumCachePoolSize";
174    String MAXIMUM_ENDPOINT_CACHE_SIZE = "CamelMaximumEndpointCacheSize";
175    String MAXIMUM_SIMPLE_CACHE_SIZE = "CamelMaximumSimpleCacheSize";
176    String MAXIMUM_TRANSFORMER_CACHE_SIZE = "CamelMaximumTransformerCacheSize";
177    String MAXIMUM_VALIDATOR_CACHE_SIZE = "CamelMaximumValidatorCacheSize";
178    String MESSAGE_HISTORY             = "CamelMessageHistory";
179    String MESSAGE_HISTORY_HEADER_FORMAT      = "CamelMessageHistoryHeaderFormat";
180    String MESSAGE_HISTORY_OUTPUT_FORMAT      = "CamelMessageHistoryOutputFormat";
181    String MULTICAST_INDEX             = "CamelMulticastIndex";
182    String MULTICAST_COMPLETE          = "CamelMulticastComplete";
183
184    String NOTIFY_EVENT = "CamelNotifyEvent";
185
186    String ON_COMPLETION      = "CamelOnCompletion";
187    String OVERRULE_FILE_NAME = "CamelOverruleFileName";
188
189    String PARENT_UNIT_OF_WORK = "CamelParentUnitOfWork";
190    String STREAM_CACHE_UNIT_OF_WORK = "CamelStreamCacheUnitOfWork";
191    
192    String RECIPIENT_LIST_ENDPOINT = "CamelRecipientListEndpoint";
193    String RECEIVED_TIMESTAMP      = "CamelReceivedTimestamp";
194    String REDELIVERED             = "CamelRedelivered";
195    String REDELIVERY_COUNTER      = "CamelRedeliveryCounter";
196    String REDELIVERY_MAX_COUNTER  = "CamelRedeliveryMaxCounter";
197    String REDELIVERY_EXHAUSTED    = "CamelRedeliveryExhausted";
198    String REDELIVERY_DELAY        = "CamelRedeliveryDelay";
199    String REST_HTTP_URI           = "CamelRestHttpUri";
200    String REST_HTTP_QUERY         = "CamelRestHttpQuery";
201    String ROLLBACK_ONLY           = "CamelRollbackOnly";
202    String ROLLBACK_ONLY_LAST      = "CamelRollbackOnlyLast";
203    String ROUTE_STOP              = "CamelRouteStop";
204
205    String REUSE_SCRIPT_ENGINE = "CamelReuseScripteEngine";
206    String COMPILE_SCRIPT = "CamelCompileScript";
207    
208    String SAXPARSER_FACTORY   = "CamelSAXParserFactory";
209
210    String SCHEDULER_POLLED_MESSAGES = "CamelSchedulerPolledMessages";
211    String SOAP_ACTION        = "CamelSoapAction";
212    String SKIP_GZIP_ENCODING = "CamelSkipGzipEncoding";
213    String SKIP_WWW_FORM_URLENCODED = "CamelSkipWwwFormUrlEncoding"; 
214    String SLIP_ENDPOINT      = "CamelSlipEndpoint";
215    String SPLIT_INDEX        = "CamelSplitIndex";
216    String SPLIT_COMPLETE     = "CamelSplitComplete";
217    String SPLIT_SIZE         = "CamelSplitSize";
218
219    String TIMER_COUNTER         = "CamelTimerCounter";
220    String TIMER_FIRED_TIME      = "CamelTimerFiredTime";
221    String TIMER_NAME            = "CamelTimerName";
222    String TIMER_PERIOD          = "CamelTimerPeriod";
223    String TIMER_TIME            = "CamelTimerTime";
224    String TO_ENDPOINT           = "CamelToEndpoint";
225    String TRACE_EVENT           = "CamelTraceEvent";
226    String TRACE_EVENT_NODE_ID   = "CamelTraceEventNodeId";
227    String TRACE_EVENT_TIMESTAMP = "CamelTraceEventTimestamp";
228    String TRACE_EVENT_EXCHANGE  = "CamelTraceEventExchange";
229    String TRY_ROUTE_BLOCK       = "TryRouteBlock";
230    String TRANSFER_ENCODING     = "Transfer-Encoding";
231
232    String UNIT_OF_WORK_EXHAUSTED    = "CamelUnitOfWorkExhausted";
233    
234    /**
235     * @deprecated UNIT_OF_WORK_PROCESS_SYNC is not in use and will be removed in future Camel release
236     */
237    @Deprecated
238    String UNIT_OF_WORK_PROCESS_SYNC = "CamelUnitOfWorkProcessSync";
239
240    String XSLT_FILE_NAME   = "CamelXsltFileName";
241    String XSLT_ERROR       = "CamelXsltError";
242    String XSLT_FATAL_ERROR = "CamelXsltFatalError";
243    String XSLT_WARNING     = "CamelXsltWarning";
244
245    /**
246     * Returns the {@link ExchangePattern} (MEP) of this exchange.
247     *
248     * @return the message exchange pattern of this exchange
249     */
250    ExchangePattern getPattern();
251
252    /**
253     * Allows the {@link ExchangePattern} (MEP) of this exchange to be customized.
254     *
255     * This typically won't be required as an exchange can be created with a specific MEP
256     * by calling {@link Endpoint#createExchange(ExchangePattern)} but it is here just in case
257     * it is needed.
258     *
259     * @param pattern  the pattern 
260     */
261    void setPattern(ExchangePattern pattern);
262
263    /**
264     * Returns a property associated with this exchange by name
265     *
266     * @param name the name of the property
267     * @return the value of the given property or <tt>null</tt> if there is no property for
268     *         the given name
269     */
270    Object getProperty(String name);
271
272    /**
273     * Returns a property associated with this exchange by name
274     *
275     * @param name the name of the property
276     * @param defaultValue the default value to return if property was absent
277     * @return the value of the given property or <tt>defaultValue</tt> if there is no
278     *         property for the given name
279     */
280    Object getProperty(String name, Object defaultValue);
281
282    /**
283     * Returns a property associated with this exchange by name and specifying
284     * the type required
285     *
286     * @param name the name of the property
287     * @param type the type of the property
288     * @return the value of the given property or <tt>null</tt> if there is no property for
289     *         the given name or <tt>null</tt> if it cannot be converted to the given type
290     */
291    <T> T getProperty(String name, Class<T> type);
292
293    /**
294     * Returns a property associated with this exchange by name and specifying
295     * the type required
296     *
297     * @param name the name of the property
298     * @param defaultValue the default value to return if property was absent
299     * @param type the type of the property
300     * @return the value of the given property or <tt>defaultValue</tt> if there is no property for
301     *         the given name or <tt>null</tt> if it cannot be converted to the given type
302     */
303    <T> T getProperty(String name, Object defaultValue, Class<T> type);
304
305    /**
306     * Sets a property on the exchange
307     *
308     * @param name  of the property
309     * @param value to associate with the name
310     */
311    void setProperty(String name, Object value);
312
313    /**
314     * Removes the given property on the exchange
315     *
316     * @param name of the property
317     * @return the old value of the property
318     */
319    Object removeProperty(String name);
320
321    /**
322     * Remove all of the properties associated with the exchange matching a specific pattern
323     *
324     * @param pattern pattern of names
325     * @return boolean whether any properties matched
326     */
327    boolean removeProperties(String pattern);
328    
329    /**
330     * Removes the properties from this exchange that match the given <tt>pattern</tt>, 
331     * except for the ones matching one ore more <tt>excludePatterns</tt>
332     * 
333     * @param pattern pattern of names that should be removed
334     * @param excludePatterns one or more pattern of properties names that should be excluded (= preserved)
335     * @return boolean whether any properties matched
336     */ 
337    boolean removeProperties(String pattern, String... excludePatterns);
338    
339    /**
340     * Returns all of the properties associated with the exchange
341     *
342     * @return all the headers in a Map
343     */
344    Map<String, Object> getProperties();
345
346    /**
347     * Returns whether any properties has been set
348     *
349     * @return <tt>true</tt> if any properties has been set
350     */
351    boolean hasProperties();
352
353    /**
354     * Returns the inbound request message
355     *
356     * @return the message
357     */
358    Message getIn();
359
360    /**
361     * Returns the inbound request message as the given type
362     *
363     * @param type the given type
364     * @return the message as the given type or <tt>null</tt> if not possible to covert to given type
365     */
366    <T> T getIn(Class<T> type);
367
368    /**
369     * Sets the inbound message instance
370     *
371     * @param in the inbound message
372     */
373    void setIn(Message in);
374
375    /**
376     * Returns the outbound message, lazily creating one if one has not already
377     * been associated with this exchange.
378     * <p/>
379     * <br/><b>Important:</b> If you want to change the current message, then use {@link #getIn()} instead as it will
380     * ensure headers etc. is kept and propagated when routing continues. Bottom line end users should rarely use
381     * this method.
382     * <p/>
383     * <br/>If you want to test whether an OUT message have been set or not, use the {@link #hasOut()} method.
384     * <p/>
385     * See also the class java doc for this {@link Exchange} for more details and this
386     * <a href="http://camel.apache.org/using-getin-or-getout-methods-on-exchange.html">FAQ entry</a>.
387     *
388     * @return the response
389     * @see #getIn()
390     */
391    Message getOut();
392
393    /**
394     * Returns the outbound request message as the given type
395     * <p/>
396     * <br/><b>Important:</b> If you want to change the current message, then use {@link #getIn()} instead as it will
397     * ensure headers etc. is kept and propagated when routing continues. Bottom line end users should rarely use
398     * this method.
399     * <p/>
400     * <br/>If you want to test whether an OUT message have been set or not, use the {@link #hasOut()} method.
401     * <p/>
402     * See also the class java doc for this {@link Exchange} for more details and this
403     * <a href="http://camel.apache.org/using-getin-or-getout-methods-on-exchange.html">FAQ entry</a>.
404     *
405     * @param type the given type
406     * @return the message as the given type or <tt>null</tt> if not possible to covert to given type
407     * @see #getIn(Class)
408     */
409    <T> T getOut(Class<T> type);
410
411    /**
412     * Returns whether an OUT message has been set or not.
413     *
414     * @return <tt>true</tt> if an OUT message exists, <tt>false</tt> otherwise.
415     */
416    boolean hasOut();
417
418    /**
419     * Sets the outbound message
420     *
421     * @param out the outbound message
422     */
423    void setOut(Message out);
424
425    /**
426     * Returns the exception associated with this exchange
427     *
428     * @return the exception (or null if no faults)
429     */
430    Exception getException();
431
432    /**
433     * Returns the exception associated with this exchange.
434     * <p/>
435     * Is used to get the caused exception that typically have been wrapped in some sort
436     * of Camel wrapper exception
437     * <p/>
438     * The strategy is to look in the exception hierarchy to find the first given cause that matches the type.
439     * Will start from the bottom (the real cause) and walk upwards.
440     *
441     * @param type the exception type
442     * @return the exception (or <tt>null</tt> if no caused exception matched)
443     */
444    <T> T getException(Class<T> type);
445
446    /**
447     * Sets the exception associated with this exchange
448     * <p/>
449     * Camel will wrap {@link Throwable} into {@link Exception} type to
450     * accommodate for the {@link #getException()} method returning a plain {@link Exception} type.
451     *
452     * @param t  the caused exception
453     */
454    void setException(Throwable t);
455
456    /**
457     * Returns true if this exchange failed due to either an exception or fault
458     *
459     * @return true if this exchange failed due to either an exception or fault
460     * @see Exchange#getException()
461     * @see Message#setFault(boolean)
462     * @see Message#isFault()
463     */
464    boolean isFailed();
465
466    /**
467     * Returns true if this exchange is transacted
468     */
469    boolean isTransacted();
470
471    /**
472     * Returns true if this exchange is an external initiated redelivered message (such as a JMS broker).
473     * <p/>
474     * <b>Important: </b> It is not always possible to determine if the message is a redelivery
475     * or not, and therefore <tt>null</tt> is returned. Such an example would be a JDBC message.
476     * However JMS brokers provides details if a message is redelivered.
477     *
478     * @return <tt>true</tt> if redelivered, <tt>false</tt> if not, <tt>null</tt> if not able to determine
479     */
480    Boolean isExternalRedelivered();
481
482    /**
483     * Returns true if this exchange is marked for rollback
484     */
485    boolean isRollbackOnly();
486
487    /**
488     * Returns the container so that a processor can resolve endpoints from URIs
489     *
490     * @return the container which owns this exchange
491     */
492    CamelContext getContext();
493
494    /**
495     * Creates a copy of the current message exchange so that it can be
496     * forwarded to another destination
497     * <p/>
498     * Notice this operation invokes <tt>copy(false)</tt>
499     */
500    Exchange copy();
501
502    /**
503     * Creates a copy of the current message exchange so that it can be
504     * forwarded to another destination
505     *
506     * @param safeCopy whether to copy exchange properties and message headers safely to a new map instance,
507     *                 or allow sharing the same map instances in the returned copy.
508     */
509    Exchange copy(boolean safeCopy);
510
511    /**
512     * Returns the endpoint which originated this message exchange if a consumer on an endpoint
513     * created the message exchange, otherwise this property will be <tt>null</tt>
514     */
515    Endpoint getFromEndpoint();
516
517    /**
518     * Sets the endpoint which originated this message exchange. This method
519     * should typically only be called by {@link org.apache.camel.Endpoint} implementations
520     *
521     * @param fromEndpoint the endpoint which is originating this message exchange
522     */
523    void setFromEndpoint(Endpoint fromEndpoint);
524    
525    /**
526     * Returns the route id which originated this message exchange if a route consumer on an endpoint
527     * created the message exchange, otherwise this property will be <tt>null</tt>
528     */
529    String getFromRouteId();
530
531    /**
532     * Sets the route id which originated this message exchange. This method
533     * should typically only be called by the internal framework.
534     *
535     * @param fromRouteId the from route id
536     */
537    void setFromRouteId(String fromRouteId);
538
539    /**
540     * Returns the unit of work that this exchange belongs to; which may map to
541     * zero, one or more physical transactions
542     */
543    UnitOfWork getUnitOfWork();
544
545    /**
546     * Sets the unit of work that this exchange belongs to; which may map to
547     * zero, one or more physical transactions
548     */
549    void setUnitOfWork(UnitOfWork unitOfWork);
550
551    /**
552     * Returns the exchange id (unique)
553     */
554    String getExchangeId();
555
556    /**
557     * Set the exchange id
558     */
559    void setExchangeId(String id);
560
561    /**
562     * Adds a {@link org.apache.camel.spi.Synchronization} to be invoked as callback when
563     * this exchange is completed.
564     *
565     * @param onCompletion  the callback to invoke on completion of this exchange
566     */
567    void addOnCompletion(Synchronization onCompletion);
568
569    /**
570     * Checks if the passed {@link org.apache.camel.spi.Synchronization} instance is
571     * already contained on this exchange.
572     *
573     * @param onCompletion  the callback instance that is being checked for
574     * @return <tt>true</tt>, if callback instance is already contained on this exchange, else <tt>false</tt>
575     */
576    boolean containsOnCompletion(Synchronization onCompletion);
577
578    /**
579     * Handover all the on completions from this exchange to the target exchange.
580     *
581     * @param target the target exchange
582     */
583    void handoverCompletions(Exchange target);
584
585    /**
586     * Handover all the on completions from this exchange
587     *
588     * @return the on completions
589     */
590    List<Synchronization> handoverCompletions();
591
592    /**
593     * Gets the timestamp when this exchange was created.
594     */
595    Date getCreated();
596
597}