private void HandleStandardMessage(OpenedQueue queue, Message message)
{
var worker = readyForWork.Dequeue();
if (worker == null) // handle message later
{
queue.Send(message);
continuousDeliveryFailures++;
if (continuousDeliveryFailures >= 100)
{
System.Threading.Thread.Sleep(1000);
continuousDeliveryFailures = 0;
}
}
else
{
continuousDeliveryFailures = 0;
var workerEndpoint = endpointRouter.GetRoutedEndpoint(worker);
using (var workerQueue = MsmqUtil.GetQueuePath(workerEndpoint).Open(QueueAccessMode.Send))
{
logger.DebugFormat("Dispatching message '{0}' to {1}", message.Id, workerEndpoint.Uri);
workerQueue.Send(message);
}
}
}
private void RemoveAllReadyToWorkMessages()
{
using (var tx = new TransactionScope())
using (var readyForWorkQueue = MsmqUtil.GetQueuePath(Endpoint).Open(QueueAccessMode.SendAndReceive))
using (var enumerator = readyForWorkQueue.GetMessageEnumerator2())
{
try
{
while (enumerator.MoveNext())
{
while (
enumerator.Current != null &&
enumerator.Current.Label == typeof(ReadyToWork).FullName)
{
var current = enumerator.RemoveCurrent(readyForWorkQueue.GetTransactionType());
HandleLoadBalancerMessage(readyForWorkQueue, current);
}
}
}
catch (MessageQueueException e)
{
if (e.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout)
{
throw;
}
}
readyForWork.Clear();
tx.Complete();
}
}
public MsmqFlatQueueTestBase()
{
defaultTestBase = new MsmqTestBase();
testQueueEndPoint = new Endpoint
{
Uri = new Uri("msmq://localhost/test_queue")
};
testQueuePath = MsmqUtil.GetQueuePath(testQueueEndPoint).QueuePath;
transactionalTestQueueEndpoint = new Endpoint
{
Uri = new Uri("msmq://localhost/transactional_test_queue")
};
transactionalTestQueuePath = MsmqUtil.GetQueuePath(transactionalTestQueueEndpoint).QueuePath;
subscriptionsEndpoint = new Endpoint
{
Uri = new Uri(testQueueEndPoint.Uri + "#" + subscriptions)
};
subscriptionQueuePath = MsmqUtil.GetQueuePath(subscriptionsEndpoint).QueuePath;
SetupQueues();
queue = MsmqUtil.GetQueuePath(testQueueEndPoint).Open();
transactionalQueue = MsmqUtil.GetQueuePath(transactionalTestQueueEndpoint).Open();
subscriptions = MsmqUtil.GetQueuePath(subscriptionsEndpoint).Open(QueueAccessMode.SendAndReceive,
new XmlMessageFormatter(new[]
{
typeof(string)
}));
}
private void SendToAllWorkers(Message message, string logMessage)
{
var values = KnownWorkers.GetValues();
foreach (var worker in values)
{
var workerEndpoint = endpointRouter.GetRoutedEndpoint(worker);
using (var workerQueue = MsmqUtil.GetQueuePath(workerEndpoint).Open(QueueAccessMode.Send))
{
logger.DebugFormat(logMessage, Endpoint.Uri, worker);
workerQueue.Send(message);
}
}
if (values.Length == 0)
{
return;
}
var copy = MessageBatchSentToAllWorkers;
if (copy != null)
{
copy(message);
}
}
public void LoadBalancer_is_singleton()
{
var queuePath = MsmqUtil.GetQueuePath(new Endpoint
{
Uri = new Uri("msmq://localhost/test.balancer")
});
var queueAcceptingPath = MsmqUtil.GetQueuePath(new Endpoint
{
Uri = new Uri("msmq://localhost/test.balancer.acceptingwork")
});
if (MessageQueue.Exists(queuePath.QueuePath) == false)
{
MessageQueue.Create(queuePath.QueuePath);
}
if (MessageQueue.Exists(queueAcceptingPath.QueuePath) == false)
{
MessageQueue.Create(queueAcceptingPath.QueuePath);
}
new LoadBalancerConfiguration()
.UseAutofac(container)
.UseStandaloneConfigurationFile("LoadBalancer.config")
.Configure();
var startable = container.Resolve <IStartable>();
var loadBalancer = container.Resolve <MsmqLoadBalancer>();
Assert.Same(startable, loadBalancer);
}
protected override void BeforeStart(OpenedQueue queue)
{
try
{
queueStrategy.InitializeQueue(Endpoint, QueueType.LoadBalancer);
}
catch (Exception e)
{
throw new TransportException(
"Could not open queue for load balancer: " + Endpoint + Environment.NewLine +
"Queue path: " + MsmqUtil.GetQueuePath(Endpoint), e);
}
try
{
ReadUrisFromSubQueue(KnownWorkers, SubQueue.Workers);
}
catch (Exception e)
{
throw new InvalidOperationException("Could not read workers subqueue", e);
}
try
{
ReadUrisFromSubQueue(KnownEndpoints, SubQueue.Endpoints);
}
catch (Exception e)
{
throw new InvalidOperationException("Could not read endpoints subqueue", e);
}
RemoveAllReadyToWorkMessages();
}
public void Dispose()
{
var endpointQueue = MsmqUtil.GetQueuePath(_endpoint);
if (endpointQueue.Exists)
{
endpointQueue.Delete();
}
}
public static void Prepare(string queueName, QueueType queueType)
{
var queueUri = new Uri(queueName);
var queuePath = MsmqUtil.GetQueuePath(new Endpoint {
Uri = queueUri
});
CreateQueueIfNotExists(queuePath.QueuePath);
//PurgeQueue(queuePath.QueuePath);
//PurgeSubqueues(queuePath.QueuePath, queueType);
}
public void Will_be_translated_correctly()
{
const string privateQueue = @"FormatName:PRIVATE=0786bae3-b81d-48a4-9f84-413800f09f08\00000010";
var uri = MsmqUtil.GetQueueUri(new MessageQueue(privateQueue));
Assert.Equal("msmq://0786bae3-b81d-48a4-9f84-413800f09f08/00000010",
uri.ToString());
Assert.Equal(privateQueue,
MsmqUtil.GetQueuePath(new Endpoint {
Uri = uri
}).QueuePath);
}
public void Should_create_subqueue_strategy_queues()
{
container = new WindsorContainer(new XmlInterpreter(
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "InitBus.config")
));
container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
Assert.True(MsmqUtil.GetQueuePath(endPoint).Exists);
}
}
public void Should_create_subqueue_strategy_queues()
{
container = new WindsorContainer(new XmlInterpreter());
new RhinoServiceBusConfiguration()
.UseCastleWindsor(container)
.UseStandaloneConfigurationFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "InitBus.config"))
.Configure();
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
Assert.True(MsmqUtil.GetQueuePath(endPoint).Exists);
}
}
private void ReadUrisFromSubQueue(Set <Uri> set, SubQueue subQueue)
{
using (var q = MsmqUtil.GetQueuePath(Endpoint).Open(QueueAccessMode.Receive))
using (var sq = q.OpenSubQueue(subQueue, QueueAccessMode.SendAndReceive))
{
var messages = sq.GetAllMessagesWithStringFormatter();
foreach (var message in messages)
{
var uriString = message.Body.ToString();
set.Add(new Uri(uriString));
}
}
}
public void Endpoint_queue_is_created_on_start()
{
var host = new DefaultHost();
host.BusConfiguration(config => config.Bus(EndpointUri));
host.Start <AutofacTestBootStrapper>();
host.Dispose();
var endpointQueue = MsmqUtil.GetQueuePath(_endpoint);
Assert.True(endpointQueue.Exists);
}
public void Init(ITransport transport, IServiceBus bus)
{
var endpoint = endpointRouter.GetRoutedEndpoint(logQueue);
var queueInfo = MsmqUtil.GetQueuePath(endpoint);
queueInfo.Create();
queue = queueInfo.Open(QueueAccessMode.Send);
transport.MessageArrived += Transport_OnMessageArrived;
transport.MessageProcessingFailure += Transport_OnMessageProcessingFailure;
transport.MessageProcessingCompleted += Transport_OnMessageProcessingCompleted;
transport.MessageSerializationException += Transport_OnMessageSerializationException;
transport.MessageSent += Transport_OnMessageSent;
}
public override void Execute(string user)
{
// will create the queues if they are not already there
messageLoggingModule.Init(transport, null);
var queuePath = MsmqUtil.GetQueuePath(new Endpoint
{
Uri = messageLoggingModule.LogQueue
}).QueuePath;
using (var queue = new MessageQueue(queuePath))
{
GrantPermissions(queue, user);
}
}
public Full_test_of_load_balancer_and_failover_and_recovery()
{
var loadBalancerQueuePathUri = new Uri(loadBalancerQueue).ToEndpoint().Uri;
var lb2Endpoint = new Uri("msmq://localhost/test_queue.balancer2").ToEndpoint();
var loadBalancerQueuePath2 = MsmqUtil.GetQueuePath(lb2Endpoint).QueuePath;
var loadBalancerQueuePathUri2 = lb2Endpoint.Uri;
if (MessageQueue.Exists(loadBalancerQueuePath2))
{
MessageQueue.Delete(loadBalancerQueuePath2);
}
MessageQueue.Create(loadBalancerQueuePath2, true);
container = new WindsorContainer();
new RhinoServiceBusConfiguration()
.UseCastleWindsor(container)
.UseStandaloneConfigurationFile(@"LoadBalancer\SendingBusToLoadBalancer.config")
.Configure();
container.Register(
Component.For <MsmqLoadBalancer>()
.DependsOn(new
{
endpointRouter = new EndpointRouter(),
threadCount = 1,
endpoint = loadBalancerQueuePathUri,
secondaryLoadBalancer = loadBalancerQueuePathUri2,
transactional = TransactionalOptions.FigureItOut,
messageBuilder = new MsmqMessageBuilder(new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(container)), new CastleServiceLocator(container))
}).LifeStyle.Transient,
Component.For <MsmqSecondaryLoadBalancer>()
.DependsOn(new
{
endpointRouter = new EndpointRouter(),
threadCount = 1,
endpoint = loadBalancerQueuePathUri2,
primaryLoadBalancer = loadBalancerQueuePathUri,
transactional = TransactionalOptions.FigureItOut,
messageBuilder = new MsmqMessageBuilder(new XmlMessageSerializer(new DefaultReflection(), new CastleServiceLocator(container)), new CastleServiceLocator(container))
})
);
//New conatainer to more closely mimic as separate app.
receivingBusContainer = new WindsorContainer();
new RhinoServiceBusConfiguration()
.UseCastleWindsor(receivingBusContainer)
.UseStandaloneConfigurationFile(@"LoadBalancer\ReceivingBusWithLoadBalancer.config")
.Configure();
receivingBusContainer.Register(Component.For <TestHandler>());
}
public void Error_subqeueue_will_contain_error_details()
{
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
bus.Send(bus.Endpoint, DateTime.Now);
using (var q = MsmqUtil.GetQueuePath(bus.Endpoint).Open())
using (var errorSubQueue = q.OpenSubQueue(SubQueue.Errors, QueueAccessMode.SendAndReceive))
{
var originalMessage = errorSubQueue.Receive();
var errorDescripotion = errorSubQueue.Receive();
Assert.Equal("Error description for: " + originalMessage.Label, errorDescripotion.Label);
}
}
}
public void Should_create_flat_queue_strategy_queues()
{
container = new WindsorContainer(new XmlInterpreter(
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "InitBus.config")
));
container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility().UseFlatQueueStructure());
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
Assert.True(MsmqUtil.GetQueuePath(endPoint).Exists);
Assert.True(MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#subscriptions"));
Assert.True(MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#errors"));
Assert.True(MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#discarded"));
Assert.True(MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#timeout"));
}
CleanQueue();
}
private void HandleStandardMessage(OpenedQueue queue, Message message)
{
var worker = readyForWork.Dequeue();
if (worker == null) // handle message later
{
queue.Send(message);
}
else
{
var workerEndpoint = endpointRouter.GetRoutedEndpoint(worker);
using (var workerQueue = MsmqUtil.GetQueuePath(workerEndpoint).Open(QueueAccessMode.Send))
{
logger.DebugFormat("Dispatching message '{0}' to {1}", message.Id, workerEndpoint.Uri);
workerQueue.Send(message);
}
}
}
public void Will_send_administrative_messages_to_all_nodes()
{
using (var loadBalancer = container.Resolve <MsmqLoadBalancer>())
using (var bus = container.Resolve <IStartableServiceBus>())
{
var wait = new ManualResetEvent(false);
loadBalancer.MessageBatchSentToAllWorkers += message => wait.Set();
loadBalancer.Start();
bus.Start();
bus.Send(loadBalancer.Endpoint, new ReadyToWork
{
Endpoint = TransactionalTestQueueUri.Uri
});
bus.Send(loadBalancer.Endpoint, new ReadyToWork
{
Endpoint = TestQueueUri2.Uri
});
bus.Send(loadBalancer.Endpoint, new AddSubscription
{
Endpoint = bus.Endpoint,
Type = "foobar"
});
wait.WaitOne(TimeSpan.FromSeconds(30), false);
}
using (var q = MsmqUtil.GetQueuePath(TransactionalTestQueueUri).Open())
{
var message = q.Receive();
Assert.Equal("Rhino.ServiceBus.Messages.AddSubscription", message.Label);
}
using (var q = MsmqUtil.GetQueuePath(TestQueueUri2).Open())
{
var message = q.Receive();
Assert.Equal("Rhino.ServiceBus.Messages.AddSubscription", message.Label);
}
}
public Full_test_of_load_balancer_and_failover_and_recovery()
{
var loadBalancerQueuePathUri = new Uri(loadBalancerQueue).ToEndpoint().Uri;
var lb2Endpoint = new Uri("msmq://localhost/test_queue.balancer2").ToEndpoint();
var loadBalancerQueuePath2 = MsmqUtil.GetQueuePath(lb2Endpoint).QueuePath;
var loadBalancerQueuePathUri2 = lb2Endpoint.Uri;
if (MessageQueue.Exists(loadBalancerQueuePath2))
{
MessageQueue.Delete(loadBalancerQueuePath2);
}
MessageQueue.Create(loadBalancerQueuePath2, true);
container = new WindsorContainer(new XmlInterpreter(@"LoadBalancer\SendingBusToLoadBalancer.config"));
container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
container.Register(
Component.For <MsmqLoadBalancer>()
.DependsOn(new
{
endpointRouter = new EndpointRouter(),
threadCount = 1,
endpoint = loadBalancerQueuePathUri,
secondaryLoadBalancer = loadBalancerQueuePathUri2,
transactional = TransactionalOptions.FigureItOut
}).LifeStyle.Transient,
Component.For <MsmqSecondaryLoadBalancer>()
.DependsOn(new
{
endpointRouter = new EndpointRouter(),
threadCount = 1,
endpoint = loadBalancerQueuePathUri2,
primaryLoadBalancer = loadBalancerQueuePathUri,
transactional = TransactionalOptions.FigureItOut
})
);
//New conatainer to more closely mimic as separate app.
receivingBusContainer = new WindsorContainer(new XmlInterpreter(@"LoadBalancer\ReceivingBusWithLoadBalancer.config"));
receivingBusContainer.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
receivingBusContainer.AddComponent <TestHandler>();
}
private void CleanQueue()
{
MsmqUtil.GetQueuePath(endPoint).Delete();
if (MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#subscriptions"))
{
MessageQueue.Delete(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#subscriptions");
}
if (MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#errors"))
{
MessageQueue.Delete(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#errors");
}
if (MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#discarded"))
{
MessageQueue.Delete(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#discarded");
}
if (MessageQueue.Exists(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#timeout"))
{
MessageQueue.Delete(MsmqUtil.GetQueuePath(endPoint).QueuePath + "#timeout");
}
}
public void When_load_balancer_starts_will_read_known_endpoints_from_endpoints_sub_queue()
{
using (var endPointsQueue = MsmqUtil.GetQueuePath(loadBalancerEndpoint)
.Open(QueueAccessMode.SendAndReceive,
new XmlMessageFormatter(new[]
{
typeof(string)
})))
{
endPointsQueue.Send(new Message(TestQueueUri.Uri.ToString()));
var peek = endPointsQueue.Peek(TimeSpan.FromSeconds(30));
string ignored;
new SubQueueStrategy().TryMoveMessage(endPointsQueue, peek, SubQueue.Endpoints, out ignored);
}
using (var loadBalancer = container.Resolve <MsmqLoadBalancer>())
{
loadBalancer.Start();
Assert.True(loadBalancer.KnownEndpoints.GetValues().Contains(TestQueueUri.Uri));
}
}
public void Error_subqeueue_will_contain_error_details()
{
using (var bus = container.Resolve <IStartableServiceBus>())
{
bus.Start();
queue.Send(new Message
{
AppSpecific = (int)MessageType.AdministrativeMessageMarker,
Body = "as",
Label = "foo"
});
using (var q = MsmqUtil.GetQueuePath(bus.Endpoint).Open())
using (var errorSubQueue = q.OpenSubQueue(SubQueue.Errors, QueueAccessMode.SendAndReceive))
{
var originalMessage = errorSubQueue.Receive();
var errorDescripotion = errorSubQueue.Receive();
Assert.Equal("Error description for: " + originalMessage.Label, errorDescripotion.Label);
}
}
}
protected void SendToQueue(Uri queueUri, params object[] msgs)
{
if (queueUri == null)
{
return;
}
try
{
var queueInfo = MsmqUtil.GetQueuePath(new Endpoint {
Uri = queueUri
});
using (var secondaryLoadBalancerQueue = queueInfo.Open(QueueAccessMode.Send))
{
secondaryLoadBalancerQueue.Send(GenerateMsmqMessageFromMessageBatch(msgs));
}
}
catch (Exception e)
{
throw new LoadBalancerException("Could not send message to queue: " + queueUri, e);
}
}
public void Execute(string user)
{
// will create the queues if they are not already there
messageLoggingModule.Init(transport, null);
var queuePath = MsmqUtil.GetQueuePath(new Endpoint
{
Uri = messageLoggingModule.LogQueue
}).QueuePath;
using (var queue = new MessageQueue(queuePath))
{
queue.SetPermissions(user,
MessageQueueAccessRights.DeleteMessage |
MessageQueueAccessRights.DeleteJournalMessage |
MessageQueueAccessRights.GenericRead |
MessageQueueAccessRights.GenericWrite |
MessageQueueAccessRights.GetQueuePermissions |
MessageQueueAccessRights.PeekMessage |
MessageQueueAccessRights.ReceiveJournalMessage |
MessageQueueAccessRights.ReceiveMessage |
MessageQueueAccessRights.WriteMessage,
AccessControlEntryType.Allow);
}
}
public MsmqTestBase()
{
TestQueueUri = new Uri("msmq://localhost/test_queue").ToEndpoint();
testQueuePath = MsmqUtil.GetQueuePath(TestQueueUri).QueuePath;
TestQueueUri2 = new Uri("msmq://localhost/test_queue2").ToEndpoint();
testQueuePath2 = MsmqUtil.GetQueuePath(TestQueueUri2).QueuePath;
TransactionalTestQueueUri = new Uri("msmq://localhost/transactional_test_queue").ToEndpoint();
transactionalTestQueuePath = MsmqUtil.GetQueuePath(TransactionalTestQueueUri).QueuePath;
SubscriptionsUri2 = new Uri("msmq://localhost/test_queue2;subscriptions").ToEndpoint();
subbscriptionQueuePath2 = MsmqUtil.GetQueuePath(SubscriptionsUri2).QueuePathWithSubQueue;
SubscriptionsUri = new Uri("msmq://localhost/test_queue;subscriptions").ToEndpoint();
subscriptionQueuePath = MsmqUtil.GetQueuePath(SubscriptionsUri).QueuePathWithSubQueue;
if (MessageQueue.Exists(testQueuePath) == false)
{
MessageQueue.Create(testQueuePath);
}
if (MessageQueue.Exists(testQueuePath2) == false)
{
MessageQueue.Create(testQueuePath2);
}
if (MessageQueue.Exists(transactionalTestQueuePath) == false)
{
MessageQueue.Create(transactionalTestQueuePath, true);
}
queue = new MessageQueue(testQueuePath);
queue.Purge();
using (var errQueue = new MessageQueue(testQueuePath + ";errors"))
{
errQueue.Purge();
}
testQueue2 = new MessageQueue(testQueuePath2);
testQueue2.Purge();
using (var errQueue2 = new MessageQueue(testQueuePath2 + ";errors"))
{
errQueue2.Purge();
}
transactionalQueue = new MessageQueue(transactionalTestQueuePath);
transactionalQueue.Purge();
using (var errQueue3 = new MessageQueue(transactionalTestQueuePath + ";errors"))
{
errQueue3.Purge();
}
using (var discardedQueue = new MessageQueue(testQueuePath + ";discarded"))
{
discardedQueue.Purge();
}
using (var timeoutQueue = new MessageQueue(testQueuePath + ";timeout"))
{
timeoutQueue.Purge();
}
subscriptions = new MessageQueue(subscriptionQueuePath)
{
Formatter = new XmlMessageFormatter(new[] { typeof(string) })
};
subscriptions.Purge();
using (var subscriptions2 = new MessageQueue(subbscriptionQueuePath2))
{
subscriptions2.Purge();
}
}
public void When_Primary_loadBalacer_recieve_endPoints_it_sends_them_to_secondary_loadBalancer()
{
using (var loadBalancer = container.Resolve <MsmqLoadBalancer>())
{
var wait = new ManualResetEvent(false);
int timesCalled = 0;
loadBalancer.SentNewEndpointPersisted += () =>
{
timesCalled += 1;
if (timesCalled == 2)
{
wait.Set();
}
};
loadBalancer.Start();
using (var loadBalancerMsmqQueue = MsmqUtil.GetQueuePath(loadBalancer.Endpoint).Open(QueueAccessMode.SendAndReceive))
{
var queuePath = MsmqUtil.GetQueuePath(TestQueueUri2);
loadBalancerMsmqQueue.Send(new Message
{
ResponseQueue = queuePath.Open().ToResponseQueue(),
Body = "a"
});
loadBalancerMsmqQueue.Send(new Message
{
ResponseQueue = queuePath.Open().ToResponseQueue(),
Body = "a"
});
queuePath = MsmqUtil.GetQueuePath(TransactionalTestQueueUri);
loadBalancerMsmqQueue.Send(new Message
{
ResponseQueue = queuePath.Open().ToResponseQueue(),
Body = "a"
});
}
wait.WaitOne(TimeSpan.FromSeconds(30), false);
var messageSerializer = container.Resolve <IMessageSerializer>();
using (var workers = new MessageQueue(testQueuePath2, QueueAccessMode.SendAndReceive))
{
int work1 = 0;
int work2 = 0;
foreach (Message msg in workers.GetAllMessages())
{
object msgFromQueue = messageSerializer.Deserialize(msg.BodyStream)[0];
var newEndpointPersisted = msgFromQueue as NewEndpointPersisted;
if (newEndpointPersisted == null)
{
continue;
}
var endpoint = newEndpointPersisted.PersistedEndpoint;
if (endpoint == TestQueueUri2.Uri)
{
work1 += 1;
}
else if (endpoint == TransactionalTestQueueUri.Uri)
{
work2 += 1;
}
}
Assert.Equal(work1, 1);
Assert.Equal(work2, 1);
}
}
}
public Is_fixed_for_SubQueueStrategy()
{
openedQueue = MsmqUtil.GetQueuePath(TestQueueUri).Open();
}
public Is_fixed_for_FlatQueueStrategy()
{
openedQueue = MsmqUtil.GetQueuePath(testQueueEndPoint).Open();
}
