public CommitResults Store(CommitsForStorage commits)
{
try
{
return doStore(commits);
}
catch (Exception e)
{
throw new EventStorageException(e);
}
}
public CommitResults Store(CommitsForStorage commits)
{
var unSuccessful = new List<Guid>();
var commitsToSave = commits.Commits.Where(x => x.Events.Length > 0);
var entries = commitsToSave.OrderBy(x => x.Events.Min(y => y.Timestamp));
foreach (var commit in entries)
{
var expectedVersion = getExpectedVersion(commit);
var versionForCommit = commit.Events.Length > 0 ? commit.Events.Min(x => x.Sequence) : 0;
if (expectedVersion != versionForCommit && versionForCommit != ExpectedVersion.Any)
{
unSuccessful.Add(commit.CommitId);
continue;
}
for (int index = 0; index < commit.Events.Length; index++)
{
var e = commit.Events[index];
var version = e.Sequence == -1 ? expectedVersion + index : e.Sequence;
_globalSequence++;
_events.Add(new EventInStorage(e.EventId, commit.Context, commit.Stream,
version,
_globalSequence,
e.Timestamp,
e.TypeKey, e.Headers, e.Body));
}
}
var successful = commits.Commits.Where(x => unSuccessful.Contains(x.CommitId) == false).Select(x => x.CommitId).ToArray();
++WriteCount;
return new CommitResults(successful.ToArray(), unSuccessful.ToArray());
}
private void store(Entry[] entries)
{
Logger.Debug("[StorageWriter] Writing entries.");
var commits = entries.ToDictionary(x => x.Commit.CommitId, x => x);
var commit = new CommitsForStorage(commits.Values.Select(x => x.Commit).ToArray());
try
{
Logger.Debug("[StorageWriter] Storing {0} commits.", commit.Commits.Length);
var results = _storage.Store(commit);
Logger.Debug("[StorageWriter] Entries stored.");
//these can't fail as they're try operations.
foreach (var c in results.SuccessfulCommits)
commits[c].signalCompletion();
foreach (var c in results.FailedDueToConcurrencyCommits)
commits[c].signalConcurrencyFailure();
}
catch (Exception e)
{
foreach (var entry in entries)
entry.Fail(e);
}
finally
{
commits.Clear();
}
}
private string storeEvent(string context, string typeKey, string body, string stream)
{
var @event = new EventForStorage(Guid.NewGuid(), 1, DateTime.UtcNow, typeKey, null, body);
var commit = new CommitForStorage(Guid.NewGuid(), context, stream, @event);
var commits = new CommitsForStorage(commit);
_storage.Store(commits);
return stream;
}
private void addCommitsToTable(CommitsForStorage commits, DataTable table)
{
foreach (var commit in commits.Commits)
for (int index = 0; index < commit.Events.Length; index++)
{
var e = commit.Events[index];
table.Rows.Add(e.EventId, commit.Stream, commit.Context, e.Sequence, index + 1, e.Timestamp, e.TypeKey, e.Headers, e.Body,
commit.CommitId);
}
}
private SqlParameter getEventsParameter(CommitsForStorage commits)
{
var eventsTable = getEmptyEventsTable();
addCommitsToTable(commits, eventsTable);
var parameter = new SqlParameter("Events", SqlDbType.Structured);
parameter.Value = eventsTable;
parameter.TypeName = "EventParameter";
return parameter;
}
private CommitResults doStore(CommitsForStorage commits)
{
var eventsParameter = getEventsParameter(commits);
using (var connection = new SqlConnection(_connectionString))
using (var command = new SqlCommand("AppendEvents", connection))
{
var unsuccessful = new List<Guid>();
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(eventsParameter);
try
{
Log.Debug("[SqlEventStorage] Opening connection.");
command.Connection.Open();
Log.Debug("[SqlEventStorage] Executing sproc to write events.");
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
unsuccessful.Add(reader.GetGuid(0));
}
var unsuccessfulCommits = unsuccessful.ToArray();
var successfulCommits =
commits.
Commits.Where(x => unsuccessful.Contains(x.CommitId) == false)
.Select(x => x.CommitId).ToArray();
return new CommitResults(successfulCommits, unsuccessfulCommits);
}
}
catch (Exception e)
{
Log.Warn("[SqlEventStorage] Error during event storage.", e);
throw;
}
}
}
