public void Setup() { var buffer = new byte[MessageLength]; Random.Shared.NextBytes(buffer); var writer = MemoryBufferWriter.Get(); try { BinaryMessageFormatter.WriteLengthPrefix(buffer.Length, writer); writer.Write(buffer); _binaryInput = writer.ToArray(); } finally { MemoryBufferWriter.Return(writer); } buffer = new byte[MessageLength]; Random.Shared.NextBytes(buffer); writer = MemoryBufferWriter.Get(); try { writer.Write(buffer); TextMessageFormatter.WriteRecordSeparator(writer); _textInput = writer.ToArray(); } finally { MemoryBufferWriter.Return(writer); } }
public IEnumerable <int> GetEnqueuedJobIds(string queue, int @from, int perPage) { var result = new List <int>(); using (var messageQueue = new MessageQueue(String.Format(_pathPattern, queue))) { var current = 0; var end = @from + perPage; var enumerator = messageQueue.GetMessageEnumerator2(); var formatter = new BinaryMessageFormatter(); while (enumerator.MoveNext()) { if (current >= @from && current < end) { var message = enumerator.Current; message.Formatter = formatter; result.Add(int.Parse((string)message.Body)); } if (current >= end) { break; } current++; } } return(result); }
/// <summary> /// Keep the message in abandon queue until a new subscriber becomes available /// </summary> private static void PutMessageIntoQueue(VideoMessage message) { var formatter = new BinaryMessageFormatter(); using (var queue = new MessageQueue(Program.AbandonMessagesQueuePath)) { queue.Formatter = formatter; // transactional queue using (var transaction = new MessageQueueTransaction()) { transaction.Begin(); if (message is DeliveryRequestMessage) { using (var msg = new Message(message, formatter) { ResponseQueue = queue, Priority = MessagePriority.Normal, Label = message.TopicName + "/" + (message as DeliveryRequestMessage).RegionName, Recoverable = true, }) { queue.Send(msg, transaction); } ConsoleHelper.WriteLine(ConsoleColor.Cyan, "Request stored in queue until proper service becomes available"); } transaction.Commit(); } // using (transaction) } // using (queue) }
public void WriteMultipleMessages() { var expectedEncoding = new byte[] { /* length: */ 0x00, /* body: <empty> */ /* length: */ 0x0E, /* body: */ 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x0D, 0x0A, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21, }; var messages = new[] { new byte[0], Encoding.UTF8.GetBytes("Hello,\r\nWorld!") }; var writer = MemoryBufferWriter.Get(); // Use small chunks to test Advance/Enlarge and partial payload writing try { foreach (var message in messages) { BinaryMessageFormatter.WriteLengthPrefix(message.Length, writer); writer.Write(message); } Assert.Equal(expectedEncoding, writer.ToArray()); } finally { MemoryBufferWriter.Return(writer); } }
public void Msmq_Receive() { var msmq = DistributedApplication.ClusterChannel as MsmqChannelProvider; // init: purge queues msmq._receiveQueue.Purge(); for (var i = 0; i < msmq._sendQueues.Count; i++) { var sendqueue = msmq._sendQueues[i]; sendqueue.Purge(); } // send a single message to the receive queue and check if it gets received and executed var message = new TestAction(); var clusterMemberInfo = new ClusterMemberInfo(); clusterMemberInfo.InstanceID = Guid.NewGuid().ToString(); // ensures message percieved as coming from other source message.SenderInfo = clusterMemberInfo; Stream messageStream = new BinaryMessageFormatter().Serialize(message); var m = new System.Messaging.Message(messageStream); m.TimeToBeReceived = TimeSpan.FromSeconds(RepositoryConfiguration.MessageRetentionTime); m.Formatter = new System.Messaging.BinaryMessageFormatter(); _messageReceivedEvent = new AutoResetEvent(false); msmq._receiveQueue.Send(m); // send message to receivequeue // test for execution: _messageReceived should be set to true var received = _messageReceivedEvent.WaitOne(3000); Assert.IsTrue(received, "Distributed action was not received/executed within 3 seconds"); }
public static void Log(string log) { string logqueName = ConfigurationManager.AppSettings["messageQueueRemoteName"];//".\\private$\\Logs"; MessageQueue que = new MessageQueue(logqueName); BinaryMessageFormatter bmf = new BinaryMessageFormatter(); que.Formatter = bmf; que.Send(log); // System.Messaging.Message msg = new System.Messaging.Message(); // msg.Label = "Log"; // msg.Body = log; // msg.UseDeadLetterQueue = true; // MessageQueue msgQ = new MessageQueue(".\\private$\\Logs"); // if (!MessageQueue.Exists(msgQ.Path)) // { // MessageQueue.Create(msgQ.Path); // } // msgQ.Formatter = new XmlMessageFormatter(new Type[] { typeof(String) }); // msgQ.ReceiveCompleted += new ReceiveCompletedEventHandler(ReceiveCompleted); // msgQ.Send(msg); // msgQ.BeginReceive(); // msgQ.Close(); //} //private static void ReceiveCompleted(Object source, // ReceiveCompletedEventArgs asyncResult) //{ // MessageQueue mq = (MessageQueue)source; // Message m = mq.EndReceive(asyncResult.AsyncResult); // mq.BeginReceive(); // return; //} }
public void WriteMultipleMessages() { var expectedEncoding = new byte[] { /* length: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* body: <empty> */ /* length: */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, /* body: */ 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x0D, 0x0A, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21, }; var messages = new[] { new byte[0], Encoding.UTF8.GetBytes("Hello,\r\nWorld!") }; var output = new MemoryStream(); // Use small chunks to test Advance/Enlarge and partial payload writing foreach (var message in messages) { BinaryMessageFormatter.WriteMessage(message, output); } Assert.Equal(expectedEncoding, output.ToArray()); }
public override bool Send(IMessage message, FormatterType format, params Type[] targetTypes) { if (!_messageQueue.CanWrite) { return(false); } IMessageFormatter formatter = this._messageQueue.Formatter; // 如果Option中没有配置目标类型,则说明每次的Formatter需要单独配置 if (null == Option.TargetTypes || 0 == Option.TargetTypes.Length) { targetTypes = Option.TargetTypes; switch (format) { case FormatterType.Xml: formatter = new XmlMessageFormatter(targetTypes); break; case FormatterType.Bin: formatter = new BinaryMessageFormatter(); break; default: break; } } Message packagedMessage = new Message(message, formatter); _messageQueue.Send(packagedMessage); return(true); }
private static void SendMessageToQueue(string quepath, DocuwareMigrationDataPointer dataPointer) { //Initisalize the Message Queue DefaultPropertiesToSend dpts = new DefaultPropertiesToSend(); dpts.Label = "Docuware 5.1b, Data Queued for Import into OpenKM Community 6.3.1"; dpts.Recoverable = true; dpts.UseJournalQueue = true; dpts.AttachSenderId = true; MessageQueue msgq = null; if (!MessageQueue.Exists(quepath)) { msgq = MessageQueue.Create(quepath); msgq.SetPermissions("Everyone", MessageQueueAccessRights.FullControl); } MessageQueue pQueue = new MessageQueue(quepath); //pQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(DocuwareMigrationDataPointer) }); BinaryMessageFormatter formatter = new BinaryMessageFormatter(); System.Messaging.Message message = new System.Messaging.Message(dataPointer, formatter); message.Recoverable = true; pQueue.DefaultPropertiesToSend = dpts; //Send the message pQueue.Send(message); //REMOVE LATER //Receiving Message //Message Mymessage = pQueue.Receive(); //Mymessage.Formatter = new BinaryMessageFormatter(); //DocuwareMigrationDataPointer docuwareMigrationDataPointerReceiver = (DocuwareMigrationDataPointer) Mymessage.Body; }
/// <inheritdoc /> public ReadOnlyMemory <byte> GetMessageBytes(HubMessage message) { var memoryBufferWriter = MemoryBufferWriter.Get(); try { var writer = new MessagePackWriter(memoryBufferWriter); // Write message to a buffer so we can get its length WriteMessageCore(message, ref writer); var dataLength = memoryBufferWriter.Length; var prefixLength = BinaryMessageFormatter.LengthPrefixLength(memoryBufferWriter.Length); var array = new byte[dataLength + prefixLength]; var span = array.AsSpan(); // Write length then message to output var written = BinaryMessageFormatter.WriteLengthPrefix(memoryBufferWriter.Length, span); Debug.Assert(written == prefixLength); memoryBufferWriter.CopyTo(span.Slice(prefixLength)); return(array); } finally { MemoryBufferWriter.Return(memoryBufferWriter); } }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { object[] values = new object[4]; values[0] = new ActiveXMessageFormatter(); values[1] = new BinaryMessageFormatter(); values[2] = new XmlMessageFormatter(); return(new TypeConverter.StandardValuesCollection(values)); }
public void WriteMessage(HubMessage message, Stream output) { using (var memoryStream = new MemoryStream()) { WriteMessageCore(message, memoryStream); BinaryMessageFormatter.WriteMessage(new ReadOnlySpan <byte>(memoryStream.ToArray()), output); } }
private DistributedLuceneActivity.LuceneActivityDistributor CheckLucMessage(System.Messaging.Message recvmessage) { var formatter = new BinaryMessageFormatter(); var lucmessage = formatter.Deserialize(recvmessage.Body as Stream) as DistributedLuceneActivity.LuceneActivityDistributor; var recactivity = lucmessage.Activity as TestLuceneActivity; Assert.IsTrue(recactivity != null, "Received message differs from message that was sent."); // check if we received the message that we have sent return(lucmessage); }
private Stream HackMessageAsRemote(DistributedLuceneActivity.LuceneActivityDistributor message) { var formatter = new BinaryMessageFormatter(); var clusterMemberInfo = new ClusterMemberInfo(); clusterMemberInfo.InstanceID = Guid.NewGuid().ToString(); // ensures message percieved as coming from other source message.SenderInfo = clusterMemberInfo; return(formatter.Serialize(message)); }
public void WriteBinaryMessage(byte[] encoded, byte[] payload) { using (var writer = new MemoryBufferWriter()) { BinaryMessageFormatter.WriteLengthPrefix(payload.Length, writer); writer.Write(payload); Assert.Equal(encoded, writer.ToArray()); } }
public void RoundTrippingTest(byte[] payload) { using (var ms = new MemoryStream()) { BinaryMessageFormatter.WriteMessage(payload, ms); var buffer = new ReadOnlyBuffer <byte>(ms.ToArray()); Assert.True(BinaryMessageParser.TryParseMessage(ref buffer, out var roundtripped)); Assert.Equal(payload, roundtripped.ToArray()); } }
// Handles both normal and large message send operations private void SendGeneric(bool useLargeMessageSample) { progressBarReceive.Visibility = Visibility.Hidden; Utilities.StartProgressBar(progressBarSend); try { MessageQueueTransaction transaction = new MessageQueueTransaction(); transaction.Begin(); IMessageFormatter formatter = new BinaryMessageFormatter(); Message message = new Message(); FileInfo fileInfo = new FileInfo(textFileName.Text); FileStream fStream = fileInfo.OpenRead(); byte[] b = new byte[fStream.Length]; fStream.Read(b, 0, b.Length); MemoryStream mStream = new MemoryStream(b, 0, b.Length, false); message.Label = fileInfo.Name; message.Formatter = formatter; message.UseDeadLetterQueue = true; message.Body = mStream; int fragmentSize = 0; if (textFragmentSize.Text.Length != 0) { fragmentSize = Int32.Parse(textFragmentSize.Text, CultureInfo.InvariantCulture); } if (useLargeMessageSample) { LargeMessageQueue largeMessageQueue = new LargeMessageQueue(this.queue, fragmentSize); largeMessageQueue.Send(message, transaction); } else { this.queue.Send(message, transaction); } transaction.Commit(); Utilities.StopProgressBar(progressBarSend); this.SetQueueViewerStatus(); MessageBox.Show("Send successful!", "Success!"); } catch (Exception ex) { Utilities.ErrorProgressBar(progressBarSend); this.SetQueueViewerStatus(); MessageBox.Show("Send Error: " + ex.Message, "Error!"); } }
public void RoundTrippingTest(byte[] payload) { using (var writer = new MemoryBufferWriter()) { BinaryMessageFormatter.WriteLengthPrefix(payload.Length, writer); writer.Write(payload); var buffer = new ReadOnlySequence <byte>(writer.ToArray()); Assert.True(BinaryMessageParser.TryParseMessage(ref buffer, out var roundtripped)); Assert.Equal(payload, roundtripped.ToArray()); } }
public void WriteTextMessage(byte[] encoded, string payload) { var message = Encoding.UTF8.GetBytes(payload); using (var writer = new MemoryBufferWriter()) { BinaryMessageFormatter.WriteLengthPrefix(message.Length, writer); writer.Write(message); Assert.Equal(encoded, writer.ToArray()); } }
/* * Send message to queue */ public static void sendMessage(Message myMessage, string queuePath) { if (!MessageQueue.Exists(queuePath)) { MessageQueue.Create(queuePath); } MessageQueue myQueue = new MessageQueue(queuePath); BinaryMessageFormatter bmf = new BinaryMessageFormatter(); // myQueue.Purge(); myQueue.Send(myMessage); myQueue.Close(); }
/// <summary> /// 获取队列中的所有信息 /// </summary> /// <returns></returns> public List <string> GetAllMessage() { Message[] allMessage = _msmq.GetAllMessages(); BinaryMessageFormatter formatter = new BinaryMessageFormatter(); List <string> list = new List <string>(); for (int i = 0; i < allMessage.Length; i++) { allMessage[i].Formatter = formatter; list.Add(allMessage[i].Body.ToString()); } return(list); }
public void WriteBinaryMessage(int offset, byte[] encoded, byte[] payload) { var output = new MemoryStream(); if (offset > 0) { output.Seek(offset, SeekOrigin.Begin); } BinaryMessageFormatter.WriteMessage(payload, output); Assert.Equal(encoded, output.ToArray().Skip(offset)); }
public void WriteMessage(HubMessage message, IBufferWriter <byte> output) { using (var stream = new LimitArrayPoolWriteStream()) { // Write message to a buffer so we can get its length WriteMessageCore(message, stream); var buffer = stream.GetBuffer(); // Write length then message to output BinaryMessageFormatter.WriteLengthPrefix(buffer.Count, output); output.Write(buffer); } }
public void There_and_back_again() { var formatter = new BinaryMessageFormatter(); const string parentTestId = "parentTestId"; var message = new TestDiscoveredMessage { ParentTestId = parentTestId }; var bytes = formatter.Serialise(message); var deserialisedMessage = (TestDiscoveredMessage)formatter.Deserialise(bytes); Assert.That(deserialisedMessage.ParentTestId, Is.EqualTo(parentTestId)); }
public void WriteTextMessage(int offset, byte[] encoded, string payload) { var message = Encoding.UTF8.GetBytes(payload); var output = new MemoryStream(); if (offset > 0) { output.Seek(offset, SeekOrigin.Begin); } BinaryMessageFormatter.WriteMessage(message, output); Assert.Equal(encoded, output.ToArray().Skip(offset)); }
private static byte[] Frame(byte[] input) { var stream = MemoryBufferWriter.Get(); try { BinaryMessageFormatter.WriteLengthPrefix(input.Length, stream); stream.Write(input); return stream.ToArray(); } finally { MemoryBufferWriter.Return(stream); } }
/// <summary> /// Attempts to extract the content of a message in string format. /// </summary> /// <param name="message">Message to extract.</param> /// <param name="usedMessageFormatterType">Informs which formatter was used to extract the message.</param> /// <returns>A string if successful else null.</returns> private string ExtractMessageContent(System.Messaging.Message message) { string result = null; //create an array of formatters, ordered as we are going to attempt to use them IMessageFormatter[] formatterArray = new IMessageFormatter[3]; formatterArray[0] = new ActiveXMessageFormatter(); formatterArray[1] = new XmlMessageFormatter(); formatterArray[2] = new BinaryMessageFormatter(); //attempt to read the message body using the different formatters foreach (IMessageFormatter formatter in formatterArray) { try { //attempt to extract the message message.Formatter = formatter; if (message.Formatter is ActiveXMessageFormatter) { result = Convert.ToString(message.Body); } else { message.BodyStream.Position = 0; StreamReader sr = new StreamReader(message.BodyStream); //do not dispose this stream else the underlying stream will close result = sr.ReadToEnd(); } //message has been successfully extracted (else we would have thrown an exception) //check the xml formatter has given us valid xml if (!(formatter is XmlMessageFormatter && !IsXml(result))) { break; } } catch { result = null; } } if (result == null) { result = Locale.UserMessages.UnableToDisplayBinaryMessage; } return(result); }
public void Send() { BinaryMessageFormatter formatter = new BinaryMessageFormatter(); Message requestMessage = new Message("Hello World", formatter); requestMessage.ResponseQueue = replyQueue; requestQueue.Send(requestMessage); Console.WriteLine("Sent request"); Console.WriteLine("\tType: {0}", requestMessage.BodyType); Console.WriteLine("\tTime: {0}", DateTime.Now.ToString("HH:mm:ss.ffffff")); Console.WriteLine("\tMessage ID: {0}", requestMessage.Id); Console.WriteLine("\tCorrel: {0}", requestMessage.CorrelationId); Console.WriteLine("\tReply To : {0}", requestMessage.ResponseQueue.Path); Console.WriteLine("\tContents: {0}", requestMessage.Body.ToString()); }
/* * Send message to queue */ public static void sendMessage(Message myMessage, string queuePath) { if (!MessageQueue.Exists(queuePath)) { MessageQueue.Create(queuePath, TRANSACTIONAL); } MessageQueueTransaction transaction = new MessageQueueTransaction(); transaction.Begin(); MessageQueue myQueue = new MessageQueue(queuePath, TRANSACTIONAL); BinaryMessageFormatter bmf = new BinaryMessageFormatter(); myQueue.Send(myMessage, transaction); transaction.Commit(); myQueue.Close(); }
public void WriteBinaryMessage(byte[] encoded, byte[] payload) { var writer = MemoryBufferWriter.Get(); try { BinaryMessageFormatter.WriteLengthPrefix(payload.Length, writer); writer.Write(payload); Assert.Equal(encoded, writer.ToArray()); } finally { MemoryBufferWriter.Return(writer); } }