public async Task <bool> SimulateMatch(List <UserRequest> players, ActorInfo actorInfo) { if (players[0].EndAfterSeconds && players[1].EndAfterSeconds) { _updateTimer = RegisterTimer(Update, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)); } bool added = await this.StateManager.TryAddStateAsync <int>(IndexName, actorInfo.ActorIndex); if (!added) { // value already exists, which means processing has already started. throw new InvalidOperationException($"Cannot assign index {actorInfo.ActorIndex} to actor!"); } added = await this.StateManager.TryAddStateAsync <GameState>(GameStateName, new GameState(players)); if (!added) { // value already exists, which means processing has already started. throw new InvalidOperationException("Processing for this actor has already started."); } return(true); }
protected override Task OnActivateAsync() { _actortimer = RegisterTimer(DoWork, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(15) ); ActorEventSource.Current.ActorMessage(this, "Actor activated."); return(this.StateManager.TryAddStateAsync("count", 0)); }
protected override Task OnActivateAsync() { this.StateManager.AddStateAsync<TermiteState>("State", new TermiteState { X = rand.Next(0, size), Y = rand.Next(0, size), HasWoodchip = false }); mTimer = RegisterTimer(Move, this.StateManager.GetStateAsync<TermiteState>("State"), TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(50)); boxClient = ServiceProxy.Create<IBox>(new Uri("fabric:/TermiteModel/Box"), new ServicePartitionKey(0)); return Task.FromResult(true); }
public virtual async Task <string> OnCreated(string id, string json, CancellationToken cancellationToken) { await this.StateManager.SetStateAsync <string>(MyInstance, json, cancellationToken); await this.StateManager.SetStateAsync <string>(IdKey, id, cancellationToken); var switches = await this.StateManager.GetStateAsync <Dictionary <string, string> >(SwitchesKey); ensureHandler(switches); var extendedState = await mHandler.OnCreated(id, json, switches); if (extendedState.Succeeded == true) { if (!string.IsNullOrEmpty(extendedState.UpdatedState)) { await this.StateManager.SetStateAsync <string>(MyState, extendedState.UpdatedState, cancellationToken); } if (!string.IsNullOrEmpty(extendedState.UpdatedEntity)) { await this.StateManager.SetStateAsync <string>(MyInstance, extendedState.UpdatedEntity, cancellationToken); } updateTimer = RegisterTimer( WatchStatusAsync, // Callback method extendedState.UpdatedState, // Parameter to pass to the callback method TimeSpan.FromSeconds(3), // Amount of time to delay before the callback is invoked TimeSpan.FromSeconds(3)); // Time interval between invocations of the callback method } return(extendedState.UpdatedEntity); }
private async Task SendPings() { this.SendCounter++; ActorEventSource.Current.ActorMessage(this, "[FailureDetector] Wants to send some pings"); foreach (var node in this.Nodes) { ActorEventSource.Current.ActorMessage(this, "[FailureDetector] Wants to send ping to node {0}", node.Key); ActorEventSource.Current.ActorMessage(this, "[FailureDetector] Alive {0}", this.Alive.ContainsKey(node.Value)); ActorEventSource.Current.ActorMessage(this, "[FailureDetector] Responses {0}", this.Responses.ContainsKey(node.Value)); if (this.Alive.ContainsKey(node.Value) && !this.Responses.ContainsKey(node.Value)) { ActorEventSource.Current.ActorMessage(this, "[FailureDetector] Sending ping to node {0}", node.Key); ActorEventSource.Current.ActorMessage(this, "[Monitor] Notifies ping to node {0}", node.Key); await SafetyMonitor.NotifyPing(node.Key); await node.Value.Ping(PingCounter ++, this.FailureDetectorId); } } this.Timer = this.RegisterTimer(HandleTimeout, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)); }
protected override async Task OnActivateAsync() { try { await this.StateManager.TryAddStateAsync <Dictionary <int, ProductStockTrend> >("ProductStockTrends", new Dictionary <int, ProductStockTrend>()); TimeSpan startDelay = TimeSpan.Parse(ConfigurationHelper.ReadValue("AppSettings", "PredictionTimerStartDelay")); TimeSpan interval = TimeSpan.Parse(ConfigurationHelper.ReadValue("AppSettings", "PredictionTimerInterval")); if (!int.TryParse(ConfigurationHelper.ReadValue("AppSettings", "PredictionNotificationAttempts"), out this.notificationAttempts)) { this.notificationAttempts = 10; } // register timer to regularly check for updates this.notificationTimer = this.RegisterTimer( this.RunNotificationAsync, null, startDelay, interval ); this.mlClient = AzureMlClientFactory.CreateClient(); await base.OnActivateAsync(); } catch (Exception ex) { Logger.Error(ex, nameof(this.OnActivateAsync)); throw; } }
/// <summary> /// This method is called whenever an actor is activated. /// Creates the initial state object and starts the Message forwarding timer. /// </summary> protected override async Task OnActivateAsync() { if (Id.Kind != ActorIdKind.String) { throw new InvalidOperationException("BrokerActor can only be created using a String ID. The ID should be the Full Name of the Message Type."); } _messageType = Id.GetStringId(); if (!await StateManager.ContainsStateAsync(StateKey)) { // This is the first time this actor has ever been activated. // Set the actor's initial state values. var state = new BrokerActorState { SubscriberMessages = new Dictionary <ReferenceWrapper, Queue <MessageWrapper> >(), SubscriberDeadLetters = new Dictionary <ReferenceWrapper, Queue <MessageWrapper> >() }; await StateManager.TryAddStateAsync(StateKey, state); ActorEventSourceMessage("State initialized."); } if (_timer == null) { _timer = RegisterTimer(async _ => { await ProcessQueuesAsync(); }, null, DueTime, Period); ActorEventSourceMessage("Timer initialized."); } }
/// <summary> /// Shutdowns the dispatcher /// </summary> internal static void Shutdown() { if (m_oneSecondTimer != null) { m_oneSecondTimer.Stop(); m_oneSecondTimer = null; } }
/// <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 Task OnActivateAsync() { ActorEventSource.Current.ActorMessage(this, "Actor activated."); EchoTimer = RegisterTimer(OnTimer, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10)); return(Task.FromResult(0)); }
private async Task InternalHandle(object _) { var handle = string.Empty; try { UnregisterTimer(_handleTimer); var handleList = (await StateManager.GetStateNamesAsync()).ToList(); if (!handleList.Any()) { return; } var messageDataConditional = await StateManager.TryGetStateAsync <MessageData>(handleList.First()); if (!messageDataConditional.HasValue) { _bigBrother.Publish(new WebhookEvent("message was empty")); return; } var messageData = messageDataConditional.Value; handle = messageData.HandleAsString; var handler = _eventHandlerFactory.CreateEventHandler(messageData.Type); await handler.Call(messageData); await StateManager.RemoveStateAsync(messageData.HandleAsString); await ActorProxy.Create <IPoolManagerActor>(new ActorId(0)).CompleteWork(messageData.Handle); } catch (Exception e) { //don't want msg state managed by fabric just yet, let failures be backed by the service bus subscriptions if (handle != string.Empty) { await StateManager.RemoveStateAsync(handle); } BigBrother.Write(e.ToExceptionEvent()); } finally { //restarts the timer in case there are more than one msg in the state, if not then let it be restarted in the standard msg population flow. if ((await StateManager.GetStateNamesAsync()).Any()) { _handleTimer = RegisterTimer( InternalHandle, null, TimeSpan.FromMilliseconds(100), TimeSpan.MaxValue); } } }
/// <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 Task OnActivateAsync() { _updateTimer = RegisterTimer( MoveObject, // Callback method null, // Parameter to pass to the callback method TimeSpan.FromMilliseconds(500), // Amount of time to delay before the callback is invoked TimeSpan.FromMilliseconds(500)); // Time interval between invocations of the callback method return(base.OnActivateAsync()); }
protected override Task OnActivateAsync() { ActorEventSource.Current.ActorMessage(this, "Actor activated."); mTimer = this.RegisterTimer(Move, //callback function null, //callback state TimeSpan.FromSeconds(5), //delay before first callback TimeSpan.FromSeconds(1)); //callback interval return(this.StateManager.TryAddStateAsync("My-Location", new Tuple <double, double>(-122.041934, 47.694861))); }
/// <summary> /// Unregisters a Timer previously set on this actor. /// </summary> /// <param name="timer">An IActorTimer representing timer that needs to be unregistered.</param> /// <returns>Task representing the Unregister timer operation.</returns> protected async Task UnregisterTimerAsync(IActorTimer timer) { await ActorRuntime.DaprInteractor.UnregisterTimerAsync(this.actorTypeName, this.Id.ToString(), timer.Name); if (this.timers.ContainsKey(timer.Name)) { this.timers.Remove(timer.Name); } }
/// <summary> /// Shutdowns the dispatcher. /// </summary> internal static void Shutdown() { if (m_oneSecondTimer == null) { return; } m_oneSecondTimer.Stop(); m_oneSecondTimer = null; }
protected override async Task OnDeactivateAsync() { if (this.Timer != null) { this.UnregisterTimer(this.Timer); this.Timer = null; } await base.OnDeactivateAsync(); }
/// <summary> /// Unregisters a Timer previously set on this actor. /// </summary> /// <param name="timer">IActorTimer representing timer that needs to be unregistered..</param> protected void UnregisterTimer(IActorTimer timer) { if ((timer != null) && (this.timers != null)) { if (this.timers.Remove(timer)) { timer.Dispose(); } } }
/// <summary> /// This method is called right before the actor is deactivated. /// Unregisters the timer. /// </summary> /// <returns> /// A <see cref="T:System.Threading.Tasks.Task">Task</see> that represents outstanding OnDeactivateAsync operation. /// </returns> protected override Task OnDeactivateAsync() { if (_timer != null) { UnregisterTimer(_timer); } _timer = null; return(Task.FromResult(true)); }
public async Task Handle(MessageData messageData) { await StateManager.AddOrUpdateStateAsync(messageData.HandlerId.ToString(), messageData, (s, pair) => pair); _handleTimer = RegisterTimer( InternalHandle, messageData, TimeSpan.FromMilliseconds(100), TimeSpan.MaxValue); }
protected override Task OnDeactivateAsync() { if (m_WorkTimer != null) { UnregisterTimer(m_WorkTimer); m_WorkTimer = null; } m_tc.TrackEvent($"OnDeactivateAsync - {this.GetActorId().ToString()}, Timers Stop"); m_tc.Flush(); return(base.OnDeactivateAsync()); }
protected override Task OnActivateAsync() { if (this.State == null) { this.State = new TermiteState { X = rand.Next(0, size), Y = rand.Next(0, size), HasWoodchip = false }; } mTimer = RegisterTimer(Move, this.State, TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(50)); return(Task.FromResult(true)); }
protected override async Task OnDeactivateAsync() { if (_Timer != null) { UnregisterTimer(_Timer); _Timer = null; } ActorId StatId = new ActorId(1); await StatId.Proxy <IStatistics>().UpdateStats("Gate", _StatDict); await base.OnDeactivateAsync(); }
protected override Task OnActivateAsync() { if (this.State == null) { this.State = new ActorState { PartitionNames = new List <string>(), PartitionLeases = new Dictionary <string, DateTime>() }; ResetPartitionNames(); mTimer = RegisterTimer(CheckLease, null, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30)); } return(Task.FromResult(true)); }
protected override Task OnActivateAsync() { // Start timer that will try to register the reminder every 10 seconds until it succeeds or // the specified number of retries is made. this._reminderRegistrationTimer = this.RegisterTimer( asyncCallback: state => this.RegisterWakeUpReminderTimerCallbackAsync(), state: null, dueTime: TimeSpan.FromMilliseconds(ReminderRegistrationRetryIntervalMilliseconds), period: TimeSpan.FromMilliseconds(ReminderRegistrationRetryIntervalMilliseconds)); return(Task.CompletedTask); }
protected override Task OnActivateAsync() { if (this.State == null) { this.State = VisualObject.CreateRandom(this.Id.ToString(), new Random(this.Id.ToString().GetHashCode())); } this.jsonString = this.State.ToJson(); // ACTOR MOVEMENT REFRESH this.updateTimer = this.RegisterTimer(this.MoveObject, null, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(10)); return(base.OnActivateAsync()); }
protected override async Task OnActivateAsync() { ActorEventSource.Current.ActorMessage(this, "Actor activated."); var assetPairs = await _dictionaryProxy.GetAssetPairsAsync(); await _assetPairQuoteRepository.AddAllAsync(assetPairs); await StateManager.TryAddStateAsync("AssetPairs", assetPairs); _updateAssetTimer = RegisterTimer(UpdateAssetPairAsync, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10)); }
protected override async Task OnActivateAsync() { await StateManager.SetStateAsync(Constants.ActivatedStateName, true); await StateManager.SetStateAsync(Constants.LastUpdatedStateName, DateTimeOffset.UtcNow); _updateTimer = RegisterTimer( OnUpdateCheckAsync, // Callback method null, // Parameter to pass to the callback method TimeSpan.FromMinutes(0), // Amount of time to delay before the callback is invoked TimeSpan.FromSeconds(10)); // Time interval between invocations of the callback method }
public async Task <GenericResponse> RegisterObserver(ActorId playerAgentID, ActorId[] fromActors) { var players = await this.StateManager.GetStateAsync <Dictionary <ActorId, MinecraftVersion> >("observers"); var version = MinecraftVersion.GetNext(); //Is player already here? if (players.ContainsKey(playerAgentID) == true) { return(new GenericResponse(true, "Already Exist")); } //this player want to listen to all associated blocks var initPlayers = await this.StateManager.GetStateAsync <Dictionary <ActorId, MinecraftVersion> >("initializeObservers"); initPlayers.Add(playerAgentID, version); await this.StateManager.SetStateAsync("initializeObservers", initPlayers); //map to hash for faster lookup var map = new HashSet <ActorId>(); foreach (var actor in fromActors) { map.Add(actor); } var associations = await this.StateManager.GetStateAsync <Dictionary <ActorId, AssociateChunkMetaData> >("associations"); //each associated grain needs to update this one foreach (var pair in associations) { var actorID = pair.Key; if (map.Contains(actorID) == false) { var assocations = pair.Value; assocations.needInitObservers.Add(actorID); } } await this.StateManager.SetStateAsync("associations", associations); //if no updates are occuring, now we have a player to update if (_updateTimer == null) { int updateRate = await this.StateManager.GetStateAsync <int>("updateRateMS"); _updateTimer = RegisterTimer((_) => Fetch(), null, TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(updateRate)); } return(new GenericResponse()); }
/// <summary> /// Schedules the given action using an actor timer. /// </summary> /// <param name="action"></param> protected void InvokeWithTimer(Func <Task> action) { Contract.Requires <ArgumentNullException>(action != null); // hoist timer so it can be unregistered IActorTimer timer = null; // schedule timer timer = RegisterTimer( async o => { UnregisterTimer(timer); await action(); }, null, TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(-1)); }
protected override async Task OnActivateAsync() { VisualObject newObject = VisualObject.CreateRandom(this.Id.ToString()); ActorEventSource.Current.ActorMessage(this, "StateCheck {0}", (await this.StateManager.ContainsStateAsync(StatePropertyName)).ToString()); VisualObject result = await this.StateManager.GetOrAddStateAsync <VisualObject>(StatePropertyName, newObject); this.jsonString = result.ToJson(); // ACTOR MOVEMENT REFRESH this.updateTimer = this.RegisterTimer(this.MoveObject, null, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(10)); return; }
protected override async Task OnActivateAsync() { VisualObject newObject = VisualObject.CreateRandom(this.Id.ToString()); ActorEventSource.Current.ActorMessage(this, "StateCheck {0}", (await this.StateManager.ContainsStateAsync(StatePropertyName)).ToString()); VisualObject result = await this.StateManager.GetOrAddStateAsync<VisualObject>(StatePropertyName, newObject); this.jsonString = result.ToJson(); // ACTOR MOVEMENT REFRESH this.updateTimer = this.RegisterTimer(this.MoveObject, null, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(10)); return; }
public Task RegisterTimerAsync(int delayInSecond) { m_delayInSecond = delayInSecond; this.StateManager.SetStateAsync <int>("m_delayInSecond", m_delayInSecond); m_tc.TrackEvent($"RegisterTimerAsync - {this.GetActorId().ToString()}, {m_delayInSecond}"); m_tc.Flush(); if (m_WorkTimer != null) { UnregisterTimer(m_WorkTimer); m_WorkTimer = null; } m_WorkTimer = RegisterTimer(doWorkInTimerAsync, null, TimeSpan.FromSeconds(delayInSecond), TimeSpan.FromSeconds(delayInSecond)); return(Task.FromResult <int>(0)); }
/// <summary> /// Starts the dispatcher with the given actor. /// </summary> /// <remarks>If the method has already been called previously, this new call will silently fail.</remarks> /// <param name="actor">The actor to run on.</param> /// <exception cref="ArgumentException">The specified actor is null.</exception> internal static void Run(IActor actor) { Enforce.ArgumentNotNull(actor, "actor"); // Double-check pattern (1) if (m_actor != null) return; lock (m_syncLock) { // Double-check pattern (2) if (m_actor != null) return; m_actor = actor; m_oneSecondTimer = actor.GetTimer(OnOneSecondTimerTick, 1000, true); } }
protected override async Task OnActivateAsync() { try { await this.StateManager.TryAddStateAsync<Dictionary<int, ProductStockTrend>>("ProductStockTrends", new Dictionary<int, ProductStockTrend>()); TimeSpan startDelay = TimeSpan.Parse(ConfigurationHelper.ReadValue("AppSettings", "PredictionTimerStartDelay")); TimeSpan interval = TimeSpan.Parse(ConfigurationHelper.ReadValue("AppSettings", "PredictionTimerInterval")); if (!int.TryParse(ConfigurationHelper.ReadValue("AppSettings", "PredictionNotificationAttempts"), out this.notificationAttempts)) { this.notificationAttempts = 10; } // register timer to regularly check for updates this.notificationTimer = this.RegisterTimer( this.RunNotificationAsync, null, startDelay, interval ); this.mlClient = AzureMlClientFactory.CreateClient(); await base.OnActivateAsync(); } catch (Exception ex) { Logger.Error(ex, nameof(this.OnActivateAsync)); throw; } }
/// <summary> /// Shutdowns the dispatcher. /// </summary> internal static void Shutdown() { if (m_oneSecondTimer == null) return; m_oneSecondTimer.Stop(); m_oneSecondTimer = null; }