public async Task OnNextAsync(DiffModel item, StreamSequenceToken token = null) { _logger.Verbose($"OnNextAsync called with {item.NewGrains.Count} items"); var newGrains = await ApplyFilter(item.NewGrains); CurrentStats?.AddRange(newGrains); if (InSummaryMode) { await _dashboardInstanceStream.OnNextAsync(new DiffModel { SummaryView = InSummaryMode, TypeCounts = item.TypeCounts, NewGrains = GetGrainSummaries(), SummaryViewLinks = GetGrainSummaryLinks(), SessionId = SessionId }); } else { item.NewGrains = newGrains; _logger.Verbose($"OnNextAsync called with {item.NewGrains.Count} items"); if (item.NewGrains != null && (item.NewGrains.Any() || item.RemovedGrains.Any())) { item.SummaryView = InSummaryMode; item.SessionId = SessionId; await _dashboardInstanceStream.OnNextAsync(item); } } }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <returns></returns> public async Task <long> RegisterRoomAsync(string name) { if (State.Rooms.ContainsValue(name)) { throw new DuplicateNameException(); } var idManager = GrainFactory.GetGrain <IRoomIdManager>(RoomIdManager.DefaultId); var id = await idManager.GenerateIdAsync(); //var room = GrainFactory.GetGrain<IChatRoom>(id); State.Rooms.Add(id, name); await Task.WhenAll( WriteStateAsync(), actions.OnNextAsync(new RoomActionMessage { Action = RoomAction.Registered, RoomId = id }) ); return(id); }
public override Task SendAllAsync(string methodName, object?[]?args, CancellationToken cancellationToken = new CancellationToken()) { var message = new InvocationMessage(methodName, args); return(_allStream.OnNextAsync(new AllMessage(message))); }
public async Task <Guid> Join(string nickname) { _onlineMembers.Add(nickname); await _stream.OnNextAsync(new Message("System", $"{nickname} join the chat '{this.GetPrimaryKeyString()}' ...")); return(_stream.Guid); }
public async Task <Guid> Join(string nickname) { _onlineMembers.Add(nickname); await _stream.OnNextAsync(new Message($"{nickname} has joined the channel")); return(_stream.Guid); }
private async Task TickTock(object arg) { var e = new GameAreaEvent { TimelineMessage = $"The clock ticks. The time is now _{DateTime.Now}_" }; logger.LogInformation("Sending event: {e}", e); await areaEventStream.OnNextAsync(e); }
public virtual Task Send <T>(short packetId, T obj = default) { var packet = new TPacket { Command = packetId, Data = obj != null?Serialize(obj) : default }; return(asyncStream.OnNextAsync(packet)); }
public async Task PlayerMove(GameMessage message) { MoveMessage moveMsg = message as MoveMessage; if (moveMsg == null) { throw new Exception($"Player move recieved a message that was not of type {typeof(MoveMessage)} but was {message.GetType()}"); } logger.LogInformation($"Player {moveMsg.PlayerId} moved in direction {moveMsg.Direction}"); await stream.OnNextAsync(message); }
public void SendBatchedMessages(string senderIdentifier) { while (true) { PayloadMessage message = MakeBatchedMessage(senderIdentifier, sequenceNumber); if (message == null) { break; } ++sequenceNumber; stream.OnNextAsync(message.AsImmutable()); } }
public async Task Deposit(double a) { this.State.Balance += a; await this.WriteStateAsync(); await _stream.OnNextAsync(new TransactionEvent { Amount = a, Type = TransactionType.Credit, Data = new Dictionary <string, string> { { "key", "hello" } } }); }
public async Task OnNextAsync(UserRegisteredEvent item, StreamSequenceToken token = null) { var @event = new UserVerificationEvent() { Email = item.Email, Status = UserVerificationStatusEnum.Verified }; if (_verificationState.State.IsAlreadyVerified) { @event.Status = UserVerificationStatusEnum.Duplicate; } if (_blacklistedEmails.Get().Contains(item.Email)) { @event.Status = UserVerificationStatusEnum.Blocked; _logger.LogWarning("Blacklisted user {email}", item.Email); } await _userVerificationStream.OnNextAsync(@event); _verificationState.State.IsAlreadyVerified = true; await _verificationState.WriteStateAsync(); }
public async Task Run() { string line; Random random = new Random(); int count = rate / 2 + random.Next(rate + 1); for (int i = 0; i < count; ++i) { line = photoFile.ReadLine(); if (line == null) { break; } long ts = DataDriver.getCurrentTimestamp() + random.Next(2 * randSpan + 1) - randSpan; line = line + " " + ts; await photoStream.OnNextAsync(line); int pid; if (!Int32.TryParse(line.Split(" ")[0], out pid)) { continue; } if (tags.ContainsKey(pid)) { foreach (int uid in tags[pid]) { string tagLine = pid + " " + uid + " " + ts; await tagStream.OnNextAsync(tagLine); } } } }
private Task HandleMatchEvent(MatchEventDto matchEventDto) { switch ((MatchEventType)matchEventDto.MatchEventType) { case MatchEventType.None: break; case MatchEventType.Goal: State.Apply(matchEventDto.ToGoalEvent()); break; case MatchEventType.YellowCard: State.Apply(matchEventDto.ToYellowCardEvent()); break; case MatchEventType.RedCard: State.Apply(matchEventDto.ToRedCardEvent()); break; case MatchEventType.Substitution: State.Apply(matchEventDto.ToSubstitutionEvent()); break; case MatchEventType.Time: State.Apply(matchEventDto.ToTimeEvent()); break; default: throw new ArgumentOutOfRangeException(); } return(_stream.OnNextAsync(matchEventDto)); }
public async Task ReportSiloStatistics(MetricsSnapshot snapshot) { try { // add or replace the snapshot for the silo this came from if (!SiloSnapshots.ContainsKey(snapshot.Source)) { SiloSnapshots.Add(snapshot.Source, snapshot); } else { SiloSnapshots[snapshot.Source] = snapshot; } if (SiloSnapshotStream != null) { await SiloSnapshotStream.OnNextAsync(snapshot); } // recalculate cluster metrics snapshot // any time a silo snapshot is added or updated ClusterSnapshot = CalculateClusterMetrics(SiloSnapshots.Values.ToList()); //if (ClusterSnapshotStream != null) // await ClusterSnapshotStream.OnNextAsync(ClusterSnapshot); logger.IncrementMetric("SiloMetricsReported"); } catch (Exception ex) { logger.TrackException(ex); throw; } }
private static async void SendMessage() { await Task.Run(async() => { try { //HEY! this will throw an exception if the Orleans.GrainClient hasn't initialized yet... IStreamProvider streamProvider = Orleans.GrainClient.GetStreamProvider("StreamProviding"); IAsyncStream <SimpleMessage> messageStream = streamProvider.GetStream <SimpleMessage>(Guid.Empty, "test"); if (messageStream == null) { Console.WriteLine("MessagesToTcpClientSender.SendMessageFromBrcAsync got a null messageStream trying to send!?!?!?"); } SimpleMessage message = new SimpleMessage() { SimpleText = "Hello World" }; await messageStream.OnNextAsync(message); } catch (Exception exc) { Console.WriteLine("Orleans call MessagesToTcpClientSender.SendMessageAsync has failed, I am going to throw exception: " + exc.Message); Console.WriteLine(exc.Message); throw; } }); }
private Task Fire([CallerMemberName] string caller = null) { numProducedItems++; logger.Info("{0} (item={1})", caller, numProducedItems); RequestContext.Set(RequestContextKey, RequestContextValue); return(producer.OnNextAsync(numProducedItems)); }
public async Task SerializationExceptionFromClassUsedInStreamsAndAlsoStateTestTest() { Guid facilityGuid = Guid.NewGuid(); MessageContract messageReceivedFromStream = null; #region Stream setup spy IStreamProvider callpointStreamProvider = _fixture.HostedCluster.StreamProviderManager.GetStreamProvider("StreamProvider"); IAsyncStream <MessageContract> callpointStream = callpointStreamProvider.GetStream <MessageContract>(facilityGuid, "Namespace"); var subHandle = callpointStream.SubscribeAsync((message, token) => { messageReceivedFromStream = message; return(TaskDone.Done); }); IStreamProvider streamProvider = _fixture.HostedCluster.StreamProviderManager.GetStreamProvider("StreamProviderOther"); IAsyncStream <SomeOtherMessage> messageStream = streamProvider.GetStream <SomeOtherMessage>(facilityGuid, "NamespaceOther"); #endregion var aceMessage = new SomeOtherMessage { MyProp = "MyProp" }; await messageStream.OnNextAsync(aceMessage); await Task.Delay(TimeSpan.FromMilliseconds(1000)); Assert.NotNull(messageReceivedFromStream); Assert.IsType <MessageContract>(messageReceivedFromStream); }
public Task RoomNotify(MOMsg msg) { if (_players.Count == 0) { return(Task.CompletedTask); } return(_stream.OnNextAsync(msg)); }
public override Task OnActivateAsync() { var streamProvider = this.GetStreamProvider("SMSProvider"); _stream = streamProvider.GetStream <byte[]>(Guid.Parse("db260371-c425-41df-b729-f530c2367bb5"), "hello"); return(_stream.OnNextAsync(new byte[] { 0xFF, 0xDE, 0xAD, 0xBE, 0xEF })); }
public async Task HandleEvent(DeviceEvent deviceEvent) { this.RaiseEvent(deviceEvent); await ConfirmEvents(); await _deviceEventStream.OnNextAsync(deviceEvent); }
public async Task UpdatePlayerAsync(string name) { State.Name = name; await WriteStateAsync(); await _stream.OnNextAsync(new PlayerUpdated(name)); }
private async Task Fire([CallerMemberName] string caller = null) { RequestContext.Set(RequestContextKey, RequestContextValue); await producer.OnNextAsync(numProducedItems); numProducedItems++; logger.LogInformation("{Caller} (item count={Count})", caller, numProducedItems); }
private async Task <bool> SaveFile(byte[] file) { State.Files.Add(file); await WriteStateAsync(); await _streamFiles.OnNextAsync(file); return(true); }
async Task <string> IEmailSender.SendEmailAsync(string message) { IAsyncStream <string> stream = this.GetStreamProvider("SMSProvider").GetStream <string>(Guid.Empty, "chat"); await stream.OnNextAsync($"{this.GetPrimaryKeyString()} - {message}"); logger.LogInformation($"\n Message received: greeting = '{message}'"); return($"\n Client said: '{message}'!"); }
async Task <string> IHello.SayHello(string greeting) { IAsyncStream <string> stream = this.GetStreamProvider("SMSProvider").GetStream <string>(Guid.Empty, "chat"); await stream.OnNextAsync($"{this.GetPrimaryKeyString()} - {greeting}"); logger.LogInformation($"\n SayHello message received: greeting = '{greeting}'"); return($"\n Client said: '{greeting}', so HelloGrain says: Hello!"); }
public async Task Notify(string msg, NotifyType type = NotifyType.Message) { PlayerNotifyMsg notify = new PlayerNotifyMsg() { Message = msg, Type = type }; await stream.OnNextAsync(notify); }
public async Task <int> ProcessActionAsync(ChunkAction action) { State.ChangeIndex++; _pixelsCache[action.XIndex + action.YIndex * _chunkWidth].Rgba = action.Color; State.Image = _imageProcessor.GetBytesFromPixels(_pixelsCache, _chunkHeight, _chunkWidth); await WriteStateAsync(); await _chunkUpdateEventStream.OnNextAsync(new ChunkUpdate { ChangeIndex = State.ChangeIndex, Color = action.Color, XIndex = action.XIndex, YIndex = action.YIndex }); return(State.ChangeIndex); }
private async Task <bool> SaveFileId(string fileId) { State.Messages.Add(fileId); await WriteStateAsync(); await _streamIds.OnNextAsync(fileId); return(true); }
public async Task <int> SendItems(IEnumerable <T> items, bool useTransaction = true, int?transactionId = null) { var curTransactionId = transactionId ?? ++_lastTransactionId; if (useTransaction) { await StartTransaction(curTransactionId); } var message = new ItemMessage <T>(items); await ActorModel.WhenAll(_messageStream.OnNextAsync(message)); if (useTransaction) { await EndTransaction(curTransactionId); } return(curTransactionId); }
public async Task Handle(string @event) { this.Events.Add(@event); this.HandledEvents++; await Task.Delay(50); await _asyncStream.OnNextAsync(new OrderEvent(this.GetPrimaryKeyString(), Event.Updated)); }