jboss-eap-6 HA singleton deploying multiple web archives in standalone configuration - jboss

Question

I am able to deploy my ear and wars in my standalone cluster. 2 of my wars are for the HA singleton. Soon after starting the first standalone jboss-eap-6, I start the second. When all my applications have deployed successfully I open J-Console, I notice that one of my singleton war is running on the first jboss-eap-6 and the second singleton war is running on the second jboss-eap-6. Also in Jconsole, there was only 1 jboss-eap-6 reporting as primary.
My question is: Is there some way in jboss-eap-6 standalone.xml I can force only 1 jboss-eap-6 to run the singleton HA wars. Or would I have to package the wars into an ear?

Answer 1

I don't think there is anything in standalone.xml that would change the behaviour of a war. In any case you should be using standalone-ha.xml for a cluster with HA singletons deployed.
The JBoss High Availability Singleton architecture changed significantly between JBoss EAP 5 and 6.
Under JBoss EAP 5 you just placed your deployable object in a deploy-hasingleton special deployment folder. Under JBoss EAP 6 your classes need to implement a JBoss Service Layer, specifically org.jboss.msc.service.Service along with a org.jboss.msc.service.ServiceActivator. it is the implementation of these service classes that control the instantiation and management of your HA Singleton. I have not tried deploying a hasingleton as a war and I have some doubts because I suspect the dependent service classes may not be available in the web container.
The ServiceActivator is responsible for managing the lifecycle of the Service. The ServiceActivator implementation class needs to be listed in a file META-INF/service/org.jboss.msc.service.ServiceActivator for JBoss to activate it during its startup / deployment.
Example:
Create a Service Activator
public abstract class SingletonActivator<T extends Serializable> implements ServiceActivator {
#Override
public SingletonService<String> instantiateSingleton() {
return new SingletonService<String>();
}
public ServiceName getServiceName() {
return ServiceName.JBOSS.append("my", "ha", "singleton");
}
/**
* Activated by the Service Activator
*
* #param service
* #param serviceName
* - the Singleton Service Name that is registered in the JBOSS cluster
*/
#Override
public final void activate(ServiceActivatorContext context) {
SingletonService<T> service = instantiateSingleton();
SingletonService<T> singleton = new SingletonService<T>(service, getServiceName());
/*
* The NamePreference is a combination of the node name (-Djboss.node.name) and the name of
* the configured cache "singleton". If there is more than 1 node, it is possible to add more than
* one name and the election will use the first available node in that list.
*/
// e.g. singleton.setElectionPolicy(new PreferredSingletonElectionPolicy(new SimpleSingletonElectionPolicy(), new NamePreference("node1/singleton")));
// or singleton.setElectionPolicy(new PreferredSingletonElectionPolicy(new SimpleSingletonElectionPolicy(), new NamePreference("node1/singleton"), new
// NamePreference("node2/singleton")));
singleton.build(new DelegatingServiceContainer(context.getServiceTarget(), context.getServiceRegistry())).setInitialMode(ServiceController.Mode.ACTIVE).install();
}
}
Create A HA Singleton Service Class that is solely responsible for looking up and invoking your EJB containing your business logic
public class SingletonService<T> implements Service<T> {
protected ScheduledExecutorService deployDelayThread = null;
/**
* The node we are running on
*/
protected String nodeName;
/**
* A flag whether the service is started (or scheduled to be started)
*/
protected final AtomicBoolean started = new AtomicBoolean(false);
/**
* Container life cycle call upon activation. This will construct the singleton instance in this JVM and start the Timer.
*/
#Override
public final void start(StartContext context) throws StartException {
this.nodeName = System.getProperty("jboss.node.name");
logger.info("Starting service '" + this.getClass().getName() + "' on node " + nodeName);
if (!started.compareAndSet(false, true)) {
throw new StartException("The service " + this.getClass().getName() + " is still started!");
}
// MSC does not allow this thread to be blocked so we let the service know that the start is asynchronous and the result will be advised later.
// We delay the actual deployment of the Singleton for a few seconds to allow time for a HASingleton Election to be held and won by one of the instances.
// If the winner is not this instance (prior to deployemnt) then stop(Context) is invoked which sets started to false and the deployment does not occur.
// context.asynchronous();
deployDelayThread.schedule(new StartSingletonAsync(context), 10, TimeUnit.SECONDS);
context.complete();
}
/** Introduces a 5s delay in starting the Singleton bean giving time for the the ha singleton election to be held and won */
private class StartSingletonAsync implements Runnable {
private StartSingletonAsync(StartContext context) {
}
#Override
public void run() {
try {
startSingletonBean();
} catch (StartException e) {
logger.info("Start Exception", e);
}
// be nice to the garbage collector, we don't need this any more
deployDelayThread.shutdown();
deployDelayThread = null;
}
}
private void startSingletonBean() throws StartException {
try {
if (!started.get()) {
throw new StartException("Aborted due to service stopping");
}
// Start your EJB
InitialContext ic = new InitialContext();
bean = ic.lookup(getJndiName());
bean.startHaSingleton();
logger.info("*** Master Only: HASingleton service " + getJndiName() + " started on master:" + nodeName);
if (!bean.isRunning()) {
logger.error("ERROR Bean should be running");
}
} catch (NamingException e) {
throwStartException(e);
}
}
private void throwStartException(Exception e) throws StartException {
String message = "Could not initialize HASingleton" + getJndiName() + " on " + nodeName;
logger.error(message, e);
throw new StartException(message, e);
}
/**
* Container life cycle call when activated
*/
#Override
public final void stop(StopContext context) {
if (deployDelayThread != null) {
deployDelayThread.shutdownNow();
}
if (!started.compareAndSet(true, false) || bean == null) {
logger.warn("The service '" + this.getClass().getName() + "' is not active!");
} else {
try {
InitialContext ic = new InitialContext();
bean = (JmxMBean) ic.lookup(getJndiName());
bean.stopHaSingleton();
logger.info("*** Master Only: HASingleton service " + getJndiName() + " stopped on master:" + nodeName);
} catch (EJBException e) {
// Note: all these exceptions are already logged by JBoss
} catch (NamingException e) {
logger.error("Could not stop HASingleton service " + getJndiName() + " on " + nodeName, e);
}
logger.info("MASTER ONLY HASingleton service '" + this.getClass().getName() + "' Stopped on node " + nodeName);
}
}
private String getJndiName() {
return "java.global/path/to/your/singleton/ejb";
}
}
Finally list your Activator class in META-INF/servcie/org.jboss.msc.service.ServiceActivator
com.mycompany.singletons.SingletonActivator
You may also need to add dependencies to the manifest META-INF/MANIFEST.MF file inside your jar as follows: Dependencies: org.jboss.msc, org.jboss.as.clustering.singleton, org.jboss.as.server
There is a more extensive implementation guide available from Redhat at https://access.redhat.com/documentation/en-US/JBoss_Enterprise_Application_Platform/6.4/html/Development_Guide/Implement_an_HA_Singleton.html. You may need to create a Redhat account to access this. There is also a quickstart example in the JBoss distribution.

Answer 2

So after further evaluation, the 2 singletons eventually would merge together after a few minutes, thus creating 1 intended singleton.