[jira] Created: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

classic Classic list List threaded Threaded
29 messages Options
12
Reply | Threaded
Open this post in threaded view
|

[jira] Created: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
------------------------------------------------------------------------------------------

                 Key: CAMEL-901
                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
             Project: Apache Camel
          Issue Type: Bug
          Components: camel-core
    Affects Versions: 1.4.0, 1.3.0, 1.2.0, 1.1.0, 1.0.0, 1.5.0
            Reporter: Bela Vizy
         Attachments: BelasErrorHandlerLoggingTest.java

Setup:

Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.

Bug #1:

The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
It should be redeliver to #3 (this works without the thread processor).

Bug #2:

The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).

See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.


--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Updated: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org

     [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Bela Vizy updated CAMEL-901:
----------------------------

    Attachment: BelasErrorHandlerLoggingTest.java

Unit Test

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>         Attachments: BelasErrorHandlerLoggingTest.java
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Updated: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

     [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Bela Vizy updated CAMEL-901:
----------------------------

    Attachment: camel-core-test.log

Log messages for the unit test

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46344#action_46344 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

Ad #1)
Not a bug. Your route is a pipeline (pipes and filters) http://activemq.apache.org/camel/pipes-and-filters.html

So the routing is: from -> process1 -> process2 -> process3. So when the message is redelivered it starts all over again at the *from* and this should be routed through the pipeline again

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46345#action_46345 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

Ad #2)
Not a bug. Its the original exchange that is received, that is passed to the error handler.
E.g. so you can move the message to a JMS queue and later move the message back again to consume the *original* exchange.

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Resolved: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

     [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Claus Ibsen resolved CAMEL-901.
-------------------------------

    Fix Version/s: 1.5.0
       Resolution: Working as Designed

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46349#action_46349 ]

Bela Vizy commented on CAMEL-901:
---------------------------------

#1
Well, not so fast. Take out the thread() and it will behave differently, they way I suggested it, that is it will re-deliver to the #3 processor where the failure occurred.

I guess I mistook a feature for a bug :) The doc is not clear about the redelivery behavior (or I should RTFM). My $0.02 is that if we use the pipeline() then it should re-deliver to the pipe otherwise the failing processor.

#2 That makes sense if it re-delivers to the pipe...

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Assigned: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

     [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Claus Ibsen reassigned CAMEL-901:
---------------------------------

    Assignee: Claus Ibsen

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46354#action_46354 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

#1

Camel is smart but *not* that smart. When it do redelivery it does not know which route steps last time was successful, it always start *all over again*.

Okay so there might be a bug/issue if it works different depending if you have thread or no thread. I will look into it.

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Reopened: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

     [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Claus Ibsen reopened CAMEL-901:
-------------------------------


> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46355#action_46355 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

#2

Ah each step with the processors are again wrapped in a DeadLetterChannel and thus Camel should retry at the processor that failed. And in this case at the last processor.



> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46455#action_46455 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

Could be related to useing seda as the queue. We have seen some timing issues with high concurrency with seda queues.

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46459#action_46459 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

Using the new handled(true) DSL and onException works.

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46493#action_46493 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

Also test with direct queue instead of seda

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46587#action_46587 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

#3
Thread adds a nested pipeline that yet again adds a DLC. Then when the exchange has been failure handled by the inner DLC then its 'thrown' back to the outer DLC that yet again will try to handle it.

ThreadType#createProcessor adds the nested Pipeline. Maybe we can avoid this.

#4
Because of the nested Pipeline and it's copy result nature it creates a new exchange id that get's routed by the outer Pipeline, and thus by magic there is 2 messages being routed, and not only one.

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46588#action_46588 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

#5
The inner processing in the Pipeline is missing the exception handled check that the outer processor has

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46589#action_46589 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

#6
And the DLC should also have this exception handled check in it's processing code

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46590#action_46590 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

TODO: Reminder to me. DefaultExchange when copy from parent - I think we should copy the exchange id as well

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Work started: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

     [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Work on CAMEL-901 started by Claus Ibsen.

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

Reply | Threaded
Open this post in threaded view
|

[jira] Commented: (CAMEL-901) If using thread() processor followed by a pipeline Camel redelivers to the wrong processor

JIRA jira@apache.org
In reply to this post by JIRA jira@apache.org

    [ https://issues.apache.org/activemq/browse/CAMEL-901?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=46591#action_46591 ]

Claus Ibsen commented on CAMEL-901:
-----------------------------------

TODO: exchangeId should not be lazy initialized I think, it should not depend on a DEBUG log or toString to init it

> If using thread() processor followed by a pipeline Camel redelivers to the wrong processor
> ------------------------------------------------------------------------------------------
>
>                 Key: CAMEL-901
>                 URL: https://issues.apache.org/activemq/browse/CAMEL-901
>             Project: Apache Camel
>          Issue Type: Bug
>          Components: camel-core
>    Affects Versions: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0, 1.5.0
>            Reporter: Bela Vizy
>            Assignee: Claus Ibsen
>             Fix For: 1.5.0
>
>         Attachments: BelasErrorHandlerLoggingTest.java, camel-core-test.log
>
>
> Setup:
> Error handler is specified before the thread processor and there are 3 processor after the thread() call. Third processor fails.
> Bug #1:
> The exchange received by the failed processor (#3) gets redelivered to the first processor in the pipe.
> It should be redeliver to #3 (this works without the thread processor).
> Bug #2:
> The specified errorHandler (log:testError) receives the exchange that entered processor #1 (first in the pipe).
> See details in the attached unit test. Also take a look at the log4j log (copy attached). The 3rd line from the bottom is the log by testError.

--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.

12