static void Main(string[] args)
{
if (args.Length < 2)
{
PrintUsage();
return;
}
string queueFormatName = args[0];
string fileName = args[1];
LargeMessage message =
new LargeMessage(new FileStream(fileName, FileMode.Open, FileAccess.Read));
LargeMessageQueue queue =
new LargeMessageQueue(queueFormatName);
queue.Open();
try
{
queue.Send(message);
}
finally
{
queue.Close();
}
}
public void Constructs()
{
// Act
// ReSharper disable once ObjectCreationAsStatement
var queue = new LargeMessageQueue<TestQueueItem>(_queueSerializerMock.Object, _referenceQueueMock.Object, _blobRepository.Object, _loggerMock.Object, null);
// Assert
Assert.AreEqual(_referenceQueueMock.Object, queue.ReferenceQueue);
Assert.AreEqual(_blobRepository.Object, queue.BlobRepository);
}
// 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!");
}
}
// Handles both lossy and non-lossy large message receive operations
private void ReceiveGeneric(bool isLossy)
{
progressBarSend.Visibility = Visibility.Hidden;
Utilities.StartProgressBar(progressBarReceive);
try
{
MessageQueueTransaction transaction = new MessageQueueTransaction();
transaction.Begin();
if (isLossy)
{
this.queue.Receive(new TimeSpan(0, 0, 10));
}
LargeMessageQueue largeMessageQueue = new LargeMessageQueue(this.queue, 0);
System.Messaging.Message message = largeMessageQueue.Receive(new TimeSpan(0, 0, 10), transaction);
// Redundant. Will never execute these for lossy receive
message.Formatter = new BinaryMessageFormatter();
MemoryStream mStream = (MemoryStream)message.Body;
string newLabel = "Received - " + message.Label;
FileStream fStream = new FileStream(newLabel, FileMode.Create, FileAccess.ReadWrite);
mStream.WriteTo(fStream);
mStream.Close();
fStream.Close();
transaction.Commit();
this.LoadImageFile(imageReceiveFile, newLabel);
imageReceiveFile.Visibility = Visibility.Visible;
Utilities.StopProgressBar(progressBarReceive);
this.SetQueueViewerStatus();
MessageBox.Show("Receive successful!", "Success!");
}
catch (LargeMessageQueueException lmqe)
{
Utilities.ErrorProgressBar(progressBarReceive);
imageReceiveFile.Visibility = Visibility.Hidden;
this.SetQueueViewerStatus();
MessageBox.Show("Receive Error: " + lmqe.Message + "\n Large Sequence Id:" + lmqe.CorrelationId, "Error!");
}
catch (Exception ex)
{
Utilities.ErrorProgressBar(progressBarReceive);
imageReceiveFile.Visibility = Visibility.Hidden;
this.SetQueueViewerStatus();
MessageBox.Show("Receive Error: " + ex.Message, "Error!");
}
}
public async Task EnqueuePostsQueueAndBlob()
{
// Arrange
var queue = new LargeMessageQueue<TestQueueItem>(_queueSerializerMock.Object, _referenceQueueMock.Object, _blobRepository.Object, _loggerMock.Object, null);
var item = new TestQueueItem {Name = "Zaphod"};
var mockBlob = new Mock<IBlob>();
string blobName = null;
_blobRepository.Setup(x => x.UploadAsync(It.IsAny<string>(), It.IsAny<Stream>()))
.Returns(Task.FromResult(mockBlob.Object))
.Callback((string n, Stream s) =>
{
// capture the blob name to ensure the queue item gets posted with the correct blob reference
blobName = n;
});
// Act
await queue.EnqueueAsync(item);
// Assert
_referenceQueueMock.Verify(x => x.EnqueueAsync(It.Is<LargeMessageReference>(v=> v.BlobReference == blobName), null));
}
public async Task ExtendLeaseWithDelayCallsReferenceQueue()
{
// Arrange
var queue = new LargeMessageQueue<TestQueueItem>(_queueSerializerMock.Object, _referenceQueueMock.Object, _blobRepository.Object, _loggerMock.Object, null);
var item = new TestQueueItem { Name = "Zaphod" };
var timespan = TimeSpan.FromSeconds(30);
var underlyingQueueItem = new Mock<IQueueItem<LargeMessageReference>>();
var queueItem = new LargeMessageQueueItem<TestQueueItem>(item, 1, underlyingQueueItem.Object);
// Act
await queue.ExtendLeaseAsync(queueItem, timespan);
// Assert
_referenceQueueMock.Verify(x => x.ExtendLeaseAsync(underlyingQueueItem.Object, timespan));
}
public async Task DequeueCallsProcessorWithLargeMessage()
{
// Arrange
var didDeque = false;
var blob = new Mock<IBlob>();
_blobRepository.Setup(x => x.Get("hello")).Returns(blob.Object);
var queue = new LargeMessageQueue<TestQueueItem>(_queueSerializerMock.Object, _referenceQueueMock.Object, _blobRepository.Object, _loggerMock.Object, null);
var item = new TestQueueItem { Name = "Zaphod" };
var reference = new LargeMessageReference {BlobReference = "hello"};
//var referenceQueueItem = new Mock<IQueueItem>();
var referenceItem = new Mock<IQueueItem<LargeMessageReference>>();
referenceItem.SetupGet(x => x.Item).Returns(reference);
_referenceQueueMock.Setup(
x => x.DequeueAsync(It.IsAny<Func<IQueueItem<LargeMessageReference>, Task<bool>>>()))
.Returns(Task.FromResult(0))
.Callback((Func<IQueueItem<LargeMessageReference>,Task<bool>> func) =>
{
func(referenceItem.Object);
});
// Act
await queue.DequeueAsync(tqi =>
{
didDeque = true;
return Task.FromResult(true);
});
// Assert
Assert.IsTrue(didDeque);
}
