/// <summary>
/// Attempt to retrieve reminders, that are my responsibility, from the global reminder table when starting this silo (reminder service instance)
/// </summary>
/// <returns></returns>
public async Task Start()
{
myRange = ring.GetMyRange();
logger.Info(ErrorCode.RS_ServiceStarting, "Starting reminder system target on: {0} x{1,8:X8}, with range {2}", Silo, Silo.GetConsistentHashCode(), myRange);
await reminderTable.Init(config, logger).WithTimeout(initTimeout);
await ReadAndUpdateReminders();
logger.Info(ErrorCode.RS_ServiceStarted, "Reminder system target started OK on: {0} x{1,8:X8}, with range {2}", Silo, Silo.GetConsistentHashCode(), myRange);
status = ReminderServiceStatus.Started;
startedTask.TrySetResult(true);
var random = new SafeRandom();
var dueTime = random.NextTimeSpan(Constants.RefreshReminderList);
listRefresher = GrainTimer.FromTaskCallback(
_ => ReadAndUpdateReminders(),
null,
dueTime,
Constants.RefreshReminderList,
name: "ReminderService.ReminderListRefresher");
listRefresher.Start();
ring.SubscribeToRangeChangeEvents(this);
}
private void PromoteToStarted()
{
if (StoppedCancellationTokenSource.IsCancellationRequested)
{
return;
}
// Logger.Info(ErrorCode.RS_ServiceStarted, "Reminder system target started OK on: {0} x{1,8:X8}, with range {2}", this.Silo, this.Silo.GetConsistentHashCode(), this.myRange);
var random = new SafeRandom();
var dueTime = random.NextTimeSpan(Constants.RefreshReminderList);
if (listRefreshTimer != null)
{
listRefreshTimer.Dispose();
}
listRefreshTimer = GrainTimer.FromTaskCallback(
this.RuntimeClient.Scheduler,
_ => ReadAndUpdateReminders(),
null,
dueTime,
Constants.RefreshReminderList,
name: "ReminderService.ReminderListRefresher");
listRefreshTimer.Start();
Status = GrainServiceStatus.Started;
startedTask.TrySetResult(true);
}
/// <summary>
/// Attempt to retrieve reminders, that are my responsibility, from the global reminder table when starting this silo (reminder service instance)
/// </summary>
/// <returns></returns>
public async Task Start()
{
myRange = ring.GetMyRange();
logger.Info(ErrorCode.RS_ServiceStarting, "Starting reminder system target on: {0} x{1,8:X8}, with range {2}", Silo, Silo.GetConsistentHashCode(), myRange);
// in case reminderTable is as grain, poke the grain to activate it, before slamming it with multipel parallel requests, which may create duplicate activations.
await reminderTable.Init();
await ReadAndUpdateReminders();
logger.Info(ErrorCode.RS_ServiceStarted, "Reminder system target started OK on: {0} x{1,8:X8}, with range {2}", Silo, Silo.GetConsistentHashCode(), myRange);
status = ReminderServiceStatus.Started;
startedTask.TrySetResult(true);
var random = new SafeRandom();
var dueTime = random.NextTimeSpan(Constants.RefreshReminderList);
listRefresher = GrainTimer.FromTaskCallback(
_ => ReadAndUpdateReminders(),
null,
dueTime,
Constants.RefreshReminderList,
name: "ReminderService.ReminderListRefresher");
listRefresher.Start();
ring.SubscribeToRangeChangeEvents(this);
}
public IDisposable RegisterTimer(Func <object, Task> asyncCallback, object state, TimeSpan dueTime, TimeSpan period)
{
var timer = GrainTimer.FromTaskCallback(asyncCallback, state, dueTime, period);
timer.Start();
return(timer);
}
public IDisposable RegisterTimer(Grain grain, Func <object, Task> asyncCallback, object state, TimeSpan dueTime, TimeSpan period)
{
var timer = GrainTimer.FromTaskCallback(this.scheduler, this.timerLogger, asyncCallback, state, dueTime, period, activationData: grain?.Data);
grain?.Data.OnTimerCreated(timer);
timer.Start();
return(timer);
}
public IDisposable RegisterTimer(IGrainContext grainContext, Func <object, Task> asyncCallback, object state, TimeSpan dueTime, TimeSpan period)
{
var timer = GrainTimer.FromTaskCallback(this.timerLogger, asyncCallback, state, dueTime, period, grainContext: grainContext);
grainContext?.GetComponent <IGrainTimerRegistry>().OnTimerCreated(timer);
timer.Start();
return(timer);
}
public void StartTimer(OrleansTaskScheduler scheduler, Func <object, Task> asyncCallback, Logger Logger)
{
StopReminder(Logger); // just to make sure.
var dueTimeSpan = CalculateDueTime();
Timer = GrainTimer.FromTaskCallback(scheduler, asyncCallback, this, dueTimeSpan, period, name: ReminderName);
if (Logger.IsVerbose)
{
Logger.Verbose("Reminder {0}, Due time{1}", this, dueTimeSpan);
}
Timer.Start();
}
public void StartTimer(Func <object, Task> asyncCallback, TraceLogger logger)
{
StopReminder(logger); // just to make sure.
var dueTimeSpan = CalculateDueTime();
Timer = GrainTimer.FromTaskCallback(asyncCallback, this, dueTimeSpan, period, name: ReminderName);
if (logger.IsVerbose)
{
logger.Verbose("Reminder {0}, Due time{1}", this, dueTimeSpan);
}
Timer.Start();
}
protected override async Task StartInBackground()
{
await DoInitialReadAndUpdateReminders();
if (Status == GrainServiceStatus.Booting)
{
var random = new SafeRandom();
listRefreshTimer = GrainTimer.FromTaskCallback(
_ => DoInitialReadAndUpdateReminders(),
null,
random.NextTimeSpan(InitialReadRetryPeriod),
InitialReadRetryPeriod,
name: "ReminderService.ReminderListInitialRead");
listRefreshTimer.Start();
}
}
public Task Start()
{
requestProcessor = GrainTimer.FromTaskCallback(this.RuntimeClient.Scheduler, this.loggerFactory.CreateLogger <GrainTimer>(), ProcessRequests, null, TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(10), "TransactionAgent");
requestProcessor.Start();
return(Task.CompletedTask);
}