async public Task <Dictionary <ServiceDictionaryKey, object> > TryGetMeals(int patientId) { Dictionary <ServiceDictionaryKey, object> dictionary = new Dictionary <ServiceDictionaryKey, object>(); try { List <Meal> meals = await _mealRepository.GetMyMeals(patientId); if (meals.Count <= 0) { dictionary.Add(ServiceDictionaryKey.ERROR, $"No meals meals for the given user: {patientId}."); dictionary.Add(ServiceDictionaryKey.HTTPSTATUSCODE, HttpStatusCode.NotFound); return(dictionary); } dynamic data = _messageSerializer.Serialize(meals); dictionary.Add(ServiceDictionaryKey.VALUE, data); } catch (Exception ex) { dictionary.AddErrorMessage(ServiceDictionaryKey.ERROR, ex, FeedbackHandler); } return(dictionary); }
public void Serialize <T>(Stream output, T message) { try { using (var clearStream = new MemoryStream()) { _xmlSerializer.Serialize(clearStream, message); clearStream.Seek(0, SeekOrigin.Begin); using (ICryptographyService cryptographyService = new RijndaelCryptographyService(_key)) { EncryptedStream encryptedStream = cryptographyService.Encrypt(clearStream); var encryptedMessage = new EncryptedMessageEnvelope { CipheredMessage = Convert.ToBase64String(encryptedStream.GetBytes()), Iv = Convert.ToBase64String(encryptedStream.Iv), }; _xmlSerializer.Serialize(output, encryptedMessage); } } } catch (SerializationException) { throw; } catch (Exception ex) { throw new SerializationException("Failed to serialize message", ex); } }
public async Task AdvertiseAsync_MessageDispatcherStarted_WebSocketShouldSendCorrectByteArray() { //arrange RosAdvertiseMessage rosAdvertiseMessage = new RosAdvertiseMessage() { Id = _publisher._uniqueId, Topic = TOPIC, Type = TYPE }; byte[] serialized = _messageSerializer.Serialize(rosAdvertiseMessage); _clientWebSocketMock.SetupGet(clientWebSocket => clientWebSocket.State).Returns(WebSocketState.Open); await _messageDispatcher.StartAsync(); //act await _publisher.AdvertiseAsync(); //assert _clientWebSocketMock.Verify(clientWebSocket => clientWebSocket.SendAsync( It.Is <ArraySegment <byte> >(arraySegment => arraySegment.Array.SequenceEqual(serialized)), WebSocketMessageType.Text, true, _cancellationTokenSource.Token)); }
public async Task DeadLetterAsync(StorageQueueMessage message) { var deadLetterMessage = new CloudQueueMessage(_serializer.Serialize(message.Properties)); await _dlQueue.AddMessageAsync(deadLetterMessage, TimeSpan.MaxValue, null, null, null) .ContinueWith(task => _queue.DeleteMessageAsync(message.QueueMessageId, message.PopReceipt), TaskContinuationOptions.OnlyOnRanToCompletion) .ConfigureAwait(false); }
protected T SerializeAndReturn <T>(T obj) where T : class { byte[] serializedMessageData; using (var output = new MemoryStream()) { var sendContext = new InMemorySendContext <T>(obj); sendContext.SourceAddress = _sourceAddress; sendContext.DestinationAddress = _destinationAddress; sendContext.FaultAddress = _faultAddress; sendContext.ResponseAddress = _responseAddress; sendContext.RequestId = _requestId; Serializer.Serialize(output, sendContext); serializedMessageData = output.ToArray(); Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData)); } return(Return <T>(serializedMessageData)); }
public async Task <Dictionary <ServiceDictionaryKey, object> > TryGetFavoriteFood(int patientId) { Dictionary <ServiceDictionaryKey, object> dictionary = new Dictionary <ServiceDictionaryKey, object>(); try { List <Food> foods = await _foodRepository.Favorites(patientId); if (foods.Count <= 0) { dictionary.Add(ServiceDictionaryKey.ERROR, $"No favorites found for given ID: {patientId}."); dictionary.Add(ServiceDictionaryKey.HTTPSTATUSCODE, HttpStatusCode.NotFound); return(dictionary); } dynamic data = _messageSerializer.Serialize(foods); dictionary.Add(ServiceDictionaryKey.VALUE, data); } catch (Exception ex) { dictionary.AddErrorMessage(ServiceDictionaryKey.ERROR, ex, FeedbackHandler); } return(dictionary); }
private void Send <T>(T message, string topic) { if (message == null) { throw new ArgumentNullException("message"); } if (string.IsNullOrEmpty(topic)) { throw new ArgumentNullException("topic"); } // mutate if (_messageMutator != null) { message = _messageMutator.GetMutatedMessage(this, message); } // route if (_messageTopicRouter != null) { topic = _messageTopicRouter.GetMessageTopic(this, topic, message); } // serialize byte[] serializedMessage = _sendMessageSerializer.Serialize(message); // send _nsqdPublisher.Publish(topic, serializedMessage); }
public void ChunkIfNeeded_SmallMessage_ReturnedWithoutChanges() { var message = new BinaryMessage { MessageId = Guid.NewGuid(), Content = GetByteArray(100) }; var headers = new MessageHeaderCollection(); var serializedMessage = _serializer.Serialize(message, headers); var rawBrokerMessage = new RawBrokerMessage(message, headers, new TestProducerEndpoint("test") { Chunk = new ChunkSettings { Size = 500 } }) { RawContent = serializedMessage }; var chunks = ChunkProducer.ChunkIfNeeded(rawBrokerMessage); chunks.Should().HaveCount(1); chunks.First().Should().BeEquivalentTo(rawBrokerMessage); }
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); }
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 bool ConsumeAddInstanceSubscription( AddInstanceSubscription subscription) { pht.Batch(actions => { var message = new MemoryStream(); messageSerializer.Serialize(new[] { subscription }, message); var itemId = actions.AddItem(new AddItemRequest { Key = SubscriptionsKey, Data = message.ToArray() }); remoteInstanceSubscriptions.Add( subscription.InstanceSubscriptionKey, subscription.Type, new Uri(subscription.Endpoint), itemId); actions.Commit(); }); RaiseSubscriptionChanged(); return(true); }
public virtual Task OnResponseHandlerExceptionAsync(IRawConsumer rawConsumer, IConsumerConfiguration cfg, BasicDeliverEventArgs args, Exception exception) { _logger.LogError($"An unhandled exception was thrown in the response handler for message '{args.BasicProperties.MessageId}'.", exception); var innerException = UnwrapInnerException(exception); var exceptionInfo = new MessageHandlerExceptionInformation { Message = $"An unhandled exception was thrown when consuming a message\n MessageId: {args.BasicProperties.MessageId}\n Queue: '{cfg.Queue.FullQueueName}'\n Exchange: '{cfg.Exchange.ExchangeName}'\nSee inner exception for more details.", ExceptionType = innerException.GetType().FullName, StackTrace = innerException.StackTrace, InnerMessage = innerException.Message }; _logger.LogInformation($"Sending MessageHandlerException with CorrelationId '{args.BasicProperties.CorrelationId}'"); rawConsumer.Model.BasicPublish( exchange: string.Empty, routingKey: args.BasicProperties?.ReplyTo ?? string.Empty, basicProperties: _propertiesProvider.GetProperties <MessageHandlerExceptionInformation>(p => { p.CorrelationId = args.BasicProperties?.CorrelationId ?? string.Empty; p.Headers.Add(PropertyHeaders.ExceptionHeader, _messageExceptionName); }), body: _serializer.Serialize(exceptionInfo) ); if (!cfg.NoAck) { _logger.LogDebug($"Nack'ing message with delivery tag '{args.DeliveryTag}'."); rawConsumer.Model.BasicNack(args.DeliveryTag, false, false); } return(Task.FromResult(true)); }
public async Task <T> Create <T>(string partitionKey, string id, T sagaData) { var json = _serializer.Serialize(sagaData); using (var connection = await GetConnection().ConfigureAwait(false)) { var sql = $@"INSERT INTO {_schema}.{_tableName} (PartitionKey, Id, Json) VALUES (@PartitionKey, @Id, @Json)"; var command = GetCommandWithParameters(sql, connection, partitionKey, id); command.Parameters.AddWithValue("@Json", json); try { await command.ExecuteNonQueryAsync(); } catch (SqlException e) when(e.Number == 208) { await CreateSagaTable(connection); return(await Create(partitionKey, id, sagaData).ConfigureAwait(false)); } catch (SqlException e) when(e.Number == 2627) { throw new SagaAlreadyStartedException(partitionKey, id); } } return(sagaData); }
protected virtual byte[] OnEncode(object message) { if (message == null) { return(new byte[0]); } if (message.GetType() == typeof(byte[])) { return((byte[])message); } if (message is InvokeMessage invoke) { //var model = Activator.CreateInstance(typeof(TInvoke),invoke); var model = new TInvoke(); model.SetValue(invoke); return(_serializer.Serialize(model)); } if (message is MessageResult result) { var model = new TResult(); model.SetResult(result); return(_serializer.Serialize(model)); } return(_serializer.SerializeNoType(message)); }
/// <summary> /// Performs the actual publishing of a message to the bus /// </summary> /// <param name="message">Message to publish</param> /// <param name="type">Type of the message</param> private void InternalPublish(object message, Type type) { Log.TraceFormat("Publishing message of type {0}", type); string messageString = _messageSerializer.Serialize(message); _messagePublisher.Publish(messageString, type); Log.TraceFormat("Published message of type {0}", type); }
public static void Test <T>(IMessageSerializer <T> serializer, T message) where T : P2PMessage { byte[] serialized = serializer.Serialize(message); T deserialized = serializer.Deserialize(serialized); byte[] serializedAgain = serializer.Serialize(deserialized); Assert.AreEqual(serialized.ToHexString(), serializedAgain.ToHexString(), "test old way"); }
public async Task AddSubscriberAsync <TMessage>(MessageSubscriber <TMessage> messageSubscriber) where TMessage : Message { var subscriberKey = exchangeSubscribersResolver.GetSubscriberKey <TMessage>(); var serialized = messageSerializer.Serialize(messageSubscriber.MessageSubscriberInfo); await database.SetAddAsync(subscriberKey, serialized); }
public async Task <Dictionary <ServiceDictionaryKey, object> > TryGetPatientById(HttpRequest req, string idText) { Dictionary <ServiceDictionaryKey, object> dictionary = new Dictionary <ServiceDictionaryKey, object>(); if (!_queryHelper.IsValidId(dictionary, idText)) { return(dictionary); } try { int id = Int32.Parse(idText); // Auth try { if (!await IsAuthorized(dictionary, req, id)) { return(dictionary); } } catch { dictionary.Add(ServiceDictionaryKey.ERROR, "Auth threw an error. Has the token lifetime expired?"); dictionary.Add(ServiceDictionaryKey.HTTPSTATUSCODE, HttpStatusCode.Unauthorized); return(dictionary); } Patient patient = await _patientRepository.Select(id); if (patient.PatientId <= 0) { dictionary.Add(ServiceDictionaryKey.ERROR, $"No patient found for given ID: {id}."); dictionary.Add(ServiceDictionaryKey.HTTPSTATUSCODE, HttpStatusCode.NotFound); return(dictionary); } PatientReturnModel returnModel = new PatientReturnModel() { Id = patient.PatientId, DateOfBirth = patient.DateOfBirth, WeightInKilograms = patient.WeightInKilograms, FirstName = patient.FirstName, LastName = patient.LastName }; dynamic data = _messageSerializer.Serialize(returnModel); dictionary.Add(ServiceDictionaryKey.VALUE, data); } catch (Exception ex) { dictionary.AddErrorMessage(ServiceDictionaryKey.ERROR, ex, FeedbackHandler); } return(dictionary); }
public Task EnqueueAsync(ClaimsPrincipal user, IReadOnlyCollection <Message> messages) { foreach (var msg in messages) { var dto = new AdoNetMessageDto(user, msg, _messageSerializer); _messageSerializer.Serialize(dto, out var json, out var contentType); InsertMessage(json, contentType); } return(Task.FromResult <object>(null)); }
public Task <long> WriteEvents(string stream, IFullEvent[] events, IDictionary <string, string> commitHeaders, long?expectedVersion = null) { _cache.Evict(stream); var translatedEvents = events.Select(e => { var descriptor = new EventDescriptor { EventId = e.EventId ?? Guid.NewGuid(), CommitHeaders = (commitHeaders ?? new Dictionary <string, string>()).Merge(new Dictionary <string, string> { [Defaults.InstanceHeader] = Defaults.Instance.ToString(), [Defaults.EndpointHeader] = Configuration.Settings.Endpoint, [Defaults.EndpointVersionHeader] = Configuration.Settings.EndpointVersion.ToString(), [Defaults.AggregatesVersionHeader] = Configuration.Settings.AggregatesVersion.ToString(), [Defaults.MachineHeader] = Environment.MachineName }), Compressed = _compress.HasFlag(Compression.Events), EntityType = e.Descriptor.EntityType, StreamType = e.Descriptor.StreamType, Bucket = e.Descriptor.Bucket, StreamId = e.Descriptor.StreamId, Parents = e.Descriptor.Parents, Version = e.Descriptor.Version, Timestamp = e.Descriptor.Timestamp, Headers = e.Descriptor.Headers, }; var mappedType = e.Event.GetType(); if (!mappedType.IsInterface) { mappedType = _mapper.GetMappedTypeFor(mappedType) ?? mappedType; } var @event = _serializer.Serialize(e.Event); if (_compress.HasFlag(Compression.Events)) { descriptor.Compressed = true; @event = @event.Compress(); } var metadata = _serializer.Serialize(descriptor); return(new EventData( descriptor.EventId, mappedType.AssemblyQualifiedName, !descriptor.Compressed, @event, metadata )); }).ToArray(); return(DoWrite(stream, translatedEvents, expectedVersion)); }
public NetMQMessage Marshall(Message msg) { var json = _serializer.Serialize(msg); var result = new NetMQMessage(new[] { new NetMQFrame(InternalMessage), new NetMQFrame(json), }); return(result); }
public async ValueTask SendAsync <TTopic, TMessage>( TTopic topic, TMessage message, CancellationToken cancellationToken = default) where TTopic : notnull { ISubscriber subscriber = _connection.GetSubscriber(); var serializedTopic = topic is string s ? s : _messageSerializer.Serialize(topic); var serializedMessage = _messageSerializer.Serialize(message); await subscriber.PublishAsync(serializedTopic, serializedMessage).ConfigureAwait(false); }
private void Send(object obj) { var msg = new Message { Label = obj.ToString(), Extension = Guid.NewGuid().ToByteArray() }; messageSerializer.Serialize(new[] { obj }, msg.BodyStream); queue.Send(msg); }
public async Task <T> Create <T>(string partitionKey, string id, T sagaData, TimeSpan ttl) { var saga = _serializer.Serialize(sagaData); var sagaSaved = await _db.StringSetAsync(GetKey(partitionKey, id), saga, ttl, When.NotExists).ConfigureAwait(false); if (!sagaSaved) { throw new SagaAlreadyStartedException(partitionKey, id); } return(sagaData); }
public void ShouldRegisterSerializableTypesFromAssembly() { BinaryMessageSerializer.RegsterSerializableFrom(GetType().Assembly); var bytes1 = _subject.Serialize(new ResponseMessage("1", new Greeting1 { Hello = "hello" })); var bytes2 = _subject.Serialize(new ResponseMessage("1", new Greeting2 { Hello = "hello" })); Assert.That(bytes1.Length, Is.LessThan(bytes2.Length)); }
public static void Test <T>(IMessageSerializer <T> serializer, T message, string expectedData = null) where T : P2PMessage { byte[] serialized = serializer.Serialize(message); T deserialized = serializer.Deserialize(serialized); byte[] serializedAgain = serializer.Serialize(deserialized); Assert.AreEqual(serialized.ToHexString(), serializedAgain.ToHexString(), "test old way"); if (expectedData != null) { Assert.AreEqual(expectedData, serialized.ToHexString()); } }
public NetMQMessage Marshall(RoutableMessage msg) { var json = _serializer.Serialize(msg); var result = new NetMQMessage(new[] { new NetMQFrame(RoutableMessage), new NetMQFrame(EmptyByteArray), new NetMQFrame(msg.RoutingTarget.Bytes), new NetMQFrame(EmptyByteArray), new NetMQFrame(json), }); return(result); }
private async Task <object> SendInternalAsync <TMessage>(TMessage message, CancellationToken cancellation) { ThrowIfDisposed(); await Initialization; // Reserve a new slot in the response table. using (var responseTableSlot = new ResponseTableSlot(this)) { _logger?.LogInformation($"Sending message of type '{typeof(TMessage).FullName}' with seq-num '{responseTableSlot.SeqNum}'."); cancellation.ThrowIfCancellationRequested(); try { // Serialize the message and send it. await SendPayloadAsync(_serializer.Serialize(message, MessageEncoding.Bson), responseTableSlot.SeqNum, 0, MessageType.Message, MessageEncoding.Bson, cancellation); } catch (Exception exc) when(!(exc is ObjectDisposedException)) { _logger?.LogError($"The message with the seq-num '{responseTableSlot.SeqNum}' could not be sent.", exc); throw; } _logger?.LogInformation($"Sent message with seq-num '{responseTableSlot.SeqNum}'. Waiting for response."); try { // Wait for a reponse fromthe remote end-point or cancellation alternatively. await Task.WhenAny(responseTableSlot.Response, cancellation.AsTask()); } catch (MessageHandlerNotFoundException) { _logger?.LogInformation($"The receiver cannot handle the message with seq-num '{responseTableSlot.SeqNum}'. No suitable message handler was found."); throw; } catch (Exception exc) when(!(exc is OperationCanceledException)) { _logger?.LogInformation($"Received response for the message with seq-num '{responseTableSlot.SeqNum}'."); throw; } _logger?.LogInformation($"Received response for the message with seq-num '{responseTableSlot.SeqNum}'."); return(await responseTableSlot.Response); } }
public async Task PublishAsync <T>(T message, PublishOptions?options = null, SchedulingOptions?scheduling = null, bool triggerSaveChanges = true, CancellationToken cancellationToken = default) where T : class { var address = options?.TargetAddress; if (address == null) { address = _addressProvider.Get(message, options); } var now = DateTime.UtcNow; var scheduled = now; if (scheduling != null) { if (scheduling.ExactDateTime != null) { scheduled = scheduling.ExactDateTime.Value; } else if (scheduling.RelativeFromNow != null && scheduling.RelativeFromNow > TimeSpan.Zero) { scheduled = now.Add(scheduling.RelativeFromNow.Value); } if (scheduled < now) { scheduled = now; } } var entity = new OutboxMessage { OutboxMessageId = Guid.NewGuid(), Created = now, Scheduled = scheduled, Published = null, TargetAddress = address, Body = _serializer .Serialize(message) .ToArray(), Options = options != null ? _serializer.Serialize(options).ToArray() : null }; await _messageStore.SaveAsync <T>(entity, message.GetType(), triggerSaveChanges, cancellationToken).ConfigureAwait(false); StreamFlowOutboxPublisher.Continue.Set(); }
public Task <long> WriteEvents(string stream, IFullEvent[] events, IDictionary <string, string> commitHeaders, long?expectedVersion = null) { Logger.Write(LogLevel.Debug, () => $"Writing {events.Count()} events to stream id [{stream}]. Expected version: {expectedVersion}"); var translatedEvents = events.Select(e => { var descriptor = new EventDescriptor { EventId = e.EventId ?? Guid.NewGuid(), CommitHeaders = commitHeaders ?? new Dictionary <string, string>(), Compressed = _compress.HasFlag(Compression.Events), EntityType = e.Descriptor.EntityType, StreamType = e.Descriptor.StreamType, Bucket = e.Descriptor.Bucket, StreamId = e.Descriptor.StreamId, Parents = e.Descriptor.Parents, Version = e.Descriptor.Version, Timestamp = e.Descriptor.Timestamp, Headers = e.Descriptor.Headers }; var mappedType = e.Event.GetType(); if (!mappedType.IsInterface) { mappedType = _mapper.GetMappedTypeFor(mappedType) ?? mappedType; } var @event = _serializer.Serialize(e.Event); if (_compress.HasFlag(Compression.Events)) { descriptor.Compressed = true; @event = @event.Compress(); } var metadata = _serializer.Serialize(descriptor); return(new EventData( descriptor.EventId, mappedType.AssemblyQualifiedName, !descriptor.Compressed, @event, metadata )); }).ToArray(); return(DoWrite(stream, translatedEvents, expectedVersion)); }
public Task PublishAsync <TMessage>(TMessage message, Guid globalMessageId, PublishConfiguration config) { var context = _contextProvider.GetMessageContext(globalMessageId); var props = _propertiesProvider.GetProperties <TMessage>(config.PropertyModifier + (p => p.Headers.Add(PropertyHeaders.Context, context))); Task exchangeTask; lock (_topologyLock) { exchangeTask = _topologyProvider.DeclareExchangeAsync(config.Exchange); } var channelTask = _channelFactory.GetChannelAsync(); return(Task .WhenAll(exchangeTask, channelTask) .ContinueWith(t => { lock (_publishLock) { var ackTask = _acknowledger.GetAckTask(channelTask.Result); channelTask.Result.BasicPublish( exchange: config.Exchange.ExchangeName, routingKey: _config.RouteWithGlobalId ? $"{config.RoutingKey}.{globalMessageId}" : config.RoutingKey, basicProperties: props, body: _serializer.Serialize(message) ); return ackTask; } }) .Unwrap()); }
public static Message FromObject(object obj, IMessageSerializer serializer) { return new Message { AssemblyQualifiedName = obj.GetType().AssemblyQualifiedName, ID = Guid.NewGuid(), TypeName = obj.GetType().Name, Body = serializer.Serialize(obj) }; }
public static ChannelMessage CreateChannelMessage(object message, IMessageSerializer messageSerializer) { if (messageSerializer == null) throw new ArgumentNullException(nameof(messageSerializer)); var messageType = message.GetType(); var stream = messageSerializer.Serialize(message); var channelMessage = new ChannelMessage(stream); channelMessage.AddHeader(MessageHeaders.MessageType, messageType.FullName); channelMessage.AddHeader(MessageHeaders.UserPrincipal, Environment.UserName); channelMessage.AddHeader(MessageHeaders.SendingMachine, Environment.MachineName); channelMessage.AddHeader(MessageHeaders.SendingModule, ResolveAssemblyFullName()); return channelMessage; }
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); } }
public static void Convert(TransportMessage message, IBytesMessage toSend, IMessageSerializer serializer) { byte[] body; if (message.Body == null && message.BodyStream != null) { body = message.BodyStream.ToBytes(); } else { var stream = new MemoryStream(); serializer.Serialize(message.Body, stream); body = stream.ToBytes(); } toSend.WriteBytes(body); // TODO: clarify usage of JMSCorrelationID toSend.JMSCorrelationID = message.CorrelationId; toSend.JMSDeliveryMode = message.Recoverable ? DeliveryMode.Persistent : DeliveryMode.NonPersistent; toSend.SetStringProperty(HEADER_RETURNADDRESS, message.ReturnAddress); toSend.SetStringProperty(HEADER_IDFORCORRELATION, message.IdForCorrelation); toSend.SetStringProperty(HEADER_WINDOWSIDENTITYNAME, message.WindowsIdentityName); toSend.SetIntProperty(HEADER_MESSAGEINTENT, (int) message.MessageIntent); //TODO: set message expiration //toSend.JMSReplyTo = new Destination message.ReplyToAddress; //if (message.TimeToBeReceived < MessageQueue.InfiniteTimeout) //toSend.JMSExpiration = (long) UTCNow.message.TimeToBeReceived.TotalMilliseconds; if (message.Headers == null) message.Headers = new List<HeaderInfo>(); var nsbHeaderKeys = new List<string>(); foreach (var keyValue in message.Headers) { toSend.SetStringProperty(keyValue.Key.ToXmsFriendly(), keyValue.Value); nsbHeaderKeys.Add(keyValue.Key.ToXmsFriendly()); } toSend.SetStringProperty(HEADER_NBSKEYS, WrapKeys(nsbHeaderKeys)); }
public void SetUp() { A.Fake<IConnectionFactory>(); _connection = A.Fake<IConnection>(); _lazyConnection = new Lazy<IConnection>(() => { _connection.Start(); return _connection; }); _session = A.Fake<ISession>(); _producer = A.Fake<IMessageProducer>(); _serializer = A.Fake<IMessageSerializer>(); _destination = A.Fake<IDestination>(); _message = A.Fake<ITextMessage>(); _messagePropertyProvider = A.Fake<IMessagePropertyProvider<IMessage>>(); A.CallTo(() => _connection.CreateSession(A<Apache.NMS.AcknowledgementMode>.Ignored)).Returns(_session); A.CallTo(() => _session.CreateProducer(_destination)).Returns(_producer); A.CallTo(() => _session.CreateTextMessage(A<string>._)).Returns(_message); A.CallTo(() => _serializer.Serialize(A<object>._)).Returns("SerializedString"); _testScheduler = new TestScheduler(); _publisher = new MessagePublisher<IMessage>(_lazyConnection, _destination, _serializer, _messagePropertyProvider, _testScheduler); }
public static MessageExecutionCompleted Success(MessageId sourceCommandId, IMessage payload, IMessageSerializer serializer) { var payloadBytes = serializer.Serialize(payload); return new MessageExecutionCompleted(sourceCommandId, payload.TypeId(), payloadBytes); }