public DifferentDatabaseScope(IDbConnection connection) : base(SessionScopeType.Custom) { if (connection == null) { throw new ArgumentNullException("connection"); } this.connection = connection; ISessionScope parentScope = ScopeUtil.FindPreviousScope(this, true); if (parentScope != null) { if (parentScope.ScopeType == SessionScopeType.Simple) { parentSimpleScope = (SessionScope)parentScope; } else if (parentScope.ScopeType == SessionScopeType.Transactional) { parentTransactionScope = (TransactionScope)parentScope; parentTransactionScope.OnTransactionCompleted += new EventHandler(OnTransactionCompleted); } else { // Not supported? } } }
internal static ISessionScope FindPreviousScope(ISessionScope thisScope, bool preferenceForTransactional, bool doNotReturnSessionScope) { object[] items = ThreadScopeAccessor.Instance.CurrentStack.ToArray(); ISessionScope first = null; for (int i = 0; i < items.Length; i++) { ISessionScope scope = items[i] as ISessionScope; if (scope == thisScope) continue; if (first == null) first = scope; if (!preferenceForTransactional) break; if (scope.ScopeType == SessionScopeType.Transactional) { return scope; } } return doNotReturnSessionScope ? null : first; }
/// <summary> /// Initializes a new instance of the <see cref="TransactionScope"/> class. /// </summary> /// <param name="mode">Whatever to create a new transaction or inherits an existing one</param> /// <param name="isolationLevel">The transaction isolation level.</param> /// <param name="onDisposeBehavior">The on dispose behavior.</param> public TransactionScope(TransactionMode mode, IsolationLevel isolationLevel, OnDispose onDisposeBehavior) : base(FlushAction.Config, SessionScopeType.Transactional) { this.mode = mode; this.isolationLevel = isolationLevel; this.onDisposeBehavior = onDisposeBehavior; bool preferenceForTransactionScope = mode == TransactionMode.Inherits ? true : false; ISessionScope previousScope = ScopeUtil.FindPreviousScope(this, preferenceForTransactionScope); if (previousScope != null) { if (previousScope.ScopeType == SessionScopeType.Transactional) { parentTransactionScope = previousScope as TransactionScope; } else { // This is not a safe cast. Reconsider it parentSimpleScope = (AbstractScope)previousScope; foreach (ISession session in parentSimpleScope.GetSessions()) { EnsureHasTransaction(session); } } } }
/// <summary> /// Initializes a new instance of the <see cref="TransactionScope"/> class. /// </summary> public TransactionScope( TransactionMode mode = TransactionMode.New, IsolationLevel isolation = IsolationLevel.Unspecified, OnDispose ondispose = OnDispose.Commit, ISessionScope parent = null, ISessionFactoryHolder holder = null, IThreadScopeInfo scopeinfo = null ) : base(FlushAction.Config, isolation, ondispose, parent, holder, scopeinfo) { this.mode = mode; parentTransactionScope = ParentScope as TransactionScope; if (mode == TransactionMode.New) { if (parentTransactionScope != null) { parentTransactionScope = null; ParentScope = null; } else { parentTransactionScope = null; } } }
private static ISession OpenSessionWithScope(ISessionScope scope, ISessionFactory sessionFactory) { lock (sessionFactory) { return(scope.OpenSession(sessionFactory, InterceptorFactory.Create())); } }
/// <summary> /// Gets the task by task name. /// </summary> /// <param name="name">The tasj name.</param> /// <returns>Scheduled task.</returns> public ScheduledTask GetTaskByName(string name) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope()) { return(sessionScope.GetRepository <ScheduledTask>().Query().SingleOrDefault(x => x.Name == name)); } }
/// <summary> /// Gets all tasks. /// </summary> /// <returns>Task list.</returns> public IList <ScheduledTask> GetAllTasks() { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope()) { return(sessionScope.GetRepository <ScheduledTask>().LoadAll()); } }
/// <summary> /// Gets the task by unique identifier. /// </summary> /// <param name="taskId">The task unique identifier.</param> /// <returns> /// The <see cref="ScheduledTask"/>. /// </returns> public ScheduledTask GetTaskById(int taskId) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope()) { return(sessionScope.GetRepository <ScheduledTask>().Query().SingleOrDefault(x => x.Id == taskId)); } }
internal static ISessionScope FindPreviousScope(ISessionScope thisScope, bool preferenceForTransactional, bool doNotReturnSessionScope) { object[] items = ThreadScopeAccessor.Instance.CurrentStack.ToArray(); ISessionScope first = null; for (int i = 0; i < items.Length; i++) { ISessionScope scope = items[i] as ISessionScope; if (scope == thisScope) { continue; } if (first == null) { first = scope; } if (!preferenceForTransactional) { break; } if (preferenceForTransactional && scope.ScopeType == SessionScopeType.Transactional) { return(scope); } } return(doNotReturnSessionScope ? null : first); }
private ISession CreateScopeSession(Type type) { ISessionScope scope = threadScopeInfo.GetRegisteredScope(); ISessionFactory sessionFactory = GetSessionFactory(type); #if DEBUG System.Diagnostics.Debug.Assert(scope != null); System.Diagnostics.Debug.Assert(sessionFactory != null); #endif if (scope.IsKeyKnown(sessionFactory)) { return(scope.GetSession(sessionFactory)); } else { ISession session; if (scope.WantsToCreateTheSession) { session = OpenSessionWithScope(scope, sessionFactory); } else { session = OpenSession(sessionFactory); } #if DEBUG System.Diagnostics.Debug.Assert(session != null); #endif scope.RegisterSession(sessionFactory, session); return(session); } }
private static ISession OpenSessionWithScope(ISessionScope scope, ISessionFactory sessionFactory) { lock (sessionFactory) { return(scope.OpenSession(sessionFactory, HookDispatcher.Instance)); } }
public TransactionScope(TransactionMode mode) : base(SessionScopeType.Transactional) { this.mode = mode; ISessionScope previousScope = ScopeUtil.FindPreviousScope(this, mode == TransactionMode.Inherits ? true : false ); if (previousScope != null) { if (previousScope.ScopeType == SessionScopeType.Transactional) { parentTransactionScope = previousScope as TransactionScope; } else { // This is not a safe cast. Reconsider it parentSimpleScope = (AbstractScope) previousScope; foreach(ISession session in parentSimpleScope.GetSessions()) { EnsureHasTransaction(session); } } } }
/// <summary> /// Unregister the scope. /// </summary> /// <param name="scope">The scope.</param> public void UnRegisterScope(ISessionScope scope) { if (GetRegisteredScope() != scope) { throw new ScopeMachineryException("Tried to unregister a scope that is not the active one"); } CurrentStack.Pop(); }
private async Task InterceptAsync(Task task, ISessionScope scope, CancellationToken ct) { await task.ContinueWith(async t => { await scope.SaveChangesAsync(ct); scope.Dispose(); }, ct).ConfigureAwait(false); }
public UnitOfWorkScenario() { SessionScopeFactory = A.Fake <ISessionScopeFactory>(); SessionScope = A.Fake <ISessionScope>(); A.CallTo(() => SessionScopeFactory.Open()).Returns(SessionScope); Func <string, ISessionScopeFactory> sessionScopeFactoryExtractor = name => (name == UnitOfWorkSettings.Default.StorageName ? SessionScopeFactory : null); UnitOfWork.SessionScopeFactoryExtractor = sessionScopeFactoryExtractor; }
/// <summary> /// Deletes the task. /// </summary> /// <param name="taskId">The task unique identifier.</param> public void DeleteTask(int taskId) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope()) { sessionScope.GetRepository <ScheduledTask>().Delete(x => x.Id == taskId); sessionScope.Complete(); } }
public UnitOfWorkNamedStorageScenario() { SessionScopeFactory = A.Fake <ISessionScopeFactory>(); SessionScope = A.Fake <ISessionScope>(); A.CallTo(() => SessionScopeFactory.Open()).Returns(SessionScope); Func <string, ISessionScopeFactory> sessionScopeFactoryExtractor = name => (name == "SuperStorage" ? SessionScopeFactory: null); UnitOfWork.SessionScopeFactoryExtractor = sessionScopeFactoryExtractor; }
/// <summary> /// Registers the scope. /// </summary> /// <param name="scope">The scope.</param> public void RegisterScope(ISessionScope scope) { if (scopeInfo == null) { throw new ActiveRecordException("A scope tried to registered itself within the framework, " + "but the Active Record was not initialized"); } scopeInfo.RegisterScope(scope); }
public DatabaseSession(ISessionScope session) { if (session == null) { throw new ArgumentNullException("session"); } this.session = session; }
/// <summary> /// Registers the scope. /// </summary> /// <param name="scope">The scope.</param> public void RegisterScope(ISessionScope scope) { if (scopeInfo == null) { throw new ActiveRecordException("A scope tried to register itself within the framework, " + "but the Active Record was not initialized"); } scopeInfo.RegisterScope(scope); }
/// <summary> /// Initializes a new instance of the <see cref="WebPageScope"/> class. /// </summary> /// <param name="sessionContest">The session contest.</param> /// <param name="navigationState">State of the navigation.</param> public WebPageScope(ISessionScope sessionContest, NavigationState navigationState) { AssertUtils.ArgumentNotNull(sessionContest, "sessionContest"); AssertUtils.ArgumentNotNull(navigationState, "navigationState"); _sessionScope = sessionContest; _navigationState = navigationState; }
private ISession GetSession() { ISessionScope scope = SessionScope.Current; if (scope == null) { throw new InvalidOperationException("You should be in a SessionScope()"); } ISessionFactoryHolder holder = ActiveRecordMediator.GetSessionFactoryHolder(); return(holder.CreateSession(typeof(ActiveRecordBase))); }
public ISession GetCurrentSessionFor(Type typeOfEntity) { ISessionScope scope = SessionScope.Current; if (scope == null) { throw new InvalidOperationException("You are not in a unit of work"); } ISessionFactoryHolder holder = ActiveRecordMediator.GetSessionFactoryHolder(); return(holder.CreateSession(typeOfEntity)); }
/// <summary> /// Called if an action on the session fails /// </summary> /// <param name="session"></param> public void FailSession(ISession session) { if (threadScopeInfo.HasInitializedScope) { ISessionScope scope = threadScopeInfo.GetRegisteredScope(); scope.FailSession(session); } else { session.Clear(); } }
/// <summary> /// Inserts the task. /// </summary> /// <param name="task">The task.</param> public void InsertTask(ScheduledTask task) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope()) { IRepository <ScheduledTask> repository = sessionScope.GetRepository <ScheduledTask>(); ValidateTask(repository, task); repository.Insert(task); sessionScope.Complete(); } }
/// <summary> /// Updates the start date. /// </summary> /// <param name="taskId">The task unique identifier.</param> /// <param name="startDateUtc">The start date UTC.</param> public void UpdateStartDate(int taskId, DateTime startDateUtc) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope(SessionScopeOption.RequiresNew)) { ScheduledTask task = new ScheduledTask { Id = taskId, LastStartUtc = startDateUtc }; sessionScope.GetRepository <ScheduledTask>().UpdateProperties(task, x => x.Id, x => x.LastStartUtc); sessionScope.Complete(); } }
private async Task <T> InterceptAsync <T>(Task <T> task, ISessionScope scope, CancellationToken ct) { var result = await task.ContinueWith(async t => { var res = t.Result; await scope.SaveChangesAsync(ct); scope.Dispose(); return(res); }, ct).ConfigureAwait(false); return(await result); }
/// <summary> /// Initializes a new instance of the <see cref="DifferentDatabaseScope"/> class. /// </summary> public DifferentDatabaseScope( IDbConnection connection, FlushAction flushAction = FlushAction.Auto, ISessionScope parent = null, ISessionFactoryHolder holder = null, IThreadScopeInfo scopeinfo = null ) : base(flushAction, parent: parent, holder: holder, scopeinfo: scopeinfo) { if (connection == null) throw new ArgumentNullException("connection"); _connection = connection; }
/// <summary> /// Initializes a new instance of the <see cref="DifferentDatabaseScope"/> class. /// </summary> public DifferentDatabaseScope( IDbConnection connection, FlushAction flushAction = FlushAction.Auto, ISessionScope parent = null, ISessionFactoryHolder holder = null, IThreadScopeInfo scopeinfo = null ) : base(flushAction, parent: parent, holder: holder, scopeinfo: scopeinfo) { if (connection == null) { throw new ArgumentNullException("connection"); } _connection = connection; }
/// <summary> /// Updates the task. /// </summary> /// <param name="task">The task.</param> public void UpdateTask(ScheduledTask task) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope()) { IRepository <ScheduledTask> repository = sessionScope.GetRepository <ScheduledTask>(); ValidateTask(repository, task); repository .UpdateProperties( task, x => x.Id, x => x.Enabled, x => x.Name, x => x.Description, x => x.RunOnlyOnce, x => x.Seconds, x => x.StopOnError, x => x.Type, x => x.Configuration); sessionScope.Complete(); } }
/// <summary> /// Updates the end date. /// </summary> /// <param name="taskId">The task unique identifier.</param> /// <param name="endDateUtc">The end date UTC.</param> /// <param name="success">if set to <c>true</c> [success].</param> public void UpdateEndDate(int taskId, DateTime endDateUtc, bool success) { using (ISessionScope sessionScope = m_SessionScopeProvider.CreateSessionScope(SessionScopeOption.RequiresNew)) { ScheduledTask task = new ScheduledTask { Id = taskId, LastEndUtc = endDateUtc }; IRepository <ScheduledTask> repository = sessionScope.GetRepository <ScheduledTask>(); if (success) { task.LastSuccessUtc = endDateUtc; repository.UpdateProperties(task, x => x.Id, x => x.LastEndUtc, x => x.LastSuccessUtc); } else { repository.UpdateProperties(task, x => x.Id, x => x.LastEndUtc); } sessionScope.Complete(); } }
/// <summary> /// Obtem a sessão ativa quando utilizado em web /// </summary> /// <returns>Sessão a ser usada</returns> public static ISession GetActiveRecordSession() { ISessionFactoryHolder holder = ActiveRecordMediator.GetSessionFactoryHolder(); ISessionScope activeScope = holder.ThreadScopeInfo.GetRegisteredScope(); ISession session = null; var key = holder.GetSessionFactory(typeof(ActiveRecordBase)); if (activeScope == null) { session = holder.CreateSession(typeof(ActiveRecordBase)); } else { if (activeScope.IsKeyKnown(key)) { session = activeScope.GetSession(key); } else { session = holder.GetSessionFactory(typeof(ActiveRecordBase)).OpenSession(); } } return(session); }
public ActiveRecordUnitOfWorkAdapter(ISessionScope scope, IUnitOfWorkImplementor previous) { this.scope = scope; this.previous = previous; }
/// <summary> /// Initializes a new instance of the <see cref="WebConversationScope"/> class. /// </summary> /// <param name="conversationManager">The conversation manager.</param> /// <param name="sessionScope">The session context.</param> public WebConversationScope(IConversationManager conversationManager, ISessionScope sessionScope) { _conversationManager = conversationManager; _sessionScope = sessionScope; }
public HighScoreController(ISessionScope sessionScope) { this.sessionScope = sessionScope; }
internal static ISessionScope FindPreviousScope(ISessionScope thisScope, bool preferenceForTransactional) { return(FindPreviousScope(thisScope, preferenceForTransactional, false)); }
public void SetUp() { _sessionScope = _container.Resolve<ISessionScope>(); _pageScope = _container.Resolve<IPageScope>(); _requestScope = _container.Resolve<IRequestScope>(); }
internal static ISession OpenSessionWithScope(ISessionScope scope, ISessionFactory sessionFactory) { lock(sessionFactory) { return scope.OpenSession(sessionFactory, InterceptorFactory.Create()); } }
/// <summary> /// Unregister the scope. /// </summary> /// <param name="scope">The scope.</param> public void UnRegisterScope(ISessionScope scope) { scopeInfo.UnRegisterScope(scope); }
/// <summary> /// Registers the scope. /// </summary> /// <param name="scope">The scope.</param> public void RegisterScope(ISessionScope scope) { CurrentStack.Push(scope); }
internal static ISessionScope FindPreviousScope(ISessionScope thisScope, bool preferenceForTransactional) { return FindPreviousScope(thisScope, preferenceForTransactional, false); }