/*
      Copyright 2008 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.context;
  
  import static fulmine.util.Utils.CLOSE_BRACE;
  import static fulmine.util.Utils.COLON;
  import static fulmine.util.Utils.OPEN_BRACE;
  import static fulmine.util.Utils.SPACE;
  import static fulmine.util.Utils.logException;
  import static fulmine.util.Utils.nullCheck;
  
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TimerTask;
  
  import org.apache.commons.lang.SystemUtils;
  
  import fulmine.AbstractLifeCycle;
  import fulmine.Domain;
  import fulmine.IDomain;
  import fulmine.ILifeCycle;
  import fulmine.IType;
  import fulmine.Type;
  import fulmine.distribution.IDistributionManager;
  import fulmine.distribution.IHeartbeatMonitor;
  import fulmine.distribution.channel.IChannel;
  import fulmine.distribution.connection.IConnectionBroker;
  import fulmine.distribution.connection.IConnectionDiscoverer;
  import fulmine.distribution.connection.IConnectionParameters;
  import fulmine.distribution.events.ContextDiscoveredEvent;
  import fulmine.event.IEvent;
  import fulmine.event.listener.AbstractEventHandler;
  import fulmine.event.listener.IEventListener;
  import fulmine.event.listener.MultiSystemEventListener;
  import fulmine.event.subscription.ISubscriptionListener;
  import fulmine.event.system.ISystemEvent;
  import fulmine.event.system.ISystemEventListener;
  import fulmine.event.system.ISystemEventSource;
  import fulmine.model.container.IContainer;
  import fulmine.model.container.IContainerFactory;
  import fulmine.model.container.events.ContainerStateChangeEvent;
  import fulmine.model.container.impl.Record;
  import fulmine.model.field.BooleanField;
  import fulmine.model.field.IField;
  import fulmine.model.field.IntegerField;
  import fulmine.model.field.LongField;
  import fulmine.protocol.specification.IFrameReader;
  import fulmine.protocol.specification.IFrameWriter;
  import fulmine.rpc.IRpcDefinition;
  import fulmine.rpc.IRpcHandler;
  import fulmine.rpc.IRpcMarker;
  import fulmine.rpc.IRpcPublicationListener;
  import fulmine.rpc.IRpcResult;
  import fulmine.rpc.IRpcResultHandler;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.collection.CollectionUtils;
  import fulmine.util.log.AsyncLog;
  
  /**
   * A context that exists within a cluster of peer contexts. These all exist to
   * provide fault tolerance for a single logical application context identity. An
   * FT cluster is identified by a 'cluster identity'. Each FT context within the
   * cluster has the same logical application context identity but a unique FT
   * context identity. The FT context identity always starts with the cluster
   * identity. Only one FT context within the cluster will be 'active'. This
   * active context is the context servicing all remote subscriptions for the
   * logical application context. The other contexts will be in a standby mode.
   * <p>
   * The FT context actually hosts a second context that is the application
   * context; both the FT context and application contexts are separate
   * {@link IFrameworkContext} instances. The FT context has a separate network
   * for its FT activities. When the FT context determines it should be active, it
   * activates the application context; the application context is always started
   * at the same time as the FT context but has its network set to 'listening
   * mode' ({@link INetwork#setListeningOnlyMode(boolean)}). When the application
   * context is activated, its network {@link IConnectionDiscoverer} is also
   * activated ({@link IConnectionDiscoverer#enablePulsing()}); this will then
   * cause the application context to be discovered by other application contexts.
   * Should the FT context go into standby mode after this, the application
   * context will have its network {@link IConnectionDiscoverer} disabled (
   * {@link IConnectionDiscoverer#disablePulsing()}).
   * <h2>Fault tolerance algorithm</h2>
  * Each context is constructed with a fault tolerant number. This indicates the
  * ordering, relative to the other contexts in the FT cluster, for becoming
  * active. The context with the lowest FT number in the cluster is the active
  * context, unless there is already an active context in the cluster. This
  * numbering also provides the mechanism for all contexts to organise themselves
  * on startup so that there is only 1 active context.
  * <p>
  * A context has 4 states;
  * <ol>
  * <li>Startup - The initial state of the context.
  * <li>Provisional active - the period when a context marks itself as
  * 'provisionally active' and awaits any conflicts. This phase is used to
  * marshal conflicts between contexts and ensure only 1 progresses to the active
  * state.
  * <li>Active - the period when the context becomes the active context in the
  * cluster. This phase is when the context can start servicing remote
  * subscriptions for the cluster as a logical application context.
  * <li>Standby - the context is in a waiting state, prepared for if the current
  * active context leaves the cluster. The standby state is a 'warm' state.
  * </ol>
  * <h3>Startup</h3>
  * On startup, an FT context uses its FT network {@link IConnectionDiscoverer}
  * to find any other FT contexts within the same cluster. When an FT context
  * finds another within the cluster, each subscribes for a 'context info' record
  * from the other. This record contains the following attributes:
  * <ul>
  * <li>FT canonical ID (string)
  * <li>FT number (int)
  * <li>start time (long)
  * <li>provisionally active (boolean)
  * <li>active (boolean)
  * </ul>
  * If the context finds any other active context, it switches to standby.
  * Otherwise, it updates its context info record to indicate it is provisionally
  * active and waits for a period of time to allow discovery of other contexts.
  * If no contexts are found it switches to the provisional active state.
  * <h3>Provisional active</h3>
  * In this state it checks that there are no other active FT contexts and if
  * none are found, it switches to the active state. Should there be more than
  * one provisionally active FT context discovered in this state, a conflict
  * resolution protocol ensues;
  * <ol>
  * <li>The FT context with the lesser context number assumes priority, the
  * greater numbered context should yield to the lesser one.
  * <li>Should both contexts have the same number, then the context with the
  * greater FT canonical ID (as per string comparison) assumes active state, the
  * other will yield and go into stand-by mode.
  * </ol>
  * <h3>Active</h3>
  * Once an FT context has confirmed it is the active context for the cluster, it
  * activates its hosted application contexts {@link IConnectionDiscoverer} that
  * will broadcast the identity of the logical application context to other
  * contexts (outside the FT cluster).
  * <h3>Loss of active FT context</h3>
  * If the active FT context is lost, all remaining FT contexts compare their
  * number with each other. The lowest becomes the new active FT context and
  * enters the provisional active state and following that (assuming no conflicts
  * arise) the active state.
  * <p>
  * Application code can supply an {@link IFTContextStateListener} to react to
  * whether the FT context is active or stand-by.
  * <h2>FT standby scope</h2>
  * An FT context only has a standby scope of 'warm'. In this state, the FT
  * context is running but does not replicate the state of the current active FT
  * context. If a standby FT context becomes active it will need to perform all
  * necessary work to create the expected records to service any existing remote
  * subscriptions (the subscriptions will be received when the context broadcasts
  * its logical context identity).
  * <p>
  * From a 'client' perspective, whenever an FT context takes over as being the
  * active context in a cluster, the client will experience a network interrupt.
  * When the new FT context is re-discovered, the client will re-connect and
  * re-subscribe for the containers.
  * 
  * @author Ramon Servadei
  */
 public class FTContext extends AbstractLifeCycle implements IFrameworkContext
 {
     final static AsyncLog LOG = new AsyncLog(FTContext.class);
 
     /** Delimiter used within the FT context identity */
     private static final String DELIMITER = COLON;
 
     /**
      * The delay to wait between start and provisional activation. This provides
      * time for other FT context instances to be discovered prior to entering
      * the provisional activation state.
      */
     private final long activationDelay;
 
     /** The prefix for all FT context identities */
     static final String FT_ID_PREFIX = "FTContext:";
 
     /**
      * The field name in a context info record for the active flag; the flag
      * that indicates if the FT context is the active FT context in the cluster.
      * This is set during the confirmed phase.
      */
     static final String CONFIRMED_ACTIVE_FIELD = "confirmedActive";
 
     /**
      * The field name in a context info record for the provisional active flag.
      * This is set during the activation phase.
      */
     static final String PROVISIONAL_ACTIVE_FIELD = "provisionalActive";
 
     /**
      * The field name in a context info record for the FT number within the FT
      * cluster.
      */
     static final String FT_NUMBER_FIELD = "FTNumber";
 
     /**
      * The field name in the context info record for when the FT context was
      * started.
      */
     static final String START_TIME_FIELD = "startTime";
 
     /** The number of heartbeats that the FTContext activation period should be. */
     public static final long HEARTBEAT_MULTIPLIER = 4;
 
     /**
      * Responds to other discovered FT contexts within the cluster and registers
      * a listener for the context info record of the discovered peer FT context.
      * 
      * @author Ramon Servadei
      */
     private final class ContextDiscoveredEventHandler extends
         AbstractEventHandler<ContextDiscoveredEvent> implements
         ISystemEventListener
     {
         @Override
         protected AsyncLog getLog()
         {
             return LOG;
         }
 
         @Override
         public void handle(ContextDiscoveredEvent event)
         {
             IConnectionParameters params = event.getConnectionParameters();
             if (params.getRemoteContextIdentity().startsWith(
                 getClusterIdentity()))
             {
                 // FT context peer located, subscribe for its info record -
                 // the record name is the same as the FT context ID
                 FTContext.this.getFtWorkerContext().subscribe(
                     params.getRemoteContextIdentity(),
                     params.getRemoteContextIdentity(), Type.SYSTEM,
                     Domain.FRAMEWORK, FTContext.this.getFtLogicHandler());
             }
         }
     }
 
     /**
      * Handles changes to the context info record of other peer FT contexts
      * within the cluster.
      * 
      * @author Ramon Servadei
      */
     private final class ContextInfoHandler extends AbstractEventHandler<Record>
     {
         @Override
         protected AsyncLog getLog()
         {
             return LOG;
         }
 
         @Override
         public void handle(Record event)
         {
             // should be a context info record
             if (event.getIdentity().startsWith(getClusterIdentity()))
             {
                 synchronized (FTContext.this.contextInfos)
                 {
                     /*
                      * The event is a CLONE so remove its 'equal' and add this
                      * cloned instance - a HashSet will not replace an equal
                      * object.
                      */
                     FTContext.this.contextInfos.remove(event);
                     FTContext.this.contextInfos.add(event);
                 }
                 FTContext.this.getStateManager().revalidate();
             }
         }
     }
 
     /**
      * Handles changes to the state of the context info record of other FT
      * contexts. This state change can indicate the loss of the FT context.
      * 
      * @author Ramon Servadei
      */
     private final class ContextInfoStateChangeHandler extends
         AbstractEventHandler<ContainerStateChangeEvent>
     {
 
         @Override
         protected AsyncLog getLog()
         {
             return LOG;
         }
 
         @Override
         public void handle(ContainerStateChangeEvent event)
         {
 
             final IContainer container = event.getContainer();
             handleContextInfo(container);
         }
 
         private void handleContextInfo(final IContainer container)
         {
             boolean run = false;
             // need to check if this is one of the other FT contexts
             synchronized (FTContext.this.contextInfos)
             {
                 if (FTContext.this.contextInfos.contains(container))
                 {
                     // due to cloning, remove the 'equal' and add the new
                     // instance
                     FTContext.this.contextInfos.remove(container);
                     FTContext.this.contextInfos.add(container);
                     run = true;
                 }
             }
             if (run)
             {
                 FTContext.this.getStateManager().revalidate();
             }
         }
 
     }
 
     /**
      * Interface for a state of the {@link FTContext}. This provides the logic
      * for validating the current state against existing conditions and for
      * transitioning to the next state when necessary.
      * 
      * @author Ramon Servadei
      */
     private interface StateLogic extends Runnable
     {
         /**
          * Verify that all conditions are valid for the state. If they are not,
          * switch to the next valid state.
          */
         void validate();
     }
 
     /**
      * Base class for one of the states of the context. A state is responsible
      * for invoking the {@link FTContext#setFTContextState(String, boolean)}
      * state that sets the state of the context info record.
      * <p>
      * This is <b>always</b> executed by the {@link FTContext#execute(Runnable)}
      * method so is inherently thread-safe.
      * 
      * @author Ramon Servadei
      */
     private abstract class AbstractStateLogic implements StateLogic
     {
         public final void run()
         {
             if (FTContext.this.activationPeriodActive)
             {
                 if (LOG.isDebugEnabled())
                 {
                     LOG.debug(FTContext.this
                         + " in activation period, no state validation will occur.");
                 }
                 return;
             }
             synchronized (FTContext.this.contextInfos)
             {
                 if (LOG.isDebugEnabled())
                 {
                     LOG.debug(FTContext.this + " start");
                 }
                 List<IContainer> confirmedActiveContexts =
                     CollectionFactory.newList();
                 List<IContainer> provisionalActiveContexts =
                     CollectionFactory.newList();
                 getContexts(confirmedActiveContexts, provisionalActiveContexts);
                 doValidate(confirmedActiveContexts, provisionalActiveContexts);
                 if (LOG.isDebugEnabled())
                 {
                     LOG.debug(FTContext.this + " finish");
                 }
             }
         }
 
         public final void validate()
         {
             // queue a command to run the current state
             FTContext.this.execute(this);
         }
 
         /**
          * Find the provisionally active and confirmed active contexts. Add them
          * to the relevant list argument.
          * 
          * @param confirmedActiveContexts
          *            the list of confirmed active contexts to populate.
          * @param provisionalActiveContexts
          *            the list of provisionally active contexts to populate.
          */
         private void getContexts(List<IContainer> confirmedActiveContexts,
             List<IContainer> provisionalActiveContexts)
         {
             synchronized (FTContext.this.contextInfos)
             {
                 FTContext.this.logFTContexts();
                 // find any other contexts that are active
                 for (IContainer contextInfo : FTContext.this.contextInfos)
                 {
                     if (contextInfo.getDataState() == IContainer.DataState.LIVE)
                     {
                         if (contextInfo.getBooleanField(
                             FTContext.CONFIRMED_ACTIVE_FIELD).get())
                         {
                             confirmedActiveContexts.add(contextInfo);
                         }
                         else
                         {
                             if (contextInfo.getBooleanField(
                                 FTContext.PROVISIONAL_ACTIVE_FIELD).get())
                             {
                                 provisionalActiveContexts.add(contextInfo);
                             }
                         }
                     }
                 }
             }
             logActiveContexts(confirmedActiveContexts, "confirmed");
             logActiveContexts(provisionalActiveContexts, "provisional");
         }
 
         /**
          * Helper that compares this FTContext against those in the collection.
          * 
          * @param otherContexts
          *            the contexts to compare
          * @return <code>true</code> if this FTContext takes priority over all
          *         in the collection, <code>false</code> otherwise
          */
         boolean checkForPriority(List<IContainer> otherContexts)
         {
             for (IContainer record : otherContexts)
             {
                 final int otherFTNumber =
                     record.getIntegerField(FT_NUMBER_FIELD).get();
                 if (otherFTNumber < FTContext.this.ftNumber)
                 {
                     return false;
                 }
                 // for duplicate cluster numbers, the one with the
                 // greater cluster context ID should be active
                 if (otherFTNumber == FTContext.this.ftNumber)
                 {
                     if (record.getIdentity().compareTo(
                         FTContext.this.getClusterIdentity()) > 0)
                     {
                         return false;
                     }
                 }
             }
             return true;
         }
 
         /**
          * Helper method to log active contexts
          * 
          * @param contexts
          * @param type
          */
         void logActiveContexts(List<IContainer> contexts, String type)
         {
             if (LOG.isDebugEnabled())
             {
                 if (contexts.size() > 0)
                 {
                     LOG.debug(FTContext.this + " found other " + type
                         + " active FTContexts: "
                         + CollectionUtils.toFormattedString(contexts));
                 }
                 else
                 {
                     LOG.debug(FTContext.this + " found no other " + type
                         + " active FTContexts.");
                 }
             }
         }
 
         @Override
         public String toString()
         {
             return getClass().getSimpleName();
         }
 
         /**
          * Verify that all conditions are valid for the state. If they are not,
          * switch to the next valid state.
          * <p>
          * <b>This is executed in a thread-safe context.</b>
          * 
          * @param confirmedActiveContexts
          *            the confirmed active FTContext instances
          * @param provisionalActiveContexts
          *            the provisional active FTContext instances
          */
         abstract void doValidate(List<IContainer> confirmedActiveContexts,
             List<IContainer> provisionalActiveContexts);
     }
 
     /**
      * The standby state of the context. May transition to the
      * {@link ProvisionalActive} state.
      * 
      * @author Ramon Servadei
      */
     private final class Standby extends AbstractStateLogic
     {
         Standby()
         {
             FTContext.this.getStateListener().willStandby();
             FTContext.this.setFTContextState(FTContext.CONFIRMED_ACTIVE_FIELD,
                 false);
             logState();
             logFTContexts();
             FTContext.this.standby();
             FTContext.this.getStateListener().didStandby();
         }
 
         /**
          * Validate that the state should remain in standby. If not, transitions
          * to {@link ProvisionalActive}.
          */
         void doValidate(List<IContainer> confirmedActiveContexts,
             List<IContainer> provisionalActiveContexts)
         {
             boolean shouldBeProvisionallyActive = true;
             // if there are confirmed active contexts, then abort
             if (confirmedActiveContexts.size() > 0)
             {
                 // need to continue to set the active context
                 shouldBeProvisionallyActive = false;
             }
             else
             {
                 // check against provisional
                 shouldBeProvisionallyActive =
                     checkForPriority(provisionalActiveContexts);
             }
             FTContext.this.logStateChange(shouldBeProvisionallyActive,
                 "provisional");
             if (shouldBeProvisionallyActive)
             {
                 FTContext.this.getStateManager().setState(
                     StateEnum.ProvisionalActive, FTContext.this);
             }
             else
             {
                 if (LOG.isDebugEnabled())
                 {
                     LOG.debug(FTContext.this + " remaining in state " + this);
                 }
                 // if there is only 1 known active
                 if (confirmedActiveContexts.size() == 1)
                 {
                     // if there has been a change in active FT context
                     if (!confirmedActiveContexts.get(0).getIdentity().equals(
                         FTContext.this.activeFTContextIdentity))
                     {
                         if (LOG.isInfoEnabled())
                         {
                             LOG.info(FTContext.this
                                 + ": the active FTContext has changed from "
                                 + FTContext.this.activeFTContextIdentity
                                 + " to "
                                 + confirmedActiveContexts.get(0).getIdentity());
                         }
                         // save the current active FT context identity
                         FTContext.this.activeFTContextIdentity =
                             confirmedActiveContexts.get(0).getIdentity();
                     }
                 }
                 else
                 {
                     if (LOG.isInfoEnabled())
                     {
                         LOG.info(FTContext.this
                             + " found "
                             + (confirmedActiveContexts.size() == 0 ? "zero"
                                 : "multiple")
                             + " confirmed active FTContexts,"
                             + " setting current 'known' active"
                             + " FTContext to null."
                             + CollectionUtils.toFormattedString(confirmedActiveContexts));
                     }
                     // we may not know the true active FTContext
                     FTContext.this.activeFTContextIdentity = null;
                 }
             }
         }
     }
 
     /**
      * Encapsulates the provisional active state of the FT context. Transitions
      * to the {@link Confirmed} state or the {@link Standby} state.
      * <p>
      * This state resolves conflicts when there are multiple provisional active
      * FT contexts within the cluster. If this FT context is the only
      * provisional active context in the cluster, transitions to the the
      * {@link Confirmed} state
      * 
      * @author Ramon Servadei
      */
     private final class ProvisionalActive extends AbstractStateLogic
     {
 
         ProvisionalActive()
         {
             FTContext.this.setFTContextState(
                 FTContext.PROVISIONAL_ACTIVE_FIELD, true);
         }
 
         @Override
         void doValidate(List<IContainer> confirmedActiveContexts,
             List<IContainer> provisionalActiveContexts)
         {
             boolean shouldBeConfirmedActive = true;
             // if there are confirmed active contexts, then abort
             if (confirmedActiveContexts.size() > 0)
             {
                 if (LOG.isInfoEnabled())
                 {
                     LOG.info(FTContext.this
                         + " found other confirmed active contexts,"
                         + " switching to standby state.");
                 }
                 FTContext.this.getStateManager().setState(StateEnum.Standby,
                     FTContext.this);
             }
             else
             {
                 // check against provisional
                 shouldBeConfirmedActive =
                     checkForPriority(provisionalActiveContexts);
             }
             FTContext.this.logStateChange(shouldBeConfirmedActive, "confirmed");
             if (shouldBeConfirmedActive)
             {
                 if (confirmedActiveContexts.size() == 0)
                 {
                     // no other active contexts
                     FTContext.this.getStateManager().setState(
                         StateEnum.Confirmed, FTContext.this);
                 }
                 else
                 {
                     // there are multiple confirmed active contexts...
                     if (LOG.isInfoEnabled())
                     {
                         LOG.info(this
                             + " waiting for other confirmed active"
                             + " FTContexts to become inactive: "
                             + CollectionUtils.toFormattedString(confirmedActiveContexts));
                     }
                 }
             }
             else
             {
                 FTContext.this.getStateManager().setState(StateEnum.Standby,
                     FTContext.this);
             }
         }
     }
 
     /**
      * The startup state for the context. Transitions to the
      * {@link ProvisionalActive} or {@link Standby} state.
      * <p>
      * This will either leave the context in stand-by mode if there is already a
      * confirmed active context in the cluster or transition to the provisional
      * active state .
      * 
      * @author Ramon Servadei
      */
     private final class Startup extends AbstractStateLogic
     {
         Startup()
         {
             FTContext.this.setFTContextState(PROVISIONAL_ACTIVE_FIELD, false);
         }
 
         @Override
         void doValidate(List<IContainer> confirmedActiveContexts,
             List<IContainer> provisionalActiveContexts)
         {
             FTContext.this.activeFTContextIdentity = null;
             boolean shouldBeProvisionalActive = true;
             IContainer currentActiveContext = null;
             FTContext.this.logFTContexts();
             for (IContainer contextInfo : FTContext.this.contextInfos)
             {
                 if (contextInfo.getDataState() == IContainer.DataState.LIVE)
                 {
                     if (contextInfo.getBooleanField(
                         FTContext.CONFIRMED_ACTIVE_FIELD).get())
                     {
                         currentActiveContext = contextInfo;
                     }
                     if (contextInfo.getIntegerField(FTContext.FT_NUMBER_FIELD).get() < FTContext.this.ftNumber)
                     {
                         shouldBeProvisionalActive = false;
                     }
                 }
             }
             FTContext.this.logStateChange(shouldBeProvisionalActive,
                 "provisional");
             if (currentActiveContext == null && shouldBeProvisionalActive)
             {
                 if (!FTContext.this.isFTContextActive())
                 {
                     // mark provisional active, let others know...
                     // technically we're not in the ProvisionalState until the
                     // activation period expires
                     FTContext.this.setFTContextState(
                         FTContext.PROVISIONAL_ACTIVE_FIELD, true);
                     FTContext.this.activationPeriodActive = true;
                     // create a new thread because this blocks for the
                     // activation delay
                     new Thread(new Runnable()
                     {
                         public void run()
                         {
                             synchronized (this)
                             {
                                 if (LOG.isInfoEnabled())
                                 {
                                     LOG.info(FTContext.this + " waiting for "
                                         + FTContext.this.activationDelay
                                         + "ms for other FTContexts"
                                         + " to be discovered.");
                                 }
                                 try
                                 {
                                     this.wait(FTContext.this.activationDelay);
                                 }
                                 catch (InterruptedException e)
                                 {
                                     logException(LOG, getFtContextIdentity(), e);
                                 }
                             }
                             FTContext.this.activationPeriodActive = false;
                             // transition to the provisional active state
                             FTContext.this.getStateManager().setState(
                                 StateEnum.ProvisionalActive, FTContext.this);
                         }
 
                     }, "Provisional activation thread for " + FTContext.this).start();
                 }
             }
             else
             {
                 // transition to the standby state
                 FTContext.this.getStateManager().setState(StateEnum.Standby,
                     FTContext.this);
             }
         }
     }
 
     /**
      * Starts the standard context discoverer and connection broker and notifies
      * the {@link IFTContextStateListener} that this FT context is now active.
      * This is idempotent; if the FT context is already active, validating this
      * multiple times has no effect.
      * 
      * @author Ramon Servadei
      */
     private final class Confirmed extends AbstractStateLogic
     {
         Confirmed()
         {
             FTContext.this.getStateListener().willActivate();
             setFTContextState(CONFIRMED_ACTIVE_FIELD, true);
             logState();
             logFTContexts();
             FTContext.this.activeFTContextIdentity =
                 FTContext.this.getFtContextIdentity();
             FTContext.this.activate();
             FTContext.this.getStateListener().didActivate();
         }
 
         @Override
         void doValidate(List<IContainer> confirmedActiveContexts,
             List<IContainer> provisionalActiveContexts)
         {
             // the confirmedActiveContexts will not have this FT context so
             // should be 0 size but if it is not, check if this FT context
             // does have priority
             if (!checkForPriority(confirmedActiveContexts))
             {
                 if (LOG.isInfoEnabled())
                 {
                     LOG.info(this
                         + " found other confirmed active"
                         + " FTContexts so restarting activation sequence: "
                         + CollectionUtils.toFormattedString(confirmedActiveContexts));
                 }
                 // transition to the startup state
                 FTContext.this.getStateManager().setState(StateEnum.Startup,
                     FTContext.this);
             }
             else
             {
                 if (LOG.isInfoEnabled())
                 {
                     LOG.info(FTContext.this
                         + " should be the confirmed active versus others: "
                         + CollectionUtils.toFormattedString(confirmedActiveContexts));
                 }
             }
         }
     }
 
     /**
      * Manages the state transitions for the FT context. This class is thread
      * safe.
      * 
      * @author Ramon Servadei
      */
     private final class StateManager
     {
         /** The current state */
         StateEnum currentState;
 
         /** The state logic for the current state */
         private FTContext.StateLogic stateLogic;
 
         /**
          * Set the state for the state manager.
          * <p>
          * <b>This is thread safe.</b>
          * 
          * @param newState
          *            the new state for the manager
          * @param context
          *            the FT context
          */
         void setState(StateEnum newState, FTContext context)
         {
             boolean stateChanged = false;
             synchronized (FTContext.this.contextInfos)
             {
                 if (newState != this.currentState)
                 {
                     if (FTContext.LOG.isDebugEnabled())
                     {
                         FTContext.LOG.debug(context + " switching from "
                             + this.currentState + " to " + newState);
                     }
                     this.currentState = newState;
                     stateChanged = true;
                 }
             }
             if (stateChanged)
             {
                 // create the logic class outside of the synchronized block
                 final FTContext.StateLogic createdState =
                     this.currentState.create(context);
                 synchronized (FTContext.this.contextInfos)
                 {
                     this.stateLogic = createdState;
                     revalidate();
                 }
             }
         }
 
         /**
          * Re-validate the current state
          * <p>
          * <b>This is thread safe.</b>
          */
         void revalidate()
         {
             synchronized (FTContext.this.contextInfos)
             {
                 // only if we are not in the activation period...
                 if (this.stateLogic != null)
                 {
                     this.stateLogic.validate();
                 }
             }
         }
     }
 
     /**
      * Enumeration for {@link StateEnum} instances
      * 
      * @author Ramon Servadei
      */
     private enum StateEnum
     {
         Startup
         {
             public FTContext.StateLogic create(FTContext context)
             {
                 return context.new Startup();
             }
         },
         Standby
         {
             public FTContext.StateLogic create(FTContext context)
             {
                 return context.new Standby();
             }
         },
         ProvisionalActive
         {
             public FTContext.StateLogic create(FTContext context)
             {
                 return context.new ProvisionalActive();
             }
         },
         Confirmed
         {
             public FTContext.StateLogic create(FTContext context)
             {
                 return context.new Confirmed();
             }
         };
         /** Create the {@link StateLogic} that validates the state */
         public abstract FTContext.StateLogic create(FTContext context);
     }
 
     /** The application context that this FT contexts hosts */
     private final IFrameworkContext appContext;
 
     /**
      * The context that manages the FT behaviour. This connects to the FT
      * network and negotiates with any other FT contexts on that network to
      * determine if this is the active one. If it is the active one, it will
      * activate its application context.
      */
     private final IFrameworkContext ftWorkerContext;
 
     /** The listener to react to state changes of the clustered context */
     private final IFTContextStateListener stateListener;
 
     /**
      * A flag to indicate if the activation period is in effect. During this
      * time, no state processing occurs.
      */
     private volatile boolean activationPeriodActive;
 
     /** The state manager */
     private final StateManager stateManager;
 
     /**
      * The listener to handle events that influence whether this FT context is
      * active or standby in the cluster.
      */
     private final MultiSystemEventListener ftLogicHandler;
 
     /**
      * The unique identity of this FT context within the cluster
      * "{clusterIdentity}:{FT number}:{host IP}:{object identityHash}:{time of
      * creation in nanoseconds}"
      */
     private final String ftContextIdentity;
 
     /**
      * The FT number of this FT context within the cluster; determines the
      * priority for becoming active relative to the other peer contexts within
      * the cluster.
      */
     private final int ftNumber;
 
     /**
      * The context info records of all other FT contexts within the cluster.
      * Also doubles up as the object lock.
      */
     private final Set<IContainer> contextInfos;
 
     /**
      * The context info for this FT context. The context info contains the
      * following
      * <ul>
      * <li>FT canonical ID (string) <li>FT number (int) <li>start time (long)
      * <li>provisionally active (boolean) <li>active (boolean)
      * </ul>
      */
     Record contextInfo;
 
     /** The identity of the active FT context in the cluster */
     String activeFTContextIdentity;
 
     /**
      * Standard constructor for an FT context that provides FT capability to a
      * hosted application context.
      * 
      * @param appContext
      *            the application context instance that is hosted by the
      *            clustering ability of this FT context. The FT cluster identity
      *            comes from the {@link IFrameworkContext#getIdentity()} of the
      *            context argument.
      * @param stateListener
      *            the listener that will react to the FT context being active or
      *            stand-by
      * @param ftNetwork
      *            the network that is used for FT activities; other FTContexts
      *            joining the same network will coordinate between themselves to
      *            identify which one should be the active context
      * @param number
      *            the FT number for the context within the cluster; determines
      *            relative priority for becoming active between all peer FT
      *            contexts within the same cluster
      * @param activationDelayMillis
      *            the delay to wait between start and provisional activation
      *            states. This provides time for other FT context instances to
      *            be discovered prior to entering the {@link ProvisionalActive}
      *            state. The value must be at least equal to the ftNetwork's
      *            {@link IHeartbeatMonitor#getNetworkHeartbeatPeriod heartbeat
      *            period} multiplied by {@link FTContext#HEARTBEAT_MULTIPLIER}.
      *            Choosing a number too low can result in newly started contexts
      *            assuming confirmed active state before detecting any other
      *            confirmed active instances.
      */
     @SuppressWarnings("unchecked")
     public FTContext(IFrameworkContext appContext,
         IFTContextStateListener stateListener, INetwork ftNetwork, int number,
         long activationDelayMillis)
     {
         nullCheck(stateListener, "No FTContext state listener provided");
         nullCheck(ftNetwork, "No FT network provided");
         this.appContext = appContext;
 
         // swap in a distribution manager that is FT aware
         final FTDistributionManager distributionManager =
             new FTDistributionManager(appContext, this);
         getAppContext().setDistributionManager(distributionManager);
         distributionManager.start();
 
         this.stateListener = stateListener;
         this.ftNumber = number;
         this.activationDelay = activationDelayMillis;
         this.stateManager = new StateManager();
         try
         {
             this.ftContextIdentity =
                 getClusterIdentity() + DELIMITER + this.ftNumber + DELIMITER
                     + InetAddress.getLocalHost().getHostAddress() + DELIMITER
                     + System.identityHashCode(getAppContext()) + DELIMITER
                     + System.nanoTime();
         }
         catch (UnknownHostException e)
         {
             throw new RuntimeException(
                 "Could not get the local host IP address for context: "
                     + getAppContext().getIdentity(), e);
         }
         this.ftWorkerContext = new FulmineContext(ftContextIdentity, 2);
         getFtWorkerContext().setNetwork(ftNetwork);
 
         this.contextInfos = CollectionFactory.newSet();
         Map<Class<? extends IEvent>, IEventListener> listeners =
             AbstractEventHandler.getEventHandlerMappings(
                 new ContextInfoStateChangeHandler(),
                 new ContextDiscoveredEventHandler(), new ContextInfoHandler());
         this.ftLogicHandler =
             new MultiSystemEventListener(getFtContextIdentity(),
                 getFtWorkerContext(), listeners);
     }
 
     /** The component that can report on the state of this context */
     private IContextWatchdog watchdog;
 
     public IContextWatchdog getContextWatchdog()
     {
         return this.watchdog;
     }
 
     public void setContextWatchdog(IContextWatchdog watchdog)
     {
         this.watchdog = watchdog;
     }
 
     protected final void doStart()
     {
         validate();
 
         prepareAppContextForStart();
         getAppContext().start();
 
         getFtWorkerContext().start();
 
         createContextInfoRecord();
 
         getStateManager().setState(StateEnum.Startup, this);
 
         getStateListener().start();
         getFtLogicHandler().start();
     }
 
     /**
      * Prepare the application context before calling {@link ILifeCycle#start()
      * start}. Default implementation sets the application context network into
      * listen-only mode.
      */
     protected void prepareAppContextForStart()
     {
         // start the application context but with no pulsing
         getNetwork().setListeningOnlyMode(true);
     }
 
     protected final void doDestroy()
     {
         try
         {
             getFtWorkerContext().getSystemEventSource(
                 ContextDiscoveredEvent.class).removeListener(
                 getFtLogicHandler());
         }
         catch (Exception e)
         {
             logException(LOG, "clusteringLogic", e);
         }
         getFtWorkerContext().destroy();
         try
         {
             getStateListener().destroy();
         }
         catch (Exception e)
         {
             logException(LOG, "statelistener", e);
         }
         getAppContext().destroy();
     }
 
     /**
      * Invoked by the {@link Standby} state and encapsulates the logic the
      * {@link FTContext} needs to perform to go into standby state.
      */
     protected void standby()
     {
         doStandby(getAppContext(), getAppContext().getNetwork(),
             getAppContext().getConnectionDiscoverer(),
             getAppContext().getConnectionBroker());
     }
 
     /**
      * Standard operation for standby that stops heartbeat pulsing and recreates
      * the {@link IConnectionBroker}
      * 
      * @param context
      *            the context for the connection broker
      * @param network
      *            the network instance for the new connection broker
      * @param discoverer
      *            the discoverer to stop heartbeats for
      * @param connectionBroker
      *            the connection broker to stop
      */
     protected final void doStandby(IFrameworkContext context, INetwork network,
         IConnectionDiscoverer discoverer, IConnectionBroker connectionBroker)
     {
         nullCheck(discoverer, "no discoverer");
         nullCheck(network, "no network");
         nullCheck(context, "no context");
         discoverer.disablePulsing();
         // bounce the connection broker
         try
         {
             if (connectionBroker != null)
             {
                 connectionBroker.destroy();
             }
             // now restart
             context.setConnectionBroker(network.createBroker());
             context.getConnectionBroker().start();
         }
         catch (Exception e)
         {
             logException(LOG, FTContext.this, e);
         }
     }
 
     /**
      * Invoked by the {@link Confirmed} state and encapsulates the logic the
      * {@link FTContext} needs to perform to go into the active state.
      */
     protected void activate()
     {
         // moving into confirmed active, switch on the application network
         getConnectionDiscoverer().enablePulsing();
     }
 
     private void validate()
     {
         final INetwork network = getNetwork();
         nullCheck(network, "No network provided for " + getAppContext());
 
         // check the activation delay is less than the heartbeat period
         if (this.activationDelay < getNetwork().getNetworkHeartbeatPeriod() * 3)
         {
             throw new IllegalStateException(
                 "The activation delay of an FTContext must be at "
                     + "least "
                     + FTContext.HEARTBEAT_MULTIPLIER
                     + "x the FT heartbeat period. The activationDelay="
                     + this.activationDelay
                     + "ms, FT heartbeatPeriod="
                     + getFtWorkerContext().getNetwork().getNetworkHeartbeatPeriod()
                     + "ms. "
                     + "Either increase the activationDelay or reduce the heartbeat period for the FT network.");
         }
     }
 
     @Override
     public String toString()
     {
         return getFtContextIdentity() + OPEN_BRACE
             + getStateManager().currentState + CLOSE_BRACE;
     }
 
     @Override
     protected AsyncLog getLog()
     {
         return LOG;
     }
 
     /**
      * @return The context that manages the FT behaviour. This connects to the
      *         FT network and negotiates with any other FT contexts on that
      *         network to determine if this is the active one. If it is the
      *         active one, it will activate its application context.
      */
     IFrameworkContext getFtWorkerContext()
     {
         return this.ftWorkerContext;
     }
 
     /**
      * @return the application context this FTContext hosts
      */
     protected IFrameworkContext getAppContext()
     {
         return this.appContext;
     }
 
     /**
      * @return The listener to react to state changes of the clustered context
      */
     private IFTContextStateListener getStateListener()
     {
         return this.stateListener;
     }
 
     /**
      * @return the listener to handle events that influence whether this FT
      *         context is active or standby in the cluster.
      */
     MultiSystemEventListener getFtLogicHandler()
     {
         return this.ftLogicHandler;
     }
 
     private StateManager getStateManager()
     {
         return this.stateManager;
     }
 
     /**
      * @return the unique identity of this FT context within the cluster
      *         "{clusterIdentity}:{FT number}:{host IP}:{object
      *         identityHash}:{time of creation in nanoseconds}"
      */
     String getFtContextIdentity()
     {
         return this.ftContextIdentity;
     }
 
     /**
      * Get the identity of the cluster this FT context is a part of:
      * "FTContext:{context-identity}"
      * 
      * @return the identity of the cluster this FT context is a part of
      */
     private String getClusterIdentity()
     {
         return FTContext.FT_ID_PREFIX + getIdentity();
     }
 
     /**
      * Create the context info record for this context
      */
     private void createContextInfoRecord()
     {
         this.contextInfo =
             (Record) getFtWorkerContext().getLocalContainer(
                 this.getFtContextIdentity(), Type.SYSTEM, Domain.FRAMEWORK);
         IntegerField contextNumber =
             new IntegerField(FTContext.FT_NUMBER_FIELD);
         contextNumber.set(this.ftNumber);
         LongField startTime = new LongField(FTContext.START_TIME_FIELD);
         startTime.set(System.currentTimeMillis());
         BooleanField provisionalActive =
             new BooleanField(FTContext.PROVISIONAL_ACTIVE_FIELD);
         provisionalActive.set(false);
         BooleanField activeContext =
             new BooleanField(FTContext.CONFIRMED_ACTIVE_FIELD);
         activeContext.set(false);
         this.contextInfo.add(contextNumber);
         this.contextInfo.add(startTime);
         this.contextInfo.add(activeContext);
         this.contextInfo.add(provisionalActive);
         this.contextInfo.flushFrame();
     }
 
     /**
      * Set the FT context provisional or confirmed active state to the specified
      * state. This method updates the context info record and flushes it; other
      * FT contexts within the cluster will receive the state change. The
      * {@link #stateListener} will be notified only on a change in state.
      * 
      * @param stateField
      *            the state of the FT context to set; either provisional or
      *            confirmed
      * @param stateValue
      *            the state for the FT context provisional or confirmed state
      * 
      * @see #isFTContextActive()
      */
     private void setFTContextState(final String stateField,
         final boolean stateValue)
     {
         final BooleanField provisionalState =
             contextInfo.getBooleanField(FTContext.PROVISIONAL_ACTIVE_FIELD);
         boolean wasProvisionallyActive = provisionalState.get();
 
         final BooleanField confirmedState =
             contextInfo.getBooleanField(FTContext.CONFIRMED_ACTIVE_FIELD);
         boolean wasConfirmedActive = confirmedState.get();
 
         boolean provisionalActive = wasProvisionallyActive;
         boolean confirmedActive = wasConfirmedActive;
         if (PROVISIONAL_ACTIVE_FIELD.equals(stateField))
         {
             provisionalActive = stateValue;
             if (!provisionalActive)
             {
                 // if not provisional, neither can we be confirmed
                 confirmedActive = false;
             }
         }
         else
         {
             confirmedActive = stateValue;
             // regardless of the confirmed state, set provisional to false
             provisionalActive = false;
         }
 
         if (LOG.isDebugEnabled())
         {
             LOG.debug(FTContext.this + " provisional: "
                 + (wasProvisionallyActive ? "active" : "standby") + "->"
                 + (provisionalActive ? "active" : "standby") + ", confirmed: "
                 + (wasConfirmedActive ? "active" : "standby") + "->"
                 + (confirmedActive ? "active" : "standby"));
         }
         provisionalState.set(provisionalActive);
         confirmedState.set(confirmedActive);
         this.contextInfo.flushFrame();
     }
 
     /**
      * Log a banner message to display the state of the context - either ACTIVE
      * or STANDBY
      */
     private void logState()
     {
         if (LOG.isInfoEnabled())
         {
             LOG.info(SystemUtils.LINE_SEPARATOR
                 + "********************************************************************************"
                 + SystemUtils.LINE_SEPARATOR
                 + "* "
                 + FTContext.this
                 + " CONTEXT IS "
                 + (this.isFTContextActive() ? "ACTIVE" : "STANDBY")
                 + SystemUtils.LINE_SEPARATOR
                 + "********************************************************************************");
         }
     }
 
     /**
      * Determine if this FT context is active. This examines the confirmed
      * active state.
      * 
      * @see #setFTContextState(String, boolean)
      * @return <code>true</code> if this FT context is active
      */
     public boolean isFTContextActive()
     {
         final BooleanField activeField =
             this.contextInfo.getBooleanField(FTContext.CONFIRMED_ACTIVE_FIELD);
         return activeField.get();
     }
 
     /**
      * Log the FTContexts in this cluster.
      */
     private void logFTContexts()
     {
         synchronized (this.contextInfos)
         {
             if (LOG.isDebugEnabled())
             {
                 if (this.contextInfos.size() > 0)
                 {
                     LOG.debug(FTContext.this + " FTContexts in cluster "
                         + getClusterIdentity() + " are: "
                         + CollectionUtils.toFormattedString(this.contextInfos));
                 }
                 else
                 {
                     if (LOG.isDebugEnabled())
                     {
                         LOG.debug(FTContext.this
                             + " No other FTContexts exist in cluster "
                             + getClusterIdentity());
                     }
                 }
             }
         }
     }
 
     /**
      * Helper method to log the state change type for the context
      * 
      * @param shouldBeActive
      *            whether the context should become active
      * @param type
      *            provisional or confirmed
      */
     private void logStateChange(boolean shouldBeActive, String type)
     {
         if (LOG.isDebugEnabled())
         {
             LOG.debug(FTContext.this + " is confirmed "
                 + (FTContext.this.isFTContextActive() ? "active" : "standby")
                 + " and should be " + type + SPACE
                 + (shouldBeActive ? "active" : "standby"));
         }
     }
 
     public void addContainer(IContainer container)
     {
         getAppContext().addContainer(container);
     }
 
     public boolean addSubscriptionListener(ISubscriptionListener listener)
     {
         return getAppContext().addSubscriptionListener(listener);
     }
 
     public boolean containsLocalContainer(String identityRegularExpression,
         IType type, IDomain domain)
     {
         return getAppContext().containsLocalContainer(
             identityRegularExpression, type, domain);
     }
 
     public boolean containsRemoteContainer(String remoteContextIdentity,
         String containerIdentity, IType type, IDomain domain)
     {
         return getAppContext().containsRemoteContainer(remoteContextIdentity,
             containerIdentity, type, domain);
     }
 
     public void execute(Runnable task)
     {
         getAppContext().execute(task);
     }
 
     public IChannel[] getConnectedChannels()
     {
         return getAppContext().getConnectedChannels();
     }
 
     public IConnectionBroker getConnectionBroker()
     {
         return getAppContext().getConnectionBroker();
     }
 
     public IConnectionDiscoverer getConnectionDiscoverer()
     {
         return getAppContext().getConnectionDiscoverer();
     }
 
     public IContainerFactory getContainerFactory()
     {
         return getAppContext().getContainerFactory();
     }
 
     public int getContextHashCode()
     {
         return getAppContext().getContextHashCode();
     }
 
     public int getEventProcessorCount()
     {
         return getAppContext().getEventProcessorCount();
     }
 
     public IFrameReader getFrameReader()
     {
         return getAppContext().getFrameReader();
     }
 
     public IFrameWriter getFrameWriter()
     {
         return getAppContext().getFrameWriter();
     }
 
     public String getIdentity()
     {
         return getAppContext().getIdentity();
     }
 
     public IContainer getLocalContainer(String identity, IType type,
         IDomain domain)
     {
         return getAppContext().getLocalContainer(identity, type, domain);
     }
 
     public Collection<IContainer> getLocalContainers()
     {
         return getAppContext().getLocalContainers();
     }
 
     public INetwork getNetwork()
     {
         return getAppContext().getNetwork();
     }
 
     public ThreadGroup getEventProcessorThreadGroup()
     {
         return getAppContext().getEventProcessorThreadGroup();
     }
 
     public IContainer getRemoteContainer(String remoteContextIdentity,
         String containerIdentity, IType type, IDomain domain)
     {
         return getAppContext().getRemoteContainer(remoteContextIdentity,
             containerIdentity, type, domain);
     }
 
     public Collection<IContainer> getRemoteContainers(
         String remoteContextIdentity)
     {
         return getAppContext().getRemoteContainers(remoteContextIdentity);
     }
 
     public ISystemEventSource getSystemEventSource(
         Class<? extends ISystemEvent> type)
     {
         return getAppContext().getSystemEventSource(type);
     }
 
     public void queueEvent(IEvent event)
     {
         getAppContext().queueEvent(event);
     }
 
     public void queueEvents(Collection<IEvent> events)
     {
         getAppContext().queueEvents(events);
     }
 
     public boolean removeContainer(IContainer container)
     {
         return getAppContext().removeContainer(container);
     }
 
     public boolean removeSubscriptionListener(ISubscriptionListener listener)
     {
         return getAppContext().removeSubscriptionListener(listener);
     }
 
     public void requestRetransmit(String contextIdentity,
         String identityRegularExpression, IType type, IDomain domain)
     {
         getAppContext().requestRetransmit(contextIdentity,
             identityRegularExpression, type, domain);
     }
 
     public void requestRetransmitAll(String contextIdentity)
     {
         getAppContext().requestRetransmitAll(contextIdentity);
     }
 
     public void retransmit(String contextIdentity,
         String identityRegularExpression, IType type, IDomain domain)
     {
         getAppContext().retransmit(contextIdentity, identityRegularExpression,
             type, domain);
     }
 
     public void retransmitAll(String contextIdentity)
     {
         getAppContext().retransmitAll(contextIdentity);
     }
 
     public void retransmitAllToAll()
     {
         getAppContext().retransmitAllToAll();
     }
 
     public void retransmitToAll(String identityRegularExpression, IType type,
         IDomain domain)
     {
         getAppContext().retransmitToAll(identityRegularExpression, type, domain);
     }
 
     public void setConnectionBroker(IConnectionBroker broker)
     {
         getAppContext().setConnectionBroker(broker);
     }
 
     public void setConnectionDiscoverer(IConnectionDiscoverer discoverer)
     {
         getAppContext().setConnectionDiscoverer(discoverer);
     }
 
     public void setDistributionManager(IDistributionManager distributionManager)
     {
         getAppContext().setDistributionManager(distributionManager);
     }
 
     public IDistributionManager getDistributionManager()
     {
         return getAppContext().getDistributionManager();
     }
 
     public void setNetwork(INetwork network)
     {
         getAppContext().setNetwork(network);
     }
 
     public boolean subscribe(String contextIdentity,
         String identityRegularExpression, IType type, IDomain domain,
         IEventListener listener)
     {
         /*
          * If we subscribe for the same context identity, but we're disabled,
          * then we do a remote subscribe - this is handled by a specialised
          * distribution manager, the FTDistributionManager.
          */
         return getAppContext().subscribe(contextIdentity,
             identityRegularExpression, type, domain, listener);
     }
 
     public boolean unsubscribe(String contextIdentity,
         String identityRegularExpression, IType type, IDomain domain,
         IEventListener listener)
     {
         /*
          * If we unsubscribe for the same context identity, but we're disabled,
          * then do a remote subscribe - this is handled by a specialised
          * distribution manager, the FTDistributionManager.
          */
         return getAppContext().unsubscribe(contextIdentity,
             identityRegularExpression, type, domain, listener);
     }
 
     public String getEventProcessorIdentityPrefix()
     {
         return getAppContext().getEventProcessorIdentityPrefix();
     }
 
     public void invokeRpc(String remoteContextIdentity, byte[] rpcData)
     {
         getAppContext().invokeRpc(remoteContextIdentity, rpcData);
     }
 
     public boolean addRpcPublicationListener(String remoteContextIdentity,
         IRpcPublicationListener listener)
     {
         return getAppContext().addRpcPublicationListener(remoteContextIdentity,
             listener);
     }
 
     public boolean unpublishRpcs(Class<?> definition, Object handler)
     {
         return getAppContext().unpublishRpcs(definition, handler);
     }
 
     public boolean publishRpcs(Class<?> definition, Object handler)
     {
         return getAppContext().publishRpcs(definition, handler);
     }
 
     public IRpcResult invoke(String remoteContextIdentity, String procedure,
         IField... args)
     {
         return getAppContext().invoke(remoteContextIdentity, procedure, args);
     }
 
     public IRpcMarker invoke(IRpcResultHandler resultHandler,
         String remoteContextIdentity, String procedure, IField... args)
     {
         return getAppContext().invoke(resultHandler, remoteContextIdentity,
             procedure, args);
     }
 
     public boolean removeRpcPublicationListener(String remoteContextIdentity,
         IRpcPublicationListener listener)
     {
         return getAppContext().removeRpcPublicationListener(
             remoteContextIdentity, listener);
     }
 
     public boolean publishProdedure(IRpcHandler handler,
         IRpcDefinition rpcDefinition)
     {
         return getAppContext().publishProdedure(handler, rpcDefinition);
     }
 
     public boolean unpublishProdedure(IRpcDefinition rpcDefinition)
     {
         return getAppContext().unpublishProdedure(rpcDefinition);
     }
 
     public IPermissionProfile getPermissionProfile()
     {
         return getAppContext().getPermissionProfile();
     }
 
     public void setPermissionProfile(IPermissionProfile profile)
     {
         getAppContext().setPermissionProfile(profile);
     }
 
     public void setRemoteUpdateHandler(IRemoteUpdateHandler handler)
     {
         getAppContext().setRemoteUpdateHandler(handler);
     }
 
     public String updateRemoteContainer(String remoteContextIdentity,
         String identity, IType type, IDomain domain, String fieldName,
         String fieldValueAsString)
     {
         return getAppContext().updateRemoteContainer(remoteContextIdentity,
             identity, type, domain, fieldName, fieldValueAsString);
     }
 
     public IContainer getSystemInfo()
     {
         return getAppContext().getSystemInfo();
     }
 
     public void schedule(TimerTask task, long delay, long period)
     {
         getAppContext().schedule(task, delay, period);
     }
 }