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); }