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