internal static void Validate(ICollection <MessageFilter> messageFilters, HashSet <string> endpoints)
{
foreach (MessageFilter filter in messageFilters)
{
EndpointNameMessageFilter endpointFilter = filter as EndpointNameMessageFilter;
if (endpointFilter != null)
{
endpointFilter.Validate(endpoints);
}
}
}
private static void ConfigureRouterViaCode(ServiceHost serviceHost)
{
//This code sets up the Routing Sample via code. Rename the provided app.config
//to App.config.example and uncomment this method call to run a config-based Routing Service
//set up some communication defaults
//note that some of these are a little artifical for the purpose of demonstrating
//different filter types and how to define them
//the regular calculator service is located at net.tcp://localhost:9090/servicemodelsamples/service/
string calcDestinationAddress = "net.tcp://localhost:9090/servicemodelsamples/service/";
//the rounding calc service is located at net.tcp://localhost:8080/servicemodelsamples/service/
string roundingDestinationAddress = "net.tcp://localhost:8080/servicemodelsamples/service/";
//the "Default" router address
string routerAddress = "http://localhost/routingservice/router/general";
//the virtualized address of the regular calculator
string virtualCalculatorAddress = "http://localhost/routingservice/router/regular/calculator";
//the virtualized address of the rounding calculator
string virtualRoundingCalculatorAddress = "http://localhost/routingservice/router/rounding/calculator";
//set up the bindings for the Routing Service's communication with the client
Binding routerBinding = new WSHttpBinding();
//set up the bindings for the Routing Service's communication with the Calculator Services
Binding clientBinding = new NetTcpBinding();
//use the IRequestReplyRouter since the client and services are expecting request/response communication
ContractDescription contract = ContractDescription.GetContract(typeof(IRequestReplyRouter));
//set up the default Router endpoint
ServiceEndpoint routerEndpoint = new ServiceEndpoint(contract, routerBinding, new EndpointAddress(routerAddress));
routerEndpoint.Name = "routerEndpoint";
//create the virtual endpoint for the regular CalculatorSerivice
ServiceEndpoint calcEndpoint = new ServiceEndpoint(contract, routerBinding, new EndpointAddress(virtualCalculatorAddress));
calcEndpoint.Name = "calculatorEndpoint";
//create the virtual endpoint for the rounding CalculatorSerivice
ServiceEndpoint roundingEndpoint = new ServiceEndpoint(contract, routerBinding, new EndpointAddress(virtualRoundingCalculatorAddress));
roundingEndpoint.Name = "roundingEndpoint";
//add the inbound endpoints that the Routing Service will listen for
serviceHost.AddServiceEndpoint(routerEndpoint);
serviceHost.AddServiceEndpoint(calcEndpoint);
serviceHost.AddServiceEndpoint(roundingEndpoint);
//create the client endpoints the router will route messages to
ServiceEndpoint RegularCalcEndpoint = new ServiceEndpoint(contract, new NetTcpBinding(), new EndpointAddress(calcDestinationAddress));
ServiceEndpoint RoundingCalcEndpoint = new ServiceEndpoint(contract, new NetTcpBinding(), new EndpointAddress(roundingDestinationAddress));
//create the endpoint lists that contains the service endpoints we want to route to
List<ServiceEndpoint> RegularCalcs = new List<ServiceEndpoint>();
List<ServiceEndpoint> RoundingCalcs = new List<ServiceEndpoint>();
//add the endpoints in the order we want the Routing Service to try sending to them
RegularCalcs.Add(RegularCalcEndpoint);
RoundingCalcs.Add(RoundingCalcEndpoint);
//create the default RoutingConfiguration
RoutingConfiguration rc = new RoutingConfiguration();
//create all of the necessary filters
//create a new XPathMessageFilter that will look for the custom header
//Unfortunately, the default namespace manager doesn't have the custom namespace
// that we use defined so we have to define that prefix ourselves.
//Any message that shows up with this header will match this filter.
XPathMessageContext namespaceManager = new XPathMessageContext();
namespaceManager.AddNamespace("custom", "http://my.custom.namespace/");
XPathMessageFilter xpathFilter = new XPathMessageFilter("sm:header()/custom:RoundingCalculator = 1", namespaceManager);
//create a new Endpoint Name Message Filter, which will match any message that was received
//on the calculator Endpoint. The Endpoint name was defined when we created the service endpoint object
EndpointNameMessageFilter endpointNameFilter = new EndpointNameMessageFilter("calculatorEndpoint");
//Create a new Prefix Endpoint Address Message Filter. This will match any message that showed up on an endpoint
//with an address that matches the address -prefix- (or front portion) provided. In this example we define
//the address prefix as "http://localhost/routingservice/router/rounding/". This means that any messages that arrive
//addressed to http://localhost/routingservice/router/rounding/* will be matched by this filter. In this case, that
//will be messages that show up on the rounding calculator endpoint, which has the address of
//http://localhost/routingservice/router/rounding/calculator.
PrefixEndpointAddressMessageFilter prefixAddressFilter = new PrefixEndpointAddressMessageFilter(new EndpointAddress("http://localhost/routingservice/router/rounding/"));
//create two new Custom message filters. In this example, we're going to use a "RoundRobin" message filter
//this message filter is created in the provided RoundRobinMessageFilter.cs file. These filters, when set
//to the same group, will alternate between reporting that they match the message and that they don't, such that
//only one of them will respond true at a time.
RoundRobinMessageFilter roundRobinFilter1 = new RoundRobinMessageFilter("group1");
RoundRobinMessageFilter roundRobinFilter2 = new RoundRobinMessageFilter("group1");
//Now let's add all of those Message Filters to the Message Filter Table
//note the use of priorities to influence the order in which the MessageFilter Table
//executes the filters. The higher the priority, the sooner the filter will be
//executed, the lower the priority, the later a filter will be executed. Thus a filter
//at priority 2 runs before a filter at priority 1. The default priority level
//if one isn't specified is 0. A Message Filter Table executes all of the filters
//at a given priority level before moving to the next lowest priority level.
//If a match is found at a particular priority, then the Message Filter Table doesn't
//continue trying to find matches at the next lower priority.
//
//While this example shows how to use Message Filter priorities, in general it is
//more performant and better design to design and configure your filters such that they
//don't require prioritization in order to function correctly.
//The first filter we add is the XPath filter, and we set its priority to 2.
//Thus this will be the first MessageFilter that executes. If it finds the custom
//header, regardless of what the results of the other filters would be, the message
//will be routed to the Rounding Calculator endpoint.
//catch messages that showed up with the custom header
rc.FilterTable.Add(xpathFilter, RoundingCalcs, 2);
//At priority 1, we'll add two filters. These will only run if the xpath filter
//at priority 2 doesn't match the message. These two filters show two different ways to
//determine where the message was addressed when it showed up. Because they effectively check
//to see if the message arrived at one of the two endpoints, we can run them
//at the same priority level since they're never going to both return true.
//find messages that showed up addressed to the specific virtual endpoints
rc.FilterTable.Add(endpointNameFilter, RegularCalcs, 1);
rc.FilterTable.Add(prefixAddressFilter, RoundingCalcs, 1);
//Finally, run the RoundRobin message filters. Since we configured the filters
//with the same group name, only one of them will match at a time. Since we've already
//Routed all the messages with the custom header, and then those addressed to the specific
//virtualized endpoints, these will only be messages that showed up addressed to the
//default router endpoint without the custom header. Since these will switch based
//on a per message call, half of the operations will go to the regular calculator, and
//half will go to the Rounding calculator.
rc.FilterTable.Add(roundRobinFilter1, RegularCalcs, 0);
rc.FilterTable.Add(roundRobinFilter2, RoundingCalcs, 0);
//create the Routing Behavior with the Routing Configuration and add it to the
//serviceHost's Description.
serviceHost.Description.Behaviors.Add(new RoutingBehavior(rc));
}
internal MessageFilter CreateFilter(XmlNamespaceManager xmlNamespaces, FilterElementCollection filters)
{
MessageFilter filter;
switch (this.FilterType)
{
case FilterType.Action:
filter = new ActionMessageFilter(this.FilterData);
break;
case FilterType.EndpointAddress:
filter = new EndpointAddressMessageFilter(new EndpointAddress(this.FilterData), false);
break;
case FilterType.PrefixEndpointAddress:
filter = new PrefixEndpointAddressMessageFilter(new EndpointAddress(this.FilterData), false);
break;
case FilterType.And:
MessageFilter filter1 = filters[this.Filter1].CreateFilter(xmlNamespaces, filters);
MessageFilter filter2 = filters[this.Filter2].CreateFilter(xmlNamespaces, filters);
filter = new StrictAndMessageFilter(filter1, filter2);
break;
case FilterType.EndpointName:
filter = new EndpointNameMessageFilter(this.FilterData);
break;
case FilterType.MatchAll:
filter = new MatchAllMessageFilter();
break;
case FilterType.Custom:
filter = CreateCustomFilter(this.CustomType, this.FilterData);
break;
case FilterType.XPath:
filter = new XPathMessageFilter(this.FilterData, xmlNamespaces);
break;
default:
// We can't really ever get here because set_FilterType performs validation.
throw FxTrace.Exception.AsError(new InvalidOperationException());
}
return filter;
}