public UsingRhinoQueuesTransport() { if (Directory.Exists("test.esent")) { Directory.Delete("test.esent", true); } var serviceLocator = new CastleServiceLocator(new WindsorContainer()); messageSerializer = new XmlMessageSerializer(new DefaultReflection(), serviceLocator); transport = new RhinoQueuesTransport( new Uri("rhino.queues://localhost:23456/q"), new EndpointRouter(), messageSerializer, 1, "test.esent", IsolationLevel.Serializable, 5, false, new RhinoQueuesMessageBuilder(messageSerializer, serviceLocator), new QueueManagerConfiguration(), new TransactionScopeStrategy() ); transport.Start(); }
private void VerifyMessageHeaderIsPassed(Action <IOutboundMessage> setHeaderAction, Action <IInboundMessageHeaders> checkHeaderAction) { byte[] data; var serializer = new XmlMessageSerializer(); OutboundMessage.Set(setHeaderAction); var message = new PingMessage(); using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, message); data = output.ToArray(); } Trace.WriteLine(OutboundMessage.Headers.MessageType); Trace.WriteLine(Encoding.UTF8.GetString(data)); using (MemoryStream input = new MemoryStream(data)) { serializer.Deserialize(input); checkHeaderAction(CurrentMessage.Headers); } }
private void VerifyMessageHeaderIsPassed(Action<IOutboundMessage> setHeaderAction, Action<IInboundMessageHeaders> checkHeaderAction) { byte[] data; var serializer = new XmlMessageSerializer(); OutboundMessage.Set(setHeaderAction); var message = new PingMessage(); using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, message); data = output.ToArray(); } Trace.WriteLine(OutboundMessage.Headers.MessageType); Trace.WriteLine(Encoding.UTF8.GetString(data)); using (MemoryStream input = new MemoryStream(data)) { serializer.Deserialize(input); checkHeaderAction(CurrentMessage.Headers); } }
public void Can_roundtrip_with_datetime_on_non_english_culture(string cultureName) { var oldCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = new CultureInfo(cultureName); try { var serializer = new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(new WindsorContainer())); var stream = new MemoryStream(); var date = DateTime.Now; serializer.Serialize(new object[] { new Bar { Date = date } }, stream); stream.Position = 0; var bar = (Bar)serializer.Deserialize(stream)[0]; Assert.Equal(date, bar.Date); } finally { Thread.CurrentThread.CurrentCulture = oldCulture; } }
public void The_xml_message_serializer_should_rock_the_house() { byte[] serializedMessageData; var serializer = new XmlMessageSerializer(); OutboundMessage.Set(x => { x.SetSourceAddress("msmq://localhost/queue_name"); x.SetDestinationAddress("msmq://remotehost/queue_name"); x.SetResponseAddress("msmq://localhost/response_queue"); x.SetFaultAddress("msmq://localhost/fault_queue"); x.SetRetryCount(7); }); using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, _message); serializedMessageData = output.ToArray(); Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData)); } using (MemoryStream input = new MemoryStream(serializedMessageData)) { SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage; Assert.AreEqual(_message, receivedMessage); } }
void VerifyMessageHeaderIsPassed(Action <ISendContext <PingMessage> > setHeaderAction, Action <IConsumeContext> checkHeaderAction) { byte[] data; var serializer = new XmlMessageSerializer(); var message = new PingMessage(); using (var output = new MemoryStream()) { var sendContext = new SendContext <PingMessage>(message); setHeaderAction(sendContext); serializer.Serialize(output, sendContext); data = output.ToArray(); } //Trace.WriteLine(Encoding.UTF8.GetString(data)); using (var input = new MemoryStream(data)) { var receiveContext = ReceiveContext.FromBodyStream(input); serializer.Deserialize(receiveContext); checkHeaderAction(receiveContext); } }
public void Setup() { ObjectBuilder = MockRepository.GenerateMock <IObjectBuilder>(); XmlMessageSerializer serializer = new XmlMessageSerializer(); ObjectBuilder.Stub(x => x.GetInstance <XmlMessageSerializer>()).Return(serializer); EndpointFactory = EndpointFactoryConfigurator.New(x => { x.SetObjectBuilder(ObjectBuilder); x.RegisterTransport <TTransport>(); x.SetDefaultSerializer <XmlMessageSerializer>(); AdditionalEndpointFactoryConfiguration(x); }); ObjectBuilder.Stub(x => x.GetInstance <IEndpointFactory>()).Return(EndpointFactory); ServiceBusConfigurator.Defaults(x => { x.SetObjectBuilder(ObjectBuilder); x.SetReceiveTimeout(500.Milliseconds()); x.SetConcurrentConsumerLimit(Environment.ProcessorCount * 2); }); EstablishContext(); }
public XmlSerializerFacade(params Type[] objectTypes) { mapper = new MessageMapper(); serializer = new XmlMessageSerializer(mapper); mapper.Initialize(objectTypes); serializer.Initialize(objectTypes); }
public MessageSerializerAdapter() { var mapper = new MessageMapper(); var json = new JsonMessageSerializer(mapper); _serializers.Add(json.ContentType, json); var bson = new BsonMessageSerializer(mapper); _serializers.Add(bson.ContentType, bson); var binary = new BinaryMessageSerializer(); _serializers.Add(binary.ContentType, binary); IList <Type> messageTypes = Configure.TypesToScan.Where(MessageConventionExtensions.IsMessageType).ToList(); var xml = new XmlMessageSerializer(mapper); xml.Initialize(messageTypes); _serializers.Add(xml.ContentType, xml); _defaultSerializer = xml; if (!_serializers.ContainsKey(_defaultSerializer.ContentType)) { _serializers.Add(_defaultSerializer.ContentType, _defaultSerializer); } }
public void EndpointSendAndReceive() { using (var management = new RabbitMqEndpointManagement(_queue)) { management.BindQueue(_queue.Name, _exchange.Name, ExchangeType.Fanout, "", null); } IMessageSerializer serializer = new XmlMessageSerializer(); var message = new BugsBunny {Food = "Carrot"}; IDuplexTransport transport = _factory.BuildLoopback(new TransportSettings(_exchange)); IOutboundTransport error = _factory.BuildError(new TransportSettings(_error)); var sendEndpoint = new Endpoint(_exchange, serializer, transport, error, new InMemoryInboundMessageTracker(5)); sendEndpoint.Send(message); var receiveEndpoint = new Endpoint(_queue, serializer, transport, error, new InMemoryInboundMessageTracker(5)); receiveEndpoint.Receive(o => { return b => { var bb = (BugsBunny)b; Console.WriteLine(bb.Food); }; }, TimeSpan.Zero); }
public SerializationMapper(IMessageMapper mapper, Conventions conventions, Configure configure) { jsonSerializer = new JsonMessageSerializer(mapper); xmlSerializer = new XmlMessageSerializer(mapper, conventions); List<Type> messageTypes = configure.TypesToScan.Where(conventions.IsMessageType).ToList(); xmlSerializer.Initialize(messageTypes); }
public void Can_handle_dictionaries_where_values_are_objects() { var serializer = new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(new WindsorContainer())); var stream = new MemoryStream(); serializer.Serialize(new object[] { new ItemWithObjectDictionary() { Name = "abc", Arguments = new Dictionary <string, object> { { "abc", "cdef" }, { "def", 1 }, { "123", new Dog { Name = "Oscar" } } } } }, stream); stream.Position = 0; stream.Position = 0; var foo = (ItemWithObjectDictionary)serializer.Deserialize(stream)[0]; Assert.Equal("abc", foo.Name); Assert.Equal("cdef", foo.Arguments["abc"]); Assert.Equal(1, (int)foo.Arguments["def"]); Assert.Equal("Oscar", ((Dog)foo.Arguments["123"]).Name); }
public void Adding_then_removing_will_result_in_no_subscriptions() { var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel()); var msg = new Message(); serializer.Serialize(new object[] { new AddSubscription { Endpoint = transactionalTestQueueEndpoint, Type = typeof(TestMessage).FullName, } }, msg.BodyStream); msg.Extension = Guid.NewGuid().ToByteArray(); queue.OpenSiblngQueue(SubQueue.Subscriptions, QueueAccessMode.Send).Send(msg); var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(), serializer, testQueueEndPoint.Uri, new EndpointRouter(), new FlatQueueStrategy(new EndpointRouter(), testQueueEndPoint.Uri)); subscriptionStorage.Initialize(); subscriptionStorage.RemoveSubscription(typeof(TestMessage).FullName, transactionalTestQueueEndpoint.Uri.ToString()); var uris = subscriptionStorage .GetSubscriptionsFor(typeof(TestMessage)); Assert.Equal(0, uris.Count()); }
public static IMessageSerializer Create(Type t) { var found = (IMessageSerializer)cache[t]; if (found != null) { return(found); } lock (cache) { // double-checked found = (IMessageSerializer)cache[t]; if (found != null) { return(found); } var types = new List <Type> { t }; var mapper = new MessageMapper(); mapper.Initialize(types); var serializer = new XmlMessageSerializer(mapper); serializer.Initialize(types); cache[t] = serializer; return(serializer); } }
public void Trying_to_send_more_than_256_objects_will_fail() { var serializer = new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(new WindsorContainer())); Assert.Throws <UnboundedResultSetException>(() => serializer.Serialize(new object[257], new MemoryStream())); }
public SerializationMapper(IMessageMapper mapper, Conventions conventions, Configure configure) { jsonSerializer = new JsonMessageSerializer(mapper); xmlSerializer = new XmlMessageSerializer(mapper, conventions); var messageTypes = configure.TypesToScan.Where(conventions.IsMessageType).ToList(); xmlSerializer.Initialize(messageTypes); }
public void Can_read_subscription_from_queue() { var serializer = new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(new WindsorContainer())); var msg = new Message(); serializer.Serialize(new object[] { new AddSubscription { Endpoint = transactionalTestQueueEndpoint, Type = typeof(TestMessage).FullName, } }, msg.BodyStream); msg.Extension = Guid.NewGuid().ToByteArray(); queue.OpenSiblngQueue(SubQueue.Subscriptions, QueueAccessMode.Send).Send(msg); var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(), serializer, testQueueEndPoint.Uri, new EndpointRouter(), new FlatQueueStrategy(new EndpointRouter(), testQueueEndPoint.Uri)); subscriptionStorage.Initialize(); var uri = subscriptionStorage .GetSubscriptionsFor(typeof(TestMessage)) .Single(); Assert.Equal(transactionalTestQueueEndpoint.Uri, uri); }
public void EndpointSendAndReceive() { using (var management = new RabbitMqEndpointManagement(_queue)) { management.BindQueue(_queue.Name, _exchange.Name, ExchangeType.Fanout, "", null); } IMessageSerializer serializer = new XmlMessageSerializer(); var message = new BugsBunny { Food = "Carrot" }; IDuplexTransport transport = _factory.BuildLoopback(new TransportSettings(_exchange)); IOutboundTransport error = _factory.BuildError(new TransportSettings(_error)); var sendEndpoint = new Endpoint(_exchange, serializer, transport, error, new InMemoryInboundMessageTracker(5)); sendEndpoint.Send(message); var receiveEndpoint = new Endpoint(_queue, serializer, transport, error, new InMemoryInboundMessageTracker(5)); receiveEndpoint.Receive(o => { return(b => { var bb = (BugsBunny)b; Console.WriteLine(bb.Food); }); }, TimeSpan.Zero); }
public MultiDeserializer(Configure config, Conventions conventions, IMessageSerializer defaultSerializer, IMessageMapper mapper, LogicalMessageFactory logicalMessageFactory, MessageMetadataRegistry metadataRegistry) { _defaultSerializer = defaultSerializer; _logicalMessageFactory = logicalMessageFactory; _metadataRegistry = metadataRegistry; var json = new JsonMessageSerializer(mapper); serializers.Add(json.ContentType, json); var bson = new BsonMessageSerializer(mapper); serializers.Add(bson.ContentType, bson); var binary = new BinaryMessageSerializer(); serializers.Add(binary.ContentType, binary); var xml = new XmlMessageSerializer(mapper, conventions); List <Type> messageTypes = config.TypesToScan.Where(conventions.IsMessageType).ToList(); xml.Initialize(messageTypes); serializers.Add(xml.ContentType, xml); if (!serializers.ContainsKey(_defaultSerializer.ContentType)) { serializers.Add(_defaultSerializer.ContentType, _defaultSerializer); } }
public ChannelGraph() { DefaultContentType = new XmlMessageSerializer().ContentType; _replyChannels.OnMissing = name => { var channels = _channels.Where(x => x.Protocol() == name).ToArray(); var incoming = channels.FirstOrDefault(x => x.Incoming); if (incoming != null) { return(incoming.Uri); } if (channels.Any()) { var existing = channels.Select(x => $"{x.Uri} Incoming = {x.Incoming}").Join(", "); throw new ArgumentOutOfRangeException($"No known reply channel for protocol '{name}', existing channels are {existing}"); } else { throw new ArgumentOutOfRangeException($"No known channels for protocol '{name}'"); } }; }
public void MoveErrorMessageToOriginQueue(QueueItem itm) { if (string.IsNullOrEmpty(itm.Id)) { throw new ArgumentException("MessageId can not be null or empty"); } if (itm.Queue.Type != QueueType.Error) { throw new ArgumentException("Queue is not of type Error, " + itm.Queue.Type); } var mgr = new ErrorManager(); // TODO: // Check if Clustered Queue, due if Clustered && NonTransactional, then Error //var deserializer = new XmlMessageSerializer(); XmlMessageSerializer _serializer = new XmlMessageSerializer(); using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(itm.Content ?? ""))) { var rcx = ReceiveContext.FromBodyStream(stream); _serializer.Deserialize(rcx); //var query = rcx.DestinationAddress.Query; //var errorQueue = rcx.DestinationAddress.OriginalString.Replace(query, "") + "_error"; //mgr.InputQueue = new EndpointAddress(errorQueue); mgr.ReturnMessageToSourceQueue(itm.Id, rcx); } }
public SerializationMapper(IMessageMapper mapper,Conventions conventions, ReadOnlySettings settings) { jsonSerializer = new JsonMessageSerializer(mapper); xmlSerializer = new XmlMessageSerializer(mapper, conventions); List<Type> messageTypes = settings.GetAvailableTypes().Where(conventions.IsMessageType).ToList(); xmlSerializer.Initialize(messageTypes); }
private void InitializeSerializer() { var serializerTypes = _typesToPublish.Values.ToArray().Concat(new[] { typeof(TibcoEventPackage) }).ToArray(); //tell the serializer about our special types Mapper.Initialize(serializerTypes); _tibcoMessageSerializer = new XmlMessageSerializer(Mapper); _tibcoMessageSerializer.Initialize(serializerTypes); }
public SerializationMapper(IMessageMapper mapper, Conventions conventions, ReadOnlySettings settings) { jsonSerializer = new JsonMessageSerializer(mapper); xmlSerializer = new XmlMessageSerializer(mapper, conventions); List <Type> messageTypes = settings.GetAvailableTypes().Where(conventions.IsMessageType).ToList(); xmlSerializer.Initialize(messageTypes); }
public EndpointFactoryDefaultSettings() { CreateMissingQueues = true; PurgeOnStartup = false; RequireTransactional = false; Serializer = new XmlMessageSerializer(); TransactionTimeout = 30.Seconds(); IsolationLevel = IsolationLevel.Serializable; }
public void Deserialize_BytesMessage_Exception() { var serializer = new XmlMessageSerializer <BytesMessage>(); var message = new TextMessage { Body = MessageText }; Assert.Throws <InvalidOperationException>(() => serializer.Deserialize(message)); }
public void Should_deserialize_into_the_proxy_object() { XmlMessageSerializer serializer = new XmlMessageSerializer(); using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(InterfaceBasedMessageXml))) { object obj = serializer.Deserialize(bodyStream); Assert.IsNotNull(obj); } }
public void Deserialize_TextMessage_CorrectResult() { var serializer = new XmlMessageSerializer <TextMessage>(); var result = serializer.Deserialize(new TextMessage { Body = MessageText }); Assert.That(result.Body == "testMessage"); }
public EndpointFactoryDefaultSettings() { CreateMissingQueues = true; CreateTransactionalQueues = false; PurgeOnStartup = false; RequireTransactional = false; Serializer = new XmlMessageSerializer(); TransactionTimeout = 30.Seconds(); IsolationLevel = IsolationLevel.Serializable; }
public void Can_serialize_and_deserialize_byte_array() { var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel()); var stream = new MemoryStream(); serializer.Serialize(new object[] { new byte[] { 1, 2, 3, 4 } }, stream); stream.Position = 0; var actual = (byte[])serializer.Deserialize(stream)[0]; Assert.Equal(new byte[] { 1, 2, 3, 4 }, actual); }
public static XmlMessageSerializer Create(params Type[] types) { var mapper = new MessageMapper(); mapper.Initialize(types); var serializer = new XmlMessageSerializer(mapper, new Conventions()); serializer.Initialize(types); return(serializer); }
public void Should_not_cause_fatal_explosions_of_the_fiery_death_kind() { var serializer = new XmlMessageSerializer(); using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(Version4Message))) { object obj = serializer.Deserialize(bodyStream); Assert.IsNotNull(obj); Assert.IsInstanceOf<ComplaintAdded>(obj); } }
public void Should_handle_the_uri_type() { var serializer = new XmlMessageSerializer(); using (var bodyStream = new MemoryStream(Encoding.UTF8.GetBytes(AnotherVersion4Message))) { object obj = serializer.Deserialize(bodyStream); Assert.IsNotNull(obj); Assert.IsInstanceOf<ComplaintAdded>(obj); } }
public void Can_serialize_and_deserialize_byte_array() { var serializer = new XmlMessageSerializer(); var stream = new MemoryStream(); serializer.Serialize(new object[] { new byte[] { 1, 2, 3, 4 } }, stream); stream.Position = 0; var actual = (byte[])serializer.Deserialize(stream).As <byte[]>(); new byte[] { 1, 2, 3, 4 }.ShouldEqual(actual); }
public void Deserialize_BytesMessage_CastResult() { var serializer = new XmlMessageSerializer <TextMessage>(); var message = new BytesMessage { Body = Encoding.UTF8.GetBytes(MessageText) }; var result = serializer.Deserialize(message); Assert.That(result.Body == "testMessage"); }
public void Can_serialize_and_deserialize_DateTimeOffset() { var value = DateTimeOffset.Now; var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel()); var stream = new MemoryStream(); serializer.Serialize(new object[] { value }, stream); stream.Position = 0; var actual = (DateTimeOffset)serializer.Deserialize(stream)[0]; Assert.Equal(value, actual); }
public void Can_serialize_and_deserialize_primitive() { long ticks = DateTime.Now.Ticks; var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel()); var stream = new MemoryStream(); serializer.Serialize(new object[] { ticks }, stream); stream.Position = 0; var actual = (long)serializer.Deserialize(stream)[0]; Assert.Equal(ticks, actual); }
public EndpointFactoryDefaultSettings() { CreateMissingQueues = true; CreateTransactionalQueues = false; PurgeOnStartup = false; RequireTransactional = false; Serializer = new XmlMessageSerializer(); var messageSerializers = new SupportedMessageSerializers(); messageSerializers.AddSerializer(Serializer); SupportedSerializers = messageSerializers; TransactionTimeout = 30.Seconds(); IsolationLevel = IsolationLevel.Serializable; RetryLimit = 5; TrackerFactory = DefaultTrackerFactory; }
public XmlTransportMessageSerializer(IMessageMapper mapper, IMessageRegisterer registerer, XmlMessageSerializer serializer) { _mapper = mapper; _registrar = registerer; _serializer = serializer; }
public void MoveErrorMessageToOriginQueue(QueueItem itm) { if (string.IsNullOrEmpty(itm.Id)) throw new ArgumentException("MessageId can not be null or empty"); if (itm.Queue.Type != QueueType.Error) throw new ArgumentException("Queue is not of type Error, " + itm.Queue.Type); var mgr = new ErrorManager(); // TODO: // Check if Clustered Queue, due if Clustered && NonTransactional, then Error //var deserializer = new XmlMessageSerializer(); XmlMessageSerializer _serializer = new XmlMessageSerializer(); using (var stream = new MemoryStream(UTF8Encoding.Default.GetBytes(itm.Content ?? ""))) { var rcx = ReceiveContext.FromBodyStream(stream); _serializer.Deserialize(rcx); //var query = rcx.DestinationAddress.Query; //var errorQueue = rcx.DestinationAddress.OriginalString.Replace(query, "") + "_error"; //mgr.InputQueue = new EndpointAddress(errorQueue); mgr.ReturnMessageToSourceQueue(itm.Id, rcx); } }
private void OnTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e) { dynamic response = new ExpandoObject(); XmlMessageSerializer serializer = new XmlMessageSerializer(new MessageMapper()); var message = serializer.Deserialize(new MemoryStream(e.Message.Body)).First(); response.Endpoint = bus.InputAddress.Queue; response.Time = DateTime.UtcNow; response.type = message.GetType().ToString(); response.body = message; response.headers = e.Message.Headers; _monitor.Invoke("MessageReceived", response); }
public void Just_how_fast_is_the_custom_xml_serializer() { var message = new SerializationTestMessage { DecimalValue = 123.45m, LongValue = 098123213, BoolValue = true, ByteValue = 127, IntValue = 123, DateTimeValue = new DateTime(2008, 9, 8, 7, 6, 5, 4), TimeSpanValue = 30.Seconds(), GuidValue = Guid.NewGuid(), StringValue = "Chris's Sample Code", DoubleValue = 1823.172, }; // var message = new PingMessage // { // CorrelationId = CombGuid.Generate() // }; var serializer = new XmlMessageSerializer(); for (int i = 0; i < 10; i++) { byte[] data; using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, message); data = output.ToArray(); } using (MemoryStream input = new MemoryStream(data)) { // serializer.Deserialize(input); } } Stopwatch timer = Stopwatch.StartNew(); const int iterations = 50000; for (int i = 0; i < iterations; i++) { using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, message); } } timer.Stop(); long perSecond = iterations*1000/timer.ElapsedMilliseconds; var msg = string.Format("Serialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond); Trace.WriteLine(msg); byte[] sample; using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, message); sample = output.ToArray(); } timer = Stopwatch.StartNew(); for (int i = 0; i < 50000; i++) { using (MemoryStream input = new MemoryStream(sample)) { serializer.Deserialize(input); } } timer.Stop(); perSecond = iterations*1000/timer.ElapsedMilliseconds; msg = string.Format("Deserialize: {0}ms, Rate: {1} m/s", timer.ElapsedMilliseconds, perSecond); Trace.WriteLine(msg); }