com.bigdata.jini.start
Class ServiceConfigurationZNodeMonitorTask

java.lang.Object
  com.bigdata.jini.start.ServiceConfigurationZNodeMonitorTask

All Implemented Interfaces:

Callable<Void>

public class ServiceConfigurationZNodeMonitorTask
extends Object
implements Callable<Void>

This is a standing task whose Future is monitored by the ServicesManagerServer. For each ServiceConfiguration znode, there is one such task per ServicesManagerServer. The task holding the ZLock is the one that handles state changes for ServiceConfiguration znode, including its children, which are the logical service instance znodes.

If the ServicesManagerServer dies, then its znodes will be deleted from the lock queues and someone else (if anyone is left alive) will get the lock and manage the logical service.

If the task itself dies, then the ServicesManagerServer needs to log an error and create a new instance of the task.

Version:

$Id$

Author:

Bryan Thompson

Field Summary

protected String	className
protected static boolean	DEBUG
protected JiniFederation	fed
protected static boolean	INFO
protected IServiceListener	listener
protected static org.apache.log4j.Logger	log

Constructor Summary

ServiceConfigurationZNodeMonitorTask(JiniFederation fed, IServiceListener listener, String className)

Method Summary

protected void	acquireLockAndRun() Waits until it acquires the lock and then runWithLock(ZLock)
protected void	balanceAll(ManagedServiceConfiguration config, String[] watchedSet)
protected void	balanceLogicalServices(ManagedServiceConfiguration config) Consider the logical service instances for the ServiceConfiguration and if necessary makes an adjustment to the #of logical services that are running.
protected void	balancePhysicalServices(ManagedServiceConfiguration config, String[] watchedSet) Consider all the physical service containers and initiates a competition to create or destroy a physical service instance for each logical service that is out of balance.
Void	call() Contends for a ZLock on #zpath and then maintains a balance between: (a) the ServiceConfiguration state for a service type; (b) the #of logical service instances for that service type; and (c) the #of physical service instances for any logical service instance for that service type.
protected void	handleEvent(com.bigdata.jini.start.ServiceConfigurationZNodeMonitorTask.ServiceConfigurationHierarchyWatcher watcher, org.apache.zookeeper.WatchedEvent e) Handle a WatchedEvent that was read from a queue.
protected void	runWithLock(ZLock zlock) Runs with the zlock held.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

log

protected static final org.apache.log4j.Logger log

INFO

protected static final boolean INFO

DEBUG

protected static final boolean DEBUG

fed

protected final JiniFederation fed

listener

protected final IServiceListener listener

className

protected final String className

Constructor Detail

ServiceConfigurationZNodeMonitorTask

public ServiceConfigurationZNodeMonitorTask(JiniFederation fed,
                                            IServiceListener listener,
                                            String className)

Parameters:

fed -

className - The class name (aka service type).

Method Detail

call

public Void call()
          throws Exception

Contends for a ZLock on #zpath and then maintains a balance between: (a) the ServiceConfiguration state for a service type; (b) the #of logical service instances for that service type; and (c) the #of physical service instances for any logical service instance for that service type.

The set of znodes to be watched is dynamic. Its only fixed fixed member is the ServiceConfiguration znode. We need to change the watch set as new logical services are created or destroyed and as new physical services are created or destroyed.

This only watch znodes and takes action while the ZLock is held. If it looses the ZLock, it will seek to re-acquire the lock. No actions are taken in the zookeeper event thread. They are all pushed into a queue and then processed in the thread that executes call(). The queue also prevents us from attempting to make more than one adjustment to the managed services at a time.

Note: This task is designed to run until cancelled. It will trap anything but an InterruptedException and restart from acquireLockAndRun().

Specified by:

call in interface Callable<Void>

Throws:

Exception

acquireLockAndRun

protected void acquireLockAndRun()
                          throws Exception

Waits until it acquires the lock and then runWithLock(ZLock)

Throws:

Exception

runWithLock

protected void runWithLock(ZLock zlock)
                    throws Exception

Runs with the zlock held.

Parameters:

zlock -

Throws:

Exception

balanceAll

protected void balanceAll(ManagedServiceConfiguration config,
                          String[] watchedSet)
                   throws Exception

Parameters:

config -

watchedSet -

Throws:

Exception

balanceLogicalServices

protected void balanceLogicalServices(ManagedServiceConfiguration config)
                               throws Exception

Consider the logical service instances for the ServiceConfiguration and if necessary makes an adjustment to the #of logical services that are running.

Parameters:

config - A recent snapshot of the ServiceConfiguration state.

Throws:

Exception

balancePhysicalServices

protected void balancePhysicalServices(ManagedServiceConfiguration config,
                                       String[] watchedSet)
                                throws org.apache.zookeeper.KeeperException,
                                       InterruptedException

Consider all the physical service containers and initiates a competition to create or destroy a physical service instance for each logical service that is out of balance. The competition itself is handled by the MonitorCreatePhysicalServiceLocksTask, which watches a well known znode for the appearence of new lock nodes and then enters into a competition to create a new physical service instance. Therefore while this initiates the competition for processing to handle the imbalance, the imbalance is NOT correct while we are in this method.

Parameters:

config - A recent snapshot of the ServiceConfiguration state.

watchedSet - The set of watched znodes (this includes the physical service containers, which is what we need here).

Throws:

InterruptedException

org.apache.zookeeper.KeeperException

handleEvent

protected void handleEvent(com.bigdata.jini.start.ServiceConfigurationZNodeMonitorTask.ServiceConfigurationHierarchyWatcher watcher,
                           org.apache.zookeeper.WatchedEvent e)
                    throws Exception

Handle a WatchedEvent that was read from a queue.

• If the path is the ServiceConfiguration znode itself, then we need to test ALL watched logicalService znodes and ALL watched physicalService znodes. This is identical to the setup procedure when we gain the ZLock and setup the ServiceConfigurationHierarchyWatcher.
• If the path is a logical service, then we want to compare its replication count (on the service configuration znode) to the #of physical service instances AND we also want to compare the #of logical services to the service count (on the service configuration znode). This is a top-down trigger.
• If the path is a physical service, then we want to compare replication count (on the service configuration znode) to the #of physical service instances. This provides a bottom up trigger for rebalancing.

Note: Since the events were read from a queue, this method runs in the application thread NOT the zookeeper event thread.

Throws:

Exception