public void When_routing_to_specific_instance_should_select_appropriate_instance()
{
var table = new UnicastRoutingTable();
var instances = new EndpointInstances();
table.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromEndpointName("Endpoint"))
});
instances.AddOrReplaceInstances("A", new List <EndpointInstance>
{
new EndpointInstance("Endpoint", "1"),
new EndpointInstance("Endpoint", "2"),
new EndpointInstance("Endpoint", "3")
});
var router = CreateRouter(routingTable: table, instances: instances);
var options = new SendOptions();
options.RouteToSpecificInstance("2");
var context = CreateContext(options);
var route = router.Route(context);
Assert.AreEqual("Endpoint-2", ExtractDestination(route));
}
async Task UpdateCaches(EndpointInstance instanceName, Type[] handledTypes, Type[] publishedTypes)
{
var newInstanceMap = BuildNewInstanceMap(instanceName);
var newEndpointMap = BuildNewEndpointMap(instanceName.Endpoint, handledTypes, endpointMap);
var newPublisherMap = BuildNewPublisherMap(instanceName, publishedTypes, publisherMap);
LogChangesToEndpointMap(endpointMap, newEndpointMap);
LogChangesToInstanceMap(instanceMap, newInstanceMap);
var toSubscribe = LogChangesToPublisherMap(publisherMap, newPublisherMap).ToArray();
#region AddOrReplace
routingTable.AddOrReplaceRoutes("AutomaticRouting", newEndpointMap.Select(
x => new RouteTableEntry(x.Key, UnicastRoute.CreateFromEndpointName(x.Value))).ToList());
publishers.AddOrReplacePublishers("AutomaticRouting", newPublisherMap.Select(
x => new PublisherTableEntry(x.Key, PublisherAddress.CreateFromEndpointName(x.Value))).ToList());
endpointInstances.AddOrReplaceInstances("AutomaticRouting", newInstanceMap.SelectMany(x => x.Value).ToList());
#endregion
instanceMap = newInstanceMap;
endpointMap = newEndpointMap;
publisherMap = newPublisherMap;
foreach (var type in toSubscribe.Intersect(messageTypesHandledByThisEndpoint))
{
await messageSession.Subscribe(type)
.ConfigureAwait(false);
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var rampSettings = context.Settings.Get <RampSettings>();
var unicastRouteTable = context.Settings.Get <UnicastRoutingTable>();
var route = UnicastRoute.CreateFromPhysicalAddress(rampSettings.BridgeAddress);
var publishers = context.Settings.Get <Publishers>();
//Send the specified messages through the bridge
var routes = rampSettings.SendRouteTable.Select(x => new RouteTableEntry(x.Key, route)).ToList();
unicastRouteTable.AddOrReplaceRoutes("NServiceBus.Bridge", routes);
var distributorAddress = context.Settings.GetOrDefault <string>("LegacyDistributor.Address");
var subscriberAddress = distributorAddress ?? context.Settings.LocalAddress();
var publisherAddress = PublisherAddress.CreateFromPhysicalAddresses(rampSettings.BridgeAddress);
publishers.AddOrReplacePublishers("Bridge", rampSettings.PublisherTable.Select(kvp => new PublisherTableEntry(kvp.Key, publisherAddress)).ToList());
context.Pipeline.Register(new SetUltimateDestinationEndpointBehavior(rampSettings.SendRouteTable), "Sets the ultimate destination endpoint on the outgoing messages.");
context.Pipeline.Register(new SetCorrelationIdBehavior(), "Encodes the reply-to address in the correlation ID.");
context.Pipeline.Register(b => new BridgeSubscribeBehavior(subscriberAddress, context.Settings.EndpointName(), rampSettings.BridgeAddress, b.Build <IDispatchMessages>(), rampSettings.PublisherTable),
"Dispatches the subscribe request to the bridge.");
context.Pipeline.Register(b => new BridgeUnsubscribeBehavior(subscriberAddress, context.Settings.EndpointName(), rampSettings.BridgeAddress, b.Build <IDispatchMessages>(), rampSettings.PublisherTable),
"Dispatches the unsubscribe request to the bridge.");
}
protected override void Setup(FeatureConfigurationContext context)
{
var transportInfra = context.Settings.Get <TransportInfrastructure>();
var nativePubSub = transportInfra.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Multicast;
var settings = context.Settings.Get <RouterConnectionSettings>();
var unicastRouteTable = context.Settings.Get <UnicastRoutingTable>();
var route = UnicastRoute.CreateFromEndpointName(settings.RouterAddress);
var publishers = context.Settings.Get <Publishers>();
var bindings = context.Settings.Get <QueueBindings>();
//Make sure router queue does exist.
bindings.BindSending(settings.RouterAddress);
//Send the specified messages through the router
var routes = settings.SendRouteTable.Select(x => new RouteTableEntry(x.Key, route)).ToList();
unicastRouteTable.AddOrReplaceRoutes("NServiceBus.Router", routes);
var distributorAddress = context.Settings.GetOrDefault <string>("LegacyDistributor.Address");
var subscriberAddress = distributorAddress ?? context.Settings.LocalAddress();
var publisherAddress = PublisherAddress.CreateFromPhysicalAddresses(settings.RouterAddress);
publishers.AddOrReplacePublishers("NServiceBus.Router", settings.PublisherTable.Select(kvp => new PublisherTableEntry(kvp.Key, publisherAddress)).ToList());
context.Pipeline.Register(new ForwardSiteMessagesToRouterBehavior(settings.RouterAddress), "Routes messages sent to sites to the bridge.");
context.Pipeline.Register(new RoutingHeadersBehavior(settings.SendRouteTable), "Sets the ultimate destination endpoint on the outgoing messages.");
context.Pipeline.Register(b => new RouterSubscribeBehavior(subscriberAddress, context.Settings.EndpointName(), settings.RouterAddress, b.Build <IDispatchMessages>(), settings.PublisherTable, nativePubSub),
"Dispatches the subscribe request via a router.");
context.Pipeline.Register(b => new RouterUnsubscribeBehavior(subscriberAddress, context.Settings.EndpointName(), settings.RouterAddress, b.Build <IDispatchMessages>(), settings.PublisherTable, nativePubSub),
"Dispatches the unsubscribe request via a router.");
}
public void When_multiple_dynamic_instances_for_local_endpoint_and_instance_selected_should_not_round_robin()
{
var routingTable = new UnicastRoutingTable();
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromEndpointName("Endpoint"))
});
var endpointInstances = new EndpointInstances();
endpointInstances.AddOrReplaceInstances("A", new List <EndpointInstance>
{
new EndpointInstance("Endpoint", "1"),
new EndpointInstance("Endpoint", "2"),
});
var options = new SendOptions();
options.RouteToSpecificInstance("2");
var context = CreateContext(options, new MyMessage());
var router = CreateRouter(routingTable: routingTable, instances: endpointInstances);
var route1 = router.Route(context);
var route2 = router.Route(context);
var route3 = router.Route(context);
Assert.AreEqual("Endpoint-2", ExtractDestination(route1));
Assert.AreEqual("Endpoint-2", ExtractDestination(route2));
Assert.AreEqual("Endpoint-2", ExtractDestination(route3));
}
public void When_multiple_dynamic_instances_for_logical_endpoints_should_round_robin()
{
var sales = "Sales";
var routingTable = new UnicastRoutingTable();
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromEndpointName(sales))
});
var endpointInstances = new EndpointInstances();
endpointInstances.AddOrReplaceInstances("A", new List <EndpointInstance>
{
new EndpointInstance(sales, "1"),
new EndpointInstance(sales, "2"),
});
var context = CreateContext(new SendOptions(), new MyMessage());
var router = CreateRouter(routingTable: routingTable, instances: endpointInstances);
var route1 = router.Route(context);
var route2 = router.Route(context);
var route3 = router.Route(context);
Assert.AreEqual("Sales-1", ExtractDestination(route1));
Assert.AreEqual("Sales-2", ExtractDestination(route2));
Assert.AreEqual("Sales-1", ExtractDestination(route3));
}
UnicastRoute RouteToThisInstance()
{
if (instanceSpecificQueue == null)
{
throw new InvalidOperationException("Cannot route to a specific instance because an endpoint instance discriminator was not configured for the destination endpoint. It can be specified via EndpointConfiguration.MakeInstanceUniquelyAddressable(string discriminator).");
}
return(UnicastRoute.CreateFromPhysicalAddress(instanceSpecificQueue));
}
UnicastRoute RouteToAnyInstance()
{
if (isSendOnly)
{
throw new InvalidOperationException("Cannot route to instances of this endpoint since it's configured to be in send-only mode.");
}
return(UnicastRoute.CreateFromEndpointName(receiveQueueName));
}
UnicastRoute RouteToSpecificInstance(IOutgoingSendContext context, string specificInstance)
{
var route = RouteUsingTable(context);
if (route.Endpoint == null)
{
throw new Exception("Routing to a specific instance is only allowed if route is defined for a logical endpoint, not for an address or instance.");
}
return(UnicastRoute.CreateFromEndpointInstance(new EndpointInstance(route.Endpoint, specificInstance)));
}
static void RegisterMessageRoute(Type mappedType, string address, Dictionary <Type, RouteTableEntry> routeTableEntries, IEnumerable <Type> baseTypes)
{
var route = UnicastRoute.CreateFromPhysicalAddress(address);
foreach (var baseType in baseTypes)
{
routeTableEntries[baseType] = new RouteTableEntry(baseType, route);
}
routeTableEntries[mappedType] = new RouteTableEntry(mappedType, route);
}
public static void ForwardToEndpoint(this RoutingSettings routing, Type messageTypeToForward, string destinationEndpointName)
{
var settings = routing.GetSettings();
var endpointRoute = UnicastRoute.CreateFromEndpointName(destinationEndpointName);
settings.GetOrCreate <ForwardingAddressDirectory>()
.ForwardToRoute(messageTypeToForward, endpointRoute);
settings.EnableFeatureByDefault <LeaveForwardingAddressFeature>();
}
public void When_routing_command_to_logical_endpoint_without_configured_instances_should_route_to_a_single_destination()
{
var logicalEndpointName = "Sales";
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry> {
new RouteTableEntry(typeof(Command), UnicastRoute.CreateFromEndpointName(logicalEndpointName))
});
var route = router.Route(typeof(Command), new DistributionPolicy());
Assert.AreEqual(logicalEndpointName, ExtractDestination(route));
}
public void When_group_does_not_exist_should_add_routes()
{
var routingTable = new UnicastRoutingTable();
var route = UnicastRoute.CreateFromEndpointName("Endpoint1");
routingTable.AddOrReplaceRoutes("key", new List <RouteTableEntry>()
{
new RouteTableEntry(typeof(Command), route),
});
var retrievedRoute = routingTable.GetRouteFor(typeof(Command));
Assert.AreSame(route, retrievedRoute);
}
void RouteTableViaConfig(EndpointConfiguration config)
{
#region RoutingExtensibility-RouteTableConfig
var routingTable = config.GetSettings().Get <UnicastRoutingTable>();
routingTable.AddOrReplaceRoutes("MySource",
new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyCommand),
UnicastRoute.CreateFromEndpointName("MyEndpoint"))
});
#endregion
}
public UnicastRoutingStrategy ResolveRoute(UnicastRoute route, OutgoingLogicalMessage outgoingLogicalMessage, string messageId, Dictionary <string, string> headers, ContextBag contextBag)
{
if (route.PhysicalAddress != null)
{
return(new UnicastRoutingStrategy(route.PhysicalAddress));
}
if (route.Instance != null)
{
return(new UnicastRoutingStrategy(transportAddressTranslation(route.Instance)));
}
var instances = endpointInstances.FindInstances(route.Endpoint).Select(e => transportAddressTranslation(e)).ToArray();
var distributionContext = new DistributionContext(instances, outgoingLogicalMessage, messageId, headers, transportAddressTranslation, contextBag);
var selectedInstanceAddress = distributionPolicy.GetDistributionStrategy(route.Endpoint, DistributionStrategyScope.Send).SelectDestination(distributionContext);
return(new UnicastRoutingStrategy(selectedInstanceAddress));
}
public void When_route_with_physical_address_routes_to_physical_address()
{
var routingTable = new UnicastRoutingTable();
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromPhysicalAddress("Physical"))
});
var context = CreateContext(new SendOptions(), new MyMessage());
var router = CreateRouter(routingTable: routingTable);
var route = router.Route(context);
Assert.AreEqual("Physical", ExtractDestination(route));
}
public void When_route_with_endpoint_instance_routes_to_instance()
{
var routingTable = new UnicastRoutingTable();
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromEndpointInstance(new EndpointInstance("Endpoint", "2")))
});
var context = CreateContext(new SendOptions(), new MyMessage());
var router = CreateRouter(routingTable: routingTable);
var route = router.Route(context);
Assert.AreEqual("Endpoint-2", ExtractDestination(route));
}
public Sender()
{
EndpointSetup <DefaultServer>((c, r) =>
{
var receiverAddress = $"{EndpointNamingConvention(typeof(Receiver))}@{ReceiverSchema}";
var transportSettings = c.ConfigureSqlServerTransport();
c.GetSettings()
.GetOrCreate <UnicastRoutingTable>()
.AddOrReplaceRoutes("Custom", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(Message), UnicastRoute.CreateFromPhysicalAddress(receiverAddress))
});
});
}
UnicastRoutingStrategy ResolveRoute(UnicastRoute route, IOutgoingSendContext context)
{
if (route.PhysicalAddress != null)
{
return(new UnicastRoutingStrategy(route.PhysicalAddress));
}
if (route.Instance != null)
{
return(new UnicastRoutingStrategy(transportAddressTranslation(route.Instance)));
}
var instances = endpointInstances.FindInstances(route.Endpoint).Select(e => transportAddressTranslation(e)).ToArray();
var distributionContext = new DistributionContext(instances, context.Message, context.MessageId, context.Headers, transportAddressTranslation, context.Extensions);
var selectedInstanceAddress = defaultDistributionPolicy.GetDistributionStrategy(route.Endpoint, DistributionStrategyScope.Send).SelectDestination(distributionContext);
return(new UnicastRoutingStrategy(selectedInstanceAddress));
}
protected override void Setup(FeatureConfigurationContext context)
{
var transportInfra = context.Settings.Get <TransportInfrastructure>();
var nativePubSub = transportInfra.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Multicast;
var settingsCollection = context.Settings.Get <RouterConnectionSettingsCollection>();
var unicastRouteTable = context.Settings.Get <UnicastRoutingTable>();
var bindings = context.Settings.Get <QueueBindings>();
var compiledSettings = new CompiledRouterConnectionSettings(settingsCollection);
foreach (var connection in settingsCollection.Connections)
{
//Make sure router queue does exist.
bindings.BindSending(connection.RouterAddress);
//Send the specified messages through the router
var route = UnicastRoute.CreateFromPhysicalAddress(connection.RouterAddress);
var routes = connection.SendRouteTable.Select(x => new RouteTableEntry(x.Key, route)).ToList();
unicastRouteTable.AddOrReplaceRoutes("NServiceBus.Router_" + connection.RouterAddress, routes);
}
if (transportInfra.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Unicast)
{
//Register the auto-publish-to-router behavior
var autoSubscribeRouters = settingsCollection.Connections.Where(x => x.EnableAutoSubscribe).Select(x => x.RouterAddress).ToArray();
context.Pipeline.Register(b => new RouterAutoSubscribeBehavior(autoSubscribeRouters, b.Build <ISubscriptionStorage>()), "Automatically subscribes routers to published events.");
}
context.Pipeline.Register(new ForwardSiteMessagesToRouterBehavior(), "Routes messages sent to sites to the bridge.");
context.Pipeline.Register(new RoutingHeadersBehavior(compiledSettings), "Sets the ultimate destination endpoint on the outgoing messages.");
context.Pipeline.Register(new CorrelationIdForReplyBehavior(), "Copy previous correlation ID for reply");
var isSendOnlyEndpoint = context.Settings.GetOrDefault <bool>("Endpoint.SendOnly");
if (!isSendOnlyEndpoint)
{
var distributorAddress = context.Settings.GetOrDefault <string>("LegacyDistributor.Address");
var subscriberAddress = distributorAddress ?? context.Settings.LocalAddress();
context.Pipeline.Register(b => new RouterSubscribeBehavior(subscriberAddress, context.Settings.EndpointName(), b.Build <IDispatchMessages>(), compiledSettings, nativePubSub),
"Dispatches the subscribe request via a router.");
context.Pipeline.Register(b => new RouterUnsubscribeBehavior(subscriberAddress, context.Settings.EndpointName(), b.Build <IDispatchMessages>(), compiledSettings, nativePubSub),
"Dispatches the unsubscribe request via a router.");
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var coreScannerConfig = context.Settings.Get <AssemblyScannerConfiguration>();
var unicastRoutingTable = context.Settings.Get <UnicastRoutingTable>();
var conventions = context.Settings.Get <Conventions>();
var messageTypes = TypesScanner.ScanMessageTypes(coreScannerConfig, conventions);
var routes = new List <RouteTableEntry>();
foreach (var messageType in messageTypes)
{
if (IsRouteDefinedFor(messageType, unicastRoutingTable))
{
continue;
}
var routeToAttribute = messageType.GetCustomAttribute <RouteToAttribute>();
if (routeToAttribute != null)
{
routes.Add(new RouteTableEntry(messageType,
UnicastRoute.CreateFromEndpointName(routeToAttribute.Destination)));
}
else
{
var routeAttribute = messageType.Assembly.GetCustomAttribute <RouteAttribute>();
if (conventions.IsCommandType(messageType) &&
routeAttribute?.CommandsDestination != null)
{
routes.Add(new RouteTableEntry(messageType,
UnicastRoute.CreateFromEndpointName(routeAttribute.CommandsDestination)));
}
else if (conventions.IsMessageType(messageType) &&
routeAttribute?.MessagesDestination != null)
{
routes.Add(new RouteTableEntry(messageType,
UnicastRoute.CreateFromEndpointName(routeAttribute.MessagesDestination)));
}
}
}
if (routes.Any())
{
unicastRoutingTable.AddOrReplaceRoutes("AttributeRoutingSource", routes);
}
}
public void When_routing_command_to_logical_endpoint_without_configured_instances_should_route_to_a_single_destination()
{
var logicalEndpointName = "Sales";
var routingTable = new UnicastRoutingTable();
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromEndpointName(logicalEndpointName))
});
var context = CreateContext(new SendOptions(), new MyMessage());
var router = CreateRouter(routingTable: routingTable);
var route = router.Route(context);
Assert.AreEqual(logicalEndpointName, ExtractDestination(route));
}
public void When_multiple_dynamic_instances_for_logical_endpoints_should_route_message_to_a_single_instance()
{
var sales = "Sales";
routingTable.AddOrReplaceRoutes("A", new List <RouteTableEntry> {
new RouteTableEntry(typeof(Command), UnicastRoute.CreateFromEndpointName(sales))
});
endpointInstances.AddOrReplaceInstances("A", new List <EndpointInstance>
{
new EndpointInstance(sales, "1"),
new EndpointInstance(sales, "2"),
});
var route = router.Route(typeof(Command), new DistributionPolicy());
Assert.AreEqual("Sales-1", ExtractDestination(route));
}
public Endpoint()
{
EndpointSetup <DefaultServer>(c =>
{
c.GetSettings().GetOrCreate <UnicastRoutingTable>()
.AddOrReplaceRoutes("CustomRoutingFeature", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyCommand), UnicastRoute.CreateFromEndpointName(ReceiverEndpoint))
});
c.GetSettings().GetOrCreate <EndpointInstances>()
.AddOrReplaceInstances("CustomRoutingFeature", new List <EndpointInstance>
{
new EndpointInstance(ReceiverEndpoint, Discriminator2)
});
c.GetSettings().GetOrCreate <DistributionPolicy>()
.SetDistributionStrategy(new SelectFirstDistributionStrategy(ReceiverEndpoint, (Context)ScenarioContext));
});
}
IEnumerable <string> ResolveRoute(UnicastRoute route)
{
if (route.Instance != null)
{
yield return(resolveTransportAddress(route.Instance));
}
else if (route.PhysicalAddress != null)
{
yield return(route.PhysicalAddress);
}
else
{
foreach (var instance in endpointInstances.FindInstances(route.Endpoint))
{
yield return(resolveTransportAddress(instance));
}
}
}
public void When_routes_are_ambiguous_should_throw_exception()
{
var routingTable = new UnicastRoutingTable();
var lowPriorityRoute = UnicastRoute.CreateFromEndpointName("Endpoint1");
var highPriorityRoute = UnicastRoute.CreateFromEndpointName("Endpoint2");
routingTable.AddOrReplaceRoutes("key2", new List <RouteTableEntry>()
{
new RouteTableEntry(typeof(Command), highPriorityRoute),
});
Assert.That(() =>
{
routingTable.AddOrReplaceRoutes("key1", new List <RouteTableEntry>()
{
new RouteTableEntry(typeof(Command), lowPriorityRoute),
});
}, Throws.Exception);
}
public void Setup(FeatureConfigurationContext context)
{
var mainEndpointName = context.Settings.EndpointName();
var routerEndpointName = $"{mainEndpointName}_Migrator";
var settings = context.Settings.Get <MigratorSettings>();
var unicastRouteTable = context.Settings.Get <UnicastRoutingTable>();
var distributionPolicy = context.Settings.Get <DistributionPolicy>();
var transportInfrastructure = context.Settings.Get <TransportInfrastructure>();
var queueBindings = context.Settings.Get <QueueBindings>();
var customizeOldTransport = context.Settings.Get <Action <TransportExtensions <TOld> > >(MigratorConfigurationExtensions.OldTransportCustomizationSettingsKey);
var customizeNewTransport = context.Settings.Get <Action <TransportExtensions <TNew> > >(MigratorConfigurationExtensions.NewTransportCustomizationSettingsKey);
var routerAddress = transportInfrastructure.ToTransportAddress(LogicalAddress.CreateRemoteAddress(new EndpointInstance(routerEndpointName)));
queueBindings.BindSending(routerAddress);
//context.RegisterStartupTask(b => new RoutingMonitor(unicastRouteTable, settings.SendRouteTable, route, b.Build<CriticalError>()));
var route = UnicastRoute.CreateFromPhysicalAddress(routerAddress);
var routes = settings.SendRouteTable.Select(x => new RouteTableEntry(x.Key, route)).ToList();
unicastRouteTable.AddOrReplaceRoutes("NServiceBus.Router.Migrator", routes);
context.Pipeline.Register(new MigratorRouterDestinationBehavior(settings.SendRouteTable),
"Sets the ultimate destination endpoint on the outgoing messages.");
context.Pipeline.Replace("MigrationModePublishConnector", b => new DualRoutingPublishConnector(routerAddress, distributionPolicy, b.Build <MessageMetadataRegistry>(), i => transportInfrastructure.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)), b.Build <ISubscriptionStorage>()),
"Routes published messages via router and publishes them natively");
context.Pipeline.Register(b => new UnsubscribeAfterMigrationBehavior(b.BuildAll <ISubscriptionStorage>().FirstOrDefault()),
"Removes old transport subscriptions when a new transport subscription for the same event and endpoint comes in");
context.Pipeline.Register(new DualRoutingFilterBehavior(mainEndpointName), "Ignores duplicates when publishing both natively and message-driven");
context.Pipeline.Register(b => new MigratorRouterSubscribeBehavior(context.Settings.LocalAddress(), context.Settings.EndpointName(), routerAddress, b.Build <IDispatchMessages>(), settings.PublisherTable),
"Dispatches the subscribe request via a router.");
var routerConfig = PrepareRouterConfiguration(routerEndpointName, mainEndpointName, context.Settings.LocalAddress(), customizeOldTransport, customizeNewTransport);
context.RegisterStartupTask(new MigratorStartupTask(routerConfig));
}
public Sender()
{
EndpointSetup <DefaultServer>(c =>
{
c.GetSettings().GetOrCreate <UnicastRoutingTable>()
.AddOrReplaceRoutes("CustomRoutingFeature", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyCommand), UnicastRoute.CreateFromEndpointName(ReceiverEndpoint))
});
c.GetSettings().GetOrCreate <EndpointInstances>()
.AddOrReplaceInstances("CustomRoutingFeature", new List <EndpointInstance>
{
new EndpointInstance(ReceiverEndpoint, "XYZ"),
new EndpointInstance(ReceiverEndpoint, "ABC")
});
c.GetSettings().GetOrCreate <DistributionPolicy>()
.SetDistributionStrategy(new XyzDistributionStrategy(ReceiverEndpoint));
});
}
public void When_routing_to_specific_instance_should_throw_when_route_for_given_type_points_to_physical_address()
{
var table = new UnicastRoutingTable();
table.AddOrReplaceRoutes("A", new List <RouteTableEntry>
{
new RouteTableEntry(typeof(MyMessage), UnicastRoute.CreateFromPhysicalAddress("PhysicalAddress"))
});
var router = CreateRouter(routingTable: table);
var options = new SendOptions();
options.RouteToSpecificInstance("instanceId");
var context = CreateContext(options);
var exception = Assert.Throws <Exception>(() => router.Route(context));
StringAssert.Contains("Routing to a specific instance is only allowed if route is defined for a logical endpoint, not for an address or instance.", exception.Message);
}
static void UpdateRoutingTable(XmlRoutingFileParser routingFileParser, XmlRoutingFileAccess routingFile, UnicastRoutingTable routingTable, UnicastSubscriberTable subscriberTable, bool nativeSends, bool nativePublishes)
{
try
{
var endpoints = routingFileParser.Parse(routingFile.Read());
var commandRoutes = new List <RouteTableEntry>();
var eventRoutes = new List <RouteTableEntry>();
foreach (var endpoint in endpoints)
{
var route = UnicastRoute.CreateFromEndpointName(endpoint.LogicalEndpointName);
foreach (var commandType in endpoint.Commands)
{
if (nativeSends)
{
log.Warn($"Selected transport uses native command routing. Route for {commandType.FullName} to {endpoint.LogicalEndpointName} configured in {routingFile.FileUri} will be ignored.");
}
commandRoutes.Add(new RouteTableEntry(commandType, route));
}
foreach (var eventType in endpoint.Events)
{
if (nativePublishes)
{
log.Warn($"Selected transport uses native event routing. Route for {eventType.FullName} to {endpoint.LogicalEndpointName} configured in {routingFile.FileUri} will be ignored.");
}
eventRoutes.Add(new RouteTableEntry(eventType, route));
}
}
routingTable.AddOrReplaceRoutes("FileBasedRouting", commandRoutes);
subscriberTable.AddOrReplaceRoutes("FileBasedRouting", eventRoutes);
log.Debug($"Updated routing information from {routingFile.FileUri}");
}
catch (Exception e)
{
log.Error($"Failed to update routing information from {routingFile.FileUri}. The last valid routing configuration will be used instead.", e);
throw;
}
}
public TypeRouteSource(Type messageType, UnicastRoute route)
{
this.messageType = messageType;
this.route = route;
}
public AssemblyRouteSource(Assembly messageAssembly, UnicastRoute route)
{
this.messageAssembly = messageAssembly;
this.route = route;
}
public NamespaceRouteSource(Assembly messageAssembly, string messageNamespace, UnicastRoute route)
{
this.messageAssembly = messageAssembly;
this.route = route;
this.messageNamespace = messageNamespace;
}
