public void SyncWorkQueueCancelling()
{
WithSync(() => {
var wq = new WorkQueueInfo(new RabbitHostInfo("localhost"), "fooQueue", false);
using (var p = new WorkQueueProducer(wq))
{
var isConnected = false;
p.IsConnectedChanged += x => isConnected = x;
Waiter.Wait(() => isConnected);
RabbitTestHelper.PurgeQueue("fooQueue");
SyncWorkQueueConsumer c = null;
var task = Task.Factory.StartNew(() => {
WithSync(() => {
using (c = new SyncWorkQueueConsumer(wq))
{
var msg = c.Receive();
msg.ShouldBeOfType <ReceiveWasCancelled>();
throw new Exception("cancelled");
}
});
});
Thread.Sleep(500);
c.Cancel();
new Action(() => task.Wait()).ShouldThrow <Exception>(x => x.InnerException.Message.ShouldEqual("cancelled"));
}
});
}
public void AsyncWorkQueue()
{
WithSync(() => {
var wq = new WorkQueueInfo(new RabbitHostInfo("localhost"), "fooQueue", false);
using (var c1 = new AsyncWorkQueueConsumer(wq))
using (var c2 = new AsyncWorkQueueConsumer(wq))
using (var p = new WorkQueueProducer(wq))
{
Lists.Repeat(1000, _ => p.Send(new TestMessage()));
var c1Count = 0;
var c2Count = 0;
c1.Received += msg => {
c1Count++;
c1.Ack(msg);
};
c2.Received += msg => {
c2Count++;
c2.Ack(msg);
};
Waiter.WaitOrDie(1000, () => c1Count + c2Count == 1000);
((double)c1Count / c2Count).ShouldBeCloseTo(1.0, 0.05);
}
});
}
public void WorkerQueueIsConnectedEvent()
{
WithSync(() => {
var wq = new WorkQueueInfo(new RabbitHostInfo("localhost"), "fooQueue", false);
using (var c = new AsyncWorkQueueConsumer(wq))
using (var p = new WorkQueueProducer(wq))
{
bool cIsConnected = false;
bool pIsConnected = false;
RabbitMessage msg = null;
c.Received += x => msg = x;
c.IsConnectedChanged += x => cIsConnected = x;
p.IsConnectedChanged += x => pIsConnected = x;
Waiter.Wait(() => cIsConnected && pIsConnected);
RabbitTestHelper.StopRabbitService();
Waiter.Wait(() => !cIsConnected && !pIsConnected);
msg.ShouldBeNull();
p.Send(new TestMessage());
RabbitTestHelper.StartRabbitService();
Waiter.Wait(() => cIsConnected && pIsConnected);
Waiter.Wait(() => msg != null);
msg.ShouldBeOfType <TestMessage>();
}
});
}
protected void Item_DataBound(object sender, DataListItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
WorkQueueInfo info = e.Item.DataItem as WorkQueueInfo;
LinkButton button = e.Item.FindControl("WorkQueueLink") as LinkButton;
button.PostBackUrl = ImageServerConstants.PageURLs.WorkQueuePage + "?ProcessorID=" + info.Server;
}
}
public void RequestWorkExecution(WorkQueueInfo workQueueInfo)
{
_workQueueContextLocation = workQueueInfo.WorkQueueContextLocation;
_workQueueLocation = workQueueInfo.WorkQueueLocation;
var workQueueContextAddress = new EndpointAddress(_workQueueContextLocation);
var workQueueContextChannelFactory = new ChannelFactory <IWorkQueueContext>(new NetTcpBinding(), workQueueContextAddress);
var workQueueContext = workQueueContextChannelFactory.CreateChannel(workQueueContextAddress);
var context = workQueueContext.GetContext(_workerInfo);
((IChannel)workQueueContext).Close();
var assembly = Assembly.Load(context.WorkCommandFile);
Type workItemType = null;
Type workResultType = null;
_container = new CompositionContainer(new AssemblyCatalog(assembly));
_container.ComposeParts(this);
foreach (var item in assembly.GetTypes())
{
if (typeof(IWorkItem).IsAssignableFrom(item))
{
workItemType = item;
}
if (typeof(IWorkResult).IsAssignableFrom(item))
{
workResultType = item;
}
}
var workQueueAddress = new EndpointAddress(_workQueueLocation);
var workQueueChannelFactoryType = typeof(ChannelFactory <>).MakeGenericType(typeof(IWorkQueue <,>).MakeGenericType(workItemType, workResultType));
var workQueueChannelFactory = Activator.CreateInstance(workQueueChannelFactoryType, new NetTcpBinding(), workQueueAddress);
var createChannelMethod = workQueueChannelFactory.GetType().GetMethod("CreateChannel", new Type[] { });
var workQueue = createChannelMethod.Invoke(workQueueChannelFactory, null);
var workQueueType = workQueue.GetType();
var getActiveStatus = workQueueType.GetMethod("GetActiveStatus");
var getNext = workQueueType.GetMethod("GetNext");
IWorkItem workItem = null;
while ((bool)getActiveStatus.Invoke(workQueue, null) && (workItem = (IWorkItem)getNext.Invoke(workQueue, new[] { _workerInfo })) != null)
{
var returnResult = workQueueType.GetMethod("ReturnResult");
var workResult = WorkCommand.Execute(workItem);
// Synchronize the result with the work item.
workResult.WorkItemId = workItem.Id;
returnResult.Invoke(workQueue, new object[] { workResult, _workerInfo });
}
var close = workQueueChannelFactoryType.GetMethods().Where(_ => _.Name == "Close").First();
close.Invoke(workQueueChannelFactory, null);
}
public void SyncWorkQueue()
{
WithSync(() => {
var wq = new WorkQueueInfo(new RabbitHostInfo("localhost"), "fooQueue", false);
using (var p = new WorkQueueProducer(wq))
{
var task = Task.Factory.StartNew(() => {
WithSync(() => {
using (var c = new SyncWorkQueueConsumer(wq))
{
Lists.Repeat(1000, _ => {
var msg = c.Receive();
c.Ack(msg);
});
}
});
});
Lists.Repeat(1000, _ => p.Send(new TestMessage()));
task.Wait(2000).ShouldBeTrue();
}
});
}
public void RequestWorkExecution(WorkQueueInfo workQueueInfo)
{
base.Channel.RequestWorkExecution(workQueueInfo);
}
