public virtual async Task AbortTransactionExceptionInnerExceptionOnlyContainsOneRootCauseException(string grainStates)
{
const int throwGrainCount = 3;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions - throwGrainCount;
const int expected = 5;
List <ITransactionTestGrain> throwGrains = Enumerable.Range(0, throwGrainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainSet(throwGrains, expected);
await coordinator.MultiGrainSet(grains, expected);
async Task InnerExceptionCheck()
{
try
{
await coordinator.MultiGrainAddAndThrow(throwGrains, grains, expected);
}
catch (Exception e)
{
e.InnerException.Should().BeOfType <AddAndThrowException>();
throw;
}
}
Func <Task> task = () => InnerExceptionCheck();
task.ShouldThrow <OrleansTransactionAbortedException>();
grains.AddRange(throwGrains);
await TestAfterDustSettles(async() =>
{
foreach (var grain in grains)
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
actual.ShouldBeEquivalentTo(expected);
}
}
});
}
public async Task AbortTransactionExceptionInnerExceptionOnlyContainsOneRootCauseException(string grainStates)
{
const int throwGrainCount = 3;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions - throwGrainCount;
const int expected = 5;
List <ITransactionTestGrain> throwGrains = Enumerable.Range(0, throwGrainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(grainStates))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainSet(throwGrains, expected);
await coordinator.MultiGrainSet(grains, expected);
async Task InnerExceptionCheck()
{
try
{
await coordinator.MultiGrainAddAndThrow(throwGrains, grains, expected);
}
catch (Exception e)
{
Assert.True(e.InnerException is AddAndThrowException);
throw e;
}
}
await Assert.ThrowsAsync <OrleansTransactionAbortedException>(() => InnerExceptionCheck());
grains.AddRange(throwGrains);
await TestAfterDustSettles(async() =>
{
foreach (var grain in grains)
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
Assert.Equal(expected, actual);
}
}
});
}
public async Task MultiGrainAbortTransactionOnExceptions(string 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(string 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);
}
}
}
public virtual async Task MultiGrainReadWriteTransaction(string grainStates, int grainCount)
{
const int delta = 5;
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.testOutput($"{grain} - failed");
}
actual.ShouldBeEquivalentTo(expected);
}
}
}
public virtual async Task RepeatGrainReadWriteTransaction(string transactionTestGrainClassName)
{
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(transactionTestGrainClassName, 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 actual = await grain.Get();
if (expected != actual)
{
this.output.WriteLine($"{grain} - failed");
}
Assert.Equal(expected, actual);
}
}
}
public virtual async Task MultiGrainReadWriteTransaction(string transactionTestGrainClassName)
{
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(transactionTestGrainClassName, id))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
await coordinator.MultiGrainSet(grains, delta);
await coordinator.MultiGrainDouble(grains);
foreach (var grain in grains)
{
await grain.Get();
}
foreach (var grainId in grainIds)
{
await CheckReport(grainId, 3, 0, 3);
}
}
public virtual async Task MultiGrainReadWriteTransaction(string transactionTestGrainClassName)
{
const int delta = 5;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions;
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(transactionTestGrainClassName))
.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 actual = await grain.Get();
Assert.Equal(expected, actual);
}
}
public virtual void MultiTransactionGrainsThrowWhenTransactions(string transactionTestGrainClassName)
{
const int delta = 5;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions;
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(transactionTestGrainClassName))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
Func <Task> task = () => coordinator.MultiGrainSet(grains, delta);
var response = task.ShouldThrow <OrleansTransactionsDisabledException>();
}
public async Task AbortTransactionOnExceptions(string transactionTestGrainClassName)
{
const int expected = 5;
ITransactionTestGrain grain = RandomTestGrain(transactionTestGrainClassName);
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 actual = await grain.Get();
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 AbortTransactionOnExceptions(string 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);
Func <Task> task = () => coordinator.AddAndThrow(grain, expected);
await task.Should().ThrowAsync <OrleansTransactionAbortedException>();
await TestAfterDustSettles(async() =>
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
actual.Should().Be(expected);
}
});
}
public virtual async Task RepeatGrainReadWriteTransaction(string grainStates, int grainCount)
{
const int repeat = 10;
const int delta = 5;
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.testOutput($"{grain} - failed");
}
actual.ShouldBeEquivalentTo(expected);
}
}
}
}
public virtual async Task MultiGrainAbortTransactionOnExceptions(string 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);
Func <Task> task = () => coordinator.MultiGrainAddAndThrow(new List <ITransactionTestGrain>()
{
throwGrain
}, grains, expected);
task.ShouldThrow <OrleansTransactionAbortedException>();
grains.Add(throwGrain);
await TestAfterDustSettles(async() =>
{
foreach (var grain in grains)
{
int[] actualValues = await grain.Get();
foreach (var actual in actualValues)
{
actual.ShouldBeEquivalentTo(expected);
}
}
});
}
public virtual async Task MultiTransactionGrainsThrowWhenTransactions(string transactionTestGrainClassName)
{
const int delta = 5;
const int grainCount = TransactionTestConstants.MaxCoordinatedTransactions;
List <ITransactionTestGrain> grains =
Enumerable.Range(0, grainCount)
.Select(i => RandomTestGrain(transactionTestGrainClassName))
.ToList();
ITransactionCoordinatorGrain coordinator = this.grainFactory.GetGrain <ITransactionCoordinatorGrain>(Guid.NewGuid());
OrleansStartTransactionFailedException exception = await Assert.ThrowsAsync <OrleansStartTransactionFailedException>(() => coordinator.MultiGrainSet(grains, delta));
Assert.IsAssignableFrom <OrleansTransactionsDisabledException>(exception.InnerException);
}
