NH Request Per Session - "Session is closed!"

Question

NHibernate Version: 2.1

I'm using what seems to be a pretty standard HttpModule approach to implementing per-request sessions in an ASP.NET+NHibernate application. I'm trying to leverage WebSessionContext, but it doesn't seem to be working correctly. Specifically, everything works brilliantly for the first request on the application, but additional requests result in a "Session is closed!" exception any time the session is used. Resetting the application pool allows another request to succeed, then more "Session is closed!".

There are a few moving pieces, but I don't know enough about how the context is managed to narrow it down so...here's everything!

In web.config:

<property name="current_session_context_class">
  NHibernate.Context.WebSessionContext, NHibernate
</property>

(I've tried setting it to just 'web', too, with the same result.)

The module, confirmed to be configured correctly:

public class NHibernateSessionModule : IHttpModule
{
    public void Dispose() { }

    public void Init(HttpApplication context)
    {
        Debug.WriteLine("NHibernateSessionModule.Init()");
        context.BeginRequest += context_BeginRequest;
        context.EndRequest += context_EndRequest;
    }

    void context_BeginRequest(object sender, EventArgs e)
    {
        Debug.WriteLine("NHibernateSessionModule.BeginRequest()");
        var session = NHibernateHelper.OpenSession();
        session.BeginTransaction();
        CurrentSessionContext.Bind(session);
    }

    void context_EndRequest(object sender, EventArgs e)
    {
        Debug.WriteLine("NHibernateSessionModule.EndRequest()");
        var session = NHibernateHelper.GetCurrentSession();
        if (session != null)
        {
            try
            {
                if (session.Transaction != null && session.Transaction.IsActive)
                    session.Transaction.Commit();
            }
            catch (Exception ex)
            {
                session.Transaction.Rollback();
                throw new ApplicationException("Error committing database transaction", ex);
            }
            finally
            {
                session.Close();
            }
        }
        CurrentSessionContext.Unbind(NHibernateHelper.SessionFactory);
    }
}

And my little helper:

public class NHibernateHelper
{
    public static readonly ISessionFactory SessionFactory;

    static NHibernateHelper()
    {
        try
        {
            Configuration cfg = new Configuration();
            cfg.AddAssembly(Assembly.GetCallingAssembly());
            SessionFactory = cfg.Configure().BuildSessionFactory();
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex);
            throw new ApplicationException("NHibernate initialization failed", ex);
        }
    }

    public static ISession GetCurrentSession()
    {
        return SessionFactory.GetCurrentSession();
    }

    public static ISession OpenSession()
    {
        return SessionFactory.OpenSession();
    }
}

Answer 1

I use the following NHibernate session manager. (This was originally from a CodeProject article, that I had modified to be a little more robust.) There is no initialization in Global.asax, only via configuration parameters in web.config/hibernate.xml.cfg.

using System.Runtime.Remoting.Messaging;
using System.Web;
using NHibernate;
using NHibernate.Cache;
using NHibernate.Cfg;

/// <summary>
/// Handles creation and management of sessions and transactions.  It is a singleton because 
/// building the initial session factory is very expensive. Inspiration for this class came 
/// from Chapter 8 of Hibernate in Action by Bauer and King.  Although it is a sealed singleton
/// you can use TypeMock (http://www.typemock.com) for more flexible testing.
/// </summary>
public sealed class NHibernateSessionManager
{
    #region Thread-safe, lazy Singleton

    /// <summary>
    /// Gets an instance via a thread-safe, lazy singleton.
    /// </summary>
    /// <remarks>
    /// See http://www.yoda.arachsys.com/csharp/singleton.html for more details about its implementation.
    /// </remarks>
    public static NHibernateSessionManager Instance
    {
        get
        {
            return Nested.NHibernateSessionManager;
        }
    }

    /// <summary>
    /// Prevents a default instance of the NHibernateSessionManager class from being created.
    /// Initializes the NHibernate session factory upon instantiation.
    /// </summary>
    private NHibernateSessionManager()
    {
        this.InitSessionFactory();
    }

