/// <summary>
/// Listens for incoming XML stanzas and raises the appropriate events.
/// </summary>
/// <remarks>This runs in the context of a separate thread. In case of an
/// exception, the Error event is raised and the thread is shutdown.</remarks>
private void ReadStream()
{
using (var reader = new StreamReader(_stream))
{
while (!_cancellationTokenSource.Token.IsCancellationRequested)
{
// If the client is not connected close reader.
if (!_client.Connected)
{
break;
}
var message = reader.ReadLineSingleBreak();
MessageReceived?.Invoke(this, new MessageReceivedEventArgs(message));
// Parse message
var command = CommandFactory.GetCommand(message);
if (command != null)
{
if (_resultTaskCompletionSources.TryGetValue(command.Code, out TaskCompletionSource <Command> resultTaskCompletionSource))
{
// query response
resultTaskCompletionSource.TrySetResult(command);
}
else
{
// event
EventReceived?.Invoke(this, new CommandEventArgs(command));
}
}
}
}
}
public EventReplier(int port, EventReceived eventReceived)
{
context = new ZContext();
socket = new ZSocket(context, ZSocketType.REP);
socket.Bind($"tcp://127.0.0.1:{port}");
onEventReceived = eventReceived;
}
public async Task Handle(EventReceived <CustomerCreated> @event, CancellationToken cancellationToken)
{
_logger.LogInformation("creating customer details for {AggregateId} ...", @event.Event.AggregateId);
var filter = Builders <CustomerDetails> .Filter
.Eq(a => a.Id, @event.Event.AggregateId);
var update = Builders <CustomerDetails> .Update
.Set(a => a.Id, @event.Event.AggregateId)
.Set(a => a.Version, @event.Event.AggregateVersion)
.Set(a => a.Firstname, @event.Event.Firstname)
.Set(a => a.Lastname, @event.Event.Lastname)
.Set(a => a.Email, @event.Event.Email)
.Set(a => a.TotalBalance, new Money(Currency.CanadianDollar, 0));
await _db.CustomersDetails.UpdateOneAsync(filter,
cancellationToken : cancellationToken,
update : update,
options : new UpdateOptions()
{
IsUpsert = true
});
_logger.LogInformation("created customer details {AggregateId}", @event.Event.AggregateId);
}
public async Task Register(string eventName, EventReceived <TEvent> messageReceived)
{
await Task.Run(() =>
{
try
{
_channel.ExchangeDeclare(eventName, ExchangeType.Fanout);
var queueName = _channel.QueueDeclare().QueueName;
_channel.QueueBind(queue: queueName,
exchange: eventName,
routingKey: "");
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = JsonConvert.DeserializeObject <TEvent>(Encoding.UTF8.GetString(body.ToArray()));
messageReceived(message);
};
_channel.BasicConsume(queue: eventName,
autoAck: true,
consumer: consumer);
}
catch (Exception e)
{
throw new EventReceiverException(e);
}
});
}
public async Task Handle(EventReceived <Withdrawal> @event, CancellationToken cancellationToken)
{
var filter = Builders <AccountDetails> .Filter.Eq(a => a.Id, @event.Event.AggregateId);
var account = await(await _db.AccountsDetails.FindAsync(filter, null, cancellationToken)).FirstOrDefaultAsync(cancellationToken);
if (null == account)
{
_logger.LogWarning("unable to find account by id {AggregateId}", @event.Event.AggregateId);
throw new ArgumentOutOfRangeException(nameof(@event.Event.AggregateId), $"unable to find account by id {@event.Event.AggregateId}");
}
var customerFilter = Builders <CustomerDetails> .Filter.Eq(a => a.Id, account.OwnerId);
var update = Builders <CustomerDetails> .Update
.Inc(a => a.TotalBalance.Value, [email protected]);
var res = await _db.CustomersDetails.FindOneAndUpdateAsync(customerFilter, update, null, cancellationToken);
if (null == res)
{
var msg = $"unable to find customer by id {account.OwnerId}";
_logger.LogWarning(msg);
throw new ArgumentOutOfRangeException(nameof(account.OwnerId), msg);
}
}
public async Task Handle(EventReceived <Withdrawal> @event, CancellationToken cancellationToken)
{
_logger.LogInformation("processing withdrawal of {@event.Event.Amount} on account {AggregateId} ...", @event.Event.AggregateId);
var filter = Builders <AccountDetails> .Filter
.And(Builders <AccountDetails> .Filter.Eq(a => a.Id, @event.Event.AggregateId),
Builders <AccountDetails> .Filter.Eq(a => a.Version, @event.Event.AggregateVersion - 1));
var update = Builders <AccountDetails> .Update
.Set(a => a.Version, @event.Event.AggregateVersion)
.Inc(a => a.Balance.Value, [email protected]);
var res = await _db.AccountsDetails.FindOneAndUpdateAsync(
filter : filter,
cancellationToken : cancellationToken,
update : update,
options : new FindOneAndUpdateOptions <AccountDetails, AccountDetails>()
{
IsUpsert = false
});
if (res != null)
{
_logger.LogInformation("withdrawn {@event.Event.Amount} from account {AggregateId} ...", @event.Event.AggregateId);
}
else
{
_logger.LogWarning("withdrawal of {@event.Event.Amount} from account {AggregateId} failed!", @event.Event.AggregateId);
}
}
public void RaiseClientEvent(EventCodes eventCode)
{
EventReceived?.Invoke(new EventData()
{
Code = (byte)eventCode
});
}
public async Task Handle(EventReceived <AccountCreated> @event, CancellationToken cancellationToken)
{
_logger.LogInformation("creating account details for aggregate {AggregateId} ...", @event.Event.AggregateId);
var customerId = @event.Event.OwnerId;
var response = await _customerDetailsContainer.ReadItemAsync <CustomerDetails>(
customerId.ToString(),
new PartitionKey(customerId.ToString()),
null, cancellationToken);
var customer = response.Resource;
if (null == customer)
{
var msg = $"unable to find customer by id {@event.Event.OwnerId}";
_logger.LogWarning(msg);
throw new ArgumentOutOfRangeException(nameof(@event.Event.OwnerId), msg);
}
var balance = Money.Zero(@event.Event.Currency);
var newAccount = new AccountDetails(@event.Event.AggregateId,
customer.Id, customer.Firstname, customer.Lastname,
balance);
await _accountsContainer.UpsertItemAsync(newAccount, new PartitionKey(@event.Event.AggregateId.ToString()),
null, cancellationToken);
_logger.LogInformation("created account {AggregateId}", @event.Event.AggregateId);
}
private void ProcessEvent(JObject packet)
{
Type requestType;
var name = packet["event"].ToObject <string>();
var eventBody = packet["body"];
Event eventObj;
if (name != null &&
_types != null &&
_types.TryGetValue("event." + name, out requestType))
{
// We have a strongly typed event type registered, use that.
eventObj = eventBody.ToObject(requestType) as Event;
}
else
{
// We have no strongly typed event type, so give the user a
// GenericEvent and they can look through the body manually.
eventObj = new GenericEvent()
{
body = eventBody.ToObject <Dictionary <string, object> >()
};
}
try {
EventReceived?.Invoke(this, new EventReceivedEventArgs(name, eventObj));
} catch (Exception) {
// TODO: Report unhandled exception?
}
}
private void ReceiveMessage(object sender, NetMQSocketEventArgs args)
{
NetMQMessage message = args.Socket.ReceiveMultipartMessage();
if (message[message.FrameCount - 2].MessageSize != 0)
{
RaiseError("ProtocolError", "Invalid event: Second to last argument must be an empty buffer!");
return;
}
var envelope = message.Take(message.FrameCount - 2).Select(n => n.ToByteArray()).ToList();
Event evt;
try
{
evt = SerializerUtils.Deserialize(envelope, message.Last.ToByteArray());
}
catch (Exception ex)
{
RaiseError("ProtocolError", $"Invalid event: {ex.Message}", ex.StackTrace);
return;
}
if (evt.Header.ResponseTo != null && Channels.TryGetValue(evt.Header.ResponseTo, out Channel ch))
{
ch.ProcessAsync(evt);
}
else
{
EventReceived?.BeginInvoke(this, new EventReceivedArgs {
Event = evt
}, null, null);
}
}
protected void OnEventReceived(IpcEvent obj)
{
// Special case: progress report events are too noisy...
if (!(obj.Data is ProgressReportEvent))
{
Logger.LogInfo("Event {0} of type \"{1}\" received from server.", obj.RequestId, obj.Data.GetType().Name);
}
EventReceived?.Invoke(obj);
}
public void SubscribeToEvent <TEvent>(EventReceived <TEvent> eventReceived) where TEvent : class, IEvent
{
if (eventReceived == null)
{
throw new ArgumentNullException(nameof(eventReceived));
}
_eventSubscriptions.Add(configurator => configurator.Handler <TEvent>(ctx => HandleEvent(eventReceived, ctx)));
}
public async Task Handle(EventReceived <AccountDeactivated> notification, CancellationToken cancellationToken)
{
// TODO: This is a test email
await _sendGridService.SendEmailAsync(
email : "*****@*****.**",
subject : "ES CRM - Account deactivated",
htmlMessage : notification.Event.Name
);
}
public async Task Handle(EventReceived <AccountCreated> notification, CancellationToken cancellationToken)
{
NewAccountCreatedEmailTemplate newAccountCreatedEmailTemplate = new NewAccountCreatedEmailTemplate(notification.Event);
// TODO: This is a test email
await _sendGridService.SendEmailAsync(
email : "*****@*****.**",
subject : "ES CRM - New account created",
htmlMessage : newAccountCreatedEmailTemplate.TransformText()
);
}
private void InvokeEvent <T>(EventHandler <T> handler, T args) where T : NetMQMonitorEventArgs
{
if (EventReceived != null)
{
EventReceived.Invoke(this, args);
}
if (handler != null)
{
handler.Invoke(this, args);
}
}
private void AdminPortTcpClient_MessageReceived(object sender, IAdminMessage e)
{
logger?.LogTrace($"{ServerInfo} Received message {e.MessageType} - {e}");
StateRunners[Context.State].OnMessageReceived(e, Context);
IAdminEvent?adminEvent = eventFactory.Create(e, Context);
logger?.LogWarning($"{ServerInfo} adminEvent is null for {e.MessageType} {e}");
if (adminEvent != null)
{
EventReceived?.Invoke(this, adminEvent);
}
}
/// <inheritdoc/>
public bool RaiseEventReceivedEvent(EventGridEventModel model)
{
if (string.IsNullOrWhiteSpace(model.EventType) || string.IsNullOrWhiteSpace(model.Subject))
{
return(false);
}
var eventGridViewerEventModel = _eventGridEventModelAdapter.Convert(model);
EventReceived?.Invoke(this, new EventGridEventArgs(eventGridViewerEventModel));
return(true);
}
public async Task HandleEvent <TEvent>(EventMessage <TEvent> message) where TEvent : class, IEvent
{
Delegate @delegate;
if (!_subscribedEvents.TryGetValue(typeof(TEvent), out @delegate))
{
return;
}
EventReceived <TEvent> eventReceivedDelegate = (EventReceived <TEvent>)@delegate;
await eventReceivedDelegate(message).ConfigureAwait(false);
}
public async Task DoesSomeStuff()
{
//arrange
//(insert mocked interfaces to handler if required)
var eventHandler = new EventReceivedHandler();
var evt = new EventReceived();
//act
await eventHandler.Handle(evt);
//assert
//.......
}
private void _run()
{
while (Running == true)
{
Poll();
var datas = GetBufferedData();
foreach (var state in datas)
{
EventReceived?.Invoke(new DMouseEventArgs(state));
}
Thread.Sleep(10);
}
}
/// <summary>
/// Refreshes the current Denon status.
/// </summary>
/// <param name="publishChanges">Indiactes if changes should be published or not.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
private async Task RefreshStatusAsync(bool publishChanges = false)
{
// Make all of the calls to get current status
var status = new MainStatus();
var mainZoneStatusTask = _httpClient.GetDenonMainZoneStatusAsync();
var secondaryZoneStatusTask = _httpClient.GetAllDenonSecondaryZonesStatusAsync(1);
await Task.WhenAll(mainZoneStatusTask, secondaryZoneStatusTask).ConfigureAwait(false);
var mainZoneStatus = await mainZoneStatusTask.ConfigureAwait(false);
var secondaryZoneStatus = await secondaryZoneStatusTask.ConfigureAwait(false);
status.Power = mainZoneStatus.Power.Value.ToUpper() == "ON";
status.Volume = 80 + decimal.Parse(mainZoneStatus.MasterVolume.Value);
status.Mute = mainZoneStatus.Mute.Value.ToUpper() == "ON";
status.Input = mainZoneStatus.InputFuncSelect.Value;
status.SurroundMode = mainZoneStatus.SurrMode.Value;
foreach (var zone in secondaryZoneStatus)
{
var statusLite = new StatusLite
{
Power = zone.Value.Power.Value.ToUpper() == "ON",
Volume = 80 + decimal.Parse(zone.Value.MasterVolume.Value),
Mute = zone.Value.Mute.Value.ToUpper() == "ON",
Input = zone.Value.InputFuncSelect.Value
};
status.SecondaryZoneStatus.Add($"ZONE{zone.Key}", statusLite);
}
// Initialize state
if (_status == null)
{
_status = status;
}
// Compare to current cached status
var updates = CompareStatusObjects(_status, status);
// If updated, publish changes
if (publishChanges && updates.Count > 0)
{
foreach (var update in updates)
{
EventReceived?.Invoke(this, new CommandEventArgs(update));
}
_status = status;
}
}
public Task SetupQueueListenerAsync(
string queueName,
string topic,
EventReceived callback,
Type parameterType,
string exchangeName = null)
{
EnsureArg.IsNotNullOrWhiteSpace(queueName, nameof(queueName));
EnsureArg.IsNotNullOrWhiteSpace(topic, nameof(topic));
EnsureArg.IsNotNull(callback, nameof(callback));
EnsureArg.IsNotNull(parameterType, nameof(parameterType));
LogSetupQueueListenerCalled(queueName, topic, parameterType, exchangeName);
return(Task.Run(() =>
{
void CallbackInvoker(EventMessage eventMessage)
{
LogReceivedCallback(queueName, topic, eventMessage.RoutingKey, eventMessage.JsonMessage);
object deserializedParameter;
try
{
deserializedParameter = JsonConvert.DeserializeObject(eventMessage.JsonMessage, parameterType);
}
catch (Exception exception)
{
LogFailedJsonConvert(queueName, topic, parameterType, eventMessage.JsonMessage, exception);
throw;
}
try
{
LogCallingCallback(queueName, topic);
callback(deserializedParameter, eventMessage.RoutingKey);
LogDoneCallingCallback(queueName, topic);
}
catch (Exception exeption)
{
LogFailedCallingCallback(queueName, topic, exeption);
throw;
}
}
_callbackRegistry.AddCallbackForQueue(queueName, topic, CallbackInvoker, exchangeName);
LogSetupQueueListenerDone(queueName, topic, parameterType, exchangeName);
}));
}
private IntPtr OnHookProc(int nCode, int wParam, IntPtr lParam)
{
if (nCode >= 0)
{
try
{
var mhs = Marshal.PtrToStructure <MouseHookStruct>(lParam);
EventReceived?.Invoke(wParam, new Point(mhs.pt.x, mhs.pt.y));
}
catch { }
}
return(CallNextHookEx(_hHook, nCode, wParam, lParam));
}
public void AddReceiver <TEvent>(string eventName, EventReceived <TEvent> eventReceived)
{
if (!Receivers.Keys.Contains(eventName))
{
lock (_mutex)
{
if (!Receivers.Keys.Contains(eventName))
{
Receivers.Add(eventName, new List <EventReceived <string> >());
}
}
}
Receivers[eventName].Add(payload => eventReceived(JsonConvert.DeserializeObject <TEvent>(payload)));
}
public async Task Handle(EventReceived <Deposit> @event, CancellationToken cancellationToken)
{
var partitionKey = new PartitionKey(@event.Event.OwnerId.ToString());
var response = await _container.ReadItemAsync <CustomerDetails>(@event.Event.OwnerId.ToString(),
partitionKey,
null, cancellationToken);
var customer = response.Resource;
var balance = (customer.TotalBalance ?? new Money(Currency.CanadianDollar, 0));
var newBalance = balance.Add(@event.Event.Amount.Value);
var updatedCustomer = new CustomerDetails(customer.Id, customer.Firstname, customer.Lastname, customer.Email, customer.Accounts, newBalance);
await _container.ReplaceItemAsync(updatedCustomer, @event.Event.OwnerId.ToString(), partitionKey, null, cancellationToken);
}
private async Task HandleEvent <TEvent>(EventReceived <TEvent> eventHandler, ConsumeContext <TEvent> context) where TEvent : class, IEvent
{
EventMessage <TEvent> message = _options.ContextManager.CreateEventMessage(context);
_logger.LogVerbose(new { @event = message.Event.ToString(), eventType = typeof(TEvent).FullName, correlationId = message.CorrelationId, retryCount = context.GetRetryAttempt() }, arg => $"Received event of type {arg.eventType} with correlationId {arg.correlationId}. (Try n. {arg.retryCount}). Event: {arg.@event}");
try
{
await eventHandler.Invoke(message).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.LogError(new { eventType = typeof(TEvent).FullName, correlationId = message.CorrelationId, retryCount = context.GetRetryAttempt(), @event = context.Message.ToString() }, ex, (arg, e) => $"Error while processing event of type {arg.eventType} with correlationId {arg.correlationId}. (Try n. {arg.retryCount}). Event: {arg.@event}. Error: {e.Message}");
throw;
}
}
public async Task Handle(EventReceived <AccountDeactivated> notification, CancellationToken cancellationToken)
{
Account account = await this._context.Accounts.FindAsync(notification.Event.AggregateId);
if (account == null)
{
return;
}
account.IsActive = false;
account.LastModifiedBy = notification.Event.UserId;
_context.Accounts.Update(account);
await _context.SaveChangesAsync(cancellationToken);
}
protected override void WndProc(ref Message m)
{
_Lock.EnterReadLock();
var isContained = Messages.Contains(m.Msg);
_Lock.ExitReadLock();
if (isContained)
{
_SynchronizationContext.Post((state) =>
{
EventReceived?.Invoke((Message)state);
}, m);
}
base.WndProc(ref m);
}
public Task SetupQueueListenerAsync <TParam>(
string queueName,
string topic,
EventReceived <TParam> callback,
string exchangeName = null)
{
EnsureArg.IsNotNullOrWhiteSpace(queueName, nameof(queueName));
EnsureArg.IsNotNullOrWhiteSpace(topic, nameof(topic));
EnsureArg.IsNotNull(callback, nameof(callback));
return(SetupQueueListenerAsync(
queueName,
topic,
(input, receivedTopic) => callback((TParam)input, receivedTopic),
typeof(TParam),
exchangeName));
}
public void FireEventReceived(NetworkEvent networkEvent)
{
if (!IsPushEnabled)
{
return;
}
try
{
Trace($"{networkEvent.GetType().Name} received: {networkEvent}");
EventReceived?.Invoke(networkEvent);
}
catch (Exception e)
{
Trace(e);
}
}
