[JBoss JIRA] (JBTM-2424) Change hornetq dependency to the journal only
by Michael Musgrove (JIRA)
Michael Musgrove created JBTM-2424:
--------------------------------------
Summary: Change hornetq dependency to the journal only
Key: JBTM-2424
URL: https://issues.jboss.org/browse/JBTM-2424
Project: JBoss Transaction Manager
Issue Type: Task
Components: Transaction Core
Affects Versions: 5.1.1
Reporter: Michael Musgrove
Assignee: Michael Musgrove
Priority: Optional
Fix For: 5.next
Currently we depend on hornetq-core. The later releases provide a hornetq-journal artifact that we use instead.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove updated JBTM-2423:
-----------------------------------
Status: Resolved (was: Pull Request Sent)
Resolution: Done
The fix will be available in the next narayana 5.1.x release. If it needs back porting then we will need to create a 5.0.6 release.
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Michael Musgrove
> Fix For: 5.next
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove updated JBTM-2423:
-----------------------------------
Fix Version/s: 5.next
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Michael Musgrove
> Fix For: 5.next
>
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove commented on JBTM-2423:
----------------------------------------
I added a line in orbportability/ORB.java to ensure that destroy is/has already been called on our root poa wrapper. This means that if whoever called shutdown on our ORB wrapper forgets to explicitly destroy it then we will do so guaranteeing that our pre/post poa destroy hooks get invoked.
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Michael Musgrove
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove commented on JBTM-2423:
----------------------------------------
Mark, you are correct. We are calling destroy on our own wrapper which does indeed do some extra work. I will revisit the fix, thanks.
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Michael Musgrove
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Michael Musgrove (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Michael Musgrove commented on JBTM-2423:
----------------------------------------
Since the run loop for JavaIdlRCServiceInit._orb has finished some code somewhere must have already called shutdown on it. The spec says that shutdown calls destroy on the root poa which in turn calls shutdown on its immediate descendants. So when the run loop finishes the code I have removed should effectively already have been called (ie both the shutdown on the orb and the destroy on the object adaptor).
The relevant bits of the spec I refer to are 4.2.5.4 shutdown
{quote}
Additionally in systems that have Portable Object Adapters (see Chapter 11)
shutdown behaves as if POA::destroy is called on the Root POA with its first
parameter set to TRUE and the second parameter set to the value of the
wait_for_completion parameter that shutdown is invoked with.
{quote}
and
{quote}
And POA::destroy will call destroy on all of its immediate descendants.
{quote}
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Michael Musgrove
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months
[JBoss JIRA] (JBTM-2423) ORBRunner uses the orb after run() returns
by Mark Little (JIRA)
[ https://issues.jboss.org/browse/JBTM-2423?page=com.atlassian.jira.plugin.... ]
Mark Little commented on JBTM-2423:
-----------------------------------
In the change you've removed ...
try
- {
- if (JavaIdlRCServiceInit._oa != null)
- JavaIdlRCServiceInit._oa.destroy();
-
- if (JavaIdlRCServiceInit._orb != null)
- JavaIdlRCServiceInit._orb.shutdown();
- }
- catch (Exception ex)
- {
- }
Have you checked through the code paths to make sure we're not relying on OA destroy or ORB shutdown to do trigger something else?
> ORBRunner uses the orb after run() returns
> ------------------------------------------
>
> Key: JBTM-2423
> URL: https://issues.jboss.org/browse/JBTM-2423
> Project: JBoss Transaction Manager
> Issue Type: Bug
> Reporter: Michael Musgrove
> Assignee: Michael Musgrove
>
> ORBRunner.java starts an orb using orb().run() but then performs operations on the orb after the run() method returns. According to the CORBA spec this is invalid:
> {quote}
> Once an ORB has shutdown, only object reference management operations(duplicate,
> release and is_nil) may be invoked on the ORB or any object reference obtained
> from it.
> {quote}
> Note that when the orb.run() method returns the orb has shutdown because, for the run method, the spec states:
> {quote}
> This operation will block until the ORB has completed the shutdown process,
> {quote}
> This issue has arisen because of a change made to our fork of the jdk orb: in the jdk orb shutdown method we join with all the orb runners. This results in deadlock:
> # com.arjuna.orbportability.ORB.shutdown is a synchronized method and it calls shutdown on the jdk orb;
> # shutdown on the jdk orb notifies the ORBRunner thread which now tries to call back into a synchronized method of com.arjuna.orbportability.ORB but is blocked because the monitor is held
> # at this point the jdk orb shutdown would normally then return allowing the
> the ORBRunner thread to make progress but a recent change now means that the jdk orb shutdown method performs a join() on the various ORBRunner threads
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
9 years, 6 months