public void FindCompatibleStatelessSessionWithTwoThreads()
{
ISessionStore store = container.Resolve <ISessionStore>();
ISessionFactory factory = container.Resolve <ISessionFactory>();
IStatelessSession session = factory.OpenStatelessSession();
StatelessSessionDelegate sessionDelegate = new StatelessSessionDelegate(true, session, store);
store.Store(Constants.DefaultAlias, sessionDelegate);
IStatelessSession session2 = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNotNull(session2);
Assert.AreSame(sessionDelegate, session2);
Thread newThread = new Thread(FindCompatibleStatelessSessionOnOtherThread);
newThread.Start();
arEvent.WaitOne();
sessionDelegate.Dispose();
Assert.IsTrue(store.IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
/// <summary>
/// Should remove the stateless session from the store only.
/// </summary>
/// <param name="session"></param>
public void Remove(StatelessSessionDelegate session)
{
var stack = (Stack)session.SessionStoreCookie;
if (stack == null)
{
throw new InvalidProgramException("AbstractSessionStore.Remove called " +
"with no cookie - no pun intended");
}
if (stack.Count == 0)
{
throw new InvalidProgramException("AbstractSessionStore.Remove called " +
"for an empty stack");
}
var current = stack.Peek() as IStatelessSession;
if (session != current)
{
throw new InvalidProgramException("AbstractSessionStore.Remove tried to " +
"remove a session which is not on the top or not in the stack at all");
}
stack.Pop();
}
/// <summary>
/// Should store the specified stateless session instance.
/// </summary>
/// <param name="alias"></param>
/// <param name="session"></param>
public void Store(string alias, StatelessSessionDelegate session)
{
var stack = GetStatelessSessionStackFor(alias);
stack.Push(session);
session.SessionStoreCookie = stack;
}
public void PerformStatelessPieceOfOperation(IStatelessSession previousSession)
{
Assert.IsNotNull(previousSession);
using (IStatelessSession session = sessManager.OpenStatelessSession())
{
Assert.IsNotNull(session);
Assert.IsTrue(StatelessSessionDelegate.AreEqual(session, previousSession));
}
}
public void NewTransactionAfterUsingStatelessSession()
{
ISessionManager manager = container.Resolve <ISessionManager>();
IStatelessSession session1 = manager.OpenStatelessSession();
ITransactionManager tmanager = container.Resolve <ITransactionManager>();
ITransaction transaction = tmanager.CreateTransaction(
TransactionMode.Requires,
IsolationMode.Serializable);
transaction.Begin();
// Nested
using (IStatelessSession session2 = manager.OpenStatelessSession())
{
Assert.IsNotNull(session2);
Assert.IsNotNull(session1);
Assert.IsNotNull(session1.Transaction,
"After requesting compatible session, first session is enlisted in transaction too.");
Assert.IsTrue(session1.Transaction.IsActive,
"After requesting compatible session, first session is enlisted in transaction too.");
using (ISession session3 = manager.OpenSession())
{
Assert.IsNotNull(session3);
Assert.IsNotNull(session3.Transaction);
Assert.IsTrue(session3.Transaction.IsActive);
}
StatelessSessionDelegate delagate1 = (StatelessSessionDelegate)session1;
StatelessSessionDelegate delagate2 = (StatelessSessionDelegate)session2;
Assert.AreSame(delagate1.InnerSession, delagate2.InnerSession);
}
transaction.Commit();
// TODO: Assert transaction was committed
// Assert.IsTrue(session1.Transaction.WasCommitted);
Assert.IsTrue(session1.IsConnected);
session1.Dispose();
Assert.IsTrue(container.Resolve <ISessionStore>().IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
public void SharedStatelessSession()
{
var manager = container.Resolve <ISessionManager>();
IStatelessSession session1 = manager.OpenStatelessSession();
IStatelessSession session2 = manager.OpenStatelessSession();
IStatelessSession session3 = manager.OpenStatelessSession();
Assert.IsNotNull(session1);
Assert.IsNotNull(session2);
Assert.IsNotNull(session3);
Assert.IsTrue(StatelessSessionDelegate.AreEqual(session1, session2));
Assert.IsTrue(StatelessSessionDelegate.AreEqual(session1, session3));
session3.Dispose();
session2.Dispose();
session1.Dispose();
Assert.IsTrue(container.Resolve <ISessionStore>().IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
public void FindCompatibleStatelessSession()
{
ISessionStore store = container.Resolve <ISessionStore>();
ISessionFactory factory = container.Resolve <ISessionFactory>();
IStatelessSession session = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNull(session);
session = factory.OpenStatelessSession();
StatelessSessionDelegate sessionDelegate = new StatelessSessionDelegate(true, session, store);
store.Store(Constants.DefaultAlias, sessionDelegate);
Assert.IsNotNull(sessionDelegate.SessionStoreCookie);
IStatelessSession session2 = store.FindCompatibleStatelessSession("something in the way she moves");
Assert.IsNull(session2);
session2 = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNotNull(session2);
Assert.AreSame(sessionDelegate, session2);
session.Dispose();
store.Remove(sessionDelegate);
session = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNull(session);
Assert.IsTrue(store.IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
public void FindCompatibleStatelessSessionWithTwoThreads()
{
ISessionStore store = container.Resolve<ISessionStore>();
ISessionFactory factory = container.Resolve<ISessionFactory>();
IStatelessSession session = factory.OpenStatelessSession();
StatelessSessionDelegate sessionDelegate = new StatelessSessionDelegate(true, session, store);
store.Store(Constants.DefaultAlias, sessionDelegate);
IStatelessSession session2 = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNotNull(session2);
Assert.AreSame(sessionDelegate, session2);
Thread newThread = new Thread(FindCompatibleStatelessSessionOnOtherThread);
newThread.Start();
arEvent.WaitOne();
sessionDelegate.Dispose();
Assert.IsTrue(store.IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
public void FindCompatibleStatelessSession()
{
ISessionStore store = container.Resolve<ISessionStore>();
ISessionFactory factory = container.Resolve<ISessionFactory>();
IStatelessSession session = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNull(session);
session = factory.OpenStatelessSession();
StatelessSessionDelegate sessionDelegate = new StatelessSessionDelegate(true, session, store);
store.Store(Constants.DefaultAlias, sessionDelegate);
Assert.IsNotNull(sessionDelegate.SessionStoreCookie);
IStatelessSession session2 = store.FindCompatibleStatelessSession("something in the way she moves");
Assert.IsNull(session2);
session2 = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNotNull(session2);
Assert.AreSame(sessionDelegate, session2);
session.Dispose();
store.Remove(sessionDelegate);
session = store.FindCompatibleStatelessSession(Constants.DefaultAlias);
Assert.IsNull(session);
Assert.IsTrue(store.IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
/// <summary>
/// Should remove the stateless session from the store only.
/// </summary>
/// <param name="session"></param>
public void Remove(StatelessSessionDelegate session)
{
var stack = (Stack) session.SessionStoreCookie;
if (stack == null)
{
throw new InvalidProgramException("AbstractSessionStore.Remove called " +
"with no cookie - no pun intended");
}
if (stack.Count == 0)
{
throw new InvalidProgramException("AbstractSessionStore.Remove called " +
"for an empty stack");
}
var current = stack.Peek() as IStatelessSession;
if (session != current)
{
throw new InvalidProgramException("AbstractSessionStore.Remove tried to " +
"remove a session which is not on the top or not in the stack at all");
}
stack.Pop();
}
/// <summary>
/// Should store the specified stateless session instance.
/// </summary>
/// <param name="alias"></param>
/// <param name="session"></param>
public void Store(string alias, StatelessSessionDelegate session)
{
Stack stack = GetStatelessSessionStackFor(alias);
stack.Push(session);
session.SessionStoreCookie = stack;
}
public void Close_with_canClose_false()
{
_delegate = new StatelessSessionDelegate(false, _mock.Object);
_delegate.Close();
_mock.Verify(s => s.Close(), Times.Exactly(0));
}
/// <summary>
/// Initializes a new instance of the <see cref="StatelessSessionDisposeSynchronization"/> class.
/// </summary>
/// <param name="session">The session.</param>
public StatelessSessionDisposeSynchronization(StatelessSessionDelegate session)
{
this._session = session;
}
/// <summary>
/// Enlists if necessary.
/// </summary>
/// <param name="weAreSessionOwner">if set to <c>true</c> [we are session owner].</param>
/// <param name="transaction">The transaction.</param>
/// <param name="session">The session.</param>
/// <returns></returns>
protected bool EnlistIfNecessary(bool weAreSessionOwner,
ITransaction transaction,
StatelessSessionDelegate session)
{
if (transaction == null) return false;
var list = (IList<IStatelessSession>) transaction.Context["nh.statelessSession.enlisted"];
bool shouldEnlist;
if (list == null)
{
list = new List<IStatelessSession>();
shouldEnlist = true;
}
else
{
shouldEnlist = true;
foreach (IStatelessSession sess in list)
{
if (StatelessSessionDelegate.AreEqual(session, sess))
{
shouldEnlist = false;
break;
}
}
}
if (shouldEnlist)
{
if (session.Transaction == null || !session.Transaction.IsActive)
{
transaction.Context["nh.statelessSession.enlisted"] = list;
IsolationLevel level = TranslateIsolationLevel(transaction.IsolationMode);
transaction.Enlist(new ResourceAdapter(session.BeginTransaction(level), transaction.IsAmbient));
list.Add(session);
}
if (weAreSessionOwner)
{
transaction.RegisterSynchronization(new StatelessSessionDisposeSynchronization(session));
}
}
return true;
}
public void SetUp()
{
_mock = new Mock<IStatelessSession>();
_delegate = new StatelessSessionDelegate(true, _mock.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="StatelessSessionDisposeSynchronization"/> class.
/// </summary>
/// <param name="session">The session.</param>
public StatelessSessionDisposeSynchronization(StatelessSessionDelegate session)
{
this._session = session;
}
/// <summary>
/// Enlists if necessary.
/// </summary>
/// <param name="weAreSessionOwner">if set to <c>true</c> [we are session owner].</param>
/// <param name="transaction">The transaction.</param>
/// <param name="session">The session.</param>
/// <returns></returns>
protected bool EnlistIfNecessary(bool weAreSessionOwner,
ITransaction transaction,
StatelessSessionDelegate session)
{
if (transaction == null) return false;
if (weAreSessionOwner && session.Transaction.IsActive)
{
var ue = new UnregisterEnlistment(Logger, session.UnregisterFromStore, transaction);
transaction.Inner.EnlistVolatile(ue, EnlistmentOptions.EnlistDuringPrepareRequired);
}
return true;
}
