bool IsRouteDefinedFor(Type messageType, UnicastRoutingTable unicastRoutingTable)
{
//this could be a FastDelegate invocation
var unicastRoute = (UnicastRoute)typeof(UnicastRoutingTable)
.GetMethod("GetRouteFor", BindingFlags.Instance | BindingFlags.NonPublic)
.Invoke(unicastRoutingTable, new[] { messageType });
return(unicastRoute != null);
}
public RoutingInfoSubscriber(UnicastRoutingTable routingTable, EndpointInstances endpointInstances, IReadOnlyCollection <Type> messageTypesHandledByThisEndpoint, Publishers publishers, TimeSpan sweepPeriod, TimeSpan heartbeatTimeout)
{
this.routingTable = routingTable;
this.endpointInstances = endpointInstances;
this.messageTypesHandledByThisEndpoint = messageTypesHandledByThisEndpoint;
this.publishers = publishers;
this.sweepPeriod = sweepPeriod;
this.heartbeatTimeout = heartbeatTimeout;
}
public void Setup()
{
routingTable = new UnicastRoutingTable();
endpointInstances = new EndpointInstances();
router = new UnicastSendRouter(
routingTable,
endpointInstances,
i => i.ToString());
}
public void Apply(UnicastRoutingTable unicastRoutingTable, Conventions conventions)
{
var entries = new Dictionary<Type, RouteTableEntry>();
foreach (var source in routeSources.OrderBy(x => x.Priority)) //Higher priority routes sources override lower priority.
{
foreach (var route in source.GenerateRoutes(conventions))
{
entries[route.MessageType] = route;
}
}
unicastRoutingTable.AddOrReplaceRoutes("EndpointConfiguration", entries.Values.ToList());
}
public void Apply(UnicastRoutingTable unicastRoutingTable, Conventions conventions)
{
var entries = new Dictionary <Type, RouteTableEntry>();
foreach (var source in routeSources.OrderBy(x => x.Priority)) //Higher priority routes sources override lower priority.
{
foreach (var route in source.GenerateRoutes(conventions))
{
entries[route.MessageType] = route;
}
}
unicastRoutingTable.AddOrReplaceRoutes("EndpointConfiguration", entries.Values.ToList());
}
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);
}
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));
}
RoutingComponent(UnicastRoutingTable unicastRoutingTable,
DistributionPolicy distributionPolicy,
EndpointInstances endpointInstances,
Publishers publishers,
UnicastSendRouter unicastSendRouter,
bool enforceBestPractices,
Validations messageValidator)
{
UnicastRoutingTable = unicastRoutingTable;
DistributionPolicy = distributionPolicy;
EndpointInstances = endpointInstances;
Publishers = publishers;
EnforceBestPractices = enforceBestPractices;
MessageValidator = messageValidator;
UnicastSendRouter = unicastSendRouter;
}
public UnicastSendRouter(
bool isSendOnly,
string receiveQueueName,
string instanceSpecificQueue,
IDistributionPolicy defaultDistributionPolicy,
UnicastRoutingTable unicastRoutingTable,
EndpointInstances endpointInstances,
Func <EndpointInstance, string> transportAddressTranslation)
{
this.isSendOnly = isSendOnly;
this.receiveQueueName = receiveQueueName;
this.instanceSpecificQueue = instanceSpecificQueue;
this.defaultDistributionPolicy = defaultDistributionPolicy;
this.unicastRoutingTable = unicastRoutingTable;
this.endpointInstances = endpointInstances;
this.transportAddressTranslation = transportAddressTranslation;
}
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 UnicastSendRouter(
string baseInputQueueName,
string endpointName,
string instanceSpecificQueue,
string distributorAddress,
IDistributionPolicy defaultDistributionPolicy,
UnicastRoutingTable unicastRoutingTable,
EndpointInstances endpointInstances,
Func <EndpointInstance, string> transportAddressTranslation)
{
this.endpointName = baseInputQueueName ?? endpointName;
this.instanceSpecificQueue = instanceSpecificQueue;
this.distributorAddress = distributorAddress;
this.defaultDistributionPolicy = defaultDistributionPolicy;
this.unicastRoutingTable = unicastRoutingTable;
this.endpointInstances = endpointInstances;
this.transportAddressTranslation = transportAddressTranslation;
}
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 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);
}
public Configuration(
UnicastRoutingTable unicastRoutingTable,
Publishers publishers,
DistributionPolicy distributionPolicy,
ConfiguredUnicastRoutes configuredUnicastRoutes,
IReadOnlyList <DistributionStrategy> customDistributionStrategies,
EndpointInstances settingsEndpointInstances,
bool enforceBestPractices,
string returnAddressOverride)
{
UnicastRoutingTable = unicastRoutingTable;
Publishers = publishers;
DistributionPolicy = distributionPolicy;
CustomDistributionStrategies = customDistributionStrategies;
ConfiguredUnicastRoutes = configuredUnicastRoutes;
EnforceBestPractices = enforceBestPractices;
PublicReturnAddress = returnAddressOverride;
EndpointInstances = settingsEndpointInstances;
}
internal void Apply(Publishers publishers, UnicastRoutingTable unicastRoutingTable, Func <string, string> makeCanonicalAddress, Conventions conventions)
{
var routeTableEntries = new Dictionary <Type, RouteTableEntry>();
var publisherTableEntries = new List <PublisherTableEntry>();
foreach (var m in this.Cast <MessageEndpointMapping>().OrderByDescending(m => m))
{
m.Configure((type, endpointAddress) =>
{
if (!conventions.IsMessageType(type))
{
return;
}
var canonicalForm = makeCanonicalAddress(endpointAddress);
var baseTypes = GetBaseTypes(type, conventions);
RegisterMessageRoute(type, canonicalForm, routeTableEntries, baseTypes);
RegisterEventRoute(type, canonicalForm, publisherTableEntries, baseTypes);
});
}
publishers.AddOrReplacePublishers("MessageEndpointMappings", publisherTableEntries);
unicastRoutingTable.AddOrReplaceRoutes("MessageEndpointMappings", routeTableEntries.Values.ToList());
}
public RoutingMonitor(UnicastRoutingTable routingTable, Dictionary <Type, string> endpointMap, UnicastRoute routeToRouter, CriticalError criticalError)
{
this.routingTable = routingTable;
this.criticalError = criticalError;
routeState = endpointMap.ToDictionary(kvp => kvp.Key, kvp => new RouteState(routeToRouter, kvp.Key, kvp.Value));
}
static void UpdateRoutingTable(DatabaseReader databaseReader, string connectionString, UnicastRoutingTable routingTable, UnicastSubscriberTable subscriberTable, bool nativeSends, bool nativePublishes)
{
try
{
var endpoints = databaseReader.GetEndpoints(connectionString);
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 database 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 database will be ignored.");
}
eventRoutes.Add(new RouteTableEntry(eventType, route));
}
}
routingTable.AddOrReplaceRoutes("DatabaseBasedRouting", commandRoutes);
subscriberTable.AddOrReplaceRoutes("DatabaseBasedRouting", eventRoutes);
_log.Debug($"Updated routing information from database");
}
catch (Exception e)
{
_log.Error($"Failed to update routing information from database. The last valid routing configuration will be used instead.", e);
throw;
}
}
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 RobustRefresher(UnicastRoutingTable routeTable, CriticalError criticalError)
{
this.routeTable = routeTable;
this.criticalError = criticalError;
}
public Refresher(UnicastRoutingTable routeTable)
{
this.routeTable = routeTable;
}
public UnicastSendRouter(UnicastRoutingTable unicastRoutingTable, EndpointInstances endpointInstances, Func <EndpointInstance, string> transportAddressTranslation)
{
this.unicastRoutingTable = unicastRoutingTable;
this.endpointInstances = endpointInstances;
this.transportAddressTranslation = transportAddressTranslation;
}
public UnicastSendRouter(UnicastRoutingTable unicastRoutingTable, EndpointInstances endpointInstances, Func<EndpointInstance, string> transportAddressTranslation)
{
this.unicastRoutingTable = unicastRoutingTable;
this.endpointInstances = endpointInstances;
this.transportAddressTranslation = transportAddressTranslation;
}
static UnicastSendRouter CreateRouter(string instanceSpecificQueue = null, bool isSendOnly = false, UnicastRoutingTable routingTable = null, EndpointInstances instances = null, DistributionPolicy policy = null)
{
var table = routingTable ?? new UnicastRoutingTable();
var inst = instances ?? new EndpointInstances();
var pol = policy ?? new DistributionPolicy();
return(new UnicastSendRouter(isSendOnly, "Endpoint", instanceSpecificQueue, pol, table, inst, i => i.ToString()));
}
public MyBehavior(UnicastRoutingTable unicastRoutingTable, Func <object, object> partitionMap, Dictionary <string, string> addressMap)
{
_unicastRoutingTable = unicastRoutingTable;
_partitionMap = partitionMap;
_addressMap = addressMap;
}
internal void Apply(Publishers publishers, UnicastRoutingTable unicastRoutingTable, Func<string, string> makeCanonicalAddress, Conventions conventions)
{
var routeTableEntries = new Dictionary<Type, RouteTableEntry>();
var publisherTableEntries = new List<PublisherTableEntry>();
foreach (var m in this.Cast<MessageEndpointMapping>().OrderByDescending(m => m))
{
m.Configure((type, endpointAddress) =>
{
if (!conventions.IsMessageType(type))
{
return;
}
var canonicalForm = makeCanonicalAddress(endpointAddress);
var baseTypes = GetBaseTypes(type, conventions);
RegisterMessageRoute(type, canonicalForm, routeTableEntries, baseTypes);
RegisterEventRoute(type, canonicalForm, publisherTableEntries, baseTypes);
});
}
publishers.AddOrReplacePublishers("MessageEndpointMappings", publisherTableEntries);
unicastRoutingTable.AddOrReplaceRoutes("MessageEndpointMappings", routeTableEntries.Values.ToList());
}
