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