public override void Commit() { var toPatch = _patchRequests.ToLookup(a => a.Key, a => a.Value); foreach (var item in toPatch) { foreach (var patch in item.Select(x => new PatchCommandData(item.Key, null, x, null))) { _session.Advanced.Defer(patch); } } try { _session.SaveChanges(); _session.Dispose(); } catch { Logger.Error("- Concurrency exception"); _session.Dispose(); throw; } foreach (var command in _afterCommitCommandQueue) { command(); } }
/// <summary> /// Occurs after the action method is invoked. /// </summary> /// <param name="context">The context for the action.</param> public void OnActionExecuted( HttpActionExecutedContext context) { if (context.Exception != null) { return; } if (_session != null) { if (_session.Advanced.NumberOfRequests > 30) { Debug.WriteLine("Number of recommended (30) remote call requests have been exceeded"); } lock (_session) { _session.SaveChanges(); _session.Advanced.Clear(); _session.Dispose(); } } if (_asyncSession != null) { _asyncSession.SaveChangesAsync(); _asyncSession.Advanced.Clear(); _asyncSession.Dispose(); } }
public virtual void SaveChanges() { if (_session == null) { return; } _session.SaveChanges(); _session.Dispose(); _session = null; }
public void Add_Adds_Customer_To_Store() { var customerFake = new CustomerFake(); _repository.Add(customerFake); Received.InOrder(() => { _defaultSession.Store(customerFake); _defaultSession.SaveChanges(); _defaultSession.Dispose(); }); }
public void AddStoresDocument() { Expect.Call(() => _session.Store(_document1)); Expect.Call(() => _session.SaveChanges()); Expect.Call(() => _session.Dispose()); _mocks.ReplayAll(); using (new DocumentSessionScope(_session)) { _repository.Save(_document1); } _mocks.VerifyAll(); }
/// <summary> /// Occurs after the action method is invoked. /// </summary> /// <param name="context">The context for the action.</param> public void OnActionExecuted( HttpActionExecutedContext context) { if (context.Exception != null) { return; } lock (_session) { _session?.SaveChanges(); _session?.Advanced.Clear(); _session?.Dispose(); } }
public void SetOrganisation(Organisation organisation, bool allowReset = false /*some system tasks require us to do this*/) { if (!allowReset && _organisation != null && _organisation.FriendlyId != organisation.FriendlyId) { throw new InvalidOperationException("Cannot set Organisation twice in one session."); } _organisation = organisation; if (_organisationSession != null) { _organisationSession.Dispose(); } _organisationSession = null; }
public override void Dispose() { if (Session != null) { Session.Dispose(); } }
public override void Dispose() { _session.Dispose(); _store.Dispose(); base.Dispose(); }
public void Dispose() { if (session != null) { session.Dispose(); } }
public Task AddTrackInfosAsync(List <TrackInfo> trackInfos, IDocumentSession session = null) { this.ThrowIfDisposed(); if (trackInfos == null) { throw new ArgumentNullException("trackInfo"); } IDocumentSession localSession = session; if (session == null) { localSession = RavenContext.Current.CreateSession(); } foreach (var trackInfo in trackInfos) { localSession.Store(trackInfo); } localSession.SaveChanges(); if (session == null) { localSession.Dispose(); } return(Task.FromResult(true)); }
public void GetVersionAndHasVersion() { Expect.Call(_session.Load <VersionContainerTest>(Id6)).Return(new VersionContainerTest()); Expect.Call(() => _session.SaveChanges()); Expect.Call(() => _session.Dispose()); _mocks.ReplayAll(); using (new DocumentSessionScope(_session)) { Assert.IsTrue(_repository.HasVersion(Id6)); } _mocks.VerifyAll(); Assert.IsFalse(_repository.HasVersion(string.Empty)); }
protected virtual void Dispose(bool disposing) { if (disposing) { _documentSession?.Dispose(); } }
public void Dispose() { store.Dispose(); session.Dispose(); store = null; session = null; }
public virtual void Dispose() { if (_disposeDocumentSession && _documentSession != null) { _documentSession.Dispose(); } }
public void Dispose() { if (_documentSession != null) { _documentSession.Dispose(); } }
public override void Dispose() { Debug.WriteLine("I AM BEING DISPOSED!"); theSession.Dispose(); theStore.Dispose(); theContainer.Dispose(); }
protected virtual void Dispose(bool disposing) { if (disposing) { session.Dispose(); } }
public static AuthorizedSession OpenSession(IDocumentStore store, string userId, string password) { IDocumentSession session = null; try { session = store.OpenSession(); var user = session.Load <AuthorizedUser>(userId); if (user == null) { ThrowNoPermissions(userId); } //TODO:change to graph query if (CheckValidAuthorizedUser(userId, password, user.PasswordHash) == false) { ThrowNoPermissions(userId); } return(new AuthorizedSession(store, session, user)); } catch { session?.Dispose(); throw; } }
public async Task ShouldUpdateDocumentInRepository() { var address = await InsertAddress(); Guid meterId = Guid.NewGuid(); var repo = CreateGenericMartenRepository(); var loadedAddress = await repo.Get(address); loadedAddress.AssignMeter(meterId); repo.Update(loadedAddress); await _session.SaveChangesAsync(); _session.Dispose(); _session = _fixture.DocumentStore.OpenSession(); repo = CreateGenericMartenRepository(); loadedAddress = await repo.Get(address); Assert.True(loadedAddress.GetMeters().Any(i => i == meterId)); }
public void EndSession(bool succesfully) { ICallContext currentContext = this.callContextFactory.RetrieveCallContext(); IDocumentSession session = currentContext[SessionStateKey] as IDocumentSession; if (session == null) { logger.Debug("There is no session into the current context."); return; } try { if (succesfully) { logger.Debug("Saving changes"); session.SaveChanges(); } else { logger.Debug("An error occured, so I'm not flushing the changes"); } } finally { session.Dispose(); currentContext[SessionStateKey] = null; logger.Debug("Session Removed"); } }
private void LoadAndSubscribeButton_Click(object sender, EventArgs e) { _session = DocumentStoreHolder.Store.OpenSession(); _category = _session.Load <Category>(CategoryIdTextbox.Text); if (_category == null) { MessageBox.Show("Category not found!"); _session.Dispose(); } else { NameTextbox.Text = _category.Name; DescriptionTextbox.Text = _category.Description; _localEtag = _session.Advanced.GetEtagFor(_category); _subscription = DocumentStoreHolder.Store .Changes() .ForDocument(CategoryIdTextbox.Text) .Where(DocumentChangedByOtherUser) .Subscribe(DocumentChangedOnServer); ToggleEditing(); } }
/// <summary> /// Releases the mutex. /// </summary> private void Dispose(bool disposing) { if (_session != null && _lock != null) { try { _session.Delete(_lock); _session.SaveChanges(); } finally { _lock = null; } } if (_session != null) { _session.Dispose(); } if (disposing) { _session = null; } }
/// <summary> /// Customize the store configuration for one off tests. /// The return value is the database schema /// </summary> /// <param name="configure"></param> /// <returns></returns> protected string StoreOptions(Action <StoreOptions> configure) { if (_session != null) { _session.Dispose(); Disposables.Remove(_session); _session = null; } var options = new StoreOptions(); options.Connection(ConnectionSource.ConnectionString); // Can be overridden options.AutoCreateSchemaObjects = AutoCreate.All; options.NameDataLength = 100; options.DatabaseSchemaName = GetType().Name.Sanitize(); configure(options); _store = new DocumentStore(options); Disposables.Add(_store); _store.Advanced.Clean.CompletelyRemoveAll(); return(options.DatabaseSchemaName); }
protected override void Dispose(bool disposing) { if (disposing) { documentSession.Dispose(); } base.Dispose(disposing); }
public virtual void Dispose() { _store?.Dispose(); if (_session != null) { _session.Dispose(); } }
public void Dispose() { foreach (var disposable in _stores) { disposable.Dispose(); } _session?.Dispose(); _store?.Dispose(); }
/// <summary> /// Closes the session. /// </summary> protected void PossiblyCloseSession() { // Only close the session for the instance that opened it originally. if (_isInitialDalInstance == true) { _session.Dispose(); _session = null; } }
protected override void OnUnload(EventArgs e) { if (_session != null) { _session.Dispose(); _session = null; } base.OnUnload(e); }
public void Read() { _reader.OnDocument += _reader_OnDocument; _session = MvcApplication.DocumentStore.OpenSession(); _reader.Read(); _session.SaveChanges(); _session.Dispose(); }
public void Dispose() { Repository.Dispose(); _session.Dispose(); if (_scope != null) { _scope.Dispose(); } }
public DeviceModule(ILogger logger, IDeviceRepository deviceRepository, IDocumentSession documentSession) : base("/devices") { Get["/"] = p => { var registeredDevices = deviceRepository.GetAll(); var registeredDeviceDtos = Mapper.Map<IEnumerable<RegisteredDeviceDto>>(registeredDevices); return Response.AsJson(registeredDeviceDtos); }; Post["/"] = p => { var newDeviceRequest = this.Bind<DeviceSetupRequest>(); var registeredDevice = new RegisteredDevice(newDeviceRequest.DeviceName, newDeviceRequest.DeviceType, newDeviceRequest.IpAddress); deviceRepository.Add(registeredDevice); documentSession.SaveChanges(); documentSession.Dispose(); return HttpStatusCode.OK; }; Post["/{name}/{commandRoute}"] = p => { Response response = HttpStatusCode.NotFound; //Lookup IP address and device type from device //TODO: Implement singleton DeviceMap object to cache and return this data var device = deviceRepository.FindByName(p.name); if (device != null) { var commandRoute = String.Format("/{0}/{1}", device.Type, p.commandRoute); response = new Response(); response.Headers.Add("cmd-route", commandRoute); response.Headers.Add("cmd-ip", device.IpAddress); response.StatusCode = HttpStatusCode.OK; logger.Info(String.Format("Recievied the {0} command for the {1}. Routing it to {2}", p.commandRoute, p.device, commandRoute)); } return response; }; Delete["/{name}"] = p => { Response response = HttpStatusCode.NotFound; return response; }; }
public void CanUpdateTasks() { Task task = new Task { Description = "kuvaus", Status = "ToDo" }; taskRepository.Save(task); session.Dispose(); session = documentStore.OpenSession(); taskRepository=new TaskRepository(session); var updateTask = taskRepository.Find().First(); updateTask.Status = "Done"; taskRepository.Update(updateTask); session.Dispose(); session = documentStore.OpenSession(); taskRepository = new TaskRepository(session); var result = taskRepository.Find().First(); Assert.That(result.Status,Is.EqualTo("Done")); }
public void Leave(string roomName, IDocumentSession session = null) { //using (var session = store.OpenSession()) var isExternalSession = session == null; if (session == null) session = store.OpenSession(); try { if (!joinedRooms.Any(r => r.Name.Equals(roomName, StringComparison.InvariantCultureIgnoreCase))) { Console.WriteLine("Cannot leave because not joined.."); return; } var roomToLeave = session.Load<Room>($"rooms/{roomName}"); if (roomToLeave != null) { roomToLeave.Users.Remove($"users/{username}"); if (roomToLeave.Users.Count == 0) //room is empty - no need to keep it { var idsToDelete = new List<string>(); using (var stream = session.Advanced.Stream( session.Query<Message, MessagesByRoomIndex>())) { do { if(stream.Current != null) session.Delete(stream.Current.Key); } while (stream.MoveNext()); } session.Delete(roomToLeave); } } joinedRooms.RemoveAt(joinedRooms.FindIndex(r => r.Id == roomToLeave.Id)); session.SaveChanges(); Console.WriteLine($"Left room {roomName}"); } finally { if (isExternalSession) session.Dispose(); } }
private IEnumerable<EventBase> ConsumeEvents(IEnumerable<EventBase> events, IDocumentSession session) { var concurrencyExceptions = new List<EventBase>(); foreach (var @event in events) { var interfaceType = typeof (IConsumerOf<>).MakeGenericType(@event.GetType()); if (_eventConsumers.ContainsKey(interfaceType) == false) continue; var consumers = _eventConsumers[interfaceType]; foreach (var consumer in consumers) { var instance = Activator.CreateInstance(consumer); instance.GetType().GetProperty("Session").SetValue(instance, session); if (instance is INeedClientSettings) { ((INeedClientSettings) instance).ClientSettings = _clientSettings; } try { instance.GetType().GetMethod("Consume", new[] { @event.GetType() }).Invoke(instance, new[] { @event }); } catch (Exception exception) { throw new MessageConsumeException(exception, interfaceType, instance.GetType().Name); } } try { if(session.Advanced.HasChanges) session.SaveChanges(); } catch (ConcurrencyException) { concurrencyExceptions.Add(@event); } finally { session.Dispose(); } } return concurrencyExceptions; }
internal static void SaveAndCloseSession(IDocumentSession session) { session.SaveChanges(); session.Dispose(); }