/// <summary>
/// Constracor
/// </summary>
public Processor()
{
ProcessorQueue = new ProcessorQueue();
impersonate = new Impersonation();
impersonate.ImpersonationLogonType = WorkflowEngine.Common.Security.ImpersonationLogonType.LOGON32_LOGON_NEW_CREDENTIALS;
if (Utils.PROCESSOR_COUNT > 1 && EngineConfiguration.UsePipelinedOnMulticore)
executor = new PipelinedExecutor();
else
executor = new SequentialExecutor();
}
public static void HandleComplete(ProcessorQueue processorQueue, IWorkflowMessage message)
{
MessageQueue completedQueue = new System.Messaging.MessageQueue(processorQueue.CompletedQueue);
using (TransactionScope txScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
try
{
completedQueue.Send(message, MessageQueueTransactionType.Automatic);
txScope.Complete();
}
catch (InvalidOperationException)
{
}
finally
{
completedQueue.Dispose();
}
}
}
/// <summary>
/// Load the Job's Queues
/// </summary>
/// <param name="processorJob">The ProcessorJob to load to</param>
/// <param name="queuesNode">The XmlNode to load from</param>
private static void LoadJobQueues(ProcessorJob processorJob, XmlNode queuesNode)
{
foreach (XmlNode queueNode in queuesNode.ChildNodes)
{
ProcessorQueue processorQueue = new ProcessorQueue();
if (!string.IsNullOrEmpty(queueNode.Attributes["MessageQueue"].Value)) //Required
processorQueue.MessageQueue = queueNode.Attributes["MessageQueue"].Value;
if (!string.IsNullOrEmpty(queueNode.Attributes["ErrorQueue"].Value)) //Required
processorQueue.ErrorQueue = queueNode.Attributes["ErrorQueue"].Value;
if (!string.IsNullOrEmpty(queueNode.Attributes["PoisonQueue"].Value)) //Required
processorQueue.PoisonQueue = queueNode.Attributes["PoisonQueue"].Value;
if (!string.IsNullOrEmpty(queueNode.Attributes["CompletedQueue"].Value)) //Required
processorQueue.CompletedQueue = queueNode.Attributes["CompletedQueue"].Value;
if (!string.IsNullOrEmpty(queueNode.Attributes["MessageQueueType"].Value)) //Required
processorQueue.MessageQueueType = (MessageQueueType)Enum.Parse(typeof(MessageQueueType), queueNode.Attributes["MessageQueueType"].Value, true);
processorJob.ProcessorQueues.Add(processorQueue);
}
}
/// <summary>
/// Get the currently active Queue to pickup or deliver messages
/// </summary>
/// <param name="processorJob">The current loaded configuration</param>
/// <param name="queueOperationType">The type of operation to execute on the Queue</param>
/// <returns>The current active ProcessorQueue for the Operation Type</returns>
public static ProcessorQueue GetActiveQueue(ProcessorJob processorJob, QueueOperationType queueOperationType)
{
// For backward compatibility if the master Queue is present return it
if (!string.IsNullOrEmpty(processorJob.MessageQueue) && !string.IsNullOrEmpty(processorJob.ErrorQueue))
return new ProcessorQueue()
{
MessageQueue = processorJob.MessageQueue,
ErrorQueue = processorJob.ErrorQueue,
PoisonQueue = processorJob.PoisonQueue,
CompletedQueue = processorJob.CompletedQueue,
MessageQueueType = processorJob.MessageQueueType
};
//If this is a delivery, deliver to the first available queue
//If this is a pickup, pick it from the queues in a reverse order
// Get the first queue with messages
ProcessorQueue queue = new ProcessorQueue();
lock (activeQueueSearchLock)
{
if (queueOperationType == QueueOperationType.Pickup)
processorJob.ProcessorQueues.Reverse();
foreach (ProcessorQueue processorQueue in processorJob.ProcessorQueues)
{
MessageQueue workflowQueue = new MessageQueue(processorQueue.MessageQueue);
queue = processorQueue;
try
{
using (MessageQueue msmq = new MessageQueue(processorQueue.MessageQueue))
{
msmq.Peek(new TimeSpan(0));
break;
}
}
catch (MessageQueueException e)
{
if (e.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout)
{
// The queue is is available and empty it can be used for delivery
if (queueOperationType == QueueOperationType.Delivery)
break;
}
}
catch (Exception) { }
}
// Reverse the queue list back to the original order
if (queueOperationType == QueueOperationType.Pickup)
processorJob.ProcessorQueues.Reverse();
}
return queue;
}
