public async Task UpdateState(ITransactionStateEntity <TState> state)
{
await EnsureInsertBufferFlushed();
await _dbExecuter.ExecuteQuery(async db =>
{
var(stateValue, transactionManager) = GetSerializables(state);
var rowsUpdated = await db.Query(_stateTableName)
.Where("state_id", _stateId)
.Where("sequence_id", state.SequenceId)
.AsUpdate(new[] { "transaction_manager", "value", "timestamp", "transaction_id" },
new object[]
{
transactionManager,
stateValue,
state.Timestamp,
state.TransactionId
})
.FirstOrDefaultAsync <int>().ConfigureAwait(false);
if (rowsUpdated != 1)
{
throw new InvalidOperationException("Something went wrong while persisting existing state");
}
});
}
protected override Task <ITransactionStateEntity <TState> > PersistState(
PendingTransactionState <TState> pendingState,
long?commitUpTo,
ITransactionStateEntity <TState> existingState = null) => ExecuteQuery <ITransactionStateEntity <TState> >(
async db =>
{
var transactionManager =
JsonConvert.SerializeObject(pendingState.TransactionManager, _jsonSettings);
var stateValue = pendingState.State != null
? JsonConvert.SerializeObject(pendingState.State, _jsonSettings)
: null;
if (existingState == null)
{
await db.Query(_options.StateTableName).AsInsert(new[]
{
"state_id", "sequence_id", "transaction_manager", "value", "timestamp", "transaction_id"
},
new object[]
{
_stateId,
pendingState.SequenceId,
transactionManager,
stateValue,
pendingState.TimeStamp,
pendingState.TransactionId
}).FirstOrDefaultAsync();
}
else
{
var rowsUpdated = await db.Query(_options.StateTableName)
.Where("state_id", _stateId)
.Where("sequence_id", existingState.SequenceId)
.AsUpdate(new[] { "transaction_manager", "value", "timestamp", "transaction_id", "state_type" },
new object[]
{
transactionManager,
stateValue,
pendingState.TimeStamp,
pendingState.TransactionId
}).FirstOrDefaultAsync <int>();
if (rowsUpdated != 1)
{
throw new InvalidOperationException("Something went wrong while persisting existing state");
}
}
return(new TransactionalState
{
Value = pendingState.State,
SequenceId = pendingState.SequenceId,
TransactionId = pendingState.TransactionId,
TransactionManager = pendingState.TransactionManager,
Timestamp = pendingState.TimeStamp
});
});
public async Task InsertState(ITransactionStateEntity <TState> state)
{
_insertStateBuffer.Add(state);
if (_insertStateBuffer.Count <= 1000)
{
return;
}
await EnsureInsertBufferFlushed();
}
private (string StateValue, string TransactionManager) GetSerializables(
ITransactionStateEntity <TState> state)
{
var transactionManager =
JsonConvert.SerializeObject(state.TransactionManager, _jsonSettings);
var stateValue = state.Value != null
? JsonConvert.SerializeObject(state.Value, _jsonSettings)
: null;
return(stateValue, transactionManager);
}
private object[] CreatePropertyBagForInsert(ITransactionStateEntity <TState> state)
{
var(stateValue, transactionManager) = GetSerializables(state);
return(new object[]
{
_stateId,
state.SequenceId,
transactionManager,
stateValue,
state.Timestamp,
state.TransactionId
});
}
protected override Task RemoveAbortedState(ITransactionStateEntity <TState> state)
=> ExecuteQuery(async db =>
{
var rowsDeleted = await db.Query(_options.StateTableName)
.Where("state_id", _stateId)
.Where("sequence_id", state.SequenceId)
.DeleteAsync().ConfigureAwait(false);
Console.WriteLine(rowsDeleted);
if (rowsDeleted != 1)
{
throw new InvalidOperationException("Something went wrong when trying to delete transaction state");
}
});
public async Task <string> Store(string expectedETag, TransactionalStateMetaData metadata,
List <PendingTransactionState <TState> > statesToPrepare, long?commitUpTo,
long?abortAfter)
{
if (abortAfter.HasValue && _states.Any())
{
while (_states.Count > 0 && _states[_states.Count - 1].SequenceId > abortAfter)
{
var entity = _states[_states.Count - 1];
await RemoveAbortedState(entity).ConfigureAwait(false);
_states.RemoveAt(_states.Count - 1);
}
}
if (statesToPrepare != null)
{
foreach (var s in statesToPrepare)
{
ITransactionStateEntity <TState> existingState = null;
if (FindState(s.SequenceId, out var pos))
{
existingState = _states[pos];
}
var persistedState = await PersistState(s, commitUpTo, existingState).ConfigureAwait(false);
if (existingState == null)
{
_states.Insert(pos, persistedState);
}
else
{
_states[pos] = persistedState;
}
}
}
Metadata = await PersistMetadata(metadata, commitUpTo ?? Metadata.CommittedSequenceId)
.ConfigureAwait(false);
await StoreFinalize(commitUpTo).ConfigureAwait(false);
return(Metadata.ETag);
}
protected abstract Task RemoveAbortedState(ITransactionStateEntity <TState> state);
protected abstract Task <ITransactionStateEntity <TState> > PersistState(PendingTransactionState <TState> pendingState,
long?commitUpTo,
ITransactionStateEntity <TState> existingState = null);
