protected async Task <bool> PerGrainFailureTest(IReminderTestGrain2 grain)
{
TimeSpan period = await grain.GetReminderPeriod(DR);
this.log.Info("PerGrainFailureTest Period={0} Grain={1}", period, grain);
await grain.StartReminder(DR);
TimeSpan sleepFor = period.Multiply(failCheckAfter) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long last = await grain.GetCounter(DR);
AssertIsInRange(last, failCheckAfter - 1, failCheckAfter + 1, grain, DR, sleepFor);
await grain.StopReminder(DR);
sleepFor = period.Multiply(2) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long curr = await grain.GetCounter(DR);
AssertIsInRange(curr, last, last + 1, grain, DR, sleepFor);
return(true);
}
public async Task Test_Reminders_1J_MultiGrainMultiReminders()
{
IReminderTestGrain2 g1 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g3 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g4 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g5 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task <bool>[] tasks =
{
Task.Run(() => this.PerGrainMultiReminderTestChurn(g1)),
Task.Run(() => this.PerGrainMultiReminderTestChurn(g2)),
Task.Run(() => this.PerGrainMultiReminderTestChurn(g3)),
Task.Run(() => this.PerGrainMultiReminderTestChurn(g4)),
Task.Run(() => this.PerGrainMultiReminderTestChurn(g5)),
};
Thread.Sleep(period.Multiply(5));
// start another silo ... although it will take it a while before it stabilizes
log.Info("Starting another silo");
await this.HostedCluster.StartAdditionalSilosAsync(1, true);
//Block until all tasks complete.
await Task.WhenAll(tasks).WithTimeout(ENDWAIT);
}
public async Task Rem_Azure_Basic_Restart()
{
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await grain.GetReminderPeriod(DR);
await grain.StartReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
long last = await grain.GetCounter(DR);
Assert.Equal(2, last);
await grain.StopReminder(DR);
TimeSpan sleepFor = period.Multiply(1) + LEEWAY;
Thread.Sleep(sleepFor); // giving some leeway
long curr = await grain.GetCounter(DR);
Assert.Equal(last, curr);
AssertIsInRange(curr, last, last + 1, grain, DR, sleepFor);
// start the same reminder again
await grain.StartReminder(DR);
sleepFor = period.Multiply(2) + LEEWAY;
Thread.Sleep(sleepFor); // giving some leeway
curr = await grain.GetCounter(DR);
AssertIsInRange(curr, 2, 3, grain, DR, sleepFor);
await grain.StopReminder(DR); // cleanup
}
public async Task Rem_Azure_Basic()
{
log.Info(TestContext.TestName);
// start up a test grain and get the period that it's programmed to use.
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await grain.GetReminderPeriod(DR);
// start up the 'DR' reminder and wait for two ticks to pass.
await grain.StartReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
// retrieve the value of the counter-- it should match the sequence number which is the number of periods
// we've waited.
long last = await grain.GetCounter(DR);
Assert.AreEqual(2, last, Time());
// stop the timer and wait for a whole period.
await grain.StopReminder(DR);
Thread.Sleep(period.Multiply(1) + LEEWAY); // giving some leeway
// the counter should not have changed.
long curr = await grain.GetCounter(DR);
Assert.AreEqual(last, curr, Time());
}
public async Task Rem_Azure_GT_Basic()
{
log.Info(TestContext.TestName);
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestCopyGrain g2 = GrainClient.GrainFactory.GetGrain <IReminderTestCopyGrain>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR); // using same period
await g1.StartReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
await g2.StartReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
long last1 = await g1.GetCounter(DR);
Assert.AreEqual(4, last1, string.Format("{0} Grain fault", Time()));
long last2 = await g2.GetCounter(DR);
Assert.AreEqual(2, last2, string.Format("{0} CopyGrain fault", Time()));
await g1.StopReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
await g2.StopReminder(DR);
long curr1 = await g1.GetCounter(DR);
Assert.AreEqual(last1, curr1, string.Format("{0} Grain fault", Time()));
long curr2 = await g2.GetCounter(DR);
Assert.AreEqual(4, curr2, string.Format("{0} CopyGrain fault", Time()));
}
public async Task Rem_Azure_MultipleReminders()
{
log.Info(TestContext.TestName);
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
await PerGrainMultiReminderTest(grain);
}
public async Task Rem_Azure_2F_MultiGrain()
{
List <SiloHandle> silos = this.HostedCluster.StartAdditionalSilos(2);
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g3 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g4 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g5 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task[] tasks =
{
Task.Run(() => PerGrainFailureTest(g1)),
Task.Run(() => PerGrainFailureTest(g2)),
Task.Run(() => PerGrainFailureTest(g3)),
Task.Run(() => PerGrainFailureTest(g4)),
Task.Run(() => PerGrainFailureTest(g5)),
};
Thread.Sleep(period.Multiply(failAfter));
// stop a couple of silos
log.Info("Stopping 2 silos");
int i = random.Next(silos.Count);
this.HostedCluster.StopSilo(silos[i]);
silos.RemoveAt(i);
this.HostedCluster.StopSilo(silos[random.Next(silos.Count)]);
await Task.WhenAll(tasks).WithTimeout(ENDWAIT); // Block until all tasks complete.
}
public async Task Rem_Azure_GT_Basic()
{
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestCopyGrain g2 = GrainClient.GrainFactory.GetGrain <IReminderTestCopyGrain>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR); // using same period
await g1.StartReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
await g2.StartReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
long last1 = await g1.GetCounter(DR);
Assert.Equal(4, last1);
long last2 = await g2.GetCounter(DR);
Assert.Equal(2, last2); // CopyGrain fault
await g1.StopReminder(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
await g2.StopReminder(DR);
long curr1 = await g1.GetCounter(DR);
Assert.Equal(last1, curr1);
long curr2 = await g2.GetCounter(DR);
Assert.Equal(4, curr2); // CopyGrain fault
}
public async Task Rem_Azure_GT_1F1J_MultiGrain()
{
List <SiloHandle> silos = await this.HostedCluster.StartAdditionalSilosAsync(1);
await this.HostedCluster.WaitForLivenessToStabilizeAsync();
IReminderTestGrain2 g1 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestCopyGrain g3 = this.GrainFactory.GetGrain <IReminderTestCopyGrain>(Guid.NewGuid());
IReminderTestCopyGrain g4 = this.GrainFactory.GetGrain <IReminderTestCopyGrain>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task[] tasks =
{
Task.Run(() => PerGrainFailureTest(g1)),
Task.Run(() => PerGrainFailureTest(g2)),
Task.Run(() => PerCopyGrainFailureTest(g3)),
Task.Run(() => PerCopyGrainFailureTest(g4)),
};
Thread.Sleep(period.Multiply(failAfter));
var siloToKill = silos[random.Next(silos.Count)];
// stop a silo and join a new one in parallel
log.Info("Stopping a silo and joining a silo");
Task t1 = Task.Run(async() => await this.HostedCluster.StopSiloAsync(siloToKill));
Task t2 = Task.Run(async() => await this.HostedCluster.StartAdditionalSilosAsync(1));
await Task.WhenAll(new[] { t1, t2 }).WithTimeout(ENDWAIT);
await Task.WhenAll(tasks).WithTimeout(ENDWAIT); // Block until all tasks complete.
}
public async Task Rem_Azure_2J_MultiGrainMultiReminders()
{
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g3 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g4 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g5 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task <bool>[] tasks =
{
Task.Run(() => PerGrainMultiReminderTestChurn(g1)),
Task.Run(() => PerGrainMultiReminderTestChurn(g2)),
Task.Run(() => PerGrainMultiReminderTestChurn(g3)),
Task.Run(() => PerGrainMultiReminderTestChurn(g4)),
Task.Run(() => PerGrainMultiReminderTestChurn(g5)),
};
await Task.Delay(period.Multiply(5));
// start two extra silos ... although it will take it a while before they stabilize
log.Info("Starting 2 extra silos");
this.HostedCluster.StartAdditionalSilos(2);
await this.HostedCluster.WaitForLivenessToStabilizeAsync();
//Block until all tasks complete.
await Task.WhenAll(tasks).WithTimeout(ENDWAIT);
}
public async Task Test_Reminders_1J_MultiGrainMultiReminders()
{
log.Info(TestContext.TestName);
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g3 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g4 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g5 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task <bool>[] tasks =
{
Task.Run(async() => { return(await PerGrainMultiReminderTestChurn(g1)); }),
Task.Run(async() => { return(await PerGrainMultiReminderTestChurn(g2)); }),
Task.Run(async() => { return(await PerGrainMultiReminderTestChurn(g3)); }),
Task.Run(async() => { return(await PerGrainMultiReminderTestChurn(g4)); }),
Task.Run(async() => { return(await PerGrainMultiReminderTestChurn(g5)); })
};
Thread.Sleep(period.Multiply(5));
// start another silo ... although it will take it a while before it stabilizes
log.Info("Starting another silo");
StartAdditionalSilos(1);
//Block until all tasks complete.
await Task.WhenAll(tasks).WithTimeout(ENDWAIT);
}
public async Task Rem_Grain_MultipleReminders()
{
//log.Info(TestContext.TestName);
IReminderTestGrain2 grain = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
await PerGrainMultiReminderTest(grain);
}
internal async Task <bool> PerGrainMultiReminderTestChurn(IReminderTestGrain2 g)
{
// for churn cases, we do execute start and stop reminders with retries as we don't have the queue-ing
// functionality implemented on the LocalReminderService yet
TimeSpan period = await g.GetReminderPeriod(DR);
logger.Info("PerGrainMultiReminderTestChurn Period={0} Grain={1}", period, g);
// Start Default Reminder
//g.StartReminder(DR, file + "_" + DR).Wait();
ExecuteWithRetries(g.StartReminder, DR);
TimeSpan sleepFor = period.Multiply(2);
Thread.Sleep(sleepFor);
// Start R1
//g.StartReminder(R1, file + "_" + R1).Wait();
ExecuteWithRetries(g.StartReminder, R1);
sleepFor = period.Multiply(2);
Thread.Sleep(sleepFor);
// Start R2
//g.StartReminder(R2, file + "_" + R2).Wait();
ExecuteWithRetries(g.StartReminder, R2);
sleepFor = period.Multiply(2);
Thread.Sleep(sleepFor);
sleepFor = period.Multiply(1);
Thread.Sleep(sleepFor);
// Stop R1
//g.StopReminder(R1).Wait();
ExecuteWithRetriesStop(g.StopReminder, R1);
sleepFor = period.Multiply(2);
Thread.Sleep(sleepFor);
// Stop R2
//g.StopReminder(R2).Wait();
ExecuteWithRetriesStop(g.StopReminder, R2);
sleepFor = period.Multiply(1);
Thread.Sleep(sleepFor);
// Stop Default reminder
//g.StopReminder(DR).Wait();
ExecuteWithRetriesStop(g.StopReminder, DR);
sleepFor = period.Multiply(1) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long last = await g.GetCounter(R1);
AssertIsInRange(last, 4, 6, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 4, 6, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 9, 10, g, DR, sleepFor);
return(true);
}
public async Task Test_Reminders_ReminderNotFound()
{
IReminderTestGrain2 g1 = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
// request a reminder that does not exist
IGrainReminder reminder = await g1.GetReminderObject("blarg");
Assert.Null(reminder);
}
public async Task Rem_Azure_RegisterSameReminderTwice()
{
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
Task <IGrainReminder> promise1 = grain.StartReminder(DR);
Task <IGrainReminder> promise2 = grain.StartReminder(DR);
Task <IGrainReminder>[] tasks = { promise1, promise2 };
await Task.WhenAll(tasks).WithTimeout(TimeSpan.FromSeconds(15));
//Assert.NotEqual(promise1.Result, promise2.Result);
// TODO: write tests where period of a reminder is changed
}
public async Task Test_Reminders_Basic_ListOps()
{
Guid id = Guid.NewGuid();
if (this.log != null)
{
log.Info("Start Grain Id = {0}", id);
}
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(id);
const int count = 5;
Task <IGrainReminder>[] startReminderTasks = new Task <IGrainReminder> [count];
for (int i = 0; i < count; i++)
{
startReminderTasks[i] = grain.StartReminder(DR + "_" + i);
}
await Task.WhenAll(startReminderTasks);
// do comparison on strings
List <string> registered = (from reminder in startReminderTasks select reminder.Result.ReminderName).ToList();
List <IGrainReminder> remindersList = await grain.GetRemindersList();
List <string> fetched = (from reminder in remindersList select reminder.ReminderName).ToList();
foreach (var remRegistered in registered)
{
Assert.IsTrue(fetched.Remove(remRegistered), $"Couldn't get reminder {remRegistered}. " +
$"Registered list: {Utils.EnumerableToString(registered)}, " +
$"fetched list: {Utils.EnumerableToString(remindersList, r => r.ReminderName)}");
}
Assert.IsTrue(fetched.Count == 0, $"More than registered reminders. Extra: {Utils.EnumerableToString(fetched)}");
// do some time tests as well
if (this.log != null)
{
log.Info("Time tests");
}
TimeSpan period = await grain.GetReminderPeriod(DR);
Thread.Sleep(period.Multiply(2) + LEEWAY); // giving some leeway
for (int i = 0; i < count; i++)
{
long curr = await grain.GetCounter(DR + "_" + i);
Assert.AreEqual(2, curr); // string.Format("Incorrect ticks for {0}_{1}", DR, i));
}
}
public async Task Rem_Azure_Wrong_LowerThanAllowedPeriod()
{
log.Info(TestContext.TestName);
try
{
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
await grain.StartReminder(DR, TimeSpan.FromMilliseconds(3000), true);
}
catch (Exception exc)
{
log.Info("Failed to register reminder: {0}", exc.Message);
throw exc.GetBaseException();
}
}
public async Task Rem_Azure_1F_Basic()
{
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task <bool> test = Task.Run(async() => { await PerGrainFailureTest(g1); return(true); });
Thread.Sleep(period.Multiply(failAfter));
// stop the secondary silo
log.Info("Stopping secondary silo");
this.HostedCluster.StopSilo(this.HostedCluster.Secondary);
await test; // Block until test completes.
}
public async Task Test_Reminders_Basic_ListOps()
{
Guid id = Guid.NewGuid();
log.LogInformation("Start Grain Id = {GrainId}", id);
IReminderTestGrain2 grain = this.GrainFactory.GetGrain <IReminderTestGrain2>(id);
const int count = 5;
Task <IGrainReminder>[] startReminderTasks = new Task <IGrainReminder> [count];
for (int i = 0; i < count; i++)
{
startReminderTasks[i] = grain.StartReminder(DR + "_" + i);
log.LogInformation("Started {ReminderName}_{ReminderNumber}", DR, i);
}
await Task.WhenAll(startReminderTasks);
// do comparison on strings
List <string> registered = (from reminder in startReminderTasks select reminder.Result.ReminderName).ToList();
log.LogInformation("Waited");
List <IGrainReminder> remindersList = await grain.GetRemindersList();
List <string> fetched = (from reminder in remindersList select reminder.ReminderName).ToList();
foreach (var remRegistered in registered)
{
Assert.True(fetched.Remove(remRegistered), $"Couldn't get reminder {remRegistered}. " +
$"Registered list: {Utils.EnumerableToString(registered)}, " +
$"fetched list: {Utils.EnumerableToString(remindersList, r => r.ReminderName)}");
}
Assert.True(fetched.Count == 0, $"More than registered reminders. Extra: {Utils.EnumerableToString(fetched)}");
// do some time tests as well
log.LogInformation("Time tests");
TimeSpan period = await grain.GetReminderPeriod(DR);
await Task.Delay(period.Multiply(2) + LEEWAY); // giving some leeway
for (int i = 0; i < count; i++)
{
long curr = await grain.GetCounter(DR + "_" + i);
Assert.Equal(2, curr);
}
}
public async Task Rem_Azure_1F1J_MultiGrain()
{
log.Info(TestContext.TestName);
List <SiloHandle> silos = StartAdditionalSilos(1);
await WaitForLivenessToStabilizeAsync();
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g3 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g4 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g5 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
TimeSpan period = await g1.GetReminderPeriod(DR);
Task <bool>[] tasks =
{
Task.Run(async() => { await PerGrainFailureTest(g1); return(true); }),
Task.Run(async() => { await PerGrainFailureTest(g2); return(true); }),
Task.Run(async() => { await PerGrainFailureTest(g3); return(true); }),
Task.Run(async() => { await PerGrainFailureTest(g4); return(true); }),
Task.Run(async() => { await PerGrainFailureTest(g5); return(true); })
};
Thread.Sleep(period.Multiply(failAfter));
var siloToKill = silos[random.Next(silos.Count)];
// stop a silo and join a new one in parallel
log.Info("Stopping a silo and joining a silo");
Task <bool> t1 = Task.Factory.StartNew(() =>
{
StopSilo(siloToKill);
return(true);
});
Task <bool> t2 = Task.Factory.StartNew(() =>
{
StartAdditionalSilos(1);
return(true);
});
await Task.WhenAll(new[] { t1, t2 }).WithTimeout(ENDWAIT);
await Task.WhenAll(tasks).WithTimeout(ENDWAIT); // Block until all tasks complete.
log.Info("\n\n\nReminderTest_1F1J_MultiGrain passed OK.\n\n\n");
}
public async Task Test_Reminders_Basic_StopByRef()
{
Console.WriteLine(TestContext.TestName + " started");
log.Info(TestContext.TestName);
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IGrainReminder r1 = await grain.StartReminder(DR);
IGrainReminder r2 = await grain.StartReminder(DR);
Console.WriteLine(TestContext.TestName + " reminders started");
try
{
// First handle should now be out of date once the seconf handle to the same reminder was obtained
await grain.StopReminder(r1);
Assert.Fail("Removed reminder1, which shouldn't be possible.");
}
catch (Exception exc)
{
log.Info("Couldn't remove {0}, as expected. Exception received = {1}", r1, exc);
}
await grain.StopReminder(r2);
log.Info("Removed reminder2 successfully");
// trying to see if readreminder works
IGrainReminder o1 = await grain.StartReminder(DR);
IGrainReminder o2 = await grain.StartReminder(DR);
IGrainReminder o3 = await grain.StartReminder(DR);
IGrainReminder o4 = await grain.StartReminder(DR);
IGrainReminder r = await grain.GetReminderObject(DR);
await grain.StopReminder(r);
log.Info("Removed got reminder successfully");
}
public async Task Rem_Azure_MultiGrainMultiReminders()
{
IReminderTestGrain2 g1 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g2 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g3 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g4 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IReminderTestGrain2 g5 = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
Task <bool>[] tasks =
{
Task.Run(() => PerGrainMultiReminderTest(g1)),
Task.Run(() => PerGrainMultiReminderTest(g2)),
Task.Run(() => PerGrainMultiReminderTest(g3)),
Task.Run(() => PerGrainMultiReminderTest(g4)),
Task.Run(() => PerGrainMultiReminderTest(g5)),
};
//Block until all tasks complete.
await Task.WhenAll(tasks).WithTimeout(ENDWAIT);
}
public async Task Test_Reminders_Basic_StopByRef()
{
IReminderTestGrain2 grain = this.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IGrainReminder r1 = await grain.StartReminder(DR);
IGrainReminder r2 = await grain.StartReminder(DR);
try
{
// First handle should now be out of date once the seconf handle to the same reminder was obtained
await grain.StopReminder(r1);
Assert.True(false, "Removed reminder1, which shouldn't be possible.");
}
catch (Exception exc)
{
log.LogInformation(exc, "Couldn't remove {Reminder}, as expected.", r1);
}
await grain.StopReminder(r2);
log.LogInformation("Removed reminder2 successfully");
// trying to see if readreminder works
_ = await grain.StartReminder(DR);
_ = await grain.StartReminder(DR);
_ = await grain.StartReminder(DR);
_ = await grain.StartReminder(DR);
IGrainReminder r = await grain.GetReminderObject(DR);
await grain.StopReminder(r);
log.LogInformation("Removed got reminder successfully");
}
public async Task Test_Reminders_Basic_StopByRef()
{
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IGrainReminder r1 = await grain.StartReminder(DR, TimeSpan.FromSeconds(10));
IGrainReminder r2 = await grain.StartReminder(DR);
try
{
// First handle should now be out of date once the seconf handle to the same reminder was obtained
await grain.StopReminder(r1);
Assert.IsTrue(false, "Removed reminder1, which shouldn't be possible.");
}
catch (Exception exc)
{
if (this.log != null)
{
log.Info("Couldn't remove {0}, as expected. Exception received = {1}", r1, exc);
}
}
await grain.StopReminder(r2);
// trying to see if readreminder works
IGrainReminder o1 = await grain.StartReminder(DR);
IGrainReminder o2 = await grain.StartReminder(DR);
IGrainReminder o3 = await grain.StartReminder(DR);
IGrainReminder o4 = await grain.StartReminder(DR);
IGrainReminder r = await grain.GetReminderObject(DR);
await grain.StopReminder(r);
}
protected async Task <bool> PerGrainMultiReminderTest(IReminderTestGrain2 g)
{
TimeSpan period = await g.GetReminderPeriod(DR);
this.log.Info("PerGrainMultiReminderTest Period={0} Grain={1}", period, g);
// Each reminder is started 2 periods after the previous reminder
// once all reminders have been started, stop them every 2 periods
// except the default reminder, which we stop after 3 periods instead
// just to test and break the symmetry
// Start Default Reminder
await g.StartReminder(DR);
TimeSpan sleepFor = period.Multiply(2) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long last = await g.GetCounter(DR);
AssertIsInRange(last, 1, 2, g, DR, sleepFor);
// Start R1
await g.StartReminder(R1);
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 1, 2, g, R1, sleepFor);
// Start R2
await g.StartReminder(R2);
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 1, 2, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 5, 6, g, DR, sleepFor);
// Stop R1
await g.StopReminder(R1);
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 3, 4, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 7, 8, g, DR, sleepFor);
// Stop R2
await g.StopReminder(R2);
sleepFor = period.Multiply(3) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 3, 4, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 10, 12, g, DR, sleepFor);
// Stop Default reminder
await g.StopReminder(DR);
sleepFor = period.Multiply(1) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 3, 4, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 10, 12, g, DR, sleepFor);
return(true);
}
internal async Task<bool> PerGrainMultiReminderTestChurn(IReminderTestGrain2 g)
{
// for churn cases, we do execute start and stop reminders with retries as we don't have the queue-ing
// functionality implemented on the LocalReminderService yet
TimeSpan period = await g.GetReminderPeriod(DR);
logger.Info("PerGrainMultiReminderTestChurn Period={0} Grain={1}", period, g);
// Start Default Reminder
//g.StartReminder(DR, file + "_" + DR).Wait();
await ExecuteWithRetries(g.StartReminder, DR);
TimeSpan sleepFor = period.Multiply(2);
await Task.Delay(sleepFor);
// Start R1
//g.StartReminder(R1, file + "_" + R1).Wait();
await ExecuteWithRetries(g.StartReminder, R1);
sleepFor = period.Multiply(2);
await Task.Delay(sleepFor);
// Start R2
//g.StartReminder(R2, file + "_" + R2).Wait();
await ExecuteWithRetries(g.StartReminder, R2);
sleepFor = period.Multiply(2);
await Task.Delay(sleepFor);
sleepFor = period.Multiply(1);
await Task.Delay(sleepFor);
// Stop R1
//g.StopReminder(R1).Wait();
await ExecuteWithRetriesStop(g.StopReminder, R1);
sleepFor = period.Multiply(2);
await Task.Delay(sleepFor);
// Stop R2
//g.StopReminder(R2).Wait();
await ExecuteWithRetriesStop(g.StopReminder, R2);
sleepFor = period.Multiply(1);
await Task.Delay(sleepFor);
// Stop Default reminder
//g.StopReminder(DR).Wait();
await ExecuteWithRetriesStop(g.StopReminder, DR);
sleepFor = period.Multiply(1) + LEEWAY; // giving some leeway
await Task.Delay(sleepFor);
long last = await g.GetCounter(R1);
AssertIsInRange(last, 4, 6, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 4, 6, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 9, 10, g, DR, sleepFor);
return true;
}
public async Task Rem_Azure_Wrong_LowerThanAllowedPeriod()
{
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
await Assert.ThrowsAsync <ArgumentException>(() =>
grain.StartReminder(DR, TimeSpan.FromMilliseconds(3000), true));
}
protected async Task<bool> PerGrainFailureTest(IReminderTestGrain2 grain)
{
TimeSpan period = await grain.GetReminderPeriod(DR);
logger.Info("PerGrainFailureTest Period={0} Grain={1}", period, grain);
await grain.StartReminder(DR);
TimeSpan sleepFor = period.Multiply(failCheckAfter) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long last = await grain.GetCounter(DR);
AssertIsInRange(last, failCheckAfter - 1, failCheckAfter + 1, grain, DR, sleepFor);
await grain.StopReminder(DR);
sleepFor = period.Multiply(2) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long curr = await grain.GetCounter(DR);
AssertIsInRange(curr, last, last + 1, grain, DR, sleepFor);
return true;
}
protected async Task<bool> PerGrainMultiReminderTest(IReminderTestGrain2 g)
{
TimeSpan period = await g.GetReminderPeriod(DR);
logger.Info("PerGrainMultiReminderTest Period={0} Grain={1}", period, g);
// Each reminder is started 2 periods after the previous reminder
// once all reminders have been started, stop them every 2 periods
// except the default reminder, which we stop after 3 periods instead
// just to test and break the symmetry
// Start Default Reminder
await g.StartReminder(DR);
TimeSpan sleepFor = period.Multiply(2) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
long last = await g.GetCounter(DR);
AssertIsInRange(last, 1, 2, g, DR, sleepFor);
// Start R1
await g.StartReminder(R1);
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 1, 2, g, R1, sleepFor);
// Start R2
await g.StartReminder(R2);
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 1, 2, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 5, 6, g, DR, sleepFor);
// Stop R1
await g.StopReminder(R1);
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 3, 4, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 7, 8, g, DR, sleepFor);
// Stop R2
await g.StopReminder(R2);
sleepFor = period.Multiply(3) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 3, 4, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 10, 12, g, DR, sleepFor);
// Stop Default reminder
await g.StopReminder(DR);
sleepFor = period.Multiply(1) + LEEWAY; // giving some leeway
Thread.Sleep(sleepFor);
last = await g.GetCounter(R1);
AssertIsInRange(last, 3, 4, g, R1, sleepFor);
last = await g.GetCounter(R2);
AssertIsInRange(last, 3, 4, g, R2, sleepFor);
last = await g.GetCounter(DR);
AssertIsInRange(last, 10, 12, g, DR, sleepFor);
return true;
}
public async Task Rem_Azure_MultipleReminders()
{
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
await PerGrainMultiReminderTest(grain);
}
