/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
var connectionString = Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING");
var containerName = Environment.GetEnvironmentVariable("RESULT_CONTAINER_NAME");
var storageAccount = CloudStorageAccount.Parse(connectionString);
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName);
await cloudBlobContainer.CreateIfNotExistsAsync();
http = new HttpRouter(new string[] { "http://+:80/" });
http.Register("/caption", SetCaption);
http.Register("/video/start", StartRecording);
http.Register("/video/end", EndRecording);
http.Register("/photo", TakePhoto);
http.Start();
await Task.CompletedTask;
}
public async Task MatchNamePortAndSetHostAddress()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
/// <summary>
/// Creates a DefaultHttpSysService instance with the specified host and port.
/// </summary>
/// <param name="isSecured">NOT_SUPPORTED_YET</param>
/// <param name="host">host</param>
/// <param name="port">port</param>
public DefaultHttpSysService(bool isSecured, string host, int port)
{
_inputPipe = new BlockingCollection <HttpContext>();
_outputPipe = new BlockingCollection <HttpContext>();
_httpInboundAdapter = new HttpSysInboundAdapter();
_httpOutboundAdapter = new HttpSysOutboundAdapter();
_httpRouter = new HttpRouter(this);
_httpProcessors = new Dictionary <string, IHttpProcessor>();
//set names
_httpInboundAdapter.Name = "TxHTTP_Inbound_Adapter";
_httpOutboundAdapter.Name = "TxHTTP_Outbound_Adapter";
_httpRouter.Name = "TxHTTP_Router";
//HttpInboundAdapter ----<TaggedContext>----> HttpRouter
_httpInboundAdapter.OutputPipe = _inputPipe;
_httpRouter.InputPipe = _inputPipe;
//---<HttpContext>---> HttpOutboundAdapter
_httpOutboundAdapter.InputPipe = _outputPipe;
_routingEngine = new RoutingEngine();
AddController(new HttpInternalController(), INTERNAL_PROCESSING_GROUP);
//create ServiceConfiguration
_serviceConfiguration = new ServiceConfiguration();
_serviceConfiguration.IsSecured = isSecured;
_serviceConfiguration.Host = host;
_serviceConfiguration.Port = port;
}
public async Task doHttpPutWithQueryString()
{
var resolver = new HttpRouteResolver();
var path = "api/models/";
var sentModel = Model.getRandomModel();
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Put);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new HttpAddSetHeaderMatcher("Content-Type", "application/json"),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path, "?ModelId=", sentModel.ModelId), sentModel.asJsonStream());
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
var modelReturn = JsonConvert.DeserializeObject <ModelControllerResponseContent>(responseString);
Assert.AreEqual(sentModel.ModelId, modelReturn.Models[0].ModelId);
Assert.AreEqual(string.Concat(srv02Address, path, "?ModelId=", sentModel.ModelId), modelReturn.RequestUri);
}
public async Task BasicWiring()
{
var resolver = new HttpRouteResolver();
/*
* route from bing to microsoft
*
*/
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher("www.microsoft.com"),
new HostAddressMatcher("www.bing.com", StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync("http://www.bing.com");
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
Trace.WriteLine(await responseMessage.Content.ReadAsStringAsync());
}
/// <summary>
/// Initializes a new instance of the <see cref="MosaicRoutesApi"/> class
/// using Configuration object
/// </summary>
/// <param name="configuration">An instance of Configuration</param>
/// <returns></returns>
internal MosaicRoutesApi(HttpRouter http, Configuration configuration = null)
{
if (configuration == null) // use the default one in Configuration
{
Configuration = Configuration.Default;
}
else
{
Configuration = configuration;
}
if (http.Url == null)
{
throw new NullReferenceException("Url cannot be null");
}
Configuration.ApiClient = new ApiClient(http.Url);
ExceptionFactory = Configuration.DefaultExceptionFactory;
// ensure API client has configuration ready
if (Configuration.ApiClient.Configuration == null)
{
Configuration.ApiClient.Configuration = Configuration;
}
}
public async Task MatchOnContextUsingCustomValuePredicate()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
var customKey = "MyCustomContextKey";
var customValue = "MyCustomValue";
// this pluming is to extract which host are we going to use to route
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
// whenever our custom predicate return true we will route the traffic to server 2
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new ContextCustomValueMatcher(customKey, (k, v) =>
{
var ar = v as string[];
if (null == ar)
{
return(false);
}
if (ar.Length == 3)
{
return(true);
}
return(false);
}));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var context = new Dictionary <string, object>();
// context contains a custom value that is a string array
context.Add(customKey, new string[] { customValue, customValue, customValue });
var results = await router.RouteAsync(string.Concat(srv01Address, path), context);
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
public static void Main(string[] args)
{
Configuration = new Configuration();
if (!File.Exists("config.json"))
{
File.WriteAllText("config.json", JsonConvert.SerializeObject(Configuration, Formatting.Indented));
Console.WriteLine("Empty config.json file created. Populate it and restart.");
return;
}
JsonConvert.PopulateObject(File.ReadAllText("config.json"), Configuration);
File.WriteAllText("config.json", JsonConvert.SerializeObject(Configuration, Formatting.Indented));
if (Configuration.Irc.Enabled)
{
IrcBot = new IrcBot();
}
var httpd = new HttpServer();
var router = new HttpRouter();
httpd.LogRequests = Configuration.LogRequests;
httpd.Request = router.Route;
var staticContent = new StaticContentHandler(Configuration.MusicPath);
router.AddRoute(new StaticContentRoute(staticContent));
var staticResources = new StaticContentHandler(Path.Combine(".", "Static"));
router.AddRoute(new StaticContentRoute(staticResources));
var mvc = new MvcRouter();
mvc.RegisterController(new IndexController());
mvc.AddRoute("Default", "{action}", new { controller = "Index", action = "Index" });
router.AddRoute(mvc);
router.AddRoute(new RegexRoute("/download/(?<path>.*)", (context, request, response) =>
{
response.AddHeader("Content-Disposition", string.Format("attachment; filename=\"{0}\"", Path.GetFileName(context["path"])));
staticContent.Serve(context["path"], request, response);
}));
MusicRunner.Start();
httpd.Start(new IPEndPoint(IPAddress.Parse(Configuration.EndPoint), Configuration.Port));
if (Configuration.Irc.Enabled)
{
IrcBot.Start();
}
Console.WriteLine("Type 'quit' to exit, or 'help' for help.");
string command = null;
while (command != "quit")
{
command = Console.ReadLine();
HandleCommand(command);
}
}
public async Task FastestRoute()
{
var resolver = new HttpRouteResolver();
/*
* anything point to http://localhost:9001
* will be routed as fastest route to
* http://locahost:9002 or http://locahost:9003
*
* With HttpGet + Same path
*
*/
var path = "api/randomdelay/0";
var trytimes = 5;
var firstMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
firstMatcher.Chain(new SetAddressListMatcher(new string[] { Srv01HostNamePort, Srv02HostNamePort, Srv03HostNamePort }, false, ContextRoutingType.FastestRoute),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(firstMatcher, 0);
var router = new HttpRouter(resolver);
var resultsList = new List <HttpRoutingResult>(trytimes);
var responsesList = new HashSet <string>();
// call as many as try times
for (var i = 1; i <= trytimes; i++)
{
resultsList.Add(await router.RouteAsync(string.Concat(srv01Address, path)));
}
foreach (var result in resultsList)
{
var responseMessage = await result.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
responsesList.Add(responseString);
}
// server returns the address
// in the response
// any count > 1 means that router is routing to more than one end point
Assert.AreEqual(true, responsesList.Count > 1);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
WriteLog("IoT Hub module client initialized.");
var connectionString = Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING");
var containerName = Environment.GetEnvironmentVariable("RESULT_CONTAINER_NAME");
var storageAccount = CloudStorageAccount.Parse(connectionString);
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName);
await cloudBlobContainer.CreateIfNotExistsAsync();
// XXX 環境変数に
videoInputStream = new VideoInputStream(0);
videoInputStream.Start();
var rtmpUri = Environment.GetEnvironmentVariable("RTMP_URI");
// XXX Size
videoLiveStream = new FfmpegRtmpVideoOutputStream(rtmpUri, fps, new Size(320, 240));
videoLiveStream.Start();
caption = new CaptionRequest {
Caption = ""
};
captionFont = new System.Drawing.Font("noto", 15f);
smallFont = new System.Drawing.Font("noto", 10f);
frameTimer = new System.Timers.Timer(1.0 / fps);
frameTimer.Elapsed += UpdateFrame;
frameTimer.Start();
http = new HttpRouter(new string[] { "http://+:80/" });
http.Register("/caption", SetCaption);
http.Register("/video/start", StartRecording);
http.Register("/video/end", EndRecording);
http.Register("/photo", TakePhoto);
http.Register("/photo_with_caption", TakePhotoWithCaption);
http.Start();
await Task.CompletedTask;
}
public async Task AggregateMultipleEndPoints()
{
var resolver = new HttpRouteResolver();
/*
* anything point to http://localhost:9001
* will be routed as be aggregated from multiple backend endpoints
*
* With HttpGet + Same path
*
*/
var path = "api/randomdelay/0";
var Hosts = 3;
var firstMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
firstMatcher.Chain(new SetAddressListMatcher(new string[] { Srv01HostNamePort, Srv02HostNamePort, Srv03HostNamePort }, false, ContextRoutingType.ScatterGather),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(firstMatcher, 0);
var router = new HttpRouter(resolver);
var resultsList = new List <HttpRoutingResult>(Hosts);
var responsesList = new HashSet <string>();
// call as many as try times
var allResults = await router.RouteAsync(string.Concat(srv01Address, path));
foreach (var result in await allResults.ResultAsAsync <List <HttpResponseMessage> >())
{
var responseString = await result.Content.ReadAsStringAsync();
responsesList.Add(responseString);
}
Assert.IsTrue(responsesList.Count == 3); // all hosts in the system
}
public async Task RetryThenRoute()
{
var resolver = new HttpRouteResolver();
/*
* Attempt to an address (that will fail), then retry after 10 ms, if still failing
* it will route to a different server.
*/
var path = "api/values/0";
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher("fail"), // point to an address that does not exist (i really hope that you have a machine on your network named "fail")
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var headStrategy = new RetryAfterStrategy(10);
// chain
headStrategy.ThenRouteToHost(Srv02HostNamePort);
router.DefaultContextExecuteStrategy = headStrategy;
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
public async Task MatchUsingCustomPredicate()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
// whenever our custom predicate return true we will route the traffic to server 2
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new PredicateMatcher((routingctx, address, ctx, body) =>
{
return(true);
}));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var context = new Dictionary <string, object>();
// context contains a custom value that is a string array
var results = await router.RouteAsync(string.Concat(srv01Address, path), context);
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
public static IHttpService UseHttp2(this IConnectionService @this, Action <Http2Options, HttpRouter> handler)
{
if (@this == null)
{
throw new ArgumentNullException(nameof(@this));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var optionsValue = new Http2Options();
var router = new HttpRouter();
handler.Invoke(optionsValue, router);
if (optionsValue.Certificate == null)
{
throw new ArgumentNullException(nameof(optionsValue.Certificate));
}
var http1 = new HttpService(
optionsValue.Http1KeepAliveTimeout,
optionsValue.Http1ReceiveTimeout,
optionsValue.Http1SendTimeout,
optionsValue.Http1MaxHeaderSize
);
http1.Handler = router;
var http2 = new Http2Service(
optionsValue.KeepAliveTimeout,
optionsValue.ReceiveTimeout,
optionsValue.SendTimeout,
optionsValue.MaxConcurrentStreams,
optionsValue.InitialWindowSize,
optionsValue.MaxHeaderListSize,
optionsValue.MaxSettings
);
http2.Handler = router;
var service = new Service(http1, http2, optionsValue.Certificate, optionsValue.HandShakeTimeout);
@this.Handler = service;
return(service);
}
public async Task MatchOnContextContainsKeyWithStringValue()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
var customKey = "MyCustomContextKey";
var customValue = "MyCustomValue";
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new ContextValueStringMatcher(customKey, customValue, StringMatchType.Exact));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var context = new Dictionary <string, object>();
context.Add(customKey, customValue);
var results = await router.RouteAsync(string.Concat(srv01Address, path), context);
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
public async Task RemoveHeader()
{
var resolver = new HttpRouteResolver();
var path = "api/Headers/0";
var customHeaderName = "customHeader";
var customHeaderValue = "customHeaderValue";
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new HttpRemoveHeaderMatcher(customHeaderName),
new HttpAddSetHeaderMatcher(customHeaderName, customHeaderValue),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
var dict = JsonConvert.DeserializeObject <Dictionary <string, IEnumerable <string> > >(responseString);
// server returns the headers in the response
Assert.AreEqual(false, dict.ContainsKey(customHeaderName));
}
public async Task MatchOnIIFMatcher()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
var customKey = "MyCustomContextKey";
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
// Whenever a context contains a key we will route all the traffic to server02
headMatcher.Chain(
new IIFMatcher(
new ContextContainsKeyMatcher(customKey, StringMatchType.Exact),
new SetAddressListMatcher(Srv02HostNamePort),
new SetAddressListMatcher(Srv03HostNamePort)
)
);
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv03Address, path), responseString);
}
public async Task MatchUsingOrMatcher()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
// if true || False then set address to serve2 and method to get
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new OrMatcher(
new FalseMatcher(),
new TrueMatcher()
)
);
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
public async Task MatchUsingAndMatcher()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
// if host name = srv1's name and port srv1's port then set the address to server 2 and http method to get.
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new AndMatcher(
new HostAddressMatcher(srv01Uri.Port.ToString(), StringMatchType.UriHostPortMatch),
new HostAddressMatcher(srv01Uri.Host, StringMatchType.UriHostNameMatch)
)
);
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
public async Task BasicTelemetry()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
// this pluming is to extract which host are we going to use to route
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat(srv01Address, path));
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
Assert.IsTrue(router.TotalExecutedLastMin > 0);
Assert.IsTrue(router.TotalResolvedLastMin > 0);
}
public async Task OverrideSchemeAndPath()
{
var resolver = new HttpRouteResolver();
var path = "api/values/0";
/*
* route to server 2 override the scheme to http & path to a static path
*/
var headMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
headMatcher.Chain(new SetAddressListMatcher(Srv02HostNamePort),
new HttpOverridePathMatcher("/api/values/0"),
new HttpOverrideSchemeMatcher("http"),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(headMatcher, 0);
var router = new HttpRouter(resolver);
var results = await router.RouteAsync(string.Concat("xxx://", Srv01HostNamePort)); // bad scehme & no path
var responseMessage = await results.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
// server returns the address
// in the response
Assert.AreEqual(string.Concat(srv02Address, path), responseString);
}
private async Task <HttpRouter> GetRouter()
{
/*
* factory create a instance of SocketSession for incoming connection.
* in this test we will create a router attached it to the factory (which is injected in every socket session)
*
*/
// prepare the router
var resolver = new HttpRouteResolver();
// routing logic
//-> If context contains GetModels (route to backend(s), fastest route, add scheme, add path, ignore body, set HttpMethod to Get)
var getModelsMatchers = new HttpSetMethodMatcher(HttpMethod.Get);
getModelsMatchers.Chain(new IgnoreSourceBodyStreamMatcher(), // ignore whatever message body provided by the socket.
new SetAddressListMatcher(new string[] { RouterTestSuit.Srv01HostNamePort, RouterTestSuit.Srv02HostNamePort, RouterTestSuit.Srv03HostNamePort }, // address list
true, // clear whatever there
ContextRoutingType.FastestRoute), // fastest
new HttpOverridePathMatcher("/api/models/"), // add path
new HttpOverrideSchemeMatcher("http"), // add scheme
new ContextValueStringMatcher("Message.Type", "GetModels"));
//-> If context contains AddModels
var addModelsMatcher = new HttpSetMethodMatcher(HttpMethod.Post);
addModelsMatcher.Chain(
new SetAddressListMatcher(RouterTestSuit.Srv01HostNamePort), // set address to Server1
new HttpAddSetHeaderMatcher("Content-Type", "application/json"), // my socket puts everything as json
new HttpOverridePathMatcher("/api/models/"), // add path
new HttpOverrideSchemeMatcher("http"), // add scheme
new ContextValueStringMatcher("Message.Type", "AddModels")
);
// There are multiple ways i can do use the above matchers
/* method 1) use Or matcher
* var orMatcher = new OrMatcher(getModelsMatchers, addModelsMatcher);
* await resolver.AddMatcherAsync(orMatcher, 0);
*/
/* method 2) use AnyMatcher
* var anyMatcher = new AnyMatcher(getModelsMatchers, addModelsMatcher);
* await resolver.AddMatcherAsync(anyMatcher, 0);
*/
// method 3) use the new ContextValueStringMatcher("Message.Type", "AddModels") in an IIF matcher (remember to remove them from Add/Get matcher variables above).
// or just create differet matchers in resolvers. the advantages, if each tree wants to cache and have state on thier
// they will do that without conficlts (check how load balanacer is used in HttpRoutingContext).
await resolver.AddMatcherAsync(getModelsMatchers, 0);
await resolver.AddMatcherAsync(addModelsMatcher, 1);
var router = new HttpRouter(resolver);
return(router);
}
public async Task SimpleLoadBalance()
{
var resolver = new HttpRouteResolver();
/*
* anything point to http://localhost:9001
* will be routed R/R balanced to
* http://locahost:9001
* http://locahost:9002
* http://locahost:9003
*
* With HttpGet + Same path
*/
var path = "/api/values/0";
var trytimes = 3;
var firstMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
firstMatcher.Chain(new SetAddressListMatcher(new string[] { Srv01HostNamePort, Srv02HostNamePort, Srv03HostNamePort }, false, ContextRoutingType.RoundRobin),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(firstMatcher, 0);
var router = new HttpRouter(resolver);
var resultsList = new List <HttpRoutingResult>(trytimes);
var responsesList = new HashSet <string>();
// call as many as try times
for (var i = 1; i <= trytimes; i++)
{
resultsList.Add(await router.RouteAsync(string.Concat(srv01Address, path)));
}
foreach (var result in resultsList)
{
var responseMessage = await result.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
responsesList.Add(responseString);
}
// response list should contain
// http <server1> + path
// http <server2> + path
// http <server3> + path
var expectedList = new List <string>()
{
string.Concat("http://", Srv01HostNamePort, path),
string.Concat("http://", Srv02HostNamePort, path),
string.Concat("http://", Srv03HostNamePort, path)
};
foreach (var response in responsesList)
{
if (expectedList.Contains(response))
{
expectedList.Remove(response);
}
}
Assert.IsTrue(expectedList.Count == 0); // all hosts in the system
}
public async Task LongLoadBalance()
{
var resolver = new HttpRouteResolver();
/*
* anything point to http://localhost:9001
* will be routed R/R balanced to
* http://locahost:9001
* http://locahost:9002
* http://locahost:9003
*
* With HttpGet + Same path
*/
var path = "/api/values/0";
var trytimes = 9;
// this pluming is to extract which host are we going to use to route
var firstMatcher = new HttpSetMethodMatcher(HttpMethod.Get);
firstMatcher.Chain(new SetAddressListMatcher(new string[] { Srv01HostNamePort, Srv02HostNamePort, Srv03HostNamePort }, false, ContextRoutingType.RoundRobin),
new HostAddressMatcher(Srv01HostNamePort, StringMatchType.UriHostandPortMatch));
await resolver.AddMatcherAsync(firstMatcher, 0);
var router = new HttpRouter(resolver);
var resultsList = new List <HttpRoutingResult>(trytimes);
var responsesList = new Dictionary <string, int>();
// call as many as try times
for (var i = 1; i <= trytimes; i++)
{
resultsList.Add(await router.RouteAsync(string.Concat(srv01Address, path)));
}
foreach (var result in resultsList)
{
var responseMessage = await result.ResultAsAsync <HttpResponseMessage>();
var responseString = await responseMessage.Content.ReadAsStringAsync();
if (!responsesList.ContainsKey(responseString))
{
responsesList.Add(responseString, 1);
}
else
{
responsesList[responseString] = ++responsesList[responseString];
}
}
var bSucess = true;
// validate that each is called exactly 3 times
foreach (var key in responsesList.Keys)
{
if (responsesList[key] != 3)
{
bSucess = false;
break;
}
}
Assert.IsTrue(bSucess); // all hosts in the system
}
public Routes(HttpRouter router)
{
this.router = router;
}
public WSocketSessionFactory(HttpRouter router)
{
Router = router;
}
public static void Run()
{
var router = new HttpRouter();
//var getTree= router.GetTree;
//var postTree = router.PostTree;
//var headTree = router.HeadTree;
//var putTree = router.PutTree;
//var deleteTree = router.DeleteTree;
router.MapGet("/get/index", (req, resp) => Console.WriteLine("/get/index"));
//不支持参数约束,前缀,后缀 繁琐而且用处不大
//Not support parameter constraints,prefix,suffix tedious and useless
router.MapGet("/get/{param1}/{param2}", (req, resp) => Console.WriteLine("/get/{param1}/{param2}"));
router.MapGet("/get/{*catchAll}", (req, resp) => Console.WriteLine("/get/{*catchAll}"));
Console.WriteLine("MapGet");
foreach (var item in router.GetTree)
{
Console.WriteLine(item.Key);
}
//MapAttribute
var compiler = new HandlerCompiler();//See HandlerCompilerSample
//compiler.Register()
router.MapAttribute(new[] { typeof(TestService) }, compiler);
//customize
router.MapAttribute(new[] { typeof(TestService) }, compiler,
(method, typeHandlers, methodHandlers, handler) =>
{
var handlers = new List <IHttpHandler>();
handlers.Add(HttpHandler.CreateModule((req, handler) =>
{
Console.WriteLine("Before typeHandlers");
return(handler.HandleAsync(req));
}));
handlers.AddRange(typeHandlers);
handlers.Add(HttpHandler.CreateModule((req, handler) =>
{
Console.WriteLine("Before methodHandlers");
return(handler.HandleAsync(req));
}));
handlers.AddRange(methodHandlers);
handlers.Add(handler);
return(HttpHandler.CreatePipeline(handlers));
});
//router.MapAttribute(compiler);
//router.MapAttribute(handlerDelegate)
Console.WriteLine();
Console.WriteLine("MapAttribute");
foreach (var item in router.GetTree)
{
Console.WriteLine(item.Key);
}
Directory.CreateDirectory("Static");
File.WriteAllText("Static/testFile.txt", "this is file content.BY 张贺", new UTF8Encoding(false));
File.WriteAllText("Static/testHtml1.html", "<h1>testHtml1<h1>", new UTF8Encoding(false));
File.WriteAllText("Static/testHtml2.html", "<h2>testHtml2<h2>", new UTF8Encoding(false));
//MapFile
router.MapFile("/testFile1", "Static/testFile.txt", 86400);//CacheControl
router.MapFile("/testFile2", "Static/testFile.txt", "text/html; charset=utf-8", 86400);
//MapFiles
router.MapFiles("/static1/{*path}", "Static", 86400);
var customMimeTypes = new MimeTypes();
//var customMimeTypes = new MimeTypes(MimeTypes.Default);
customMimeTypes.Add(".html", "text/html; charset=utf-8");
router.MapFiles("/static2/{*customName}", "Static", customMimeTypes, 86400, "customName");
//router.MapFiles("/static2/{*customName}", "Static", MimeTypes.Default, TimeSpan.FromDays(1), "customName");
//MapSlash
//尾部/
router.GetTree.MapSlash();
//router.MapSlash();
Console.WriteLine();
Console.WriteLine("MapSlash");
foreach (var item in router.GetTree)
{
Console.WriteLine(item.Key);
}
//动态路由
//Dynamic change router
//CopyOnWrite(Safe)
var newGetTree = new HttpRouter.Tree();
newGetTree.Map("/new/index", HttpHandler.Create((req, resp) => { Console.WriteLine("/new/index"); }));
newGetTree.Map("/new/{param1}/{param2}", HttpHandler.Create((req, resp) => { Console.WriteLine("/new/{param1}/{param2}"); }));
newGetTree.Map("/new/{*catchAll}", HttpHandler.Create((req, resp) => { Console.WriteLine("/new/{*catchAll}"); }));
newGetTree.MapSlash();
newGetTree.MapTree(router.GetTree);
router.GetTree = newGetTree;
Console.WriteLine();
Console.WriteLine("NewGetTree");
foreach (var item in router.GetTree)
{
Console.WriteLine(item.Key);
}
//Match
Console.WriteLine();
Console.WriteLine("Match");
var params1 = new PathParams();
var h1 = router.GetTree.Match("/attribute/index", params1);
Console.WriteLine(params1.Count);
var params2 = new PathParams();
var h2 = router.GetTree.Match("/attribute/p1/x/y", params2);
Console.WriteLine(params2.Count);
var params3 = new PathParams();
var h3 = router.GetTree.Match("/attribute/catchAll/x/y/z//", params3);
Console.WriteLine(params3.Count);
//HandleAsync
Console.WriteLine();
Console.WriteLine("HandleAsync");
var req1 = new HttpRequest("/attribute/index")
{
Method = HttpMethod.Get
};
var resp1 = router.HandleAsync(req1).Result;
var req2 = new HttpRequest("/attribute/p1/x/y")
{
Method = HttpMethod.Get
};
var resp2 = router.HandleAsync(req2).Result;
var req3 = new HttpRequest("/attribute/catchAll/x/y/z//")
{
Method = HttpMethod.Get
};
var resp3 = router.HandleAsync(req3).Result;
var req4 = new HttpRequest("/testFile1")
{
Method = HttpMethod.Get
};
var resp4 = router.HandleAsync(req4).Result;
Console.WriteLine(resp4.Content.ReadStringAsync().Result);
var req5 = new HttpRequest("/testFile2")
{
Method = HttpMethod.Head
};
var resp5 = router.HandleAsync(req5).Result;
Console.WriteLine(resp5.Content.ReadStringAsync().Result);
var req6 = new HttpRequest("/static1/testHtml1.html")
{
Method = HttpMethod.Get
};
var resp6 = router.HandleAsync(req6).Result;
Console.WriteLine(resp6.Content.ReadStringAsync().Result);
var req7 = new HttpRequest("/static2/testHtml2.html")
{
Method = HttpMethod.Get
};
var resp7 = router.HandleAsync(req7).Result;
Console.WriteLine(resp7.Content.ReadStringAsync().Result);
//------------------------------------------------------------------------
//router chain(HttpRouter is IHttpHandler)
var router1 = new HttpRouter();
var router2 = new HttpRouter();//var tree1 = new HttpRouter.Tree();
router2.MapGet("/{*path}", (req, resp) => {
Console.WriteLine(nameof(router2));
Console.WriteLine(req.PathParams().GetValue <string>("path"));
});
router1.GetTree.Map("/Images/{*img}", router2);
router1.GetTree.Map("/Js/{*js}", HttpHandler.Create(
(req) => {
Console.WriteLine("Js");
return(router2.HandleAsync(req));
}));
Console.WriteLine();
var req8 = new HttpRequest("/Images/123456.png")
{
Method = HttpMethod.Get
};
var resp8 = router1.HandleAsync(req8).Result;
var req9 = new HttpRequest("/Js/jq.js")
{
Method = HttpMethod.Get
};
var resp9 = router1.HandleAsync(req9).Result;
//------------------------------------------------------------------------
//special
// /path1/{param1} Match /path1/ (if not Map /path1/)
var router3 = new HttpRouter();
router3.MapGet("/", (req, resp) => { Console.WriteLine("/"); });
router3.MapGet("/{param1}", (req, resp) => { Console.WriteLine("/{param1}"); });
var req10 = new HttpRequest("/")
{
Method = HttpMethod.Get
};
var resp10 = router3.HandleAsync(req10).Result;
var router4 = new HttpRouter();
//router4.MapGet("/", (req, resp) => { Console.WriteLine("/"); });
router4.MapGet("/{param1}", (req, resp) => { Console.WriteLine("/{param1}"); });
var req11 = new HttpRequest("/")
{
Method = HttpMethod.Get
};
var resp11 = router4.HandleAsync(req11).Result;
// multiple /
var router5 = new HttpRouter();
router5.MapGet("////", (req, resp) => { Console.WriteLine("////"); });
var req12 = new HttpRequest("////")
{
Method = HttpMethod.Get
};
var resp12 = router5.HandleAsync(req12).Result;
router5.MapGet("/Path1/{param1}/{param2}/", (req, resp) => { Console.WriteLine("/Path1/{param1}/{param2}/"); });
//OR /Path1/{param1}/{param2}/{param3}
var req13 = new HttpRequest("/Path1///")
{
Method = HttpMethod.Get
};
var resp13 = router5.HandleAsync(req13).Result;
}
