Mailing-List: contact dev-help@myfaces.apache.org; run by ezmlm
Precedence: bulk
Reply-To: "MyFaces Development" <dev@myfaces.apache.org>
Message-ID: <882933149.1222845464309.JavaMail.jira@brutus>
Date: Wed, 1 Oct 2008 00:17:44 -0700 (PDT)
From: "Blake Sullivan (JIRA)" <dev@myfaces.apache.org>
To: dev@myfaces.apache.org
Subject: [jira] Created: (TRINIDAD-1245) High Availability Testing Support
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 7bit

High Availability Testing Support
---------------------------------

                 Key: TRINIDAD-1245
                 URL: https://issues.apache.org/jira/browse/TRINIDAD-1245
             Project: MyFaces Trinidad
          Issue Type: New Feature
          Components: Archetype
    Affects Versions: 1.2.9-core
         Environment: All
            Reporter: Blake Sullivan
            Priority: Minor


Most Servlet Engines support fail over for high availability by replicating changes the the Session state to other servers.  This requires that all of the state and substate in the Session be Serializable.  If the state is not Serializable, the failover will fail with a SerializationException and most likely the Session attribute key for which Serialization failed.  This poses several problems for framework and application developers:
1) An actual high-availability configuration should not be necessary to test that the framework and application is using Session state correctly
2) The Servlet specification requires that an exception be thrown immediately when adding setting a non Serializable attribute on the Session when the Servlet engine is running in high-availibility mode.  This enables the offending code to be quickly identified for simple case, but this requires:
a) That the server be running in such a mode, which may be a pain to configure
b) Some Servlet engines don't implement  this feature
3) Knowing the offending key in the Session state is not very useful if the value of the key is an extremely complicated structure.  In particular, determining precisely which attribute value on which component in the component state structure used in Trinidad state saving  is a nightmare.

The proposal is to address the problems by:
1) Making it possible to run Trinidad in a mode where unserializable state content and sets on Session attributes are detected
2) When a state Serialization failure is detected, more detailed failure information regarding the component and attribute key and value that failed can be determined by rerunning with additional, but slower settings

In order to decrease runtime overhead, the proposal is that a System property:

org.apache.myfaces.trinidad.CHECK_STATE_SERIALIZATION

is used to control this behavior as this allows the behavior to be determined a class load time.

The behavior is controlled by passing a comma-delimited set of case-insensitive values on the system property:
NONE--no state serialization checks are performed (the default)
ALL--perform all available tests (unless NONE is also specified, in which case NONE takes precedence)
SESSION-Wrap the Session Map returned by the ExternalContext to test that only Serializable objects are placed in the Session Map, throwing a CastCastException if the Object is not Serializable
TREE--aggressively attempt to serialize the component state during state saving and throw an exception if serialization fails
COMPONENT--aggressively attempt to serialize each component subtree's state during state saving in order to identify the problem component (slow)
PROPERTY--aggessively attempt to serialize each property value during state saving in order to identify the problem property (slow)

For high availability testing, the tester would initially start off validating the Session and JSF state is Serializable by setting the system property to:
-Dorg.apache.myfaces.trinidad.CHECK_STATE_SERIALIZATION=session,tree

If a JSF state serialization is detected, the test is rerun with the component and property flags enabled:
-Dorg.apache.myfaces.trinidad.CHECK_STATE_SERIALIZATION=all

Programmatic access to these flags would be on the StateUtils class:


  /**
   * Returns <code>true</code> if components should be checked for
   * serializability when when generating the view's state object.
   * <p>
   * By default component state serialization checking is off.  It can be
   * enabled by setting the system property
   * <code>org.apache.myfaces.trinidad.CHECK_STATE_SERIALIZATION</code>
   * to <code>all</code> or, more rarely, adding <code>component</code> to the
   * comma-separated list of serialization checks to perform.
   * <p>
   * As property serialization checking is expensive, it is usually
   * only enabled after component tree serialization checking has detected
   * a problem.  In addition, since component serialization checking only
   * detects the problem component, it is usually combined with
   * property state serialization checking either by specifying <code>all</code>.
   * @return
   * @see #checkComponentTreeStateSerialization
   */
  public static boolean checkComponentStateSerialization(FacesContext context)
 
  /**
   * Returns <code>true</code> if the component tree should be checked for
   * serializability when when generating the view's state object.
   * <p>
   * By default component tree state serialization checking is off.  It can be
   * enabled by setting the system property
   * <code>org.apache.myfaces.trinidad.CHECK_STATE_SERIALIZATION</code>
   * to <code>all</code> or, more commonly, adding <code>tree</code> to the
   * comma-separated list of serialization checks to perform.
   * <p>
   * Because unserializable objects defeat fail-over, it is important to
   * check for serializability when testing applications.  While component
   * tree state serializability checking isn't cheap, it is much faster to
   * initially only enable checking of the component tree and then switch
   * to <code>all</code> testing to determine the problem component and 
   * property when the component tree testing determines a problem.
   * @return
   * @see #checkComponentStateSerialization
   */
  public static boolean checkComponentTreeStateSerialization(FacesContext context)
 
  /**
   * Returns <code>true</code> if Object written to the SessionMap should be checked for
   * Serializability when <code>put</code> is called.
   * <p>
   * Configuring this property allows this aspect of high-availability to be tested without
   * configuring the server to run in high-availability mode.
   * <p>
   * By default session serialization checking is off.  It can be
   * enabled by setting the system property
   * <code>org.apache.myfaces.trinidad.CHECK_STATE_SERIALIZATION</code>
   * to <code>all</code> or, more commonly, adding <code>session</code> to the
   * comma-separated list of serialization checks to perform.
   * @return
   * @see #checkComponentStateSerialization
   * @see #checkComponentTreeStateSerialization
   */
  public static boolean checkSessionSerialization(ExternalContext extContext)


-- 
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.