Very quick response:

Note the issue here is whether classes extend ServiceMBeanSupport, not whether they expose a JMX interface.

Also, have a look at http://www.jboss.com/index.html?module=bb&op=viewtopic&t=118608 . Came up a couple weeks back. Showed me a benefit of subclassing ServiceMBeanSupport -- get to take advantage of the already coded methods that prevent duplicate lifecycle invocations when a MC bean is annotated with @JMX.

"galder.zamarreno@jboss.com" wrote:

+ Barrier, BarrierController, HASingletonController, HASingletonSupport and HAServiceMBeanSupport

HASingletonController extends HASingletonSupport which sends notifications related to node becoming coordinator, or node stopping being coordinator. BarrierControler is the listener of these notifications, who's job is to start/stop of dependant services. Barrier is wrapper around the dependant service, which is started/stopped upon BarrierController's command via lifecycle methods.

1. BarrierController listens for JMX notifications, so should probably remain the same. Does not seem to make much sense to have JMX pulled out because it's its core business.

2. Whether Barrier should be JMX aware is debatable. Extends ServiceMBeanSupport directly and does little more. It's a mere delegator.

3. HASingletonController does nothing JMX related, except publicise (via getters) the configuration options for target start/stop methods. Needs JMX factoring out IMO.

4. HASingletonSupport knows when a node is coordinator or not, and via its parent, sends JMX notifications (only local notifications). HAServiceMBeanSupport can send JMX notifications locally or broadcast them accross the cluster. Both rely heavily on JMX functionality, so could stay the same.
5.- 5.- JBAS-3982 should take in account the decision on HAServiceMBeanSupport, which provides infrastructure for cluster wide notifications"

+ HASingletonElectionPolicyBase and HASingletonElectionPolicySimple

This is new functionality to decide where to run HA singleton services instead of the coordinator. It makes sense to factor JMX out of these classes to separate functionality from any JMX managed methods. An election policy should be independent, like the load balance policies.

+ FarmMemberService

+ ClusterPartition

Does not make sense to have a non JMX version.

+ UnifiedInvoker and UnifiedInvokerHA

I'm not going to discuss legacy invokers here because they should remain as they are for backwards compatibility. To discuss JMX factoring out, let's focus on the unified invokers.

To factor out JMX from invokers makes sense to help unit testing and potentially make path for them to be migrated to Remoting (there's a JIRA on this) and be used standalone. It would also make my life a lot easier unit testing JBAS-4455 :)

+ DetachedHANamingService and HANamingService

DetachedHANamingService uses JMX (via Query) to find an HAPartition with a given name via findHAPartitionWithName method. Couldn't find any references to this method and it's not a managed method either.

+ HASessionStateService

This looks like legacy code, so no need to touch it?

+ PingJndi

Once again, legacy code?

Thoughts? Comments? Bored? :)

"bstansberry@jboss.com" wrote:

Note the issue here is whether classes extend ServiceMBeanSupport, not whether they expose a JMX interface.

HASingletonController can have the target bean directly injected, in which case it will not invoke the target's methods via JMX.

Your comment about @StartSingleton, etc. is valid, but lets defer to a different discussion. Not going to happen for beta3.

What does a class gain by subclassing ServiceMBeanSupport:

1) Benefits from the lifecycle coding. Stuff that prevents startService() being called again when service is already started, etc.
2) Support for exposing service lifecycle state as an mbean attribute (getState())
3) I gets a ref to the mbean server when an instance is registered in JMX. Can use that to make JMX calls.
4) Probably others; part of task is to identify and see if relevant

1) and 2) are conceptually different from 3). Illustration:

Class implements the lifecycle methods; deployed by MC as a pojo service. MC invokes lifecycle methods.

In the -beans.xml the bean is annotated with @JMX. Sole purpose of this is to get the bean registered in JMX. Doing this is not a functional requirement of the class; it's a deployment decision for *that particular instance of the class*. MC will create a JMX proxy to the service and deploy that as well. When the proxy is deployed, the create/start/stop/destroy methods get called *again*. This is where benefit 1) is useful. You could get the same benefit by coding equivalent #1 functionality in the bean class itself, or in some PojoServiceSupport superclass.

If the class needs to use the mbean server to do its work, then you start getting into benefit #3. You need a ref to the server.

What I want here is the #3 cases isolated, particularly for the HASingletonController/HASingletonSupport. That class should be usable without it having a ref to an MBeanServer if:

1) user doesn't need the JMX notifications
2) user configures the deployment to dependency inject the target rather than injecting an ObjectName.
3) Other things you might find by digging.

Don't worry about making DetachedHANamingService not extend ServiceMBeanSupport. It's the singleton stuff where I can imagine wanting to have a lot of deployment flexibility.