    /// <summary>
    /// Assists with ensuring thread-safe, lazy singleton
    /// </summary>
    private class Nested
    {
        private Nested()
        {
        }

        internal static readonly NHibernateSessionManager NHibernateSessionManager = new NHibernateSessionManager();
    }

    #endregion

    private void InitSessionFactory()
    {
        this.sessionFactory = new Configuration().Configure().BuildSessionFactory();
    }

    /// <summary>
    /// Allows you to register an interceptor on a new session.  This may not be called if there is already
    /// an open session attached to the HttpContext.  If you have an interceptor to be used, modify
    /// the HttpModule to call this before calling BeginTransaction().
    /// </summary>
    public static void RegisterInterceptor(IInterceptor interceptor)
    {
        ISession session = ContextSession;

        if (session != null && session.IsOpen)
        {
            throw new CacheException(new System.Resources.ResourceManager(typeof(NHibernateSessionManager)).GetString("RegisterInterceptor_CacheException"));
        }

        GetSession(interceptor);
    }

    /// <summary>
    /// Gets a session (without an interceptor). This method is not called directly; instead,
    /// it gets invoked from other public methods.
    /// </summary>
    /// <returns></returns>
    public static ISession GetSession()
    {
        return GetSession(null);
    }

    /// <summary>
    /// Gets a session with or without an interceptor. This method is not called directly; instead,
    /// it gets invoked from other public methods.
    /// </summary>
    /// <remarks>
    /// Throws <see cref="HibernateException"/> if a reference to a session could not be retrieved.
    /// </remarks>
    private static ISession GetSession(IInterceptor interceptor)
    {
        ISession session = ContextSession;

        if (session == null)
        {
            if (interceptor != null)
            {
                session = Instance.sessionFactory.OpenSession(interceptor);
            }
            else
            {
                session = Instance.sessionFactory.OpenSession();
            }

            ContextSession = session;
        }

        if (session == null)
        {
            throw new HibernateException("Session was null");
        }

        return session;
    }

    /// <summary>
    /// Flushes anything left in the session, committing changes as long as no <see cref="NHibernate.AssertionFailure">NHibernate.AssertionFailure's</see> are thrown.
    /// </summary>
    /// <exception cref="System.Data.SqlClient.SqlException"></exception>
    public static void FlushSession()
    {
        ISession session = ContextSession;

        if (session != null && session.IsOpen)
        {
            // Due to a bug in Hibernate (see http://forum.hibernate.org/viewtopic.php?p=2293664#2293664) make sure Flush() is wrapped in a transaction
            if (!HasOpenTransaction())
            {
                BeginTransaction();
            }

            try
            {
                session.Flush();
            }
            catch (NHibernate.AssertionFailure af)
            {
                if (af.Message == "null id in entry (don't flush the Session after an exception occurs)")
                {
                    System.Diagnostics.Trace.TraceError("NHibernate.AssertionFailure: " + af.Message);
                }
                else
                {
                    throw;
                }
            }
            CommitTransaction();
        }

        ContextSession = null;
    }

    /// <summary>
    /// Flushes anything left in the session and closes the connection.
    /// </summary>
    public static void CloseSession()
    {
        ISession session = ContextSession;

        if (session != null && session.IsOpen)
        {
            FlushSession();
            session.Close();
        }

        ContextSession = null;
    }

    /// <summary>
    /// Begin an ITransaction (if one is not already active)
    /// </summary>
    public static void BeginTransaction()
    {
        ITransaction transaction = ContextTransaction;

        if (transaction == null)
        {
            transaction = GetSession().BeginTransaction();
            ContextTransaction = transaction;
        }
    }

    /// <summary>
    /// Begin an ITransaction (if one is not already active)
    /// </summary>
    /// <param name="isolationLevel"></param>
    public static void BeginTransaction(System.Data.IsolationLevel isolationLevel)
    {
        ITransaction transaction = ContextTransaction;

        if (transaction == null)
        {
            transaction = GetSession().BeginTransaction(isolationLevel);
            ContextTransaction = transaction;
        }
    }

