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> /// 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; }