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);
}
}
