protected override void Append(LoggingEvent loggingEvent) { LogLog.Debug(_declaringType, "Appending"); if (!EventRateLimiter.Request(loggingEvent.TimeStamp)) { LogLog.Debug(_declaringType, "Appending denied due to event limiter saturated."); return; } var sqsDatum = _eventProcessor.ProcessEvent(loggingEvent, RenderLoggingEvent(loggingEvent)).Single(); var sendMessageBatchRequestEntry = new SendMessageBatchRequestEntry { MessageBody = sqsDatum.Message, Id = sqsDatum.ID, }; if (sqsDatum.DelaySeconds.HasValue) { sendMessageBatchRequestEntry.DelaySeconds = sqsDatum.DelaySeconds.Value; } _client.AddSendMessageRequest(new SendMessageBatchRequestWrapper { QueueName = sqsDatum.QueueName, Entries = new[] { sendMessageBatchRequestEntry }.ToList() } ); }
/// <summary> /// default Middleware implementation /// </summary> /// <param name="context"></param> /// <param name="eventProcessor">the event processor used to process generic events</param> /// <returns></returns> public async Task Invoke(HttpContext context, IEventProcessor eventProcessor) { // Make the request replayable context.Request.EnableRewind(); // The handle url is remapped to the root dir in the UseEventEndpoint call. No matter what the user gives as input // So if the request is not going to the root directory it is not meant for us if (!string.IsNullOrWhiteSpace(context.Request.Path.Value.Trim('/'))) { await _next(context); return; } if (eventProcessor == null) { throw new ArgumentNullException(nameof(eventProcessor), $"It is most likely you did not register {nameof(IEventProcessor)}"); } var request = context.Request; var response = context.Response; response.StatusCode = StatusCodes.Status200OK; // Do the event processing logic here eventProcessor.ProcessEvent(context); }
public override async void ExecuteCore(IJobExecutionContext context) { try { ThreadContext.Properties["loggedby"] = "ProcessEventQueueJob"; var apiContext = new ApiContext(TenantId); var filter = String.Format("Status eq '{0}'", EventStatus.Pending); var events = await _eventHandler.GetEvents(TenantId, filter); foreach (var evt in events) { var statusCode = StatusCode.New; if (evt.Topic.Contains(".updated")) { statusCode = StatusCode.Active; } await _eventProcessor.ProcessEvent(apiContext, evt.ToMozuEvent(), statusCode); } await _eventHandler.PurgeOldEvents(apiContext); context.Result = "Completed Sync"; } catch (Exception ex) { _logger.Error(ex.Message, ex); } }
public void ProcessAttack(ServerGameState fullState, InteractionAttack interactionAttack) { var newEvent = new EventCharacterAttacks() { Attacker = interactionAttack.Attacker, Attacked = interactionAttack.Target }; eventProcessor.ProcessEvent(fullState, newEvent); }
protected override void SendBuffer(LoggingEvent[] events) { var rs = events.SelectMany(e => _eventProcessor.ProcessEvent(e, RenderLoggingEvent(e)).Select(r => r)); var requests = Assemble(rs); foreach (var putMetricDataRequest in requests) { _client.AddLogRequest(putMetricDataRequest); } }
/// <inheritdoc /> public void Initialize() { var consumer = new EventingBasicConsumer(_consumerChannel); consumer.Received += async(model, ea) => { var eventName = ea.RoutingKey; await _eventProcessor.ProcessEvent(eventName, ea.Body); // ACK _consumerChannel.BasicAck(ea.DeliveryTag, multiple: false); }; _consumerChannel.BasicConsume(queue: _queueName, autoAck: false, consumer: consumer); }
public void EventProcessorTest_Message() { HttpContext context = new DefaultHttpContext(); context.Request.Body = new MemoryStream(Encoding.ASCII.GetBytes(_messageEventJson)); _dispatcher.RegisterCallback <Message>((message) => { Assert.Equal("*****@*****.**", message.User); Assert.Equal("Hello world", message.Text); Assert.Equal("1355517523.000005", message.Timestamp); }); _processor.ProcessEvent(context); }
private void RegisterSubscriptionClientMessageHandler() { _subscriptionClient.RegisterMessageHandler( async(message, token) => { var eventName = $"{message.Label}{IntegrationEventSuffix}"; await _eventProcessor.ProcessEvent(eventName, message.Body); // Complete the message so that it is not received again. await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken); }, new MessageHandlerOptions(ExceptionReceivedHandler) { MaxConcurrentCalls = 10, AutoComplete = false }); }
public Task Subscribe(CancellationToken token = default) { _consumerChannel = CreateConsumerChannel(); var consumer = new EventingBasicConsumer(_consumerChannel); consumer.Received += async(model, ea) => { var eventName = ea.RoutingKey; await _eventProcessor.ProcessEvent(eventName, ea.Body.ToArray()); // ACK _consumerChannel.BasicAck(ea.DeliveryTag, multiple: false); }; _consumerChannel.BasicConsume(queue: _queueName, autoAck: false, consumer: consumer); return(Task.CompletedTask); }
public async Task <IActionResult> A_Chaining( [OrchestrationTrigger] IDurableOrchestrationContext context, ILogger log ) { log.LogInformation($"************** RunOrchestrator method executing ********************"); var reuqest = context.GetInput <EventReq>(); List <string> result = new List <string>(); foreach (var eventName in reuqest.EventNames) { result.Add(await _eventProcessor.ProcessEvent(eventName)); } return(new JsonResult(result)); }
public void Initialize() { if (!_persistentConnection.TryConnect()) { return; } var conn = _persistentConnection.GetConnection(); conn.SubscribeAsync($"{_options.Exchange}.>", _options.Client, async(sender, args) => { var subject = args.Message.Subject; var eventName = subject.StartsWith(_options.Exchange) ? subject.Substring(_options.Exchange.Length + 1) : subject; await _eventProcessor.ProcessEvent(eventName, args.Message.Data); }); }
public void ProcessPlayCard(ServerGameState fullState, InteractionPlayCard interactionPlayCard) { var me = fullState.Me; var opp = fullState.Opp; var card = me.Hand.First(x => x.Id == interactionPlayCard.CardId); logger.Log(LogType.Services, LogSeverity.Info, $"{me.Player.Name} plays {card.Name} for {card.Cost} mana"); me.Mana.SpendMana(card.Cost); me.Hand.Remove(card); var newEvent = new EventCardPlayed() { Card = card, MinionPosition = interactionPlayCard.MinionPosition }; eventProcessor.ProcessEvent(fullState, newEvent); }
protected override void Append(LoggingEvent loggingEvent) { LogLog.Debug(_declaringType, "Appending"); if (!EventRateLimiter.Request(loggingEvent.TimeStamp)) { LogLog.Debug(_declaringType, "Appending denied due to event limiter saturated."); return; } var logDatum = _eventProcessor.ProcessEvent(loggingEvent, RenderLoggingEvent(loggingEvent)).Single(); _client.AddLogRequest(new PutLogEventsRequest(logDatum.GroupName, logDatum.StreamName, new[] { new InputLogEvent { Timestamp = logDatum.Timestamp.Value.ToUniversalTime(), Message = logDatum.Message } }.ToList())); }
protected override void Append(LoggingEvent loggingEvent) { LogLog.Debug(_declaringType, "Appending"); if (!EventRateLimiter.Request(loggingEvent.TimeStamp)) { LogLog.Debug(_declaringType, "Appending denied due to event limiter saturated."); return; } var sqsDatum = _eventProcessor.ProcessEvent(loggingEvent, RenderLoggingEvent(loggingEvent)).Single(); if (System.Text.UTF8Encoding.UTF8.GetByteCount(sqsDatum.Message) > 256 * 1024) { throw new MessageTooLargeException(sqsDatum.Message); } if (sqsDatum.QueueName != null && !_queueNameRegex.IsMatch(sqsDatum.QueueName)) { throw new MessageTooLargeException(sqsDatum.Message); } var sendMessageBatchRequestEntry = new SendMessageBatchRequestEntry { MessageBody = sqsDatum.Message, Id = sqsDatum.ID, }; if (sqsDatum.DelaySeconds.HasValue) { sendMessageBatchRequestEntry.DelaySeconds = sqsDatum.DelaySeconds.Value; } _client.AddSendMessageRequest(new SendMessageBatchRequestWrapper { QueueName = sqsDatum.QueueName ?? _fallbackQueueName, Entries = new[] { sendMessageBatchRequestEntry }.ToList() } ); }
public Task Subscribe(CancellationToken token = default) { _connection.Connected += conn => { foreach (var exchange in _options.Exchanges ?? new string[0]) { conn.SubscribeAsync($"{exchange}.>", _options.Client, async(sender, args) => { var subject = args.Message.Subject; var eventName = subject.StartsWith(exchange) ? subject.Substring(exchange.Length + 1) : subject; await _eventProcessor.ProcessEvent(eventName, args.Message.Data); }); } }; _connection.VerifyConnection(); return(Task.CompletedTask); }
protected override void Append(LoggingEvent loggingEvent) { LogLog.Debug(_declaringType, "Appending"); if (!EventRateLimiter.Request(loggingEvent.TimeStamp)) { LogLog.Debug(_declaringType, "Appending denied due to event limiter saturated."); return; } var snsDatum = _eventProcessor.ProcessEvent(loggingEvent, RenderLoggingEvent(loggingEvent)).Single(); _client.AddPublishRequest(new PublishRequestWrapper { Message = snsDatum.Message, Topic = snsDatum.Topic ?? _fallbackTopic }); }
protected override Task ExecuteAsync(CancellationToken stoppingToken) { stoppingToken.ThrowIfCancellationRequested(); var consumer = new EventingBasicConsumer(_channel); consumer.Received += (ModuleHandle, ea) => { Console.WriteLine("--> Event Received!"); var body = ea.Body; var notificationMessage = Encoding.UTF8.GetString(body.ToArray()); _eventProcessor.ProcessEvent(notificationMessage); }; _channel.BasicConsume(queue: _queueName, autoAck: true, consumer: consumer); return(Task.CompletedTask); }
/// <summary> /// Process events from the queue. /// Process all events. /// </summary> public void ProcessEvents() { try { if (base.IsDisposed) { throw new ObjectDisposedException(GetType().Name, "it is not allowed to process events after channel is disposed"); } if (scheduler.CanEnterTimedDelegate()) { TelemetryEvent result; while (queue.TryDequeue(out result)) { eventProcessor.ProcessEvent(result); } if (!hasProcessedEvents) { hasProcessedEvents = true; initializedAction(); } } } catch (Exception exceptionObject) { FaultEvent faultEvent = new FaultEvent("VS/Telemetry/InternalFault", $"Exception in SessionChannel.EventProcessorChannel ProcessEvents Channel = {ChannelId}", exceptionObject) { PostThisEventToTelemetry = false }; faultEvent.AddProcessDump(Process.GetCurrentProcess().Id); telemetrySession.PostEvent(faultEvent); } finally { scheduler.ExitTimedDelegate(); } }
public void ProcessAttack(ServerGameState state, EventCharacterAttacks eventAttack) { // TODO: Process other types of attack (only Minion -> Player attacks are supported the moment) if (!IsAttackStillValid(state, eventAttack)) { return; } // 1. Attack state.Me.LastTurnEvents.Add(eventAttack); // 2. Got Attacked var characterGotAttackedEvent = new EventCharacterGotAttacked() { Attacked = eventAttack.Attacked, Attacker = eventAttack.Attacker }; eventProcessor.ProcessEvent(state, characterGotAttackedEvent); if (!IsAttackStillValid(state, eventAttack)) { return; } // 3. Deal Damage var characterDealsDamageEvent = new EventCharacterDealsDamage() { Damaged = eventAttack.Attacked, Damager = eventAttack.Attacker }; eventProcessor.ProcessEvent(state, characterDealsDamageEvent); if (!IsAttackStillValid(state, eventAttack)) { return; } //TODO: process it inside EventCharacterDealsDamage var attackingMinion = state.Me.Minions.FirstOrDefault(x => x.Id == eventAttack.Attacker); logger.Log(LogType.Services, LogSeverity.Info, $"{attackingMinion.Card.Name} attacks {state.Me.Player.Name} for {attackingMinion.Attack} damage"); // 4 Got Damaged //TODO: check if the damage event actually happened and was not somehow nullified var characterDamagedEvent = new EventCharacterDamaged() { Damaged = eventAttack.Attacked, Damager = eventAttack.Attacker }; eventProcessor.ProcessEvent(state, characterDamagedEvent); //TODO: process it inside EventCharacterDamaged state.Opp.Player.Health -= attackingMinion.Attack; logger.Log(LogType.Services, LogSeverity.Info, $"{state.Opp.Player.Name} Health reduced to {state.Opp.Player.Health} hp"); // 5. Check if Opp died if (state.Opp.Player.Health <= 0) { var charactedDiedEvent = new EventCharacterDied() { DiedCharacter = eventAttack.Attacked }; eventProcessor.ProcessEvent(state, charactedDiedEvent); } else { var characterSurvivedDamage = new EventCharacterSurvivedDamage(); eventProcessor.ProcessEvent(state, characterSurvivedDamage); } // 6. After Attack Event var afterAttackEvent = new EventCharacterAfterAttack(); eventProcessor.ProcessEvent(state, afterAttackEvent); }
public async Task ProcessMissedEvents(IApiContext apiContext, DateTime?lastRunTime) { //get events since last run var filter = string.Empty; if (lastRunTime.HasValue) { filter = String.Format("createDate gt '{0}'", lastRunTime.Value.ToString("u")); } var eventReader = new EventReader { Context = apiContext, Filter = filter, PageSize = 200 }; var eventList = new List <Event>(); while (await eventReader.ReadAsync()) { eventList.AddRange(eventReader.Items); } if (!eventList.Any()) { return; } var concise = from record in eventList group record by new { record.EntityId, record.Topic } into g let recent = ( from groupedItem in g orderby groupedItem.AuditInfo.UpdateDate descending select groupedItem ).First() select recent; foreach (var evt in concise) { if (!evt.IsApproved()) { continue; } var aubEvent = evt.ToAubEvent(); var entFilter = String.Format("Id eq '{0}' and Status eq 'Processed'", aubEvent.Id); var evtInEntity = await GetEvents(apiContext.TenantId, entFilter); var evtList = evtInEntity.ToList(); if (evtList.Any()) { var ent = evtList.FirstOrDefault(); if (ent != null && ent.ProcessedDateTime > evt.AuditInfo.UpdateDate) { continue; } } var statusCode = StatusCode.New; if (evt.Topic.Contains(".updated")) { statusCode = StatusCode.Active; } await _eventProcessor.ProcessEvent(apiContext, evt, statusCode); } }
internal static void Fire(uint data1, uint data2, DateTime time) => Fire(processor.ProcessEvent(data1, data2, time));
protected virtual IEnumerable <PutMetricDataRequest> ProcessEvents(LoggingEvent[] events) { return(events.SelectMany(e => _eventProcessor.ProcessEvent(e, RenderLoggingEvent(e)).Select(r => r))); }
public override void ProcessEvent(IEventProcessor processor) { processor.ProcessEvent(this); }
protected virtual IEnumerable <LogDatum> ProcessEvents(LoggingEvent[] events) { return(events.SelectMany(e => _eventProcessor.ProcessEvent(e, RenderLoggingEvent(e)).Select(r => r))); }