public static ServerDomainMessage ToDomainMessage(this IMessage message, bool query = false) { var type = message.GetType(); var msg = new ServerDomainMessage { EventData = JsonConvert.SerializeObject(message.Clear()), TypeName = type.AssemblyQualifiedName, EventName = query ? type.FullName : type.Name, EventType = EventType.Command, SequenceNumber = DateTime.UtcNow.Ticks + Random.Next() }; switch (message) { case IEvent @event: msg.Id = @event.Id; msg.Version = @event.Version; msg.TimeStamp = @event.TimeStamp; msg.EventType = EventType.Event; break; case IAmbientCommand _: msg.EventType = EventType.AmbientCommand; break; } return(msg); }
private async void ProcessMessage(ServerDomainMessage domainMessage) { try { switch (domainMessage.EventType) { case EventType.AmbientCommand: case EventType.QueryResult: case EventType.Event: { if (_eventRegistrations.TryGetValue(domainMessage.EventName, out var reg)) { _messageDeliveries.Enqueue(new MessageDelivery(reg, domainMessage)); } break; } default: _memoryCache.Set(domainMessage.SequenceNumber, domainMessage); await _hubConnection.SendAsync(HubEventNames.TryAccept, domainMessage.SequenceNumber, _config.Value.ServiceName, _config.Value.ApiKey); break; } } catch (Exception e) { _logger.LogError(e, "Error on Recieving Message"); } }
public async Task PublishEventToClient(string client, ServerDomainMessage message, string apiKey) { var vaildate = await _keyStore.Validate(apiKey); if (!vaildate.Ok) { throw new HubException("Api Key Validation Failed"); } await Clients.Client(client).SendAsync(HubEventNames.PropagateEvent, message); }
public async Task Process(ServerDomainMessage msg) { try { await _msg.Invoke((IMessage)JsonConvert.DeserializeObject(msg.EventData, Type.GetType(msg.TypeName)), msg, CancellationToken.None); } catch (Exception e) { _logger.LogError(e, $"Error while Deligate to Messeage Handler {msg.EventName} {msg.EventType}"); } }
public async Task PublishEvent(ServerDomainMessage message, string apiKey) { var vaildate = await _keyStore.Validate(apiKey); if (!vaildate.Ok) { throw new HubException("Api Key Validation Failed"); } _logger.LogInformation($"Event Publised: {vaildate.ServiceName} -- {message.EventName}"); await _eventManager.ProvideEvent(Context.ConnectionId, message, apiKey); }
public override async Task Invoke(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token) { var obj = _target(); var spec = (obj as ISpecificationProviderBase)?.GetSpecification(); string error = null; if (spec != null && !spec.IsSatisfiedBy(msg)) { error = spec.Message; } await(Task) GetMethod()(obj, msg, error); }
public async Task Handle(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token) { if (rawMessage.EventType == EventType.QueryResult) { using var scope = _serviceScopeFactory.CreateScope(); var handler = (GlobalEventHandlerBase)scope.ServiceProvider.GetRequiredService(typeof(GlobalEventHandler <>).MakeGenericType(msg.GetType())); await handler.Handle(msg); } else { foreach (var handlerInstace in _handlers) { await handlerInstace.Handle(msg, rawMessage, token); } } }
public async Task ResolveQuery(QueryRoleClaims query, ServerDomainMessage serverDomainMessage) { _logger.LogInformation(EventIds.UserManager.RoleManagment, $"Query Role {query.RoleId} Claims"); var role = await _userDatabase.UserRoles .Include(e => e.Claims) .AsNoTracking() .FirstOrDefaultAsync(e => e.Id == query.RoleId); var result = new UserClaims(role?.Id ?? Guid.Empty); if (role != null) { result.Claims.AddRange(role.Claims.Select(e => new UserClaim(e.Data, e.Id))); } else { _logger.LogWarning(EventIds.UserManager.RoleManagment, $"Claims For {query.RoleId} Not Found: Returning Empty List"); } await _client.RespondToQuery(result, serverDomainMessage); }
public abstract Task Invoke(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token);
public override async Task Invoke(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token) => await(Task) GetMethod()(_handler(), msg, token);
public Task SendToClient(string client, ServerDomainMessage serverDomainMessage, CancellationToken token) { _sendToClient?.Invoke(client, serverDomainMessage, token); return(Task.CompletedTask); }
public static TType ToRealMessage <TType>(this ServerDomainMessage message) where TType : class => JsonConvert.DeserializeObject(message.EventData, Type.GetType(message.TypeName)) as TType;
public static async Task RespondToQuery <TType>(this IDispatcherClient client, TType result, ServerDomainMessage original) { if (result == null) { return; } var data = new QueryEvent <TType>(original.EventName, result); await client.SendToClient(original.Sender, new ServerDomainMessage { EventName = data.GetType().FullName, EventType = EventType.QueryResult, EventData = JsonConvert.SerializeObject(data), TypeName = typeof(QueryEvent <TType>).AssemblyQualifiedName }, CancellationToken.None); }
public RecivedDomainEvent(ServerDomainMessage realMessage, string apiKey) { RealMessage = realMessage; ApiKey = apiKey; }
public MessageDelivery(EventRegistration eventRegistration, ServerDomainMessage message) { _eventRegistration = eventRegistration; _message = message; }
public async Task SendToClient(string client, ServerDomainMessage serverDomainMessage, CancellationToken token) => await _hubConnection.SendAsync(HubEventNames.PublishEventToClient, client, serverDomainMessage, _config.Value.ApiKey, token);