public async Task RegisterNonRepeatingReminderAsync(CancellationToken cancellationToken)
{
_reminder = await RegisterReminderAsync(nameof(ReproActor),
Array.Empty <byte>(),
TimeSpan.FromSeconds(1),
NeverRepeatReminder);
}
/// <summary>
/// This method is called whenever an actor is activated.
/// An actor is activated the first time any of its methods are invoked.
/// </summary>
protected override async Task OnActivateAsync()
{
ActorEventSource.Current.ActorMessage(this, "Actor activated.");
// The StateManager is this actor's private state store.
// Data stored in the StateManager will be replicated for high-availability for actors that use volatile or persisted state storage.
// Any serializable object can be saved in the StateManager.
// For more information, see https://aka.ms/servicefabricactorsstateserialization
ActorEventSource.Current.ActorMessage(this, "Registering the periodic reminder.");
IActorReminder reminderRegistration = await this.RegisterReminderAsync(
"FirstReminder",
BitConverter.GetBytes(1),
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(10));
ActorEventSource.Current.ActorMessage(this, "Trying to set the workflow state as Begin");
bool state = await this.StateManager.TryAddStateAsync("WorkflowState", "Begin");
if (state == false)
{
ActorEventSource.Current.ActorMessage(this, "Set WorkflowState failed as it already exists.");
}
await this.StateManager.TryAddStateAsync("count", 0);
}
public async Task <bool> Register(PlayerType requestedPlayer)
{
var gameState = await StateManager.GetStateAsync <GameState>("GameState");
var players = gameState.Players;
const int MAX_PLAYER_COUNT = 2;
if (players.Count == MAX_PLAYER_COUNT)
{
return(await Task.FromResult(false)); // TODO: consider returning exception.
}
if (players.Contains(requestedPlayer))
{
return(await Task.FromResult(false)); // TODO: consider returning exception.
}
players.Add(requestedPlayer);
if (players.Count == MAX_PLAYER_COUNT)
{
RaiseGameStartedEvent();
// Register timeout reminder
_reminderRegistration = await RegisterReminderAsync(
REMINDER_NAME,
BitConverter.GetBytes(0),
TimeSpan.FromMinutes(TIMEOUT_INTERVAL),
TimeSpan.FromMilliseconds(-1));
}
await StateManager.SetStateAsync("GameState", gameState);
return(await Task.FromResult(true));
}
public async Task ReceiveReminderAsync(string reminderName, byte[] context, TimeSpan dueTime, TimeSpan period)
{
switch (reminderName)
{
case CustomerOrderReminderNames.FulfillOrderReminder:
await this.FulfillOrderAsync();
RVSSalesActorStatus orderStatus = await this.GetOrderStatusAsync();
if (orderStatus == RVSSalesActorStatus.Shipped || orderStatus == RVSSalesActorStatus.Canceled)
{
//Remove fulfill order reminder so Actor can be gargabe collected.
IActorReminder orderReminder = this.GetReminder(CustomerOrderReminderNames.FulfillOrderReminder);
await this.UnregisterReminderAsync(orderReminder);
}
break;
default:
// We should never arrive here normally. The system won't call reminders that don't exist.
// But for our own sake in case we add a new reminder somewhere and forget to handle it, this will remind us.
throw new InvalidOperationException("Unknown reminder: " + reminderName);
}
}
async Task IRemindable.ReceiveReminderAsync(string reminderName, byte[] context, TimeSpan dueTime, TimeSpan period)
{
switch (reminderName)
{
case RegisterPatientReminderName:
await this.RegisterPatientReminder();
await RegisterHealthReportReminder();
await this.UnregisterReminderAsync(this.registrationReminder);
this.registrationReminder = null;
break;
case GenerateAndSendHealthReportReminderName:
await this.GenerateAndSendHealthReportAsync();
break;
default:
//ActorEventSource.Current.Message("Reminder {0} is not implemented on BandActor.", reminderName);
break;
}
return;
}
protected override async Task OnActivateAsync()
{
await base.OnActivateAsync();
IActorReminder reminderRegistration = await RegisterReminderAsync("Reminder", BitConverter.GetBytes(100), TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(10));
return;
}
/// <remarks>
/// Do nothing by design. We just need to make sure that the actor is properly activated.
/// </remarks>>
public async Task Run()
{
_wakeupReminder = await this.RegisterReminderAsync(
WakeUpReminderName,
null,
TimeSpan.FromMinutes(15),
TimeSpan.FromMinutes(15));
}
public ActorReminderData(ActorId actorId, IActorReminder reminder, TimeSpan logicalCreationTime)
{
this.ActorId = actorId;
this.Name = reminder.Name;
this.DueTime = reminder.DueTime;
this.Period = reminder.Period;
this.State = reminder.State;
this.LogicalCreationTime = logicalCreationTime;
}
Task IActorStateProvider.SaveReminderAsync(ActorId actorId, IActorReminder state, CancellationToken cancellationToken)
{
var key = CreateReminderStorageKey(actorId, state.Name);
var reminderData = new ActorReminderData(actorId, state, TimeSpan.Zero);
this.stateDictionary.AddOrUpdate(key, reminderData, (s, o) => reminderData);
return(Task.FromResult(true));
}
public MockActorReminderData(ActorId actorId, IActorReminder reminder, TimeSpan logicalCreationTime)
{
ActorId = actorId;
Name = reminder.Name;
DueTime = reminder.DueTime;
Period = reminder.Period;
State = reminder.State;
LogicalCreationTime = logicalCreationTime;
}
public async Task OnActivateAsync()
{
//fix an issue when manually overwriting the reminder with custom interval being reset because actor is balancing between nodes
var isDefaultReminder = (((await StateManager.GetStateNamesAsync()).FirstOrDefault(x => x == REMINDER_SCHEDULE)) == null);
if (isDefaultReminder)
{
ActorReminder = await RegisterReminderAsync(REMINDER_SCHEDULE, null, TimeSpan.FromSeconds(5), TimeSpan.FromMinutes(1));
}
}
public ActorReminder(ActorId actorId, IActorManager actorManager, IActorReminder reminder)
: this(
actorId,
actorManager,
reminder.Name,
reminder.State,
reminder.DueTime,
reminder.Period)
{
}
public Task SaveReminderAsync(ActorId actorId, IActorReminder reminder,
CancellationToken cancellationToken = new CancellationToken())
{
var utcNow = DateTime.UtcNow;
var timeOfDay = utcNow.TimeOfDay;
var reminderState = new MockActorReminderState(new MockActorReminderData(actorId, reminder, timeOfDay), timeOfDay);
_reminders.Add(actorId, reminderState);
return(Task.FromResult(reminderState));
}
private async Task RegisterKillMeReminder()
{
IActorReminder reminderRegistration = await this.RegisterReminderAsync(
$"Kill.Me",
null,
TimeSpan.FromMinutes(15), //The amount of time to delay before firing the reminder
TimeSpan.FromMinutes(15) //The time interval between firing of reminders
);
//TODO telemetry
}
public async Task TryUnregisterReminderAsync(string reminderName)
{
try
{
IActorReminder reminder = GetReminder(reminderName);
await UnregisterReminderAsync(reminder);
}
catch (ReminderNotFoundException)
{
}
}
private async Task RegisterWorkflowReminder()
{
IActorReminder reminderRegistration = await this.RegisterReminderAsync(
WorkflowReminderKey,
null,
TimeSpan.FromSeconds(5), //The amount of time to delay before firing the reminder
TimeSpan.FromSeconds(15) //The time interval between firing of reminders
);
//TODO telemetry
}
/// <inheritdoc />
public Task <bool> IsReminderRegisteredAsync(string reminderName)
{
IActorReminder reminder = null;
try
{
reminder = GetReminder(reminderName);
}
catch (ReminderNotFoundException)
{
//not found...
}
return(Task.FromResult(reminder != null));
}
protected override Task OnDeactivateAsync()
{
// Timer unregistration.
if (mTimer != null)
{
this.UnregisterTimer(mTimer);
}
// Reminder unregistration.
IActorReminder reminder = GetReminder("Task");
UnregisterReminderAsync(reminder);
return(base.OnDeactivateAsync());
}
private async Task <bool> ReminderUnRegistered(string reminderName)
{
try
{
IActorReminder reminder = GetReminder(reminderName);
await UnregisterReminderAsync(reminder);
return(true);
}
catch (Exception ex)
{
//TODO telemetry
return(false);
}
}
protected override Task OnActivateAsync()
{
base.OnActivateAsync();
try
{
_reminder = GetReminder(nameof(ReproActor));
}
catch (ReminderNotFoundException rmne)
{
//squelch purposely here
//if this reminder was not set before the actor was deactivated, then this exception is thrown
//if this reminder had been set before the actor was deactivated, then no exception need be caught
}
return(Task.CompletedTask);
}
/// <summary>
/// This method is called whenever an actor is activated.
/// An actor is activated the first time any of its methods are invoked.
/// </summary>
protected override async Task OnActivateAsync()
{
ActorEventSource.Current.ActorMessage(this, "@BankAccount.OnActivateAsync for account '{0}'", Id.GetStringId());
// Add state if it doesn't exist. doesn't fail if state already exists
StateManager.TryAddStateAsync("AccountState", null as BankAccountState).GetAwaiter().GetResult();
// register a reminder
//Question: should this be in constructor? if Reminders are persisted, they shouldn't have to be created on Activation...?
IActorReminder actorReminder = await this.RegisterReminderAsync(
"process standing orders", // reminder name
null, // parameter to reminder - must be byte[]
TimeSpan.FromSeconds(5), // Amount of time to delay before the reminder is invoked
TimeSpan.FromMinutes(1)); // Time interval between invocations of the reminder method
return;
}
protected override async Task OnActivateAsync()
{
////ActorEventSource.Current.ActorMessage(this, "Actor activated.");
//// The StateManager is this actor's private state store.
//// Data stored in the StateManager will be replicated for high-availability for actors that use volatile or persisted state storage.
//// Any serializable object can be saved in the StateManager.
//// For more information, see https://aka.ms/servicefabricactorsstateserialization
//// return this.StateManager.TryAddStateAsync("count", 0);
////var schedulerDtos = GetSchedulerList();
await base.OnActivateAsync();
ActorEventSource.Current.ActorMessage(this, "Actor activated.");
IActorReminder generationReminderRegistration = await this.RegisterReminderAsync(GenerationRemainder, BitConverter.GetBytes(100), TimeSpan.FromMilliseconds(0), TimeSpan.FromMinutes(10));
////IActorReminder mailReminderRegistration = await this.RegisterReminderAsync(generationRemainder, BitConverter.GetBytes(100), TimeSpan.FromMinutes(1), TimeSpan.FromHours(1));
return;
}
public Task SaveReminderAsync(ActorId actorId, IActorReminder reminder,
CancellationToken cancellationToken = new CancellationToken())
{
ActionsPerformed.Add(nameof(SaveReminderAsync));
if (_trackedActors.ContainsKey(actorId))
{
var actorState = _trackedActors[actorId];
actorState.Reminders.Add(reminder.Name, reminder);
}
else
{
var actorState = new MockedInternalActorState();
actorState.Reminders.Add(reminder.Name, reminder);
_trackedActors.Add(actorId, actorState);
}
return(Task.FromResult(true));
}
private async Task RegisterKillMeReminder()
{
try
{
IActorReminder reminderRegistration = await this.RegisterReminderAsync(
KillMeReminderKey,
null,
TimeSpan.FromMinutes(15), //The amount of time to delay before firing the reminder
TimeSpan.FromMinutes(15) //The time interval between firing of reminders
);
//TODO telemetry
}
catch (Exception ex)
{
Debugger.Break();
}
}
/// <summary>
/// Unregisters the specified reminder.
/// </summary>
/// <param name="reminder">IActorReminder</param>
/// <returns>Task</returns>
protected Task UnregisterReminderAsync(IActorReminder reminder)
{
ActorModel.Assert(reminder != null, "Cannot unregister a 'null' reminder.");
var reminders = ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId());
var reminderToBeRemoved = reminders.SingleOrDefault(val
=> ((ActorReminder)val).Name.Equals(reminder.Name));
if (reminderToBeRemoved != null)
{
reminderToBeRemoved.Dispose();
}
var task = new ActorCompletionTask <object>();
var actorCompletionMachine = task.ActorCompletionMachine;
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(true));
return(task);
}
private async Task <bool> Start()
{
string currentState = await this.StateManager.GetStateAsync <string>("WorkflowState");
if (currentState == "Begin")
{
// take some action
await this.StateManager.TryAddStateAsync("Temp", 0);
await this.StateManager.AddOrUpdateStateAsync("WorkflowState", "Begin", (key, value) => "InProgress");
}
if (currentState == "InProgress")
{
// do some other work
int temp = await this.StateManager.GetStateAsync <int>("Temp");
++temp;
await this.StateManager.AddOrUpdateStateAsync("Temp", 0, (key, value) => temp > value?temp : value);
if (temp >= 5)
{
await this.StateManager.AddOrUpdateStateAsync("WorkflowState", "Begin", (key, value) => "Completed");
}
}
if (currentState == "Completed")
{
IActorReminder reminder = GetReminder("FirstReminder");
await UnregisterReminderAsync(reminder);
ActorEventSource.Current.ActorMessage(this, "Successfully unregistered the reminder.");
}
ActorEventSource.Current.ActorMessage(this, "Successfully executed the Actor lifecycle.");
return(true);
}
private async Task <bool> StartOld()
{
int currentValue = await this.StateManager.GetStateAsync <int>("count");
if (currentValue > 5)
{
IActorReminder reminder = GetReminder("FirstReminder");
await UnregisterReminderAsync(reminder);
ActorEventSource.Current.ActorMessage(this, "Successfully unregistered the reminder.");
return(true);
}
int newValue = currentValue + 1;
await this.StateManager.AddOrUpdateStateAsync("count", newValue, (key, value) => newValue);
ActorEventSource.Current.ActorMessage(this, "Successfully incremented the value of state.");
return(true);
}
async Task IActorStateProvider.SaveReminderAsync(ActorId actorId, IActorReminder reminder, CancellationToken cancellationToken)
{
await this.EnsureStateProviderInitializedAsync(cancellationToken);
var key = CreateStorageKey(actorId, reminder.Name);
var reminderData = new ActorReminderData(actorId, reminder, this.logicalTimeManager.CurrentLogicalTime);
var data = ActorReminderDataSerializer.Serialize(reminderData);
await this.stateProviderHelper.ExecuteWithRetriesAsync(
async() =>
{
using (var tx = this.stateManager.CreateTransaction())
{
await this.GetReminderDictionary(actorId).AddOrUpdateAsync(tx, key, data, (rowKey, rowValue) => data);
await this.reminderCompletedDictionary.TryRemoveAsync(tx, key);
await tx.CommitAsync();
}
},
string.Format("SaveReminderAsync[{0}]", actorId),
cancellationToken);
}
/// <summary>
/// Unregisters a reminder previously registered using <see cref="Dapr.Actors.Runtime.Actor.RegisterReminderAsync" />.
/// </summary>
/// <param name="reminder">The actor reminder to unregister.</param>
/// <returns>
/// Returns a task that represents the asynchronous unregistration operation.
/// </returns>
protected Task UnregisterReminderAsync(IActorReminder reminder)
{
return(ActorRuntime.DaprInteractor.UnregisterReminderAsync(this.actorTypeName, this.Id.ToString(), reminder.Name));
}
/// <inheritdoc/>
public async Task RegisterReminder()
{
this.reminder = await this.remindableWrapper.RegisterReminderAsync("Test", null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5));
}
