public void Prepare(long sequenceNumber, Guid transactionId, DateTime timestamp,
ITransactionParticipant transactionManager, TState state)
{
prepare++;
total++;
if (MetaData.TimeStamp < timestamp)
{
MetaData.TimeStamp = timestamp;
}
if (prepares == null)
{
prepares = new SortedDictionary <long, PendingTransactionState <TState> >();
}
var tmstring = (transactionManager == null) ? null :
JsonConvert.SerializeObject(transactionManager, MetaData.SerializerSettings);
prepares[sequenceNumber] = new PendingTransactionState <TState>
{
SequenceId = sequenceNumber,
TransactionId = transactionId.ToString(),
TimeStamp = timestamp,
TransactionManager = tmstring,
State = state
};
if (cancelAbove < sequenceNumber)
{
cancelAbove = sequenceNumber;
}
}
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 static StateEntity Create <T>(JsonSerializerSettings JsonSettings,
string partitionKey, PendingTransactionState <T> pendingState)
where T : class, new()
{
return(new StateEntity
{
TransactionId = pendingState.TransactionId,
TransactionTimestamp = pendingState.TimeStamp,
TransactionManager = JsonConvert.SerializeObject(pendingState.TransactionManager, JsonSettings),
StateJson = JsonConvert.SerializeObject(pendingState.State, JsonSettings)
});
}
public static StateEntity Create <T>(JsonSerializerSettings JsonSettings,
string partitionKey, PendingTransactionState <T> pendingState)
where T : class, new()
{
return(new StateEntity
{
PartitionKey = partitionKey,
RowKey = MakeRowKey(pendingState.TransactionId, pendingState.SequenceId),
TransactionId = pendingState.TransactionId,
SequenceId = pendingState.SequenceId,
StateJson = JsonConvert.SerializeObject(pendingState.State, JsonSettings)
});
}
private PendingTransactionState <TState> MakePendingState(long seqno, TState val, bool tm)
{
var result = new PendingTransactionState <TState>()
{
SequenceId = seqno,
TimeStamp = DateTime.UtcNow,
TransactionId = Guid.NewGuid().ToString(),
TransactionManager = tm ? default(ParticipantId) : MakeParticipantId(),
State = new TState()
};
result.State = val;
return(result);
}
public async Task <string> Confirm(string expectedETag, string metadata, string transactionIdToCommit)
{
if (this.StateStorage.Etag != expectedETag)
{
throw new ArgumentException(nameof(expectedETag), "Etag does not match");
}
this.StateStorage.State.Metadata = metadata;
PendingTransactionState <TState> committedState = this.StateStorage.State.PendingStates.FirstOrDefault(pending => transactionIdToCommit == pending.TransactionId);
if (committedState != null)
{
this.StateStorage.State.CommittedTransactionId = committedState.TransactionId;
this.StateStorage.State.CommittedState = committedState.State;
this.StateStorage.State.PendingStates = StateStorage.State.PendingStates.Where(pending => pending.SequenceId > committedState.SequenceId).ToList();
}
await this.StateStorage.WriteStateAsync();
return(this.StateStorage.Etag);
}
protected abstract Task <ITransactionStateEntity <TState> > PersistState(PendingTransactionState <TState> pendingState,
long?commitUpTo,
ITransactionStateEntity <TState> existingState = null);
