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));
}
public ReminderTableData ReadRows(uint begin, uint end)
{
var range = RangeFactory.CreateRange(begin, end);
IEnumerable <GrainReference> keys = reminderTable.Keys.Where(range.InRange);
// is there a sleaker way of doing this in C#?
var list = new List <ReminderEntry>();
foreach (GrainReference k in keys)
{
list.AddRange(reminderTable[k].Values);
}
if (logger.IsEnabled(LogLevel.Trace))
{
logger.LogTrace(
"Selected {SelectCount} out of {TotalCount} reminders from memory for {Range}. Selected: {Reminders}",
list.Count,
reminderTable.Count,
range.ToString(),
Utils.EnumerableToString(list, e => e.ToString()));
}
return(new ReminderTableData(list));
}
public void DoRangeTest()
{
Range <string> stringRange = RangeFactory.CreateRange(null, "cdf");
string actual = stringRange.ToString();
Assert.AreEqual("{ NULL : cdf }", actual);
Assert.IsTrue(stringRange.Contains("abc"));
Assert.IsFalse(stringRange.Contains("xyz"));
stringRange = RangeFactory.CreateRange("xyz", "abc");
actual = stringRange.ToString();
Assert.AreEqual("{ abc : xyz }", actual);
Assert.IsTrue(stringRange.Contains("abc"));
Assert.IsTrue(stringRange.Contains("cfdes"));
Assert.IsTrue(stringRange.Contains("xyz"));
Assert.IsFalse(stringRange.Contains("aa"));
Assert.IsFalse(stringRange.Contains("zz"));
ValueRange <int> intRange = RangeFactory.CreateValueRange <int>(1, null);
actual = intRange.ToString();
Assert.AreEqual("{ 1 : NULL }", actual);
Assert.IsTrue(intRange.Contains(2));
Assert.IsTrue(intRange.Contains(int.MaxValue));
Assert.IsFalse(intRange.Contains(int.MinValue));
}
internal void AddServer(SiloAddress silo)
{
lock (membershipRingList)
{
if (membershipRingList.Contains(silo))
{
return; // we already have this silo
}
int myOldIndex = membershipRingList.FindIndex(elem => elem.Equals(MyAddress));
if (!(membershipRingList.Count == 0 || myOldIndex != -1))
{
throw new OrleansException(string.Format("{0}: Couldn't find my position in the ring {1}.", MyAddress, Utils.EnumerableToString(membershipRingList)));
}
// insert new silo in the sorted order
int hash = silo.GetConsistentHashCode();
// Find the last silo with hash smaller than the new silo, and insert the latter after (this is why we have +1 here) the former.
// Notice that FindLastIndex might return -1 if this should be the first silo in the list, but then
// 'index' will get 0, as needed.
int index = membershipRingList.FindLastIndex(siloAddr => siloAddr.GetConsistentHashCode() < hash) + 1;
membershipRingList.Insert(index, silo);
// relating to triggering handler ... new node took over some of my responsibility
if (index == myOldIndex || // new node was inserted in my place
(myOldIndex == 0 && index == membershipRingList.Count - 1)) // I am the first node, and the new server is the last node
{
IRingRange oldRange = MyRange;
try
{
MyRange = RangeFactory.CreateRange(unchecked ((uint)hash), unchecked ((uint)myKey));
}
catch (OverflowException exc)
{
log.Error(ErrorCode.ConsistentRingProviderBase + 5,
String.Format("OverflowException: hash as int= x{0, 8:X8}, hash as uint= x{1, 8:X8}, myKey as int x{2, 8:X8}, myKey as uint x{3, 8:X8}.",
hash, (uint)hash, myKey, (uint)myKey), exc);
}
NotifyLocalRangeSubscribers(oldRange, MyRange, false);
}
log.Info("Added Server {0}. Current view: {1}", silo.ToStringWithHashCode(), this.ToString());
}
}
private static IRingRange CalculateRange(List <Tuple <uint, SiloAddress> > list, SiloAddress silo)
{
var ranges = new List <IRingRange>();
for (int i = 0; i < list.Count; i++)
{
var curr = list[i];
var next = list[(i + 1) % list.Count];
// 'backward/clockwise' definition to assign responsibilities on the ring.
if (next.Item2.Equals(silo))
{
IRingRange range = RangeFactory.CreateRange(curr.Item1, next.Item1);
ranges.Add(range);
}
}
return(RangeFactory.CreateRange(ranges));
}
internal void RemoveServer(SiloAddress silo)
{
lock (membershipRingList)
{
int indexOfFailedSilo = membershipRingList.FindIndex(elem => elem.Equals(silo));
if (indexOfFailedSilo < 0)
{
return; // we have already removed this silo
}
membershipRingList.Remove(silo);
// related to triggering handler
int myNewIndex = membershipRingList.FindIndex(elem => elem.Equals(MyAddress));
if (myNewIndex == -1)
{
throw new OrleansException(string.Format("{0}: Couldn't find my position in the ring {1}.", MyAddress, this.ToString()));
}
bool wasMyPred = ((myNewIndex == indexOfFailedSilo) || (myNewIndex == 0 && indexOfFailedSilo == membershipRingList.Count)); // no need for '- 1'
if (wasMyPred) // failed node was our predecessor
{
if (log.IsVerbose)
{
log.Verbose("Failed server was my pred? {0}, updated view {1}", wasMyPred, this.ToString());
}
IRingRange oldRange = MyRange;
if (membershipRingList.Count == 1) // i'm the only one left
{
MyRange = RangeFactory.CreateFullRange();
NotifyLocalRangeSubscribers(oldRange, MyRange, true);
}
else
{
int myNewPredIndex = myNewIndex == 0 ? membershipRingList.Count - 1 : myNewIndex - 1;
int myPredecessorsHash = membershipRingList[myNewPredIndex].GetConsistentHashCode();
MyRange = RangeFactory.CreateRange(unchecked ((uint)myPredecessorsHash), unchecked ((uint)myKey));
NotifyLocalRangeSubscribers(oldRange, MyRange, true);
}
}
log.Info("Removed Server {0} hash {1}. Current view {2}", silo, silo.GetConsistentHashCode(), this.ToString());
}
}
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(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 override string ToString()
{
lock (membershipRingList)
{
if (membershipRingList.Count == 1)
{
return(Utils.EnumerableToString(membershipRingList, silo => String.Format("{0} -> {1}", silo.ToStringWithHashCode(), RangeFactory.CreateFullRange())));
}
var sb = new StringBuilder("[");
for (int i = 0; i < membershipRingList.Count; i++)
{
SiloAddress curr = membershipRingList[i];
SiloAddress next = membershipRingList[(i + 1) % membershipRingList.Count];
IRingRange range = RangeFactory.CreateRange(unchecked ((uint)curr.GetConsistentHashCode()), unchecked ((uint)next.GetConsistentHashCode()));
sb.Append(String.Format("{0} -> {1}, ", curr.ToStringWithHashCode(), range));
}
sb.Append("]");
return(sb.ToString());
}
}
/// <summary>
/// Return all rows that have their GrainReference's.GetUniformHashCode() in the range (start, end]
/// </summary>
/// <param name="begin"></param>
/// <param name="end"></param>
/// <returns></returns>
public ReminderTableData ReadRows(uint begin, uint end)
{
var range = RangeFactory.CreateRange(begin, end);
IEnumerable <GrainReference> keys = reminderTable.Keys.Where(range.InRange);
// is there a sleaker way of doing this in C#?
var list = new List <ReminderEntry>();
foreach (GrainReference k in keys)
{
list.AddRange(reminderTable[k].Values);
}
if (logger.IsVerbose3)
{
logger.Verbose3("Selected {0} out of {1} reminders from memory for {2}. List is: {3}{4}", list.Count, reminderTable.Count, range.ToString(),
Environment.NewLine, Utils.EnumerableToString(list, e => e.ToString()));
}
return(new ReminderTableData(list));
}
public bool Remove(IRingRange range)
{
bool wholerange = true;
foreach (SingleRange s in RangeFactory.GetSubRanges(range))
{
bool found = false;
foreach (SingleRange m in ranges)
{
if (m.Begin == m.End) // treat full range as special case
{
found = true;
ranges.Remove(m);
if (s.Begin != s.End) // if s is full range as well, then end of story ... whole range is covered
{
ranges.Add(RangeFactory.CreateRange(s.End, s.Begin) as SingleRange);
}
break;
}
if (m.InRange(s.Begin + 1) && m.InRange(s.End)) // s cant overlap two singleranges
{
found = true;
ranges.Remove(m);
if (s.Begin != m.Begin)
{
ranges.Add(RangeFactory.CreateRange(m.Begin, s.Begin) as SingleRange);
}
if (s.End != m.End)
{
ranges.Add(RangeFactory.CreateRange(s.End, m.End) as SingleRange);
}
break;
}
}
wholerange = wholerange && found;
}
return(wholerange);
}
