private void HandleMessageFromQueue(IMessage[] messages, List <HeaderInfo> headers, string queueName)
{
if (!messages.Any())
{
return;
}
var transportMessage = new TransportMessage
{
Body = messages,
WindowsIdentityName = Thread.CurrentPrincipal.Identity.Name,
Headers = headers,
ReturnAddress = queueName
};
var sentMessage = new SentMessage {
Destination = Address, Message = transportMessage
};
MessageReceived(sentMessage.Message);
LocalQueue.Enqueue(sentMessage);
while (_queueToReceiveMessagesLater.Count > 0)
{
MessageReceived(_queueToReceiveMessagesLater.Dequeue().Message);
}
}
public void Enque(T newVar)
{
QueueLimit.WaitOne();
lock (CurrLock)
{
LocalQueue.Enqueue(newVar);
}
}
/// <summary>
/// Adds all of the given processes to the local queue.
/// </summary>
/// <param name="processes">The processes to add.</param>
public void AddToLocalQueue(IEnumerable <Process> processes)
{
foreach (var process in processes)
{
LocalQueue.Enqueue(process);
}
SortTheQueue();
}
/// <summary>
/// Re-queues a message for processing at another time.
/// </summary>
/// <param name="m">The message to process later.</param>
/// <remarks>
/// This method will place the message onto the back of the queue
/// which may break message ordering.
/// </remarks>
public void ReceiveMessageLater(TransportMessage m)
{
var sentMessage = new SentMessage {
Destination = Address, Message = m
};
_queueToReceiveMessagesLater.Enqueue(sentMessage);
LocalQueue.Enqueue(sentMessage);
}
public LocalQueueTest(ITestOutputHelper output)
{
this.output = output;
var options = new Options(Path.GetTempPath());
options.QueueTimeLimit = 1; // set the time limit to 1 minute so we can check that expiry works
options.QueueEntryTries = 2; // try twice in our tests.
_queue = new LocalQueue(options, "testQueue");
}
public T Deque()
{
T returnValue = default(T);
if (LocalQueue.Count > 0)
{
lock (CurrLock)
{
returnValue = LocalQueue.Dequeue();
QueueLimit.Release();
}
}
return(returnValue);
}
protected bool RelayFailoverMessage()
{
using (MessageQueueTransaction mqt = new MessageQueueTransaction())
{
try
{
mqt.Begin();
Message failoverMessage = LocalQueue.Receive(mqt);
TransportMessage transportMessage = ConvertToTransportMessage(failoverMessage);
if (this.SkipDeserialization)
{
transportMessage.BodyStream = failoverMessage.BodyStream;
}
else
{
try
{
transportMessage.Body = Extract(failoverMessage);
}
catch (Exception e)
{
logger.Error("Could not extract message data.", e);
base.MoveToErrorQueue(Convert(transportMessage));
// commit receive transaction from failoverQueue, ChannelInfo, QueueManager)
mqt.Commit();
return(true); // deserialization failed - no reason to try again, so don't throw
}
}
// lookup destination queue name
string destination = "";
if (transportMessage.Headers != null)
{
foreach (HeaderInfo headerInfo in transportMessage.Headers)
{
if (headerInfo.Key.Equals("destination"))
{
destination = headerInfo.Value;
transportMessage.Headers.Remove(headerInfo);
break;
}
}
}
// make sure a destination queue name was found
if (destination.Equals(""))
{
// consider writing this message to the error queue
// then commit transactional receive
// since application can not determine where to send it
throw new Exception("Destination Not found");
}
MQMessage mqMessage = base.Convert(transportMessage);
base.Send(mqMessage, destination);
// commit receive transaction from failoverQueue, ChannelInfo, QueueManager)
mqt.Commit();
return(true);
}
catch (Exception ex)
{
logger.Error("Exception in WmqTranportFailover.RelayFailoverMessage: " + ex.Message);
// roll back transaction
mqt.Abort();
return(false);
}
finally
{
mqt.Dispose();
}
}
}
/// <summary>
/// Sorts the local queue.
/// </summary>
public void SortTheQueue()
{
LocalQueue = new ConcurrentQueue <Process>(LocalQueue.OrderBy(Dispatcher.GetQueueOrder()));
}
/// <summary>
/// Adds to the queue and orders it.
/// </summary>
/// <param name="process">The process to be added to the queue.</param>
public void AddToLocalQueue(Process process)
{
LocalQueue.Enqueue(process);
SortTheQueue();
}
public QueueService()
{
Queuer = new LocalQueue();
}
public MainController(LocalQueue localQueue, IConfiguration configuration)
{
_localQueue = _localQueue = localQueue;
_configuration = configuration;
}
