private string GetTestGrainClassName(TransactionTestConstants.TransactionGrainStates grainStates)
{
if (this.distributedTm)
{
if (grainStates == TransactionTestConstants.TransactionGrainStates.SingleStateTransaction)
{
return(TransactionTestConstants.SingleStateTransactionalGrainDistributedTM);
}
if (grainStates == TransactionTestConstants.TransactionGrainStates.DoubleStateTransaction)
{
return(TransactionTestConstants.DoubleStateTransactionalGrainDistributedTM);
}
if (grainStates == TransactionTestConstants.TransactionGrainStates.MaxStateTransaction)
{
return(TransactionTestConstants.MaxStateTransactionalGrainDistributedTM);
}
throw new SkipException($"{grainStates} not supported when using distributed transaction manager.");
}
if (grainStates == TransactionTestConstants.TransactionGrainStates.SingleStateTransaction)
{
return(TransactionTestConstants.SingleStateTransactionalGrain);
}
if (grainStates == TransactionTestConstants.TransactionGrainStates.DoubleStateTransaction)
{
return(TransactionTestConstants.DoubleStateTransactionalGrain);
}
if (grainStates == TransactionTestConstants.TransactionGrainStates.MaxStateTransaction)
{
return(TransactionTestConstants.MaxStateTransactionalGrain);
}
throw new SkipException($"{grainStates} not supported when using distributed transaction manager.");
}
public async Task MultiGrainAbortTransactionOnExceptions(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions - 1;
const int expected = 5;
ITransactionTestGrain throwGrain = RandomTestGrain(grainStates);
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await throwGrain.Set(expected);
await coordinator.MultiGrainSet(grains, expected);
await Assert.ThrowsAsync <OrleansTransactionAbortedException>(() => coordinator.MultiGrainAddAndThrow(throwGrain, grains, expected));
grains.Add(throwGrain);
await TestAfterDustSettles(async() =>
{
foreach (var grain in grains)
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
Assert.Equal(expected, actual);
}
}
});
}
public virtual async Task MultiGrainReadWriteTransaction(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int delta = 5;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions;
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainSet(grains, delta);
await coordinator.MultiGrainDouble(grains);
int expected = delta + delta;
foreach (var grain in grains)
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
if (expected != actual)
{
this.output.WriteLine($"{grain} - failed");
}
Assert.Equal(expected, actual);
}
}
}
//For distributedTM
public virtual async Task TransactionWillRecoverAfterRandomSiloFailure(TransactionTestConstants.TransactionGrainStates transactionTestGrainClassName)
{
const int grainCount = 100;
var txGrains = Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(transactionTestGrainClassName))
.ToList();
var txSucceedBeforeInterruption = await AllTxSucceed(txGrains);
this.logger.LogInformation($"Tx succeed before interruption : {txSucceedBeforeInterruption}");
//randomly ungraceful shut down one silo
this.testCluster.KillSilo(this.testCluster.Silos[this.seed.Next(this.testCluster.Silos.Count)]);
await TestingUtils.WaitUntilAsync(lastTry => CheckTxResult(txGrains, lastTry), RecoveryTimeout);
}
public virtual async Task SingleGrainWriteTransaction(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int delta = 5;
ITransactionTestGrain grain = RandomTestGrain(grainStates);
var original = await grain.Get();
await grain.Add(delta);
var expected = original.Select(value => value + delta).ToArray();
var actual = await grain.Get();
Assert.Equal(expected, actual);
}
public virtual async Task SingleGrainReadTransaction(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int expected = 0;
ITransactionTestGrain grain = RandomTestGrain(grainStates);
var actualResults = await grain.Get();
//each transaction state should all be 0 since no operation was applied yet
foreach (var actual in actualResults)
{
Assert.Equal(expected, actual);
}
}
public virtual async Task MultiWriteToSingleGrainTransaction(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int delta = 5;
const int concurrentWrites = 3;
ITransactionTestGrain grain = RandomTestGrain(grainStates);
List <ITransactionTestGrain> grains = Enumerable.Repeat(grain, concurrentWrites).ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainAdd(grains, delta);
int expected = delta * concurrentWrites;
int[] actualValues = await grains[0].Get();
foreach (var actual in actualValues)
{
Assert.Equal(expected, actual);
}
}
public async Task AbortTransactionOnOrphanCalls(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int expected = 5;
ITransactionTestGrain grain = RandomTestGrain(grainStates);
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await grain.Set(expected);
await Assert.ThrowsAsync <OrleansOrphanCallException>(() => coordinator.OrphanCallTransaction(grain));
//await Task.Delay(20000); // give time for GC
await TestAfterDustSettles(async() =>
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
Assert.Equal(expected, actual);
}
});
}
public async Task AbortTransactionOnExceptions(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int expected = 5;
ITransactionTestGrain grain = RandomTestGrain(grainStates);
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainSet(new List <ITransactionTestGrain> {
grain
}, expected);
await Assert.ThrowsAsync <OrleansTransactionAbortedException>(() => coordinator.AddAndThrow(grain, expected));
await TestAfterDustSettles(async() =>
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
Assert.Equal(expected, actual);
}
});
}
public virtual async Task RepeatGrainReadWriteTransaction(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int repeat = 10;
const int delta = 5;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions;
List <Guid> grainIds = Enumerable.Range(0, grainCount)
.Select(i => Guid.NewGuid())
.ToList();
List <ITransactionTestGrain> grains = grainIds
.Select(id => TestGrain(grainStates, id))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainSet(grains, delta);
for (int i = 0; i < repeat; i++)
{
await coordinator.MultiGrainDouble(grains);
int expected = delta * (int)Math.Pow(2, i + 1);
foreach (var grain in grains)
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
if (expected != actual)
{
this.output.WriteLine($"{grain} - failed");
}
Assert.Equal(expected, actual);
}
}
}
}
public virtual async Task MultiGrainWriteTransaction(TransactionTestConstants.TransactionGrainStates grainStates)
{
const int expected = 5;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions;
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainAdd(grains, expected);
foreach (var grain in grains)
{
var actualValues = await grain.Get();
foreach (var actual in actualValues)
{
Assert.Equal(expected, actual);
}
}
}
protected virtual ITransactionTestGrain TestGrain(TransactionTestConstants.TransactionGrainStates grainStates, Guid id)
{
return(TestGrain(GetTestGrainClassName(grainStates), id));
}
protected ITransactionTestGrain RandomTestGrain(TransactionTestConstants.TransactionGrainStates grainStates)
{
return(TestGrain(grainStates, Guid.NewGuid()));
}
public Task TransactionWillRecoverAfterRandomSiloFailure(TransactionTestConstants.TransactionGrainStates transactionGrainStates)
{
return(this.testRunner.TransactionWillRecoverAfterRandomSiloFailure(transactionGrainStates));
}
