public Task <ReminderTableData> ReadRows(uint begin, uint end)
{
ReminderTableData t = remTable.ReadRows(begin, end);
logger.Verbose("Read {0} reminders from memory: {1}, {2}", t.Reminders.Count, Environment.NewLine, Utils.EnumerableToString(t.Reminders));
return(Task.FromResult(t));
}
public Task <ReminderTableData> ReadRows(uint begin, uint end)
{
var range = RangeFactory.CreateRange(begin, end);
var list = reminderTable.Where(e => range.InRange(e.Key)).SelectMany(e => e.Value.Values).ToList();
if (logger.IsEnabled(LogLevel.Trace))
{
logger.LogTrace(
"Selected {SelectCount} out of {TotalCount} reminders from memory for {Range}. Selected: {Reminders}",
list.Count,
reminderTable.Values.Sum(r => r.Count),
range.ToString(),
Utils.EnumerableToString(list, e => e.ToString()));
}
var result = new ReminderTableData(list);
if (logger.IsEnabled(LogLevel.Debug))
{
logger.LogDebug("Read {ReminderCount} reminders from memory: {Reminders}", result.Reminders.Count, Utils.EnumerableToString(result.Reminders));
}
return(Task.FromResult(result));
}
protected async Task RemindersRange(int iterations = 1000)
{
await Task.WhenAll(Enumerable.Range(1, iterations).Select(async i =>
{
GrainReference grainRef = MakeTestGrainReference();
await RetryHelper.RetryOnExceptionAsync <Task>(10, RetryOperation.Sigmoid, async() =>
{
await remindersTable.UpsertRow(CreateReminder(grainRef, i.ToString()));
return(Task.CompletedTask);
});
}));
ReminderTableData rows = await remindersTable.ReadRows(0, uint.MaxValue);
Assert.Equal(rows.Reminders.Count, iterations);
rows = await remindersTable.ReadRows(0, 0);
Assert.Equal(rows.Reminders.Count, iterations);
uint[] remindersHashes = rows.Reminders.Select(r => r.GrainRef.GetUniformHashCode()).ToArray();
SafeRandom random = new SafeRandom();
await Task.WhenAll(Enumerable.Range(0, iterations).Select(i =>
TestRemindersHashInterval(remindersTable, (uint)random.Next(), (uint)random.Next(),
remindersHashes)));
}
public Task <ReminderTableData> ReadRows(uint begin, uint end)
{
ReminderTableData t = remTable.ReadRows(begin, end);
if (logger.IsEnabled(LogLevel.Debug))
{
logger.LogDebug("Read {ReminderCount} reminders from memory: {Reminders}", t.Reminders.Count, Utils.EnumerableToString(t.Reminders));
}
return(Task.FromResult(t));
}
/// <summary>
/// Maps the specified source.
/// </summary>
/// <param name="converter"></param>
/// <param name="src">The source.</param>
/// <param name="dst">The DST.</param>
/// <returns></returns>
internal static ReminderTableData Map(
IGrainReferenceConverter converter,
List <OrleansEFReminder> src,
ReminderTableData dst = null
)
{
var entries = src
.Select(a => Map(converter, a))
.ToList();
dst = dst ?? new ReminderTableData(entries);
return(dst);
}
public async Task <ReminderTableData> ReadRows(GrainReference key)
{
ReminderTableData data = new ReminderTableData();
// E.g. Get all keys with pattern "key/*"
var range = await etcdClient.GetRangeValAsync($"{key}/").ConfigureAwait(false);
foreach (var item in range)
{
//data.Reminders.Add(new ReminderEntry()
// {
// item.Value.ToByteArray()
// })
}
return(null);
}
public async Task <ReminderTableData> ReadRows(uint beginHash, uint endHash)
{
var dic = JsonSerializer.Deserialize <Dictionary <string, uint> >(await Database.StringGetAsync(GetKeyStringForHash()));
RedisKey[] keys;
if (beginHash < endHash)
{
keys = dic
.Where(x => x.Value > beginHash && x.Value <= endHash)
.Select(y => new RedisKey(y.Key))
.ToArray();
}
else
{
keys = dic
.Where(x => x.Value > beginHash || x.Value <= endHash)
.Select(y => new RedisKey(y.Key))
.ToArray();
}
var values = await Database.StringGetAsync(keys);
var tableData = values.Select(x => JsonSerializer.Deserialize <RedisReminderTableData>(x)).ToList();
var reminders = tableData
.Select(y => new ReminderEntry
{
Period = TimeSpan.FromMilliseconds(y.Period),
ReminderName = y.ReminderName,
ETag = y.Version.ToString(),
StartAt = y.StartTime,
GrainRef = _converter.GetGrainFromKeyString(y.GrainId)
}).ToList();
var reminderTableData = new ReminderTableData(reminders);
if (reminders.Count > 0)
{
Console.WriteLine("OPA!");
}
return(reminderTableData);
}
public async Task <ReminderTableData> ReadRows(uint begin, uint end)
{
try
{
var entries = await remTableManager.FindReminderEntries(begin, end);
ReminderTableData data = ConvertFromTableEntryList(entries);
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace("Read in {0} Table=" + Environment.NewLine + "{1}", RangeFactory.CreateRange(begin, end), data);
}
return(data);
}
catch (Exception exc)
{
logger.Warn((int)AzureUtils.Utilities.ErrorCode.AzureTable_40,
$"Intermediate error reading reminders in range {RangeFactory.CreateRange(begin, end)} for table {remTableManager.TableName}.", exc);
throw;
}
}
public async Task <ReminderTableData> ReadRows(GrainReference key)
{
try
{
var entries = await remTableManager.FindReminderEntries(key);
ReminderTableData data = ConvertFromTableEntryList(entries);
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace("Read for grain {0} Table=" + Environment.NewLine + "{1}", key, data.ToString());
}
return(data);
}
catch (Exception exc)
{
logger.Warn((int)AzureUtils.Utilities.ErrorCode.AzureTable_47,
$"Intermediate error reading reminders for grain {key} in table {remTableManager.TableName}.", exc);
throw;
}
}
public async Task <ReminderTableData> ReadRows(uint begin, uint end)
{
try
{
var entries = await remTableManager.FindReminderEntries(begin, end);
ReminderTableData data = ConvertFromTableEntryList(entries);
if (logger.IsVerbose2)
{
logger.Verbose2("Read in {0} Table=" + Environment.NewLine + "{1}", RangeFactory.CreateRange(begin, end), data);
}
return(data);
}
catch (Exception exc)
{
logger.Warn(ErrorCode.AzureTable_40, String.Format("Intermediate error reading reminders in range {0} for table {1}.",
RangeFactory.CreateRange(begin, end), remTableManager.TableName), exc);
throw;
}
}
public async Task <ReminderTableData> ReadRows(GrainReference key)
{
try
{
var entries = await remTableManager.FindReminderEntries(key);
ReminderTableData data = ConvertFromTableEntryList(entries);
if (logger.IsVerbose2)
{
logger.Verbose2("Read for grain {0} Table=" + Environment.NewLine + "{1}", key, data.ToString());
}
return(data);
}
catch (Exception exc)
{
logger.Warn(ErrorCode.AzureTable_47, String.Format("Intermediate error reading reminders for grain {0} in table {1}.",
key, remTableManager.TableName), exc);
throw;
}
}
private async Task ReadTableAndStartTimers(IRingRange range, int rangeSerialNumberCopy)
{
if (Logger.IsVerbose)
{
Logger.Verbose("Reading rows from {0}", range.ToString());
}
localTableSequence++;
long cachedSequence = localTableSequence;
try
{
var srange = (SingleRange)range;
ReminderTableData table = await reminderTable.ReadRows(srange.Begin, srange.End); // get all reminders, even the ones we already have
if (rangeSerialNumberCopy < RangeSerialNumber)
{
if (Logger.IsVerbose)
{
Logger.Verbose($"My range changed while reading from the table, ignoring the results. Another read has been started. RangeSerialNumber {RangeSerialNumber}, RangeSerialNumberCopy {rangeSerialNumberCopy}.");
}
return;
}
if (StoppedCancellationTokenSource.IsCancellationRequested)
{
return;
}
// if null is a valid value, it means that there's nothing to do.
if (null == table && reminderTable is MockReminderTable)
{
return;
}
var remindersNotInTable = localReminders.Where(r => range.InRange(r.Key.GrainRef)).ToDictionary(r => r.Key, r => r.Value); // shallow copy
if (Logger.IsVerbose)
{
Logger.Verbose("For range {0}, I read in {1} reminders from table. LocalTableSequence {2}, CachedSequence {3}", range.ToString(), table.Reminders.Count, localTableSequence, cachedSequence);
}
foreach (ReminderEntry entry in table.Reminders)
{
var key = new ReminderIdentity(entry.GrainRef, entry.ReminderName);
LocalReminderData localRem;
if (localReminders.TryGetValue(key, out localRem))
{
if (cachedSequence > localRem.LocalSequenceNumber) // info read from table is same or newer than local info
{
if (localRem.Timer != null) // if ticking
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("In table, In local, Old, & Ticking {0}", localRem);
}
// it might happen that our local reminder is different than the one in the table, i.e., eTag is different
// if so, stop the local timer for the old reminder, and start again with new info
if (!localRem.ETag.Equals(entry.ETag))
// this reminder needs a restart
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("{0} Needs a restart", localRem);
}
localRem.StopReminder(Logger);
localReminders.Remove(localRem.Identity);
StartAndAddTimer(entry);
}
}
else // if not ticking
{
// no-op
if (Logger.IsVerbose2)
{
Logger.Verbose2("In table, In local, Old, & Not Ticking {0}", localRem);
}
}
}
else // cachedSequence < localRem.LocalSequenceNumber ... // info read from table is older than local info
{
if (localRem.Timer != null) // if ticking
{
// no-op
if (Logger.IsVerbose2)
{
Logger.Verbose2("In table, In local, Newer, & Ticking {0}", localRem);
}
}
else // if not ticking
{
// no-op
if (Logger.IsVerbose2)
{
Logger.Verbose2("In table, In local, Newer, & Not Ticking {0}", localRem);
}
}
}
}
else // exists in table, but not locally
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("In table, Not in local, {0}", entry);
}
// create and start the reminder
StartAndAddTimer(entry);
}
// keep a track of extra reminders ... this 'reminder' is useful, so remove it from extra list
remindersNotInTable.Remove(key);
} // foreach reminder read from table
int remindersCountBeforeRemove = localReminders.Count;
// foreach reminder that is not in global table, but exists locally
foreach (var reminder in remindersNotInTable.Values)
{
if (cachedSequence < reminder.LocalSequenceNumber)
{
// no-op
if (Logger.IsVerbose2)
{
Logger.Verbose2("Not in table, In local, Newer, {0}", reminder);
}
}
else // cachedSequence > reminder.LocalSequenceNumber
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("Not in table, In local, Old, so removing. {0}", reminder);
}
// remove locally
reminder.StopReminder(Logger);
localReminders.Remove(reminder.Identity);
}
}
if (Logger.IsVerbose)
{
Logger.Verbose($"Removed {localReminders.Count - remindersCountBeforeRemove} reminders from local table");
}
}
catch (Exception exc)
{
Logger.Error(ErrorCode.RS_FailedToReadTableAndStartTimer, "Failed to read rows from table.", exc);
throw;
}
}
private async Task <IEnumerable <ReminderEntry> > GetAllRows(IReminderTable table)
{
ReminderTableData data = await table.ReadRows(0, 0xffffffff);
return(data.Reminders);
}
