public void Subscribe <TDomainEvent>(string database, string channel, Action <TDomainEvent> handler) where TDomainEvent : IDomainEvent { if (string.IsNullOrWhiteSpace(channel)) { throw new ArgumentException("Channel not specified.", nameof(channel)); } if (handler == null) { throw new ArgumentNullException(nameof(handler)); } var subscriber = _connModule.GetSubscriber(database); subscriber.Subscribe(channel, (onChannel, message) => { var messageParts = ChannelMessageEncoder.UnPack(message); TDomainEvent domainEvent = _serializationMgr.Deserialize <TDomainEvent>( messageParts.contentType, messageParts.messageData); LogReceivedDomainEvent(database, channel, domainEvent); handler(domainEvent); }); }
public IDisposable SendRequestAsync <TRequest, TResponse>( TRequest request, Endpoint endpoint, Action <TResponse> callback, Action <Exception> onFailure, long timeout, string processingGroup = null) { if (m_Disposing.WaitOne(0)) { throw new InvalidOperationException("Engine is disposing"); } using (m_RequestsTracker.Track()) { try { var session = m_TransportManager.GetMessagingSession(endpoint.TransportId, GetProcessingGroup(endpoint, processingGroup)); RequestHandle requestHandle = session.SendRequest( endpoint.Destination.Publish, SerializeMessage(endpoint.SerializationFormat, request), message => { try { var responseMessage = m_SerializationManager.Deserialize <TResponse>(endpoint.SerializationFormat, message.Bytes); callback(responseMessage); } catch (Exception e) { onFailure(e); } finally { m_RequestTimeoutManager.Schedule(1); } }); lock (m_ActualRequests) { requestHandle.DueDate = DateTime.UtcNow.AddMilliseconds(timeout); m_ActualRequests.Add(requestHandle, onFailure); m_RequestTimeoutManager.Schedule(timeout); } return(requestHandle); } catch (Exception e) { _log.WriteError(nameof(SendRequestAsync), $"Failed to register handler. Transport: {endpoint.TransportId}, Destination: {endpoint.Destination}", e); throw; } } }
private async Task StartWorkerAsync <T>(IMessageConsumer consumer, SubscriptionInfo <T> subscriptionInfo, ConcurrentQueue <ITextMessage> queue, CancellationToken cancellationToken) where T : class, Options.IMessage { while (!cancellationToken.IsCancellationRequested) { ITextMessage messageInfo; //messageInfo = consumer.Receive(TimeSpan.FromMilliseconds(2000)); var result = queue.TryDequeue(out messageInfo); if (messageInfo != null) { var jsonMessage = messageInfo.Text; var message = serializationManager.Deserialize <T>(jsonMessage); try { await subscriptionInfo.OnReceivedAsync?.Invoke(message, cancellationToken); messageInfo.Acknowledge(); } catch (Exception ex) { await subscriptionInfo?.OnErrorAsync?.Invoke(message, ex, cancellationToken); } } await Task.Delay(1000, cancellationToken); } }
public static T Deserialize <T>(this ISerializationManager serializationManager, byte[] inputValue) { using (var ms = new System.IO.MemoryStream(inputValue)) { return((T)serializationManager.Deserialize(ms, typeof(T))); } }
public static object Deserialize(this ISerializationManager serializationManager, byte[] inputValue, Type type) { using (var ms = new System.IO.MemoryStream(inputValue)) { return(serializationManager.Deserialize(ms, type)); } }
private async Task SubscribeToChannels(IEnumerable <MessageChannelSubscriber> subscribers) { foreach (var msgSubscriber in subscribers) { ISubscriber subscriber = ConnModule.GetSubscriber(msgSubscriber.DatabaseName); // Callback invoked when message published to channel: await subscriber.SubscribeAsync(msgSubscriber.Channel, (channel, message) => { Type messageType = msgSubscriber.DispatchInfo.MessageType; var messageParts = ChannelMessageEncoder.UnPack(message); // Deserialize message byte array into domain-event type associated with handler: IDomainEvent domainEvent = (IDomainEvent)_serializationManager.Deserialize( messageParts.contentType, messageType, messageParts.messageData); LogReceivedDomainEvent(channel, domainEvent, msgSubscriber); // Invoke the in-process handler: DispatchModule.InvokeDispatcherInNewLifetimeScopeAsync( msgSubscriber.DispatchInfo, domainEvent).Wait(); }); } }
public object Get(string key, Type type) { var typeCode = Type.GetTypeCode(type); switch (typeCode) { case TypeCode.Boolean: return(preferences.GetBoolean(key, false)); case TypeCode.String: return(preferences.GetString(key, null)); case TypeCode.Single: return(preferences.GetFloat(key, 0)); case TypeCode.Int64: return(preferences.GetLong(key, 0)); case TypeCode.Int16: case TypeCode.Int32: return(preferences.GetInt(key, 0)); #if FEATURE_SERIALIZATION case TypeCode.Object: { var stringValue = preferences.GetString(key, null); return(serializationManager.Deserialize(stringValue, type)); } #endif default: throw new NotSupportedException(); } }
public async Task ProcessMessagesAsync <T>(SubscriptionInfo <T> subscriptionInfo, CancellationToken cancellationToken) where T : class, IMessage { while (!cancellationToken.IsCancellationRequested) { try { var messages = await _sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { MaxNumberOfMessages = 2, QueueUrl = "http://localhost:9324/queue/default" }); var data = messages.Messages; foreach (var item in data) { var message = _serializationManager.Deserialize <T>(item.Body); await subscriptionInfo.OnReceivedAsync?.Invoke(message, cancellationToken); await _sqsClient.DeleteMessageAsync(new DeleteMessageRequest { QueueUrl = "http://localhost:9324/queue/default", ReceiptHandle = item.ReceiptHandle }); } } catch (Exception ex) { throw; } await Task.Delay(1000); } }
private void RpcConsumerReplyReceived(BasicDeliverEventArgs deliveryEvent) { ValidateRpcReply(deliveryEvent); // Determine the command type based on the type name stored in basic properties. NOTE: a command type name is // just a value used to identify the type used to determine the C# class type on the receiving end corresponding // to the type on the caller's end. They may or may not be the same physical C# type. string typeName = deliveryEvent.BasicProperties.Type; Type commandType = _brokerState.RpcTypes[typeName]; // Dispatch the message the handler to obtain the result. MessageDispatchInfo dispatcher = _messagingModule.GetInProcessCommandDispatcher(commandType); IMessage message = _serializationMgr.Deserialize(commandType, deliveryEvent); object result = null; try { result = _messagingModule.InvokeDispatcherAsync(dispatcher, message).Result; // Publish the reply back to the publisher that made the request on the // queue specified by them in the message header on a new channel. PublishConsumerReply(result, deliveryEvent.BasicProperties); } catch (AggregateException ex) { PublishConsumerExceptionReply(ex.InnerException, deliveryEvent.BasicProperties); } catch (Exception ex) { PublishConsumerExceptionReply(ex, deliveryEvent.BasicProperties); } }
/// <summary> /// Publishes a message to a consumer defined queue used for receiving /// RPC style messages. The caller awaits the reply response message. /// </summary> /// <param name="message">The RPC style message to publish.</param> /// <returns>Future result after the reply is received.</returns> public async Task PublishToRpcConsumerAsync(IMessage message, CancellationToken cancellationToken) { Check.NotNull(message, nameof(message)); AssertRpcCommand(message); var rpcCommandAttrib = message.GetAttribute <RpcCommandAttribute>(); var command = message as ICommand; RpcProperties rpcProps = new RpcProperties { ContentType = rpcCommandAttrib.ContentType, ExternalTypeName = rpcCommandAttrib.ExternalTypeName }; // Obtain the consumer queue on which the message should be published. RpcMessagePublisher rpcPublisher = GetRpcPublisher(rpcCommandAttrib); string[] orderedContentTypes = { message.GetContentType(), rpcProps.ContentType, rpcPublisher.ContentType }; byte[] messageBody = _serializationMgr.Serialize(command, orderedContentTypes); LogPublishedRpcMessage(message, rpcPublisher, rpcProps); // Publish the RPC request the consumer's queue and await a response. rpcProps.ContentType = command.GetContentType(); byte[] replyBody = null; try { replyBody = await rpcPublisher.Client.Invoke(command, rpcProps, cancellationToken, messageBody); object reply = _serializationMgr.Deserialize(rpcProps.ContentType, command.ResultType, replyBody); command.SetResult(reply); LogReceivedRpcResponse(message, rpcPublisher); } catch (RpcReplyException ex) { var dispatchEx = _serializationMgr.Deserialize <MessageDispatchException>(rpcProps.ContentType, ex.Exception); _logger.LogError(RabbitMqLogEvents.PUBLISHER_RPC_RESPONSE, "RPC Exception Reply.", dispatchEx); throw dispatchEx; } }
public T CloneObject <T>(T objectToClone) where T : class { var updatable = objectToClone as IUpdatable; if (updatable != null) { return(Clone(updatable) as T); } var stream = _serializationManager.Serialize(objectToClone); var clone = _serializationManager.Deserialize <T>(stream); _objectIdResetter.ResetIdFor(clone); return(clone); }
public static object Deserialize(this ISerializationManager serializationManager, string input, Type type, Encoding encoding = null) { if (encoding == null) { if (serializationManager is ISerializationManager_TextEncoding) { encoding = ((ISerializationManager_TextEncoding)serializationManager).Encoding; } else { // TODO: Do a policy thing here, throw exception or a default encoding = Encoding.UTF8; } } var stream = new ReadonlyStringStream(input, encoding); return(serializationManager.Deserialize(stream, type)); }
// Deserialize the message into the type associated with the message dispatch // metadata and delegates to the messaging module to dispatch the message to // consumer handlers. private void MessageReceived(MessageConsumer messageConsumer, IModel channel, BasicDeliverEventArgs deliveryEvent) { IMessage message = _serializationMgr.Deserialize(messageConsumer.DispatchInfo.MessageType, deliveryEvent); message.SetAcknowledged(false); LogReceivedExchangeMessage(message, messageConsumer); // Delegate to the Messaging Module to dispatch the message to queue consumer. Task <object> futureResult = _messagingModule.InvokeDispatcherAsync( messageConsumer.DispatchInfo, message); futureResult.Wait(); if (!messageConsumer.QueueSettings.IsNoAck) { HandleAcknowledgeMessage(message, channel, deliveryEvent); } HandleRejectedMessage(message, channel, deliveryEvent); }
public ISubscription Subscribe <T>(Func <T, MessageContext, Task> callback, SubscriptionOptions?options = null) { var autoAck = options?.AutoAck ?? true; var exchange = options?.Exchange ?? _config.DefaultExchange; if (exchange is null) { throw new InvalidExchangeException(); } var model = CreateModel(); EnsureExchangeCreated(model, exchange, options.ExchangeType()); var queueName = EnsureQueueCreated(model, exchange, options?.Queue, options?.RoutingKeys); var consumer = new AsyncEventingBasicConsumer(model); var consumerTag = model.BasicConsume(queue: queueName, autoAck: autoAck, consumer: consumer); consumer.Received += async(_, eventArgs) => { var context = new MessageContext(eventArgs, autoAck, model); var activity = MessageDiagnostics.StartMessageIn(context); try { var obj = _serialization.Deserialize <T>(eventArgs.Body, eventArgs.BasicProperties.ContentType); await callback(obj, context); } finally { MessageDiagnostics.StopMessageIn(activity, context); } }; return(new SubscriptionImpl(model, consumerTag)); }
public static T Deserialize <T>(this ISerializationManager serializationManager, string input, Encoding encoding = null) { return((T)serializationManager.Deserialize(input, typeof(T), encoding)); }
public virtual T SerializeAndDeserialize(T source, SerializationContext serializationContext = null) { var stream = _serializationManager.Serialize(source); return(_serializationManager.Deserialize <T>(stream, serializationContext)); }
public object Get(string key, Type type) { var valueByteArray = blobCache.Get(key).Wait(); return(serializationManager.Deserialize(valueByteArray, type)); }
public virtual T SerializeAndDeserialize(T source) { var stream = _serializationManager.Serialize(source); return(_serializationManager.Deserialize <T>(stream)); }
public object Get(string key, Type type) { var value = cache.Get(key); return(serializationManager.Deserialize(value, type)); }
public TObject Deserialize <TObject>(byte[] serializationBytes, SerializationContext serializationContext = null) { return(_serializationManager.Deserialize <TObject>(decompressedByte(serializationBytes), serializationContext)); }
public static T Deserialize <T>(this ISerializationManager serializationManager, byte[] input) { return((T)serializationManager.Deserialize(input, typeof(T))); }
public TObject Deserialize <TObject>(string serializationString) { return(_serializationManager.Deserialize <TObject>(bytesFrom(serializationString))); }