public IPersistanceData Get(long persistanceDataId) { IPersistanceData result = null; using (var connection = new SqlConnectionWithExceptionLogger(this._loggingService, this._connectionStringValue)) { connection.Open(); connection.TryExecute(() => { var command = connection.CreateCommand(); command.CommandType = CommandType.Text; command.CommandText = "SELECT [SomeData] FROM [dbo].[ufn_GetPersistedData](@PersistanceDataId)"; command.Parameters.AddWithValue("@PersistanceDataId", persistanceDataId); using (var reader = command.ExecuteReader()) { if (reader.Read()) { result = new PersistanceData { SomeData = reader.GetString(0) }; } } }); } return(result); }
/// <summary> /// Removes existing instance of ProcessManager from the database and /// completes transaction opened by FindData(). /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> public void DeleteData <T>(IPersistanceData <T> data) where T : class, IProcessManagerData { string tableName = GetTableName(data.Data); var sqlServerData = (SqlServerData <T>)data; string sql = string.Format(@"DELETE FROM {0} WHERE Id = @Id", tableName); using (var sqlConnection = new SqlConnection(_connectionString)) { sqlConnection.Open(); using (var command = new SqlCommand(sql)) { command.Connection = sqlConnection; command.Parameters.Add("@Id", SqlDbType.UniqueIdentifier).Value = sqlServerData.Id; try { command.ExecuteNonQuery(); } finally { sqlConnection.Close(); } } } }
/// <summary> /// Update data of existing ProcessManager. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="persistanceData"></param> public void UpdateData <T>(IPersistanceData <T> persistanceData) where T : class, IProcessManagerData { var collectionName = GetCollectionName(persistanceData.Data); IMongoCollection <MongoDbSslData <T> > collection = _mongoDatabase.GetCollection <MongoDbSslData <T> >(collectionName); var indexOptions = new CreateIndexOptions(); var indexKeys = Builders <MongoDbSslData <T> > .IndexKeys.Ascending("Data.CorrelationId"); var indexModel = new CreateIndexModel <MongoDbSslData <T> >(indexKeys, indexOptions); collection.Indexes.CreateOne(indexModel); var versionData = (MongoDbSslData <T>)persistanceData; int currentVersion = versionData.Version; var filter = Builders <MongoDbSslData <T> > .Filter.Eq("Data.CorrelationId", versionData.Data.CorrelationId) & Builders <MongoDbSslData <T> > .Filter.Eq(_ => _.Version, currentVersion); versionData.Version += 1; var result = collection.ReplaceOne(filter, versionData); if (result.IsAcknowledged && result.ModifiedCount == 0) { throw new ArgumentException(string.Format("Possible Concurrency Error. ProcessManagerData with CorrelationId {0} and Version {1} could not be updated.", versionData.Data.CorrelationId, versionData.Version)); } }
/// <summary> /// Removes existing instance of ProcessManager from the database. /// </summary> /// <param name="persistanceData"></param> public void DeleteData <T>(IPersistanceData <T> persistanceData) where T : class, IProcessManagerData { var collectionName = GetCollectionName(persistanceData.Data); MongoCollection collection = _mongoDatabase.GetCollection(collectionName); collection.Remove(Query.EQ("Data.CorrelationId", persistanceData.Data.CorrelationId)); }
public void DeleteData <T>(IPersistanceData <T> persistanceData) where T : class, IProcessManagerData { lock (_memoryCacheLock) { string key = persistanceData.Data.CorrelationId.ToString(); //Cache.Remove(key); _provider.Remove(key); } }
public void Create(IPersistanceData entityToCreate) { using (var connection = new SqlConnectionWithExceptionLogger(this._loggingService, this._connectionStringValue)) { connection.Open(); connection.TryExecute(() => { CreateStateData(connection, entityToCreate); }); } }
public void Store(IPersistanceData data) { var key = new StateKey { PersistanceDataId = data.PersistanceDataId, Data = data.SomeData }; this._storage.AddOrUpdate(key, data, (k, oldData) => { return(data); }); }
/// <summary> /// Removes existing instance of ProcessManager from the database. /// </summary> /// <param name="persistanceData"></param> public void DeleteData <T>(IPersistanceData <T> persistanceData) where T : class, IProcessManagerData { var collectionName = GetCollectionName(persistanceData.Data); IMongoCollection <IPersistanceData <T> > collection = _mongoDatabase.GetCollection <IPersistanceData <T> >(collectionName); var indexOptions = new CreateIndexOptions(); var indexKeys = Builders <IPersistanceData <T> > .IndexKeys.Ascending("Data.CorrelationId"); var indexModel = new CreateIndexModel <IPersistanceData <T> >(indexKeys, indexOptions); collection.Indexes.CreateOne(indexModel); var filter = Builders <IPersistanceData <T> > .Filter.Eq("Data.CorrelationId", persistanceData.Data.CorrelationId); collection.DeleteOne(filter); }
/// <summary> /// Update data of existing ProcessManager and completes transaction opened by FindData(). /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> public void UpdateData <T>(IPersistanceData <T> data) where T : class, IProcessManagerData { string tableName = GetTableName(data.Data); var sqlServerData = (SqlServerData <T>)data; int currentVersion = sqlServerData.Version; var xmlSerializer = new XmlSerializer(data.Data.GetType()); var sww = new StringWriter(); XmlWriter writer = XmlWriter.Create(sww); xmlSerializer.Serialize(writer, data.Data); var dataXml = sww.ToString(); string sql = string.Format(@"UPDATE {0} SET DataXml = @DataXml, Version = @NewVersion WHERE Id = @Id AND Version = @CurrentVersion", tableName); int result; using (var sqlConnection = new SqlConnection(_connectionString)) { sqlConnection.Open(); using (var command = new SqlCommand(sql)) { command.Connection = sqlConnection; command.CommandTimeout = _commandTimeout; command.Parameters.Add("@Id", SqlDbType.UniqueIdentifier).Value = sqlServerData.Id; command.Parameters.Add("@DataXml", SqlDbType.Xml).Value = dataXml; command.Parameters.Add("@CurrentVersion", SqlDbType.Int).Value = currentVersion; command.Parameters.Add("@NewVersion", SqlDbType.Int).Value = ++currentVersion; try { result = command.ExecuteNonQuery(); } finally { sqlConnection.Close(); } } } if (result == 0) { throw new ArgumentException(string.Format("Possible Concurrency Error. ProcessManagerData with CorrelationId {0} and Version {1} could not be updated.", sqlServerData.Data.CorrelationId, sqlServerData.Version)); } }
public IPersistanceData Update(IPersistanceData entityToUpdate) { using (var connection = new SqlConnectionWithExceptionLogger(this._loggingService, this._connectionStringValue)) { connection.Open(); if (entityToUpdate.PersistanceDataId == 0) { CreateStateData(connection, entityToUpdate); } else { UpdateStateData(connection, entityToUpdate); } } // Get from DB ? nein..ev. neue werte sind nur IDs aus output, somit alles da.. return(entityToUpdate); }
public void UpdateData <T>(IPersistanceData <T> data) where T : class, IProcessManagerData { lock (_memoryCacheLock) { string error = null; var newData = (MemoryData <T>)data; string key = data.Data.CorrelationId.ToString(); //if (Cache.Contains(key)) if (_provider.Contains(key)) { //var currentVersion = ((MemoryData<T>)(Cache.Get(key))).Version; var currentVersion = ((MemoryData <T>)(_provider.Get <string, object>(key))).Version; var updatedData = new MemoryData <T> { Data = data.Data, Version = newData.Version + 1 }; if (currentVersion == newData.Version) { //Cache.Set(key, updatedData, _policy); _provider.Remove(key); _provider.Add(key, updatedData, _absoluteExpiry); } else { error = string.Format("Possible Concurrency Error. ProcessManagerData with CorrelationId {0} and Version {1} could not be updated.", key, currentVersion); } } else { error = string.Format("ProcessManagerData with CorrelationId {0} does not exist in memory.", key); } if (!string.IsNullOrEmpty(error)) { throw new ArgumentException(error); } } }
/// <summary> /// Update data of existing ProcessManager. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="persistanceData"></param> public void UpdateData <T>(IPersistanceData <T> persistanceData) where T : class, IProcessManagerData { var collectionName = GetCollectionName(persistanceData.Data); MongoCollection <T> collection = _mongoDatabase.GetCollection <T>(collectionName); collection.CreateIndex("CorrelationId"); var versionData = (MongoDbData <T>)persistanceData; int currentVersion = versionData.Version; var query = Query.And(Query.EQ("Data.CorrelationId", versionData.Data.CorrelationId), Query.EQ("Version", currentVersion)); versionData.Version += 1; var result = collection.FindAndModify(query, SortBy.Null, Update.Replace(versionData)); if (result.ModifiedDocument == null) { throw new ArgumentException(string.Format("Possible Concurrency Error. ProcessManagerData with CorrelationId {0} and Version {1} could not be updated.", versionData.Data.CorrelationId, versionData.Version)); } }
public void ShouldPersistNewProcessManagerWhenPersistanceDataDoesNotYetExist() { // Arrange _mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler <FakeMessage1>), typeof(IAsyncMessageHandler <FakeMessage1>))).Returns(new List <HandlerReference> { new HandlerReference { HandlerType = typeof(FakeProcessManager1), MessageType = typeof(FakeMessage1) } }); _mockContainer.Setup(x => x.GetHandlerTypes(typeof(IStartProcessManager <FakeMessage1>), typeof(IStartAsyncProcessManager <FakeMessage1>))).Returns(new List <HandlerReference> { new HandlerReference { HandlerType = typeof(FakeProcessManager1), MessageType = typeof(FakeMessage1) } }); var processManager = new FakeProcessManager1(); _mockContainer.Setup(x => x.GetInstance(typeof(FakeProcessManager1))).Returns(processManager); IPersistanceData <FakeProcessManagerData> nullPersistanceData = null; _mockProcessManagerFinder.Setup(x => x.FindData <FakeProcessManagerData>(It.IsAny <IProcessManagerPropertyMapper>(), It.IsAny <Message>())).Returns(nullPersistanceData); var processManagerProcessor = new ProcessManagerProcessor(_mockProcessManagerFinder.Object, _mockContainer.Object, _mockLogger.Object); // Act processManagerProcessor.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(new FakeMessage1(Guid.NewGuid()) { Username = "******" }), new ConsumeContext()).GetAwaiter().GetResult(); // Assert _mockProcessManagerFinder.Verify(x => x.InsertData(It.Is <FakeProcessManagerData>(y => y.User == "Tim Watson")), Times.Once); }
public void Store(IPersistanceData data) { this._persistanceService.Update(data); }
public void DeleteData <T>(IPersistanceData <T> data) where T : class, IProcessManagerData { Finder.DeleteData(data); }
public void UpdateData <T>(IPersistanceData <T> data) where T : class, IProcessManagerData { }
private static void UpdateStateData(SqlConnectionWithExceptionLogger connection, IPersistanceData entityToUpdate) { connection.TryExecute(() => { using (var command = connection.CreateCommand()) { command.CommandType = CommandType.StoredProcedure; command.CommandText = "[dbo].[usp_UpdateData]"; command.Parameters.AddWithValue("@PersistanceProcessId", entityToUpdate.PersistanceDataId); command.ExecuteNonQuery(); } }); }
private static void CreateStateData(SqlConnectionWithExceptionLogger connection, IPersistanceData entityToCreate) { connection.TryExecute(() => { using (var command = connection.CreateCommand()) { command.CommandType = CommandType.StoredProcedure; command.CommandText = "[dbo].[usp_InsertData]"; command.Parameters.AddWithValue("@Data", entityToCreate.SomeData); var outPutParameter = new SqlParameter { ParameterName = "@PersistanceDataId", SqlDbType = SqlDbType.BigInt, Direction = ParameterDirection.Output }; command.Parameters.Add(outPutParameter); command.ExecuteNonQuery(); entityToCreate.PersistanceDataId = (long)outPutParameter.Value; } }); }