    /// <summary>
    /// Commit transaction, if a transaction is currently open. Automatic rollback if commit fails.
    /// </summary>
    public static void CommitTransaction()
    {
        ITransaction transaction = ContextTransaction;

        try
        {
            if (HasOpenTransaction())
            {
                try
                {
                    transaction.Commit();
                }
                catch (NHibernate.AssertionFailure af)
                {
                    if (af.Message == "null id in entry (don't flush the Session after an exception occurs)")
                    {
                        System.Diagnostics.Trace.TraceError("NHibernate.AssertionFailure: " + af.Message);
                    }
                    else
                    {
                        throw;
                    }
                }
                ContextTransaction = null;
            }
        }
        catch (HibernateException)
        {
            RollbackTransaction();
            throw;
        }
    }

    /// <summary>
    /// Checks for an open <see cref="ITransaction"/>.
    /// </summary>
    /// <returns></returns>
    public static bool HasOpenTransaction()
    {
        ITransaction transaction = ContextTransaction;

        return transaction != null && transaction.IsActive && !transaction.WasCommitted && !transaction.WasRolledBack;
    }

    /// <summary>
    /// Rollback transaction, closing the <see cref="ContextSession"/> if successful.
    /// </summary>
    public static void RollbackTransaction()
    {
        ITransaction transaction = ContextTransaction;

        try
        {
            if (HasOpenTransaction())
            {
                transaction.Rollback();
            }

            ContextTransaction = null;
        }
        finally
        {
            if (ContextSession != null)
            {
                ContextSession.Close();
                ContextSession = null;
            }
        }
    }

    /// <summary>
    /// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms 
    /// specific <see cref="CallContext" />.  Discussion concerning this found at 
    /// http://forum.springframework.net/showthread.php?t=572.
    /// </summary>
    private static ITransaction ContextTransaction
    {
        // this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
        // [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)]
        get
        {
            if (IsInWebContext())
            {
                return (ITransaction)HttpContext.Current.Items[TRANSACTION_KEY];
            }
            else
            {
                return (ITransaction)CallContext.GetData(TRANSACTION_KEY);
            }
        }
        // this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
        // [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)]
        set
        {
            if (IsInWebContext())
            {
                HttpContext.Current.Items[TRANSACTION_KEY] = value;
            }
            else
            {
                CallContext.SetData(TRANSACTION_KEY, value);
            }
        }
    }

    /// <summary>
    /// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms 
    /// specific <see cref="CallContext" />.  Discussion concerning this found at 
    /// http://forum.springframework.net/showthread.php?t=572.
    /// </summary>
    private static ISession ContextSession
    {
        // [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)]  // this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
        get
        {
            if (IsInWebContext())
            {
                return (ISession)HttpContext.Current.Items[SESSION_KEY];
            }
            else
            {
                return (ISession)CallContext.GetData(SESSION_KEY);
            }
        }
        // [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)]  // this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
        set
        {
            if (IsInWebContext())
            {
                HttpContext.Current.Items[SESSION_KEY] = value;
            }
            else
            {
                CallContext.SetData(SESSION_KEY, value);
            }
        }
    }

    private static bool IsInWebContext()
    {
        return HttpContext.Current != null;
    }

    private const string TRANSACTION_KEY = "CONTEXT_TRANSACTION";
    private const string SESSION_KEY = "CONTEXT_SESSION";
    private ISessionFactory sessionFactory;
}

Answer 2

Just a guess, but what happens if you put your CurrentSessionContext.Unbind inside the finally scope, just after session.Close()? I can't remember exactly, but I believe the execution is ended after the finally block is done, so if that's the case, the session is still bound to the context, and therefore never evicted..?

Answer 3

The example for NHibernate 1.2 (from NHibernate in Action), shows that the unbind is done before the close.

Does this change of ordering help?

var session = NHibernateHelper.GetCurrentSession();
CurrentSessionContext.Unbind(NHibernateHelper.SessionFactory);
...
session.Close();