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