internal async Task RemindersParallelUpsert()
{
var upserts = await Task.WhenAll(Enumerable.Range(0, 50).Select(i =>
{
var reminder = CreateReminder(MakeTestGrainReference(), i.ToString());
return(Task.WhenAll(Enumerable.Range(1, 5).Select(j => remindersTable.UpsertRow(reminder))));
}));
Assert.IsFalse(upserts.Any(i => i.Distinct().Count() != 5));
}
internal static async Task ReminderTableTest(IReminderTable reminderTable)
{
Guid guid = Guid.NewGuid();
var results = await Task.WhenAll(Enumerable.Range(0, 10).
Select(x => reminderTable.UpsertRow(CreateReminder(MakeTestGrainReference(guid), "0"))));
Assert.AreEqual(results.Distinct().Count(), results.Length);
await Task.WhenAll(Enumerable.Range(1, 999).Select(async i =>
{
GrainReference grainRef = MakeTestGrainReference(Guid.NewGuid());
await reminderTable.UpsertRow(CreateReminder(grainRef, i.ToString()));
}));
var rows = await reminderTable.ReadRows(0, uint.MaxValue);
Assert.AreEqual(rows.Reminders.Count, 1000);
rows = await reminderTable.ReadRows(0, 0);
Assert.AreEqual(rows.Reminders.Count, 1000);
var remindersHashes = rows.Reminders.Select(r => r.GrainRef.GetUniformHashCode()).ToArray();
SafeRandom random = new SafeRandom();
await Task.WhenAll(Enumerable.Repeat(
TestRemindersHashInterval(reminderTable, (uint)random.Next(), (uint)random.Next(),
remindersHashes), 1000));
var reminder = rows.Reminders.First();
var shouldExist = await reminderTable.ReadRow(reminder.GrainRef, reminder.ReminderName);
Assert.IsNotNull(shouldExist);
string etagTemp = reminder.ETag;
reminder.ETag = await reminderTable.UpsertRow(reminder);
var removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, etagTemp);
Assert.IsFalse(removeRowRes, "should have failed. Etag is wrong");
removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, "bla", reminder.ETag);
Assert.IsFalse(removeRowRes, "should have failed. reminder name is wrong");
removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag);
Assert.IsTrue(removeRowRes, "should have succeeded. Etag is right");
removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag);
Assert.IsFalse(removeRowRes, "should have failed. reminder shouldn't exist");
}
internal static async Task ReminderTableTest(IReminderTable reminderTable)
{
Guid guid = Guid.NewGuid();
var results = await Task.WhenAll(Enumerable.Range(0, 10).
Select(x => reminderTable.UpsertRow(CreateReminder(MakeTestGrainReference(guid), "0"))));
Assert.AreEqual(results.Distinct().Count(), results.Length);
await Task.WhenAll(Enumerable.Range(1, 999).Select(async i =>
{
GrainReference grainRef = MakeTestGrainReference(Guid.NewGuid());
await reminderTable.UpsertRow(CreateReminder(grainRef, i.ToString()));
}));
var rows = await reminderTable.ReadRows(0, uint.MaxValue);
Assert.AreEqual(rows.Reminders.Count, 1000);
rows = await reminderTable.ReadRows(0, 0);
Assert.AreEqual(rows.Reminders.Count, 1000);
var remindersHashes = rows.Reminders.Select(r => r.GrainRef.GetUniformHashCode()).ToArray();
SafeRandom random = new SafeRandom();
await Task.WhenAll(Enumerable.Repeat(
TestRemindersHashInterval(reminderTable, (uint) random.Next(), (uint) random.Next(),
remindersHashes), 1000));
var reminder = rows.Reminders.First();
var shouldExist = await reminderTable.ReadRow(reminder.GrainRef, reminder.ReminderName);
Assert.IsNotNull(shouldExist);
string etagTemp = reminder.ETag;
reminder.ETag = await reminderTable.UpsertRow(reminder);
var removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, etagTemp);
Assert.IsFalse(removeRowRes, "should have failed. Etag is wrong");
removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, "bla", reminder.ETag);
Assert.IsFalse(removeRowRes, "should have failed. reminder name is wrong");
removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag);
Assert.IsTrue(removeRowRes, "should have succeeded. Etag is right");
removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag);
Assert.IsFalse(removeRowRes, "should have failed. reminder shouldn't exist");
}
protected async Task RemindersParallelUpsert()
{
var upserts = await Task.WhenAll(Enumerable.Range(0, 5).Select(i =>
{
var reminder = CreateReminder(MakeTestGrainReference(), i.ToString());
return(Task.WhenAll(Enumerable.Range(1, 5).Select(j =>
{
return RetryHelper.RetryOnExceptionAsync <string>(5, RetryOperation.Sigmoid, async() =>
{
return await remindersTable.UpsertRow(reminder);
});
})));
}));
Assert.DoesNotContain(upserts, i => i.Distinct().Count() != 5);
}
private static async Task<string> UpsertReminder(IReminderTable reminder, GrainReference grainRef, string reminderName, DateTime startAt, TimeSpan period)
{
var reminderRow = new ReminderEntry
{
GrainRef = grainRef,
Period = period,
StartAt = startAt,
ReminderName = reminderName
};
return await reminder.UpsertRow(reminderRow);
}
private static async Task <string> UpsertReminder(IReminderTable reminder, GrainReference grainRef, string reminderName, DateTime startAt, TimeSpan period)
{
var reminderRow = new ReminderEntry
{
GrainRef = grainRef,
Period = period,
StartAt = startAt,
ReminderName = reminderName
};
return(await reminder.UpsertRow(reminderRow));
}
private async Task TestTableInsertRate(IReminderTable reminderTable, double numOfInserts)
{
DateTime startedAt = DateTime.UtcNow;
try
{
List <Task <bool> > promises = new List <Task <bool> >();
for (int i = 0; i < numOfInserts; i++)
{
//"177BF46E-D06D-44C0-943B-C12F26DF5373"
string s = string.Format("177BF46E-D06D-44C0-943B-C12F26D{0:d5}", i);
var e = new ReminderEntry
{
//GrainId = LegacyGrainId.GetGrainId(new Guid(s)),
GrainRef = (GrainReference)this.fixture.InternalGrainFactory.GetGrain(LegacyGrainId.NewId()),
ReminderName = "MY_REMINDER_" + i,
Period = TimeSpan.FromSeconds(5),
StartAt = DateTime.UtcNow
};
int capture = i;
Task <bool> promise = Task.Run(async() =>
{
await reminderTable.UpsertRow(e);
this.output.WriteLine("Done " + capture);
return(true);
});
promises.Add(promise);
this.log.LogInformation("Started {Capture}", capture);
}
this.log.LogInformation("Started all, now waiting...");
await Task.WhenAll(promises).WithTimeout(TimeSpan.FromSeconds(500));
}
catch (Exception exc)
{
this.log.LogInformation(exc, "Exception caught");
}
TimeSpan dur = DateTime.UtcNow - startedAt;
this.log.LogInformation(
"Inserted {InsertCount} rows in {Duration}, i.e., {Rate} upserts/sec",
numOfInserts,
dur,
(numOfInserts / dur.TotalSeconds).ToString("f2"));
}
private async Task TestTableInsertRate(IReminderTable reminderTable, double numOfInserts)
{
DateTime startedAt = DateTime.UtcNow;
try
{
List <Task <bool> > promises = new List <Task <bool> >();
for (int i = 0; i < numOfInserts; i++)
{
//"177BF46E-D06D-44C0-943B-C12F26DF5373"
string s = string.Format("177BF46E-D06D-44C0-943B-C12F26D{0:d5}", i);
var e = new ReminderEntry
{
//GrainId = GrainId.GetGrainId(new Guid(s)),
GrainRef = GrainReference.FromGrainId(GrainId.NewId()),
ReminderName = "MY_REMINDER_" + i,
Period = TimeSpan.FromSeconds(5),
StartAt = DateTime.UtcNow
};
int capture = i;
Task <bool> promise = Task.Run(async() =>
{
await reminderTable.UpsertRow(e);
Console.WriteLine("Done " + capture);
return(true);
});
promises.Add(promise);
log.Info("Started " + capture);
}
log.Info("Started all, now waiting...");
await Task.WhenAll(promises).WithTimeout(TimeSpan.FromSeconds(500));
}
catch (Exception exc)
{
log.Info("Exception caught {0}", exc);
}
TimeSpan dur = DateTime.UtcNow - startedAt;
log.Info("Inserted {0} rows in {1}, i.e., {2:f2} upserts/sec", numOfInserts, dur, (numOfInserts / dur.TotalSeconds));
}
public async Task <IGrainReminder> RegisterOrUpdateReminder(GrainReference grainRef, string reminderName, TimeSpan dueTime, TimeSpan period)
{
var entry = new ReminderEntry
{
GrainRef = grainRef,
ReminderName = reminderName,
StartAt = DateTime.UtcNow.Add(dueTime),
Period = period,
};
if (logger.IsEnabled(LogLevel.Debug))
{
logger.Debug(ErrorCode.RS_RegisterOrUpdate, "RegisterOrUpdateReminder: {0}", entry.ToString());
}
await DoResponsibilitySanityCheck(grainRef, "RegisterReminder");
var newEtag = await reminderTable.UpsertRow(entry);
if (newEtag != null)
{
if (logger.IsEnabled(LogLevel.Debug))
{
logger.Debug("Registered reminder {0} in table, assigned localSequence {1}", entry, localTableSequence);
}
entry.ETag = newEtag;
StartAndAddTimer(entry);
if (logger.IsEnabled(LogLevel.Trace))
{
PrintReminders();
}
return(new ReminderData(grainRef, reminderName, newEtag) as IGrainReminder);
}
var msg = string.Format("Could not register reminder {0} to reminder table due to a race. Please try again later.", entry);
logger.Error(ErrorCode.RS_Register_TableError, msg);
throw new ReminderException(msg);
}
private async Task TestTableInsertRate(IReminderTable reminderTable, double numOfInserts)
{
DateTime startedAt = DateTime.UtcNow;
try
{
List<Task<bool>> promises = new List<Task<bool>>();
for (int i = 0; i < numOfInserts; i++)
{
//"177BF46E-D06D-44C0-943B-C12F26DF5373"
string s = string.Format("177BF46E-D06D-44C0-943B-C12F26D{0:d5}", i);
var e = new ReminderEntry
{
//GrainId = GrainId.GetGrainId(new Guid(s)),
GrainRef = GrainReference.FromGrainId(GrainId.NewId()),
ReminderName = "MY_REMINDER_" + i,
Period = TimeSpan.FromSeconds(5),
StartAt = DateTime.UtcNow
};
int capture = i;
Task<bool> promise = Task.Run(async () =>
{
await reminderTable.UpsertRow(e);
Console.WriteLine("Done " + capture);
return true;
});
promises.Add(promise);
log.Info("Started " + capture);
}
log.Info("Started all, now waiting...");
await Task.WhenAll(promises).WithTimeout(TimeSpan.FromSeconds(500));
}
catch (Exception exc)
{
log.Info("Exception caught {0}", exc);
}
TimeSpan dur = DateTime.UtcNow - startedAt;
log.Info("Inserted {0} rows in {1}, i.e., {2:f2} upserts/sec", numOfInserts, dur, (numOfInserts / dur.TotalSeconds));
}
