public ISubscription SubscribeAsync <T>(Func <T, Task> subscribeMethod, SubscriptionConfiguration config) { var routingKey = config.RoutingKey; var topologyTask = _topologyProvider.BindQueueAsync(config.Queue, config.Exchange, routingKey); var channelTask = _channelFactory.CreateChannelAsync(); var subscriberTask = Task .WhenAll(topologyTask, channelTask) .ContinueWith(t => { if (topologyTask.IsFaulted) { throw topologyTask.Exception ?? new Exception("Topology Task Faulted"); } var consumer = _consumerFactory.CreateConsumer(config, channelTask.Result); consumer.OnMessageAsync = async(o, args) => { var body = _serializer.Deserialize <T>(args.Body); await subscribeMethod(body); }; consumer.Model.BasicConsume(config.Queue.FullQueueName, config.NoAck, consumer); _logger.LogDebug($"Setting up a consumer on channel '{channelTask.Result.ChannelNumber}' for queue {config.Queue.QueueName} with NoAck set to {config.NoAck}."); return(new Subscription(consumer, config.Queue.FullQueueName)); }); Task.WaitAll(subscriberTask); _subscriptions.Add(subscriberTask.Result); return(subscriberTask.Result); }
public async Task <TMessage> Get(TimeSpan?visibilityTimeout = null) { visibilityTimeout = visibilityTimeout ?? TimeSpan.FromMinutes(5); var message = await _cloudQueue.Value.GetMessageAsync(visibilityTimeout, null, null); return(await _messageSerializer.Deserialize <TMessage>( message.AsBytes, new MessageInfo( message.Id, message.InsertionTime.Value.UtcDateTime, message.ExpirationTime.Value.UtcDateTime, message.NextVisibleTime.Value.UtcDateTime, message.DequeueCount, message.PopReceipt))); }
public Message DeserializeMessage(string body) { foreach (var pair in _map) { TypeSerializer typeSerializer = pair.Value; string messageSubject = typeSerializer.Serializer.GetMessageSubject(body); if (string.IsNullOrWhiteSpace(messageSubject)) { continue; } Type matchedType = typeSerializer.Type; if (!string.Equals(_messageSubjectProvider.GetSubjectForType(matchedType), messageSubject, StringComparison.OrdinalIgnoreCase)) { continue; } IMessageSerializer messageSerializer = typeSerializer.Serializer; return(messageSerializer.Deserialize(body, matchedType)); } // TODO Maybe we should log the body separately (at debug/trace?), rather than include it in the exception message. Then they're easier to filter. throw new MessageFormatNotSupportedException( $"Message can not be handled - type undetermined. Message body: '{body}'"); }
private void Time(object message, IMessageSerializer serializer) { var watch = new Stopwatch(); watch.Start(); for (var i = 0; i < numberOfIterations; i++) { using (var stream = new MemoryStream()) serializer.Serialize(message, stream); } watch.Stop(); Debug.WriteLine("Serializing: " + watch.Elapsed); watch.Reset(); var s = new MemoryStream(); serializer.Serialize(message, s); var buffer = s.GetBuffer(); s.Dispose(); watch.Start(); for (var i = 0; i < numberOfIterations; i++) { using (var forDeserializing = new MemoryStream(buffer)) serializer.Deserialize(forDeserializing); } watch.Stop(); Debug.WriteLine("Deserializing: " + watch.Elapsed); }
public Task <IMessage> Send <TCommand>(string service, TCommand command) where TCommand : ICommand { var taskCompletionSource = new TaskCompletionSource <IMessage>(); var commandId = Guid.NewGuid().ToString(); var responseQueue = m_channel.QueueDeclare().QueueName; m_consumer.Consume(responseQueue, true, true, deliveryArgs => { if (deliveryArgs.BasicProperties != null && deliveryArgs.BasicProperties.CorrelationId == commandId && !string.IsNullOrEmpty(deliveryArgs.BasicProperties.Type)) { var response = m_serializer.Deserialize(deliveryArgs.BasicProperties.Type, deliveryArgs.Body); taskCompletionSource.SetResult(response); } else { taskCompletionSource.SetException(new DeliveryFailedException(deliveryArgs)); } }); var commandTopic = $"command.{service}.{command.GetType().Name}"; m_publisher.Publish(EXCHANGE_NAME, commandTopic, command, commandId, responseQueue); return(taskCompletionSource.Task); }
public static MailMessage DeserializeMessage(this IMessageSerializer messageSerializer, MessageContext context) { using (var stream = new MemoryStream(context.Body)) { return((MailMessage)messageSerializer.Deserialize(stream, new[] { typeof(MailMessage) }).Single()); } }
public static MailMessage DeserializeMessage(this IMessageSerializer messageSerializer, TransportMessage message) { using (var stream = new MemoryStream(message.Body)) { return((MailMessage)messageSerializer.Deserialize(stream, new[] { typeof(MailMessage) }).Single()); } }
public static void ShouldContain <TMessage>(this IInboundTransport transport, IMessageSerializer serializer) where TMessage : class { var future = new Future <TMessage>(); transport.Receive(context => { context.ShouldNotBeNull(); context.ShouldBeAnInstanceOf <IReceiveContext>(); serializer.Deserialize(context); IConsumeContext <TMessage> messageContext; if (context.TryGetContext(out messageContext)) { if (!future.IsCompleted) { future.Complete(messageContext.Message); } } return(null); }, TimeSpan.FromSeconds(3)); future.IsCompleted.ShouldBeTrue(transport.Address + " should contain a message of type " + typeof(TMessage).Name); }
private async Task <Envelope> DeserialzeEnvelope(EventData eventData) { object messageId; eventData.Properties.TryGetValue( "Khala.Envelope.MessageId", out messageId); object correlationId; eventData.Properties.TryGetValue( "Khala.Envelope.CorrelationId", out correlationId); using (Stream stream = eventData.GetBodyStream()) using (var reader = new StreamReader(stream, Encoding.UTF8)) { string value = await reader.ReadToEndAsync().ConfigureAwait(false); object message = _messageSerializer.Deserialize(value); return(new Envelope( ParseGuid(messageId) ?? Guid.NewGuid(), ParseGuid(correlationId), message)); } }
private void SocketListener_DataRecieved(object sender, SocketEventArgs e) { var connection = (Connection)e.Socket.UserToken; var message = messageSerializer.Deserialize(e.Data); connection.ReceiveMessage(message); }
public static void ShouldContain(this IInboundTransport transport, IMessageSerializer serializer, Type messageType) { var future = new Future <bool>(); transport.Receive(context => { context.ShouldNotBeNull(); context.ShouldBeAnInstanceOf <IReceiveContext>(); serializer.Deserialize(context); if (context.IsContextAvailable(messageType)) { if (!future.IsCompleted) { future.Complete(true); } } return(null); }, TimeSpan.FromSeconds(8)); future.IsCompleted.ShouldBeTrue(transport.Address + " should contain a message of type " + messageType.ToShortTypeName()); }
private void MessageReadTS() { _log.Debug(nameof(MessageReadTS)); while (!_readCancel.IsCancellationRequested) { Read(out Byte[] data); if (data.Length > 0) { IMessage message = _serializer.Deserialize(data); if (message.Command == Commands.Finished) { _readCancel.Cancel(); } RaiseMessageReceived(message); } Thread.Sleep(100); } try { _inReader.Close(); } catch (Exception ex) { _log.Error("Failed to disconnect.", ex); } _log.Debug($"Thread {nameof(MessageReadTS)} stopped."); }
/// <summary> /// This method processes records, performing retries as needed. /// </summary> /// <param name="records">The records to be processed.</param> protected void ProcessReceivedRecords(List <Record> records) { foreach (Record rec in records) { bool processedSuccessfully = false; TMessage data = null; try { // Use the passed in serializer to interpret the message data = serializer.Deserialize <TMessage>(rec.Data, rec.Data.Length); // Your own logic to process a record goes here. HandleMessage(data); processedSuccessfully = true; } catch (Exception e) { //Console.Error.WriteLine("Exception processing record data: " + data, e); HandleProcessingFailure(rec, e); } if (!processedSuccessfully) { //TODO: Decide what to do when message processing fails //The answer is probably explode and die // However the best way to do this is probably to just throw and exception from HandleProcessingFailure in the derived classes. } } }
public async Task <Tuple <long, T> > Get <T>(string bucket, Id streamId, Id[] parents) where T : class { var streamName = _streamGen(typeof(T), StreamTypes.Poco, bucket, streamId, parents); Logger.Write(LogLevel.Debug, () => $"Getting poco stream [{streamName}]"); if (_shouldCache) { var cached = _cache.Retreive(streamName) as Tuple <long, T>; if (cached != null) { Logger.Write(LogLevel.Debug, () => $"Found poco [{streamId}] bucket [{bucket}] version {cached.Item1} in cache"); return(new Tuple <long, T>(cached.Item1, // An easy way to make a deep copy _serializer.Deserialize <T>(_serializer.Serialize(cached.Item2)))); } } var read = await _store.GetEventsBackwards(streamName, StreamPosition.End, 1).ConfigureAwait(false); if (read == null || !read.Any()) { return(null); } var @event = read.Single(); if (_shouldCache) { _cache.Cache(streamName, @event.Event); } return(new Tuple <long, T>(@event.Descriptor.Version, @event.Event as T)); }
public object FromTransport(string serializedMessage, string serializedType) { var type = _messageTypeResolver.GetMessageType(serializedType); var message = _messageSerializer.Deserialize(type, serializedMessage); return(message); }
private void WireUpConsumer(IRawConsumer consumer, IConsumerConfiguration cfg) { consumer.OnMessageAsync = (o, args) => { ResponseCompletionSource responseTcs = null; return(_errorStrategy.ExecuteAsync(() => { if (_responseDictionary.TryRemove(args.BasicProperties.CorrelationId, out responseTcs)) { _logger.LogDebug($"Recived response with correlationId {args.BasicProperties.CorrelationId}."); responseTcs.RequestTimer.Dispose(); _errorStrategy.OnResponseRecievedAsync(args, responseTcs); if (responseTcs.Task.IsFaulted) { return _completed; } var response = _serializer.Deserialize(args); responseTcs.TrySetResult(response); return _completed; } _logger.LogWarning($"Unable to find callback for {args.BasicProperties.CorrelationId}."); return _completed; }, exception => _errorStrategy.OnResponseRecievedException(consumer, cfg, args, responseTcs, exception))); }; }
private void Time(IMessage[] messages, IMessageSerializer serializer) { Stopwatch watch = new Stopwatch(); watch.Start(); for (int i = 0; i < numberOfIterations; i++) using (MemoryStream stream = new MemoryStream()) serializer.Serialize(messages, stream); watch.Stop(); Debug.WriteLine("Serializing: " + watch.Elapsed); watch.Reset(); MemoryStream s = new MemoryStream(); serializer.Serialize(messages, s); byte[] buffer = s.GetBuffer(); s.Dispose(); Console.WriteLine(Encoding.ASCII.GetString(buffer)); watch.Start(); object[] result = null; for (int i = 0; i < numberOfIterations; i++) using (var forDeserializing = new MemoryStream(buffer)) result = serializer.Deserialize(forDeserializing); watch.Stop(); Debug.WriteLine("Deserializing: " + watch.Elapsed); }
public async Task <object> SendRequest(Uri uri, object requestData, CancellationToken cancellationToken = default) { if (uri == null) { throw new ArgumentNullException(nameof(uri)); } if (requestData == null) { throw new ArgumentNullException(nameof(requestData)); } var payload = await _serializer.Serialize(requestData); var content = new StreamContent(payload); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var requestMessage = new HttpRequestMessage(HttpMethod.Post, uri); requestMessage.Content = content; var handle = BuildHandler(_httpClient, _httpMessageHandlers, requestMessage, cancellationToken); var responseMessage = await handle(); responseMessage.EnsureSuccessStatusCode(); var resultStream = await responseMessage.Content.ReadAsStreamAsync(); return(await _serializer.Deserialize(resultStream)); }
private void TriggerMessageReceived(HttpMessage message) { var request = message as HttpRequest; if (_messageSerializer != null && request != null) { if (message.Body != null && message.Body.Length > 0) { var result = _messageSerializer.Deserialize(message.Headers["Content-Type"], message.Body); if (result == null) { throw new BadRequestException("Unsupported content-type: " + message.ContentType); } var formAndFiles = result as FormAndFilesResult; if (formAndFiles != null) { request.Form = formAndFiles.Form; request.Files = formAndFiles.Files; } else { throw new HttpException(500, "Unknown decoder result: " + result); } } var cookies = request.Headers["Cookie"]; if (cookies != null) { request.Cookies = _cookieParser.Parse(cookies); } } _messageReceived(message); }
public static UnpackedMessage ReadDataMessage(byte[] buffer, IMessageSerializer serializer) { var header = ReadHeader(buffer); if (header.MessageFormatVersion != MessageHeader.DataMessageFormatVersion) { throw new InvalidOperationException("Unexpected message format"); } var attributes = ReadAttributes(buffer, header); string contract = attributes .GetAttributeString(MessageAttributeTypeContract.ContractName) .ExposeException("Protocol violation: message should have contract name"); var type = serializer .GetTypeByContractName(contract) .ExposeException("Unsupported contract name: '{0}'", contract); var index = MessageHeader.FixedSize + (int)header.AttributesLength; var count = (int)header.ContentLength; using (var stream = new MemoryStream(buffer, index, count)) { var instance = serializer.Deserialize(stream, type); return(new UnpackedMessage(header, attributes, instance, type)); } }
public async Task Handle(TNotification notification, CancellationToken cancellationToken = default) { if (notification == null) { throw new ArgumentNullException(nameof(notification)); } var requestMessagePayloadStream = (await _messageSerializer.Serialize(notification, _messageMetadata.RequestMetadata)) ?? throw new InvalidOperationException("Request message payload was serialized to a null value"); var responseMessagePayloadStream = await _messageTransport.SendRequest(_uri, requestMessagePayloadStream, cancellationToken); var messageSerializerResult = (await _messageSerializer.Deserialize(responseMessagePayloadStream)) ?? throw new InvalidOperationException("Response message payload was deserialized to a null value"); foreach (var metaData in messageSerializerResult.MessageMetadata) { _messageMetadata.ResponseMetadata.Add(metaData); } if (messageSerializerResult.Message != null) { throw new InvalidOperationException($"Response message contained a message payload, but was not expected to"); } }
public static IMessage Deserialize(BinaryReader reader, MavMessageType mavType) { IMessageSerializer serializer = CreateSerializer(mavType); IMessage message = serializer?.Deserialize(reader); return(message); }
public ISubscription SubscribeAsync <T>(Func <T, TMessageContext, Task> subscribeMethod, SubscriptionConfiguration config) { var routingKey = _config.RouteWithGlobalId ? $"{config.RoutingKey}.#" : config.RoutingKey; var topologyTask = _topologyProvider.BindQueueAsync(config.Queue, config.Exchange, routingKey); var channelTask = _channelFactory.CreateChannelAsync(); var subscriberTask = Task .WhenAll(topologyTask, channelTask) .ContinueWith(t => { var consumer = _consumerFactory.CreateConsumer(config, channelTask.Result); consumer.OnMessageAsync = (o, args) => _errorHandling.ExecuteAsync(() => { var body = _serializer.Deserialize <T>(args.Body); var context = _contextProvider.ExtractContext(args.BasicProperties.Headers[PropertyHeaders.Context]); _contextEnhancer.WireUpContextFeatures(context, consumer, args); return(subscribeMethod(body, context)); }, exception => _errorHandling.OnSubscriberExceptionAsync(consumer, config, args, exception)); consumer.Model.BasicConsume(config.Queue.FullQueueName, config.NoAck, consumer); _logger.LogDebug($"Setting up a consumer on channel '{channelTask.Result.ChannelNumber}' for queue {config.Queue.QueueName} with NoAck set to {config.NoAck}."); return(new Subscription(consumer, config.Queue.QueueName)); }); Task.WaitAll(subscriberTask); _subscriptions.Add(subscriberTask.Result); return(subscriberTask.Result); }
public async ValueTask <object> ReceiveAsync(CancellationToken cancellationToken) { var message = await _connection.ReceiveAsync(cancellationToken) .ConfigureAwait(false); if (message is not MessageData messageData) { throw new InvalidOperationException($"Received invalid message: {message.GetType().Name} is not a {typeof(MessageData).Name} type."); } var data = messageData.Data; var messageType = _messageTypeCache.GetTypeById(messageData.TypeId); var deserialized = _serializer.Deserialize(data, messageType); // TODO: Consider using MetadataFactory here (but set messageId to null, because it wasn't passed). // Probably best to implement CreateEmpty() method on MetadataFactory. if (messageData.Metadata == null) { messageData.Metadata = MessageMetadata.CreateEmpty(); } return(new MessageWithMetadata { Message = deserialized, Metadata = messageData.Metadata }); }
/// <summary> /// Fetches a weather report from the API for the given coordinates. /// </summary> public async Task <WeatherReport> GetWeatherReport(double latitude, double longitude) { var responseString = await _httpClient.GetStringAsync( $"data/2.5/weather?lat={latitude}&lon={longitude}&APPID={config.Key}&units=metric"); return(_messageSerializer.Deserialize <WeatherReport>(responseString)); }
protected object[] DeserializeMessages(OpenedQueue messageQueue, Message transportMessage, Action <CurrentMessageInformation, Exception> messageSerializationException) { try { return(messageSerializer.Deserialize(transportMessage.BodyStream)); } catch (Exception e) { try { logger.Error("Error when serializing message", e); if (messageSerializationException != null) { var information = new MsmqCurrentMessageInformation { MsmqMessage = transportMessage, Queue = messageQueue, Message = transportMessage, Source = messageQueue.RootUri, MessageId = transportMessage.GetMessageId(), Headers = transportMessage.Extension.DeserializeHeaders(), }; messageSerializationException(information, e); } } catch (Exception moduleEx) { logger.Error("Error when notifying about serialization exception", moduleEx); } throw; } }
protected T SerializeAndReturn <T>(T obj) where T : class { byte[] serializedMessageData; using (var output = new MemoryStream()) { _serializer.Serialize(output, obj.ToSendContext()); serializedMessageData = output.ToArray(); // Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData)); } using (var input = new MemoryStream(serializedMessageData)) { IReceiveContext receiveContext = ReceiveContext.FromBodyStream(input); _serializer.Deserialize(receiveContext); IConsumeContext <T> context; receiveContext.TryGetContext(out context).ShouldBeTrue(); context.ShouldNotBeNull(); return(context.Message); } }
internal SolaceMessage(IMessage mbMessage, IMessageSerializer serializer, Action acknowledgeAction, Action abortAction) { this.CorrelationId = mbMessage.CorrelationId; this.Content = serializer.Deserialize <TContent>((byte[])(Array)mbMessage.GetBinaryAttachment()); this.ackAction = acknowledgeAction; this.abortAction = abortAction; }
private Envelope RestoreEnvelope(PendingEvent pendingEvent) => new Envelope( pendingEvent.MessageId, _serializer.Deserialize(pendingEvent.EventJson), pendingEvent.OperationId, pendingEvent.CorrelationId, pendingEvent.Contributor);
public async Task <T> GetSaga <T>(string partitionKey, string id) { using (var connection = await GetConnection().ConfigureAwait(false)) { var sql = $@"SELECT Json FROM {_schema}.{_tableName} WHERE PartitionKey = @PartitionKey AND Id = @Id AND Expiration > @UtcNow"; var command = GetCommandWithParameters(sql, connection, partitionKey, id); try { var result = await command.ExecuteReaderAsync(CommandBehavior.SingleResult).ConfigureAwait(false); if (!result.HasRows) { throw new SagaNotFoundException(partitionKey, id); } await result.ReadAsync().ConfigureAwait(false); var json = result.GetString(0); return(_serializer.Deserialize <T>(json)); } catch (SqlException e) when(e.Number == 208) { await CreateSagaTable(connection); return(await GetSaga <T>(partitionKey, id).ConfigureAwait(false)); } } }
private object[] DeserializeMessages(Message message) { try { return(messageSerializer.Deserialize(new MemoryStream(message.Data))); } catch (Exception e) { try { logger.Error("Error when serializing message", e); var serializationError = MessageSerializationException; if (serializationError != null) { currentMessageInformation = new RhinoQueueCurrentMessageInformation { Message = message, Source = new Uri(message.Headers["source"]), MessageId = new Guid(message.Headers["id"]), TransportMessageId = message.Id.ToString(), TransportMessage = message, Queue = queue, }; serializationError(currentMessageInformation, e); } } catch (Exception moduleEx) { logger.Error("Error when notifying about serialization exception", moduleEx); } throw; } }
internal static object Reserialize(IMessageSerializer serializer, object message) { if (serializer == null) return message; var writer = new BinaryTokenStreamWriter(); serializer.Serialize(message, writer); var bytes = writer.ToByteArray(); var reader = new BinaryTokenStreamReader(bytes); return serializer.Deserialize(reader); }
private IMessage InvokeMutators(IMessage message, IMessageSerializer serializer) { var messageToSerialize = messageMutator.MutateOutgoing(message); using (var stream = new MemoryStream()) { serializer.Serialize(new[] { messageToSerialize }, stream); stream.Position = 0; var result = serializer.Deserialize(stream)[0]; return messageMutator.MutateIncoming(result); } }
IObservable<object> ListenForMessages(ZmqContext context, string address, IMessageSerializer serializer) { return Observable.Create<object> ( o => { _socket.Connect(address); var poller = _scheduler.SchedulePeriodic ( _pollInterval, () => { try { var msg = _socket.ReceiveMessage(TimeSpan.Zero); while (msg != null && msg.FrameCount == 3) { var typeName = ZmqContext.DefaultEncoding.GetString(msg[1].Buffer); var type = MessageTypeRegistry.Resolve(typeName); var data = msg[2].Buffer; if (type != null) { var poco = serializer.Deserialize(data, type); o.OnNext(poco); } msg = _socket.ReceiveMessage(TimeSpan.Zero); } } catch (Exception ex) { o.OnError(ex); } } ); return new CompositeDisposable(poller, Disposable.Create(() => _socket.Disconnect(address))); } ) .SubscribeOn(_scheduler) .ObserveOn(_scheduler) .Publish() .RefCount(); }