Example #1
0
        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);
                });
            }));

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

            var 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)));
        }
Example #2
0
        public async Task <List <IGrainReminder> > GetReminders(GrainReference grainRef)
        {
            if (logger.IsEnabled(LogLevel.Debug))
            {
                logger.Debug(ErrorCode.RS_GetReminders, "GetReminders: GrainReference={0}", grainRef.ToString());
            }
            var tableData = await reminderTable.ReadRows(grainRef);

            return(tableData.Reminders.Select(entry => entry.ToIGrainReminder()).ToList());
        }
Example #3
0
        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");
        }
        public async Task<Immutable<ReminderResponse>> GetReminders(int pageNumber, int pageSize)
        {
            if (_reminderTable == null)
            {
                return EmptyReminders;
            }

            var reminderData = await _reminderTable.ReadRows(0, 0xffffffff);

            if(!reminderData.Reminders.Any())
            {
                return EmptyReminders;
            }

            return new ReminderResponse
            {
                Reminders = reminderData
                    .Reminders
                    .OrderBy(x => x.StartAt)
                    .Skip((pageNumber - 1) * pageSize)
                    .Take(pageSize)
                    .Select(ToReminderInfo)
                    .ToArray(),

                Count = reminderData.Reminders.Count
            }.AsImmutable();
        }
Example #6
0
        private async Task TestRemindersHashInterval(IReminderTable reminderTable, uint beginHash, uint endHash,
                                                     uint[] remindersHashes)
        {
            var rowsTask       = reminderTable.ReadRows(beginHash, endHash);
            var expectedHashes = beginHash < endHash
                ? remindersHashes.Where(r => r > beginHash && r <= endHash)
                : remindersHashes.Where(r => r > beginHash || r <= endHash);

            HashSet <uint> expectedSet    = new HashSet <uint>(expectedHashes);
            var            returnedHashes = (await rowsTask).Reminders.Select(r => r.GrainRef.GetUniformHashCode());
            var            returnedSet    = new HashSet <uint>(returnedHashes);

            Assert.True(returnedSet.SetEquals(expectedSet));
        }
        private static async Task TestRemindersHashInterval(IReminderTable reminderTable, uint beginHash, uint endHash,
            uint[] remindersHashes)
        {
            var rowsTask = reminderTable.ReadRows(beginHash, endHash);
            var expectedHashes = beginHash < endHash
                ? remindersHashes.Where(r => r > beginHash && r <= endHash)
                : remindersHashes.Where(r => r > beginHash || r <= endHash);

            HashSet<uint> expectedSet = new HashSet<uint>(expectedHashes);
            var returnedHashes = (await rowsTask).Reminders.Select(r => r.GrainRef.GetUniformHashCode());
            var returnedSet = new HashSet<uint>(returnedHashes);

            Assert.IsTrue(returnedSet.SetEquals(expectedSet));
        }
Example #8
0
        internal async Task RemindersRange(int iterations = 1000)
        {
            await Task.WhenAll(Enumerable.Range(1, iterations).Select(async i =>
            {
                GrainReference grainRef = MakeTestGrainReference();
                await remindersTable.UpsertRow(CreateReminder(grainRef, i.ToString()));
            }));

            var rows = await remindersTable.ReadRows(0, uint.MaxValue);

            Assert.AreEqual(rows.Reminders.Count, iterations);

            rows = await remindersTable.ReadRows(0, 0);

            Assert.AreEqual(rows.Reminders.Count, iterations);

            var 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)));
        }
Example #9
0
        public async Task <ReminderResponse> GetReminders(int pageNumber, int pageSize)
        {
            var reminderData = await _reminderTable.ReadRows(0, 0xffffffff);

            return(new ReminderResponse {
                Reminders = reminderData
                            .Reminders
                            .OrderBy(x => x.StartAt)
                            .Skip((pageNumber - 1) * pageSize)
                            .Take(pageSize)
                            .Select(ToReminderInfo)
                            .ToArray(),

                Count = reminderData.Reminders.Count
            });
        }
        private async Task <IEnumerable <ReminderEntry> > GetAllRows(IReminderTable table)
        {
            ReminderTableData data = await table.ReadRows(0, 0xffffffff);

            return(data.Reminders);
        }
 private async Task<IEnumerable<ReminderEntry>> GetAllRows(IReminderTable table)
 {
     ReminderTableData data = await table.ReadRows(0, 0xffffffff);
     return data.Reminders;
 }